Showing preview only (1,355K chars total). Download the full file or copy to clipboard to get everything.
Repository: howardwu/IPFS-Ethereum-Storage
Branch: master
Commit: b0e7c8334679
Files: 7
Total size: 1.3 MB
Directory structure:
gitextract_9var7xdy/
├── LICENSE
├── README.md
├── contract/
│ ├── SimpleStorage.sol
│ └── SimpleStorageBytecode.txt
├── ipfs/
│ └── ipfs.js
├── storage/
│ └── style.css
└── storage.html
================================================
FILE CONTENTS
================================================
================================================
FILE: LICENSE
================================================
Copyright (c) 2017 Howard Wu.
All files, with the exceptions below, are released under the MIT License:
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.
================================================
FILE: README.md
================================================
# IPFS + Ethereum Storage
We will create a simple datastore solution using IPFS and Ethereum. IPFS provides a convenient interface for distributed data storage, with a hash-based content address for reference to our file. This address will be stored in our smart contract on a private Ethereum blockchain. To retrieve the latest data, we will fetch the address from our blockchain and query IPFS for the associated file.
## Build Guide
This repository has the following dependencies:
* [IPFS](https://ipfs.io) - the Interplanetary File System
* [Geth](https://ethereum.org/cli) - the Go implementation of Ethereum
### Install Geth
__Mac:__ For Mac users, install [Homebrew](https://brew.sh/) and update:
```
brew update
brew upgrade
```
Then run:
```
brew tap ethereum/ethereum
brew install ethereum
```
__Windows:__ For Windows users, download the [latest stable release](https://geth.ethereum.org/downloads/), extract it, download the zip file, extract _geth.exe_ from zip, open a command terminal and type:
```
chdir <path to extracted binary>
open geth.exe
```
__Linux:__ For Ubuntu users, run:
```
sudo apt-get install software-properties-common
sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install ethereum
```
### Install IPFS
__Mac/Linux:__ For Mac and Linux users, download the [prebuilt package](https://ipfs.io/docs/install/), then untar and move the binary to your executables `$PATH` as follows:
```
tar xvfz go-ipfs.tar.gz
mv go-ipfs/ipfs /usr/local/bin/ipfs
```
__Windows:__ For Windows users, download the [prebuilt package](https://ipfs.io/docs/install/), then unzip and move `ipfs.exe` to your `%PATH%`.
To test that your IPFS installation worked, in your terminal (Mac/Linux) or command prompt (Windows) window, run:
```
ipfs help
```
The help menu describing IPFS actions will be printed out.
## Initialize an Ethereum node
We will start by setting up a private Ethereum blockchain on your local machine.
### Setup Geth
Create a new directory for your private blockchain. In your terminal (Mac/Linux) or command prompt (Windows) window, navigate to the directory and create a new account:
```
geth --datadir="./" account new
```
Enter a password when prompted for your local Ethereum account. Geth will create a keystore directory and store the account file in the keystore.
### Genesis Block
Setting up a private blockchain requires defining a genesis block, which sets the initial parameters and token distribution.
In the directory containing your account, copy/paste/save the following JSON into a file called `genesisblock.json`:
```
{
"config": {
"chainID" : 10,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0
},
"nonce": "0x01",
"difficulty": "0x20000",
"mixhash": "0x00000000000000000000000000000000000000647572616c65787365646c6578",
"coinbase": "0x0000000000000000000000000000000000000000",
"timestamp": "0x00",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"extraData": "0x00",
"gasLimit": "0x2FEFD8",
"alloc": {
}
}
```
This will be block 0 of your private blockchain. If you ever wish to have others join this network, they will need this genesis block as well.
We will now instantiate the blockchain network and load the geth console:
```
geth --datadir="./" init genesisblock.json
geth --datadir="./" --networkid 23422 --rpc --rpccorsdomain="*" --rpcport="8545" --minerthreads="1" --mine --nodiscover --maxpeers=0 --unlock 0 console
```
The `--datadir` flag tells geth the path for storing blockchain data. The `--networkid` flag gives your private blockchain a unique reference ID. The `--rpc` and related flags enable remote procedure call (RPC) functionality for web3. The `--minerthreads` flag enables the specified number of CPU threads for mining. The `--mine` flag indicates the mine function for processing transactions and propagating smart contracts through the network. The `--nodiscover` and `--maxpeers` flag disables peer discovery mechanisms. The `--unlock 0` flag unlocks the first account in the system. The `--console` flag enables the REPL terminal.
As this is our first time running the `--mine` flag, wait for the DAG file to be generated. You will see `Generating DAG: xx%` for a couple minutes. This is a one-time operation.
## Initialize IPFS
While we wait for the DAG to be generated, let's setup IPFS. Start by initializing IPFS and modifying CORS restrictions:
```
ipfs init
ipfs config --json API.HTTPHeaders.Access-Control-Allow-Origin '["*"]'
ipfs config --json Gateway.HTTPHeaders.Access-Control-Allow-Origin '["*"]'
```
Now start the daemon:
```
ipfs daemon
```
## Run the Application
Open `storage.html` and follow the instructions on the front page.
## Further Resources
Below are references, projects, and developing work related to IPFS and Ethereum.
### IPFS
* [IPFS](http://ipfs.io) - A peer-to-peer hypermedia protocol to make the web faster, safer, and more open.
* [astralboot](https://github.com/ipfs/astralboot) - Low level boot server that deploys directly out of IPFS (TFTP, PXE Boot).
* [ipget](https://github.com/ipfs/ipget) - wget for IPFS: retrieve files over IPFS and save them locally.
* [container-demos](https://github.com/ipfs/container-demos) - Demos on how to boot docker images and VMs from IPFS.
* [ipfs-npm](https://github.com/ipfs/ipfs-npm) - npm on IPFS.
* [luckychain](https://github.com/luckychain/lucky) - Intel SGX and IPFS-based blockchain implementing Proof of Luck.
### Ethereum
* [Ethereum](https://www.ethereum.org/) - Ethereum is a decentralized platform that runs smart contracts: applications that run exactly as programmed without any possibility of downtime, censorship, fraud or third party interference.
* [web3.js](https://github.com/ethereum/web3.js) - the Ethereum compatible JavaScript API which implements the Generic JSON RPC spec.
* [Ethereum Javascript API (web3)](https://github.com/ethereum/wiki/wiki/JavaScript-API) - Web3 JavaScript Ðapp API.
### Ethereum + IPFS
* [akasha](http://akasha.world/) - A Next-Generation Social Media Network, powered by Ethereum and embedded into IPFS.
* [digix](https://www.dgx.io/) - An asset-tokenization platform built on Ethereum and IPFS.
* [embark](https://github.com/iurimatias/embark-framework) - A framework that allows you to easily develop and deploy Decentralized Applications (DApps).
* [eris](https://github.com/eris-ltd/eris) - An application platform for building, testing, maintaining, and
operating applications built to run on an ecosystem level.
* [uport](https://www.uport.me) - A mobile, self-sovereign identity and key management system, built on the Ethereum blockchain.
* [js-deflate](https://github.com/dankogai/js-deflate) - Gzipping of data to make it fit in URLs
## Acknowledgement
The Ethereum Foundation and Ledger Labs have provided the original Ethereum [contract resources](https://github.com/ledgerlabs/ethereum-getting-started/wiki/Anatomy-of-a-Contract).
================================================
FILE: contract/SimpleStorage.sol
================================================
contract SimpleStorage {
string storedData;
function set(string x) {
storedData = x;
}
function get() constant returns (string x) {
return storedData;
}
}
================================================
FILE: contract/SimpleStorageBytecode.txt
================================================
6060604052610282806100126000396000f360606040526000357c0100000000000000000000000000000000000000000000000000000000900480634ed3885e146100445780636d4ce63c1461009a57610042565b005b6100986004808035906020019082018035906020019191908080601f016020809104026020016040519081016040528093929190818152602001838380828437820191505050505050909091905050610115565b005b6100a760048050506101c6565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101075780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b8060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061016457805160ff1916838001178555610195565b82800160010185558215610195579182015b82811115610194578251826000505591602001919060010190610176565b5b5090506101c091906101a2565b808211156101bc57600081815060009055506001016101a2565b5090565b50505b50565b602060405190810160405280600081526020015060006000508054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156102735780601f1061024857610100808354040283529160200191610273565b820191906000526020600020905b81548152906001019060200180831161025657829003601f168201915b5050505050905061027f565b9056
================================================
FILE: ipfs/ipfs.js
================================================
var IpfsApi =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "/_karma_webpack_//";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 538);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(5)
, core = __webpack_require__(33)
, hide = __webpack_require__(19)
, redefine = __webpack_require__(20)
, ctx = __webpack_require__(34)
, PROTOTYPE = 'prototype';
var $export = function(type, name, source){
var IS_FORCED = type & $export.F
, IS_GLOBAL = type & $export.G
, IS_STATIC = type & $export.S
, IS_PROTO = type & $export.P
, IS_BIND = type & $export.B
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
, expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
, key, own, out, exp;
if(IS_GLOBAL)source = name;
for(key in source){
// contains in native
own = !IS_FORCED && target && target[key] !== undefined;
// export native or passed
out = (own ? target : source)[key];
// bind timers to global for call from export context
exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
// extend global
if(target)redefine(target, key, out, type & $export.U);
// export
if(exports[key] != out)hide(exports, key, exp);
if(IS_PROTO && expProto[key] != out)expProto[key] = out;
}
};
global.core = core;
// type bitmap
$export.F = 1; // forced
$export.G = 2; // global
$export.S = 4; // static
$export.P = 8; // proto
$export.B = 16; // bind
$export.W = 32; // wrap
$export.U = 64; // safe
$export.R = 128; // real proto method for `library`
module.exports = $export;
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer, 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 = __webpack_require__(254)
var ieee754 = __webpack_require__(481)
var isArray = __webpack_require__(266)
exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
/**
* 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.
*
* - 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()
/*
* Export kMaxLength after typed array support is determined.
*/
exports.kMaxLength = kMaxLength()
function typedArraySupport () {
try {
var arr = new Uint8Array(1)
arr.foo = function () { return 42 }
return arr.foo() === 42 && // typed array instances can be augmented
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
}
function createBuffer (that, length) {
if (kMaxLength() < length) {
throw new RangeError('Invalid typed array length')
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = new Uint8Array(length)
that.__proto__ = Buffer.prototype
} else {
// Fallback: Return an object instance of the Buffer class
if (that === null) {
that = new Buffer(length)
}
that.length = length
}
return that
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer (arg, encodingOrOffset, length) {
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
return new Buffer(arg, encodingOrOffset, length)
}
// Common case.
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new Error(
'If encoding is specified then the first argument must be a string'
)
}
return allocUnsafe(this, arg)
}
return from(this, arg, encodingOrOffset, length)
}
Buffer.poolSize = 8192 // not used by this implementation
// TODO: Legacy, not needed anymore. Remove in next major version.
Buffer._augment = function (arr) {
arr.__proto__ = Buffer.prototype
return arr
}
function from (that, value, encodingOrOffset, length) {
if (typeof value === 'number') {
throw new TypeError('"value" argument must not be a number')
}
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
return fromArrayBuffer(that, value, encodingOrOffset, length)
}
if (typeof value === 'string') {
return fromString(that, value, encodingOrOffset)
}
return fromObject(that, value)
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function (value, encodingOrOffset, length) {
return from(null, value, encodingOrOffset, length)
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array
if (typeof Symbol !== 'undefined' && Symbol.species &&
Buffer[Symbol.species] === Buffer) {
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
Object.defineProperty(Buffer, Symbol.species, {
value: null,
configurable: true
})
}
}
function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be a number')
}
}
function alloc (that, size, fill, encoding) {
assertSize(size)
if (size <= 0) {
return createBuffer(that, size)
}
if (fill !== undefined) {
// Only pay attention to encoding if it's a string. This
// prevents accidentally sending in a number that would
// be interpretted as a start offset.
return typeof encoding === 'string'
? createBuffer(that, size).fill(fill, encoding)
: createBuffer(that, size).fill(fill)
}
return createBuffer(that, size)
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function (size, fill, encoding) {
return alloc(null, size, fill, encoding)
}
function allocUnsafe (that, size) {
assertSize(size)
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < size; i++) {
that[i] = 0
}
}
return that
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function (size) {
return allocUnsafe(null, size)
}
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function (size) {
return allocUnsafe(null, size)
}
function fromString (that, string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8'
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('"encoding" must be a valid string encoding')
}
var length = byteLength(string, encoding) | 0
that = createBuffer(that, length)
that.write(string, encoding)
return that
}
function fromArrayLike (that, array) {
var length = checked(array.length) | 0
that = createBuffer(that, length)
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}
function fromArrayBuffer (that, array, byteOffset, length) {
array.byteLength // this throws if `array` is not a valid ArrayBuffer
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('\'offset\' is out of bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('\'length\' is out of bounds')
}
if (length === undefined) {
array = new Uint8Array(array, byteOffset)
} else {
array = new Uint8Array(array, byteOffset, length)
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = array
that.__proto__ = Buffer.prototype
} else {
// Fallback: Return an object instance of the Buffer class
that = fromArrayLike(that, array)
}
return that
}
function fromObject (that, obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0
that = createBuffer(that, len)
if (that.length === 0) {
return that
}
obj.copy(that, 0, 0, len)
return that
}
if (obj) {
if ((typeof ArrayBuffer !== 'undefined' &&
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
if (typeof obj.length !== 'number' || isnan(obj.length)) {
return createBuffer(that, 0)
}
return fromArrayLike(that, obj)
}
if (obj.type === 'Buffer' && isArray(obj.data)) {
return fromArrayLike(that, obj.data)
}
}
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}
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 (length) {
if (+length != length) { // eslint-disable-line eqeqeq
length = 0
}
return Buffer.alloc(+length)
}
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
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i]
y = b[i]
break
}
}
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 Buffer.alloc(0)
}
var i
if (length === undefined) {
length = 0
for (i = 0; i < list.length; i++) {
length += list[i].length
}
}
var buffer = Buffer.allocUnsafe(length)
var pos = 0
for (i = 0; i < list.length; i++) {
var buf = list[i]
if (!Buffer.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos)
pos += buf.length
}
return buffer
}
function byteLength (string, encoding) {
if (Buffer.isBuffer(string)) {
return string.length
}
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
return string.byteLength
}
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':
case undefined:
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
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
// property of a typed array.
// This behaves neither like String nor Uint8Array in that we set start/end
// to their upper/lower bounds if the value passed is out of range.
// undefined is handled specially as per ECMA-262 6th Edition,
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
if (start === undefined || start < 0) {
start = 0
}
// Return early if start > this.length. Done here to prevent potential uint32
// coercion fail below.
if (start > this.length) {
return ''
}
if (end === undefined || end > this.length) {
end = this.length
}
if (end <= 0) {
return ''
}
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
end >>>= 0
start >>>= 0
if (end <= start) {
return ''
}
if (!encoding) encoding = 'utf8'
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
}
}
}
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
Buffer.prototype._isBuffer = true
function swap (b, n, m) {
var i = b[n]
b[n] = b[m]
b[m] = i
}
Buffer.prototype.swap16 = function swap16 () {
var len = this.length
if (len % 2 !== 0) {
throw new RangeError('Buffer size must be a multiple of 16-bits')
}
for (var i = 0; i < len; i += 2) {
swap(this, i, i + 1)
}
return this
}
Buffer.prototype.swap32 = function swap32 () {
var len = this.length
if (len % 4 !== 0) {
throw new RangeError('Buffer size must be a multiple of 32-bits')
}
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3)
swap(this, i + 1, i + 2)
}
return this
}
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 (target, start, end, thisStart, thisEnd) {
if (!Buffer.isBuffer(target)) {
throw new TypeError('Argument must be a Buffer')
}
if (start === undefined) {
start = 0
}
if (end === undefined) {
end = target ? target.length : 0
}
if (thisStart === undefined) {
thisStart = 0
}
if (thisEnd === undefined) {
thisEnd = this.length
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError('out of range index')
}
if (thisStart >= thisEnd && start >= end) {
return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}
start >>>= 0
end >>>= 0
thisStart >>>= 0
thisEnd >>>= 0
if (this === target) return 0
var x = thisEnd - thisStart
var y = end - start
var len = Math.min(x, y)
var thisCopy = this.slice(thisStart, thisEnd)
var targetCopy = target.slice(start, end)
for (var i = 0; i < len; ++i) {
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i]
y = targetCopy[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
function arrayIndexOf (arr, val, byteOffset, encoding) {
var indexSize = 1
var arrLength = arr.length
var valLength = val.length
if (encoding !== undefined) {
encoding = String(encoding).toLowerCase()
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if (arr.length < 2 || val.length < 2) {
return -1
}
indexSize = 2
arrLength /= 2
valLength /= 2
byteOffset /= 2
}
}
function read (buf, i) {
if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}
var foundIndex = -1
for (var i = 0; byteOffset + i < arrLength; i++) {
if (read(arr, byteOffset + i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i
if (i - foundIndex + 1 === valLength) return (byteOffset + foundIndex) * indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex
foundIndex = -1
}
}
return -1
}
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
if (typeof byteOffset === 'string') {
encoding = byteOffset
byteOffset = 0
} else 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') {
val = Buffer.from(val, encoding)
}
if (Buffer.isBuffer(val)) {
// special case: looking for empty string/buffer always fails
if (val.length === 0) {
return -1
}
return arrayIndexOf(this, val, byteOffset, encoding)
}
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, encoding)
}
throw new TypeError('val must be string, number or Buffer')
}
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1
}
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)) return i
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 {
throw new Error(
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
)
}
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 = this.subarray(start, end)
newBuf.__proto__ = Buffer.prototype
} else {
var sliceLen = end - start
newBuf = new Buffer(sliceLen, undefined)
for (var i = 0; i < sliceLen; i++) {
newBuf[i] = this[i + start]
}
}
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" argument must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value" argument 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) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 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) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 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 = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1
}
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 = 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1
}
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 (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 {
Uint8Array.prototype.set.call(
target,
this.subarray(start, start + len),
targetStart
)
}
return len
}
// Usage:
// buffer.fill(number[, offset[, end]])
// buffer.fill(buffer[, offset[, end]])
// buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start
start = 0
end = this.length
} else if (typeof end === 'string') {
encoding = end
end = this.length
}
if (val.length === 1) {
var code = val.charCodeAt(0)
if (code < 256) {
val = code
}
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
} else if (typeof val === 'number') {
val = val & 255
}
// Invalid ranges are not set to a default, so can range check early.
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0
end = end === undefined ? this.length : end >>> 0
if (!val) val = 0
var i
if (typeof val === 'number') {
for (i = start; i < end; i++) {
this[i] = val
}
} else {
var bytes = Buffer.isBuffer(val)
? val
: utf8ToBytes(new Buffer(val, encoding).toString())
var len = bytes.length
for (i = 0; i < end - start; i++) {
this[i + start] = bytes[i % len]
}
}
return this
}
// HELPER FUNCTIONS
// ================
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
}
function isnan (val) {
return val !== val // eslint-disable-line no-self-compare
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1).Buffer, (function() { return this; }())))
/***/ },
/* 2 */
/***/ function(module, exports) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(6);
module.exports = function(it){
if(!isObject(it))throw TypeError(it + ' is not an object!');
return it;
};
/***/ },
/* 4 */
/***/ function(module, exports) {
module.exports = function(exec){
try {
return !!exec();
} catch(e){
return true;
}
};
/***/ },
/* 5 */
/***/ function(module, exports) {
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
/***/ },
/* 6 */
/***/ function(module, exports) {
module.exports = function(it){
return typeof it === 'object' ? it !== null : typeof it === 'function';
};
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
var store = __webpack_require__(86)('wks')
, uid = __webpack_require__(47)
, Symbol = __webpack_require__(5).Symbol
, USE_SYMBOL = typeof Symbol == 'function';
var $exports = module.exports = function(name){
return store[name] || (store[name] =
USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
};
$exports.store = store;
/***/ },
/* 8 */
/***/ function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = setTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
clearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
setTimeout(drainQueue, 0);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(4)(function(){
return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
});
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
var anObject = __webpack_require__(3)
, IE8_DOM_DEFINE = __webpack_require__(159)
, toPrimitive = __webpack_require__(31)
, dP = Object.defineProperty;
exports.f = __webpack_require__(9) ? Object.defineProperty : function defineProperty(O, P, Attributes){
anObject(O);
P = toPrimitive(P, true);
anObject(Attributes);
if(IE8_DOM_DEFINE)try {
return dP(O, P, Attributes);
} catch(e){ /* empty */ }
if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
if('value' in Attributes)O[P] = Attributes.value;
return O;
};
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(module) {(function (module, exports) {
'use strict';
// Utils
function assert (val, msg) {
if (!val) throw new Error(msg || 'Assertion failed');
}
// Could use `inherits` module, but don't want to move from single file
// architecture yet.
function inherits (ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function () {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
// BN
function BN (number, base, endian) {
if (BN.isBN(number)) {
return number;
}
this.negative = 0;
this.words = null;
this.length = 0;
// Reduction context
this.red = null;
if (number !== null) {
if (base === 'le' || base === 'be') {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || 'be');
}
}
if (typeof module === 'object') {
module.exports = BN;
} else {
exports.BN = BN;
}
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
Buffer = __webpack_require__(1).Buffer;
} catch (e) {
}
BN.isBN = function isBN (num) {
return num !== null && typeof num === 'object' &&
num.constructor.name === 'BN' && Array.isArray(num.words);
};
BN.max = function max (left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min (left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init (number, base, endian) {
if (typeof number === 'number') {
return this._initNumber(number, base, endian);
}
if (typeof number === 'object') {
return this._initArray(number, base, endian);
}
if (base === 'hex') {
base = 16;
}
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, '');
var start = 0;
if (number[0] === '-') {
start++;
}
if (base === 16) {
this._parseHex(number, start);
} else {
this._parseBase(number, base, start);
}
if (number[0] === '-') {
this.negative = 1;
}
this.strip();
if (endian !== 'le') return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initNumber = function _initNumber (number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 0x4000000) {
this.words = [ number & 0x3ffffff ];
this.length = 1;
} else if (number < 0x10000000000000) {
this.words = [
number & 0x3ffffff,
(number / 0x4000000) & 0x3ffffff
];
this.length = 2;
} else {
assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
this.words = [
number & 0x3ffffff,
(number / 0x4000000) & 0x3ffffff,
1
];
this.length = 3;
}
if (endian !== 'le') return;
// Reverse the bytes
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray (number, base, endian) {
// Perhaps a Uint8Array
assert(typeof number.length === 'number');
if (number.length <= 0) {
this.words = [ 0 ];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var j, w;
var off = 0;
if (endian === 'be') {
for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
this.words[j] |= (w << off) & 0x3ffffff;
this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
off += 24;
if (off >= 26) {
off -= 26;
j++;
}
}
} else if (endian === 'le') {
for (i = 0, j = 0; i < number.length; i += 3) {
w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
this.words[j] |= (w << off) & 0x3ffffff;
this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
off += 24;
if (off >= 26) {
off -= 26;
j++;
}
}
}
return this.strip();
};
function parseHex (str, start, end) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r <<= 4;
// 'a' - 'f'
if (c >= 49 && c <= 54) {
r |= c - 49 + 0xa;
// 'A' - 'F'
} else if (c >= 17 && c <= 22) {
r |= c - 17 + 0xa;
// '0' - '9'
} else {
r |= c & 0xf;
}
}
return r;
}
BN.prototype._parseHex = function _parseHex (number, start) {
// Create possibly bigger array to ensure that it fits the number
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var j, w;
// Scan 24-bit chunks and add them to the number
var off = 0;
for (i = number.length - 6, j = 0; i >= start; i -= 6) {
w = parseHex(number, i, i + 6);
this.words[j] |= (w << off) & 0x3ffffff;
// NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
off += 24;
if (off >= 26) {
off -= 26;
j++;
}
}
if (i + 6 !== start) {
w = parseHex(number, start, i + 6);
this.words[j] |= (w << off) & 0x3ffffff;
this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
}
this.strip();
};
function parseBase (str, start, end, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
// 'a'
if (c >= 49) {
r += c - 49 + 0xa;
// 'A'
} else if (c >= 17) {
r += c - 17 + 0xa;
// '0' - '9'
} else {
r += c;
}
}
return r;
}
BN.prototype._parseBase = function _parseBase (number, base, start) {
// Initialize as zero
this.words = [ 0 ];
this.length = 1;
// Find length of limb in base
for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
limbLen++;
}
limbLen--;
limbPow = (limbPow / base) | 0;
var total = number.length - start;
var mod = total % limbLen;
var end = Math.min(total, total - mod) + start;
var word = 0;
for (var i = start; i < end; i += limbLen) {
word = parseBase(number, i, i + limbLen, base);
this.imuln(limbPow);
if (this.words[0] + word < 0x4000000) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
if (mod !== 0) {
var pow = 1;
word = parseBase(number, i, number.length, base);
for (i = 0; i < mod; i++) {
pow *= base;
}
this.imuln(pow);
if (this.words[0] + word < 0x4000000) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
};
BN.prototype.copy = function copy (dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
dest.words[i] = this.words[i];
}
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone () {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand (size) {
while (this.length < size) {
this.words[this.length++] = 0;
}
return this;
};
// Remove leading `0` from `this`
BN.prototype.strip = function strip () {
while (this.length > 1 && this.words[this.length - 1] === 0) {
this.length--;
}
return this._normSign();
};
BN.prototype._normSign = function _normSign () {
// -0 = 0
if (this.length === 1 && this.words[0] === 0) {
this.negative = 0;
}
return this;
};
BN.prototype.inspect = function inspect () {
return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
};
/*
var zeros = [];
var groupSizes = [];
var groupBases = [];
var s = '';
var i = -1;
while (++i < BN.wordSize) {
zeros[i] = s;
s += '0';
}
groupSizes[0] = 0;
groupSizes[1] = 0;
groupBases[0] = 0;
groupBases[1] = 0;
var base = 2 - 1;
while (++base < 36 + 1) {
var groupSize = 0;
var groupBase = 1;
while (groupBase < (1 << BN.wordSize) / base) {
groupBase *= base;
groupSize += 1;
}
groupSizes[base] = groupSize;
groupBases[base] = groupBase;
}
*/
var zeros = [
'',
'0',
'00',
'000',
'0000',
'00000',
'000000',
'0000000',
'00000000',
'000000000',
'0000000000',
'00000000000',
'000000000000',
'0000000000000',
'00000000000000',
'000000000000000',
'0000000000000000',
'00000000000000000',
'000000000000000000',
'0000000000000000000',
'00000000000000000000',
'000000000000000000000',
'0000000000000000000000',
'00000000000000000000000',
'000000000000000000000000',
'0000000000000000000000000'
];
var groupSizes = [
0, 0,
25, 16, 12, 11, 10, 9, 8,
8, 7, 7, 7, 7, 6, 6,
6, 6, 6, 6, 6, 5, 5,
5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
];
var groupBases = [
0, 0,
33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
];
BN.prototype.toString = function toString (base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === 'hex') {
out = '';
var off = 0;
var carry = 0;
for (var i = 0; i < this.length; i++) {
var w = this.words[i];
var word = (((w << off) | carry) & 0xffffff).toString(16);
carry = (w >>> (24 - off)) & 0xffffff;
if (carry !== 0 || i !== this.length - 1) {
out = zeros[6 - word.length] + word + out;
} else {
out = word + out;
}
off += 2;
if (off >= 26) {
off -= 26;
i--;
}
}
if (carry !== 0) {
out = carry.toString(16) + out;
}
while (out.length % padding !== 0) {
out = '0' + out;
}
if (this.negative !== 0) {
out = '-' + out;
}
return out;
}
if (base === (base | 0) && base >= 2 && base <= 36) {
// var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
var groupSize = groupSizes[base];
// var groupBase = Math.pow(base, groupSize);
var groupBase = groupBases[base];
out = '';
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) {
out = zeros[groupSize - r.length] + r + out;
} else {
out = r + out;
}
}
if (this.isZero()) {
out = '0' + out;
}
while (out.length % padding !== 0) {
out = '0' + out;
}
if (this.negative !== 0) {
out = '-' + out;
}
return out;
}
assert(false, 'Base should be between 2 and 36');
};
BN.prototype.toNumber = function toNumber () {
var ret = this.words[0];
if (this.length === 2) {
ret += this.words[1] * 0x4000000;
} else if (this.length === 3 && this.words[2] === 0x01) {
// NOTE: at this stage it is known that the top bit is set
ret += 0x10000000000000 + (this.words[1] * 0x4000000);
} else if (this.length > 2) {
assert(false, 'Number can only safely store up to 53 bits');
}
return (this.negative !== 0) ? -ret : ret;
};
BN.prototype.toJSON = function toJSON () {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer (endian, length) {
assert(typeof Buffer !== 'undefined');
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray (endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, 'byte array longer than desired length');
assert(reqLength > 0, 'Requested array length <= 0');
this.strip();
var littleEndian = endian === 'le';
var res = new ArrayType(reqLength);
var b, i;
var q = this.clone();
if (!littleEndian) {
// Assume big-endian
for (i = 0; i < reqLength - byteLength; i++) {
res[i] = 0;
}
for (i = 0; !q.isZero(); i++) {
b = q.andln(0xff);
q.iushrn(8);
res[reqLength - i - 1] = b;
}
} else {
for (i = 0; !q.isZero(); i++) {
b = q.andln(0xff);
q.iushrn(8);
res[i] = b;
}
for (; i < reqLength; i++) {
res[i] = 0;
}
}
return res;
};
if (Math.clz32) {
BN.prototype._countBits = function _countBits (w) {
return 32 - Math.clz32(w);
};
} else {
BN.prototype._countBits = function _countBits (w) {
var t = w;
var r = 0;
if (t >= 0x1000) {
r += 13;
t >>>= 13;
}
if (t >= 0x40) {
r += 7;
t >>>= 7;
}
if (t >= 0x8) {
r += 4;
t >>>= 4;
}
if (t >= 0x02) {
r += 2;
t >>>= 2;
}
return r + t;
};
}
BN.prototype._zeroBits = function _zeroBits (w) {
// Short-cut
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 0x1fff) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 0x7f) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 0xf) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 0x3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 0x1) === 0) {
r++;
}
return r;
};
// Return number of used bits in a BN
BN.prototype.bitLength = function bitLength () {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray (num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = (bit / 26) | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
}
return w;
}
// Number of trailing zero bits
BN.prototype.zeroBits = function zeroBits () {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength () {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos (width) {
if (this.negative !== 0) {
return this.abs().inotn(width).iaddn(1);
}
return this.clone();
};
BN.prototype.fromTwos = function fromTwos (width) {
if (this.testn(width - 1)) {
return this.notn(width).iaddn(1).ineg();
}
return this.clone();
};
BN.prototype.isNeg = function isNeg () {
return this.negative !== 0;
};
// Return negative clone of `this`
BN.prototype.neg = function neg () {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg () {
if (!this.isZero()) {
this.negative ^= 1;
}
return this;
};
// Or `num` with `this` in-place
BN.prototype.iuor = function iuor (num) {
while (this.length < num.length) {
this.words[this.length++] = 0;
}
for (var i = 0; i < num.length; i++) {
this.words[i] = this.words[i] | num.words[i];
}
return this.strip();
};
BN.prototype.ior = function ior (num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
// Or `num` with `this`
BN.prototype.or = function or (num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor (num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
// And `num` with `this` in-place
BN.prototype.iuand = function iuand (num) {
// b = min-length(num, this)
var b;
if (this.length > num.length) {
b = num;
} else {
b = this;
}
for (var i = 0; i < b.length; i++) {
this.words[i] = this.words[i] & num.words[i];
}
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand (num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
// And `num` with `this`
BN.prototype.and = function and (num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand (num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
// Xor `num` with `this` in-place
BN.prototype.iuxor = function iuxor (num) {
// a.length > b.length
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var i = 0; i < b.length; i++) {
this.words[i] = a.words[i] ^ b.words[i];
}
if (this !== a) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = a.length;
return this.strip();
};
BN.prototype.ixor = function ixor (num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
// Xor `num` with `this`
BN.prototype.xor = function xor (num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor (num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
// Not ``this`` with ``width`` bitwidth
BN.prototype.inotn = function inotn (width) {
assert(typeof width === 'number' && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
// Extend the buffer with leading zeroes
this._expand(bytesNeeded);
if (bitsLeft > 0) {
bytesNeeded--;
}
// Handle complete words
for (var i = 0; i < bytesNeeded; i++) {
this.words[i] = ~this.words[i] & 0x3ffffff;
}
// Handle the residue
if (bitsLeft > 0) {
this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
}
// And remove leading zeroes
return this.strip();
};
BN.prototype.notn = function notn (width) {
return this.clone().inotn(width);
};
// Set `bit` of `this`
BN.prototype.setn = function setn (bit, val) {
assert(typeof bit === 'number' && bit >= 0);
var off = (bit / 26) | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) {
this.words[off] = this.words[off] | (1 << wbit);
} else {
this.words[off] = this.words[off] & ~(1 << wbit);
}
return this.strip();
};
// Add `num` to `this` in-place
BN.prototype.iadd = function iadd (num) {
var r;
// negative + positive
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
// positive + negative
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
// a.length > b.length
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 0x3ffffff;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 0x3ffffff;
carry = r >>> 26;
}
this.length = a.length;
if (carry !== 0) {
this.words[this.length] = carry;
this.length++;
// Copy the rest of the words
} else if (a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
return this;
};
// Add `num` to `this`
BN.prototype.add = function add (num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
// Subtract `num` from `this` in-place
BN.prototype.isub = function isub (num) {
// this - (-num) = this + num
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
// -this - num = -(this + num)
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
// At this point both numbers are positive
var cmp = this.cmp(num);
// Optimization - zeroify
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
// a > b
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 0x3ffffff;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 0x3ffffff;
}
// Copy rest of the words
if (carry === 0 && i < a.length && a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = Math.max(this.length, i);
if (a !== this) {
this.negative = 1;
}
return this.strip();
};
// Subtract `num` from `this`
BN.prototype.sub = function sub (num) {
return this.clone().isub(num);
};
function smallMulTo (self, num, out) {
out.negative = num.negative ^ self.negative;
var len = (self.length + num.length) | 0;
out.length = len;
len = (len - 1) | 0;
// Peel one iteration (compiler can't do it, because of code complexity)
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 0x3ffffff;
var carry = (r / 0x4000000) | 0;
out.words[0] = lo;
for (var k = 1; k < len; k++) {
// Sum all words with the same `i + j = k` and accumulate `ncarry`,
// note that ncarry could be >= 0x3ffffff
var ncarry = carry >>> 26;
var rword = carry & 0x3ffffff;
var maxJ = Math.min(k, num.length - 1);
for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
var i = (k - j) | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += (r / 0x4000000) | 0;
rword = r & 0x3ffffff;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) {
out.words[k] = carry | 0;
} else {
out.length--;
}
return out.strip();
}
// TODO(indutny): it may be reasonable to omit it for users who don't need
// to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
// multiplication (like elliptic secp256k1).
var comb10MulTo = function comb10MulTo (self, num, out) {
var a = self.words;
var b = num.words;
var o = out.words;
var c = 0;
var lo;
var mid;
var hi;
var a0 = a[0] | 0;
var al0 = a0 & 0x1fff;
var ah0 = a0 >>> 13;
var a1 = a[1] | 0;
var al1 = a1 & 0x1fff;
var ah1 = a1 >>> 13;
var a2 = a[2] | 0;
var al2 = a2 & 0x1fff;
var ah2 = a2 >>> 13;
var a3 = a[3] | 0;
var al3 = a3 & 0x1fff;
var ah3 = a3 >>> 13;
var a4 = a[4] | 0;
var al4 = a4 & 0x1fff;
var ah4 = a4 >>> 13;
var a5 = a[5] | 0;
var al5 = a5 & 0x1fff;
var ah5 = a5 >>> 13;
var a6 = a[6] | 0;
var al6 = a6 & 0x1fff;
var ah6 = a6 >>> 13;
var a7 = a[7] | 0;
var al7 = a7 & 0x1fff;
var ah7 = a7 >>> 13;
var a8 = a[8] | 0;
var al8 = a8 & 0x1fff;
var ah8 = a8 >>> 13;
var a9 = a[9] | 0;
var al9 = a9 & 0x1fff;
var ah9 = a9 >>> 13;
var b0 = b[0] | 0;
var bl0 = b0 & 0x1fff;
var bh0 = b0 >>> 13;
var b1 = b[1] | 0;
var bl1 = b1 & 0x1fff;
var bh1 = b1 >>> 13;
var b2 = b[2] | 0;
var bl2 = b2 & 0x1fff;
var bh2 = b2 >>> 13;
var b3 = b[3] | 0;
var bl3 = b3 & 0x1fff;
var bh3 = b3 >>> 13;
var b4 = b[4] | 0;
var bl4 = b4 & 0x1fff;
var bh4 = b4 >>> 13;
var b5 = b[5] | 0;
var bl5 = b5 & 0x1fff;
var bh5 = b5 >>> 13;
var b6 = b[6] | 0;
var bl6 = b6 & 0x1fff;
var bh6 = b6 >>> 13;
var b7 = b[7] | 0;
var bl7 = b7 & 0x1fff;
var bh7 = b7 >>> 13;
var b8 = b[8] | 0;
var bl8 = b8 & 0x1fff;
var bh8 = b8 >>> 13;
var b9 = b[9] | 0;
var bl9 = b9 & 0x1fff;
var bh9 = b9 >>> 13;
out.negative = self.negative ^ num.negative;
out.length = 19;
/* k = 0 */
lo = Math.imul(al0, bl0);
mid = Math.imul(al0, bh0);
mid += Math.imul(ah0, bl0);
hi = Math.imul(ah0, bh0);
var w0 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w0 >>> 26);
w0 &= 0x3ffffff;
/* k = 1 */
lo = Math.imul(al1, bl0);
mid = Math.imul(al1, bh0);
mid += Math.imul(ah1, bl0);
hi = Math.imul(ah1, bh0);
lo += Math.imul(al0, bl1);
mid += Math.imul(al0, bh1);
mid += Math.imul(ah0, bl1);
hi += Math.imul(ah0, bh1);
var w1 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w1 >>> 26);
w1 &= 0x3ffffff;
/* k = 2 */
lo = Math.imul(al2, bl0);
mid = Math.imul(al2, bh0);
mid += Math.imul(ah2, bl0);
hi = Math.imul(ah2, bh0);
lo += Math.imul(al1, bl1);
mid += Math.imul(al1, bh1);
mid += Math.imul(ah1, bl1);
hi += Math.imul(ah1, bh1);
lo += Math.imul(al0, bl2);
mid += Math.imul(al0, bh2);
mid += Math.imul(ah0, bl2);
hi += Math.imul(ah0, bh2);
var w2 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w2 >>> 26);
w2 &= 0x3ffffff;
/* k = 3 */
lo = Math.imul(al3, bl0);
mid = Math.imul(al3, bh0);
mid += Math.imul(ah3, bl0);
hi = Math.imul(ah3, bh0);
lo += Math.imul(al2, bl1);
mid += Math.imul(al2, bh1);
mid += Math.imul(ah2, bl1);
hi += Math.imul(ah2, bh1);
lo += Math.imul(al1, bl2);
mid += Math.imul(al1, bh2);
mid += Math.imul(ah1, bl2);
hi += Math.imul(ah1, bh2);
lo += Math.imul(al0, bl3);
mid += Math.imul(al0, bh3);
mid += Math.imul(ah0, bl3);
hi += Math.imul(ah0, bh3);
var w3 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w3 >>> 26);
w3 &= 0x3ffffff;
/* k = 4 */
lo = Math.imul(al4, bl0);
mid = Math.imul(al4, bh0);
mid += Math.imul(ah4, bl0);
hi = Math.imul(ah4, bh0);
lo += Math.imul(al3, bl1);
mid += Math.imul(al3, bh1);
mid += Math.imul(ah3, bl1);
hi += Math.imul(ah3, bh1);
lo += Math.imul(al2, bl2);
mid += Math.imul(al2, bh2);
mid += Math.imul(ah2, bl2);
hi += Math.imul(ah2, bh2);
lo += Math.imul(al1, bl3);
mid += Math.imul(al1, bh3);
mid += Math.imul(ah1, bl3);
hi += Math.imul(ah1, bh3);
lo += Math.imul(al0, bl4);
mid += Math.imul(al0, bh4);
mid += Math.imul(ah0, bl4);
hi += Math.imul(ah0, bh4);
var w4 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w4 >>> 26);
w4 &= 0x3ffffff;
/* k = 5 */
lo = Math.imul(al5, bl0);
mid = Math.imul(al5, bh0);
mid += Math.imul(ah5, bl0);
hi = Math.imul(ah5, bh0);
lo += Math.imul(al4, bl1);
mid += Math.imul(al4, bh1);
mid += Math.imul(ah4, bl1);
hi += Math.imul(ah4, bh1);
lo += Math.imul(al3, bl2);
mid += Math.imul(al3, bh2);
mid += Math.imul(ah3, bl2);
hi += Math.imul(ah3, bh2);
lo += Math.imul(al2, bl3);
mid += Math.imul(al2, bh3);
mid += Math.imul(ah2, bl3);
hi += Math.imul(ah2, bh3);
lo += Math.imul(al1, bl4);
mid += Math.imul(al1, bh4);
mid += Math.imul(ah1, bl4);
hi += Math.imul(ah1, bh4);
lo += Math.imul(al0, bl5);
mid += Math.imul(al0, bh5);
mid += Math.imul(ah0, bl5);
hi += Math.imul(ah0, bh5);
var w5 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w5 >>> 26);
w5 &= 0x3ffffff;
/* k = 6 */
lo = Math.imul(al6, bl0);
mid = Math.imul(al6, bh0);
mid += Math.imul(ah6, bl0);
hi = Math.imul(ah6, bh0);
lo += Math.imul(al5, bl1);
mid += Math.imul(al5, bh1);
mid += Math.imul(ah5, bl1);
hi += Math.imul(ah5, bh1);
lo += Math.imul(al4, bl2);
mid += Math.imul(al4, bh2);
mid += Math.imul(ah4, bl2);
hi += Math.imul(ah4, bh2);
lo += Math.imul(al3, bl3);
mid += Math.imul(al3, bh3);
mid += Math.imul(ah3, bl3);
hi += Math.imul(ah3, bh3);
lo += Math.imul(al2, bl4);
mid += Math.imul(al2, bh4);
mid += Math.imul(ah2, bl4);
hi += Math.imul(ah2, bh4);
lo += Math.imul(al1, bl5);
mid += Math.imul(al1, bh5);
mid += Math.imul(ah1, bl5);
hi += Math.imul(ah1, bh5);
lo += Math.imul(al0, bl6);
mid += Math.imul(al0, bh6);
mid += Math.imul(ah0, bl6);
hi += Math.imul(ah0, bh6);
var w6 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w6 >>> 26);
w6 &= 0x3ffffff;
/* k = 7 */
lo = Math.imul(al7, bl0);
mid = Math.imul(al7, bh0);
mid += Math.imul(ah7, bl0);
hi = Math.imul(ah7, bh0);
lo += Math.imul(al6, bl1);
mid += Math.imul(al6, bh1);
mid += Math.imul(ah6, bl1);
hi += Math.imul(ah6, bh1);
lo += Math.imul(al5, bl2);
mid += Math.imul(al5, bh2);
mid += Math.imul(ah5, bl2);
hi += Math.imul(ah5, bh2);
lo += Math.imul(al4, bl3);
mid += Math.imul(al4, bh3);
mid += Math.imul(ah4, bl3);
hi += Math.imul(ah4, bh3);
lo += Math.imul(al3, bl4);
mid += Math.imul(al3, bh4);
mid += Math.imul(ah3, bl4);
hi += Math.imul(ah3, bh4);
lo += Math.imul(al2, bl5);
mid += Math.imul(al2, bh5);
mid += Math.imul(ah2, bl5);
hi += Math.imul(ah2, bh5);
lo += Math.imul(al1, bl6);
mid += Math.imul(al1, bh6);
mid += Math.imul(ah1, bl6);
hi += Math.imul(ah1, bh6);
lo += Math.imul(al0, bl7);
mid += Math.imul(al0, bh7);
mid += Math.imul(ah0, bl7);
hi += Math.imul(ah0, bh7);
var w7 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w7 >>> 26);
w7 &= 0x3ffffff;
/* k = 8 */
lo = Math.imul(al8, bl0);
mid = Math.imul(al8, bh0);
mid += Math.imul(ah8, bl0);
hi = Math.imul(ah8, bh0);
lo += Math.imul(al7, bl1);
mid += Math.imul(al7, bh1);
mid += Math.imul(ah7, bl1);
hi += Math.imul(ah7, bh1);
lo += Math.imul(al6, bl2);
mid += Math.imul(al6, bh2);
mid += Math.imul(ah6, bl2);
hi += Math.imul(ah6, bh2);
lo += Math.imul(al5, bl3);
mid += Math.imul(al5, bh3);
mid += Math.imul(ah5, bl3);
hi += Math.imul(ah5, bh3);
lo += Math.imul(al4, bl4);
mid += Math.imul(al4, bh4);
mid += Math.imul(ah4, bl4);
hi += Math.imul(ah4, bh4);
lo += Math.imul(al3, bl5);
mid += Math.imul(al3, bh5);
mid += Math.imul(ah3, bl5);
hi += Math.imul(ah3, bh5);
lo += Math.imul(al2, bl6);
mid += Math.imul(al2, bh6);
mid += Math.imul(ah2, bl6);
hi += Math.imul(ah2, bh6);
lo += Math.imul(al1, bl7);
mid += Math.imul(al1, bh7);
mid += Math.imul(ah1, bl7);
hi += Math.imul(ah1, bh7);
lo += Math.imul(al0, bl8);
mid += Math.imul(al0, bh8);
mid += Math.imul(ah0, bl8);
hi += Math.imul(ah0, bh8);
var w8 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w8 >>> 26);
w8 &= 0x3ffffff;
/* k = 9 */
lo = Math.imul(al9, bl0);
mid = Math.imul(al9, bh0);
mid += Math.imul(ah9, bl0);
hi = Math.imul(ah9, bh0);
lo += Math.imul(al8, bl1);
mid += Math.imul(al8, bh1);
mid += Math.imul(ah8, bl1);
hi += Math.imul(ah8, bh1);
lo += Math.imul(al7, bl2);
mid += Math.imul(al7, bh2);
mid += Math.imul(ah7, bl2);
hi += Math.imul(ah7, bh2);
lo += Math.imul(al6, bl3);
mid += Math.imul(al6, bh3);
mid += Math.imul(ah6, bl3);
hi += Math.imul(ah6, bh3);
lo += Math.imul(al5, bl4);
mid += Math.imul(al5, bh4);
mid += Math.imul(ah5, bl4);
hi += Math.imul(ah5, bh4);
lo += Math.imul(al4, bl5);
mid += Math.imul(al4, bh5);
mid += Math.imul(ah4, bl5);
hi += Math.imul(ah4, bh5);
lo += Math.imul(al3, bl6);
mid += Math.imul(al3, bh6);
mid += Math.imul(ah3, bl6);
hi += Math.imul(ah3, bh6);
lo += Math.imul(al2, bl7);
mid += Math.imul(al2, bh7);
mid += Math.imul(ah2, bl7);
hi += Math.imul(ah2, bh7);
lo += Math.imul(al1, bl8);
mid += Math.imul(al1, bh8);
mid += Math.imul(ah1, bl8);
hi += Math.imul(ah1, bh8);
lo += Math.imul(al0, bl9);
mid += Math.imul(al0, bh9);
mid += Math.imul(ah0, bl9);
hi += Math.imul(ah0, bh9);
var w9 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w9 >>> 26);
w9 &= 0x3ffffff;
/* k = 10 */
lo = Math.imul(al9, bl1);
mid = Math.imul(al9, bh1);
mid += Math.imul(ah9, bl1);
hi = Math.imul(ah9, bh1);
lo += Math.imul(al8, bl2);
mid += Math.imul(al8, bh2);
mid += Math.imul(ah8, bl2);
hi += Math.imul(ah8, bh2);
lo += Math.imul(al7, bl3);
mid += Math.imul(al7, bh3);
mid += Math.imul(ah7, bl3);
hi += Math.imul(ah7, bh3);
lo += Math.imul(al6, bl4);
mid += Math.imul(al6, bh4);
mid += Math.imul(ah6, bl4);
hi += Math.imul(ah6, bh4);
lo += Math.imul(al5, bl5);
mid += Math.imul(al5, bh5);
mid += Math.imul(ah5, bl5);
hi += Math.imul(ah5, bh5);
lo += Math.imul(al4, bl6);
mid += Math.imul(al4, bh6);
mid += Math.imul(ah4, bl6);
hi += Math.imul(ah4, bh6);
lo += Math.imul(al3, bl7);
mid += Math.imul(al3, bh7);
mid += Math.imul(ah3, bl7);
hi += Math.imul(ah3, bh7);
lo += Math.imul(al2, bl8);
mid += Math.imul(al2, bh8);
mid += Math.imul(ah2, bl8);
hi += Math.imul(ah2, bh8);
lo += Math.imul(al1, bl9);
mid += Math.imul(al1, bh9);
mid += Math.imul(ah1, bl9);
hi += Math.imul(ah1, bh9);
var w10 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w10 >>> 26);
w10 &= 0x3ffffff;
/* k = 11 */
lo = Math.imul(al9, bl2);
mid = Math.imul(al9, bh2);
mid += Math.imul(ah9, bl2);
hi = Math.imul(ah9, bh2);
lo += Math.imul(al8, bl3);
mid += Math.imul(al8, bh3);
mid += Math.imul(ah8, bl3);
hi += Math.imul(ah8, bh3);
lo += Math.imul(al7, bl4);
mid += Math.imul(al7, bh4);
mid += Math.imul(ah7, bl4);
hi += Math.imul(ah7, bh4);
lo += Math.imul(al6, bl5);
mid += Math.imul(al6, bh5);
mid += Math.imul(ah6, bl5);
hi += Math.imul(ah6, bh5);
lo += Math.imul(al5, bl6);
mid += Math.imul(al5, bh6);
mid += Math.imul(ah5, bl6);
hi += Math.imul(ah5, bh6);
lo += Math.imul(al4, bl7);
mid += Math.imul(al4, bh7);
mid += Math.imul(ah4, bl7);
hi += Math.imul(ah4, bh7);
lo += Math.imul(al3, bl8);
mid += Math.imul(al3, bh8);
mid += Math.imul(ah3, bl8);
hi += Math.imul(ah3, bh8);
lo += Math.imul(al2, bl9);
mid += Math.imul(al2, bh9);
mid += Math.imul(ah2, bl9);
hi += Math.imul(ah2, bh9);
var w11 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w11 >>> 26);
w11 &= 0x3ffffff;
/* k = 12 */
lo = Math.imul(al9, bl3);
mid = Math.imul(al9, bh3);
mid += Math.imul(ah9, bl3);
hi = Math.imul(ah9, bh3);
lo += Math.imul(al8, bl4);
mid += Math.imul(al8, bh4);
mid += Math.imul(ah8, bl4);
hi += Math.imul(ah8, bh4);
lo += Math.imul(al7, bl5);
mid += Math.imul(al7, bh5);
mid += Math.imul(ah7, bl5);
hi += Math.imul(ah7, bh5);
lo += Math.imul(al6, bl6);
mid += Math.imul(al6, bh6);
mid += Math.imul(ah6, bl6);
hi += Math.imul(ah6, bh6);
lo += Math.imul(al5, bl7);
mid += Math.imul(al5, bh7);
mid += Math.imul(ah5, bl7);
hi += Math.imul(ah5, bh7);
lo += Math.imul(al4, bl8);
mid += Math.imul(al4, bh8);
mid += Math.imul(ah4, bl8);
hi += Math.imul(ah4, bh8);
lo += Math.imul(al3, bl9);
mid += Math.imul(al3, bh9);
mid += Math.imul(ah3, bl9);
hi += Math.imul(ah3, bh9);
var w12 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w12 >>> 26);
w12 &= 0x3ffffff;
/* k = 13 */
lo = Math.imul(al9, bl4);
mid = Math.imul(al9, bh4);
mid += Math.imul(ah9, bl4);
hi = Math.imul(ah9, bh4);
lo += Math.imul(al8, bl5);
mid += Math.imul(al8, bh5);
mid += Math.imul(ah8, bl5);
hi += Math.imul(ah8, bh5);
lo += Math.imul(al7, bl6);
mid += Math.imul(al7, bh6);
mid += Math.imul(ah7, bl6);
hi += Math.imul(ah7, bh6);
lo += Math.imul(al6, bl7);
mid += Math.imul(al6, bh7);
mid += Math.imul(ah6, bl7);
hi += Math.imul(ah6, bh7);
lo += Math.imul(al5, bl8);
mid += Math.imul(al5, bh8);
mid += Math.imul(ah5, bl8);
hi += Math.imul(ah5, bh8);
lo += Math.imul(al4, bl9);
mid += Math.imul(al4, bh9);
mid += Math.imul(ah4, bl9);
hi += Math.imul(ah4, bh9);
var w13 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w13 >>> 26);
w13 &= 0x3ffffff;
/* k = 14 */
lo = Math.imul(al9, bl5);
mid = Math.imul(al9, bh5);
mid += Math.imul(ah9, bl5);
hi = Math.imul(ah9, bh5);
lo += Math.imul(al8, bl6);
mid += Math.imul(al8, bh6);
mid += Math.imul(ah8, bl6);
hi += Math.imul(ah8, bh6);
lo += Math.imul(al7, bl7);
mid += Math.imul(al7, bh7);
mid += Math.imul(ah7, bl7);
hi += Math.imul(ah7, bh7);
lo += Math.imul(al6, bl8);
mid += Math.imul(al6, bh8);
mid += Math.imul(ah6, bl8);
hi += Math.imul(ah6, bh8);
lo += Math.imul(al5, bl9);
mid += Math.imul(al5, bh9);
mid += Math.imul(ah5, bl9);
hi += Math.imul(ah5, bh9);
var w14 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w14 >>> 26);
w14 &= 0x3ffffff;
/* k = 15 */
lo = Math.imul(al9, bl6);
mid = Math.imul(al9, bh6);
mid += Math.imul(ah9, bl6);
hi = Math.imul(ah9, bh6);
lo += Math.imul(al8, bl7);
mid += Math.imul(al8, bh7);
mid += Math.imul(ah8, bl7);
hi += Math.imul(ah8, bh7);
lo += Math.imul(al7, bl8);
mid += Math.imul(al7, bh8);
mid += Math.imul(ah7, bl8);
hi += Math.imul(ah7, bh8);
lo += Math.imul(al6, bl9);
mid += Math.imul(al6, bh9);
mid += Math.imul(ah6, bl9);
hi += Math.imul(ah6, bh9);
var w15 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w15 >>> 26);
w15 &= 0x3ffffff;
/* k = 16 */
lo = Math.imul(al9, bl7);
mid = Math.imul(al9, bh7);
mid += Math.imul(ah9, bl7);
hi = Math.imul(ah9, bh7);
lo += Math.imul(al8, bl8);
mid += Math.imul(al8, bh8);
mid += Math.imul(ah8, bl8);
hi += Math.imul(ah8, bh8);
lo += Math.imul(al7, bl9);
mid += Math.imul(al7, bh9);
mid += Math.imul(ah7, bl9);
hi += Math.imul(ah7, bh9);
var w16 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w16 >>> 26);
w16 &= 0x3ffffff;
/* k = 17 */
lo = Math.imul(al9, bl8);
mid = Math.imul(al9, bh8);
mid += Math.imul(ah9, bl8);
hi = Math.imul(ah9, bh8);
lo += Math.imul(al8, bl9);
mid += Math.imul(al8, bh9);
mid += Math.imul(ah8, bl9);
hi += Math.imul(ah8, bh9);
var w17 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w17 >>> 26);
w17 &= 0x3ffffff;
/* k = 18 */
lo = Math.imul(al9, bl9);
mid = Math.imul(al9, bh9);
mid += Math.imul(ah9, bl9);
hi = Math.imul(ah9, bh9);
var w18 = c + lo + ((mid & 0x1fff) << 13);
c = hi + (mid >>> 13) + (w18 >>> 26);
w18 &= 0x3ffffff;
o[0] = w0;
o[1] = w1;
o[2] = w2;
o[3] = w3;
o[4] = w4;
o[5] = w5;
o[6] = w6;
o[7] = w7;
o[8] = w8;
o[9] = w9;
o[10] = w10;
o[11] = w11;
o[12] = w12;
o[13] = w13;
o[14] = w14;
o[15] = w15;
o[16] = w16;
o[17] = w17;
o[18] = w18;
if (c !== 0) {
o[19] = c;
out.length++;
}
return out;
};
// Polyfill comb
if (!Math.imul) {
comb10MulTo = smallMulTo;
}
function bigMulTo (self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.length + num.length;
var carry = 0;
var hncarry = 0;
for (var k = 0; k < out.length - 1; k++) {
// Sum all words with the same `i + j = k` and accumulate `ncarry`,
// note that ncarry could be >= 0x3ffffff
var ncarry = hncarry;
hncarry = 0;
var rword = carry & 0x3ffffff;
var maxJ = Math.min(k, num.length - 1);
for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var a = self.words[i] | 0;
var b = num.words[j] | 0;
var r = a * b;
var lo = r & 0x3ffffff;
ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
lo = (lo + rword) | 0;
rword = lo & 0x3ffffff;
ncarry = (ncarry + (lo >>> 26)) | 0;
hncarry += ncarry >>> 26;
ncarry &= 0x3ffffff;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) {
out.words[k] = carry;
} else {
out.length--;
}
return out.strip();
}
function jumboMulTo (self, num, out) {
var fftm = new FFTM();
return fftm.mulp(self, num, out);
}
BN.prototype.mulTo = function mulTo (num, out) {
var res;
var len = this.length + num.length;
if (this.length === 10 && num.length === 10) {
res = comb10MulTo(this, num, out);
} else if (len < 63) {
res = smallMulTo(this, num, out);
} else if (len < 1024) {
res = bigMulTo(this, num, out);
} else {
res = jumboMulTo(this, num, out);
}
return res;
};
// Cooley-Tukey algorithm for FFT
// slightly revisited to rely on looping instead of recursion
function FFTM (x, y) {
this.x = x;
this.y = y;
}
FFTM.prototype.makeRBT = function makeRBT (N) {
var t = new Array(N);
var l = BN.prototype._countBits(N) - 1;
for (var i = 0; i < N; i++) {
t[i] = this.revBin(i, l, N);
}
return t;
};
// Returns binary-reversed representation of `x`
FFTM.prototype.revBin = function revBin (x, l, N) {
if (x === 0 || x === N - 1) return x;
var rb = 0;
for (var i = 0; i < l; i++) {
rb |= (x & 1) << (l - i - 1);
x >>= 1;
}
return rb;
};
// Performs "tweedling" phase, therefore 'emulating'
// behaviour of the recursive algorithm
FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {
for (var i = 0; i < N; i++) {
rtws[i] = rws[rbt[i]];
itws[i] = iws[rbt[i]];
}
};
FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {
this.permute(rbt, rws, iws, rtws, itws, N);
for (var s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
/* jshint maxdepth : false */
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b (n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var i = 0;
for (N = N / 2 | 0; N; N = N >>> 1) {
i++;
}
return 1 << i + 1 + odd;
};
FFTM.prototype.conjugate = function conjugate (rws, iws, N) {
if (N <= 1) return;
for (var i = 0; i < N / 2; i++) {
var t = rws[i];
rws[i] = rws[N - i - 1];
rws[N - i - 1] = t;
t = iws[i];
iws[i] = -iws[N - i - 1];
iws[N - i - 1] = -t;
}
};
FFTM.prototype.normalize13b = function normalize13b (ws, N) {
var carry = 0;
for (var i = 0; i < N / 2; i++) {
var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
Math.round(ws[2 * i] / N) +
carry;
ws[i] = w & 0x3ffffff;
if (w < 0x4000000) {
carry = 0;
} else {
carry = w / 0x4000000 | 0;
}
}
return ws;
};
FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {
var carry = 0;
for (var i = 0; i < len; i++) {
carry = carry + (ws[i] | 0);
rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;
rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;
}
// Pad with zeroes
for (i = 2 * len; i < N; ++i) {
rws[i] = 0;
}
assert(carry === 0);
assert((carry & ~0x1fff) === 0);
};
FFTM.prototype.stub = function stub (N) {
var ph = new Array(N);
for (var i = 0; i < N; i++) {
ph[i] = 0;
}
return ph;
};
FFTM.prototype.mulp = function mulp (x, y, out) {
var N = 2 * this.guessLen13b(x.length, y.length);
var rbt = this.makeRBT(N);
var _ = this.stub(N);
var rws = new Array(N);
var rwst = new Array(N);
var iwst = new Array(N);
var nrws = new Array(N);
var nrwst = new Array(N);
var niwst = new Array(N);
var rmws = out.words;
rmws.length = N;
this.convert13b(x.words, x.length, rws, N);
this.convert13b(y.words, y.length, nrws, N);
this.transform(rws, _, rwst, iwst, N, rbt);
this.transform(nrws, _, nrwst, niwst, N, rbt);
for (var i = 0; i < N; i++) {
var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
rwst[i] = rx;
}
this.conjugate(rwst, iwst, N);
this.transform(rwst, iwst, rmws, _, N, rbt);
this.conjugate(rmws, _, N);
this.normalize13b(rmws, N);
out.negative = x.negative ^ y.negative;
out.length = x.length + y.length;
return out.strip();
};
// Multiply `this` by `num`
BN.prototype.mul = function mul (num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
// Multiply employing FFT
BN.prototype.mulf = function mulf (num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
// In-place Multiplication
BN.prototype.imul = function imul (num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln (num) {
assert(typeof num === 'number');
assert(num < 0x4000000);
// Carry
var carry = 0;
for (var i = 0; i < this.length; i++) {
var w = (this.words[i] | 0) * num;
var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
carry >>= 26;
carry += (w / 0x4000000) | 0;
// NOTE: lo is 27bit maximum
carry += lo >>> 26;
this.words[i] = lo & 0x3ffffff;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return this;
};
BN.prototype.muln = function muln (num) {
return this.clone().imuln(num);
};
// `this` * `this`
BN.prototype.sqr = function sqr () {
return this.mul(this);
};
// `this` * `this` in-place
BN.prototype.isqr = function isqr () {
return this.imul(this.clone());
};
// Math.pow(`this`, `num`)
BN.prototype.pow = function pow (num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
// Skip leading zeroes
var res = this;
for (var i = 0; i < w.length; i++, res = res.sqr()) {
if (w[i] !== 0) break;
}
if (++i < w.length) {
for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
if (w[i] === 0) continue;
res = res.mul(q);
}
}
return res;
};
// Shift-left in-place
BN.prototype.iushln = function iushln (bits) {
assert(typeof bits === 'number' && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = ((this.words[i] | 0) - newCarry) << r;
this.words[i] = c | carry;
carry = newCarry >>> (26 - r);
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) {
this.words[i + s] = this.words[i];
}
for (i = 0; i < s; i++) {
this.words[i] = 0;
}
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln (bits) {
// TODO(indutny): implement me
assert(this.negative === 0);
return this.iushln(bits);
};
// Shift-right in-place
// NOTE: `hint` is a lowest bit before trailing zeroes
// NOTE: if `extended` is present - it will be filled with destroyed bits
BN.prototype.iushrn = function iushrn (bits, hint, extended) {
assert(typeof bits === 'number' && bits >= 0);
var h;
if (hint) {
h = (hint - (hint % 26)) / 26;
} else {
h = 0;
}
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
// Extended mode, copy masked part
if (maskedWords) {
for (var i = 0; i < s; i++) {
maskedWords.words[i] = this.words[i];
}
maskedWords.length = s;
}
if (s === 0) {
// No-op, we should not move anything at all
} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) {
this.words[i] = this.words[i + s];
}
} else {
this.words[0] = 0;
this.length = 1;
}
var carry = 0;
for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
var word = this.words[i] | 0;
this.words[i] = (carry << (26 - r)) | (word >>> r);
carry = word & mask;
}
// Push carried bits as a mask
if (maskedWords && carry !== 0) {
maskedWords.words[maskedWords.length++] = carry;
}
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn (bits, hint, extended) {
// TODO(indutny): implement me
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
// Shift-left
BN.prototype.shln = function shln (bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln (bits) {
return this.clone().iushln(bits);
};
// Shift-right
BN.prototype.shrn = function shrn (bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn (bits) {
return this.clone().iushrn(bits);
};
// Test if n bit is set
BN.prototype.testn = function testn (bit) {
assert(typeof bit === 'number' && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
// Fast case: bit is much higher than all existing words
if (this.length <= s) return false;
// Check bit and return
var w = this.words[s];
return !!(w & q);
};
// Return only lowers bits of number (in-place)
BN.prototype.imaskn = function imaskn (bits) {
assert(typeof bits === 'number' && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, 'imaskn works only with positive numbers');
if (r !== 0) {
s++;
}
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
this.words[this.length - 1] &= mask;
}
return this.strip();
};
// Return only lowers bits of number
BN.prototype.maskn = function maskn (bits) {
return this.clone().imaskn(bits);
};
// Add plain number `num` to `this`
BN.prototype.iaddn = function iaddn (num) {
assert(typeof num === 'number');
assert(num < 0x4000000);
if (num < 0) return this.isubn(-num);
// Possible sign change
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
// Add without checks
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn (num) {
this.words[0] += num;
// Carry
for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
this.words[i] -= 0x4000000;
if (i === this.length - 1) {
this.words[i + 1] = 1;
} else {
this.words[i + 1]++;
}
}
this.length = Math.max(this.length, i + 1);
return this;
};
// Subtract plain number `num` from `this`
BN.prototype.isubn = function isubn (num) {
assert(typeof num === 'number');
assert(num < 0x4000000);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else {
// Carry
for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 0x4000000;
this.words[i + 1] -= 1;
}
}
return this.strip();
};
BN.prototype.addn = function addn (num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn (num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs () {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs () {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
var len = num.length + shift;
var i;
this._expand(len);
var w;
var carry = 0;
for (i = 0; i < num.length; i++) {
w = (this.words[i + shift] | 0) + carry;
var right = (num.words[i] | 0) * mul;
w -= right & 0x3ffffff;
carry = (w >> 26) - ((right / 0x4000000) | 0);
this.words[i + shift] = w & 0x3ffffff;
}
for (; i < this.length - shift; i++) {
w = (this.words[i + shift] | 0) + carry;
carry = w >> 26;
this.words[i + shift] = w & 0x3ffffff;
}
if (carry === 0) return this.strip();
// Subtraction overflow
assert(carry === -1);
carry = 0;
for (i = 0; i < this.length; i++) {
w = -(this.words[i] | 0) + carry;
carry = w >> 26;
this.words[i] = w & 0x3ffffff;
}
this.negative = 1;
return this.strip();
};
BN.prototype._wordDiv = function _wordDiv (num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
// Normalize
var bhi = b.words[b.length - 1] | 0;
var bhiBits = this._countBits(bhi);
shift = 26 - bhiBits;
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
// Initialize quotient
var m = a.length - b.length;
var q;
if (mode !== 'mod') {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var i = 0; i < q.length; i++) {
q.words[i] = 0;
}
}
var diff = a.clone()._ishlnsubmul(b, 1, m);
if (diff.negative === 0) {
a = diff;
if (q) {
q.words[m] = 1;
}
}
for (var j = m - 1; j >= 0; j--) {
var qj = (a.words[b.length + j] | 0) * 0x4000000 +
(a.words[b.length + j - 1] | 0);
// NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
// (0x7ffffff)
qj = Math.min((qj / bhi) | 0, 0x3ffffff);
a._ishlnsubmul(b, qj, j);
while (a.negative !== 0) {
qj--;
a.negative = 0;
a._ishlnsubmul(b, 1, j);
if (!a.isZero()) {
a.negative ^= 1;
}
}
if (q) {
q.words[j] = qj;
}
}
if (q) {
q.strip();
}
a.strip();
// Denormalize
if (mode !== 'div' && shift !== 0) {
a.iushrn(shift);
}
return {
div: q || null,
mod: a
};
};
// NOTE: 1) `mode` can be set to `mod` to request mod only,
// to `div` to request div only, or be absent to
// request both div & mod
// 2) `positive` is true if unsigned mod is requested
BN.prototype.divmod = function divmod (num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) {
return {
div: new BN(0),
mod: new BN(0)
};
}
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== 'mod') {
div = res.div.neg();
}
if (mode !== 'div') {
mod = res.mod.neg();
if (positive && mod.negative !== 0) {
mod.iadd(num);
}
}
return {
div: div,
mod: mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== 'mod') {
div = res.div.neg();
}
return {
div: div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== 'div') {
mod = res.mod.neg();
if (positive && mod.negative !== 0) {
mod.isub(num);
}
}
return {
div: res.div,
mod: mod
};
}
// Both numbers are positive at this point
// Strip both numbers to approximate shift value
if (num.length > this.length || this.cmp(num) < 0) {
return {
div: new BN(0),
mod: this
};
}
// Very short reduction
if (num.length === 1) {
if (mode === 'div') {
return {
div: this.divn(num.words[0]),
mod: null
};
}
if (mode === 'mod') {
return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
}
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
// Find `this` / `num`
BN.prototype.div = function div (num) {
return this.divmod(num, 'div', false).div;
};
// Find `this` % `num`
BN.prototype.mod = function mod (num) {
return this.divmod(num, 'mod', false).mod;
};
BN.prototype.umod = function umod (num) {
return this.divmod(num, 'mod', true).mod;
};
// Find Round(`this` / `num`)
BN.prototype.divRound = function divRound (num) {
var dm = this.divmod(num);
// Fast case - exact division
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
// Round down
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
// Round up
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn (num) {
assert(num <= 0x3ffffff);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) {
acc = (p * acc + (this.words[i] | 0)) % num;
}
return acc;
};
// In-place division by number
BN.prototype.idivn = function idivn (num) {
assert(num <= 0x3ffffff);
var carry = 0;
for (var i = this.length - 1; i >= 0; i--) {
var w = (this.words[i] | 0) + carry * 0x4000000;
this.words[i] = (w / num) | 0;
carry = w % num;
}
return this.strip();
};
BN.prototype.divn = function divn (num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd (p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) {
x = x.umod(p);
} else {
x = x.clone();
}
// A * x + B * y = x
var A = new BN(1);
var B = new BN(0);
// C * x + D * y = y
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
if (i > 0) {
x.iushrn(i);
while (i-- > 0) {
if (A.isOdd() || B.isOdd()) {
A.iadd(yp);
B.isub(xp);
}
A.iushrn(1);
B.iushrn(1);
}
}
for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
if (j > 0) {
y.iushrn(j);
while (j-- > 0) {
if (C.isOdd() || D.isOdd()) {
C.iadd(yp);
D.isub(xp);
}
C.iushrn(1);
D.iushrn(1);
}
}
if (x.cmp(y) >= 0) {
x.isub(y);
A.isub(C);
B.isub(D);
} else {
y.isub(x);
C.isub(A);
D.isub(B);
}
}
return {
a: C,
b: D,
gcd: y.iushln(g)
};
};
// This is reduced incarnation of the binary EEA
// above, designated to invert members of the
// _prime_ fields F(p) at a maximal speed
BN.prototype._invmp = function _invmp (p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) {
a = a.umod(p);
} else {
a = a.clone();
}
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
if (i > 0) {
a.iushrn(i);
while (i-- > 0) {
if (x1.isOdd()) {
x1.iadd(delta);
}
x1.iushrn(1);
}
}
for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
if (j > 0) {
b.iushrn(j);
while (j-- > 0) {
if (x2.isOdd()) {
x2.iadd(delta);
}
x2.iushrn(1);
}
}
if (a.cmp(b) >= 0) {
a.isub(b);
x1.isub(x2);
} else {
b.isub(a);
x2.isub(x1);
}
}
var res;
if (a.cmpn(1) === 0) {
res = x1;
} else {
res = x2;
}
if (res.cmpn(0) < 0) {
res.iadd(p);
}
return res;
};
BN.prototype.gcd = function gcd (num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
// Remove common factor of two
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) {
a.iushrn(1);
}
while (b.isEven()) {
b.iushrn(1);
}
var r = a.cmp(b);
if (r < 0) {
// Swap `a` and `b` to make `a` always bigger than `b`
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) {
break;
}
a.isub(b);
} while (true);
return b.iushln(shift);
};
// Invert number in the field F(num)
BN.prototype.invm = function invm (num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven () {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd () {
return (this.words[0] & 1) === 1;
};
// And first word and num
BN.prototype.andln = function andln (num) {
return this.words[0] & num;
};
// Increment at the bit position in-line
BN.prototype.bincn = function bincn (bit) {
assert(typeof bit === 'number');
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
// Fast case: bit is much higher than all existing words
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
// Add bit and propagate, if needed
var carry = q;
for (var i = s; carry !== 0 && i < this.length; i++) {
var w = this.words[i] | 0;
w += carry;
carry = w >>> 26;
w &= 0x3ffffff;
this.words[i] = w;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return this;
};
BN.prototype.isZero = function isZero () {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn (num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) {
res = 1;
} else {
if (negative) {
num = -num;
}
assert(num <= 0x3ffffff, 'Number is too big');
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
// Compare two numbers and return:
// 1 - if `this` > `num`
// 0 - if `this` == `num`
// -1 - if `this` < `num`
BN.prototype.cmp = function cmp (num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
// Unsigned comparison
BN.prototype.ucmp = function ucmp (num) {
// At this point both numbers have the same sign
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var i = this.length - 1; i >= 0; i--) {
var a = this.words[i] | 0;
var b = num.words[i] | 0;
if (a === b) continue;
if (a < b) {
res = -1;
} else if (a > b) {
res = 1;
}
break;
}
return res;
};
BN.prototype.gtn = function gtn (num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt (num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten (num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte (num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn (num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt (num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten (num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte (num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn (num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq (num) {
return this.cmp(num) === 0;
};
//
// A reduce context, could be using montgomery or something better, depending
// on the `m` itself.
//
BN.red = function red (num) {
return new Red(num);
};
BN.prototype.toRed = function toRed (ctx) {
assert(!this.red, 'Already a number in reduction context');
assert(this.negative === 0, 'red works only with positives');
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed () {
assert(this.red, 'fromRed works only with numbers in reduction context');
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed (ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed (ctx) {
assert(!this.red, 'Already a number in reduction context');
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd (num) {
assert(this.red, 'redAdd works only with red numbers');
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd (num) {
assert(this.red, 'redIAdd works only with red numbers');
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub (num) {
assert(this.red, 'redSub works only with red numbers');
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub (num) {
assert(this.red, 'redISub works only with red numbers');
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl (num) {
assert(this.red, 'redShl works only with red numbers');
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul (num) {
assert(this.red, 'redMul works only with red numbers');
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul (num) {
assert(this.red, 'redMul works only with red numbers');
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr () {
assert(this.red, 'redSqr works only with red numbers');
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr () {
assert(this.red, 'redISqr works only with red numbers');
this.red._verify1(this);
return this.red.isqr(this);
};
// Square root over p
BN.prototype.redSqrt = function redSqrt () {
assert(this.red, 'redSqrt works only with red numbers');
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm () {
assert(this.red, 'redInvm works only with red numbers');
this.red._verify1(this);
return this.red.invm(this);
};
// Return negative clone of `this` % `red modulo`
BN.prototype.redNeg = function redNeg () {
assert(this.red, 'redNeg works only with red numbers');
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow (num) {
assert(this.red && !num.red, 'redPow(normalNum)');
this.red._verify1(this);
return this.red.pow(this, num);
};
// Prime numbers with efficient reduction
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
// Pseudo-Mersenne prime
function MPrime (name, p) {
// P = 2 ^ N - K
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp () {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce (num) {
// Assumes that `num` is less than `P^2`
// num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) {
r.isub(this.p);
} else {
r.strip();
}
return r;
};
MPrime.prototype.split = function split (input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK (num) {
return num.imul(this.k);
};
function K256 () {
MPrime.call(
this,
'k256',
'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
}
inherits(K256, MPrime);
K256.prototype.split = function split (input, output) {
// 256 = 9 * 26 + 22
var mask = 0x3fffff;
var outLen = Math.min(input.length, 9);
for (var i = 0; i < outLen; i++) {
output.words[i] = input.words[i];
}
output.length = outLen;
if (input.length <= 9) {
input.words[0] = 0;
input.length = 1;
return;
}
// Shift by 9 limbs
var prev = input.words[9];
output.words[output.length++] = prev & mask;
for (i = 10; i < input.length; i++) {
var next = input.words[i] | 0;
input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
prev = next;
}
prev >>>= 22;
input.words[i - 10] = prev;
if (prev === 0 && input.length > 10) {
input.length -= 10;
} else {
input.length -= 9;
}
};
K256.prototype.imulK = function imulK (num) {
// K = 0x1000003d1 = [ 0x40, 0x3d1 ]
num.words[num.length] = 0;
num.words[num.length + 1] = 0;
num.length += 2;
// bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
var lo = 0;
for (var i = 0; i < num.length; i++) {
var w = num.words[i] | 0;
lo += w * 0x3d1;
num.words[i] = lo & 0x3ffffff;
lo = w * 0x40 + ((lo / 0x4000000) | 0);
}
// Fast length reduction
if (num.words[num.length - 1] === 0) {
num.length--;
if (num.words[num.length - 1] === 0) {
num.length--;
}
}
return num;
};
function P224 () {
MPrime.call(
this,
'p224',
'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
}
inherits(P224, MPrime);
function P192 () {
MPrime.call(
this,
'p192',
'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
}
inherits(P192, MPrime);
function P25519 () {
// 2 ^ 255 - 19
MPrime.call(
this,
'25519',
'7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK (num) {
// K = 0x13
var carry = 0;
for (var i = 0; i < num.length; i++) {
var hi = (num.words[i] | 0) * 0x13 + carry;
var lo = hi & 0x3ffffff;
hi >>>= 26;
num.words[i] = lo;
carry = hi;
}
if (carry !== 0) {
num.words[num.length++] = carry;
}
return num;
};
// Exported mostly for testing purposes, use plain name instead
BN._prime = function prime (name) {
// Cached version of prime
if (primes[name]) return primes[name];
var prime;
if (name === 'k256') {
prime = new K256();
} else if (name === 'p224') {
prime = new P224();
} else if (name === 'p192') {
prime = new P192();
} else if (name === 'p25519') {
prime = new P25519();
} else {
throw new Error('Unknown prime ' + name);
}
primes[name] = prime;
return prime;
};
//
// Base reduction engine
//
function Red (m) {
if (typeof m === 'string') {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), 'modulus must be greater than 1');
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1 (a) {
assert(a.negative === 0, 'red works only with positives');
assert(a.red, 'red works only with red numbers');
};
Red.prototype._verify2 = function _verify2 (a, b) {
assert((a.negative | b.negative) === 0, 'red works only with positives');
assert(a.red && a.red === b.red,
'red works only with red numbers');
};
Red.prototype.imod = function imod (a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg (a) {
if (a.isZero()) {
return a.clone();
}
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add (a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) {
res.isub(this.m);
}
return res._forceRed(this);
};
Red.prototype.iadd = function iadd (a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) {
res.isub(this.m);
}
return res;
};
Red.prototype.sub = function sub (a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) {
res.iadd(this.m);
}
return res._forceRed(this);
};
Red.prototype.isub = function isub (a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) {
res.iadd(this.m);
}
return res;
};
Red.prototype.shl = function shl (a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul (a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul (a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr (a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr (a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt (a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
// Fast case
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
// Tonelli-Shanks algorithm (Totally unoptimized and slow)
//
// Find Q and S, that Q * 2 ^ S = (P - 1)
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
// Find quadratic non-residue
// NOTE: Max is such because of generalized Riemann hypothesis.
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) {
z.redIAdd(nOne);
}
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) {
tmp = tmp.redSqr();
}
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm (a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else {
return this.imod(inv);
}
};
Red.prototype.pow = function pow (a, num) {
if (num.isZero()) return new BN(1);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var i = 2; i < wnd.length; i++) {
wnd[i] = this.mul(wnd[i - 1], a);
}
var res = wnd[0];
var current = 0;
var currentLen = 0;
var start = num.bitLength() % 26;
if (start === 0) {
start = 26;
}
for (i = num.length - 1; i >= 0; i--) {
var word = num.words[i];
for (var j = start - 1; j >= 0; j--) {
var bit = (word >> j) & 1;
if (res !== wnd[0]) {
res = this.sqr(res);
}
if (bit === 0 && current === 0) {
currentLen = 0;
continue;
}
current <<= 1;
current |= bit;
currentLen++;
if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
res = this.mul(res, wnd[current]);
currentLen = 0;
current = 0;
}
start = 26;
}
return res;
};
Red.prototype.convertTo = function convertTo (num) {
var r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom (num) {
var res = num.clone();
res.red = null;
return res;
};
//
// Montgomery method engine
//
BN.mont = function mont (num) {
return new Mont(num);
};
function Mont (m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) {
this.shift += 26 - (this.shift % 26);
}
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo (num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom (num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul (a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) {
res = u.isub(this.m);
} else if (u.cmpn(0) < 0) {
res = u.iadd(this.m);
}
return res._forceRed(this);
};
Mont.prototype.mul = function mul (a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) {
res = u.isub(this.m);
} else if (u.cmpn(0) < 0) {
res = u.iadd(this.m);
}
return res._forceRed(this);
};
Mont.prototype.invm = function invm (a) {
// (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
var res = this.imod(a._invmp(this.m).mul(this.r2));
return res._forceRed(this);
};
})(typeof module === 'undefined' || module, this);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(92)(module)))
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
// 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.
module.exports = Stream;
var EE = __webpack_require__(32).EventEmitter;
var inherits = __webpack_require__(2);
inherits(Stream, EE);
Stream.Readable = __webpack_require__(522);
Stream.Writable = __webpack_require__(524);
Stream.Duplex = __webpack_require__(520);
Stream.Transform = __webpack_require__(523);
Stream.PassThrough = __webpack_require__(521);
// Backwards-compat with node 0.4.x
Stream.Stream = Stream;
// old-style streams. Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.
function Stream() {
EE.call(this);
}
Stream.prototype.pipe = function(dest, options) {
var source = this;
function ondata(chunk) {
if (dest.writable) {
if (false === dest.write(chunk) && source.pause) {
source.pause();
}
}
}
source.on('data', ondata);
function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}
dest.on('drain', ondrain);
// If the 'end' option is not supplied, dest.end() will be called when
// source gets the 'end' or 'close' events. Only dest.end() once.
if (!dest._isStdio && (!options || options.end !== false)) {
source.on('end', onend);
source.on('close', onclose);
}
var didOnEnd = false;
function onend() {
if (didOnEnd) return;
didOnEnd = true;
dest.end();
}
function onclose() {
if (didOnEnd) return;
didOnEnd = true;
if (typeof dest.destroy === 'function') dest.destroy();
}
// don't leave dangling pipes when there are errors.
function onerror(er) {
cleanup();
if (EE.listenerCount(this, 'error') === 0) {
throw er; // Unhandled stream error in pipe.
}
}
source.on('error', onerror);
dest.on('error', onerror);
// remove all the event listeners that were added.
function cleanup() {
source.removeListener('data', ondata);
dest.removeListener('drain', ondrain);
source.removeListener('end', onend);
source.removeListener('close', onclose);
source.removeListener('error', onerror);
dest.removeListener('error', onerror);
source.removeListener('end', cleanup);
source.removeListener('close', cleanup);
dest.removeListener('close', cleanup);
}
source.on('end', cleanup);
source.on('close', cleanup);
dest.on('close', cleanup);
dest.emit('pipe', source);
// Allow for unix-like usage: A.pipe(B).pipe(C)
return dest;
};
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.15 ToLength
var toInteger = __webpack_require__(39)
, min = Math.min;
module.exports = function(it){
return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.13 ToObject(argument)
var defined = __webpack_require__(27);
module.exports = function(it){
return Object(defined(it));
};
/***/ },
/* 15 */
/***/ function(module, exports) {
'use strict';
exports.command = function command(send, name) {
return function (opts, cb) {
if (typeof opts === 'function') {
cb = opts;
opts = {};
}
return send(name, null, opts, null, cb);
};
};
exports.argCommand = function argCommand(send, name) {
return function (arg, opts, cb) {
if (typeof opts === 'function') {
cb = opts;
opts = {};
}
return send(name, arg, opts, null, cb);
};
};
/***/ },
/* 16 */
/***/ function(module, exports) {
var hasOwnProperty = {}.hasOwnProperty;
module.exports = function(it, key){
return hasOwnProperty.call(it, key);
};
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {// 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.
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(arg) {
if (Array.isArray) {
return Array.isArray(arg);
}
return objectToString(arg) === '[object Array]';
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return (objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = Buffer.isBuffer;
function objectToString(o) {
return Object.prototype.toString.call(o);
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1).Buffer))
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var elliptic = exports;
elliptic.version = __webpack_require__(488).version;
elliptic.utils = __webpack_require__(472);
elliptic.rand = __webpack_require__(140);
elliptic.hmacDRBG = __webpack_require__(470);
elliptic.curve = __webpack_require__(88);
elliptic.curves = __webpack_require__(463);
// Protocols
elliptic.ec = __webpack_require__(464);
elliptic.eddsa = __webpack_require__(467);
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
var dP = __webpack_require__(10)
, createDesc = __webpack_require__(38);
module.exports = __webpack_require__(9) ? function(object, key, value){
return dP.f(object, key, createDesc(1, value));
} : function(object, key, value){
object[key] = value;
return object;
};
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(5)
, hide = __webpack_require__(19)
, has = __webpack_require__(16)
, SRC = __webpack_require__(47)('src')
, TO_STRING = 'toString'
, $toString = Function[TO_STRING]
, TPL = ('' + $toString).split(TO_STRING);
__webpack_require__(33).inspectSource = function(it){
return $toString.call(it);
};
(module.exports = function(O, key, val, safe){
var isFunction = typeof val == 'function';
if(isFunction)has(val, 'name') || hide(val, 'name', key);
if(O[key] === val)return;
if(isFunction)has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
if(O === global){
O[key] = val;
} else {
if(!safe){
delete O[key];
hide(O, key, val);
} else {
if(O[key])O[key] = val;
else hide(O, key, val);
}
}
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, TO_STRING, function toString(){
return typeof this == 'function' && this[SRC] || $toString.call(this);
});
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
var $export = __webpack_require__(0)
, fails = __webpack_require__(4)
, defined = __webpack_require__(27)
, quot = /"/g;
// B.2.3.2.1 CreateHTML(string, tag, attribute, value)
var createHTML = function(string, tag, attribute, value) {
var S = String(defined(string))
, p1 = '<' + tag;
if(attribute !== '')p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"';
return p1 + '>' + S + '</' + tag + '>';
};
module.exports = function(NAME, exec){
var O = {};
O[NAME] = exec(createHTML);
$export($export.P + $export.F * fails(function(){
var test = ''[NAME]('"');
return test !== test.toLowerCase() || test.split('"').length > 3;
}), 'String', O);
};
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(67)
, defined = __webpack_require__(27);
module.exports = function(it){
return IObject(defined(it));
};
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
var pIE = __webpack_require__(68)
, createDesc = __webpack_require__(38)
, toIObject = __webpack_require__(22)
, toPrimitive = __webpack_require__(31)
, has = __webpack_require__(16)
, IE8_DOM_DEFINE = __webpack_require__(159)
, gOPD = Object.getOwnPropertyDescriptor;
exports.f = __webpack_require__(9) ? gOPD : function getOwnPropertyDescriptor(O, P){
O = toIObject(O);
P = toPrimitive(P, true);
if(IE8_DOM_DEFINE)try {
return gOPD(O, P);
} catch(e){ /* empty */ }
if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
};
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
var has = __webpack_require__(16)
, toObject = __webpack_require__(14)
, IE_PROTO = __webpack_require__(109)('IE_PROTO')
, ObjectProto = Object.prototype;
module.exports = Object.getPrototypeOf || function(O){
O = toObject(O);
if(has(O, IE_PROTO))return O[IE_PROTO];
if(typeof O.constructor == 'function' && O instanceof O.constructor){
return O.constructor.prototype;
} return O instanceof Object ? ObjectProto : null;
};
/***/ },
/* 25 */
/***/ function(module, exports) {
module.exports = function(it){
if(typeof it != 'function')throw TypeError(it + ' is not a function!');
return it;
};
/***/ },
/* 26 */
/***/ function(module, exports) {
var toString = {}.toString;
module.exports = function(it){
return toString.call(it).slice(8, -1);
};
/***/ },
/* 27 */
/***/ function(module, exports) {
// 7.2.1 RequireObjectCoercible(argument)
module.exports = function(it){
if(it == undefined)throw TypeError("Can't call method on " + it);
return it;
};
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
var fails = __webpack_require__(4);
module.exports = function(method, arg){
return !!method && fails(function(){
arg ? method.call(null, function(){}, 1) : method.call(null);
});
};
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
// 4 -> Array#every
// 5 -> Array#find
// 6 -> Array#findIndex
var ctx = __webpack_require__(34)
, IObject = __webpack_require__(67)
, toObject = __webpack_require__(14)
, toLength = __webpack_require__(13)
, asc = __webpack_require__(271);
module.exports = function(TYPE, $create){
var IS_MAP = TYPE == 1
, IS_FILTER = TYPE == 2
, IS_SOME = TYPE == 3
, IS_EVERY = TYPE == 4
, IS_FIND_INDEX = TYPE == 6
, NO_HOLES = TYPE == 5 || IS_FIND_INDEX
, create = $create || asc;
return function($this, callbackfn, that){
var O = toObject($this)
, self = IObject(O)
, f = ctx(callbackfn, that, 3)
, length = toLength(self.length)
, index = 0
, result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined
, val, res;
for(;length > index; index++)if(NO_HOLES || index in self){
val = self[index];
res = f(val, index, O);
if(TYPE){
if(IS_MAP)result[index] = res; // map
else if(res)switch(TYPE){
case 3: return true; // some
case 5: return val; // find
case 6: return index; // findIndex
case 2: result.push(val); // filter
} else if(IS_EVERY)return false; // every
}
}
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
};
};
/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {
// most Object methods by ES6 should accept primitives
var $export = __webpack_require__(0)
, core = __webpack_require__(33)
, fails = __webpack_require__(4);
module.exports = function(KEY, exec){
var fn = (core.Object || {})[KEY] || Object[KEY]
, exp = {};
exp[KEY] = exec(fn);
$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
};
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = __webpack_require__(6);
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function(it, S){
if(!isObject(it))return it;
var fn, val;
if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
throw TypeError("Can't convert object to primitive value");
};
/***/ },
/* 32 */
/***/ function(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
}
throw TypeError('Uncaught, unspecified "error" event.');
}
}
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:
args = Array.prototype.slice.call(arguments, 1);
handler.apply(this, args);
}
} else if (isObject(handler)) {
args = Array.prototype.slice.call(arguments, 1);
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) {
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);
if (typeof console.trace === 'function') {
// not supported in IE 10
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 if (listeners) {
// 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.prototype.listenerCount = function(type) {
if (this._events) {
var evlistener = this._events[type];
if (isFunction(evlistener))
return 1;
else if (evlistener)
return evlistener.length;
}
return 0;
};
EventEmitter.listenerCount = function(emitter, type) {
return emitter.listenerCount(type);
};
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;
}
/***/ },
/* 33 */
/***/ function(module, exports) {
var core = module.exports = {version: '2.3.0'};
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {
// optional / simple context binding
var aFunction = __webpack_require__(25);
module.exports = function(fn, that, length){
aFunction(fn);
if(that === undefined)return fn;
switch(length){
case 1: return function(a){
return fn.call(that, a);
};
case 2: return function(a, b){
return fn.call(that, a, b);
};
case 3: return function(a, b, c){
return fn.call(that, a, b, c);
};
}
return function(/* ...args */){
return fn.apply(that, arguments);
};
};
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
var Map = __webpack_require__(175)
, $export = __webpack_require__(0)
, shared = __webpack_require__(86)('metadata')
, store = shared.store || (shared.store = new (__webpack_require__(178)));
var getOrCreateMetadataMap = function(target, targetKey, create){
var targetMetadata = store.get(target);
if(!targetMetadata){
if(!create)return undefined;
store.set(target, targetMetadata = new Map);
}
var keyMetadata = targetMetadata.get(targetKey);
if(!keyMetadata){
if(!create)return undefined;
targetMetadata.set(targetKey, keyMetadata = new Map);
} return keyMetadata;
};
var ordinaryHasOwnMetadata = function(MetadataKey, O, P){
var metadataMap = getOrCreateMetadataMap(O, P, false);
return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
};
var ordinaryGetOwnMetadata = function(MetadataKey, O, P){
var metadataMap = getOrCreateMetadataMap(O, P, false);
return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
};
var ordinaryDefineOwnMetadata = function(MetadataKey, MetadataValue, O, P){
getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
};
var ordinaryOwnMetadataKeys = function(target, targetKey){
var metadataMap = getOrCreateMetadataMap(target, targetKey, false)
, keys = [];
if(metadataMap)metadataMap.forEach(function(_, key){ keys.push(key); });
return keys;
};
var toMetaKey = function(it){
return it === undefined || typeof it == 'symbol' ? it : String(it);
};
var exp = function(O){
$export($export.S, 'Reflect', O);
};
module.exports = {
store: store,
map: getOrCreateMetadataMap,
has: ordinaryHasOwnMetadata,
get: ordinaryGetOwnMetadata,
set: ordinaryDefineOwnMetadata,
keys: ordinaryOwnMetadataKeys,
key: toMetaKey,
exp: exp
};
/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
if(__webpack_require__(9)){
var LIBRARY = __webpack_require__(42)
, global = __webpack_require__(5)
, fails = __webpack_require__(4)
, $export = __webpack_require__(0)
, $typed = __webpack_require__(87)
, $buffer = __webpack_require__(116)
, ctx = __webpack_require__(34)
, anInstance = __webpack_require__(40)
, propertyDesc = __webpack_require__(38)
, hide = __webpack_require__(19)
, redefineAll = __webpack_require__(54)
, isInteger = __webpack_require__(104)
, toInteger = __webpack_require__(39)
, toLength = __webpack_require__(13)
, toIndex = __webpack_require__(46)
, toPrimitive = __webpack_require__(31)
, has = __webpack_require__(16)
, same = __webpack_require__(172)
, classof = __webpack_require__(53)
, isObject = __webpack_require__(6)
, toObject = __webpack_require__(14)
, isArrayIter = __webpack_require__(102)
, create = __webpack_require__(43)
, getPrototypeOf = __webpack_require__(24)
, gOPN = __webpack_require__(44).f
, isIterable = __webpack_require__(278)
, getIterFn = __webpack_require__(118)
, uid = __webpack_require__(47)
, wks = __webpack_require__(7)
, createArrayMethod = __webpack_require__(29)
, createArrayIncludes = __webpack_require__(76)
, speciesConstructor = __webpack_require__(110)
, ArrayIterators = __webpack_require__(119)
, Iterators = __webpack_require__(41)
, $iterDetect = __webpack_require__(82)
, setSpecies = __webpack_require__(55)
, arrayFill = __webpack_require__(95)
, arrayCopyWithin = __webpack_require__(152)
, $DP = __webpack_require__(10)
, $GOPD = __webpack_require__(23)
, dP = $DP.f
, gOPD = $GOPD.f
, RangeError = global.RangeError
, TypeError = global.TypeError
, Uint8Array = global.Uint8Array
, ARRAY_BUFFER = 'ArrayBuffer'
, SHARED_BUFFER = 'Shared' + ARRAY_BUFFER
, BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'
, PROTOTYPE = 'prototype'
, ArrayProto = Array[PROTOTYPE]
, $ArrayBuffer = $buffer.ArrayBuffer
, $DataView = $buffer.DataView
, arrayForEach = createArrayMethod(0)
, arrayFilter = createArrayMethod(2)
, arraySome = createArrayMethod(3)
, arrayEvery = createArrayMethod(4)
, arrayFind = createArrayMethod(5)
, arrayFindIndex = createArrayMethod(6)
, arrayIncludes = createArrayIncludes(true)
, arrayIndexOf = createArrayIncludes(false)
, arrayValues = ArrayIterators.values
, arrayKeys = ArrayIterators.keys
, arrayEntries = ArrayIterators.entries
, arrayLastIndexOf = ArrayProto.lastIndexOf
, arrayReduce = ArrayProto.reduce
, arrayReduceRight = ArrayProto.reduceRight
, arrayJoin = ArrayProto.join
, arraySort = ArrayProto.sort
, arraySlice = ArrayProto.slice
, arrayToString = ArrayProto.toString
, arrayToLocaleString = ArrayProto.toLocaleString
, ITERATOR = wks('iterator')
, TAG = wks('toStringTag')
, TYPED_CONSTRUCTOR = uid('typed_constructor')
, DEF_CONSTRUCTOR = uid('def_constructor')
, ALL_CONSTRUCTORS = $typed.CONSTR
, TYPED_ARRAY = $typed.TYPED
, VIEW = $typed.VIEW
, WRONG_LENGTH = 'Wrong length!';
var $map = createArrayMethod(1, function(O, length){
return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
});
var LITTLE_ENDIAN = fails(function(){
return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
});
var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function(){
new Uint8Array(1).set({});
});
var strictToLength = function(it, SAME){
if(it === undefined)throw TypeError(WRONG_LENGTH);
var number = +it
, length = toLength(it);
if(SAME && !same(number, length))throw RangeError(WRONG_LENGTH);
return length;
};
var toOffset = function(it, BYTES){
var offset = toInteger(it);
if(offset < 0 || offset % BYTES)throw RangeError('Wrong offset!');
return offset;
};
var validate = function(it){
if(isObject(it) && TYPED_ARRAY in it)return it;
throw TypeError(it + ' is not a typed array!');
};
var allocate = function(C, length){
if(!(isObject(C) && TYPED_CONSTRUCTOR in C)){
throw TypeError('It is not a typed array constructor!');
} return new C(length);
};
var speciesFromList = function(O, list){
return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
};
var fromList = function(C, list){
var index = 0
, length = list.length
, result = allocate(C, length);
while(length > index)result[index] = list[index++];
return result;
};
var addGetter = function(it, key, internal){
dP(it, key, {get: function(){ return this._d[internal]; }});
};
var $from = function from(source /*, mapfn, thisArg */){
var O = toObject(source)
, aLen = arguments.length
, mapfn = aLen > 1 ? arguments[1] : undefined
, mapping = mapfn !== undefined
, iterFn = getIterFn(O)
, i, length, values, result, step, iterator;
if(iterFn != undefined && !isArrayIter(iterFn)){
for(iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++){
values.push(step.value);
} O = values;
}
if(mapping && aLen > 2)mapfn = ctx(mapfn, arguments[2], 2);
for(i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++){
result[i] = mapping ? mapfn(O[i], i) : O[i];
}
return result;
};
var $of = function of(/*...items*/){
var index = 0
, length = arguments.length
, result = allocate(this, length);
while(length > index)result[index] = arguments[index++];
return result;
};
// iOS Safari 6.x fails here
var TO_LOCALE_BUG = !!Uint8Array && fails(function(){ arrayToLocaleString.call(new Uint8Array(1)); });
var $toLocaleString = function toLocaleString(){
return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);
};
var proto = {
copyWithin: function copyWithin(target, start /*, end */){
return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
},
every: function every(callbackfn /*, thisArg */){
return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
},
fill: function fill(value /*, start, end */){ // eslint-disable-line no-unused-vars
return arrayFill.apply(validate(this), arguments);
},
filter: function filter(callbackfn /*, thisArg */){
return speciesFromList(this, arrayFilter(validate(this), callbackfn,
arguments.length > 1 ? arguments[1] : undefined));
},
find: function find(predicate /*, thisArg */){
return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
},
findIndex: function findIndex(predicate /*, thisArg */){
return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
},
forEach: function forEach(callbackfn /*, thisArg */){
arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
},
indexOf: function indexOf(searchElement /*, fromIndex */){
return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
},
includes: function includes(searchElement /*, fromIndex */){
return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
},
join: function join(separator){ // eslint-disable-line no-unused-vars
return arrayJoin.apply(validate(this), arguments);
},
lastIndexOf: function lastIndexOf(searchElement /*, fromIndex */){ // eslint-disable-line no-unused-vars
return arrayLastIndexOf.apply(validate(this), arguments);
},
map: function map(mapfn /*, thisArg */){
return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);
},
reduce: function reduce(callbackfn /*, initialValue */){ // eslint-disable-line no-unused-vars
return arrayReduce.apply(validate(this), arguments);
},
reduceRight: function reduceRight(callbackfn /*, initialValue */){ // eslint-disable-line no-unused-vars
return arrayReduceRight.apply(validate(this), arguments);
},
reverse: function reverse(){
var that = this
, length = validate(that).length
, middle = Math.floor(length / 2)
, index = 0
, value;
while(index < middle){
value = that[index];
that[index++] = that[--length];
that[length] = value;
} return that;
},
some: function some(callbackfn /*, thisArg */){
return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
},
sort: function sort(comparefn){
return arraySort.call(validate(this), comparefn);
},
subarray: function subarray(begin, end){
var O = validate(this)
, length = O.length
, $begin = toIndex(begin, length);
return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
O.buffer,
O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
toLength((end === undefined ? length : toIndex(end, length)) - $begin)
);
}
};
var $slice = function slice(start, end){
return speciesFromList(this, arraySlice.call(validate(this), start, end));
};
var $set = function set(arrayLike /*, offset */){
validate(this);
var offset = toOffset(arguments[1], 1)
, length = this.length
, src = toObject(arrayLike)
, len = toLength(src.length)
, index = 0;
if(len + offset > length)throw RangeError(WRONG_LENGTH);
while(index < len)this[offset + index] = src[index++];
};
var $iterators = {
entries: function entries(){
return arrayEntries.call(validate(this));
},
keys: function keys(){
return arrayKeys.call(validate(this));
},
values: function values(){
return arrayValues.call(validate(this));
}
};
var isTAIndex = function(target, key){
return isObject(target)
&& target[TYPED_ARRAY]
&& typeof key != 'symbol'
&& key in target
&& String(+key) == String(key);
};
var $getDesc = function getOwnPropertyDescriptor(target, key){
return isTAIndex(target, key = toPrimitive(key, true))
? propertyDesc(2, target[key])
: gOPD(target, key);
};
var $setDesc = function defineProperty(target, key, desc){
if(isTAIndex(target, key = toPrimitive(key, true))
&& isObject(desc)
&& has(desc, 'value')
&& !has(desc, 'get')
&& !has(desc, 'set')
// TODO: add validation descriptor w/o calling accessors
&& !desc.configurable
&& (!has(desc, 'writable') || desc.writable)
&& (!has(desc, 'enumerable') || desc.enumerable)
){
target[key] = desc.value;
return target;
} else return dP(target, key, desc);
};
if(!ALL_CONSTRUCTORS){
$GOPD.f = $getDesc;
$DP.f = $setDesc;
}
$export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {
getOwnPropertyDescriptor: $getDesc,
defineProperty: $setDesc
});
if(fails(function(){ arrayToString.call({}); })){
arrayToString = arrayToLocaleString = function toString(){
return arrayJoin.call(this);
}
}
var $TypedArrayPrototype$ = redefineAll({}, proto);
redefineAll($TypedArrayPrototype$, $iterators);
hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
redefineAll($TypedArrayPrototype$, {
slice: $slice,
set: $set,
constructor: function(){ /* noop */ },
toString: arrayToString,
toLocaleString: $toLocaleString
});
addGetter($TypedArrayPrototype$, 'buffer', 'b');
addGetter($TypedArrayPrototype$, 'byteOffset', 'o');
addGetter($TypedArrayPrototype$, 'byteLength', 'l');
addGetter($TypedArrayPrototype$, 'length', 'e');
dP($TypedArrayPrototype$, TAG, {
get: function(){ return this[TYPED_ARRAY]; }
});
module.exports = function(KEY, BYTES, wrapper, CLAMPED){
CLAMPED = !!CLAMPED;
var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array'
, ISNT_UINT8 = NAME != 'Uint8Array'
, GETTER = 'get' + KEY
, SETTER = 'set' + KEY
, TypedArray = global[NAME]
, Base = TypedArray || {}
, TAC = TypedArray && getPrototypeOf(TypedArray)
, FORCED = !TypedArray || !$typed.ABV
, O = {}
, TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];
var getter = function(that, index){
var data = that._d;
return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
};
var setter = function(that, index, value){
var data = that._d;
if(CLAMPED)value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;
data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
};
var addElement = function(that, index){
dP(that, index, {
get: function(){
return getter(this, index);
},
set: function(value){
return setter(this, index, value);
},
enumerable: true
});
};
if(FORCED){
TypedArray = wrapper(function(that, data, $offset, $length){
anInstance(that, TypedArray, NAME, '_d');
var index = 0
, offset = 0
, buffer, byteLength, length, klass;
if(!isObject(data)){
length = strictToLength(data, true)
byteLength = length * BYTES;
buffer = new $ArrayBuffer(byteLength);
} else if(data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER){
buffer = data;
offset = toOffset($offset, BYTES);
var $len = data.byteLength;
if($length === undefined){
if($len % BYTES)throw RangeError(WRONG_LENGTH);
byteLength = $len - offset;
if(byteLength < 0)throw RangeError(WRONG_LENGTH);
} else {
byteLength = toLength($length) * BYTES;
if(byteLength + offset > $len)throw RangeError(WRONG_LENGTH);
}
length = byteLength / BYTES;
} else if(TYPED_ARRAY in data){
return fromList(TypedArray, data);
} else {
return $from.call(TypedArray, data);
}
hide(that, '_d', {
b: buffer,
o: offset,
l: byteLength,
e: length,
v: new $DataView(buffer)
});
while(index < length)addElement(that, index++);
});
TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);
hide(TypedArrayPrototype, 'constructor', TypedArray);
} else if(!$iterDetect(function(iter){
// V8 works with iterators, but fails in many other cases
// https://code.google.com/p/v8/issues/detail?id=4552
new TypedArray(null); // eslint-disable-line no-new
new TypedArray(iter); // eslint-disable-line no-new
}, true)){
TypedArray = wrapper(function(that, data, $offset, $length){
anInstance(that, TypedArray, NAME);
var klass;
// `ws` module bug, temporarily remove validation length for Uint8Array
// https://github.com/websockets/ws/pull/645
if(!isObject(data))return new Base(strictToLength(data, ISNT_UINT8));
if(data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER){
return $length !== undefined
? new Base(data, toOffset($offset, BYTES), $length)
: $offset !== undefined
? new Base(data, toOffset($offset, BYTES))
: new Base(data);
}
if(TYPED_ARRAY in data)return fromList(TypedArray, data);
return $from.call(TypedArray, data);
});
arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function(key){
if(!(key in TypedArray))hide(TypedArray, key, Base[key]);
});
TypedArray[PROTOTYPE] = TypedArrayPrototype;
if(!LIBRARY)TypedArrayPrototype.constructor = TypedArray;
}
var $nativeIterator = TypedArrayPrototype[ITERATOR]
, CORRECT_ITER_NAME = !!$nativeIterator && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined)
, $iterator = $iterators.values;
hide(TypedArray, TYPED_CONSTRUCTOR, true);
hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
hide(TypedArrayPrototype, VIEW, true);
hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);
if(CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)){
dP(TypedArrayPrototype, TAG, {
get: function(){ return NAME; }
});
}
O[NAME] = TypedArray;
$export($export.G + $export.W + $export.F * (TypedArray != Base), O);
$export($export.S, NAME, {
BYTES_PER_ELEMENT: BYTES,
from: $from,
of: $of
});
if(!(BYTES_PER_ELEMENT in TypedArrayPrototype))hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);
$export($export.P, NAME, proto);
setSpecies(NAME);
$export($export.P + $export.F * FORCED_SET, NAME, {set: $set});
$export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);
$export($export.P + $export.F * (TypedArrayPrototype.toString != arrayToString), NAME, {toString: arrayToString});
$export($export.P + $export.F * fails(function(){
new TypedArray(1).slice();
}), NAME, {slice: $slice});
$export($export.P + $export.F * (fails(function(){
return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString()
}) || !fails(function(){
TypedArrayPrototype.toLocaleString.call([1, 2]);
})), NAME, {toLocaleString: $toLocaleString});
Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
if(!LIBRARY && !CORRECT_ITER_NAME)hide(TypedArrayPrototype, ITERATOR, $iterator);
};
} else module.exports = function(){ /* empty */ };
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
var META = __webpack_require__(47)('meta')
, isObject = __webpack_require__(6)
, has = __webpack_require__(16)
, setDesc = __webpack_require__(10).f
, id = 0;
var isExtensible = Object.isExtensible || function(){
return true;
};
var FREEZE = !__webpack_require__(4)(function(){
return isExtensible(Object.preventExtensions({}));
});
var setMeta = function(it){
setDesc(it, META, {value: {
i: 'O' + ++id, // object ID
w: {}
gitextract_9var7xdy/ ├── LICENSE ├── README.md ├── contract/ │ ├── SimpleStorage.sol │ └── SimpleStorageBytecode.txt ├── ipfs/ │ └── ipfs.js ├── storage/ │ └── style.css └── storage.html
SYMBOL INDEX (866 symbols across 1 files)
FILE: ipfs/ipfs.js
function __webpack_require__ (line 7) | function __webpack_require__(moduleId) {
function typedArraySupport (line 147) | function typedArraySupport () {
function kMaxLength (line 159) | function kMaxLength () {
function createBuffer (line 165) | function createBuffer (that, length) {
function Buffer (line 194) | function Buffer (arg, encodingOrOffset, length) {
function from (line 219) | function from (that, value, encodingOrOffset, length) {
function assertSize (line 260) | function assertSize (size) {
function alloc (line 266) | function alloc (that, size, fill, encoding) {
function allocUnsafe (line 290) | function allocUnsafe (that, size) {
function fromString (line 314) | function fromString (that, string, encoding) {
function fromArrayLike (line 330) | function fromArrayLike (that, array) {
function fromArrayBuffer (line 339) | function fromArrayBuffer (that, array, byteOffset, length) {
function fromObject (line 367) | function fromObject (that, obj) {
function checked (line 397) | function checked (length) {
function SlowBuffer (line 407) | function SlowBuffer (length) {
function byteLength (line 490) | function byteLength (string, encoding) {
function slowToString (line 537) | function slowToString (encoding, start, end) {
function swap (line 610) | function swap (b, n, m) {
function arrayIndexOf (line 721) | function arrayIndexOf (arr, val, byteOffset, encoding) {
function hexWrite (line 803) | function hexWrite (buf, string, offset, length) {
function utf8Write (line 830) | function utf8Write (buf, string, offset, length) {
function asciiWrite (line 834) | function asciiWrite (buf, string, offset, length) {
function binaryWrite (line 838) | function binaryWrite (buf, string, offset, length) {
function base64Write (line 842) | function base64Write (buf, string, offset, length) {
function ucs2Write (line 846) | function ucs2Write (buf, string, offset, length) {
function base64Slice (line 928) | function base64Slice (buf, start, end) {
function utf8Slice (line 936) | function utf8Slice (buf, start, end) {
function decodeCodePointsArray (line 1014) | function decodeCodePointsArray (codePoints) {
function asciiSlice (line 1032) | function asciiSlice (buf, start, end) {
function binarySlice (line 1042) | function binarySlice (buf, start, end) {
function hexSlice (line 1052) | function hexSlice (buf, start, end) {
function utf16leSlice (line 1065) | function utf16leSlice (buf, start, end) {
function checkOffset (line 1113) | function checkOffset (offset, ext, length) {
function checkInt (line 1274) | function checkInt (buf, value, offset, ext, max, min) {
function objectWriteUInt16 (line 1327) | function objectWriteUInt16 (buf, value, offset, littleEndian) {
function objectWriteUInt32 (line 1361) | function objectWriteUInt32 (buf, value, offset, littleEndian) {
function checkIEEE754 (line 1511) | function checkIEEE754 (buf, value, offset, ext, max, min) {
function writeFloat (line 1516) | function writeFloat (buf, value, offset, littleEndian, noAssert) {
function writeDouble (line 1532) | function writeDouble (buf, value, offset, littleEndian, noAssert) {
function base64clean (line 1665) | function base64clean (str) {
function stringtrim (line 1677) | function stringtrim (str) {
function toHex (line 1682) | function toHex (n) {
function utf8ToBytes (line 1687) | function utf8ToBytes (string, units) {
function asciiToBytes (line 1767) | function asciiToBytes (str) {
function utf16leToBytes (line 1776) | function utf16leToBytes (str, units) {
function base64ToBytes (line 1792) | function base64ToBytes (str) {
function blitBuffer (line 1796) | function blitBuffer (src, dst, offset, length) {
function isnan (line 1804) | function isnan (val) {
function cleanUpNextTick (line 1906) | function cleanUpNextTick() {
function drainQueue (line 1918) | function drainQueue() {
function Item (line 1956) | function Item(fun, array) {
function noop (line 1970) | function noop() {}
function assert (line 2029) | function assert (val, msg) {
function inherits (line 2035) | function inherits (ctor, superCtor) {
function BN (line 2045) | function BN (number, base, endian) {
function parseHex (line 2206) | function parseHex (str, start, end) {
function parseBase (line 2260) | function parseBase (str, start, end, mul) {
function toBitArray (line 2647) | function toBitArray (num) {
function smallMulTo (line 3012) | function smallMulTo (self, num, out) {
function bigMulTo (line 3634) | function bigMulTo (self, num, out) {
function jumboMulTo (line 3675) | function jumboMulTo (self, num, out) {
function FFTM (line 3699) | function FFTM (x, y) {
function MPrime (line 4955) | function MPrime (name, p) {
function K256 (line 5005) | function K256 () {
function P224 (line 5072) | function P224 () {
function P192 (line 5080) | function P192 () {
function P25519 (line 5088) | function P25519 () {
function Red (line 5139) | function Red (m) {
function Mont (line 5373) | function Mont (m) {
function Stream (line 5492) | function Stream() {
function ondata (line 5499) | function ondata(chunk) {
function ondrain (line 5509) | function ondrain() {
function onend (line 5525) | function onend() {
function onclose (line 5533) | function onclose() {
function onerror (line 5541) | function onerror(er) {
function cleanup (line 5552) | function cleanup() {
function isArray (line 5664) | function isArray(arg) {
function isBoolean (line 5672) | function isBoolean(arg) {
function isNull (line 5677) | function isNull(arg) {
function isNullOrUndefined (line 5682) | function isNullOrUndefined(arg) {
function isNumber (line 5687) | function isNumber(arg) {
function isString (line 5692) | function isString(arg) {
function isSymbol (line 5697) | function isSymbol(arg) {
function isUndefined (line 5702) | function isUndefined(arg) {
function isRegExp (line 5707) | function isRegExp(re) {
function isObject (line 5712) | function isObject(arg) {
function isDate (line 5717) | function isDate(d) {
function isError (line 5722) | function isError(e) {
function isFunction (line 5727) | function isFunction(arg) {
function isPrimitive (line 5732) | function isPrimitive(arg) {
function objectToString (line 5744) | function objectToString(o) {
function EventEmitter (line 6041) | function EventEmitter() {
function g (line 6175) | function g() {
function isFunction (line 6303) | function isFunction(arg) {
function isNumber (line 6307) | function isNumber(arg) {
function isObject (line 6311) | function isObject(arg) {
function isUndefined (line 6315) | function isUndefined(arg) {
function Duplex (line 7153) | function Duplex(options) {
function onend (line 7170) | function onend() {
function onEndNT (line 7180) | function onEndNT(self) {
function forEach (line 7184) | function forEach(xs, f) {
function assertEncoding (line 7226) | function assertEncoding(encoding) {
function passThroughWrite (line 7402) | function passThroughWrite(buffer) {
function utf16DetectIncompleteChar (line 7406) | function utf16DetectIncompleteChar(buffer) {
function base64DetectIncompleteChar (line 7411) | function base64DetectIncompleteChar(buffer) {
function CipherBase (line 7426) | function CipherBase (hashMode) {
function HashNoConstructor (line 7641) | function HashNoConstructor(hash) {
function Hash (line 7662) | function Hash(hash) {
function normalizeArray (line 7717) | function normalizeArray(parts, allowAboveRoot) {
function trim (line 7826) | function trim(arr) {
function filter (line 7899) | function filter (xs, f) {
function nextTick (line 7933) | function nextTick(fn) {
function Hash (line 7951) | function Hash (blockSize, finalSize) {
function Duplex (line 8065) | function Duplex(options) {
function onend (line 8082) | function onend() {
function onEndNT (line 8092) | function onEndNT(self) {
function forEach (line 8096) | function forEach(xs, f) {
function assert (line 9095) | function assert(val, msg) {
function oldBrowser (line 9112) | function oldBrowser () {
function randomBytes (line 9124) | function randomBytes (size, cb) {
function deprecated (line 9230) | function deprecated() {
function inspect (line 9277) | function inspect(obj, opts) {
function stylizeWithColor (line 9335) | function stylizeWithColor(str, styleType) {
function stylizeNoColor (line 9347) | function stylizeNoColor(str, styleType) {
function arrayToHash (line 9352) | function arrayToHash(array) {
function formatValue (line 9363) | function formatValue(ctx, value, recurseTimes) {
function formatPrimitive (line 9476) | function formatPrimitive(ctx, value) {
function formatError (line 9495) | function formatError(value) {
function formatArray (line 9500) | function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
function formatProperty (line 9520) | function formatProperty(ctx, value, recurseTimes, visibleKeys, key, arra...
function reduceToSingleString (line 9579) | function reduceToSingleString(output, base, braces) {
function isArray (line 9602) | function isArray(ar) {
function isBoolean (line 9607) | function isBoolean(arg) {
function isNull (line 9612) | function isNull(arg) {
function isNullOrUndefined (line 9617) | function isNullOrUndefined(arg) {
function isNumber (line 9622) | function isNumber(arg) {
function isString (line 9627) | function isString(arg) {
function isSymbol (line 9632) | function isSymbol(arg) {
function isUndefined (line 9637) | function isUndefined(arg) {
function isRegExp (line 9642) | function isRegExp(re) {
function isObject (line 9647) | function isObject(arg) {
function isDate (line 9652) | function isDate(d) {
function isError (line 9657) | function isError(e) {
function isFunction (line 9663) | function isFunction(arg) {
function isPrimitive (line 9668) | function isPrimitive(arg) {
function objectToString (line 9680) | function objectToString(o) {
function pad (line 9685) | function pad(n) {
function timestamp (line 9694) | function timestamp() {
function hasOwnProperty (line 9736) | function hasOwnProperty(obj, prop) {
function fixup_uint32 (line 9768) | function fixup_uint32 (x) {
function scrub_vec (line 9773) | function scrub_vec (v) {
function Global (line 9780) | function Global () {
function bufferToArray (line 9843) | function bufferToArray (buf) {
function AES (line 9852) | function AES (key) {
function incr32 (line 10124) | function incr32 (iv) {
function getBlock (line 10139) | function getBlock (self) {
function EVP_BytesToKey (line 10493) | function EVP_BytesToKey (password, salt, keyLen, ivLen) {
function parseKeys (line 10573) | function parseKeys (buffer) {
function decrypt (line 10653) | function decrypt (data, password) {
function Timeout (line 10691) | function Timeout(id, clearFn) {
function getCiphers (line 10789) | function getCiphers () {
function blind (line 10802) | function blind(priv) {
function crt (line 10811) | function crt(msg, priv) {
function getr (line 10831) | function getr(priv) {
function Hmac (line 11604) | function Hmac(alg, key) {
function arrayMap (line 11710) | function arrayMap(array, iteratee) {
function baseMap (line 11738) | function baseMap(collection, iteratee) {
function baseProperty (line 11755) | function baseProperty(key) {
function map (line 11817) | function map(collection, iteratee) {
function isArrayLike (line 11874) | function isArrayLike(value) {
function isFunction (line 11896) | function isFunction(value) {
function isLength (line 11931) | function isLength(value) {
function isObject (line 11960) | function isObject(value) {
function charSet (line 12003) | function charSet (s) {
function filter (line 12014) | function filter (pattern, options) {
function ext (line 12021) | function ext (a, b) {
function minimatch (line 12055) | function minimatch (p, pattern, options) {
function Minimatch (line 12073) | function Minimatch (pattern, options) {
function make (line 12105) | function make () {
function parseNegate (line 12161) | function parseNegate () {
function braceExpand (line 12196) | function braceExpand (pattern, options) {
function parse (line 12234) | function parse (pattern, isSub) {
function makeRe (line 12602) | function makeRe () {
function match (line 12660) | function match (f, partial) {
function globUnescape (line 12877) | function globUnescape (s) {
function regExpEscape (line 12881) | function regExpEscape (s) {
function Protocols (line 12896) | function Protocols(proto) {
function p (line 12937) | function p(code, size, name) {
function posix (line 12947) | function posix(path) {
function win32 (line 12951) | function win32(path) {
function TransformState (line 13027) | function TransformState(stream) {
function afterTransform (line 13039) | function afterTransform(stream, er, data) {
function Transform (line 13061) | function Transform(options) {
function done (line 13138) | function done(stream, er) {
function nop (line 13205) | function nop() {}
function WriteReq (line 13207) | function WriteReq(chunk, encoding, cb) {
function WritableState (line 13215) | function WritableState(options, stream) {
function Writable (line 13332) | function Writable(options) {
function writeAfterEnd (line 13358) | function writeAfterEnd(stream, cb) {
function validChunk (line 13370) | function validChunk(stream, state, chunk, cb) {
function decodeChunk (line 13426) | function decodeChunk(state, chunk, encoding) {
function writeOrBuffer (line 13436) | function writeOrBuffer(stream, state, chunk, encoding, cb) {
function doWrite (line 13464) | function doWrite(stream, state, writev, len, chunk, encoding, cb) {
function onwriteError (line 13473) | function onwriteError(stream, state, sync, er, cb) {
function onwriteStateUpdate (line 13481) | function onwriteStateUpdate(state) {
function onwrite (line 13488) | function onwrite(stream, er) {
function afterWrite (line 13513) | function afterWrite(stream, state, finished, cb) {
function onwriteDrain (line 13523) | function onwriteDrain(stream, state) {
function clearBuffer (line 13531) | function clearBuffer(stream, state) {
function needFinish (line 13614) | function needFinish(state) {
function prefinish (line 13618) | function prefinish(stream, state) {
function finishMaybe (line 13625) | function finishMaybe(stream, state) {
function endWritable (line 13639) | function endWritable(stream, state, cb) {
function CorkedRequest (line 13651) | function CorkedRequest(state) {
function extend (line 13694) | function extend() {
function DecoderBuffer (line 13725) | function DecoderBuffer(base, options) {
function EncoderBuffer (line 13785) | function EncoderBuffer(value, reporter) {
function DERDecoder (line 13877) | function DERDecoder(entity) {
function DERNode (line 13897) | function DERNode(parent) {
function derDecodeTag (line 14125) | function derDecodeTag(buf, fail) {
function derDecodeLen (line 14158) | function derDecodeLen(buf, primitive, fail) {
function DEREncoder (line 14204) | function DEREncoder(entity) {
function DERNode (line 14221) | function DERNode(parent) {
function two (line 14335) | function two(num) {
function encodeTag (line 14463) | function encodeTag(tag, primitive, cls, reporter) {
function replacer (line 14578) | function replacer(key, value) {
function truncate (line 14591) | function truncate(s, n) {
function getMessage (line 14599) | function getMessage(self) {
function fail (line 14616) | function fail(actual, expected, message, operator, stackStartFunction) {
function ok (line 14636) | function ok(value, message) {
function _deepEqual (line 14667) | function _deepEqual(actual, expected) {
function isArguments (line 14712) | function isArguments(object) {
function objEquiv (line 14716) | function objEquiv(a, b) {
function expectedException (line 14785) | function expectedException(actual, expected) {
function _throws (line 14801) | function _throws(shouldThrow, block, expected, message) {
function Rand (line 15928) | function Rand(rand) {
function StreamCipher (line 15990) | function StreamCipher (mode, key, iv, decrypt) {
function xorTest (line 16067) | function xorTest (a, b) {
function encryptStart (line 16133) | function encryptStart (self, data, decrypt) {
function encryptByte (line 16147) | function encryptByte (self, byteParam, decrypt) {
function shiftIn (line 16171) | function shiftIn (buffer, value) {
function encryptByte (line 16188) | function encryptByte (self, byteParam, decrypt) {
function getBlock (line 16224) | function getBlock (self) {
function StreamCipher (line 16251) | function StreamCipher (mode, key, iv, decrypt) {
function core_md5 (line 17184) | function core_md5(x, len)
function md5_cmn (line 17282) | function md5_cmn(q, a, b, x, s, t)
function md5_ff (line 17286) | function md5_ff(a, b, c, d, x, s, t)
function md5_gg (line 17290) | function md5_gg(a, b, c, d, x, s, t)
function md5_hh (line 17294) | function md5_hh(a, b, c, d, x, s, t)
function md5_ii (line 17298) | function md5_ii(a, b, c, d, x, s, t)
function safe_add (line 17307) | function safe_add(x, y)
function bit_rol (line 17317) | function bit_rol(num, cnt)
function _getPrimes (line 17447) | function _getPrimes() {
function simpleSieve (line 17469) | function simpleSieve(p) {
function fermatTest (line 17484) | function fermatTest(p) {
function findPrime (line 17489) | function findPrime(bits, gen) {
function ownProp (line 17547) | function ownProp (obj, field) {
function alphasorti (line 17556) | function alphasorti (a, b) {
function alphasort (line 17560) | function alphasort (a, b) {
function setupIgnores (line 17564) | function setupIgnores (self, options) {
function ignoreMap (line 17576) | function ignoreMap (pattern) {
function setopts (line 17589) | function setopts (self, pattern, options) {
function finish (line 17653) | function finish (self) {
function mark (line 17710) | function mark (self, p) {
function makeAbs (line 17734) | function makeAbs (self, f) {
function isIgnored (line 17755) | function isIgnored (self, path) {
function childrenIgnored (line 17764) | function childrenIgnored (self, path) {
function glob (line 17842) | function glob (pattern, options, cb) {
function extend (line 17861) | function extend (origin, add) {
function Glob (line 17893) | function Glob (pattern, options, cb) {
function next (line 17989) | function next () {
function lstatcb_ (line 18280) | function lstatcb_ (er, lstat) {
function readdirCb (line 18322) | function readdirCb (self, abs, cb) {
function lstatcb_ (line 18525) | function lstatcb_ (er, lstat) {
function baseTimes (line 18598) | function baseTimes(n, iteratee) {
function isIndex (line 18616) | function isIndex(value, length) {
function baseForOwn (line 18672) | function baseForOwn(object, iteratee) {
function baseHas (line 18684) | function baseHas(object, key) {
function baseKeys (line 18700) | function baseKeys(object) {
function baseProperty (line 18711) | function baseProperty(key) {
function createBaseEach (line 18725) | function createBaseEach(eachFunc, fromRight) {
function createBaseFor (line 18753) | function createBaseFor(fromRight) {
function getPrototype (line 18790) | function getPrototype(value) {
function indexKeys (line 18802) | function indexKeys(object) {
function isPrototype (line 18818) | function isPrototype(value) {
function isArguments (line 18843) | function isArguments(value) {
function isArrayLike (line 18901) | function isArrayLike(value) {
function isArrayLikeObject (line 18930) | function isArrayLikeObject(value) {
function isFunction (line 18952) | function isFunction(value) {
function isLength (line 18987) | function isLength(value) {
function isObject (line 19016) | function isObject(value) {
function isObjectLike (line 19045) | function isObjectLike(value) {
function isString (line 19067) | function isString(value) {
function keys (line 19100) | function keys(object) {
function arrayMap (line 19259) | function arrayMap(array, iteratee) {
function arraySome (line 19280) | function arraySome(array, predicate) {
function baseTimes (line 19301) | function baseTimes(n, iteratee) {
function baseToPairs (line 19320) | function baseToPairs(object, props) {
function checkGlobal (line 19333) | function checkGlobal(value) {
function isHostObject (line 19344) | function isHostObject(value) {
function isIndex (line 19364) | function isIndex(value, length) {
function mapToArray (line 19377) | function mapToArray(map) {
function setToArray (line 19394) | function setToArray(set) {
function Hash (line 19463) | function Hash() {}
function hashDelete (line 19473) | function hashDelete(hash, key) {
function hashGet (line 19485) | function hashGet(hash, key) {
function hashHas (line 19501) | function hashHas(hash, key) {
function hashSet (line 19513) | function hashSet(hash, key, value) {
function MapCache (line 19527) | function MapCache(values) {
function mapClear (line 19545) | function mapClear() {
function mapDelete (line 19562) | function mapDelete(key) {
function mapGet (line 19579) | function mapGet(key) {
function mapHas (line 19596) | function mapHas(key) {
function mapSet (line 19614) | function mapSet(key, value) {
function Stack (line 19640) | function Stack(values) {
function stackClear (line 19658) | function stackClear() {
function stackDelete (line 19671) | function stackDelete(key) {
function stackGet (line 19687) | function stackGet(key) {
function stackHas (line 19703) | function stackHas(key) {
function stackSet (line 19720) | function stackSet(key, value) {
function assocDelete (line 19754) | function assocDelete(array, key) {
function assocGet (line 19776) | function assocGet(array, key) {
function assocHas (line 19789) | function assocHas(array, key) {
function assocIndexOf (line 19801) | function assocIndexOf(array, key) {
function assocSet (line 19819) | function assocSet(array, key, value) {
function baseCastPath (line 19835) | function baseCastPath(value) {
function baseGet (line 19847) | function baseGet(object, path) {
function baseHas (line 19867) | function baseHas(object, key) {
function baseHasIn (line 19883) | function baseHasIn(object, key) {
function baseIsEqual (line 19902) | function baseIsEqual(value, other, customizer, bitmask, stack) {
function baseIsEqualDeep (line 19927) | function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, ...
function baseIsMatch (line 19980) | function baseIsMatch(object, source, matchData, customizer) {
function baseIteratee (line 20031) | function baseIteratee(value) {
function baseKeys (line 20056) | function baseKeys(object) {
function baseMatches (line 20067) | function baseMatches(source) {
function baseMatchesProperty (line 20085) | function baseMatchesProperty(path, srcValue) {
function baseProperty (line 20104) | function baseProperty(key) {
function basePropertyDeep (line 20117) | function basePropertyDeep(path) {
function equalArrays (line 20137) | function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
function equalByTag (line 20211) | function equalByTag(object, other, tag, equalFunc, customizer, bitmask, ...
function equalObjects (line 20292) | function equalObjects(object, other, equalFunc, customizer, bitmask, sta...
function getMatchData (line 20374) | function getMatchData(object) {
function getNative (line 20392) | function getNative(object, key) {
function getPrototype (line 20404) | function getPrototype(value) {
function getTag (line 20415) | function getTag(value) {
function hasPath (line 20453) | function hasPath(object, path, hasFunc) {
function indexKeys (line 20483) | function indexKeys(object) {
function isKey (line 20500) | function isKey(value, object) {
function isKeyable (line 20517) | function isKeyable(value) {
function isPrototype (line 20530) | function isPrototype(value) {
function isStrictComparable (line 20545) | function isStrictComparable(value) {
function matchesStrictComparable (line 20558) | function matchesStrictComparable(key, srcValue) {
function toSource (line 20575) | function toSource(func) {
function eq (line 20619) | function eq(value, other) {
function isArguments (line 20641) | function isArguments(value) {
function isArrayLike (line 20699) | function isArrayLike(value) {
function isArrayLikeObject (line 20728) | function isArrayLikeObject(value) {
function isFunction (line 20750) | function isFunction(value) {
function isLength (line 20785) | function isLength(value) {
function isObject (line 20815) | function isObject(value) {
function isObjectLike (line 20844) | function isObjectLike(value) {
function isNative (line 20866) | function isNative(value) {
function isString (line 20892) | function isString(value) {
function isSymbol (line 20915) | function isSymbol(value) {
function isTypedArray (line 20938) | function isTypedArray(value) {
function get (line 20968) | function get(object, path, defaultValue) {
function hasIn (line 20999) | function hasIn(object, path) {
function keys (line 21031) | function keys(object) {
function toPairs (line 21074) | function toPairs(object) {
function identity (line 21094) | function identity(value) {
function property (line 21120) | function property(path) {
function MillerRabin (line 21135) | function MillerRabin(rand) {
function parse (line 21259) | function parse (opts) {
function serialize (line 21276) | function serialize (opts) {
function once (line 21299) | function once (fn) {
function pbkdf2 (line 21369) | function pbkdf2 (password, salt, iterations, keylen, digest, callback) {
function pbkdf2Sync (line 21386) | function pbkdf2Sync (password, salt, iterations, keylen, digest) {
function i2ops (line 21463) | function i2ops(c) {
function withPublic (line 21475) | function withPublic(paddedMsg, key) {
function Duplex (line 21555) | function Duplex(options) {
function onend (line 21576) | function onend() {
function forEach (line 21587) | function forEach (xs, f) {
function Sha256 (line 21631) | function Sha256 () {
function ch (line 21654) | function ch (x, y, z) {
function maj (line 21658) | function maj (x, y, z) {
function sigma0 (line 21662) | function sigma0 (x) {
function sigma1 (line 21666) | function sigma1 (x) {
function gamma0 (line 21670) | function gamma0 (x) {
function gamma1 (line 21674) | function gamma1 (x) {
function Sha512 (line 21788) | function Sha512 () {
function Ch (line 21819) | function Ch (x, y, z) {
function maj (line 21823) | function maj (x, y, z) {
function sigma0 (line 21827) | function sigma0 (x, xl) {
function sigma1 (line 21831) | function sigma1 (x, xl) {
function Gamma0 (line 21835) | function Gamma0 (x, xl) {
function Gamma0l (line 21839) | function Gamma0l (x, xl) {
function Gamma1 (line 21843) | function Gamma1 (x, xl) {
function Gamma1l (line 21847) | function Gamma1l (x, xl) {
function getCarry (line 21851) | function getCarry (a, b) {
function writeInt64BE (line 21981) | function writeInt64BE (h, l, offset) {
function PassThrough (line 22023) | function PassThrough(options) {
function ReadableState (line 22096) | function ReadableState(options, stream) {
function Readable (line 22163) | function Readable(options) {
function readableAddChunk (line 22206) | function readableAddChunk(stream, state, chunk, encoding, addToFront) {
function needMoreData (line 22261) | function needMoreData(state) {
function computeNewHighWaterMark (line 22275) | function computeNewHighWaterMark(n) {
function howMuchToRead (line 22291) | function howMuchToRead(n, state) {
function chunkInvalid (line 22423) | function chunkInvalid(state, chunk) {
function onEofChunk (line 22431) | function onEofChunk(stream, state) {
function emitReadable (line 22449) | function emitReadable(stream) {
function emitReadable_ (line 22459) | function emitReadable_(stream) {
function maybeReadMore (line 22471) | function maybeReadMore(stream, state) {
function maybeReadMore_ (line 22478) | function maybeReadMore_(stream, state) {
function onunpipe (line 22522) | function onunpipe(readable) {
function onend (line 22529) | function onend() {
function cleanup (line 22542) | function cleanup() {
function ondata (line 22565) | function ondata(chunk) {
function onerror (line 22582) | function onerror(er) {
function onclose (line 22593) | function onclose() {
function onfinish (line 22598) | function onfinish() {
function unpipe (line 22605) | function unpipe() {
function pipeOnDrain (line 22622) | function pipeOnDrain(src) {
function nReadingNextTick (line 22712) | function nReadingNextTick(self) {
function resume (line 22729) | function resume(stream, state) {
function resume_ (line 22736) | function resume_(stream, state) {
function flow (line 22758) | function flow(stream) {
function fromList (line 22836) | function fromList(n, state) {
function endReadable (line 22883) | function endReadable(stream) {
function endReadableNT (line 22896) | function endReadableNT(state, stream) {
function forEach (line 22905) | function forEach(xs, f) {
function indexOf (line 22911) | function indexOf(xs, x) {
function checkTypeSupport (line 23021) | function checkTypeSupport (type) {
function isFunction (line 23043) | function isFunction (value) {
function ReadableState (line 23114) | function ReadableState(options, stream) {
function Readable (line 23181) | function Readable(options) {
function readableAddChunk (line 23224) | function readableAddChunk(stream, state, chunk, encoding, addToFront) {
function needMoreData (line 23279) | function needMoreData(state) {
function computeNewHighWaterMark (line 23293) | function computeNewHighWaterMark(n) {
function howMuchToRead (line 23309) | function howMuchToRead(n, state) {
function chunkInvalid (line 23441) | function chunkInvalid(state, chunk) {
function onEofChunk (line 23449) | function onEofChunk(stream, state) {
function emitReadable (line 23467) | function emitReadable(stream) {
function emitReadable_ (line 23477) | function emitReadable_(stream) {
function maybeReadMore (line 23489) | function maybeReadMore(stream, state) {
function maybeReadMore_ (line 23496) | function maybeReadMore_(stream, state) {
function onunpipe (line 23540) | function onunpipe(readable) {
function onend (line 23547) | function onend() {
function cleanup (line 23560) | function cleanup() {
function ondata (line 23583) | function ondata(chunk) {
function onerror (line 23600) | function onerror(er) {
function onclose (line 23611) | function onclose() {
function onfinish (line 23616) | function onfinish() {
function unpipe (line 23623) | function unpipe() {
function pipeOnDrain (line 23640) | function pipeOnDrain(src) {
function nReadingNextTick (line 23730) | function nReadingNextTick(self) {
function resume (line 23747) | function resume(stream, state) {
function resume_ (line 23754) | function resume_(stream, state) {
function flow (line 23776) | function flow(stream) {
function fromList (line 23854) | function fromList(n, state) {
function endReadable (line 23901) | function endReadable(stream) {
function endReadableNT (line 23914) | function endReadableNT(state, stream) {
function forEach (line 23923) | function forEach(xs, f) {
function indexOf (line 23929) | function indexOf(xs, x) {
function TransformState (line 23996) | function TransformState(stream) {
function afterTransform (line 24008) | function afterTransform(stream, er, data) {
function Transform (line 24030) | function Transform(options) {
function done (line 24107) | function done(stream, er) {
function nop (line 24174) | function nop() {}
function WriteReq (line 24176) | function WriteReq(chunk, encoding, cb) {
function WritableState (line 24184) | function WritableState(options, stream) {
function Writable (line 24301) | function Writable(options) {
function writeAfterEnd (line 24327) | function writeAfterEnd(stream, cb) {
function validChunk (line 24339) | function validChunk(stream, state, chunk, cb) {
function decodeChunk (line 24395) | function decodeChunk(state, chunk, encoding) {
function writeOrBuffer (line 24405) | function writeOrBuffer(stream, state, chunk, encoding, cb) {
function doWrite (line 24433) | function doWrite(stream, state, writev, len, chunk, encoding, cb) {
function onwriteError (line 24442) | function onwriteError(stream, state, sync, er, cb) {
function onwriteStateUpdate (line 24450) | function onwriteStateUpdate(state) {
function onwrite (line 24457) | function onwrite(stream, er) {
function afterWrite (line 24482) | function afterWrite(stream, state, finished, cb) {
function onwriteDrain (line 24492) | function onwriteDrain(stream, state) {
function clearBuffer (line 24500) | function clearBuffer(stream, state) {
function needFinish (line 24583) | function needFinish(state) {
function prefinish (line 24587) | function prefinish(stream, state) {
function finishMaybe (line 24594) | function finishMaybe(stream, state) {
function endWritable (line 24608) | function endWritable(stream, state, cb) {
function CorkedRequest (line 24620) | function CorkedRequest(state) {
function DestroyableTransform (line 24675) | function DestroyableTransform(opts) {
function noop (line 24695) | function noop (chunk, enc, callback) {
function through2 (line 24702) | function through2 (construct) {
function Through2 (line 24737) | function Through2 (override) {
function Url (line 24807) | function Url() {
function urlParse (line 24875) | function urlParse(url, parseQueryString, slashesDenoteHost) {
function urlFormat (line 25145) | function urlFormat(obj) {
function urlResolve (line 25211) | function urlResolve(source, relative) {
function urlResolveObject (line 25219) | function urlResolveObject(source, relative) {
function deprecate (line 25537) | function deprecate (fn, msg) {
function config (line 25568) | function config (name) {
function wrappy (line 25592) | function wrappy (fn, cb) {
function IpfsAPI (line 25635) | function IpfsAPI(hostOrMultiaddr, port, opts) {
function define (line 25697) | function define(O, key, value) {
function Entity (line 25726) | function Entity(name, body) {
function Node (line 25813) | function Node(enc, parent) {
function Reporter (line 26407) | function Reporter(options) {
function ReporterError (line 26495) | function ReporterError(path, msg) {
function PEMDecoder (line 26576) | function PEMDecoder(entity) {
function PEMEncoder (line 26640) | function PEMEncoder(entity) {
function headers (line 27717) | function headers(file) {
function strip (line 27734) | function strip(name, base) {
function loadPaths (line 27739) | function loadPaths(opts, file) {
function getFilesStream (line 27807) | function getFilesStream(files, opts) {
function requireCommands (line 27849) | function requireCommands() {
function loadCommands (line 27875) | function loadCommands(send) {
function parseChunkedJson (line 27905) | function parseChunkedJson(res, cb) {
function onRes (line 27912) | function onRes(buffer, cb) {
function requestAPI (line 27955) | function requestAPI(config, path, args, qs, files, buffer, cb) {
function wrap (line 28069) | function wrap(innerFn, outerFn, self, tryLocsList) {
function tryCatch (line 28092) | function tryCatch(fn, obj, arg) {
function Generator (line 28113) | function Generator() {}
function GeneratorFunction (line 28114) | function GeneratorFunction() {}
function GeneratorFunctionPrototype (line 28115) | function GeneratorFunctionPrototype() {}
function defineIteratorMethods (line 28124) | function defineIteratorMethods(prototype) {
function AwaitArgument (line 28161) | function AwaitArgument(arg) {
function AsyncIterator (line 28165) | function AsyncIterator(generator) {
function makeInvokeMethod (line 28253) | function makeInvokeMethod(innerFn, self, context) {
function pushTryEntry (line 28408) | function pushTryEntry(locs) {
function resetTryEntry (line 28423) | function resetTryEntry(entry) {
function Context (line 28430) | function Context(tryLocsList) {
function values (line 28466) | function values(iterable) {
function doneResult (line 28502) | function doneResult() {
function handle (line 28548) | function handle(loc, caught) {
function balanced (line 28699) | function balanced(a, b, str) {
function maybeMatch (line 28714) | function maybeMatch(reg, str) {
function range (line 28720) | function range(a, b, str) {
function encode (line 28780) | function encode (source) {
function decode (line 28812) | function decode (string) {
function init (line 28860) | function init () {
function toByteArray (line 28873) | function toByteArray (b64) {
function tripletToBase64 (line 28915) | function tripletToBase64 (num) {
function encodeChunk (line 28919) | function encodeChunk (uint8, start, end) {
function fromByteArray (line 28929) | function fromByteArray (uint8) {
function numeric (line 28977) | function numeric(str) {
function escapeBraces (line 28983) | function escapeBraces(str) {
function unescapeBraces (line 28991) | function unescapeBraces(str) {
function parseCommaParts (line 29003) | function parseCommaParts(str) {
function expandTop (line 29030) | function expandTop(str) {
function identity (line 29037) | function identity(e) {
function embrace (line 29041) | function embrace(str) {
function isPadded (line 29044) | function isPadded(el) {
function lte (line 29048) | function lte(i, y) {
function gte (line 29051) | function gte(i, y) {
function expand (line 29055) | function expand(str, isTop) {
function Decipher (line 29172) | function Decipher (mode, key, iv) {
function Splitter (line 29208) | function Splitter () {
function unpad (line 29240) | function unpad (last) {
function createDecipheriv (line 29265) | function createDecipheriv (suite, password, iv) {
function createDecipher (line 29290) | function createDecipher (suite, password) {
function Cipher (line 29315) | function Cipher (mode, key, iv) {
function Splitter (line 29354) | function Splitter () {
function createCipheriv (line 29394) | function createCipheriv (suite, password, iv) {
function createCipher (line 29418) | function createCipher (suite, password) {
function GHASH (line 29439) | function GHASH (key) {
function toArray (line 29503) | function toArray (buf) {
function fromArray (line 29511) | function fromArray (out) {
function fixup_uint32 (line 29521) | function fixup_uint32 (x) {
function xor (line 29526) | function xor (a, b) {
function createCipher (line 29546) | function createCipher (suite, password) {
function createDecipher (line 29561) | function createDecipher (suite, password) {
function createCipheriv (line 29577) | function createCipheriv (suite, key, iv) {
function createDecipheriv (line 29591) | function createDecipheriv (suite, key, iv) {
function getCiphers (line 29610) | function getCiphers () {
function DES (line 29636) | function DES (opts) {
function Sign (line 29712) | function Sign (algorithm) {
function Verify (line 29749) | function Verify (algorithm) {
function createSign (line 29789) | function createSign (algorithm) {
function createVerify (line 29793) | function createVerify (algorithm) {
function sign (line 29820) | function sign (hash, key, hashType, signType) {
function ecSign (line 29850) | function ecSign (hash, priv) {
function dsaSign (line 29863) | function dsaSign (hash, priv, algo) {
function toDER (line 29885) | function toDER (r, s) {
function getKey (line 29904) | function getKey (x, q, hash, algo) {
function bits2int (line 29941) | function bits2int (obits, q) {
function bits2octets (line 29950) | function bits2octets (bits, q) {
function makeKey (line 29962) | function makeKey (q, kv, algo) {
function makeR (line 29988) | function makeR (g, k, p, q) {
function verify (line 30010) | function verify (sig, hash, key, signType) {
function ecVerify (line 30062) | function ecVerify (sig, hash, pub) {
function dsaVerify (line 30072) | function dsaVerify (sig, hash, pub) {
function checkValue (line 30095) | function checkValue (b, q) {
function F (line 30628) | function F(){}
function asinh (line 30928) | function asinh(x){
function F (line 32039) | function F(){}
function get (line 32183) | function get(target, propertyKey/*, receiver*/){
function set (line 32290) | function set(target, propertyKey, V/*, receiver*/){
function ECDH (line 34092) | function ECDH(curve) {
function formatReturnValue (line 34154) | function formatReturnValue(bn, enc, len) {
function toArray (line 34182) | function toArray(buf, bigEndian) {
function toBuffer (line 34196) | function toBuffer(arr, size, bigEndian) {
function hash (line 34205) | function hash(buf, fn, hashSize, bigEndian) {
function CBCState (line 34224) | function CBCState(iv) {
function instantiate (line 34232) | function instantiate(Base) {
function Cipher (line 34292) | function Cipher(options) {
function DESState (line 34444) | function DESState() {
function DES (line 34449) | function DES(options) {
function EDEState (line 34593) | function EDEState(type, key) {
function EDE (line 34615) | function EDE(options) {
function getDiffieHellman (line 34912) | function getDiffieHellman (mod) {
function createDiffieHellman (line 34923) | function createDiffieHellman (prime, enc, generator, genc) {
function setPublicKey (line 34968) | function setPublicKey(pub, enc) {
function setPrivateKey (line 34977) | function setPrivateKey(priv, enc) {
function checkPrime (line 34987) | function checkPrime(prime, generator) {
function DH (line 35040) | function DH(prime, generator, malleable) {
function formatReturnValue (line 35112) | function formatReturnValue(bn, enc) {
function BaseCurve (line 35136) | function BaseCurve(type, conf) {
function BasePoint (line 35361) | function BasePoint(curve, type) {
function EdwardsCurve (line 35494) | function EdwardsCurve(conf) {
function Point (line 35598) | function Point(curve, x, y, z, t) {
function MontCurve (line 35910) | function MontCurve(conf) {
function Point (line 35931) | function Point(curve, x, z) {
function ShortCurve (line 36092) | function ShortCurve(conf) {
function Point (line 36333) | function Point(curve, x, y, isRed) {
function obj2point (line 36417) | function obj2point(obj) {
function JPoint (line 36562) | function JPoint(curve, x, y, z) {
function PresetCurve (line 37006) | function PresetCurve(options) {
function defineCurve (line 37022) | function defineCurve(name, options) {
function EC (line 37218) | function EC(options) {
function KeyPair (line 37440) | function KeyPair(ec, options) {
function Signature (line 37557) | function Signature(options, enc) {
function Position (line 37574) | function Position() {
function getLength (line 37578) | function getLength(buf, p) {
function rmPadding (line 37593) | function rmPadding(buf) {
function constructLength (line 37643) | function constructLength(arr, len) {
function EDDSA (line 37700) | function EDDSA(curve) {
function KeyPair (line 37831) | function KeyPair(eddsa, params) {
function Signature (line 37933) | function Signature(eddsa, sig) {
function HmacDRBG (line 37995) | function HmacDRBG(options) {
function toArray (line 38904) | function toArray(msg, enc) {
function zero2 (line 38936) | function zero2(word) {
function toHex (line 38944) | function toHex(msg) {
function getNAF (line 38960) | function getNAF(num, w) {
function getJSF (line 38990) | function getJSF(k1, k2) {
function cachedProperty (line 39046) | function cachedProperty(obj, computer) {
function parseBytes (line 39056) | function parseBytes(bytes) {
function intFromLE (line 39062) | function intFromLE(bytes) {
function globSync (line 39111) | function globSync (pattern, options) {
function GlobSync (line 39119) | function GlobSync (pattern, options) {
function BlockHash (line 39571) | function BlockHash() {
function Hmac (line 39670) | function Hmac(hash, key, enc) {
function RIPEMD160 (line 39727) | function RIPEMD160() {
function f (line 39792) | function f(j, x, y, z) {
function K (line 39805) | function K(j) {
function Kh (line 39818) | function Kh(j) {
function SHA256 (line 39957) | function SHA256() {
function SHA224 (line 40023) | function SHA224() {
function SHA512 (line 40047) | function SHA512() {
function SHA384 (line 40194) | function SHA384() {
function SHA1 (line 40223) | function SHA1() {
function ch32 (line 40280) | function ch32(x, y, z) {
function maj32 (line 40284) | function maj32(x, y, z) {
function p32 (line 40288) | function p32(x, y, z) {
function s0_256 (line 40292) | function s0_256(x) {
function s1_256 (line 40296) | function s1_256(x) {
function g0_256 (line 40300) | function g0_256(x) {
function g1_256 (line 40304) | function g1_256(x) {
function ft_1 (line 40308) | function ft_1(s, x, y, z) {
function ch64_hi (line 40317) | function ch64_hi(xh, xl, yh, yl, zh, zl) {
function ch64_lo (line 40324) | function ch64_lo(xh, xl, yh, yl, zh, zl) {
function maj64_hi (line 40331) | function maj64_hi(xh, xl, yh, yl, zh, zl) {
function maj64_lo (line 40338) | function maj64_lo(xh, xl, yh, yl, zh, zl) {
function s0_512_hi (line 40345) | function s0_512_hi(xh, xl) {
function s0_512_lo (line 40356) | function s0_512_lo(xh, xl) {
function s1_512_hi (line 40367) | function s1_512_hi(xh, xl) {
function s1_512_lo (line 40378) | function s1_512_lo(xh, xl) {
function g0_512_hi (line 40389) | function g0_512_hi(xh, xl) {
function g0_512_lo (line 40400) | function g0_512_lo(xh, xl) {
function g1_512_hi (line 40411) | function g1_512_hi(xh, xl) {
function g1_512_lo (line 40422) | function g1_512_lo(xh, xl) {
function toArray (line 40441) | function toArray(msg, enc) {
function toHex (line 40473) | function toHex(msg) {
function htonl (line 40481) | function htonl(w) {
function toHex32 (line 40490) | function toHex32(msg, endian) {
function zero2 (line 40502) | function zero2(word) {
function zero8 (line 40510) | function zero8(word) {
function join32 (line 40530) | function join32(msg, start, end, endian) {
function split32 (line 40546) | function split32(msg, endian) {
function rotr32 (line 40566) | function rotr32(w, b) {
function rotl32 (line 40571) | function rotl32(w, b) {
function sum32 (line 40576) | function sum32(a, b) {
function sum32_3 (line 40581) | function sum32_3(a, b, c) {
function sum32_4 (line 40586) | function sum32_4(a, b, c, d) {
function sum32_5 (line 40591) | function sum32_5(a, b, c, d, e) {
function assert (line 40596) | function assert(cond, msg) {
function sum64 (line 40604) | function sum64(buf, pos, ah, al) {
function sum64_hi (line 40615) | function sum64_hi(ah, al, bh, bl) {
function sum64_lo (line 40622) | function sum64_lo(ah, al, bh, bl) {
function sum64_4_hi (line 40628) | function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
function sum64_4_lo (line 40643) | function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
function sum64_5_hi (line 40649) | function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
function sum64_5_lo (line 40666) | function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
function rotr64_hi (line 40673) | function rotr64_hi(ah, al, num) {
function rotr64_lo (line 40679) | function rotr64_lo(ah, al, num) {
function shr64_hi (line 40685) | function shr64_hi(ah, al, num) {
function shr64_lo (line 40690) | function shr64_lo(ah, al, num) {
function inflight (line 40832) | function inflight (key, cb) {
function makeres (line 40842) | function makeres (key) {
function slice (line 40863) | function slice (args) {
function _normalizeFamily (line 40974) | function _normalizeFamily(family) {
function baseFilter (line 41610) | function baseFilter(collection, predicate) {
function checkGlobal (line 41710) | function checkGlobal(value) {
function isHostObject (line 41721) | function isHostObject(value) {
function Hash (line 41775) | function Hash() {}
function hashDelete (line 41785) | function hashDelete(hash, key) {
function hashGet (line 41797) | function hashGet(hash, key) {
function hashHas (line 41813) | function hashHas(hash, key) {
function hashSet (line 41825) | function hashSet(hash, key, value) {
function MapCache (line 41839) | function MapCache(values) {
function mapClear (line 41857) | function mapClear() {
function mapDelete (line 41874) | function mapDelete(key) {
function mapGet (line 41891) | function mapGet(key) {
function mapHas (line 41908) | function mapHas(key) {
function mapSet (line 41926) | function mapSet(key, value) {
function assocDelete (line 41953) | function assocDelete(array, key) {
function assocGet (line 41975) | function assocGet(array, key) {
function assocHas (line 41988) | function assocHas(array, key) {
function assocIndexOf (line 42000) | function assocIndexOf(array, key) {
function assocSet (line 42018) | function assocSet(array, key, value) {
function getNative (line 42035) | function getNative(object, key) {
function isKeyable (line 42047) | function isKeyable(value) {
function toSource (line 42075) | function toSource(func) {
function memoize (line 42131) | function memoize(func, resolver) {
function eq (line 42186) | function eq(value, other) {
function isFunction (line 42208) | function isFunction(value) {
function isObject (line 42241) | function isObject(value) {
function isObjectLike (line 42270) | function isObjectLike(value) {
function isNative (line 42292) | function isNative(value) {
function isSymbol (line 42318) | function isSymbol(value) {
function toString (line 42344) | function toString(value) {
function arrayFilter (line 42387) | function arrayFilter(array, predicate) {
function filter (line 42437) | function filter(collection, predicate) {
function stringToStringTuples (line 42511) | function stringToStringTuples(str) {
function stringTuplesToString (line 42539) | function stringTuplesToString(tuples) {
function stringTuplesToTuples (line 42553) | function stringTuplesToTuples(tuples) {
function tuplesToStringTuples (line 42567) | function tuplesToStringTuples(tuples) {
function tuplesToBuffer (line 42578) | function tuplesToBuffer(tuples) {
function sizeForAddr (line 42591) | function sizeForAddr(p, addr) {
function bufferToTuples (line 42603) | function bufferToTuples(buf) {
function bufferToString (line 42637) | function bufferToString(buf) {
function stringToBuffer (line 42644) | function stringToBuffer(str) {
function fromString (line 42652) | function fromString(str) {
function fromBuffer (line 42657) | function fromBuffer(buf) {
function validateBuffer (line 42663) | function validateBuffer(buf) {
function isValidBuffer (line 42671) | function isValidBuffer(buf) {
function cleanPath (line 42675) | function cleanPath(str) {
function ParseError (line 42679) | function ParseError(str) {
function protoFromTuple (line 42683) | function protoFromTuple(tup) {
function Convert (line 42703) | function Convert(proto, a) {
function port2buf (line 42757) | function port2buf(port) {
function buf2port (line 42763) | function buf2port(buf) {
function mh2buf (line 42767) | function mh2buf(hash) {
function buf2mh (line 42774) | function buf2mh(buf) {
function Multiaddr (line 42801) | function Multiaddr(addr) {
function Multipart (line 42979) | function Multipart(boundary) {
function oaep (line 43249) | function oaep(key, msg){
function pkcs1 (line 43276) | function pkcs1(key, msg, reverse){
function compare (line 43300) | function compare(a, b){
function oaep (line 43366) | function oaep(key, msg){
function pkcs1 (line 43383) | function pkcs1(key, msg, reverse){
function nonZero (line 43398) | function nonZero(len, crypto) {
function error (line 43487) | function error(type) {
function map (line 43499) | function map(array, fn) {
function mapDomain (line 43518) | function mapDomain(string, fn) {
function ucs2decode (line 43547) | function ucs2decode(string) {
function ucs2encode (line 43581) | function ucs2encode(array) {
function basicToDigit (line 43603) | function basicToDigit(codePoint) {
function digitToBasic (line 43627) | function digitToBasic(digit, flag) {
function adapt (line 43638) | function adapt(delta, numPoints, firstTime) {
function decode (line 43655) | function decode(input) {
function encode (line 43756) | function encode(input) {
function toUnicode (line 43874) | function toUnicode(input) {
function toASCII (line 43893) | function toASCII(input) {
function hasOwnProperty (line 43986) | function hasOwnProperty(obj, prop) {
function map (line 44119) | function map (xs, f) {
function ReadableState (line 44204) | function ReadableState(options, stream) {
function Readable (line 44272) | function Readable(options) {
function readableAddChunk (line 44308) | function readableAddChunk(stream, state, chunk, encoding, addToFront) {
function needMoreData (line 44357) | function needMoreData(state) {
function roundUpToNextPowerOf2 (line 44374) | function roundUpToNextPowerOf2(n) {
function howMuchToRead (line 44386) | function howMuchToRead(n, state) {
function chunkInvalid (line 44548) | function chunkInvalid(state, chunk) {
function onEofChunk (line 44561) | function onEofChunk(stream, state) {
function emitReadable (line 44582) | function emitReadable(stream) {
function emitReadable_ (line 44597) | function emitReadable_(stream) {
function maybeReadMore (line 44608) | function maybeReadMore(stream, state) {
function maybeReadMore_ (line 44617) | function maybeReadMore_(stream, state) {
function onunpipe (line 44667) | function onunpipe(readable) {
function onend (line 44672) | function onend() {
function cleanup (line 44683) | function cleanup() {
function onerror (line 44704) | function onerror(er) {
function onclose (line 44722) | function onclose() {
function onfinish (line 44727) | function onfinish() {
function unpipe (line 44733) | function unpipe() {
function pipeOnDrain (line 44757) | function pipeOnDrain(src) {
function flow (line 44767) | function flow(src) {
function pipeOnReadable (line 44811) | function pipeOnReadable() {
function emitDataEvents (line 44915) | function emitDataEvents(stream, startPaused) {
function fromList (line 45036) | function fromList(n, state) {
function endReadable (line 45100) | function endReadable(stream) {
function forEach (line 45121) | function forEach (xs, f) {
function indexOf (line 45127) | function indexOf (xs, x) {
function TransformState (line 45216) | function TransformState(options, stream) {
function afterTransform (line 45227) | function afterTransform(stream, er, data) {
function Transform (line 45253) | function Transform(options) {
function done (line 45332) | function done(stream, er) {
function WriteReq (line 45399) | function WriteReq(chunk, encoding, cb) {
function WritableState (line 45405) | function WritableState(options, stream) {
function Writable (line 45476) | function Writable(options) {
function writeAfterEnd (line 45498) | function writeAfterEnd(stream, state, cb) {
function validChunk (line 45512) | function validChunk(stream, state, chunk, cb) {
function decodeChunk (line 45554) | function decodeChunk(state, chunk, encoding) {
function writeOrBuffer (line 45566) | function writeOrBuffer(stream, state, chunk, encoding, cb) {
function doWrite (line 45587) | function doWrite(stream, state, len, chunk, encoding, cb) {
function onwriteError (line 45596) | function onwriteError(stream, state, sync, er, cb) {
function onwriteStateUpdate (line 45608) | function onwriteStateUpdate(state) {
function onwrite (line 45615) | function onwrite(stream, er) {
function afterWrite (line 45641) | function afterWrite(stream, state, finished, cb) {
function onwriteDrain (line 45652) | function onwriteDrain(stream, state) {
function clearBuffer (line 45661) | function clearBuffer(stream, state) {
function needFinish (line 45715) | function needFinish(stream, state) {
function finishMaybe (line 45722) | function finishMaybe(stream, state) {
function endWritable (line 45731) | function endWritable(stream, state, cb) {
function bytesToWords (line 45809) | function bytesToWords (bytes) {
function wordsToBytes (line 45817) | function wordsToBytes (words) {
function processBlock (line 45825) | function processBlock (H, M, offset) {
function f1 (line 45904) | function f1 (x, y, z) {
function f2 (line 45908) | function f2 (x, y, z) {
function f3 (line 45912) | function f3 (x, y, z) {
function f4 (line 45916) | function f4 (x, y, z) {
function f5 (line 45920) | function f5 (x, y, z) {
function rotl (line 45924) | function rotl (x, n) {
function ripemd160 (line 45928) | function ripemd160 (message) {
function SandwichStream (line 45976) | function SandwichStream(options) {
function sandwichStream (line 46071) | function sandwichStream(options) {
function Sha (line 46123) | function Sha () {
function rotl5 (line 46142) | function rotl5 (num) {
function rotl30 (line 46146) | function rotl30 (num) {
function ft (line 46150) | function ft (s, b, c, d) {
function Sha1 (line 46224) | function Sha1 () {
function rotl1 (line 46243) | function rotl1 (num) {
function rotl5 (line 46247) | function rotl5 (num) {
function rotl30 (line 46251) | function rotl30 (num) {
function ft (line 46255) | function ft (s, b, c, d) {
function Sha224 (line 46325) | function Sha224 () {
function Sha384 (line 46376) | function Sha384 () {
function writeInt64BE (line 46410) | function writeInt64BE (h, l, offset) {
function transform (line 46453) | function transform(chunk, enc, cb) {
function flush (line 46473) | function flush(cb) {
function push (line 46480) | function push(self, val) {
function noop (line 46485) | function noop(incoming) {
function split (line 46489) | function split(matcher, mapper, options) {
function decideMode (line 46593) | function decideMode (preferBinary) {
function statusValid (line 46773) | function statusValid (xhr) {
function read (line 46913) | function read () {
function PassThrough (line 47083) | function PassThrough(options) {
function read (line 47168) | function read(buf, offset) {
function encode (line 47205) | function encode(num, out, offset) {
function Context (line 47303) | function Context() {}
Condensed preview — 7 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,446K chars).
[
{
"path": "LICENSE",
"chars": 1159,
"preview": "Copyright (c) 2017 Howard Wu.\n\nAll files, with the exceptions below, are released under the MIT License:\n\n Permission i"
},
{
"path": "README.md",
"chars": 7062,
"preview": "# IPFS + Ethereum Storage\n\nWe will create a simple datastore solution using IPFS and Ethereum. IPFS provides a convenien"
},
{
"path": "contract/SimpleStorage.sol",
"chars": 193,
"preview": "contract SimpleStorage {\n string storedData;\n\n function set(string x) {\n storedData = x;\n }\n\n functio"
},
{
"path": "contract/SimpleStorageBytecode.txt",
"chars": 1320,
"preview": "6060604052610282806100126000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063"
},
{
"path": "ipfs/ipfs.js",
"chars": 1334651,
"preview": "var IpfsApi =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedMod"
},
{
"path": "storage/style.css",
"chars": 71,
"preview": "html * {\n color: #000 !important;\n font-family: Arial !important;\n}"
},
{
"path": "storage.html",
"chars": 9066,
"preview": "<!doctype>\n<html>\n\n<head>\n <title>IPFS + Ethereum Storage Application</title>\n <link rel=\"stylesheet\" type=\"text/c"
}
]
About this extraction
This page contains the full source code of the howardwu/IPFS-Ethereum-Storage GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 7 files (1.3 MB), approximately 396.7k tokens, and a symbol index with 866 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.