smock 0.1.217 → 0.1.218

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/big.js/LICENCE

@@ -0,0 +1,23 @@
+The MIT Expat Licence.
+
+Copyright (c) 2012 Michael Mclaughlin
+
+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.
+

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/big.js/README.md

@@ -0,0 +1,214 @@
+
+# big.js #
+
+A small, fast JavaScript library for arbitrary-precision decimal arithmetic.
+
+The little sister to [bignumber.js](https://github.com/MikeMcl/bignumber.js/).
+See also [decimal.js](https://github.com/MikeMcl/decimal.js/).
+
+## Features
+
+  - Faster, smaller and easier-to-use than JavaScript versions of Java's BigDecimal
+  - Only 2.6 KB minified and gzipped
+  - Simple API
+  - Replicates the `toExponential`, `toFixed` and `toPrecision` methods of JavaScript's Number type
+  - Includes a `sqrt` method
+  - Stores values in an accessible decimal floating point format
+  - No dependencies
+  - Comprehensive [documentation](http://mikemcl.github.io/big.js/) and test set
+
+## Load
+
+The library is the single JavaScript file *big.js* (or *big.min.js*, which is *big.js* minified).
+
+It can be loaded via a script tag in an HTML document for the browser
+
+    <script src='./relative/path/to/big.js'></script>
+
+or as a CommonJS, [Node.js](http://nodejs.org) or AMD module using `require`.
+
+For Node, put the *big.js* file into the same directory as the file that is requiring it and use
+
+    var Big = require('./big.js');
+
+or put it in a *node_modules* directory within the directory and use `require('big.js')`.
+
+To load with AMD loader libraries such as [requireJS](http://requirejs.org/):
+
+    require(['big'], function(Big) {
+        // Use Big here in local scope. No global Big.
+    });
+
+## Use
+
+*In all examples below, `var`, semicolons and `toString` calls are not shown.
+If a commented-out value is in quotes it means `toString` has been called on the preceding expression.*
+
+The library exports a single function: Big, the constructor of Big number instances.
+It accepts a value of type Number, String or Big number Object.
+
+    x = new Big(123.4567)
+    y = Big('123456.7e-3')             // 'new' is optional
+    z = new Big(x)
+    x.eq(y) && x.eq(z) && y.eq(z)      // true
+
+A Big number is immutable in the sense that it is not changed by its methods.
+
+    0.3 - 0.1                          // 0.19999999999999998
+    x = new Big(0.3)
+    x.minus(0.1)                       // "0.2"
+    x                                  // "0.3"
+
+The methods that return a Big number can be chained.
+
+    x.div(y).plus(z).times(9).minus('1.234567801234567e+8').plus(976.54321).div('2598.11772')
+    x.sqrt().div(y).pow(3).gt(y.mod(z))    // true
+
+Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods.
+
+    x = new Big(255.5)
+    x.toExponential(5)                 // "2.55500e+2"
+    x.toFixed(5)                       // "255.50000"
+    x.toPrecision(5)                   // "255.50"
+
+The maximum number of decimal places and the rounding mode used to round the results of the `div`, `sqrt` and `pow`
+(with negative exponent) methods is determined by the value of the `DP` and `RM` properties of the `Big` number constructor.
+The other methods always give the exact result.
+
+    Big.DP = 10
+    Big.RM = 1
+
+    x = new Big(2);
+    y = new Big(3);
+    z = x.div(y)                       // "0.6666666667"
+    z.sqrt()                           // "0.8164965809"
+    z.pow(-3)                          // "3.3749999995"
+    z.times(z)                         // "0.44444444448888888889"
+    z.times(z).round(10)               // "0.4444444445"
+
+The value of a Big number is stored in a decimal floating point format in terms of a coefficient, exponent and sign.
+
+    x = new Big(-123.456);
+    x.c                                // "1,2,3,4,5,6"    coefficient (i.e. significand)
+    x.e                                // 2                exponent
+    x.s                                // -1               sign
+
+For further information see the [API](http://mikemcl.github.io/big.js/) reference from the *doc* folder.
+
+## Test
+
+The *test* directory contains the test scripts for each Big number method.
+
+The tests can be run with Node or a browser.
+
+To test a single method, from a command-line shell at the *test* directory, use e.g.
+
+    $ node toFixed
+
+To test all the methods
+
+    $ node every-test
+
+For the browser, see *single-test.html* and *every-test.html* in the *test/browser* directory.
+
+*big-vs-number.html* enables some of the methods of big.js to be compared with those of JavaScript's Number type.
+
+## Performance
+
+The *perf* directory contains two applications and a *lib* directory containing the BigDecimal libraries used by both.
+
+*big-vs-bigdecimal.html* tests the performance of big.js against the JavaScript translations of two versions of BigDecimal, its use should be more or less self-explanatory.
+(The GWT version doesn't work in IE 6.)
+
+* GWT: java.math.BigDecimal
+<https://github.com/iriscouch/bigdecimal.js>
+* ICU4J: com.ibm.icu.math.BigDecimal
+<https://github.com/dtrebbien/BigDecimal.js>
+
+The BigDecimal in Node's npm registry is the GWT version. Despite its seeming popularity I have found it to have some serious bugs, see the Node script *perf/lib/bigdecimal_GWT/bugs.js* for examples of flaws in its *remainder*, *divide* and *compareTo* methods.
+
+*bigtime.js* is a Node command-line application which tests the performance of big.js against the GWT version of
+BigDecimal from the npm registry.
+
+For example, to compare the time taken by the big.js `plus` method and the BigDecimal `add` method:
+
+    $ node bigtime plus 10000 40
+
+This will time 10000 calls to each, using operands of up to 40 random digits and will check that the results match.
+
+For help:
+
+    $ node bigtime -h
+
+## Build
+
+I.e. minify.
+
+For Node, if uglify-js is installed globally ( `npm install uglify-js -g` ) then
+
+    uglifyjs -o ./big.min.js ./big.js
+
+will create *big.min.js*.
+
+The *big.min.js* already present was created with *Microsoft Ajax Minifier 4.95*, as it produced a smaller file size.
+
+## Feedback
+
+Feedback is welcome.
+
+Bugs/comments/questions?
+Open an issue, or email
+
+Michael
+<a href="mailto:M8ch88l@gmail.com">M8ch88l@gmail.com</a>
+
+Bitcoin donation to:
+**1DppGRQSjVSMgGxuygDEHQuWEdTiVEzJYG**
+Thank you
+
+## Licence
+
+See LICENCE.
+
+## Change Log
+
+####2.5.1
+
+* 8/06/14 Amend README requires.
+
+####2.5.0
+
+* 26/01/14 Added `toJSON` method so serialization uses `toString`.
+
+####2.4.1
+
+* 17/10/13 Conform signed zero to IEEEE 754 (2008). 
+
+####2.4.0
+
+* 19/09/13 Throw instances of `Error`.
+
+####2.3.0
+
+* 16/09/13 Added `cmp` method.
+
+####2.2.0
+
+* 11/07/13 Added 'round up' mode.
+
+####2.1.0
+
+* 26/06/13 Allow e.g. `.1` and `2.`.
+
+####2.0.0
+
+* 12/05/13 Added `abs` method and replaced `cmp` with `eq`, `gt`, `gte`, `lt`, and `lte` methods.
+
+####1.0.1
+
+* Changed default value of MAX_DP to 1E6
+
+####1.0.0
+
+* 7/11/2012 Initial release
+

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/big.js/big.js

@@ -0,0 +1,1026 @@
+/* big.js v2.5.1 https://github.com/MikeMcl/big.js/LICENCE */
+;(function ( global ) {
+    'use strict';
+
+    /*
+      big.js v2.5.1
+      A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
+      https://github.com/MikeMcl/big.js/
+      Copyright (c) 2012 Michael Mclaughlin <M8ch88l@gmail.com>
+      MIT Expat Licence
+    */
+
+    /****************************** EDITABLE DEFAULTS **********************************/
+
+
+    // The default values below must be integers within the stated ranges (inclusive).
+
+    /*
+     * The maximum number of decimal places of the results of methods involving
+     * division, i.e. 'div' and 'sqrt', and 'pow' with negative exponents.
+     */
+    Big['DP'] = 20;                                  // 0 to MAX_DP
+
+    /*
+     * The rounding mode used when rounding to the above decimal places.
+     *
+     * 0 Round towards zero (i.e. truncate, no rounding).               (ROUND_DOWN)
+     * 1 Round to nearest neighbour. If equidistant, round up.          (ROUND_HALF_UP)
+     * 2 Round to nearest neighbour. If equidistant, to even neighbour. (ROUND_HALF_EVEN)
+     * 3 Round away from zero.                                          (ROUND_UP)
+     */
+    Big['RM'] = 1;                                   // 0, 1, 2 or 3
+
+        // The maximum value of 'Big.DP'.
+    var MAX_DP = 1E6,                                // 0 to 1e+6
+
+        // The maximum magnitude of the exponent argument to the 'pow' method.
+        MAX_POWER = 1E6,                             // 1 to 1e+6
+
+        /*
+         * The exponent value at and beneath which 'toString' returns exponential notation.
+         * Javascript's Number type: -7
+         * -1e+6 is the minimum recommended exponent value of a Big.
+         */
+        TO_EXP_NEG = -7,                             // 0 to -1e+6
+
+        /*
+         * The exponent value at and above which 'toString' returns exponential notation.
+         * Javascript's Number type: 21
+         * 1e+6 is the maximum recommended exponent value of a Big, though there is no
+         * enforcing or checking of a limit.
+         */
+        TO_EXP_POS = 21,                             // 0 to 1e+6
+
+
+    /***********************************************************************************/
+
+        P = Big.prototype,
+        isValid = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,
+        ONE = new Big(1);
+
+
+    // CONSTRUCTOR
+
+
+    /*
+     * The exported function.
+     * Create and return a new instance of a Big object.
+     *
+     * n {number|string|Big} A numeric value.
+     */
+    function Big( n ) {
+        var i, j, nL,
+            x = this;
+
+        // Enable constructor usage without new.
+        if ( !(x instanceof Big) ) {
+            return new Big( n )
+        }
+
+        // Duplicate.
+        if ( n instanceof Big ) {
+            x['s'] = n['s'];
+            x['e'] = n['e'];
+            x['c'] = n['c'].slice();
+            return
+        }
+
+        // Minus zero?
+        if ( n === 0 && 1 / n < 0 ) {
+            n = '-0'
+        // Ensure 'n' is string and check validity.
+        } else if ( !isValid.test(n += '') ) {
+            throwErr( NaN )
+        }
+
+        // Determine sign.
+        x['s'] = n.charAt(0) == '-' ? ( n = n.slice(1), -1 ) : 1;
+
+        // Decimal point?
+        if ( ( i = n.indexOf('.') ) > -1 ) {
+            n = n.replace( '.', '' )
+        }
+
+        // Exponential form?
+        if ( ( j = n.search(/e/i) ) > 0 ) {
+
+            // Determine exponent.
+            if ( i < 0 ) {
+                i = j
+            }
+            i += +n.slice( j + 1 );
+            n = n.substring( 0, j )
+
+        } else if ( i < 0 ) {
+
+            // Integer.
+            i = n.length
+        }
+
+        // Determine leading zeros.
+        for ( j = 0; n.charAt(j) == '0'; j++ ) {
+        }
+
+        if ( j == ( nL = n.length ) ) {
+
+            // Zero.
+            x['c'] = [ x['e'] = 0 ]
+        } else {
+
+            // Determine trailing zeros.
+            for ( ; n.charAt(--nL) == '0'; ) {
+            }
+
+            x['e'] = i - j - 1;
+            x['c'] = [];
+
+            // Convert string to array of digits (without leading and trailing zeros).
+            for ( i = 0; j <= nL; x['c'][i++] = +n.charAt(j++) ) {
+            }
+        }
+    }
+
+
+    // PRIVATE FUNCTIONS
+
+
+    /*
+     * Round Big 'x' to a maximum of 'dp' decimal places using rounding mode
+     * 'rm'. (Called by 'div', 'sqrt' and 'round'.)
+     *
+     * x {Big} The Big to round.
+     * dp {number} Integer, 0 to MAX_DP inclusive.
+     * rm {number} 0, 1, 2 or 3 ( ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP )
+     * [more] {boolean} Whether the result of division was truncated.
+     */
+    function rnd( x, dp, rm, more ) {
+        var xc = x['c'],
+            i = x['e'] + dp + 1;
+
+        if ( rm === 1 ) {
+            // 'xc[i]' is the digit after the digit that may be rounded up.
+            more = xc[i] >= 5
+        } else if ( rm === 2 ) {
+            more = xc[i] > 5 || xc[i] == 5 && ( more || i < 0 || xc[i + 1] != null || xc[i - 1] & 1 )
+        } else if ( rm === 3 ) {
+            more = more || xc[i] != null || i < 0
+        } else if ( more = false, rm !== 0 ) {
+            throwErr( '!Big.RM!' )
+        }
+
+        if ( i < 1 || !xc[0] ) {
+            x['c'] = more
+              // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+              ? ( x['e'] = -dp, [1] )
+              // Zero.
+              : [ x['e'] = 0 ];
+        } else {
+
+            // Remove any digits after the required decimal places.
+            xc.length = i--;
+
+            // Round up?
+            if ( more ) {
+
+                // Rounding up may mean the previous digit has to be rounded up and so on.
+                for ( ; ++xc[i] > 9; ) {
+                    xc[i] = 0;
+
+                    if ( !i-- ) {
+                        ++x['e'];
+                        xc.unshift(1)
+                    }
+                }
+            }
+
+            // Remove trailing zeros.
+            for ( i = xc.length; !xc[--i]; xc.pop() ) {
+            }
+        }
+
+        return x
+    }
+
+
+    /*
+     * Throw a BigError.
+     *
+     * message {string} The error message.
+     */
+    function throwErr( message ) {
+        var err = new Error( message );
+        err['name'] = 'BigError';
+
+        throw err
+    }
+
+
+    // PROTOTYPE/INSTANCE METHODS
+
+
+    /*
+     * Return a new Big whose value is the absolute value of this Big.
+     */
+    P['abs'] = function () {
+        var x = new Big(this);
+        x['s'] = 1;
+
+        return x
+    };
+
+
+    /*
+     * Return
+     * 1 if the value of this 'Big' is greater than the value of 'Big' 'y',
+     * -1 if the value of this 'Big' is less than the value of 'Big' 'y', or
+     * 0 if they have the same value.
+    */
+    P['cmp'] = function ( y ) {
+        var xNeg,
+            x = this,
+            xc = x['c'],
+            yc = ( y = new Big( y ) )['c'],
+            i = x['s'],
+            j = y['s'],
+            k = x['e'],
+            l = y['e'];
+
+        // Either zero?
+        if ( !xc[0] || !yc[0] ) {
+            return !xc[0] ? !yc[0] ? 0 : -j : i
+        }
+
+        // Signs differ?
+        if ( i != j ) {
+            return i
+        }
+        xNeg = i < 0;
+
+        // Compare exponents.
+        if ( k != l ) {
+            return k > l ^ xNeg ? 1 : -1
+        }
+
+        // Compare digit by digit.
+        for ( i = -1,
+              j = ( k = xc.length ) < ( l = yc.length ) ? k : l;
+              ++i < j; ) {
+
+            if ( xc[i] != yc[i] ) {
+                return xc[i] > yc[i] ^ xNeg ? 1 : -1
+            }
+        }
+
+        // Compare lengths.
+        return k == l ? 0 : k > l ^ xNeg ? 1 : -1
+    };
+
+
+    /*
+     * Return a new Big whose value is the value of this Big divided by the
+     * value of Big 'y', rounded, if necessary, to a maximum of 'Big.DP'
+     * decimal places using rounding mode 'Big.RM'.
+     */
+    P['div'] = function ( y ) {
+        var x = this,
+            dvd = x['c'],
+            dvs = ( y = new Big(y) )['c'],
+            s = x['s'] == y['s'] ? 1 : -1,
+            dp = Big['DP'];
+
+        if ( dp !== ~~dp || dp < 0 || dp > MAX_DP ) {
+            throwErr( '!Big.DP!' )
+        }
+
+        // Either 0?
+        if ( !dvd[0] || !dvs[0] ) {
+
+            // Both 0?
+            if ( dvd[0] == dvs[0] ) {
+                throwErr( NaN )
+            }
+
+            // 'dvs' is 0?
+            if ( !dvs[0] ) {
+                // Throw +-Infinity.
+                throwErr( s / 0 )
+            }
+
+            // 'dvd' is 0. Return +-0.
+            return new Big( s * 0 )
+        }
+
+        var dvsL, dvsT, next, cmp, remI,
+            dvsZ = dvs.slice(),
+            dvdI = dvsL = dvs.length,
+            dvdL = dvd.length,
+            rem = dvd.slice( 0, dvsL ),
+            remL = rem.length,
+            quo = new Big(ONE),
+            qc = quo['c'] = [],
+            qi = 0,
+            digits = dp + ( quo['e'] = x['e'] - y['e'] ) + 1;
+
+        quo['s'] = s;
+        s = digits < 0 ? 0 : digits;
+
+        // Create version of divisor with leading zero.
+        dvsZ.unshift(0);
+
+        // Add zeros to make remainder as long as divisor.
+        for ( ; remL++ < dvsL; rem.push(0) ) {
+        }
+
+        do {
+
+            // 'next' is how many times the divisor goes into the current remainder.
+            for ( next = 0; next < 10; next++ ) {
+
+                // Compare divisor and remainder.
+                if ( dvsL != ( remL = rem.length ) ) {
+                    cmp = dvsL > remL ? 1 : -1
+                } else {
+                    for ( remI = -1, cmp = 0; ++remI < dvsL; ) {
+
+                        if ( dvs[remI] != rem[remI] ) {
+                            cmp = dvs[remI] > rem[remI] ? 1 : -1;
+                            break
+                        }
+                    }
+                }
+
+                // Subtract divisor from remainder (if divisor < remainder).
+                if ( cmp < 0 ) {
+
+                    // Remainder cannot be more than one digit longer than divisor.
+                    // Equalise lengths using divisor with extra leading zero?
+                    for ( dvsT = remL == dvsL ? dvs : dvsZ; remL; ) {
+
+                        if ( rem[--remL] < dvsT[remL] ) {
+
+                            for ( remI = remL;
+                                  remI && !rem[--remI];
+                                  rem[remI] = 9 ) {
+                            }
+                            --rem[remI];
+                            rem[remL] += 10
+                        }
+                        rem[remL] -= dvsT[remL]
+                    }
+                    for ( ; !rem[0]; rem.shift() ) {
+                    }
+                } else {
+                    break
+                }
+            }
+
+            // Add the 'next' digit to the result array.
+            qc[qi++] = cmp ? next : ++next;
+
+            // Update the remainder.
+            rem[0] && cmp
+              ? ( rem[remL] = dvd[dvdI] || 0 )
+              : ( rem = [ dvd[dvdI] ] )
+
+        } while ( ( dvdI++ < dvdL || rem[0] != null ) && s-- );
+
+        // Leading zero? Do not remove if result is simply zero (qi == 1).
+        if ( !qc[0] && qi != 1) {
+
+            // There can't be more than one zero.
+            qc.shift();
+            quo['e']--;
+        }
+
+        // Round?
+        if ( qi > digits ) {
+            rnd( quo, dp, Big['RM'], rem[0] != null )
+        }
+
+        return quo
+    }
+
+
+    /*
+     * Return true if the value of this Big is equal to the value of Big 'y',
+     * otherwise returns false.
+     */
+    P['eq'] = function ( y ) {
+        return !this.cmp( y )
+    };
+
+
+    /*
+     * Return true if the value of this Big is greater than the value of Big 'y',
+     * otherwise returns false.
+     */
+    P['gt'] = function ( y ) {
+        return this.cmp( y ) > 0
+    };
+
+
+    /*
+     * Return true if the value of this Big is greater than or equal to the
+     * value of Big 'y', otherwise returns false.
+     */
+    P['gte'] = function ( y ) {
+        return this.cmp( y ) > -1
+    };
+
+
+    /*
+     * Return true if the value of this Big is less than the value of Big 'y',
+     * otherwise returns false.
+     */
+    P['lt'] = function ( y ) {
+        return this.cmp( y ) < 0
+    };
+
+
+    /*
+     * Return true if the value of this Big is less than or equal to the value
+     * of Big 'y', otherwise returns false.
+     */
+    P['lte'] = function ( y ) {
+         return this.cmp( y ) < 1
+    };
+
+
+    /*
+     * Return a new Big whose value is the value of this Big minus the value
+     * of Big 'y'.
+     */
+    P['minus'] = function ( y ) {
+        var d, i, j, xLTy,
+            x = this,
+            a = x['s'],
+            b = ( y = new Big( y ) )['s'];
+
+        // Signs differ?
+        if ( a != b ) {
+            return y['s'] = -b, x['plus'](y)
+        }
+
+        var xc = x['c'].slice(),
+            xe = x['e'],
+            yc = y['c'],
+            ye = y['e'];
+
+        // Either zero?
+        if ( !xc[0] || !yc[0] ) {
+
+            // 'y' is non-zero?
+            return yc[0]
+              ? ( y['s'] = -b, y )
+              // 'x' is non-zero?
+              : new Big( xc[0]
+                ? x
+                // Both are zero.
+                : 0 )
+        }
+
+        // Determine which is the bigger number.
+        // Prepend zeros to equalise exponents.
+        if ( a = xe - ye ) {
+            d = ( xLTy = a < 0 ) ? ( a = -a, xc ) : ( ye = xe, yc );
+
+            for ( d.reverse(), b = a; b--; d.push(0) ) {
+            }
+            d.reverse()
+        } else {
+
+            // Exponents equal. Check digit by digit.
+            j = ( ( xLTy = xc.length < yc.length ) ? xc : yc ).length;
+
+            for ( a = b = 0; b < j; b++ ) {
+
+                if ( xc[b] != yc[b] ) {
+                    xLTy = xc[b] < yc[b];
+                    break
+                }
+            }
+        }
+
+        // 'x' < 'y'? Point 'xc' to the array of the bigger number.
+        if ( xLTy ) {
+            d = xc, xc = yc, yc = d;
+            y['s'] = -y['s']
+        }
+
+        /*
+         * Append zeros to 'xc' if shorter. No need to add zeros to 'yc' if shorter
+         * as subtraction only needs to start at 'yc.length'.
+         */
+        if ( ( b = -( ( j = xc.length ) - yc.length ) ) > 0 ) {
+
+            for ( ; b--; xc[j++] = 0 ) {
+            }
+        }
+
+        // Subtract 'yc' from 'xc'.
+        for ( b = yc.length; b > a; ){
+
+            if ( xc[--b] < yc[b] ) {
+
+                for ( i = b; i && !xc[--i]; xc[i] = 9 ) {
+                }
+                --xc[i];
+                xc[b] += 10
+            }
+            xc[b] -= yc[b]
+        }
+
+        // Remove trailing zeros.
+        for ( ; xc[--j] == 0; xc.pop() ) {
+        }
+
+        // Remove leading zeros and adjust exponent accordingly.
+        for ( ; xc[0] == 0; xc.shift(), --ye ) {
+        }
+
+        if ( !xc[0] ) {
+
+            // n - n = +0
+            y['s'] = 1;
+
+            // Result must be zero.
+            xc = [ye = 0]
+        }
+
+        return y['c'] = xc, y['e'] = ye, y
+    };
+
+
+    /*
+     * Return a new Big whose value is the value of this Big modulo the
+     * value of Big 'y'.
+     */
+    P['mod'] = function ( y ) {
+        y = new Big( y );
+        var c,
+            x = this,
+            i = x['s'],
+            j = y['s'];
+
+        if ( !y['c'][0] ) {
+            throwErr( NaN )
+        }
+
+        x['s'] = y['s'] = 1;
+        c = y.cmp( x ) == 1;
+        x['s'] = i, y['s'] = j;
+
+        return c
+          ? new Big(x)
+          : ( i = Big['DP'], j = Big['RM'],
+            Big['DP'] = Big['RM'] = 0,
+              x = x['div'](y),
+                Big['DP'] = i, Big['RM'] = j,
+                  this['minus']( x['times'](y) ) )
+    };
+
+
+    /*
+     * Return a new Big whose value is the value of this Big plus the value
+     * of Big 'y'.
+     */
+    P['plus'] = function ( y ) {
+        var d,
+            x = this,
+            a = x['s'],
+            b = ( y = new Big( y ) )['s'];
+
+        // Signs differ?
+        if ( a != b ) {
+            return y['s'] = -b, x['minus'](y)
+        }
+
+        var xe = x['e'],
+            xc = x['c'],
+            ye = y['e'],
+            yc = y['c'];
+
+        // Either zero?
+        if ( !xc[0] || !yc[0] ) {
+
+            // 'y' is non-zero?
+            return yc[0]
+              ? y
+              : new Big( xc[0]
+
+                // 'x' is non-zero?
+                ? x
+
+                // Both are zero. Return zero.
+                : a * 0 )
+        }
+
+        // Prepend zeros to equalise exponents.
+        // Note: Faster to use reverse then do unshifts.
+        if ( xc = xc.slice(), a = xe - ye ) {
+            d = a > 0 ? ( ye = xe, yc ) : ( a = -a, xc );
+
+            for ( d.reverse(); a--; d.push(0) ) {
+            }
+            d.reverse()
+        }
+
+        // Point 'xc' to the longer array.
+        if ( xc.length - yc.length < 0 ) {
+            d = yc, yc = xc, xc = d
+        }
+
+        /*
+         * Only start adding at 'yc.length - 1' as the
+         * further digits of 'xc' can be left as they are.
+         */
+        for ( a = yc.length, b = 0; a;
+             b = ( xc[--a] = xc[a] + yc[a] + b ) / 10 ^ 0, xc[a] %= 10 ) {
+        }
+
+        // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+
+        if ( b ) {
+            xc.unshift(b);
+            ++ye
+        }
+
+         // Remove trailing zeros.
+        for ( a = xc.length; xc[--a] == 0; xc.pop() ) {
+        }
+
+        return y['c'] = xc, y['e'] = ye, y
+    };
+
+
+    /*
+     * Return a Big whose value is the value of this Big raised to the power
+     * 'e'. If 'e' is negative, round, if necessary, to a maximum of 'Big.DP'
+     * decimal places using rounding mode 'Big.RM'.
+     *
+     * e {number} Integer, -MAX_POWER to MAX_POWER inclusive.
+     */
+    P['pow'] = function ( e ) {
+        var isNeg = e < 0,
+            x = new Big(this),
+            y = ONE;
+
+        if ( e !== ~~e || e < -MAX_POWER || e > MAX_POWER ) {
+            throwErr( '!pow!' )
+        }
+
+        for ( e = isNeg ? -e : e; ; ) {
+
+            if ( e & 1 ) {
+                y = y['times'](x)
+            }
+            e >>= 1;
+
+            if ( !e ) {
+                break
+            }
+            x = x['times'](x)
+        }
+
+        return isNeg ? ONE['div'](y) : y
+    };
+
+
+    /*
+     * Return a new Big whose value is the value of this Big rounded, if
+     * necessary, to a maximum of 'dp' decimal places using rounding mode 'rm'.
+     * If 'dp' is not specified, round to 0 decimal places.
+     * If 'rm' is not specified, use 'Big.RM'.
+     *
+     * [dp] {number} Integer, 0 to MAX_DP inclusive.
+     * [rm] 0, 1, 2 or 3 ( ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP )
+     */
+    P['round'] = function ( dp, rm ) {
+        var x = new Big(this);
+
+        if ( dp == null ) {
+            dp = 0
+        } else if ( dp !== ~~dp || dp < 0 || dp > MAX_DP ) {
+            throwErr( '!round!' )
+        }
+        rnd( x, dp, rm == null ? Big['RM'] : rm );
+
+        return x
+    };
+
+
+    /*
+     * Return a new Big whose value is the square root of the value of this
+     * Big, rounded, if necessary, to a maximum of 'Big.DP' decimal places
+     * using rounding mode 'Big.RM'.
+     */
+    P['sqrt'] = function () {
+        var estimate, r, approx,
+            x = this,
+            xc = x['c'],
+            i = x['s'],
+            e = x['e'],
+            half = new Big('0.5');
+
+        // Zero?
+        if ( !xc[0] ) {
+            return new Big(x)
+        }
+
+        // Negative?
+        if ( i < 0 ) {
+            throwErr( NaN )
+        }
+
+        // Estimate.
+        i = Math.sqrt( x.toString() );
+
+        // Math.sqrt underflow/overflow?
+        // Pass 'x' to Math.sqrt as integer, then adjust the exponent of the result.
+        if ( i == 0 || i == 1 / 0 ) {
+            estimate = xc.join('');
+
+            if ( !( estimate.length + e & 1 ) ) {
+                estimate += '0'
+            }
+
+            r = new Big( Math.sqrt(estimate).toString() );
+            r['e'] = ( ( ( e + 1 ) / 2 ) | 0 ) - ( e < 0 || e & 1 )
+        } else {
+            r = new Big( i.toString() )
+        }
+
+        i = r['e'] + ( Big['DP'] += 4 );
+
+        // Newton-Raphson loop.
+        do {
+            approx = r;
+            r = half['times']( approx['plus']( x['div'](approx) ) )
+        } while ( approx['c'].slice( 0, i ).join('') !==
+                       r['c'].slice( 0, i ).join('') );
+
+        rnd( r, Big['DP'] -= 4, Big['RM'] );
+
+        return r
+    };
+
+
+    /*
+     * Return a new Big whose value is the value of this Big times the value
+     * of Big 'y'.
+     */
+    P['times'] = function ( y ) {
+        var c,
+            x = this,
+            xc = x['c'],
+            yc = ( y = new Big( y ) )['c'],
+            a = xc.length,
+            b = yc.length,
+            i = x['e'],
+            j = y['e'];
+
+        y['s'] = x['s'] == y['s'] ? 1 : -1;
+
+        // Either 0?
+        if ( !xc[0] || !yc[0] ) {
+
+            return new Big( y['s'] * 0 )
+        }
+
+        y['e'] = i + j;
+
+        if ( a < b ) {
+            c = xc, xc = yc, yc = c, j = a, a = b, b = j
+        }
+
+        for ( j = a + b, c = []; j--; c.push(0) ) {
+        }
+
+        // Multiply!
+        for ( i = b - 1; i > -1; i-- ) {
+
+            for ( b = 0, j = a + i;
+                  j > i;
+                  b = c[j] + yc[i] * xc[j - i - 1] + b,
+                  c[j--] = b % 10 | 0,
+                  b = b / 10 | 0 ) {
+            }
+
+            if ( b ) {
+                c[j] = ( c[j] + b ) % 10
+            }
+        }
+
+        b && ++y['e'];
+
+        // Remove any leading zero.
+        !c[0] && c.shift();
+
+        // Remove trailing zeros.
+        for ( j = c.length; !c[--j]; c.pop() ) {
+        }
+
+        return y['c'] = c, y
+    };
+
+
+    /*
+     * Return a string representing the value of this Big.
+     * Return exponential notation if this Big has a positive exponent equal
+     * to or greater than 'TO_EXP_POS', or a negative exponent equal to or less
+     * than 'TO_EXP_NEG'.
+     */
+    P['toString'] = P['valueOf'] = P['toJSON'] = function () {
+        var x = this,
+            e = x['e'],
+            str = x['c'].join(''),
+            strL = str.length;
+
+        // Exponential notation?
+        if ( e <= TO_EXP_NEG || e >= TO_EXP_POS ) {
+            str = str.charAt(0) + ( strL > 1 ?  '.' + str.slice(1) : '' ) +
+              ( e < 0 ? 'e' : 'e+' ) + e
+
+        // Negative exponent?
+        } else if ( e < 0 ) {
+
+        // Prepend zeros.
+            for ( ; ++e; str = '0' + str ) {
+            }
+            str = '0.' + str
+
+        // Positive exponent?
+        } else if ( e > 0 ) {
+
+            if ( ++e > strL ) {
+
+                // Append zeros.
+                for ( e -= strL; e-- ; str += '0' ) {
+                }
+            } else if ( e < strL ) {
+                str = str.slice( 0, e ) + '.' + str.slice(e)
+            }
+
+        // Exponent zero.
+        } else if ( strL > 1 ) {
+            str = str.charAt(0) + '.' + str.slice(1)
+        }
+
+        // Avoid '-0'
+        return x['s'] < 0 && x['c'][0] ? '-' + str : str
+    };
+
+
+    /*
+     ***************************************************************************
+     * If 'toExponential', 'toFixed', 'toPrecision' and 'format' are not
+     * required they can safely be commented-out or deleted. No redundant code
+     * will be left. 'format' is used only by 'toExponential', 'toFixed' and
+     * 'toPrecision'.
+     ***************************************************************************
+     */
+
+
+    /*
+     * PRIVATE FUNCTION
+     *
+     * Return a string representing the value of Big 'x' in normal or
+     * exponential notation to a fixed number of decimal places or significant
+     * digits 'dp'.
+     * (Called by toString, toExponential, toFixed and toPrecision.)
+     *
+     * x {Big} The Big to format.
+     * dp {number} Integer, 0 to MAX_DP inclusive.
+     * toE {number} undefined (toFixed), 1 (toExponential) or 2 (toPrecision).
+     */
+    function format( x, dp, toE ) {
+        // The index (in normal notation) of the digit that may be rounded up.
+        var i = dp - ( x = new Big(x) )['e'],
+            c = x['c'];
+
+        // Round?
+        if ( c.length > ++dp ) {
+            rnd( x, i, Big['RM'] )
+        }
+
+        // Recalculate 'i' if toFixed as 'x.e' may have changed if value rounded up.
+        i = !c[0] ? i + 1 : toE ? dp : ( c = x['c'], x['e'] + i + 1 );
+
+        // Append zeros?
+        for ( ; c.length < i; c.push(0) ) {
+        }
+        i = x['e'];
+
+        /*
+         * 'toPrecision' returns exponential notation if the number of
+         * significant digits specified is less than the number of digits
+         * necessary to represent the integer part of the value in normal
+         * notation.
+         */
+        return toE == 1 || toE == 2 && ( dp <= i || i <= TO_EXP_NEG )
+
+            // Exponential notation.
+            ? ( x['s'] < 0 && c[0] ? '-' : '' ) + ( c.length > 1
+              ? ( c.splice( 1, 0, '.' ), c.join('') )
+              : c[0] ) + ( i < 0 ? 'e' : 'e+' ) + i
+
+            // Normal notation.
+            : x.toString()
+    }
+
+
+    /*
+     * Return a string representing the value of this Big in exponential
+     * notation to 'dp' fixed decimal places and rounded, if necessary, using
+     * 'Big.RM'.
+     *
+     * [dp] {number} Integer, 0 to MAX_DP inclusive.
+     */
+    P['toExponential'] = function ( dp ) {
+
+        if ( dp == null ) {
+            dp = this['c'].length - 1
+        } else if ( dp !== ~~dp || dp < 0 || dp > MAX_DP ) {
+            throwErr( '!toExp!' )
+        }
+
+        return format( this, dp, 1 )
+    };
+
+
+    /*
+     * Return a string representing the value of this Big in normal notation
+     * to 'dp' fixed decimal places and rounded, if necessary, using 'Big.RM'.
+     *
+     * [dp] {number} Integer, 0 to MAX_DP inclusive.
+     */
+    P['toFixed'] = function ( dp ) {
+        var str,
+            x = this,
+            neg = TO_EXP_NEG,
+            pos = TO_EXP_POS;
+
+        TO_EXP_NEG = -( TO_EXP_POS = 1 / 0 );
+
+        if ( dp == null ) {
+            str = x.toString()
+        } else if ( dp === ~~dp && dp >= 0 && dp <= MAX_DP ) {
+            str = format( x, x['e'] + dp );
+
+            // (-0).toFixed() is '0', but (-0.1).toFixed() is '-0'.
+            // (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+            if ( x['s'] < 0 && x['c'][0] && str.indexOf('-') < 0 ) {
+                // As e.g. -0.5 if rounded to -0 will cause toString to omit the minus sign.
+                str = '-' + str
+            }
+        }
+        TO_EXP_NEG = neg, TO_EXP_POS = pos;
+
+        if ( !str ) {
+            throwErr( '!toFix!' )
+        }
+
+        return str
+    };
+
+
+    /*
+     * Return a string representing the value of this Big to 'sd' significant
+     * digits and rounded, if necessary, using 'Big.RM'. If 'sd' is less than
+     * the number of digits necessary to represent the integer part of the value
+     * in normal notation, then use exponential notation.
+     *
+     * sd {number} Integer, 1 to MAX_DP inclusive.
+     */
+    P['toPrecision'] = function ( sd ) {
+
+        if ( sd == null ) {
+            return this.toString()
+        } else if ( sd !== ~~sd || sd < 1 || sd > MAX_DP ) {
+            throwErr( '!toPre!' )
+        }
+
+        return format( this, sd - 1, 2 )
+    };
+
+
+    // EXPORT
+
+
+    // Node and other CommonJS-like environments that support module.exports.
+    if ( typeof module !== 'undefined' && module.exports ) {
+        module.exports = Big
+
+    //AMD.
+    } else if ( typeof define == 'function' && define.amd ) {
+        define( function () {
+            return Big
+        })
+
+    //Browser.
+    } else {
+        global['Big'] = Big
+    }
+
+})( this );