2958 lines
No EOL
80 KiB
JavaScript
2958 lines
No EOL
80 KiB
JavaScript
require=
|
|
// modules are defined as an array
|
|
// [ module function, map of requireuires ]
|
|
//
|
|
// map of requireuires is short require name -> numeric require
|
|
//
|
|
// anything defined in a previous bundle is accessed via the
|
|
// orig method which is the requireuire for previous bundles
|
|
(function outer (modules, cache, entry) {
|
|
// Save the require from previous bundle to this closure if any
|
|
var previousRequire = typeof require == "function" && require;
|
|
|
|
function newRequire(name, jumped, inSkipCache){
|
|
|
|
var m, skipCache = inSkipCache;
|
|
if (typeof name === 'string') {
|
|
if (name.charAt(0) === '!' ) {
|
|
name = name.substr(1);
|
|
skipCache=true;
|
|
}
|
|
}
|
|
if(skipCache || !cache[name]) {
|
|
if(!modules[name]) {
|
|
// if we cannot find the the module within our internal map or
|
|
// cache jump to the current global require ie. the last bundle
|
|
// that was added to the page.
|
|
var currentRequire = typeof require == "function" && require;
|
|
if (!jumped && currentRequire) return currentRequire(name, true);
|
|
|
|
// If there are other bundles on this page the require from the
|
|
// previous one is saved to 'previousRequire'. Repeat this as
|
|
// many times as there are bundles until the module is found or
|
|
// we exhaust the require chain.
|
|
if (previousRequire) return previousRequire(name, true);
|
|
throw new Error('Cannot find module \'' + name + '\'');
|
|
}
|
|
|
|
m = {exports:{}};
|
|
var nextSkipCache = inSkipCache ? false : skipCache;
|
|
if (!skipCache) cache[name] = m;
|
|
skipCache = false;
|
|
modules[name][0].call(m.exports, function(x){
|
|
var id = modules[name][1][x];
|
|
return newRequire(id ? id : x, false, nextSkipCache);
|
|
},m,m.exports,outer,modules,cache,entry);
|
|
}
|
|
return m ? m.exports:cache[name].exports;
|
|
}
|
|
for(var i=0;i<entry.length;i++) newRequire(entry[i]);
|
|
|
|
// Override the current require with this new one
|
|
return newRequire;
|
|
})
|
|
({"hxYaTp":[function(require,module,exports){
|
|
|
|
module.exports.Storage = require('./js/models/Storage');
|
|
module.exports.PublicKeyRing = require('./js/models/PublicKeyRing');
|
|
module.exports.CopayPeer = require('./js/models/CopayPeer');
|
|
module.exports.FakeStorage = require('./test/FakeStorage');
|
|
|
|
},{"./js/models/CopayPeer":3,"./js/models/PublicKeyRing":4,"./js/models/Storage":5,"./test/FakeStorage":17}],"copay":[function(require,module,exports){
|
|
module.exports=require('hxYaTp');
|
|
},{}],3:[function(require,module,exports){
|
|
|
|
var imports = require('soop').imports();
|
|
var EventEmitter= imports.EventEmitter || require('events').EventEmitter;
|
|
|
|
/*
|
|
* Emits
|
|
* 'networkChange'
|
|
* when network layout has change (new/lost peers, etc)
|
|
*
|
|
* 'data'
|
|
* when an unknown data type arrives
|
|
*
|
|
* Provides
|
|
* send(toPeerIds, {data}, cb?)
|
|
*
|
|
*/
|
|
|
|
function CopayPeer(opts) {
|
|
opts = opts || {};
|
|
this.peerId = opts.peerId;
|
|
this.apiKey = opts.apiKey || 'lwjd5qra8257b9';
|
|
this.debug = opts.debug || 3;
|
|
this.maxPeers = opts.maxPeers || 5;
|
|
this.connectedPeers = [];
|
|
}
|
|
|
|
CopayPeer.parent=EventEmitter;
|
|
|
|
// Array helpers
|
|
CopayPeer._arrayDiff = function(a, b) {
|
|
var seen = [];
|
|
var diff = [];
|
|
|
|
for (var i = 0; i < b.length; i++)
|
|
seen[b[i]] = true;
|
|
|
|
for (var j = 0; j < a.length; j++)
|
|
if (!seen[a[j]])
|
|
diff.push(a[j]);
|
|
|
|
return diff;
|
|
};
|
|
|
|
CopayPeer._inArray = function(el, array) {
|
|
return array.indexOf(el) > -1;
|
|
};
|
|
|
|
CopayPeer._arrayPushOnce = function(el, array) {
|
|
var ret = false;
|
|
if (!CopayPeer._inArray(el, array)) {
|
|
array.push(el);
|
|
ret = true;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
CopayPeer._arrayRemove = function(el, array) {
|
|
var pos = array.indexOf(el);
|
|
if (pos >= 0) array.splice(pos, 1);
|
|
|
|
return array;
|
|
};
|
|
|
|
// DEBUG
|
|
CopayPeer.prototype._showConnectedPeers = function() {
|
|
console.log("### CONNECTED PEERS", this.connectedPeers);
|
|
};
|
|
|
|
CopayPeer.prototype._onClose = function(peerId) {
|
|
this.connectedPeers = CopayPeer._arrayRemove(peerId, this.connectedPeers);
|
|
this._notify();
|
|
};
|
|
|
|
CopayPeer.prototype._connectToPeers = function(peerIds) {
|
|
var self = this;
|
|
var ret = false;
|
|
var arrayDiff1= CopayPeer._arrayDiff(peerIds, this.connectedPeers);
|
|
var arrayDiff = CopayPeer._arrayDiff(arrayDiff1, [this.peerId]);
|
|
arrayDiff.forEach(function(peerId) {
|
|
console.log('### CONNECTING TO:', peerId);
|
|
self.connectTo(peerId);
|
|
ret = true;
|
|
});
|
|
return ret;
|
|
};
|
|
|
|
CopayPeer.prototype._onData = function(data, isInbound) {
|
|
var obj;
|
|
try {
|
|
obj = JSON.parse(data);
|
|
} catch (e) {
|
|
console.log('### ERROR ON DATA: "%s" ', data, isInbound, e);
|
|
return;
|
|
};
|
|
console.log('### RECEIVED TYPE: %s FROM %s', obj.data.type, obj.sender);
|
|
|
|
switch(obj.data.type) {
|
|
case 'peerList':
|
|
this._connectToPeers(obj.data.peers);
|
|
this._notify();
|
|
break;
|
|
case 'disconnect':
|
|
this._onClose(obj.sender);
|
|
break;
|
|
default:
|
|
this.emit('data', obj.sender, obj.data, isInbound);
|
|
}
|
|
};
|
|
|
|
CopayPeer.prototype._sendPeers = function(peerIds) {
|
|
console.log('#### SENDING PEER LIST: ', this.connectedPeers, ' TO ', peerIds?peerIds: 'ALL');
|
|
this.send(peerIds, {
|
|
type: 'peerList',
|
|
peers: this.connectedPeers,
|
|
});
|
|
};
|
|
|
|
CopayPeer.prototype._addPeer = function(peerId, isInbound) {
|
|
|
|
var hasChanged = CopayPeer._arrayPushOnce(peerId, this.connectedPeers);
|
|
|
|
|
|
if (isInbound && hasChanged) {
|
|
this._sendPeers(); //broadcast peer list
|
|
}
|
|
else {
|
|
if (isInbound) {
|
|
this._sendPeers(peerId);
|
|
}
|
|
}
|
|
};
|
|
|
|
CopayPeer.prototype._setupConnectionHandlers = function(
|
|
dataConn, isInbound, openCallback, closeCallback) {
|
|
|
|
var self=this;
|
|
|
|
dataConn.on('open', function() {
|
|
if (!CopayPeer._inArray(dataConn.peer, self.connectedPeers)) {
|
|
|
|
console.log('### DATA CONNECTION READY TO: ADDING PEER: %s (inbound: %s)',
|
|
dataConn.peer, isInbound);
|
|
|
|
self._addPeer(dataConn.peer, isInbound);
|
|
self._notify( isInbound ? dataConn.peer : null);
|
|
if (typeof openCallback === 'function') openCallback();
|
|
}
|
|
});
|
|
|
|
dataConn.on('data', function(data) {
|
|
self._onData(data, isInbound);
|
|
});
|
|
|
|
dataConn.on('error', function(e) {
|
|
console.log('### DATA ERROR',e ); //TODO
|
|
});
|
|
|
|
dataConn.on('close', function() {
|
|
console.log('### CLOSE RECV FROM:', dataConn.peer); //TODO
|
|
self._onClose(dataConn.peer);
|
|
if (typeof closeCallback === 'function') closeCallback();
|
|
});
|
|
};
|
|
|
|
CopayPeer.prototype._notify = function(newPeer) {
|
|
this._showConnectedPeers();
|
|
this.emit('networkChange', newPeer);
|
|
};
|
|
|
|
CopayPeer.prototype._setupPeerHandlers = function(openCallback) {
|
|
var self=this;
|
|
var p = this.peer;
|
|
|
|
|
|
p.on('open', function(peerId) {
|
|
console.log('### PEER OPEN. I AM:' + peerId);
|
|
self.peerId = peerId;
|
|
self.connectedPeers = [peerId];
|
|
self._notify();
|
|
return openCallback(peerId);
|
|
});
|
|
|
|
p.on('error', function(err) {
|
|
console.log('### PEER ERROR:', err);
|
|
});
|
|
|
|
p.on('connection', function(dataConn) {
|
|
|
|
console.log('### NEW INBOUND CONNECTION %d/%d', self.connectedPeers.length, self.maxPeers);
|
|
if (self.connectedPeers.length >= self.maxPeers) {
|
|
console.log('### PEER REJECTED. PEER MAX LIMIT REACHED');
|
|
dataConn.on('open', function() {
|
|
console.log('### CLOSING CONN FROM:' + dataConn.peer);
|
|
dataConn.close();
|
|
});
|
|
}
|
|
else {
|
|
self._setupConnectionHandlers(dataConn, true);
|
|
}
|
|
});
|
|
};
|
|
|
|
CopayPeer.prototype.start = function(openCallback) {
|
|
// Start PeerJS Peer
|
|
this.peer = new Peer(this.peerId, {
|
|
key: this.apiKey, // TODO: we need our own PeerServer KEY (http://peerjs.com/peerserver)
|
|
debug: this.debug,
|
|
});
|
|
|
|
this._setupPeerHandlers(openCallback);
|
|
};
|
|
|
|
CopayPeer.prototype._sendToOne = function(peerId, data, cb) {
|
|
if (peerId !== this.peerId) {
|
|
var conns = this.peer.connections[peerId];
|
|
|
|
if (conns) {
|
|
var str = JSON.stringify({
|
|
sender: this.peerId,
|
|
data: data
|
|
});
|
|
|
|
for (var i = 0; i < conns.length; i++) {
|
|
var conn = conns[i];
|
|
conn.send(str);
|
|
}
|
|
}
|
|
}
|
|
if (typeof cb === 'function') cb();
|
|
};
|
|
|
|
CopayPeer.prototype.send = function(peerIds, data, cb) {
|
|
var self=this;
|
|
|
|
if (!peerIds) {
|
|
peerIds = this.connectedPeers;
|
|
data.isBroadcast = 1;
|
|
}
|
|
console.log('[CopayPeer.js.216:SENDD:]',data); //TODO
|
|
|
|
if (Array.isArray(peerIds)) {
|
|
var l = peerIds.length;
|
|
var i = 0;
|
|
peerIds.forEach(function(peerId) {
|
|
self._sendToOne(peerId, data, function () {
|
|
if (++i === l && typeof cb === 'function') cb();
|
|
});
|
|
});
|
|
}
|
|
else if (typeof peerIds === 'string')
|
|
self._sendToOne(peerIds, data, cb);
|
|
};
|
|
|
|
CopayPeer.prototype.connectTo = function(peerId, openCallback, closeCallback ) {
|
|
var self = this;
|
|
|
|
console.log('### STARTING TO CONNECT TO:' + peerId );
|
|
|
|
var dataConn = this.peer.connect(peerId, {
|
|
// label: 'wallet',
|
|
serialization: 'none',
|
|
reliable: true,
|
|
metadata: { message: 'hi copayer!' }
|
|
});
|
|
|
|
self._setupConnectionHandlers(dataConn, false, openCallback, closeCallback);
|
|
};
|
|
|
|
CopayPeer.prototype.disconnect = function(peerId, cb) {
|
|
var self = this;
|
|
|
|
this.send(null, { type: 'disconnect' }, function() {
|
|
self.connectedPeers = [];
|
|
self.peerId = null;
|
|
if (self.peer) {
|
|
self.peer.disconnect();
|
|
self.peer.destroy();
|
|
self.peer = null;
|
|
}
|
|
if (typeof cb === 'function') cb();
|
|
});
|
|
};
|
|
|
|
module.exports = require('soop')(CopayPeer);
|
|
|
|
},{"events":12,"soop":16}],4:[function(require,module,exports){
|
|
|
|
'use strict';
|
|
|
|
|
|
var imports = require('soop').imports();
|
|
var bitcore = require('bitcore');
|
|
var BIP32 = bitcore.BIP32;
|
|
var Address = bitcore.Address;
|
|
var Script = bitcore.Script;
|
|
var coinUtil = bitcore.util;
|
|
var Transaction = bitcore.Transaction;
|
|
var buffertools = bitcore.buffertools;
|
|
|
|
var Storage = imports.Storage || require('./Storage');
|
|
var storage = Storage.default();
|
|
|
|
/*
|
|
* This follow Electrum convetion, as described in
|
|
* https://bitcointalk.org/index.php?topic=274182.0
|
|
*
|
|
* We should probably adopt the next standard once it's ready, as discussed in:
|
|
* http://sourceforge.net/p/bitcoin/mailman/message/32148600/
|
|
*
|
|
*/
|
|
|
|
var PUBLIC_BRANCH = 'm/0/';
|
|
var CHANGE_BRANCH = 'm/1/';
|
|
|
|
function PublicKeyRing(opts) {
|
|
opts = opts || {};
|
|
|
|
this.network = opts.networkName === 'livenet' ?
|
|
bitcore.networks.livenet : bitcore.networks.testnet;
|
|
|
|
this.requiredCopayers = opts.requiredCopayers || 3;
|
|
this.totalCopayers = opts.totalCopayers || 5;
|
|
|
|
this.id = opts.id || PublicKeyRing.getRandomId();
|
|
|
|
this.dirty = 1;
|
|
this.copayersBIP32 = [];
|
|
|
|
this.changeAddressIndex=0;
|
|
this.addressIndex=0;
|
|
}
|
|
|
|
|
|
PublicKeyRing.getRandomId = function () {
|
|
return buffertools.toHex(coinUtil.generateNonce());
|
|
};
|
|
|
|
PublicKeyRing.decrypt = function (passphrase, encPayload) {
|
|
console.log('[wallet.js.35] TODO READ: passphrase IGNORED');
|
|
return encPayload;
|
|
};
|
|
|
|
PublicKeyRing.encrypt = function (passphrase, payload) {
|
|
console.log('[wallet.js.92] TODO: passphrase IGNORED');
|
|
return payload;
|
|
};
|
|
|
|
PublicKeyRing.fromObj = function (data) {
|
|
var config = { networkName: data.networkName || 'livenet' };
|
|
|
|
var w = new PublicKeyRing(config);
|
|
|
|
w.requiredCopayers = data.requiredCopayers;
|
|
w.totalCopayers = data.totalCopayers;
|
|
w.addressIndex = data.addressIndex;
|
|
w.changeAddressIndex = data.changeAddressIndex;
|
|
|
|
// this.bip32 = ;
|
|
w.copayersBIP32 = data.copayersExtPubKeys.map( function (pk) {
|
|
return new BIP32(pk);
|
|
});
|
|
|
|
w.dirty = 0;
|
|
|
|
return w;
|
|
};
|
|
|
|
PublicKeyRing.read = function (id, passphrase) {
|
|
var encPayload = storage.get(id);
|
|
if (!encPayload)
|
|
throw new Error('Could not find wallet data');
|
|
var data;
|
|
try {
|
|
data = JSON.parse( PublicKeyRing.decrypt( passphrase, encPayload ));
|
|
} catch (e) {
|
|
throw new Error('error in storage: '+ e.toString());
|
|
return;
|
|
};
|
|
|
|
if (data.id !== id)
|
|
throw new Error('Wrong id in data');
|
|
|
|
|
|
return PublicKeyRing.fromObj(data);
|
|
};
|
|
|
|
PublicKeyRing.prototype.toObj = function() {
|
|
return {
|
|
id: this.id,
|
|
networkName: this.network.name,
|
|
requiredCopayers: this.requiredCopayers,
|
|
totalCopayers: this.totalCopayers,
|
|
|
|
changeAddressIndex: this.changeAddressIndex,
|
|
addressIndex: this.addressIndex,
|
|
copayersExtPubKeys: this.copayersBIP32.map( function (b) {
|
|
return b.extendedPublicKeyString();
|
|
}),
|
|
ts: parseInt(Date.now() / 1000),
|
|
};
|
|
};
|
|
|
|
PublicKeyRing.prototype.serialize = function () {
|
|
return JSON.stringify(this.toObj());
|
|
};
|
|
|
|
|
|
PublicKeyRing.prototype.store = function (passphrase) {
|
|
|
|
if (!this.id)
|
|
throw new Error('wallet has no id');
|
|
|
|
storage.set(this.id, PublicKeyRing.encrypt(passphrase,this.serialize()));
|
|
this.dirty = 0;
|
|
|
|
return true;
|
|
};
|
|
|
|
PublicKeyRing.prototype.registeredCopayers = function () {
|
|
return this.copayersBIP32.length;
|
|
};
|
|
|
|
|
|
|
|
PublicKeyRing.prototype.haveAllRequiredPubKeys = function () {
|
|
return this.registeredCopayers() >= this.totalCopayers;
|
|
};
|
|
|
|
PublicKeyRing.prototype._checkKeys = function() {
|
|
|
|
if (!this.haveAllRequiredPubKeys())
|
|
throw new Error('dont have required keys yet');
|
|
};
|
|
|
|
|
|
PublicKeyRing.prototype._newExtendedPublicKey = function () {
|
|
return new BIP32(this.network.name)
|
|
.extendedPublicKeyString();
|
|
};
|
|
|
|
PublicKeyRing.prototype.addCopayer = function (newEpk) {
|
|
|
|
if (this.haveAllRequiredPubKeys())
|
|
throw new Error('already have all required key:' + this.totalCopayers);
|
|
|
|
if (!newEpk) {
|
|
newEpk = this._newExtendedPublicKey();
|
|
}
|
|
|
|
this.copayersBIP32.forEach(function(b){
|
|
if (b.extendedPublicKeyString() === newEpk)
|
|
throw new Error('already have that key');
|
|
});
|
|
|
|
this.copayersBIP32.push(new BIP32(newEpk));
|
|
this.dirty = 1;
|
|
return newEpk;
|
|
};
|
|
|
|
|
|
PublicKeyRing.prototype.getCopayersPubKeys = function (index, isChange) {
|
|
this._checkKeys();
|
|
|
|
var pubKeys = [];
|
|
var l = this.copayersBIP32.length;
|
|
for(var i=0; i<l; i++) {
|
|
var path = (isChange ? CHANGE_BRANCH : PUBLIC_BRANCH) + index;
|
|
var bip32 = this.copayersBIP32[i].derive(path);
|
|
pubKeys[i] = bip32.eckey.public;
|
|
}
|
|
|
|
return pubKeys;
|
|
};
|
|
|
|
PublicKeyRing.prototype._checkIndexRange = function (index, isChange) {
|
|
if ( (isChange && index > this.changeAddressIndex) ||
|
|
(!isChange && index > this.addressIndex)) {
|
|
console.log('Out of bounds at getAddress: Index %d isChange: %d', index, isChange);
|
|
throw new Error('index out of bound');
|
|
}
|
|
};
|
|
|
|
PublicKeyRing.prototype.getRedeemScript = function (index, isChange) {
|
|
this._checkIndexRange(index, isChange);
|
|
|
|
var pubKeys = this.getCopayersPubKeys(index, isChange);
|
|
var script = Script.createMultisig(this.requiredCopayers, pubKeys);
|
|
return script;
|
|
};
|
|
|
|
PublicKeyRing.prototype.getAddress = function (index, isChange) {
|
|
this._checkIndexRange(index, isChange);
|
|
|
|
var script = this.getRedeemScript(index,isChange);
|
|
var hash = coinUtil.sha256ripe160(script.getBuffer());
|
|
var version = this.network.addressScript;
|
|
var addr = new Address(version, hash);
|
|
return addr.as('base58');
|
|
};
|
|
|
|
//generate a new address, update index.
|
|
PublicKeyRing.prototype.generateAddress = function(isChange) {
|
|
|
|
var ret =
|
|
this.getAddress(isChange ? this.changeAddressIndex : this.addressIndex, isChange);
|
|
if (isChange)
|
|
this.changeAddressIndex++;
|
|
else
|
|
this.addressIndex++;
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
PublicKeyRing.prototype.getAddresses = function() {
|
|
var ret = [];
|
|
|
|
for (var i=0; i<this.changeAddressIndex; i++) {
|
|
ret.push(this.getAddress(i,true));
|
|
}
|
|
|
|
for (var i=0; i<this.addressIndex; i++) {
|
|
ret.push(this.getAddress(i,false));
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
PublicKeyRing.prototype._checkInPRK = function(inPKR, ignoreId) {
|
|
|
|
|
|
if (!inPKR.ts) {
|
|
throw new Error('inPRK bad format: Did you use .toObj()?');
|
|
}
|
|
|
|
if (!ignoreId && this.id !== inPKR.id) {
|
|
throw new Error('inPRK id mismatch');
|
|
}
|
|
|
|
if (this.network.name !== inPKR.networkName)
|
|
throw new Error('inPRK network mismatch');
|
|
|
|
if (
|
|
this.requiredCopayers && inPKR.requiredCopayers &&
|
|
(this.requiredCopayers !== inPKR.requiredCopayers))
|
|
throw new Error('inPRK requiredCopayers mismatch');
|
|
|
|
if (
|
|
this.totalCopayers && inPKR.totalCopayers &&
|
|
(this.totalCopayers !== inPKR.totalCopayers))
|
|
throw new Error('inPRK requiredCopayers mismatch');
|
|
|
|
if (! inPKR.ts)
|
|
throw new Error('no ts at inPRK');
|
|
};
|
|
|
|
|
|
PublicKeyRing.prototype._mergeIndexes = function(inPKR) {
|
|
var hasChanged = false;
|
|
|
|
// Indexes
|
|
if (inPKR.changeAddressIndex > this.changeAddressIndex) {
|
|
this.changeAddressIndex = inPKR.changeAddressIndex;
|
|
hasChanged = true;
|
|
}
|
|
|
|
if (inPKR.addressIndex > this.addressIndex) {
|
|
this.addressIndex = inPKR.addressIndex;
|
|
hasChanged = true;
|
|
}
|
|
return hasChanged;
|
|
};
|
|
|
|
PublicKeyRing.prototype._mergePubkeys = function(inPKR) {
|
|
var hasChanged = false;
|
|
var l= this.copayersBIP32.length;
|
|
|
|
var self = this;
|
|
|
|
inPKR.copayersExtPubKeys.forEach( function(epk) {
|
|
var haveIt = false;
|
|
for(var j=0; j<l; j++) {
|
|
if (self.copayersBIP32[j].extendedPublicKeyString() === epk) {
|
|
haveIt=true;
|
|
break;
|
|
}
|
|
}
|
|
if (!haveIt) {
|
|
self.copayersBIP32.push(new BIP32(epk));
|
|
hasChanged=true;
|
|
}
|
|
});
|
|
return hasChanged;
|
|
};
|
|
|
|
PublicKeyRing.prototype.merge = function(inPKR, ignoreId) {
|
|
var hasChanged = false;
|
|
|
|
this._checkInPRK(inPKR, ignoreId);
|
|
|
|
if (this._mergeIndexes(inPKR))
|
|
hasChanged = true;
|
|
|
|
if (this._mergePubkeys(inPKR))
|
|
hasChanged = true;
|
|
|
|
return hasChanged;
|
|
};
|
|
|
|
module.exports = require('soop')(PublicKeyRing);
|
|
|
|
},{"./Storage":5,"bitcore":6,"soop":16}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var imports = require('soop').imports();
|
|
|
|
function Storage() {
|
|
this.data = {};
|
|
}
|
|
|
|
Storage.prototype.get = function(k) {
|
|
return JSON.parse(localStorage.getItem(k));
|
|
};
|
|
|
|
Storage.prototype.set = function(k,v) {
|
|
localStorage.setItem(k, JSON.stringify(v));
|
|
};
|
|
|
|
Storage.prototype.remove = function(k) {
|
|
localStorage.removeItem(k);
|
|
};
|
|
|
|
|
|
Storage.prototype.clearAll = function() {
|
|
localStorage.clear();
|
|
};
|
|
|
|
module.exports = require('soop')(Storage);
|
|
|
|
},{"soop":16}],6:[function(require,module,exports){
|
|
(function (process,Buffer){
|
|
/*
|
|
One way to require files is this simple way:
|
|
module.exports.Address = require('./Address');
|
|
|
|
However, that will load all classes in memory even if they are not used.
|
|
Instead, we can set the 'get' property of each class to only require them when
|
|
they are accessed, saving memory if they are not used in a given project.
|
|
*/
|
|
var requireWhenAccessed = function(name, file) {
|
|
Object.defineProperty(module.exports, name, {get: function() {return require(file)}});
|
|
};
|
|
|
|
requireWhenAccessed('bignum', 'bignum');
|
|
requireWhenAccessed('base58', 'base58-native');
|
|
requireWhenAccessed('bufferput', 'bufferput');
|
|
requireWhenAccessed('buffertools', 'buffertools');
|
|
requireWhenAccessed('config', './config');
|
|
requireWhenAccessed('const', './const');
|
|
requireWhenAccessed('Deserialize', './Deserialize');
|
|
requireWhenAccessed('log', './util/log');
|
|
requireWhenAccessed('networks', './networks');
|
|
requireWhenAccessed('util', './util/util');
|
|
requireWhenAccessed('EncodedData', './util/EncodedData');
|
|
requireWhenAccessed('VersionedData', './util/VersionedData');
|
|
requireWhenAccessed('BinaryParser', './util/BinaryParser');
|
|
requireWhenAccessed('Address', './Address');
|
|
requireWhenAccessed('BIP32', './BIP32');
|
|
requireWhenAccessed('Point', './Point');
|
|
requireWhenAccessed('Opcode', './Opcode');
|
|
requireWhenAccessed('Script', './Script');
|
|
requireWhenAccessed('Transaction', './Transaction');
|
|
requireWhenAccessed('TransactionBuilder', './TransactionBuilder');
|
|
requireWhenAccessed('Connection', './Connection');
|
|
requireWhenAccessed('Peer', './Peer');
|
|
requireWhenAccessed('Block', './Block');
|
|
requireWhenAccessed('ScriptInterpreter', './ScriptInterpreter');
|
|
requireWhenAccessed('Bloom', './Bloom');
|
|
requireWhenAccessed('Key', './Key');
|
|
Object.defineProperty(module.exports, 'KeyModule', {get: function() {
|
|
console.log('KeyModule is deprecated.');
|
|
return require('bindings')('KeyModule');
|
|
}});
|
|
requireWhenAccessed('SINKey', './SINKey');
|
|
requireWhenAccessed('SIN', './SIN');
|
|
requireWhenAccessed('PrivateKey', './PrivateKey');
|
|
requireWhenAccessed('RpcClient', './RpcClient');
|
|
requireWhenAccessed('Wallet', './Wallet');
|
|
requireWhenAccessed('WalletKey', './WalletKey');
|
|
requireWhenAccessed('PeerManager', './PeerManager');
|
|
module.exports.Buffer = Buffer;
|
|
|
|
if (typeof process.versions === 'undefined') {
|
|
// Browser specific
|
|
module.exports.bignum.config({EXPONENTIAL_AT: 9999999, DECIMAL_PLACES: 0, ROUNDING_MODE: 1});
|
|
}
|
|
|
|
|
|
}).call(this,require("/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
|
|
},{"/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":13,"bindings":7,"buffer":9}],7:[function(require,module,exports){
|
|
(function (process,__filename){
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var fs = require('fs')
|
|
, path = require('path')
|
|
, join = path.join
|
|
, dirname = path.dirname
|
|
, exists = fs.existsSync || path.existsSync
|
|
, defaults = {
|
|
arrow: process.env.NODE_BINDINGS_ARROW || ' → '
|
|
, compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled'
|
|
, platform: process.platform
|
|
, arch: process.arch
|
|
, version: process.versions.node
|
|
, bindings: 'bindings.node'
|
|
, try: [
|
|
// node-gyp's linked version in the "build" dir
|
|
[ 'module_root', 'build', 'bindings' ]
|
|
// node-waf and gyp_addon (a.k.a node-gyp)
|
|
, [ 'module_root', 'build', 'Debug', 'bindings' ]
|
|
, [ 'module_root', 'build', 'Release', 'bindings' ]
|
|
// Debug files, for development (legacy behavior, remove for node v0.9)
|
|
, [ 'module_root', 'out', 'Debug', 'bindings' ]
|
|
, [ 'module_root', 'Debug', 'bindings' ]
|
|
// Release files, but manually compiled (legacy behavior, remove for node v0.9)
|
|
, [ 'module_root', 'out', 'Release', 'bindings' ]
|
|
, [ 'module_root', 'Release', 'bindings' ]
|
|
// Legacy from node-waf, node <= 0.4.x
|
|
, [ 'module_root', 'build', 'default', 'bindings' ]
|
|
// Production "Release" buildtype binary (meh...)
|
|
, [ 'module_root', 'compiled', 'version', 'platform', 'arch', 'bindings' ]
|
|
]
|
|
}
|
|
|
|
/**
|
|
* The main `bindings()` function loads the compiled bindings for a given module.
|
|
* It uses V8's Error API to determine the parent filename that this function is
|
|
* being invoked from, which is then used to find the root directory.
|
|
*/
|
|
|
|
function bindings (opts) {
|
|
|
|
// Argument surgery
|
|
if (typeof opts == 'string') {
|
|
opts = { bindings: opts }
|
|
} else if (!opts) {
|
|
opts = {}
|
|
}
|
|
opts.__proto__ = defaults
|
|
|
|
// Get the module root
|
|
if (!opts.module_root) {
|
|
opts.module_root = exports.getRoot(exports.getFileName())
|
|
}
|
|
|
|
// Ensure the given bindings name ends with .node
|
|
if (path.extname(opts.bindings) != '.node') {
|
|
opts.bindings += '.node'
|
|
}
|
|
|
|
var tries = []
|
|
, i = 0
|
|
, l = opts.try.length
|
|
, n
|
|
, b
|
|
, err
|
|
|
|
for (; i<l; i++) {
|
|
n = join.apply(null, opts.try[i].map(function (p) {
|
|
return opts[p] || p
|
|
}))
|
|
tries.push(n)
|
|
try {
|
|
b = opts.path ? require.resolve(n) : require(n)
|
|
if (!opts.path) {
|
|
b.path = n
|
|
}
|
|
return b
|
|
} catch (e) {
|
|
if (!/not find/i.test(e.message)) {
|
|
throw e
|
|
}
|
|
}
|
|
}
|
|
|
|
err = new Error('Could not locate the bindings file. Tried:\n'
|
|
+ tries.map(function (a) { return opts.arrow + a }).join('\n'))
|
|
err.tries = tries
|
|
throw err
|
|
}
|
|
module.exports = exports = bindings
|
|
|
|
|
|
/**
|
|
* Gets the filename of the JavaScript file that invokes this function.
|
|
* Used to help find the root directory of a module.
|
|
*/
|
|
|
|
exports.getFileName = function getFileName () {
|
|
var origPST = Error.prepareStackTrace
|
|
, origSTL = Error.stackTraceLimit
|
|
, dummy = {}
|
|
, fileName
|
|
|
|
Error.stackTraceLimit = 10
|
|
|
|
Error.prepareStackTrace = function (e, st) {
|
|
for (var i=0, l=st.length; i<l; i++) {
|
|
fileName = st[i].getFileName()
|
|
if (fileName !== __filename) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// run the 'prepareStackTrace' function above
|
|
Error.captureStackTrace(dummy)
|
|
dummy.stack
|
|
|
|
// cleanup
|
|
Error.prepareStackTrace = origPST
|
|
Error.stackTraceLimit = origSTL
|
|
|
|
return fileName
|
|
}
|
|
|
|
/**
|
|
* Gets the root directory of a module, given an arbitrary filename
|
|
* somewhere in the module tree. The "root directory" is the directory
|
|
* containing the `package.json` file.
|
|
*
|
|
* In: /home/nate/node-native-module/lib/index.js
|
|
* Out: /home/nate/node-native-module
|
|
*/
|
|
|
|
exports.getRoot = function getRoot (file) {
|
|
var dir = dirname(file)
|
|
, prev
|
|
while (true) {
|
|
if (dir === '.') {
|
|
// Avoids an infinite loop in rare cases, like the REPL
|
|
dir = process.cwd()
|
|
}
|
|
if (exists(join(dir, 'package.json')) || exists(join(dir, 'node_modules'))) {
|
|
// Found the 'package.json' file or 'node_modules' dir; we're done
|
|
return dir
|
|
}
|
|
if (prev === dir) {
|
|
// Got to the top
|
|
throw new Error('Could not find module root given file: "' + file
|
|
+ '". Do you have a `package.json` file? ')
|
|
}
|
|
// Try the parent dir next
|
|
prev = dir
|
|
dir = join(dir, '..')
|
|
}
|
|
}
|
|
|
|
}).call(this,require("/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"/node_modules/bitcore/node_modules/bindings/bindings.js")
|
|
},{"/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":13,"fs":8,"path":14}],8:[function(require,module,exports){
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
/**
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* Author: Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
* License: MIT
|
|
*
|
|
* `npm install buffer`
|
|
*/
|
|
|
|
var base64 = require('base64-js')
|
|
var ieee754 = require('ieee754')
|
|
|
|
exports.Buffer = Buffer
|
|
exports.SlowBuffer = Buffer
|
|
exports.INSPECT_MAX_BYTES = 50
|
|
Buffer.poolSize = 8192
|
|
|
|
/**
|
|
* If `Buffer._useTypedArrays`:
|
|
* === true Use Uint8Array implementation (fastest)
|
|
* === false Use Object implementation (compatible down to IE6)
|
|
*/
|
|
Buffer._useTypedArrays = (function () {
|
|
// Detect if browser supports Typed Arrays. Supported browsers are IE 10+, Firefox 4+,
|
|
// Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+. If the browser does not support adding
|
|
// properties to `Uint8Array` instances, then that's the same as no `Uint8Array` support
|
|
// because we need to be able to add all the node Buffer API methods. This is an issue
|
|
// in Firefox 4-29. Now fixed: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
|
|
try {
|
|
var buf = new ArrayBuffer(0)
|
|
var arr = new Uint8Array(buf)
|
|
arr.foo = function () { return 42 }
|
|
return 42 === arr.foo() &&
|
|
typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
|
|
} catch (e) {
|
|
return false
|
|
}
|
|
})()
|
|
|
|
/**
|
|
* 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 (subject, encoding, noZero) {
|
|
if (!(this instanceof Buffer))
|
|
return new Buffer(subject, encoding, noZero)
|
|
|
|
var type = typeof subject
|
|
|
|
// Workaround: node's base64 implementation allows for non-padded strings
|
|
// while base64-js does not.
|
|
if (encoding === 'base64' && type === 'string') {
|
|
subject = stringtrim(subject)
|
|
while (subject.length % 4 !== 0) {
|
|
subject = subject + '='
|
|
}
|
|
}
|
|
|
|
// Find the length
|
|
var length
|
|
if (type === 'number')
|
|
length = coerce(subject)
|
|
else if (type === 'string')
|
|
length = Buffer.byteLength(subject, encoding)
|
|
else if (type === 'object')
|
|
length = coerce(subject.length) // assume that object is array-like
|
|
else
|
|
throw new Error('First argument needs to be a number, array or string.')
|
|
|
|
var buf
|
|
if (Buffer._useTypedArrays) {
|
|
// Preferred: Return an augmented `Uint8Array` instance for best performance
|
|
buf = Buffer._augment(new Uint8Array(length))
|
|
} else {
|
|
// Fallback: Return THIS instance of Buffer (created by `new`)
|
|
buf = this
|
|
buf.length = length
|
|
buf._isBuffer = true
|
|
}
|
|
|
|
var i
|
|
if (Buffer._useTypedArrays && typeof subject.byteLength === 'number') {
|
|
// Speed optimization -- use set if we're copying from a typed array
|
|
buf._set(subject)
|
|
} else if (isArrayish(subject)) {
|
|
// Treat array-ish objects as a byte array
|
|
for (i = 0; i < length; i++) {
|
|
if (Buffer.isBuffer(subject))
|
|
buf[i] = subject.readUInt8(i)
|
|
else
|
|
buf[i] = subject[i]
|
|
}
|
|
} else if (type === 'string') {
|
|
buf.write(subject, 0, encoding)
|
|
} else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
|
|
for (i = 0; i < length; i++) {
|
|
buf[i] = 0
|
|
}
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
// STATIC METHODS
|
|
// ==============
|
|
|
|
Buffer.isEncoding = function (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.isBuffer = function (b) {
|
|
return !!(b !== null && b !== undefined && b._isBuffer)
|
|
}
|
|
|
|
Buffer.byteLength = function (str, encoding) {
|
|
var ret
|
|
str = str + ''
|
|
switch (encoding || 'utf8') {
|
|
case 'hex':
|
|
ret = str.length / 2
|
|
break
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
ret = utf8ToBytes(str).length
|
|
break
|
|
case 'ascii':
|
|
case 'binary':
|
|
case 'raw':
|
|
ret = str.length
|
|
break
|
|
case 'base64':
|
|
ret = base64ToBytes(str).length
|
|
break
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
ret = str.length * 2
|
|
break
|
|
default:
|
|
throw new Error('Unknown encoding')
|
|
}
|
|
return ret
|
|
}
|
|
|
|
Buffer.concat = function (list, totalLength) {
|
|
assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
|
|
'list should be an Array.')
|
|
|
|
if (list.length === 0) {
|
|
return new Buffer(0)
|
|
} else if (list.length === 1) {
|
|
return list[0]
|
|
}
|
|
|
|
var i
|
|
if (typeof totalLength !== 'number') {
|
|
totalLength = 0
|
|
for (i = 0; i < list.length; i++) {
|
|
totalLength += list[i].length
|
|
}
|
|
}
|
|
|
|
var buf = new Buffer(totalLength)
|
|
var pos = 0
|
|
for (i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
item.copy(buf, pos)
|
|
pos += item.length
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// BUFFER INSTANCE METHODS
|
|
// =======================
|
|
|
|
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
|
|
assert(strLen % 2 === 0, 'Invalid hex string')
|
|
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2
|
|
}
|
|
for (var i = 0; i < length; i++) {
|
|
var byte = parseInt(string.substr(i * 2, 2), 16)
|
|
assert(!isNaN(byte), 'Invalid hex string')
|
|
buf[offset + i] = byte
|
|
}
|
|
Buffer._charsWritten = i * 2
|
|
return i
|
|
}
|
|
|
|
function _utf8Write (buf, string, offset, length) {
|
|
var charsWritten = Buffer._charsWritten =
|
|
blitBuffer(utf8ToBytes(string), buf, offset, length)
|
|
return charsWritten
|
|
}
|
|
|
|
function _asciiWrite (buf, string, offset, length) {
|
|
var charsWritten = Buffer._charsWritten =
|
|
blitBuffer(asciiToBytes(string), buf, offset, length)
|
|
return charsWritten
|
|
}
|
|
|
|
function _binaryWrite (buf, string, offset, length) {
|
|
return _asciiWrite(buf, string, offset, length)
|
|
}
|
|
|
|
function _base64Write (buf, string, offset, length) {
|
|
var charsWritten = Buffer._charsWritten =
|
|
blitBuffer(base64ToBytes(string), buf, offset, length)
|
|
return charsWritten
|
|
}
|
|
|
|
function _utf16leWrite (buf, string, offset, length) {
|
|
var charsWritten = Buffer._charsWritten =
|
|
blitBuffer(utf16leToBytes(string), buf, offset, length)
|
|
return charsWritten
|
|
}
|
|
|
|
Buffer.prototype.write = function (string, offset, length, encoding) {
|
|
// Support both (string, offset, length, encoding)
|
|
// and the legacy (string, encoding, offset, length)
|
|
if (isFinite(offset)) {
|
|
if (!isFinite(length)) {
|
|
encoding = length
|
|
length = undefined
|
|
}
|
|
} else { // legacy
|
|
var swap = encoding
|
|
encoding = offset
|
|
offset = length
|
|
length = swap
|
|
}
|
|
|
|
offset = Number(offset) || 0
|
|
var remaining = this.length - offset
|
|
if (!length) {
|
|
length = remaining
|
|
} else {
|
|
length = Number(length)
|
|
if (length > remaining) {
|
|
length = remaining
|
|
}
|
|
}
|
|
encoding = String(encoding || 'utf8').toLowerCase()
|
|
|
|
var ret
|
|
switch (encoding) {
|
|
case 'hex':
|
|
ret = _hexWrite(this, string, offset, length)
|
|
break
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
ret = _utf8Write(this, string, offset, length)
|
|
break
|
|
case 'ascii':
|
|
ret = _asciiWrite(this, string, offset, length)
|
|
break
|
|
case 'binary':
|
|
ret = _binaryWrite(this, string, offset, length)
|
|
break
|
|
case 'base64':
|
|
ret = _base64Write(this, string, offset, length)
|
|
break
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
ret = _utf16leWrite(this, string, offset, length)
|
|
break
|
|
default:
|
|
throw new Error('Unknown encoding')
|
|
}
|
|
return ret
|
|
}
|
|
|
|
Buffer.prototype.toString = function (encoding, start, end) {
|
|
var self = this
|
|
|
|
encoding = String(encoding || 'utf8').toLowerCase()
|
|
start = Number(start) || 0
|
|
end = (end !== undefined)
|
|
? Number(end)
|
|
: end = self.length
|
|
|
|
// Fastpath empty strings
|
|
if (end === start)
|
|
return ''
|
|
|
|
var ret
|
|
switch (encoding) {
|
|
case 'hex':
|
|
ret = _hexSlice(self, start, end)
|
|
break
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
ret = _utf8Slice(self, start, end)
|
|
break
|
|
case 'ascii':
|
|
ret = _asciiSlice(self, start, end)
|
|
break
|
|
case 'binary':
|
|
ret = _binarySlice(self, start, end)
|
|
break
|
|
case 'base64':
|
|
ret = _base64Slice(self, start, end)
|
|
break
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
ret = _utf16leSlice(self, start, end)
|
|
break
|
|
default:
|
|
throw new Error('Unknown encoding')
|
|
}
|
|
return ret
|
|
}
|
|
|
|
Buffer.prototype.toJSON = function () {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
}
|
|
}
|
|
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
|
Buffer.prototype.copy = function (target, target_start, start, end) {
|
|
var source = this
|
|
|
|
if (!start) start = 0
|
|
if (!end && end !== 0) end = this.length
|
|
if (!target_start) target_start = 0
|
|
|
|
// Copy 0 bytes; we're done
|
|
if (end === start) return
|
|
if (target.length === 0 || source.length === 0) return
|
|
|
|
// Fatal error conditions
|
|
assert(end >= start, 'sourceEnd < sourceStart')
|
|
assert(target_start >= 0 && target_start < target.length,
|
|
'targetStart out of bounds')
|
|
assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
|
|
assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')
|
|
|
|
// Are we oob?
|
|
if (end > this.length)
|
|
end = this.length
|
|
if (target.length - target_start < end - start)
|
|
end = target.length - target_start + start
|
|
|
|
var len = end - start
|
|
|
|
if (len < 100 || !Buffer._useTypedArrays) {
|
|
for (var i = 0; i < len; i++)
|
|
target[i + target_start] = this[i + start]
|
|
} else {
|
|
target._set(this.subarray(start, start + len), target_start)
|
|
}
|
|
}
|
|
|
|
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) {
|
|
var res = ''
|
|
var tmp = ''
|
|
end = Math.min(buf.length, end)
|
|
|
|
for (var i = start; i < end; i++) {
|
|
if (buf[i] <= 0x7F) {
|
|
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
|
|
tmp = ''
|
|
} else {
|
|
tmp += '%' + buf[i].toString(16)
|
|
}
|
|
}
|
|
|
|
return res + decodeUtf8Char(tmp)
|
|
}
|
|
|
|
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])
|
|
return ret
|
|
}
|
|
|
|
function _binarySlice (buf, start, end) {
|
|
return _asciiSlice(buf, start, end)
|
|
}
|
|
|
|
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 (start, end) {
|
|
var len = this.length
|
|
start = clamp(start, len, 0)
|
|
end = clamp(end, len, len)
|
|
|
|
if (Buffer._useTypedArrays) {
|
|
return Buffer._augment(this.subarray(start, end))
|
|
} else {
|
|
var sliceLen = end - start
|
|
var newBuf = new Buffer(sliceLen, undefined, true)
|
|
for (var i = 0; i < sliceLen; i++) {
|
|
newBuf[i] = this[i + start]
|
|
}
|
|
return newBuf
|
|
}
|
|
}
|
|
|
|
// `get` will be removed in Node 0.13+
|
|
Buffer.prototype.get = function (offset) {
|
|
console.log('.get() is deprecated. Access using array indexes instead.')
|
|
return this.readUInt8(offset)
|
|
}
|
|
|
|
// `set` will be removed in Node 0.13+
|
|
Buffer.prototype.set = function (v, offset) {
|
|
console.log('.set() is deprecated. Access using array indexes instead.')
|
|
return this.writeUInt8(v, offset)
|
|
}
|
|
|
|
Buffer.prototype.readUInt8 = function (offset, noAssert) {
|
|
if (!noAssert) {
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset < this.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
if (offset >= this.length)
|
|
return
|
|
|
|
return this[offset]
|
|
}
|
|
|
|
function _readUInt16 (buf, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
var val
|
|
if (littleEndian) {
|
|
val = buf[offset]
|
|
if (offset + 1 < len)
|
|
val |= buf[offset + 1] << 8
|
|
} else {
|
|
val = buf[offset] << 8
|
|
if (offset + 1 < len)
|
|
val |= buf[offset + 1]
|
|
}
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readUInt16LE = function (offset, noAssert) {
|
|
return _readUInt16(this, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readUInt16BE = function (offset, noAssert) {
|
|
return _readUInt16(this, offset, false, noAssert)
|
|
}
|
|
|
|
function _readUInt32 (buf, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
var val
|
|
if (littleEndian) {
|
|
if (offset + 2 < len)
|
|
val = buf[offset + 2] << 16
|
|
if (offset + 1 < len)
|
|
val |= buf[offset + 1] << 8
|
|
val |= buf[offset]
|
|
if (offset + 3 < len)
|
|
val = val + (buf[offset + 3] << 24 >>> 0)
|
|
} else {
|
|
if (offset + 1 < len)
|
|
val = buf[offset + 1] << 16
|
|
if (offset + 2 < len)
|
|
val |= buf[offset + 2] << 8
|
|
if (offset + 3 < len)
|
|
val |= buf[offset + 3]
|
|
val = val + (buf[offset] << 24 >>> 0)
|
|
}
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readUInt32LE = function (offset, noAssert) {
|
|
return _readUInt32(this, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readUInt32BE = function (offset, noAssert) {
|
|
return _readUInt32(this, offset, false, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readInt8 = function (offset, noAssert) {
|
|
if (!noAssert) {
|
|
assert(offset !== undefined && offset !== null,
|
|
'missing offset')
|
|
assert(offset < this.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
if (offset >= this.length)
|
|
return
|
|
|
|
var neg = this[offset] & 0x80
|
|
if (neg)
|
|
return (0xff - this[offset] + 1) * -1
|
|
else
|
|
return this[offset]
|
|
}
|
|
|
|
function _readInt16 (buf, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
var val = _readUInt16(buf, offset, littleEndian, true)
|
|
var neg = val & 0x8000
|
|
if (neg)
|
|
return (0xffff - val + 1) * -1
|
|
else
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readInt16LE = function (offset, noAssert) {
|
|
return _readInt16(this, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readInt16BE = function (offset, noAssert) {
|
|
return _readInt16(this, offset, false, noAssert)
|
|
}
|
|
|
|
function _readInt32 (buf, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
var val = _readUInt32(buf, offset, littleEndian, true)
|
|
var neg = val & 0x80000000
|
|
if (neg)
|
|
return (0xffffffff - val + 1) * -1
|
|
else
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readInt32LE = function (offset, noAssert) {
|
|
return _readInt32(this, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readInt32BE = function (offset, noAssert) {
|
|
return _readInt32(this, offset, false, noAssert)
|
|
}
|
|
|
|
function _readFloat (buf, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
return ieee754.read(buf, offset, littleEndian, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readFloatLE = function (offset, noAssert) {
|
|
return _readFloat(this, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readFloatBE = function (offset, noAssert) {
|
|
return _readFloat(this, offset, false, noAssert)
|
|
}
|
|
|
|
function _readDouble (buf, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
|
|
}
|
|
|
|
return ieee754.read(buf, offset, littleEndian, 52, 8)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleLE = function (offset, noAssert) {
|
|
return _readDouble(this, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleBE = function (offset, noAssert) {
|
|
return _readDouble(this, offset, false, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset < this.length, 'trying to write beyond buffer length')
|
|
verifuint(value, 0xff)
|
|
}
|
|
|
|
if (offset >= this.length) return
|
|
|
|
this[offset] = value
|
|
}
|
|
|
|
function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
|
|
verifuint(value, 0xffff)
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
|
|
buf[offset + i] =
|
|
(value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
|
(littleEndian ? i : 1 - i) * 8
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
|
|
_writeUInt16(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
|
|
_writeUInt16(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
|
|
verifuint(value, 0xffffffff)
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
|
|
buf[offset + i] =
|
|
(value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
|
|
_writeUInt32(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
|
|
_writeUInt32(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset < this.length, 'Trying to write beyond buffer length')
|
|
verifsint(value, 0x7f, -0x80)
|
|
}
|
|
|
|
if (offset >= this.length)
|
|
return
|
|
|
|
if (value >= 0)
|
|
this.writeUInt8(value, offset, noAssert)
|
|
else
|
|
this.writeUInt8(0xff + value + 1, offset, noAssert)
|
|
}
|
|
|
|
function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
|
|
verifsint(value, 0x7fff, -0x8000)
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
if (value >= 0)
|
|
_writeUInt16(buf, value, offset, littleEndian, noAssert)
|
|
else
|
|
_writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
|
|
_writeInt16(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
|
|
_writeInt16(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
|
|
verifsint(value, 0x7fffffff, -0x80000000)
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
if (value >= 0)
|
|
_writeUInt32(buf, value, offset, littleEndian, noAssert)
|
|
else
|
|
_writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
|
|
_writeInt32(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
|
|
_writeInt32(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
function _writeFloat (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
|
|
verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
ieee754.write(buf, value, offset, littleEndian, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
|
|
_writeFloat(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
|
|
_writeFloat(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
function _writeDouble (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
assert(value !== undefined && value !== null, 'missing value')
|
|
assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
|
|
assert(offset !== undefined && offset !== null, 'missing offset')
|
|
assert(offset + 7 < buf.length,
|
|
'Trying to write beyond buffer length')
|
|
verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
|
|
}
|
|
|
|
var len = buf.length
|
|
if (offset >= len)
|
|
return
|
|
|
|
ieee754.write(buf, value, offset, littleEndian, 52, 8)
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
|
|
_writeDouble(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
|
|
_writeDouble(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
// fill(value, start=0, end=buffer.length)
|
|
Buffer.prototype.fill = function (value, start, end) {
|
|
if (!value) value = 0
|
|
if (!start) start = 0
|
|
if (!end) end = this.length
|
|
|
|
if (typeof value === 'string') {
|
|
value = value.charCodeAt(0)
|
|
}
|
|
|
|
assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
|
|
assert(end >= start, 'end < start')
|
|
|
|
// Fill 0 bytes; we're done
|
|
if (end === start) return
|
|
if (this.length === 0) return
|
|
|
|
assert(start >= 0 && start < this.length, 'start out of bounds')
|
|
assert(end >= 0 && end <= this.length, 'end out of bounds')
|
|
|
|
for (var i = start; i < end; i++) {
|
|
this[i] = value
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.inspect = function () {
|
|
var out = []
|
|
var len = this.length
|
|
for (var i = 0; i < len; i++) {
|
|
out[i] = toHex(this[i])
|
|
if (i === exports.INSPECT_MAX_BYTES) {
|
|
out[i + 1] = '...'
|
|
break
|
|
}
|
|
}
|
|
return '<Buffer ' + out.join(' ') + '>'
|
|
}
|
|
|
|
/**
|
|
* 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 () {
|
|
if (typeof Uint8Array !== 'undefined') {
|
|
if (Buffer._useTypedArrays) {
|
|
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 Error('Buffer.toArrayBuffer not supported in this browser')
|
|
}
|
|
}
|
|
|
|
// HELPER FUNCTIONS
|
|
// ================
|
|
|
|
function stringtrim (str) {
|
|
if (str.trim) return str.trim()
|
|
return str.replace(/^\s+|\s+$/g, '')
|
|
}
|
|
|
|
var BP = Buffer.prototype
|
|
|
|
/**
|
|
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
|
|
*/
|
|
Buffer._augment = function (arr) {
|
|
arr._isBuffer = true
|
|
|
|
// save reference to original Uint8Array get/set methods before overwriting
|
|
arr._get = arr.get
|
|
arr._set = arr.set
|
|
|
|
// deprecated, will be removed in node 0.13+
|
|
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.copy = BP.copy
|
|
arr.slice = BP.slice
|
|
arr.readUInt8 = BP.readUInt8
|
|
arr.readUInt16LE = BP.readUInt16LE
|
|
arr.readUInt16BE = BP.readUInt16BE
|
|
arr.readUInt32LE = BP.readUInt32LE
|
|
arr.readUInt32BE = BP.readUInt32BE
|
|
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.writeUInt16LE = BP.writeUInt16LE
|
|
arr.writeUInt16BE = BP.writeUInt16BE
|
|
arr.writeUInt32LE = BP.writeUInt32LE
|
|
arr.writeUInt32BE = BP.writeUInt32BE
|
|
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
|
|
}
|
|
|
|
// slice(start, end)
|
|
function clamp (index, len, defaultValue) {
|
|
if (typeof index !== 'number') return defaultValue
|
|
index = ~~index; // Coerce to integer.
|
|
if (index >= len) return len
|
|
if (index >= 0) return index
|
|
index += len
|
|
if (index >= 0) return index
|
|
return 0
|
|
}
|
|
|
|
function coerce (length) {
|
|
// Coerce length to a number (possibly NaN), round up
|
|
// in case it's fractional (e.g. 123.456) then do a
|
|
// double negate to coerce a NaN to 0. Easy, right?
|
|
length = ~~Math.ceil(+length)
|
|
return length < 0 ? 0 : length
|
|
}
|
|
|
|
function isArray (subject) {
|
|
return (Array.isArray || function (subject) {
|
|
return Object.prototype.toString.call(subject) === '[object Array]'
|
|
})(subject)
|
|
}
|
|
|
|
function isArrayish (subject) {
|
|
return isArray(subject) || Buffer.isBuffer(subject) ||
|
|
subject && typeof subject === 'object' &&
|
|
typeof subject.length === 'number'
|
|
}
|
|
|
|
function toHex (n) {
|
|
if (n < 16) return '0' + n.toString(16)
|
|
return n.toString(16)
|
|
}
|
|
|
|
function utf8ToBytes (str) {
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; i++) {
|
|
var b = str.charCodeAt(i)
|
|
if (b <= 0x7F)
|
|
byteArray.push(str.charCodeAt(i))
|
|
else {
|
|
var start = i
|
|
if (b >= 0xD800 && b <= 0xDFFF) i++
|
|
var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
|
|
for (var j = 0; j < h.length; j++)
|
|
byteArray.push(parseInt(h[j], 16))
|
|
}
|
|
}
|
|
return byteArray
|
|
}
|
|
|
|
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) {
|
|
var c, hi, lo
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; i++) {
|
|
c = str.charCodeAt(i)
|
|
hi = c >> 8
|
|
lo = c % 256
|
|
byteArray.push(lo)
|
|
byteArray.push(hi)
|
|
}
|
|
|
|
return byteArray
|
|
}
|
|
|
|
function base64ToBytes (str) {
|
|
return base64.toByteArray(str)
|
|
}
|
|
|
|
function blitBuffer (src, dst, offset, length) {
|
|
var pos
|
|
for (var i = 0; i < length; i++) {
|
|
if ((i + offset >= dst.length) || (i >= src.length))
|
|
break
|
|
dst[i + offset] = src[i]
|
|
}
|
|
return i
|
|
}
|
|
|
|
function decodeUtf8Char (str) {
|
|
try {
|
|
return decodeURIComponent(str)
|
|
} catch (err) {
|
|
return String.fromCharCode(0xFFFD) // UTF 8 invalid char
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We have to make sure that the value is a valid integer. This means that it
|
|
* is non-negative. It has no fractional component and that it does not
|
|
* exceed the maximum allowed value.
|
|
*/
|
|
function verifuint (value, max) {
|
|
assert(typeof value === 'number', 'cannot write a non-number as a number')
|
|
assert(value >= 0, 'specified a negative value for writing an unsigned value')
|
|
assert(value <= max, 'value is larger than maximum value for type')
|
|
assert(Math.floor(value) === value, 'value has a fractional component')
|
|
}
|
|
|
|
function verifsint (value, max, min) {
|
|
assert(typeof value === 'number', 'cannot write a non-number as a number')
|
|
assert(value <= max, 'value larger than maximum allowed value')
|
|
assert(value >= min, 'value smaller than minimum allowed value')
|
|
assert(Math.floor(value) === value, 'value has a fractional component')
|
|
}
|
|
|
|
function verifIEEE754 (value, max, min) {
|
|
assert(typeof value === 'number', 'cannot write a non-number as a number')
|
|
assert(value <= max, 'value larger than maximum allowed value')
|
|
assert(value >= min, 'value smaller than minimum allowed value')
|
|
}
|
|
|
|
function assert (test, message) {
|
|
if (!test) throw new Error(message || 'Failed assertion')
|
|
}
|
|
|
|
},{"base64-js":10,"ieee754":11}],10:[function(require,module,exports){
|
|
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
|
|
;(function (exports) {
|
|
'use strict';
|
|
|
|
var Arr = (typeof Uint8Array !== 'undefined')
|
|
? Uint8Array
|
|
: Array
|
|
|
|
var ZERO = '0'.charCodeAt(0)
|
|
var PLUS = '+'.charCodeAt(0)
|
|
var SLASH = '/'.charCodeAt(0)
|
|
var NUMBER = '0'.charCodeAt(0)
|
|
var LOWER = 'a'.charCodeAt(0)
|
|
var UPPER = 'A'.charCodeAt(0)
|
|
|
|
function decode (elt) {
|
|
var code = elt.charCodeAt(0)
|
|
if (code === PLUS)
|
|
return 62 // '+'
|
|
if (code === SLASH)
|
|
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
|
|
}
|
|
|
|
module.exports.toByteArray = b64ToByteArray
|
|
module.exports.fromByteArray = uint8ToBase64
|
|
}())
|
|
|
|
},{}],11:[function(require,module,exports){
|
|
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
|
|
var e, m,
|
|
eLen = nBytes * 8 - mLen - 1,
|
|
eMax = (1 << eLen) - 1,
|
|
eBias = eMax >> 1,
|
|
nBits = -7,
|
|
i = isLE ? (nBytes - 1) : 0,
|
|
d = isLE ? -1 : 1,
|
|
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,
|
|
eLen = nBytes * 8 - mLen - 1,
|
|
eMax = (1 << eLen) - 1,
|
|
eBias = eMax >> 1,
|
|
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
|
|
i = isLE ? 0 : (nBytes - 1),
|
|
d = isLE ? 1 : -1,
|
|
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;
|
|
};
|
|
|
|
},{}],12:[function(require,module,exports){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
function EventEmitter() {
|
|
this._events = this._events || {};
|
|
this._maxListeners = this._maxListeners || undefined;
|
|
}
|
|
module.exports = EventEmitter;
|
|
|
|
// Backwards-compat with node 0.10.x
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
|
|
EventEmitter.prototype._events = undefined;
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
|
// added to it. This is a useful default which helps finding memory leaks.
|
|
EventEmitter.defaultMaxListeners = 10;
|
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
|
// that to be increased. Set to zero for unlimited.
|
|
EventEmitter.prototype.setMaxListeners = function(n) {
|
|
if (!isNumber(n) || n < 0 || isNaN(n))
|
|
throw TypeError('n must be a positive number');
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.emit = function(type) {
|
|
var er, handler, len, args, i, listeners;
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// If there is no 'error' event listener then throw.
|
|
if (type === 'error') {
|
|
if (!this._events.error ||
|
|
(isObject(this._events.error) && !this._events.error.length)) {
|
|
er = arguments[1];
|
|
if (er instanceof Error) {
|
|
throw er; // Unhandled 'error' event
|
|
} else {
|
|
throw TypeError('Uncaught, unspecified "error" event.');
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
handler = this._events[type];
|
|
|
|
if (isUndefined(handler))
|
|
return false;
|
|
|
|
if (isFunction(handler)) {
|
|
switch (arguments.length) {
|
|
// fast cases
|
|
case 1:
|
|
handler.call(this);
|
|
break;
|
|
case 2:
|
|
handler.call(this, arguments[1]);
|
|
break;
|
|
case 3:
|
|
handler.call(this, arguments[1], arguments[2]);
|
|
break;
|
|
// slower
|
|
default:
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
handler.apply(this, args);
|
|
}
|
|
} else if (isObject(handler)) {
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
|
|
listeners = handler.slice();
|
|
len = listeners.length;
|
|
for (i = 0; i < len; i++)
|
|
listeners[i].apply(this, args);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
EventEmitter.prototype.addListener = function(type, listener) {
|
|
var m;
|
|
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// To avoid recursion in the case that type === "newListener"! Before
|
|
// adding it to the listeners, first emit "newListener".
|
|
if (this._events.newListener)
|
|
this.emit('newListener', type,
|
|
isFunction(listener.listener) ?
|
|
listener.listener : listener);
|
|
|
|
if (!this._events[type])
|
|
// Optimize the case of one listener. Don't need the extra array object.
|
|
this._events[type] = listener;
|
|
else if (isObject(this._events[type]))
|
|
// If we've already got an array, just append.
|
|
this._events[type].push(listener);
|
|
else
|
|
// Adding the second element, need to change to array.
|
|
this._events[type] = [this._events[type], listener];
|
|
|
|
// Check for listener leak
|
|
if (isObject(this._events[type]) && !this._events[type].warned) {
|
|
var m;
|
|
if (!isUndefined(this._maxListeners)) {
|
|
m = this._maxListeners;
|
|
} else {
|
|
m = EventEmitter.defaultMaxListeners;
|
|
}
|
|
|
|
if (m && m > 0 && this._events[type].length > m) {
|
|
this._events[type].warned = true;
|
|
console.error('(node) warning: possible EventEmitter memory ' +
|
|
'leak detected. %d listeners added. ' +
|
|
'Use emitter.setMaxListeners() to increase limit.',
|
|
this._events[type].length);
|
|
console.trace();
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
|
|
EventEmitter.prototype.once = function(type, listener) {
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
var fired = false;
|
|
|
|
function g() {
|
|
this.removeListener(type, g);
|
|
|
|
if (!fired) {
|
|
fired = true;
|
|
listener.apply(this, arguments);
|
|
}
|
|
}
|
|
|
|
g.listener = listener;
|
|
this.on(type, g);
|
|
|
|
return this;
|
|
};
|
|
|
|
// emits a 'removeListener' event iff the listener was removed
|
|
EventEmitter.prototype.removeListener = function(type, listener) {
|
|
var list, position, length, i;
|
|
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events || !this._events[type])
|
|
return this;
|
|
|
|
list = this._events[type];
|
|
length = list.length;
|
|
position = -1;
|
|
|
|
if (list === listener ||
|
|
(isFunction(list.listener) && list.listener === listener)) {
|
|
delete this._events[type];
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
|
|
} else if (isObject(list)) {
|
|
for (i = length; i-- > 0;) {
|
|
if (list[i] === listener ||
|
|
(list[i].listener && list[i].listener === listener)) {
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (position < 0)
|
|
return this;
|
|
|
|
if (list.length === 1) {
|
|
list.length = 0;
|
|
delete this._events[type];
|
|
} else {
|
|
list.splice(position, 1);
|
|
}
|
|
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) {
|
|
var key, listeners;
|
|
|
|
if (!this._events)
|
|
return this;
|
|
|
|
// not listening for removeListener, no need to emit
|
|
if (!this._events.removeListener) {
|
|
if (arguments.length === 0)
|
|
this._events = {};
|
|
else if (this._events[type])
|
|
delete this._events[type];
|
|
return this;
|
|
}
|
|
|
|
// emit removeListener for all listeners on all events
|
|
if (arguments.length === 0) {
|
|
for (key in this._events) {
|
|
if (key === 'removeListener') continue;
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners('removeListener');
|
|
this._events = {};
|
|
return this;
|
|
}
|
|
|
|
listeners = this._events[type];
|
|
|
|
if (isFunction(listeners)) {
|
|
this.removeListener(type, listeners);
|
|
} else {
|
|
// LIFO order
|
|
while (listeners.length)
|
|
this.removeListener(type, listeners[listeners.length - 1]);
|
|
}
|
|
delete this._events[type];
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.listeners = function(type) {
|
|
var ret;
|
|
if (!this._events || !this._events[type])
|
|
ret = [];
|
|
else if (isFunction(this._events[type]))
|
|
ret = [this._events[type]];
|
|
else
|
|
ret = this._events[type].slice();
|
|
return ret;
|
|
};
|
|
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
var ret;
|
|
if (!emitter._events || !emitter._events[type])
|
|
ret = 0;
|
|
else if (isFunction(emitter._events[type]))
|
|
ret = 1;
|
|
else
|
|
ret = emitter._events[type].length;
|
|
return ret;
|
|
};
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
|
|
},{}],13:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
|
|
var process = module.exports = {};
|
|
|
|
process.nextTick = (function () {
|
|
var canSetImmediate = typeof window !== 'undefined'
|
|
&& window.setImmediate;
|
|
var canPost = typeof window !== 'undefined'
|
|
&& window.postMessage && window.addEventListener
|
|
;
|
|
|
|
if (canSetImmediate) {
|
|
return function (f) { return window.setImmediate(f) };
|
|
}
|
|
|
|
if (canPost) {
|
|
var queue = [];
|
|
window.addEventListener('message', function (ev) {
|
|
var source = ev.source;
|
|
if ((source === window || source === null) && ev.data === 'process-tick') {
|
|
ev.stopPropagation();
|
|
if (queue.length > 0) {
|
|
var fn = queue.shift();
|
|
fn();
|
|
}
|
|
}
|
|
}, true);
|
|
|
|
return function nextTick(fn) {
|
|
queue.push(fn);
|
|
window.postMessage('process-tick', '*');
|
|
};
|
|
}
|
|
|
|
return function nextTick(fn) {
|
|
setTimeout(fn, 0);
|
|
};
|
|
})();
|
|
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
}
|
|
|
|
// TODO(shtylman)
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
(function (process){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
// resolves . and .. elements in a path array with directory names there
|
|
// must be no slashes, empty elements, or device names (c:\) in the array
|
|
// (so also no leading and trailing slashes - it does not distinguish
|
|
// relative and absolute paths)
|
|
function normalizeArray(parts, allowAboveRoot) {
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
|
var last = parts[i];
|
|
if (last === '.') {
|
|
parts.splice(i, 1);
|
|
} else if (last === '..') {
|
|
parts.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
parts.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (allowAboveRoot) {
|
|
for (; up--; up) {
|
|
parts.unshift('..');
|
|
}
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
// Split a filename into [root, dir, basename, ext], unix version
|
|
// 'root' is just a slash, or nothing.
|
|
var splitPathRe =
|
|
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
|
var splitPath = function(filename) {
|
|
return splitPathRe.exec(filename).slice(1);
|
|
};
|
|
|
|
// path.resolve([from ...], to)
|
|
// posix version
|
|
exports.resolve = function() {
|
|
var resolvedPath = '',
|
|
resolvedAbsolute = false;
|
|
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
var path = (i >= 0) ? arguments[i] : process.cwd();
|
|
|
|
// Skip empty and invalid entries
|
|
if (typeof path !== 'string') {
|
|
throw new TypeError('Arguments to path.resolve must be strings');
|
|
} else if (!path) {
|
|
continue;
|
|
}
|
|
|
|
resolvedPath = path + '/' + resolvedPath;
|
|
resolvedAbsolute = path.charAt(0) === '/';
|
|
}
|
|
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
|
|
// Normalize the path
|
|
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
|
|
return !!p;
|
|
}), !resolvedAbsolute).join('/');
|
|
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
|
};
|
|
|
|
// path.normalize(path)
|
|
// posix version
|
|
exports.normalize = function(path) {
|
|
var isAbsolute = exports.isAbsolute(path),
|
|
trailingSlash = substr(path, -1) === '/';
|
|
|
|
// Normalize the path
|
|
path = normalizeArray(filter(path.split('/'), function(p) {
|
|
return !!p;
|
|
}), !isAbsolute).join('/');
|
|
|
|
if (!path && !isAbsolute) {
|
|
path = '.';
|
|
}
|
|
if (path && trailingSlash) {
|
|
path += '/';
|
|
}
|
|
|
|
return (isAbsolute ? '/' : '') + path;
|
|
};
|
|
|
|
// posix version
|
|
exports.isAbsolute = function(path) {
|
|
return path.charAt(0) === '/';
|
|
};
|
|
|
|
// posix version
|
|
exports.join = function() {
|
|
var paths = Array.prototype.slice.call(arguments, 0);
|
|
return exports.normalize(filter(paths, function(p, index) {
|
|
if (typeof p !== 'string') {
|
|
throw new TypeError('Arguments to path.join must be strings');
|
|
}
|
|
return p;
|
|
}).join('/'));
|
|
};
|
|
|
|
|
|
// path.relative(from, to)
|
|
// posix version
|
|
exports.relative = function(from, to) {
|
|
from = exports.resolve(from).substr(1);
|
|
to = exports.resolve(to).substr(1);
|
|
|
|
function trim(arr) {
|
|
var start = 0;
|
|
for (; start < arr.length; start++) {
|
|
if (arr[start] !== '') break;
|
|
}
|
|
|
|
var end = arr.length - 1;
|
|
for (; end >= 0; end--) {
|
|
if (arr[end] !== '') break;
|
|
}
|
|
|
|
if (start > end) return [];
|
|
return arr.slice(start, end - start + 1);
|
|
}
|
|
|
|
var fromParts = trim(from.split('/'));
|
|
var toParts = trim(to.split('/'));
|
|
|
|
var length = Math.min(fromParts.length, toParts.length);
|
|
var samePartsLength = length;
|
|
for (var i = 0; i < length; i++) {
|
|
if (fromParts[i] !== toParts[i]) {
|
|
samePartsLength = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var outputParts = [];
|
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
|
outputParts.push('..');
|
|
}
|
|
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
|
|
return outputParts.join('/');
|
|
};
|
|
|
|
exports.sep = '/';
|
|
exports.delimiter = ':';
|
|
|
|
exports.dirname = function(path) {
|
|
var result = splitPath(path),
|
|
root = result[0],
|
|
dir = result[1];
|
|
|
|
if (!root && !dir) {
|
|
// No dirname whatsoever
|
|
return '.';
|
|
}
|
|
|
|
if (dir) {
|
|
// It has a dirname, strip trailing slash
|
|
dir = dir.substr(0, dir.length - 1);
|
|
}
|
|
|
|
return root + dir;
|
|
};
|
|
|
|
|
|
exports.basename = function(path, ext) {
|
|
var f = splitPath(path)[2];
|
|
// TODO: make this comparison case-insensitive on windows?
|
|
if (ext && f.substr(-1 * ext.length) === ext) {
|
|
f = f.substr(0, f.length - ext.length);
|
|
}
|
|
return f;
|
|
};
|
|
|
|
|
|
exports.extname = function(path) {
|
|
return splitPath(path)[3];
|
|
};
|
|
|
|
function filter (xs, f) {
|
|
if (xs.filter) return xs.filter(f);
|
|
var res = [];
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (f(xs[i], i, xs)) res.push(xs[i]);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// String.prototype.substr - negative index don't work in IE8
|
|
var substr = 'ab'.substr(-1) === 'b'
|
|
? function (str, start, len) { return str.substr(start, len) }
|
|
: function (str, start, len) {
|
|
if (start < 0) start = str.length + start;
|
|
return str.substr(start, len);
|
|
}
|
|
;
|
|
|
|
}).call(this,require("/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
|
|
},{"/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":13}],15:[function(require,module,exports){
|
|
|
|
module.exports = function(){
|
|
var orig = Error.prepareStackTrace;
|
|
Error.prepareStackTrace = function(_, stack){ return stack; };
|
|
var err = new Error;
|
|
Error.captureStackTrace(err, arguments.callee);
|
|
var stack = err.stack;
|
|
Error.prepareStackTrace = orig;
|
|
return stack;
|
|
};
|
|
|
|
},{}],16:[function(require,module,exports){
|
|
(function (process,global){
|
|
var path = require('path');
|
|
var callsite = require('callsite');
|
|
var realModulePaths = module.paths;
|
|
var realModuleFilename = module.filename;
|
|
|
|
// Decorate the given constructor with some useful
|
|
// object oriented constructs (mainly a convenient inherit()
|
|
// method and the ability to do a super send)
|
|
module.exports = function(constructor) {
|
|
// inherit from the given constructor
|
|
constructor.inherit = function(parent) {
|
|
if (arguments.length > 1) {
|
|
// this allows chaining multiple classes in the call
|
|
parent.inherit(Array.prototype.slice.call(arguments, 1));
|
|
}
|
|
this.super_ = parent;
|
|
this.prototype.__proto__ = parent.prototype;
|
|
this.__proto__ = parent;
|
|
};
|
|
|
|
// invoke the given method of the parent
|
|
constructor.super = function(receiver, method, args) {
|
|
if (!this.super_) return;
|
|
if (typeof method == 'string') {
|
|
// invoke the named method
|
|
return this.super_.prototype[method].apply(receiver, args);
|
|
} else {
|
|
// invoke the constructor of the parent
|
|
return this.super_.apply(receiver, method);
|
|
}
|
|
};
|
|
|
|
// a standarized way to access a cached default instance
|
|
constructor.default = function() {
|
|
if (!this._default) this._default = new this();
|
|
return this._default;
|
|
};
|
|
|
|
// set the parent if one is specified
|
|
if (constructor.parent) {
|
|
constructor.inherit(constructor.parent);
|
|
}
|
|
|
|
return constructor;
|
|
};
|
|
|
|
// load the given module using the given imports
|
|
// @fname the module name (relative paths are relative to the caller's
|
|
// location in the file system
|
|
// @imports namespace for binding values in the loaded module
|
|
var load = function(fname, imports) {
|
|
if((fname.slice(0,2) == './') || (fname.slice(0,3) == '../')) {
|
|
var callerFilename = callsite()[1].getFileName();
|
|
fname = path.resolve(path.dirname(callerFilename), fname);
|
|
}
|
|
|
|
// fake out module path resolution here
|
|
module.paths = module.parent.paths;
|
|
module.filename = module.parent.filename;
|
|
fname = require.resolve(fname);
|
|
module.paths = realModulePaths;
|
|
module.filename = realModuleFilename;
|
|
|
|
var cachedModule = require.cache[fname];
|
|
if (cachedModule) delete require.cache[fname];
|
|
global._imports = imports;
|
|
var answer = require(fname);
|
|
delete require.cache[fname];
|
|
if (cachedModule) require.cache[fname] = cachedModule;
|
|
return answer;
|
|
};
|
|
|
|
var load_browser = function(fname, imports) {
|
|
global._imports = imports;
|
|
var answer;
|
|
try {
|
|
answer = require('!' + fname);
|
|
} catch (e) {
|
|
console.log('SOOP:' + e.message + '\nNote that SOOP requires a custom browserify configuration. please check soop\'s readme');
|
|
throw e;
|
|
}
|
|
return answer;
|
|
};
|
|
|
|
module.exports.load = process.versions ? load : load_browser;
|
|
|
|
// access the imports passed from a call to load()
|
|
module.exports.imports = function() {
|
|
var answer = global._imports || {};
|
|
global._imports = {};
|
|
return answer;
|
|
};
|
|
|
|
}).call(this,require("/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":13,"callsite":15,"path":14}],17:[function(require,module,exports){
|
|
|
|
var FakeStorage = function(){
|
|
this.storage = {};
|
|
};
|
|
|
|
FakeStorage.prototype.set = function (id) {
|
|
return this.storage[id];
|
|
};
|
|
|
|
FakeStorage.prototype.get = function(id, payload) {
|
|
this.storage[id] = payload;
|
|
}
|
|
|
|
module.exports = require('soop')(FakeStorage);
|
|
|
|
},{"soop":16}]},{},[]) |