Can not install in Windows server 2012

Unable to install. I have OpenSSL and Python already installed.

Pretty sure this is the relevant bit:

..\bignum.cc(9): fatal error C1083: Cannot open include file: 'openssl/bn.h': N
o such file or directory [C:\temp\test\node_modules\bignum\build\bignum.vcxproj
]

I went to a clean directory and tried to install it alone from the command line to get a clean log file npm-debug.log, here it is:

0 info it worked if it ends with ok
1 verbose cli [ 'C:\\Program Files (x86)\\nodejs\\\\node.exe',
1 verbose cli   'C:\\Program Files (x86)\\nodejs\\node_modules\\npm\\bin\\npm-cli.js',
1 verbose cli   'install',
1 verbose cli   'bignum',
1 verbose cli   '--msvs_version=2012' ]
2 info using npm@1.4.9
3 info using node@v0.10.28
4 verbose node symlink C:\Program Files (x86)\nodejs\\node.exe
5 verbose cache add [ 'bignum', null ]
6 verbose cache add name=undefined spec="bignum" args=["bignum",null]
7 verbose parsed url { protocol: null,
7 verbose parsed url   slashes: null,
7 verbose parsed url   auth: null,
7 verbose parsed url   host: null,
7 verbose parsed url   port: null,
7 verbose parsed url   hostname: null,
7 verbose parsed url   hash: null,
7 verbose parsed url   search: null,
7 verbose parsed url   query: null,
7 verbose parsed url   pathname: 'bignum',
7 verbose parsed url   path: 'bignum',
7 verbose parsed url   href: 'bignum' }
8 silly lockFile 2c5ed189-bignum bignum
9 verbose lock bignum C:\Users\Administrator\AppData\Roaming\npm-cache\2c5ed189-bignum.lock
10 silly lockFile 2c5ed189-bignum bignum
11 silly lockFile 2c5ed189-bignum bignum
12 verbose addNamed [ 'bignum', '' ]
13 verbose addNamed [ null, '*' ]
14 silly lockFile b970923f-bignum bignum@
15 verbose lock bignum@ C:\Users\Administrator\AppData\Roaming\npm-cache\b970923f-bignum.lock
16 silly addNameRange { name: 'bignum', range: '*', hasData: false }
17 verbose url raw bignum
18 verbose url resolving [ 'https://registry.npmjs.org/', './bignum' ]
19 verbose url resolved https://registry.npmjs.org/bignum
20 info trying registry request attempt 1 at 15:05:59
21 verbose etag "AQJKN2WV1YYHDQLPVSQCKW90L"
22 http GET https://registry.npmjs.org/bignum
23 http 304 https://registry.npmjs.org/bignum
24 silly registry.get cb [ 304,
24 silly registry.get   { date: 'Tue, 03 Jun 2014 22:05:51 GMT',
24 silly registry.get     server: 'Apache',
24 silly registry.get     via: '1.1 varnish',
24 silly registry.get     'last-modified': 'Tue, 03 Jun 2014 22:05:52 GMT',
24 silly registry.get     'cache-control': 'max-age=1',
24 silly registry.get     etag: '"AQJKN2WV1YYHDQLPVSQCKW90L"',
24 silly registry.get     'x-served-by': 'cache-lax1425-LAX',
24 silly registry.get     'x-cache': 'MISS',
24 silly registry.get     'x-cache-hits': '0',
24 silly registry.get     'x-timer': 'S1401833151.833257,VS0,VE171',
24 silly registry.get     vary: 'Accept',
24 silly registry.get     'content-length': '0',
24 silly registry.get     'keep-alive': 'timeout=10, max=50',
24 silly registry.get     connection: 'Keep-Alive' } ]
25 verbose etag bignum from cache
26 silly addNameRange number 2 { name: 'bignum', range: '*', hasData: true }
27 silly addNameRange versions [ 'bignum',
27 silly addNameRange   [ '0.4.0',
27 silly addNameRange     '0.4.1',
27 silly addNameRange     '0.5.0',
27 silly addNameRange     '0.5.1',
27 silly addNameRange     '0.5.2',
27 silly addNameRange     '0.5.3',
27 silly addNameRange     '0.5.4',
27 silly addNameRange     '0.6.0',
27 silly addNameRange     '0.6.1',
27 silly addNameRange     '0.6.2',
27 silly addNameRange     '0.7.0' ] ]
28 verbose addNamed [ 'bignum', '0.7.0' ]
29 verbose addNamed [ '0.7.0', '0.7.0' ]
30 silly lockFile 77d8773b-bignum-0-7-0 bignum@0.7.0
31 verbose lock bignum@0.7.0 C:\Users\Administrator\AppData\Roaming\npm-cache\77d8773b-bignum-0-7-0.lock
32 silly lockFile 77d8773b-bignum-0-7-0 bignum@0.7.0
33 silly lockFile 77d8773b-bignum-0-7-0 bignum@0.7.0
34 silly lockFile b970923f-bignum bignum@
35 silly lockFile b970923f-bignum bignum@
36 silly resolved [ { name: 'bignum',
36 silly resolved     version: '0.7.0',
36 silly resolved     description: 'Arbitrary-precision integer arithmetic using OpenSSL',
36 silly resolved     main: './index.js',
36 silly resolved     repository:
36 silly resolved      { type: 'git',
36 silly resolved        url: 'http://github.com/justmoon/node-bignum.git' },
36 silly resolved     keywords:
36 silly resolved      [ 'openssl',
36 silly resolved        'big',
36 silly resolved        'bignum',
36 silly resolved        'bigint',
36 silly resolved        'integer',
36 silly resolved        'arithmetic',
36 silly resolved        'precision' ],
36 silly resolved     author:
36 silly resolved      { name: 'Stefan Thomas',
36 silly resolved        email: 'justmoon@members.fsf.org',
36 silly resolved        url: 'http://www.justmoon.net' },
36 silly resolved     dependencies: { nan: '~1.0.0' },
36 silly resolved     devDependencies: { expresso: '>=0.6.0', binary: '>=0.1.7', put: '>=0.0.5' },
36 silly resolved     license: 'MIT/X11',
36 silly resolved     engine: { node: '>=0.8.0' },
36 silly resolved     scripts: { install: 'node-gyp configure build', test: 'expresso' },
36 silly resolved     contributors: [ [Object] ],
36 silly resolved     readme: 'bignum\n======\n\nArbitrary precision integral arithmetic for Node.js using\nOpenSSL.\n\nThis library is based on\n[node-bigint](https://github.com/substack/node-bigint) by\n[substack](https://github.com/substack), but instead of using libgmp,\nit uses the builtin bignum functionality provided by OpenSSL. The\nadvantage is that OpenSSL is already part of Node.js, so this\nlibrary does not add any external dependency whatsoever.\n\ndifferences\n===========\n\nWhen switching from node-bigint to node-bignum, please be aware of\nthese differences:\n\n- Bignum rounds towards zero for integer divisions, e.g. `10 / -3 = -3`, whereas bigint\n  rounds towards negative infinity, e.g. `10 / -3 = -4`.\n- Bitwise operations (and, or, xor) are implemented for positive numbers only.\n- nextPrime() is not supported.\n- sqrt() and root() are not supported.\n\n(Patches for the missing functionality are welcome.)\n\nexample\n=======\n\nsimple.js\n---------\n\n    var bignum = require(\'bignum\');\n\n    var b = bignum(\'782910138827292261791972728324982\')\n        .sub(\'182373273283402171237474774728373\')\n        .div(8)\n    ;\n    console.log(b);\n\n***\n    $ node simple.js\n    <Bignum 75067108192986261319312244199576>\n\nperfect.js\n----------\n\nGenerate the perfect numbers:\n\n    // If 2**n-1 is prime, then (2**n-1) * 2**(n-1) is perfect.\n    var bignum = require(\'bignum\');\n\n    for (var n = 0; n < 100; n++) {\n        var p = bignum.pow(2, n).sub(1);\n        if (p.probPrime(50)) {\n            var perfect = p.mul(bignum.pow(2, n - 1));\n            console.log(perfect.toString());\n        }\n    }\n\n***\n\n    6\n    28\n    496\n    8128\n    33550336\n    8589869056\n    137438691328\n    2305843008139952128\n    2658455991569831744654692615953842176\n    191561942608236107294793378084303638130997321548169216\n\nmethods[0]\n==========\n\nbignum(n, base=10)\n------------------\n\nCreate a new `bignum` from `n` and a base. `n` can be a string, integer, or\nanother `bignum`.\n\nIf you pass in a string you can set the base that string is encoded in.\n\n.toString(base=10)\n------------------\n\nPrint out the `bignum` instance in the requested base as a string.\n\nbignum.fromBuffer(buf, opts)\n----------------------------\n\nCreate a new `bignum` from a `Buffer`.\n\nThe default options are:\n\n    {\n        endian : \'big\',\n        size : 1, // number of bytes in each word\n    }\n\nNote that endian doesn\'t matter when size = 1. If you wish to reverse the entire buffer byte by byte, pass size: \'auto\'.\n\nbignum.prime(bits, safe=true)\n-----------------------------\n\nGenerate a probable prime of length `bits`. If `safe` is true, it will be a "safe" prime of the form p=2p\'+1 where p\' is also prime.\n\nmethods[1]\n==========\n\nFor all of the instance methods below you can write either\n\n    bignum.method(x, y, z)\n\nor if x is a `bignum` instance``\n\n    x.method(y, z)\n\n.toNumber()\n-----------\n\nTurn a `bignum` into a `Number`. If the `bignum` is too big you\'ll lose\nprecision or you\'ll get ±`Infinity`.\n\n.toBuffer(opts)\n-------------\n\nReturn a new `Buffer` with the data from the `bignum`.\n\nThe default options are:\n\n    {\n        endian : \'big\',\n        size : 1, // number of bytes in each word\n    }\n\nNote that endian doesn\'t matter when size = 1. If you wish to reverse the entire buffer byte by byte, pass size: \'auto\'.\n\n.add(n)\n-------\n\nReturn a new `bignum` containing the instance value plus `n`.\n\n.sub(n)\n-------\n\nReturn a new `bignum` containing the instance value minus `n`.\n\n.mul(n)\n-------\n\nReturn a new `bignum` containing the instance value multiplied by `n`.\n\n.div(n)\n-------\n\nReturn a new `bignum` containing the instance value integrally divided by `n`.\n\n.abs()\n------\n\nReturn a new `bignum` with the absolute value of the instance.\n\n.neg()\n------\n\nReturn a new `bignum` with the negative of the instance value.\n\n.cmp(n)\n-------\n\nCompare the instance value to `n`. Return a positive integer if `> n`, a\nnegative integer if `< n`, and 0 if `== n`.\n\n.gt(n)\n------\n\nReturn a boolean: whether the instance value is greater than n (`> n`).\n\n.ge(n)\n------\n\nReturn a boolean: whether the instance value is greater than or equal to n\n(`>= n`).\n\n.eq(n)\n------\n\nReturn a boolean: whether the instance value is equal to n (`== n`).\n\n.lt(n)\n------\n\nReturn a boolean: whether the instance value is less than n (`< n`).\n\n.le(n)\n------\n\nReturn a boolean: whether the instance value is less than or equal to n\n(`<= n`).\n\n.and(n)\n-------\n\nReturn a new `bignum` with the instance value bitwise AND (&)-ed with `n`.\n\n.or(n)\n------\n\nReturn a new `bignum` with the instance value bitwise inclusive-OR (|)-ed with\n`n`.\n\n.xor(n)\n-------\n\nReturn a new `bignum` with the instance value bitwise exclusive-OR (^)-ed with\n`n`.\n\n.mod(n)\n-------\n\nReturn a new `bignum` with the instance value modulo `n`.\n\n`m`.\n.pow(n)\n-------\n\nReturn a new `bignum` with the instance value raised to the `n`th power.\n\n.powm(n, m)\n-----------\n\nReturn a new `bignum` with the instance value raised to the `n`th power modulo\n`m`.\n\n.invertm(m)\n-----------\n\nCompute the multiplicative inverse modulo `m`.\n\n.rand()\n-------\n.rand(upperBound)\n-----------------\n\nIf `upperBound` is supplied, return a random `bignum` between the instance value\nand `upperBound - 1`, inclusive.\n\nOtherwise, return a random `bignum` between 0 and the instance value - 1,\ninclusive.\n\n.probPrime()\n------------\n\nReturn whether the bignum is:\n\n* certainly prime (true)\n* probably prime (\'maybe\')\n* certainly composite (false)\n\nusing [BN_is_prime_ex](http://www.openssl.org/docs/crypto/BN_generate_prime.html).\n\n.sqrt()\n-------\n\nReturn a new `bignum` that is the square root. This truncates.\n\n.root(n)\n-------\n\nReturn a new `bignum` that is the `nth` root. This truncates.\n\n.shiftLeft(n)\n-------------\n\nReturn a new `bignum` that is the `2^n` multiple. Equivalent of the `<<`\noperator.\n\n.shiftRight(n)\n--------------\n\nReturn a new `bignum` of the value integer divided by\n`2^n`. Equivalent of the `>>` operator.\n\n.gcd(n)\n-------\n\nReturn the greatest common divisor of the current `bignum` with `n` as a new\n`bignum`.\n\n.jacobi(n)\n-------\n\nReturn the Jacobi symbol (or Legendre symbol if `n` is prime) of the current\n`bignum` (= a) over `n`. Note that `n` must be odd and >= 3. 0 <= a < n.\n\nReturns -1 or 1 as an int (NOT a bignum). Throws an error on failure.\n\n.bitLength()\n------------\n\nReturn the number of bits used to represent the current `bignum`.\n\ninstall\n=======\n\nTo compile the package, your system needs to be set up for building Node.js\nmodules.\n\nYou can install node-bignum with [npm](http://npmjs.org):\n\n    npm install bignum\n\ndevelop\n=======\n\nYou can clone the git repo and compile with\n\n    git clone git://github.com/justmoon/node-bignum.git\n    cd node-bignum\n    npm install\n\nRun the tests with\n\n    npm test\n',
36 silly resolved     readmeFilename: 'README.markdown',
36 silly resolved     bugs: { url: 'https://github.com/justmoon/node-bignum/issues' },
36 silly resolved     homepage: 'https://github.com/justmoon/node-bignum',
36 silly resolved     _id: 'bignum@0.7.0',
36 silly resolved     _shasum: '95355f01f0c096f3a17290565d5ca657d6440744',
36 silly resolved     _from: 'bignum@',
36 silly resolved     _resolved: 'https://registry.npmjs.org/bignum/-/bignum-0.7.0.tgz' } ]
37 info install bignum@0.7.0 into C:\temp\test
38 info installOne bignum@0.7.0
39 info C:\temp\test\node_modules\bignum unbuild
40 verbose tar unpack C:\Users\Administrator\AppData\Roaming\npm-cache\bignum\0.7.0\package.tgz
41 silly lockFile 5eefa0e2--C-temp-test-node-modules-bignum tar://C:\temp\test\node_modules\bignum
42 verbose lock tar://C:\temp\test\node_modules\bignum C:\Users\Administrator\AppData\Roaming\npm-cache\5eefa0e2--C-temp-test-node-modules-bignum.lock
43 silly lockFile 6d5f7228-m-cache-bignum-0-7-0-package-tgz tar://C:\Users\Administrator\AppData\Roaming\npm-cache\bignum\0.7.0\package.tgz
44 verbose lock tar://C:\Users\Administrator\AppData\Roaming\npm-cache\bignum\0.7.0\package.tgz C:\Users\Administrator\AppData\Roaming\npm-cache\6d5f7228-m-cache-bignum-0-7-0-package-tgz.lock
45 silly gunzTarPerm modes [ '755', '644' ]
46 silly gunzTarPerm extractEntry package.json
47 silly gunzTarPerm extractEntry .npmignore
48 silly gunzTarPerm extractEntry index.js
49 silly gunzTarPerm extractEntry .dntrc
50 silly gunzTarPerm extractEntry .travis.yml
51 silly gunzTarPerm extractEntry README.markdown
52 silly gunzTarPerm extractEntry bignum.cc
53 silly gunzTarPerm extractEntry binding.gyp
54 silly gunzTarPerm extractEntry examples/gen.js
55 silly gunzTarPerm extractEntry examples/perfect.js
56 silly gunzTarPerm extractEntry examples/simple.js
57 silly gunzTarPerm extractEntry test/big.js
58 silly gunzTarPerm extractEntry test/buf.js
59 silly gunzTarPerm extractEntry test/seed.js
60 silly lockFile 5eefa0e2--C-temp-test-node-modules-bignum tar://C:\temp\test\node_modules\bignum
61 silly lockFile 5eefa0e2--C-temp-test-node-modules-bignum tar://C:\temp\test\node_modules\bignum
62 silly lockFile 6d5f7228-m-cache-bignum-0-7-0-package-tgz tar://C:\Users\Administrator\AppData\Roaming\npm-cache\bignum\0.7.0\package.tgz
63 silly lockFile 6d5f7228-m-cache-bignum-0-7-0-package-tgz tar://C:\Users\Administrator\AppData\Roaming\npm-cache\bignum\0.7.0\package.tgz
64 info preinstall bignum@0.7.0
65 verbose readDependencies using package.json deps
66 verbose readDependencies using package.json deps
67 verbose cache add [ 'nan@~1.0.0', null ]
68 verbose cache add name=undefined spec="nan@~1.0.0" args=["nan@~1.0.0",null]
69 verbose parsed url { protocol: null,
69 verbose parsed url   slashes: null,
69 verbose parsed url   auth: null,
69 verbose parsed url   host: null,
69 verbose parsed url   port: null,
69 verbose parsed url   hostname: null,
69 verbose parsed url   hash: null,
69 verbose parsed url   search: null,
69 verbose parsed url   query: null,
69 verbose parsed url   pathname: 'nan@~1.0.0',
69 verbose parsed url   path: 'nan@~1.0.0',
69 verbose parsed url   href: 'nan@~1.0.0' }
70 verbose cache add name="nan" spec="~1.0.0" args=["nan","~1.0.0"]
71 verbose parsed url { protocol: null,
71 verbose parsed url   slashes: null,
71 verbose parsed url   auth: null,
71 verbose parsed url   host: null,
71 verbose parsed url   port: null,
71 verbose parsed url   hostname: null,
71 verbose parsed url   hash: null,
71 verbose parsed url   search: null,
71 verbose parsed url   query: null,
71 verbose parsed url   pathname: '~1.0.0',
71 verbose parsed url   path: '~1.0.0',
71 verbose parsed url   href: '~1.0.0' }
72 verbose addNamed [ 'nan', '~1.0.0' ]
73 verbose addNamed [ null, '>=1.0.0-0 <1.1.0-0' ]
74 silly lockFile 66a60b03-nan-1-0-0 nan@~1.0.0
75 verbose lock nan@~1.0.0 C:\Users\Administrator\AppData\Roaming\npm-cache\66a60b03-nan-1-0-0.lock
76 silly addNameRange { name: 'nan', range: '>=1.0.0-0 <1.1.0-0', hasData: false }
77 verbose url raw nan
78 verbose url resolving [ 'https://registry.npmjs.org/', './nan' ]
79 verbose url resolved https://registry.npmjs.org/nan
80 info trying registry request attempt 1 at 15:05:59
81 verbose etag "ARDQ81ENXNX1F9W06GIOP93F9"
82 http GET https://registry.npmjs.org/nan
83 http 304 https://registry.npmjs.org/nan
84 silly registry.get cb [ 304,
84 silly registry.get   { date: 'Tue, 03 Jun 2014 22:05:52 GMT',
84 silly registry.get     server: 'Apache',
84 silly registry.get     via: '1.1 varnish',
84 silly registry.get     'last-modified': 'Tue, 03 Jun 2014 22:05:14 GMT',
84 silly registry.get     'cache-control': 'max-age=1',
84 silly registry.get     etag: '"ARDQ81ENXNX1F9W06GIOP93F9"',
84 silly registry.get     'x-served-by': 'cache-lax1424-LAX',
84 silly registry.get     'x-cache': 'HIT',
84 silly registry.get     'x-cache-hits': '5',
84 silly registry.get     'x-timer': 'S1401833152.199757,VS0,VE0',
84 silly registry.get     vary: 'Accept',
84 silly registry.get     'content-length': '0',
84 silly registry.get     'keep-alive': 'timeout=10, max=50',
84 silly registry.get     connection: 'Keep-Alive' } ]
85 verbose etag nan from cache
86 silly addNameRange number 2 { name: 'nan', range: '>=1.0.0-0 <1.1.0-0', hasData: true }
87 silly addNameRange versions [ 'nan',
87 silly addNameRange   [ '0.3.0-wip',
87 silly addNameRange     '0.3.0-wip2',
87 silly addNameRange     '0.3.0',
87 silly addNameRange     '0.3.1',
87 silly addNameRange     '0.3.2',
87 silly addNameRange     '0.4.0',
87 silly addNameRange     '0.4.1',
87 silly addNameRange     '0.4.2',
87 silly addNameRange     '0.4.3',
87 silly addNameRange     '0.4.4',
87 silly addNameRange     '0.5.0',
87 silly addNameRange     '0.5.1',
87 silly addNameRange     '0.5.2',
87 silly addNameRange     '0.6.0',
87 silly addNameRange     '0.7.0',
87 silly addNameRange     '0.7.1',
87 silly addNameRange     '0.8.0',
87 silly addNameRange     '1.0.0',
87 silly addNameRange     '1.1.0',
87 silly addNameRange     '1.1.1',
87 silly addNameRange     '1.1.2' ] ]
88 verbose addNamed [ 'nan', '1.0.0' ]
89 verbose addNamed [ '1.0.0', '1.0.0' ]
90 silly lockFile cc7fa090-nan-1-0-0 nan@1.0.0
91 verbose lock nan@1.0.0 C:\Users\Administrator\AppData\Roaming\npm-cache\cc7fa090-nan-1-0-0.lock
92 silly lockFile cc7fa090-nan-1-0-0 nan@1.0.0
93 silly lockFile cc7fa090-nan-1-0-0 nan@1.0.0
94 silly lockFile 66a60b03-nan-1-0-0 nan@~1.0.0
95 silly lockFile 66a60b03-nan-1-0-0 nan@~1.0.0
96 silly resolved [ { name: 'nan',
96 silly resolved     version: '1.0.0',
96 silly resolved     description: 'Native Abstractions for Node.js: C++ header for Node 0.8->0.12 compatibility',
96 silly resolved     main: 'include_dirs.js',
96 silly resolved     repository: { type: 'git', url: 'git://github.com/rvagg/nan.git' },
96 silly resolved     contributors: [ [Object], [Object], [Object], [Object], [Object], [Object] ],
96 silly resolved     license: 'MIT',
96 silly resolved     readme: 'Native Abstractions for Node.js\n===============================\n\n**A header file filled with macro and utility goodness for making add-on development for Node.js easier across versions 0.8, 0.10 and 0.11, and eventually 0.12.**\n\n***Current version: 1.0.0*** *(See [nan.h](https://github.com/rvagg/nan/blob/master/nan.h) for complete ChangeLog)*\n\n[![NPM](https://nodei.co/npm/nan.png?downloads=true)](https://nodei.co/npm/nan/) [![NPM](https://nodei.co/npm-dl/nan.png?months=6)](https://nodei.co/npm/nan/)\n\nThanks to the crazy changes in V8 (and some in Node core), keeping native addons compiling happily across versions, particularly 0.10 to 0.11/0.12, is a minor nightmare. The goal of this project is to store all logic necessary to develop native Node.js addons without having to inspect `NODE_MODULE_VERSION` and get yourself into a macro-tangle.\n\nThis project also contains some helper utilities that make addon development a bit more pleasant.\n\n * **[News & Updates](#news)**\n * **[Usage](#usage)**\n * **[Example](#example)**\n * **[API](#api)**\n\n<a name="news"></a>\n## News & Updates\n\n### May-2013: Major changes for V8 3.25 / Node 0.11.13\n\nNode 0.11.11 and 0.11.12 were both broken releases for native add-ons, you simply can\'t properly compile against either of them for different reasons. But we now have a 0.11.13 release that jumps a couple of versions of V8 ahead and includes some more, major (traumatic) API changes.\n\nBecause we are now nearing Node 0.12 and estimate that the version of V8 we are using in Node 0.11.13 will be close to the API we get for 0.12, we have taken the opportunity to not only *fix* NAN for 0.11.13 but make some major changes to improve the NAN API.\n\nWe have **removed support for Node 0.11 versions prior to 0.11.13**, (although our tests are still passing for 0.11.10). As usual, our tests are run against (and pass) the last 5 versions of Node 0.8 and Node 0.10. We also include Node 0.11.13 obviously.\n\nThe major change is something that [Benjamin Byholm](kkoopa) has put many hours in to. We now have a fantastic new `NanNew<T>(args)` interface for creating new `Local`s, this replaces `NanNewLocal()` and much more. If you look in [./nan.h](nan.h) you\'ll see a large number of overloaded versions of this method. In general you should be able to `NanNew<Type>(arguments)` for any type you want to make a `Local` from. This includes `Persistent` types, so we now have a `Local<T> NanNew(const Persistent<T> arg)` to replace `NanPersistentToLocal()`.\n\nWe also now have `NanUndefined()`, `NanNull()`, `NanTrue()` and `NanFalse()`. Mainly because of the new requirement for an `Isolate` argument for each of the native V8 versions of this.\n\nV8 has now introduced an `EscapableHandleScope` from which you `scope.Escape(Local<T> value)` to *return* a value from a one scope to another. This replaces the standard `HandleScope` and `scope.Close(Local<T> value)`, although `HandleScope` still exists for when you don\'t need to return a handle to the caller. For NAN we are exposing it as `NanEscapableScope()` and `NanEscapeScope()`, while `NanScope()` is still how you create a new scope that doesn\'t need to return handles. For older versions of Node/V8, it\'ll still map to the older `HandleScope` functionality.\n\n`NanFromV8String()` was deprecated and has now been removed. You should use `NanCString()` or `NanRawString()` instead.\n\nBecause `node::MakeCallback()` now takes an `Isolate`, and because it doesn\'t exist in older versions of Node, we\'ve introduced `NanMakeCallabck()`. You should *always* use this when calling a JavaScript function from C++.\n\nThere\'s lots more, check out the Changelog in nan.h or look through [#86](https://github.com/rvagg/nan/pull/86) for all the gory details.\n\n### Dec-2013: NanCString and NanRawString\n\nTwo new functions have been introduced to replace the functionality that\'s been provided by `NanFromV8String` until now. NanCString has sensible defaults so it\'s super easy to fetch a null-terminated c-style string out of a `v8::String`. `NanFromV8String` is still around and has defaults that allow you to pass a single handle to fetch a `char*` while `NanRawString` requires a little more attention to arguments.\n\n### Nov-2013: Node 0.11.9+ breaking V8 change\n\nThe version of V8 that\'s shipping with Node 0.11.9+ has changed the signature for new `Local`s to: `v8::Local<T>::New(isolate, value)`, i.e. introducing the `isolate` argument and therefore breaking all new `Local` declarations for previous versions. NAN 0.6+ now includes a `NanNewLocal<T>(value)` that can be used in place to work around this incompatibility and maintain compatibility with 0.8->0.11.9+ (minus a few early 0.11 releases).\n\nFor example, if you wanted to return a `null` on a callback you will have to change the argument from `v8::Local<v8::Value>::New(v8::Null())` to `NanNewLocal<v8::Value>(v8::Null())`.\n\n### Nov-2013: Change to binding.gyp `"include_dirs"` for NAN\n\nInclusion of NAN in a project\'s binding.gyp is now greatly simplified. You can now just use `"<!(node -e \\"require(\'nan\')\\")"` in your `"include_dirs"`, see example below (note Windows needs the quoting around `require` to be just right: `"require(\'nan\')"` with appropriate `\\` escaping).\n\n<a name="usage"></a>\n## Usage\n\nSimply add **NAN** as a dependency in the *package.json* of your Node addon:\n\n``` bash\n$ npm install --save nan\n```\n\nPull in the path to **NAN** in your *binding.gyp* so that you can use `#include <nan.h>` in your *.cpp* files:\n\n``` python\n"include_dirs" : [\n    "<!(node -e \\"require(\'nan\')\\")"\n]\n```\n\nThis works like a `-I<path-to-NAN>` when compiling your addon.\n\n<a name="example"></a>\n## Example\n\nSee **[LevelDOWN](https://github.com/rvagg/node-leveldown/pull/48)** for a full example of **NAN** in use.\n\nFor a simpler example, see the **[async pi estimation example](https://github.com/rvagg/nan/tree/master/examples/async_pi_estimate)** in the examples directory for full code and an explanation of what this Monte Carlo Pi estimation example does. Below are just some parts of the full example that illustrate the use of **NAN**.\n\nCompare to the current 0.10 version of this example, found in the [node-addon-examples](https://github.com/rvagg/node-addon-examples/tree/master/9_async_work) repository and also a 0.11 version of the same found [here](https://github.com/kkoopa/node-addon-examples/tree/5c01f58fc993377a567812597e54a83af69686d7/9_async_work).\n\nNote that there is no embedded version sniffing going on here and also the async work is made much simpler, see below for details on the `NanAsyncWorker` class.\n\n```c++\n// addon.cc\n#include <node.h>\n#include <nan.h>\n// ...\n\nusing v8::FunctionTemplate;\nusing v8::Handle;\nusing v8::Object;\n\nvoid InitAll(Handle<Object> exports) {\n  exports->Set(NanSymbol("calculateSync"),\n    NanNew<FunctionTemplate>(CalculateSync)->GetFunction());\n\n  exports->Set(NanSymbol("calculateAsync"),\n    NanNew<FunctionTemplate>(CalculateAsync)->GetFunction());\n}\n\nNODE_MODULE(addon, InitAll)\n```\n\n```c++\n// sync.h\n#include <node.h>\n#include <nan.h>\n\nNAN_METHOD(CalculateSync);\n```\n\n```c++\n// sync.cc\n#include <node.h>\n#include <nan.h>\n#include "./sync.h"\n// ...\n\nusing v8::Number;\n\n// Simple synchronous access to the `Estimate()` function\nNAN_METHOD(CalculateSync) {\n  NanScope();\n\n  // expect a number as the first argument\n  int points = args[0]->Uint32Value();\n  double est = Estimate(points);\n\n  NanReturnValue(NanNew<Number>(est));\n}\n```\n\n```c++\n// async.cc\n#include <node.h>\n#include <nan.h>\n#include "./async.h"\n\n// ...\n\nusing v8::Function;\nusing v8::Local;\nusing v8::Null;\nusing v8::Number;\nusing v8::Value;\n\nclass PiWorker : public NanAsyncWorker {\n public:\n  PiWorker(NanCallback *callback, int points)\n    : NanAsyncWorker(callback), points(points) {}\n  ~PiWorker() {}\n\n  // Executed inside the worker-thread.\n  // It is not safe to access V8, or V8 data structures\n  // here, so everything we need for input and output\n  // should go on `this`.\n  void Execute () {\n    estimate = Estimate(points);\n  }\n\n  // Executed when the async work is complete\n  // this function will be run inside the main event loop\n  // so it is safe to use V8 again\n  void HandleOKCallback () {\n    NanScope();\n\n    Local<Value> argv[] = {\n        NanNew(NanNull())\n      , NanNew<Number>(estimate)\n    };\n\n    callback->Call(2, argv);\n  };\n\n private:\n  int points;\n  double estimate;\n};\n\n// Asynchronous access to the `Estimate()` function\nNAN_METHOD(CalculateAsync) {\n  NanScope();\n\n  int points = args[0]->Uint32Value();\n  NanCallback *callback = new NanCallback(args[1].As<Function>());\n\n  NanAsyncQueueWorker(new PiWorker(callback, points));\n  NanReturnUndefined();\n}\n```\n\n<a name="api"></a>\n## API\n\n * <a href="#api_nan_method"><b><code>NAN_METHOD</code></b></a>\n * <a href="#api_nan_getter"><b><code>NAN_GETTER</code></b></a>\n * <a href="#api_nan_setter"><b><code>NAN_SETTER</code></b></a>\n * <a href="#api_nan_property_getter"><b><code>NAN_PROPERTY_GETTER</code></b></a>\n * <a href="#api_nan_property_setter"><b><code>NAN_PROPERTY_SETTER</code></b></a>\n * <a href="#api_nan_property_enumerator"><b><code>NAN_PROPERTY_ENUMERATOR</code></b></a>\n * <a href="#api_nan_property_deleter"><b><code>NAN_PROPERTY_DELETER</code></b></a>\n * <a href="#api_nan_property_query"><b><code>NAN_PROPERTY_QUERY</code></b></a>\n * <a href="#api_nan_index_getter"><b><code>NAN_INDEX_GETTER</code></b></a>\n * <a href="#api_nan_index_setter"><b><code>NAN_INDEX_SETTER</code></b></a>\n * <a href="#api_nan_index_enumerator"><b><code>NAN_INDEX_ENUMERATOR</code></b></a>\n * <a href="#api_nan_index_deleter"><b><code>NAN_INDEX_DELETER</code></b></a>\n * <a href="#api_nan_index_query"><b><code>NAN_INDEX_QUERY</code></b></a>\n * <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK</code></b></a>\n * <a href="#api_nan_deprecated"><b><code>NAN_DEPRECATED</code></b></a>\n * <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>\n * <a href="#api_nan_new"><b><code>NanNew</code></b></a>\n * <a href="#api_nan_undefined"><b><code>NanUndefined</code></b></a>\n * <a href="#api_nan_null"><b><code>NanNull</code></b></a>\n * <a href="#api_nan_true"><b><code>NanTrue</code></b></a>\n * <a href="#api_nan_false"><b><code>NanFalse</code></b></a>\n * <a href="#api_nan_return_value"><b><code>NanReturnValue</code></b></a>\n * <a href="#api_nan_return_undefined"><b><code>NanReturnUndefined</code></b></a>\n * <a href="#api_nan_return_null"><b><code>NanReturnNull</code></b></a>\n * <a href="#api_nan_return_empty_string"><b><code>NanReturnEmptyString</code></b></a>\n * <a href="#api_nan_scope"><b><code>NanScope</code></b></a>\n * <a href="#api_nan_escapable_scope"><b><code>NanEscapableScope</code></b></a>\n * <a href="#api_nan_escape_scope"><b><code>NanEscapeScope</code></b></a>\n * <a href="#api_nan_locker"><b><code>NanLocker</code></b></a>\n * <a href="#api_nan_unlocker"><b><code>NanUnlocker</code></b></a>\n * <a href="#api_nan_get_internal_field_pointer"><b><code>NanGetInternalFieldPointer</code></b></a>\n * <a href="#api_nan_set_internal_field_pointer"><b><code>NanSetInternalFieldPointer</code></b></a>\n * <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>\n * <a href="#api_nan_symbol"><b><code>NanSymbol</code></b></a>\n * <a href="#api_nan_get_pointer_safe"><b><code>NanGetPointerSafe</code></b></a>\n * <a href="#api_nan_set_pointer_safe"><b><code>NanSetPointerSafe</code></b></a>\n * <a href="#api_nan_raw_string"><b><code>NanRawString</code></b></a>\n * <a href="#api_nan_c_string"><b><code>NanCString</code></b></a>\n * <a href="#api_nan_boolean_option_value"><b><code>NanBooleanOptionValue</code></b></a>\n * <a href="#api_nan_uint32_option_value"><b><code>NanUInt32OptionValue</code></b></a>\n * <a href="#api_nan_error"><b><code>NanError</code></b>, <b><code>NanTypeError</code></b>, <b><code>NanRangeError</code></b></a>\n * <a href="#api_nan_throw_error"><b><code>NanThrowError</code></b>, <b><code>NanThrowTypeError</code></b>, <b><code>NanThrowRangeError</code></b>, <b><code>NanThrowError(Handle<Value>)</code></b>, <b><code>NanThrowError(Handle<Value>, int)</code></b></a>\n * <a href="#api_nan_new_buffer_handle"><b><code>NanNewBufferHandle(char *, size_t, FreeCallback, void *)</code></b>, <b><code>NanNewBufferHandle(char *, uint32_t)</code></b>, <b><code>NanNewBufferHandle(uint32_t)</code></b></a>\n * <a href="#api_nan_buffer_use"><b><code>NanBufferUse(char *, uint32_t)</code></b></a>\n * <a href="#api_nan_new_context_handle"><b><code>NanNewContextHandle</code></b></a>\n * <a href="#api_nan_get_current_context"><b><code>NanGetCurrentContext</code></b></a>\n * <a href="#api_nan_has_instance"><b><code>NanHasInstance</code></b></a>\n * <a href="#api_nan_dispose_persistent"><b><code>NanDisposePersistent</code></b></a>\n * <a href="#api_nan_assign_persistent"><b><code>NanAssignPersistent</code></b></a>\n * <a href="#api_nan_make_weak_persistent"><b><code>NanMakeWeakPersistent</code></b></a>\n * <a href="#api_nan_set_template"><b><code>NanSetTemplate</code></b></a>\n * <a href="#api_nan_make_callback"><b><code>NanMakeCallback</code></b></a>\n * <a href="#api_nan_compile_script"><b><code>NanCompileScript</code></b></a>\n * <a href="#api_nan_run_script"><b><code>NanRunScript</code></b></a>\n * <a href="#api_nan_adjust_external_memory"><b><code>NanAdjustExternalMemory</code></b></a>\n * <a href="#api_nan_add_gc_epilogue_callback"><b><code>NanAddGCEpilogueCallback</code></b></a>\n * <a href="#api_nan_add_gc_prologue_callback"><b><code>NanAddGCPrologueCallback</code></b></a>\n * <a href="#api_nan_remove_gc_epilogue_callback"><b><code>NanRemoveGCEpilogueCallback</code></b></a>\n * <a href="#api_nan_remove_gc_prologue_callback"><b><code>NanRemoveGCPrologueCallback</code></b></a>\n * <a href="#api_nan_get_heap_statistics"><b><code>NanGetHeapStatistics</code></b></a>\n * <a href="#api_nan_callback"><b><code>NanCallback</code></b></a>\n * <a href="#api_nan_async_worker"><b><code>NanAsyncWorker</code></b></a>\n * <a href="#api_nan_async_queue_worker"><b><code>NanAsyncQueueWorker</code></b></a>\n\n<a name="api_nan_method"></a>\n### NAN_METHOD(methodname)\n\nUse `NAN_METHOD` to define your V8 accessible methods:\n\n```c++\n// .h:\nclass Foo : public node::ObjectWrap {\n  ...\n\n  static NAN_METHOD(Bar);\n  static NAN_METHOD(Baz);\n}\n\n\n// .cc:\nNAN_METHOD(Foo::Bar) {\n  ...\n}\n\nNAN_METHOD(Foo::Baz) {\n  ...\n}\n```\n\nThe reason for this macro is because of the method signature change in 0.11:\n\n```c++\n// 0.10 and below:\nHandle<Value> name(const Arguments& args)\n\n// 0.11 and above\nvoid name(const FunctionCallbackInfo<Value>& args)\n```\n\nThe introduction of `FunctionCallbackInfo` brings additional complications:\n\n<a name="api_nan_getter"></a>\n### NAN_GETTER(methodname)\n\nUse `NAN_GETTER` to declare your V8 accessible getters. You get a `Local<String>` `property` and an appropriately typed `args` object that can act like the `args` argument to a `NAN_METHOD` call.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_GETTER`.\n\n<a name="api_nan_setter"></a>\n### NAN_SETTER(methodname)\n\nUse `NAN_SETTER` to declare your V8 accessible setters. Same as `NAN_GETTER` but you also get a `Local<Value>` `value` object to work with.\n\n<a name="api_nan_property_getter"></a>\n### NAN_PROPERTY_GETTER(cbname)\nUse `NAN_PROPERTY_GETTER` to declare your V8 accessible property getters. You get a `Local<String>` `property` and an appropriately typed `args` object that can act similar to the `args` argument to a `NAN_METHOD` call.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_GETTER`.\n\n<a name="api_nan_property_setter"></a>\n### NAN_PROPERTY_SETTER(cbname)\nUse `NAN_PROPERTY_SETTER` to declare your V8 accessible property setters. Same as `NAN_PROPERTY_GETTER` but you also get a `Local<Value>` `value` object to work with.\n\n<a name="api_nan_property_enumerator"></a>\n### NAN_PROPERTY_ENUMERATOR(cbname)\nUse `NAN_PROPERTY_ENUMERATOR` to declare your V8 accessible property enumerators. You get an appropriately typed `args` object like the `args` argument to a `NAN_PROPERTY_GETTER` call.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_ENUMERATOR`.\n\n<a name="api_nan_property_deleter"></a>\n### NAN_PROPERTY_DELETER(cbname)\nUse `NAN_PROPERTY_DELETER` to declare your V8 accessible property deleters. Same as `NAN_PROPERTY_GETTER`.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_DELETER`.\n\n<a name="api_nan_property_query"></a>\n### NAN_PROPERTY_QUERY(cbname)\nUse `NAN_PROPERTY_QUERY` to declare your V8 accessible property queries. Same as `NAN_PROPERTY_GETTER`.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_QUERY`.\n\n<a name="api_nan_index_getter"></a>\n### NAN_INDEX_GETTER(cbname)\nUse `NAN_INDEX_GETTER` to declare your V8 accessible index getters. You get a `uint32_t` `index` and an appropriately typed `args` object that can act similar to the `args` argument to a `NAN_METHOD` call.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_GETTER`.\n\n<a name="api_nan_index_setter"></a>\n### NAN_INDEX_SETTER(cbname)\nUse `NAN_INDEX_SETTER` to declare your V8 accessible index setters. Same as `NAN_INDEX_GETTER` but you also get a `Local<Value>` `value` object to work with.\n\n<a name="api_nan_index_enumerator"></a>\n### NAN_INDEX_ENUMERATOR(cbname)\nUse `NAN_INDEX_ENUMERATOR` to declare your V8 accessible index enumerators. You get an appropriately typed `args` object like the `args` argument to a `NAN_INDEX_GETTER` call.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_ENUMERATOR`.\n\n<a name="api_nan_index_deleter"></a>\n### NAN_INDEX_DELETER(cbname)\nUse `NAN_INDEX_DELETER` to declare your V8 accessible index deleters. Same as `NAN_INDEX_GETTER`.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_DELETER`.\n\n<a name="api_nan_index_query"></a>\n### NAN_INDEX_QUERY(cbname)\nUse `NAN_INDEX_QUERY` to declare your V8 accessible index queries. Same as `NAN_INDEX_GETTER`.\n\nYou can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_QUERY`.\n\n<a name="api_nan_weak_callback"></a>\n### NAN_WEAK_CALLBACK(cbname)\n\nUse `NAN_WEAK_CALLBACK` to define your V8 WeakReference callbacks. Do not use for declaration. There is an argument object `const _NanWeakCallbackData<T, P> &data` allowing access to the weak object and the supplied parameter through its `GetValue` and `GetParameter` methods.\n\n```c++\nNAN_WEAK_CALLBACK(weakCallback) {\n  int *parameter = data.GetParameter();\n  NanMakeCallback(NanGetCurrentContext()->Global(), data.GetValue(), 0, NULL);\n  if ((*parameter)++ == 0) {\n    data.Revive();\n  } else {\n    delete parameter;\n    data.Dispose();\n  }\n}\n```\n\n<a name="api_nan_deprecated"></a>\n### NAN_DEPRECATED\nDeclares a function as deprecated.\n\n```c++\nstatic NAN_DEPRECATED NAN_METHOD(foo) {\n  ...\n}\n```\n\n<a name="api_nan_inline"></a>\n### NAN_INLINE\nInlines a function.\n\n```c++\nNAN_INLINE int foo(int bar) {\n  ...\n}\n```\n\n<a name="api_nan_new"></a>\n### Local&lt;T&gt; NanNew&lt;T&gt;( ... )\n\nUse `NanNew` to construct almost all v8 objects and make new local handles.\n\n```c++\nLocal<String> s = NanNew<String>("value");\n\n...\n\nPersistent<Object> o;\n\n...\n\nLocal<Object> lo = NanNew(o);\n\n```\n\n<a name="api_nan_undefined"></a>\n### Handle&lt;Primitive&gt; NanUndefined()\n\nUse instead of `Undefined()`\n\n<a name="api_nan_null"></a>\n### Handle&lt;Primitive&gt; NanNull()\n\nUse instead of `Null()`\n\n<a name="api_nan_true"></a>\n### Handle&lt;Primitive&gt; NanTrue()\n\nUse instead of `True()`\n\n<a name="api_nan_false"></a>\n### Handle&lt;Primitive&gt; NanFalse()\n\nUse instead of `False()`\n\n<a name="api_nan_return_value"></a>\n### NanReturnValue(Handle&lt;Value&gt;)\n\nUse `NanReturnValue` when you want to return a value from your V8 accessible method:\n\n```c++\nNAN_METHOD(Foo::Bar) {\n  ...\n\n  NanReturnValue(NanNew<String>("FooBar!"));\n}\n```\n\nNo `return` statement required.\n\n<a name="api_nan_return_undefined"></a>\n### NanReturnUndefined()\n\nUse `NanReturnUndefined` when you don\'t want to return anything from your V8 accessible method:\n\n```c++\nNAN_METHOD(Foo::Baz) {\n  ...\n\n  NanReturnUndefined();\n}\n```\n\n<a name="api_nan_return_null"></a>\n### NanReturnNull()\n\nUse `NanReturnNull` when you want to return `Null` from your V8 accessible method:\n\n```c++\nNAN_METHOD(Foo::Baz) {\n  ...\n\n  NanReturnNull();\n}\n```\n\n<a name="api_nan_return_empty_string"></a>\n### NanReturnEmptyString()\n\nUse `NanReturnEmptyString` when you want to return an empty `String` from your V8 accessible method:\n\n```c++\nNAN_METHOD(Foo::Baz) {\n  ...\n\n  NanReturnEmptyString();\n}\n```\n\n<a name="api_nan_scope"></a>\n### NanScope()\n\nThe introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanScope()` necessary, use it in place of `HandleScope scope`:\n\n```c++\nNAN_METHOD(Foo::Bar) {\n  NanScope();\n\n  NanReturnValue(NanNew<String>("FooBar!"));\n}\n```\n\n<a name="api_nan_escapable_scope"></a>\n### NanEscapableScope()\n\nThe separation of handle scopes into escapable and inescapable scopes makes `NanEscapableScope()` necessary, use it in place of `HandleScope scope` when you later wish to `Close()` the scope:\n\n```c++\nHandle<String> Foo::Bar() {\n  NanEscapableScope();\n\n  return NanEscapeScope(NanNew<String>("FooBar!"));\n}\n```\n\n<a name="api_nan_esacpe_scope"></a>\n### Local&lt;T&gt; NanEscapeScope(Handle&lt;T&gt; value);\nUse together with `NanEscapableScope` to escape the scope. Corresponds to `HandleScope::Close` or `EscapableHandleScope::Escape`.\n\n<a name="api_nan_locker"></a>\n### NanLocker()\n\nThe introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanLocker()` necessary, use it in place of `Locker locker`:\n\n```c++\nNAN_METHOD(Foo::Bar) {\n  NanLocker();\n  ...\n  NanUnlocker();\n}\n```\n\n<a name="api_nan_unlocker"></a>\n### NanUnlocker()\n\nThe introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanUnlocker()` necessary, use it in place of `Unlocker unlocker`:\n\n```c++\nNAN_METHOD(Foo::Bar) {\n  NanLocker();\n  ...\n  NanUnlocker();\n}\n```\n\n<a name="api_nan_get_internal_field_pointer"></a>\n### void * NanGetInternalFieldPointer(Handle&lt;Object&gt;, int)\n\nGets a pointer to the internal field with at `index` from a V8 `Object` handle.\n\n```c++\nLocal<Object> obj;\n...\nNanGetInternalFieldPointer(obj, 0);\n```\n<a name="api_nan_set_internal_field_pointer"></a>\n### void NanSetInternalFieldPointer(Handle&lt;Object&gt;, int, void *)\n\nSets the value of the internal field at `index` on a V8 `Object` handle.\n\n```c++\nstatic Persistent<Function> dataWrapperCtor;\n...\nLocal<Object> wrapper = NanPersistentToLocal(dataWrapperCtor)->NewInstance();\nNanSetInternalFieldPointer(wrapper, 0, this);\n```\n\n<a name="api_nan_object_wrap_handle"></a>\n### Local&lt;Object&gt; NanObjectWrapHandle(Object)\n\nWhen you want to fetch the V8 object handle from a native object you\'ve wrapped with Node\'s `ObjectWrap`, you should use `NanObjectWrapHandle`:\n\n```c++\nNanObjectWrapHandle(iterator)->Get(NanSymbol("end"))\n```\n\n<a name="api_nan_symbol"></a>\n### String NanSymbol(char *)\n\nUse to create string symbol objects (i.e. `v8::String::NewSymbol(x)`), for getting and setting object properties, or names of objects.\n\n```c++\nbool foo = false;\nif (obj->Has(NanSymbol("foo")))\n  foo = optionsObj->Get(NanSymbol("foo"))->BooleanValue()\n```\n\n<a name="api_nan_get_pointer_safe"></a>\n### Type NanGetPointerSafe(Type *[, Type])\n\nA helper for getting values from optional pointers. If the pointer is `NULL`, the function returns the optional default value, which defaults to `0`.  Otherwise, the function returns the value the pointer points to.\n\n```c++\nchar *plugh(uint32_t *optional) {\n  char res[] = "xyzzy";\n  uint32_t param = NanGetPointerSafe<uint32_t>(optional, 0x1337);\n  switch (param) {\n    ...\n  }\n  NanSetPointerSafe<uint32_t>(optional, 0xDEADBEEF);\n}  \n```\n\n<a name="api_nan_set_pointer_safe"></a>\n### bool NanSetPointerSafe(Type *, Type)\n\nA helper for setting optional argument pointers. If the pointer is `NULL`, the function simply returns `false`.  Otherwise, the value is assigned to the variable the pointer points to.\n\n```c++\nconst char *plugh(size_t *outputsize) {\n  char res[] = "xyzzy";\n  if !(NanSetPointerSafe<size_t>(outputsize, strlen(res) + 1)) {\n    ...\n  }\n\n  ...\n}\n```\n\n<a name="api_nan_raw_string"></a>\n### void* NanRawString(Handle&lt;Value&gt;, enum Nan::Encoding, size_t *, void *, size_t, int)\n\nWhen you want to convert a V8 `String` to a `char*` buffer, use `NanRawString`. You have to supply an encoding as well as a pointer to a variable that will be assigned the number of bytes in the returned string. It is also possible to supply a buffer and its length to the function in order not to have a new buffer allocated. The final argument allows setting `String::WriteOptions`.\nJust remember that you\'ll end up with an object that you\'ll need to `delete[]` at some point unless you supply your own buffer:\n\n```c++\nsize_t count;\nvoid* decoded = NanRawString(args[1], Nan::BASE64, &count, NULL, 0, String::HINT_MANY_WRITES_EXPECTED);\nchar param_copy[count];\nmemcpy(param_copy, decoded, count);\ndelete[] decoded;\n```\n\n<a name="api_nan_c_string"></a>\n### char* NanCString(Handle&lt;Value&gt;, size_t *[, char *, size_t, int])\n\nWhen you want to convert a V8 `String` to a null-terminated C `char*` use `NanCString`. The resulting `char*` will be UTF-8-encoded, and you need to supply a pointer to a variable that will be assigned the number of bytes in the returned string. It is also possible to supply a buffer and its length to the function in order not to have a new buffer allocated. The final argument allows optionally setting `String::WriteOptions`, which default to `v8::String::NO_OPTIONS`.\nJust remember that you\'ll end up with an object that you\'ll need to `delete[]` at some point unless you supply your own buffer:\n\n```c++\nsize_t count;\nchar* name = NanCString(args[0], &count);\n```\n\n<a name="api_nan_boolean_option_value"></a>\n### bool NanBooleanOptionValue(Handle&lt;Value&gt;, Handle&lt;String&gt;[, bool])\n\nWhen you have an "options" object that you need to fetch properties from, boolean options can be fetched with this pair. They check first if the object exists (`IsEmpty`), then if the object has the given property (`Has`) then they get and convert/coerce the property to a `bool`.\n\nThe optional last parameter is the *default* value, which is `false` if left off:\n\n```c++\n// `foo` is false unless the user supplies a truthy value for it\nbool foo = NanBooleanOptionValue(optionsObj, NanSymbol("foo"));\n// `bar` is true unless the user supplies a falsy value for it\nbool bar = NanBooleanOptionValueDefTrue(optionsObj, NanSymbol("bar"), true);\n```\n\n<a name="api_nan_uint32_option_value"></a>\n### uint32_t NanUInt32OptionValue(Handle&lt;Value&gt;, Handle&lt;String&gt;, uint32_t)\n\nSimilar to `NanBooleanOptionValue`, use `NanUInt32OptionValue` to fetch an integer option from your options object. Can be any kind of JavaScript `Number` and it will be coerced to an unsigned 32-bit integer.\n\nRequires all 3 arguments as a default is not optional:\n\n```c++\nuint32_t count = NanUInt32OptionValue(optionsObj, NanSymbol("count"), 1024);\n```\n\n<a name="api_nan_error"></a>\n### NanError(message), NanTypeError(message), NanRangeError(message)\n\nFor making `Error`, `TypeError` and `RangeError` objects.\n\n```c++\nLocal<Value> res = NanError("you must supply a callback argument");\n```\n\n<a name="api_nan_throw_error"></a>\n### NanThrowError(message), NanThrowTypeError(message), NanThrowRangeError(message), NanThrowError(Local&lt;Value&gt;), NanThrowError(Local&lt;Value&gt;, int)\n\nFor throwing `Error`, `TypeError` and `RangeError` objects. You should `return` this call:\n\n```c++\nreturn NanThrowError("you must supply a callback argument");\n```\n\nCan also handle any custom object you may want to throw. If used with the error code argument, it will add the supplied error code to the error object as a property called `code`.\n\n<a name="api_nan_new_buffer_handle"></a>\n### Local&lt;Object&gt; NanNewBufferHandle(char *, uint32_t), Local&lt;Object&gt; NanNewBufferHandle(uint32_t)\n\nThe `Buffer` API has changed a little in Node 0.11, this helper provides consistent access to `Buffer` creation:\n\n```c++\nNanNewBufferHandle((char*)value.data(), value.size());\n```\n\nCan also be used to initialize a `Buffer` with just a `size` argument.\n\nCan also be supplied with a `NanFreeCallback` and a hint for the garbage collector.\n\n<a name="api_nan_buffer_use"></a>\n### Local&lt;Object&gt; NanBufferUse(char*, uint32_t)\n\n`Buffer::New(char*, uint32_t)` prior to 0.11 would make a copy of the data.\nWhile it was possible to get around this, it required a shim by passing a\ncallback. So the new API `Buffer::Use(char*, uint32_t)` was introduced to remove\nneeding to use this shim.\n\n`NanBufferUse` uses the `char*` passed as the backing data, and will free the\nmemory automatically when the weak callback is called. Keep this in mind, as\ncareless use can lead to "double free or corruption" and other cryptic failures.\n\n<a name="api_nan_has_instance"></a>\n### bool NanHasInstance(Persistent&lt;FunctionTemplate&gt;&, Handle&lt;Value&gt;)\n\nCan be used to check the type of an object to determine it is of a particular class you have already defined and have a `Persistent<FunctionTemplate>` handle for.\n\n<a href="#api_nan_new_context_handle">\n### Local&lt;Context&gt; NanNewContextHandle([ExtensionConfiguration*, Handle&lt;ObjectTemplate&gt;, Handle&lt;Value&gt;])\nCreates a new `Local<Context>` handle.\n\n```c++\nLocal<FunctionTemplate> ftmpl = NanNew<FunctionTemplate>();\nLocal<ObjectTemplate> otmpl = ftmpl->InstanceTemplate();\nLocal<Context> ctx =  NanNewContextHandle(NULL, otmpl);\n```\n\n<a href="#api_nan_get_current_context">\n### Local<Context> NanGetCurrentContext()\n\nGets the current context.\n\n```c++\nLocal<Context> ctx = NanGetCurrentContext();\n```\n\n<a name="api_nan_dispose_persistent"></a>\n### void NanDisposePersistent(Persistent&lt;T&gt; &)\n\nUse `NanDisposePersistent` to dispose a `Persistent` handle.\n\n```c++\nNanDisposePersistent(persistentHandle);\n```\n\n<a name="api_nan_assign_persistent"></a>\n### NanAssignPersistent(type, handle, object)\n\nUse `NanAssignPersistent` to assign a non-`Persistent` handle to a `Persistent` one. You can no longer just declare a `Persistent` handle and assign directly to it later, you have to `Reset` it in Node 0.11, so this makes it easier.\n\nIn general it is now better to place anything you want to protect from V8\'s garbage collector as properties of a generic `Object` and then assign that to a `Persistent`. This works in older versions of Node also if you use `NanAssignPersistent`:\n\n```c++\nPersistent<Object> persistentHandle;\n\n...\n\nLocal<Object> obj = NanNew<Object>();\nobj->Set(NanSymbol("key"), keyHandle); // where keyHandle might be a Local<String>\nNanAssignPersistent(Object, persistentHandle, obj)\n```\n\n<a name="api_nan_make_weak_persistent"></a>\n### NanMakeWeakPersistent(Handle&lt;T&gt; handle, P* parameter, _NanWeakCallbackInfo&lt;T, P&gt;::Callback callback)\n\nCreates a weak persistent handle with the supplied parameter and `NAN_WEAK_CALLBACK`. The callback has to be fully specialized to work on all versions of Node.\n\n```c++\nNAN_WEAK_CALLBACK(weakCallback) {\n\n...\n\n}\n\nLocal<Function> func;\n\n...\n\nint *parameter = new int(0);\nNanMakeWeakPersistent(func, parameter, &weakCallback<Function, int>);\n```\n\n<a name="api_nan_set_template"></a>\n### NanSetTemplate(templ, name, value)\n\nUse to add properties on object and function templates.\n\n<a name="api_nan_make_callback"></a>\n### NanMakeCallback(target, func, argc, argv)\n\nUse instead of `node::MakeCallback` to call javascript functions. This is the only proper way of calling functions.\n\n<a name="api_nan_compile_script"></a>\n### NanCompileScript(Handle<String> s [, const ScriptOrigin&amp; origin])\n\nUse to create new scripts bound to the current context.\n\n<a name="api_nan_run_script"></a>\n### NanRunScript(script)\n\nUse to run both bound and unbound scripts.\n\n<a name="api_nan_adjust_external_memory"></a>\n### NanAdjustExternalMemory(int change_in_bytes)\n\nSimply does `AdjustAmountOfExternalAllocatedMemory`\n\n<a name="api_nan_add_gc_epilogue_callback"></a>\n### NanAddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type_filter=kGCTypeAll)\n\nSimply does `AddGCEpilogueCallback`\n\n<a name="api_nan_add_gc_prologue_callback"></a>\n### NanAddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type_filter=kGCTypeAll)\n\nSimply does `AddGCPrologueCallback`\n\n<a name="api_nan_remove_gc_epilogue_callback"></a>\n### NanRemoveGCEpilogueCallback(GCEpilogueCallback callback)\n\nSimply does `RemoveGCEpilogueCallback`\n\n<a name="api_nan_add_gc_prologue_callback"></a>\n### NanRemoveGCPrologueCallback(GCPrologueCallback callback)\n\nSimply does `RemoveGCPrologueCallback`\n\n<a name="api_nan_get_heap_statistics"></a>\n### NanGetHeapStatistics(HeapStatistics *heap_statistics)\n\nSimply does `GetHeapStatistics`\n\n<a name="api_nan_callback"></a>\n### NanCallback\n\nBecause of the difficulties imposed by the changes to `Persistent` handles in V8 in Node 0.11, creating `Persistent` versions of your `Handle<Function>` is annoyingly tricky. `NanCallback` makes it easier by taking your handle, making it persistent until the `NanCallback` is deleted and even providing a handy `Call()` method to fetch and execute the callback `Function`.\n\n```c++\nLocal<Function> callbackHandle = args[0].As<Function>();\nNanCallback *callback = new NanCallback(callbackHandle);\n// pass `callback` around and it\'s safe from GC until you:\ndelete callback;\n```\n\nYou can execute the callback like so:\n\n```c++\n// no arguments:\ncallback->Call(0, NULL);\n\n// an error argument:\nHandle<Value> argv[] = {\n  NanError(NanNew<String>("fail!"))\n};\ncallback->Call(1, argv);\n\n// a success argument:\nHandle<Value> argv[] = {\n  NanNull(),\n  NanNew<String>("w00t!")\n};\ncallback->Call(2, argv);\n```\n\n`NanCallback` also has a `Local<Function> GetCallback()` method that you can use\nto fetch a local handle to the underlying callback function, as well  as a\n`void SetFunction(Handle<Function>)` for setting the callback on the\n`NanCallback`.  Additionally a generic constructor is available for using\n`NanCallback` without performing heap allocations.\n\n<a name="api_nan_async_worker"></a>\n### NanAsyncWorker\n\n`NanAsyncWorker` is an abstract class that you can subclass to have much of the annoying async queuing and handling taken care of for you. It can even store arbitrary V8 objects for you and have them persist while the async work is in progress.\n\nSee a rough outline of the implementation:\n\n```c++\nclass NanAsyncWorker {\npublic:\n  NanAsyncWorker (NanCallback *callback);\n\n  // Clean up persistent handles and delete the *callback\n  virtual ~NanAsyncWorker ();\n\n  // Check the `char *errmsg` property and call HandleOKCallback()\n  // or HandleErrorCallback depending on whether it has been set or not\n  virtual void WorkComplete ();\n\n  // You must implement this to do some async work. If there is an\n  // error then allocate `errmsg` to a message and the callback will\n  // be passed that string in an Error object\n  virtual void Execute ();\n\n  // Save a V8 object in a Persistent handle to protect it from GC\n  void SavePersistent(const char *key, Local<Object> &obj);\n\n  // Fetch a stored V8 object (don\'t call from within `Execute()`)\n  Local<Object> GetFromPersistent(const char *key);\n\nprotected:\n  // Set this if there is an error, otherwise it\'s NULL\n  const char *errmsg;\n\n  // Default implementation calls the callback function with no arguments.\n  // Override this to return meaningful data\n  virtual void HandleOKCallback ();\n\n  // Default implementation calls the callback function with an Error object\n  // wrapping the `errmsg` string\n  virtual void HandleErrorCallback ();\n};\n```\n\n<a name="api_nan_async_queue_worker"></a>\n### NanAsyncQueueWorker(NanAsyncWorker *)\n\n`NanAsyncQueueWorker` will run a `NanAsyncWorker` asynchronously via libuv. Both the *execute* and *after_work* steps are taken care of for you&mdash;most of the logic for this is embedded in `NanAsyncWorker`.\n\n### Contributors\n\nNAN is only possible due to the excellent work of the following contributors:\n\n<table><tbody>\n<tr><th align="left">Rod Vagg</th><td><a href="https://github.com/rvagg">GitHub/rvagg</a></td><td><a href="http://twitter.com/rvagg">Twitter/@rvagg</a></td></tr>\n<tr><th align="left">Benjamin Byholm</th><td><a href="https://github.com/kkoopa/">GitHub/kkoopa</a></td></tr>\n<tr><th align="left">Trevor Norris</th><td><a href="https://github.com/trevnorris">GitHub/trevnorris</a></td><td><a href="http://twitter.com/trevnorris">Twitter/@trevnorris</a></td></tr>\n<tr><th align="left">Nathan Rajlich</th><td><a href="https://github.com/TooTallNate">GitHub/TooTallNate</a></td><td><a href="http://twitter.com/TooTallNate">Twitter/@TooTallNate</a></td></tr>\n<tr><th align="left">Brett Lawson</th><td><a href="https://github.com/brett19">GitHub/brett19</a></td><td><a href="http://twitter.com/brett19x">Twitter/@brett19x</a></td></tr>\n<tr><th align="left">Ben Noordhuis</th><td><a href="https://github.com/bnoordhuis">GitHub/bnoordhuis</a></td><td><a href="http://twitter.com/bnoordhuis">Twitter/@bnoordhuis</a></td></tr>\n</tbody></table>\n\nLicence &amp; copyright\n-----------------------\n\nCopyright (c) 2014 NAN contributors (listed above).\n\nNative Abstractions for Node.js is licensed under an MIT +no-false-attribs license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.\n',
96 silly resolved     readmeFilename: 'README.md',
96 silly resolved     bugs: { url: 'https://github.com/rvagg/nan/issues' },
96 silly resolved     homepage: 'https://github.com/rvagg/nan',
96 silly resolved     _id: 'nan@1.0.0',
96 silly resolved     _from: 'nan@~1.0.0',
96 silly resolved     scripts: {} } ]
97 info install nan@1.0.0 into C:\temp\test\node_modules\bignum
98 info installOne nan@1.0.0
99 info C:\temp\test\node_modules\bignum\node_modules\nan unbuild
100 verbose tar unpack C:\Users\Administrator\AppData\Roaming\npm-cache\nan\1.0.0\package.tgz
101 silly lockFile 7e74fbac--modules-bignum-node-modules-nan tar://C:\temp\test\node_modules\bignum\node_modules\nan
102 verbose lock tar://C:\temp\test\node_modules\bignum\node_modules\nan C:\Users\Administrator\AppData\Roaming\npm-cache\7e74fbac--modules-bignum-node-modules-nan.lock
103 silly lockFile dd35ef2a--npm-cache-nan-1-0-0-package-tgz tar://C:\Users\Administrator\AppData\Roaming\npm-cache\nan\1.0.0\package.tgz
104 verbose lock tar://C:\Users\Administrator\AppData\Roaming\npm-cache\nan\1.0.0\package.tgz C:\Users\Administrator\AppData\Roaming\npm-cache\dd35ef2a--npm-cache-nan-1-0-0-package-tgz.lock
105 silly gunzTarPerm modes [ '755', '644' ]
106 silly gunzTarPerm extractEntry package.json
107 silly gunzTarPerm modified mode [ 'package.json', 438, 420 ]
108 silly gunzTarPerm extractEntry README.md
109 silly gunzTarPerm modified mode [ 'README.md', 438, 420 ]
110 silly gunzTarPerm extractEntry LICENSE
111 silly gunzTarPerm modified mode [ 'LICENSE', 438, 420 ]
112 silly gunzTarPerm extractEntry include_dirs.js
113 silly gunzTarPerm modified mode [ 'include_dirs.js', 438, 420 ]
114 silly gunzTarPerm extractEntry .dntrc
115 silly gunzTarPerm modified mode [ '.dntrc', 438, 420 ]
116 silly gunzTarPerm extractEntry build/config.gypi
117 silly gunzTarPerm modified mode [ 'build/config.gypi', 438, 420 ]
118 silly gunzTarPerm extractEntry nan.h
119 silly gunzTarPerm modified mode [ 'nan.h', 438, 420 ]
120 silly lockFile 7e74fbac--modules-bignum-node-modules-nan tar://C:\temp\test\node_modules\bignum\node_modules\nan
121 silly lockFile 7e74fbac--modules-bignum-node-modules-nan tar://C:\temp\test\node_modules\bignum\node_modules\nan
122 silly lockFile dd35ef2a--npm-cache-nan-1-0-0-package-tgz tar://C:\Users\Administrator\AppData\Roaming\npm-cache\nan\1.0.0\package.tgz
123 silly lockFile dd35ef2a--npm-cache-nan-1-0-0-package-tgz tar://C:\Users\Administrator\AppData\Roaming\npm-cache\nan\1.0.0\package.tgz
124 info preinstall nan@1.0.0
125 verbose readDependencies using package.json deps
126 verbose readDependencies using package.json deps
127 silly resolved []
128 verbose about to build C:\temp\test\node_modules\bignum\node_modules\nan
129 info build C:\temp\test\node_modules\bignum\node_modules\nan
130 verbose linkStuff [ false,
130 verbose linkStuff   false,
130 verbose linkStuff   false,
130 verbose linkStuff   'C:\\temp\\test\\node_modules\\bignum\\node_modules' ]
131 info linkStuff nan@1.0.0
132 verbose linkBins nan@1.0.0
133 verbose linkMans nan@1.0.0
134 verbose rebuildBundles nan@1.0.0
135 info install nan@1.0.0
136 info postinstall nan@1.0.0
137 verbose about to build C:\temp\test\node_modules\bignum
138 info build C:\temp\test\node_modules\bignum
139 verbose linkStuff [ false, false, false, 'C:\\temp\\test\\node_modules' ]
140 info linkStuff bignum@0.7.0
141 verbose linkBins bignum@0.7.0
142 verbose linkMans bignum@0.7.0
143 verbose rebuildBundles bignum@0.7.0
144 verbose rebuildBundles [ 'nan' ]
145 info install bignum@0.7.0
146 verbose unsafe-perm in lifecycle true
147 info bignum@0.7.0 Failed to exec install script
148 info C:\temp\test\node_modules\bignum unbuild
149 info preuninstall bignum@0.7.0
150 info uninstall bignum@0.7.0
151 verbose true,C:\temp\test\node_modules,C:\temp\test\node_modules unbuild bignum@0.7.0
152 info postuninstall bignum@0.7.0
153 error bignum@0.7.0 install: `node-gyp configure build`
153 error Exit status 1
154 error Failed at the bignum@0.7.0 install script.
154 error This is most likely a problem with the bignum package,
154 error not with npm itself.
154 error Tell the author that this fails on your system:
154 error     node-gyp configure build
154 error You can get their info via:
154 error     npm owner ls bignum
154 error There is likely additional logging output above.
155 error System Windows_NT 6.2.9200
156 error command "C:\\Program Files (x86)\\nodejs\\\\node.exe" "C:\\Program Files (x86)\\nodejs\\node_modules\\npm\\bin\\npm-cli.js" "install" "bignum" "--msvs_version=2012"
157 error cwd C:\temp\test
158 error node -v v0.10.28
159 error npm -v 1.4.9
160 error code ELIFECYCLE
161 verbose exit [ 1, true ]

The command line output:

C:\temp\test>npm install bignum --msvs_version=2012
npm http GET https://registry.npmjs.org/bignum
npm http 304 https://registry.npmjs.org/bignum
npm http GET https://registry.npmjs.org/nan
npm http 304 https://registry.npmjs.org/nan

> bignum@0.7.0 install C:\temp\test\node_modules\bignum
> node-gyp configure build

C:\temp\test\node_modules\bignum>node "C:\Program Files (x86)\nodejs\node_module
s\npm\bin\node-gyp-bin\\..\..\node_modules\node-gyp\bin\node-gyp.js" configure b
uild
Building the projects in this solution one at a time. To enable parallel build,
please add the "/m" switch.
  bignum.cc
C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\include\xlocale(336): wa
rning C4530: C++ exception handler used, but unwind semantics are not enabled.
Specify /EHsc [C:\temp\test\node_modules\bignum\build\bignum.vcxproj]
..\bignum.cc(9): fatal error C1083: Cannot open include file: 'openssl/bn.h': N
o such file or directory [C:\temp\test\node_modules\bignum\build\bignum.vcxproj
]
gyp ERR! build error
gyp ERR! stack Error: `C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe
` failed with exit code: 1
gyp ERR! stack     at ChildProcess.onExit (C:\Program Files (x86)\nodejs\node_mo
dules\npm\node_modules\node-gyp\lib\build.js:267:23)
gyp ERR! stack     at ChildProcess.EventEmitter.emit (events.js:98:17)
gyp ERR! stack     at Process.ChildProcess._handle.onexit (child_process.js:807:
12)
gyp ERR! System Windows_NT 6.2.9200
gyp ERR! command "node" "C:\\Program Files (x86)\\nodejs\\node_modules\\npm\\nod
e_modules\\node-gyp\\bin\\node-gyp.js" "configure" "build"
gyp ERR! cwd C:\temp\test\node_modules\bignum
gyp ERR! node -v v0.10.28
gyp ERR! node-gyp -v v0.13.0
gyp ERR! not ok
npm ERR! bignum@0.7.0 install: `node-gyp configure build`
npm ERR! Exit status 1
npm ERR!
npm ERR! Failed at the bignum@0.7.0 install script.
npm ERR! This is most likely a problem with the bignum package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR!     node-gyp configure build
npm ERR! You can get their info via:
npm ERR!     npm owner ls bignum
npm ERR! There is likely additional logging output above.

npm ERR! System Windows_NT 6.2.9200
npm ERR! command "C:\\Program Files (x86)\\nodejs\\\\node.exe" "C:\\Program File
s (x86)\\nodejs\\node_modules\\npm\\bin\\npm-cli.js" "install" "bignum" "--msvs_
version=2012"
npm ERR! cwd C:\temp\test
npm ERR! node -v v0.10.28
npm ERR! npm -v 1.4.9
npm ERR! code ELIFECYCLE
npm ERR!
npm ERR! Additional logging details can be found in:
npm ERR!     C:\temp\test\npm-debug.log
npm ERR! not ok code 0

justmoon / node-bignum

Can not install in Windows server 2012 #32