2 |3 | {{propName}} 4 | 5 | {{#creationExtras}} 6 | created: 7 | {{#createDate}} 8 | {{createDate}} 9 | {{/createDate}} 10 | {{#author}} 11 | by {{author}} 12 | {{/author}} 13 | {{/creationExtras}} 14 | {{#modifiedExtras}} 15 | 16 | modified: 17 | {{#lastmodifiedDate}} 18 | {{lastmodifiedDate}} 19 | {{/lastmodifiedDate}} 20 | {{#lastmodifiedBy}} 21 | by {{lastmodifiedBy}} 22 | {{/lastmodifiedBy}} 23 | {{/modifiedExtras}} 24 | 25 | 26 | 27 | {{{summary}}} 28 | {{{syntax}}} 29 | 30 | {{#returnValues}} 31 | Returns: {{type}} 32 | {{description}} 33 | {{/returnValues}} 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | {{#propValues}} 42 | 43 | [ 44 | {{name}} 45 | ] 46 | {{type}} 47 | 48 | {{default}} 49 | {{{description}}} 50 | 51 | {{#propsForProps}} 52 | 53 | [ 54 | {{name}} 55 | ] 56 | {{type}} 57 | 58 | {{default}} 59 | {{{description}}} 60 | {{/propsForProps}} 61 | 62 | {{/propValues}} 63 | 64 | 65 | 66 | 67 | 68 | {{Strings.DOCS_MORE_LINK}} 69 | {{infoUrlName}} 70 | {{licenseUrlName}} 71 | 72 | 73 | -------------------------------------------------------------------------------- /docs/nodejs/timers.json: -------------------------------------------------------------------------------- 1 | {"setTimeout":{"y":"setTimeout(callback, delay, [arg], [...])","s":"To schedule execution of a one-time callback<\/code> after delay<\/code> milliseconds. Returns a\ntimeoutObject<\/code> for possible use with clearTimeout()<\/code>. Optionally you can\nalso pass arguments to the callback.\n\n<\/p>\n It is important to note that your callback will probably not be called in exactly\ndelay<\/code> milliseconds - Node.js makes no guarantees about the exact timing of when\nthe callback will fire, nor of the ordering things will fire in. The callback will\nbe called as close as possible to the time specified.\n\n<\/p>\n","p":[{"o":false,"t":"callback","d":"","type":""},{"o":false,"t":"delay","d":"","type":""},{"o":true,"t":"arg","d":"","type":""},{"o":true,"t":"...","d":"","type":""}]},"clearTimeout":{"y":"clearTimeout(timeoutObject)","s":" Prevents a timeout from triggering.\n\n<\/p>\n","p":[{"o":false,"t":"timeoutObject","d":"","type":""}]},"setInterval":{"y":"setInterval(callback, delay, [arg], [...])","s":" To schedule the repeated execution of callback<\/code> every delay<\/code> milliseconds.\nReturns a intervalObject<\/code> for possible use with clearInterval()<\/code>. Optionally\nyou can also pass arguments to the callback.\n\n<\/p>\n","p":[{"o":false,"t":"callback","d":"","type":""},{"o":false,"t":"delay","d":"","type":""},{"o":true,"t":"arg","d":"","type":""},{"o":true,"t":"...","d":"","type":""}]},"clearInterval":{"y":"clearInterval(intervalObject)","s":" Stops a interval from triggering.\n\n<\/p>\n","p":[{"o":false,"t":"intervalObject","d":"","type":""}]},"unref":{"y":"unref()","s":" The opaque value returned by setTimeout<\/code> and setInterval<\/code> also has the method\ntimer.unref()<\/code> which will allow you to create a timer that is active but if\nit is the only item left in the event loop won't keep the program running.\nIf the timer is already unref<\/code>d calling unref<\/code> again will have no effect.\n\n<\/p>\n In the case of setTimeout<\/code> when you unref<\/code> you create a separate timer that\nwill wakeup the event loop, creating too many of these may adversely effect\nevent loop performance -- use wisely.\n\n<\/p>\n","p":[]},"ref":{"y":"ref()","s":" If you had previously unref()<\/code>d a timer you can call ref()<\/code> to explicitly\nrequest the timer hold the program open. If the timer is already ref<\/code>d calling\nref<\/code> again will have no effect.\n\n<\/p>\n","p":[]},"setImmediate":{"y":"setImmediate(callback, [arg], [...])","s":" To schedule the "immediate" execution of callback<\/code> after I\/O events\ncallbacks and before setTimeout<\/code> and setInterval<\/code> . Returns an\nimmediateObject<\/code> for possible use with clearImmediate()<\/code>. Optionally you\ncan also pass arguments to the callback.\n\n<\/p>\n Immediates are queued in the order created, and are popped off the queue once\nper loop iteration. This is different from process.nextTick<\/code> which will\nexecute process.maxTickDepth<\/code> queued callbacks per iteration. setImmediate<\/code>\nwill yield to the event loop after firing a queued callback to make sure I\/O is\nnot being starved. While order is preserved for execution, other I\/O events may\nfire between any two scheduled immediate callbacks.\n\n<\/p>\n","p":[{"o":false,"t":"callback","d":"","type":""},{"o":true,"t":"arg","d":"","type":""},{"o":true,"t":"...","d":"","type":""}]},"clearImmediate":{"y":"clearImmediate(immediateObject)","s":" Stops an immediate from triggering.\n<\/p>\n","p":[{"o":false,"t":"immediateObject","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/global.json: -------------------------------------------------------------------------------- 1 | {"eval":{"s":"The eval() method evaluates JavaScript code represented as a string.","y":"eval(string)","p":[{"t":"string","d":"A string representing a JavaScript expression, statement, or sequence of statements. The expression can include variables and properties of existing objects."}]},"uneval":{"s":"The uneval() method creates an string representation of the source code of an Object.","y":"uneval(object)","p":[{"t":"object","d":"A JavaScript expression or statement."}]},"isFinite":{"s":"The global isFinite() function determines whether the passed value is a finite number. If needed, the parameter is first converted to a number.","y":"isFinite(testValue)","p":[{"t":"testValue","d":"The value to be tested for finiteness."}]},"isNaN":{"s":"The isNaN() function determines whether a value is NaN or not. Be careful, this function is broken. You may be interested in Number.isNaN() as defined in ECMAScript 6 or you can use typeof to determine if the value is Not-A-Number.","y":"isNaN(testValue)","p":[{"t":"testValue","d":"The value to be tested."}]},"parseFloat":{"s":"The parseFloat() function parses a string argument and returns a floating point number.","y":"parseFloat(string)","p":[{"t":"string","d":"A string that represents the value you want to parse."}]},"parseInt":{"s":"The parseInt() function parses a string argument and returns an integer of the specified radix or base.","y":"parseInt(string, radix);","p":[{"t":"string","d":"The value to parse. If string is not a string, then it is converted to one. Leading whitespace in the string is ignored."},{"t":"radix","d":"An integer that represents the radix of the above mentioned string. Always specify this parameter to eliminate reader confusion and to guarantee predictable behavior. Different implementations produce different results when a radix is not specified."}]},"decodeURI":{"s":"The decodeURI() function decodes a Uniform Resource Identifier (URI) previously created by encodeURI or by a similar routine.","y":"decodeURI(encodedURI)","p":[{"t":"encodedURI","d":"A complete, encoded Uniform Resource Identifier."}]},"decodeURIComponent":{"s":"The decodeURIComponent() method decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent or by a similar routine.","y":"decodeURIComponent(encodedURI)","p":[{"t":"encodedURI","d":"An encoded component of a Uniform Resource Identifier."}]},"encodeURI":{"s":"The encodeURI() method encodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two \"surrogate\" characters).","y":"encodeURI(URI)","p":[{"t":"URI","d":"A complete Uniform Resource Identifier."}]},"encodeURIComponent":{"s":"The encodeURIComponent() method encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two \"surrogate\" characters).","y":"encodeURIComponent(str);","p":[{"t":"str","d":"String. A component of a URI."}]},"escape":{"s":"The deprecated escape() method computes a new string in which certain characters have been replaced by a hexadecimal escape sequence. Use encodeURI or encodeURIComponent instead.","y":"escape(str)","p":[{"t":"str","d":"A string to be encoded."}]},"unescape":{"s":"The deprecated unescape() method computes a new string in which hexadecimal escape sequences are replaced with the character that it represents. The escape sequences might be introduced by a function like escape. Because unescape is deprecated, use decodeURI or decodeURIComponent instead.","y":"unescape(str)","p":[{"t":"str","d":"A string to be decoded."}]}} -------------------------------------------------------------------------------- /docs/nodejs/readline.json: -------------------------------------------------------------------------------- 1 | {"createInterface":{"y":"readline.createInterface(options)","s":" Creates a readline Interface<\/code> instance. Accepts an "options" Object that takes\nthe following values:\n\n<\/p>\n \ninput<\/code> - the readable stream to listen to (Required).<\/p>\n<\/li>\n output<\/code> - the writable stream to write readline data to (Required).<\/p>\n<\/li>\n completer<\/code> - an optional function that is used for Tab autocompletion. See\nbelow for an example of using this.<\/p>\n<\/li>\n terminal<\/code> - pass true<\/code> if the input<\/code> and output<\/code> streams should be\ntreated like a TTY, and have ANSI\/VT100 escape codes written to it.\nDefaults to checking isTTY<\/code> on the output<\/code> stream upon instantiation.<\/p>\n<\/li>\n<\/ul>\n The completer<\/code> function is given the current line entered by the user, and\nis supposed to return an Array with 2 entries:\n\n<\/p>\n \nAn Array with matching entries for the completion.<\/p>\n<\/li>\n The substring that was used for the matching.<\/p>\n<\/li>\n<\/ol>\n Which ends up looking something like:\n[[substr1, substr2, ...], originalsubstring]<\/code>.\n\n<\/p>\n Example:\n\n<\/p>\n function completer(line) {\n var completions = '.help .error .exit .quit .q'.split(' ')\n var hits = completions.filter(function(c) { return c.indexOf(line) == 0 })\n \/\/ show all completions if none found\n return [hits.length ? hits : completions, line]\n}<\/code><\/pre>\nAlso completer<\/code> can be run in async mode if it accepts two arguments:\n\n<\/p>\n function completer(linePartial, callback) {\n callback(null, [['123'], linePartial]);\n}<\/code><\/pre>\ncreateInterface<\/code> is commonly used with process.stdin<\/code> and\nprocess.stdout<\/code> in order to accept user input:\n\n<\/p>\n var readline = require('readline');\nvar rl = readline.createInterface({\n input: process.stdin,\n output: process.stdout\n});<\/code><\/pre>\nOnce you have a readline instance, you most commonly listen for the\n"line"<\/code> event.\n\n<\/p>\n If terminal<\/code> is true<\/code> for this instance then the output<\/code> stream will get\nthe best compatibility if it defines an output.columns<\/code> property, and fires\na "resize"<\/code> event on the output<\/code> if\/when the columns ever change\n(process.stdout<\/code> does this automatically when it is a TTY).\n\n<\/p>\n","p":[{"o":false,"t":"options","d":"","type":""}]},"cursorTo":{"y":"readline.cursorTo(stream, x, y)","s":" Move cursor to the specified position in a given TTY stream.\n\n<\/p>\n","p":[{"o":false,"t":"stream","d":"","type":""},{"o":false,"t":"x","d":"","type":""},{"o":false,"t":"y","d":"","type":""}]},"moveCursor":{"y":"readline.moveCursor(stream, dx, dy)","s":" Move cursor relative to it's current position in a given TTY stream.\n\n<\/p>\n","p":[{"o":false,"t":"stream","d":"","type":""},{"o":false,"t":"dx","d":"","type":""},{"o":false,"t":"dy","d":"","type":""}]},"clearLine":{"y":"readline.clearLine(stream, dir)","s":" Clears current line of given TTY stream in a specified direction.\ndir<\/code> should have one of following values:\n\n<\/p>\n \n-1<\/code> - to the left from cursor<\/li>\n 1<\/code> - to the right from cursor<\/li>\n 0<\/code> - the entire line<\/li>\n<\/ul>\n","p":[{"o":false,"t":"stream","d":"","type":""},{"o":false,"t":"dir","d":"","type":""}]},"clearScreenDown":{"y":"readline.clearScreenDown(stream)","s":"Clears the screen from the current position of the cursor down.\n<\/p>\n","p":[{"o":false,"t":"stream","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /Readme.md: -------------------------------------------------------------------------------- 1 | # QuickDocsJS 2 | This extension provides a quick documentation for each JavaScript function. 3 | It supports JSDoc comments since v1.2 and some requirejs stuff (v1.4) which allows you to access documentations which aren't in the same file! 4 | You don't use normal JS but jQuery or NodeJS? QuickDocs supports both of them (v1.5 & v1.6). 5 | 6 | **Miss some docs for standard functions or JS extensions like jQuery? Add them here [issue (#12)](../../issues/12). Thanks for your help!** 7 | 8 | QuickDocsJS makes it easy to read your JSDoc comments inline, but you have to write these comments... 9 | 10 | ...Maybe you want to check out my [FuncDocr](https://github.com/Wikunia/brackets-FuncDocr) extension to generate JSDocs for your own functions. 11 | 12 | ## You're rich? 13 | You don't need a second yacht and have some coins to spend? Here I am :) 14 | 15 | [![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=Wikunia&url=https://github.com/Wikunia/brackets-QuickDocsJS&title=Brackets-QuickDocsJS&language=javascript&tags=github&category=software) 16 | [![Donate! :3](https://www.paypalobjects.com/en_US/GB/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=B5VQXWCZXYN2W) 17 | 18 | 19 | ## Type Recognition Magic 20 | 21 | The extension tries to get the correct documentation if the function is available for strings and arrays. 22 | 23 | ```javascript 24 | var abc = 'abc'; 25 | var pos = abc.indexOf('a'); // the documentation for String.indexOf 26 | var parts = abc.split(''); 27 | pos = parts.indexOf('a'); // the documentation for Array.indexOf 28 | ``` 29 | 30 | ## How to use 31 | You can use the Navigation menu or ```Ctrl+K``` (Windows) or ```CMD+K``` (Mac), while your cursor is on a JavaScript function, to open the inline documentation. 32 | 33 | ![Example](image/example.png?raw=true) 34 | 35 | This extension uses the documentation from [http://developer.mozilla.org](http://developer.mozilla.org) for JS functions and [http://nodejs.org](http://nodejs.org) for NodeJS functions. 36 | 37 | Since v1.6.0 QuickDocs supports jQuery! Thanks [http://api.jquery.com](http://api.jquery.com) 38 | 39 | ## v 1.6.0 40 | Support for jQuery! 41 | ![jQuery](image/jQuery.png?raw=true) 42 | `@link`-tags are parsed as HTML links now and you can use them to jump easy between functions! 43 | 44 | ## v 1.5.0 45 | Support for NodeJS! 46 | ![NodeJS](image/nodeJS.png?raw=true) 47 | 48 | ## v 1.4.1 49 | QuickDocsJS can use require.js `define` statements to get docs by reading other modules. 50 | [#8](../../issues/8) 51 | 52 | 53 | ## v 1.4 54 | QuickDocsJS supports prototype functions: 55 | ```javascript 56 | /** 57 | * split a string into an array with limit entries 58 | * The last entry contains the last part of the string, which can contain the separator) 59 | * @param {String} separator string separator 60 | * @param {Integer} limit number of entries in the array 61 | * @return {Array} array of separated strings 62 | */ 63 | String.prototype.splitLimit = function(separator,limit) { 64 | var splitString = this; 65 | var result = []; 66 | var pos = splitString.search(separator); 67 | if (pos < 0) return false; 68 | result.push(splitString.substring(0,pos)); 69 | result.push(splitString.substring(pos+1)); 70 | return result; 71 | } 72 | 73 | 74 | ``` 75 | 76 | ## v 1.2 77 | It's now possible to get documentations for your own functions using JSDoc. 78 | ``` 79 | /** 80 | get the type of a variable 81 | @param {String} content content of document 82 | @param {String} variable name of the variable 83 | @returns {String} type of the variable: unknown,String,Array or RegExp 84 | */ 85 | function getVariableType (content, variable) { 86 | ``` 87 | 88 | ![User functions](image/user_func.png?raw=true) 89 | 90 | 91 | 92 | ##Languages 93 | + English 94 | 95 | ### License 96 | Creative Commons v2.5 97 | [http://creativecommons.org/licenses/by/2.5/](http://creativecommons.org/licenses/by/2.5/) 98 | -------------------------------------------------------------------------------- /docs/nodejs/repl.json: -------------------------------------------------------------------------------- 1 | {"start":{"y":"repl.start(options)","s":" Returns and starts a REPLServer<\/code> instance. Accepts an "options" Object that\ntakes the following values:\n\n<\/p>\n \nprompt<\/code> - the prompt and stream<\/code> for all I\/O. Defaults to > <\/code>.<\/p>\n<\/li>\n input<\/code> - the readable stream to listen to. Defaults to process.stdin<\/code>.<\/p>\n<\/li>\n output<\/code> - the writable stream to write readline data to. Defaults to\nprocess.stdout<\/code>.<\/p>\n<\/li>\n terminal<\/code> - pass true<\/code> if the stream<\/code> should be treated like a TTY, and\nhave ANSI\/VT100 escape codes written to it. Defaults to checking isTTY<\/code>\non the output<\/code> stream upon instantiation.<\/p>\n<\/li>\n eval<\/code> - function that will be used to eval each given line. Defaults to\nan async wrapper for eval()<\/code>. See below for an example of a custom eval<\/code>.<\/p>\n<\/li>\n useColors<\/code> - a boolean which specifies whether or not the writer<\/code> function\nshould output colors. If a different writer<\/code> function is set then this does\nnothing. Defaults to the repl's terminal<\/code> value.<\/p>\n<\/li>\n useGlobal<\/code> - if set to true<\/code>, then the repl will use the global<\/code> object,\ninstead of running scripts in a separate context. Defaults to false<\/code>.<\/p>\n<\/li>\n ignoreUndefined<\/code> - if set to true<\/code>, then the repl will not output the\nreturn value of command if it's undefined<\/code>. Defaults to false<\/code>.<\/p>\n<\/li>\n writer<\/code> - the function to invoke for each command that gets evaluated which\nreturns the formatting (including coloring) to display. Defaults to\nutil.inspect<\/code>.<\/p>\n<\/li>\n<\/ul>\n You can use your own eval<\/code> function if it has following signature:\n\n<\/p>\n function eval(cmd, context, filename, callback) {\n callback(null, result);\n}<\/code><\/pre>\nMultiple REPLs may be started against the same running instance of node. Each\nwill share the same global object but will have unique I\/O.\n\n<\/p>\n Here is an example that starts a REPL on stdin, a Unix socket, and a TCP socket:\n\n<\/p>\n var net = require("net"),\n repl = require("repl");\n\nconnections = 0;\n\nrepl.start({\n prompt: "node via stdin> ",\n input: process.stdin,\n output: process.stdout\n});\n\nnet.createServer(function (socket) {\n connections += 1;\n repl.start({\n prompt: "node via Unix socket> ",\n input: socket,\n output: socket\n }).on('exit', function() {\n socket.end();\n })\n}).listen("\/tmp\/node-repl-sock");\n\nnet.createServer(function (socket) {\n connections += 1;\n repl.start({\n prompt: "node via TCP socket> ",\n input: socket,\n output: socket\n }).on('exit', function() {\n socket.end();\n });\n}).listen(5001);<\/code><\/pre>\nRunning this program from the command line will start a REPL on stdin. Other\nREPL clients may connect through the Unix socket or TCP socket. telnet<\/code> is useful\nfor connecting to TCP sockets, and socat<\/code> can be used to connect to both Unix and\nTCP sockets.\n\n<\/p>\n By starting a REPL from a Unix socket-based server instead of stdin, you can\nconnect to a long-running node process without restarting it.\n\n<\/p>\n For an example of running a "full-featured" (terminal<\/code>) REPL over\na net.Server<\/code> and net.Socket<\/code> instance, see: https:\/\/gist.github.com\/2209310<\/a>\n\n<\/p>\n For an example of running a REPL instance over curl(1)<\/code>,\nsee: https:\/\/gist.github.com\/2053342<\/a>\n\n<\/p>\n","p":[{"o":false,"t":"options","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/nodejs/os.json: -------------------------------------------------------------------------------- 1 | {"tmpdir":{"y":"os.tmpdir()","s":" Returns the operating system's default directory for temp files.\n\n<\/p>\n","p":[]},"endianness":{"y":"os.endianness()","s":" Returns the endianness of the CPU. Possible values are "BE"<\/code> or "LE"<\/code>.\n\n<\/p>\n","p":[]},"hostname":{"y":"os.hostname()","s":" Returns the hostname of the operating system.\n\n<\/p>\n","p":[]},"type":{"y":"os.type()","s":" Returns the operating system name.\n\n<\/p>\n","p":[]},"platform":{"y":"os.platform()","s":" Returns the operating system platform.\n\n<\/p>\n","p":[]},"arch":{"y":"os.arch()","s":" Returns the operating system CPU architecture.\n\n<\/p>\n","p":[]},"release":{"y":"os.release()","s":" Returns the operating system release.\n\n<\/p>\n","p":[]},"uptime":{"y":"os.uptime()","s":" Returns the system uptime in seconds.\n\n<\/p>\n","p":[]},"loadavg":{"y":"os.loadavg()","s":" Returns an array containing the 1, 5, and 15 minute load averages.\n\n<\/p>\n The load average is a measure of system activity, calculated by the operating\nsystem and expressed as a fractional number. As a rule of thumb, the load\naverage should ideally be less than the number of logical CPUs in the system.\n\n<\/p>\n The load average is a very UNIX-y concept; there is no real equivalent on\nWindows platforms. That is why this function always returns [0, 0, 0]<\/code> on\nWindows.\n\n<\/p>\n","p":[]},"totalmem":{"y":"os.totalmem()","s":" Returns the total amount of system memory in bytes.\n\n<\/p>\n","p":[]},"freemem":{"y":"os.freemem()","s":" Returns the amount of free system memory in bytes.\n\n<\/p>\n","p":[]},"cpus":{"y":"os.cpus()","s":" Returns an array of objects containing information about each CPU\/core\ninstalled: model, speed (in MHz), and times (an object containing the number of\nmilliseconds the CPU\/core spent in: user, nice, sys, idle, and irq).\n\n<\/p>\n Example inspection of os.cpus:\n\n<\/p>\n [ { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 252020,\n nice: 0,\n sys: 30340,\n idle: 1070356870,\n irq: 0 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 306960,\n nice: 0,\n sys: 26980,\n idle: 1071569080,\n irq: 0 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 248450,\n nice: 0,\n sys: 21750,\n idle: 1070919370,\n irq: 0 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 256880,\n nice: 0,\n sys: 19430,\n idle: 1070905480,\n irq: 20 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 511580,\n nice: 20,\n sys: 40900,\n idle: 1070842510,\n irq: 0 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 291660,\n nice: 0,\n sys: 34360,\n idle: 1070888000,\n irq: 10 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 308260,\n nice: 0,\n sys: 55410,\n idle: 1071129970,\n irq: 880 } },\n { model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',\n speed: 2926,\n times:\n { user: 266450,\n nice: 1480,\n sys: 34920,\n idle: 1072572010,\n irq: 30 } } ]<\/code><\/pre>\n","p":[]},"networkInterfaces":{"y":"os.networkInterfaces()","s":"Get a list of network interfaces:\n\n<\/p>\n{ lo0: \n [ { address: '::1', family: 'IPv6', internal: true },\n { address: 'fe80::1', family: 'IPv6', internal: true },\n { address: '127.0.0.1', family: 'IPv4', internal: true } ],\n en1: \n [ { address: 'fe80::cabc:c8ff:feef:f996', family: 'IPv6',\n internal: false },\n { address: '10.0.1.123', family: 'IPv4', internal: false } ],\n vmnet1: [ { address: '10.99.99.254', family: 'IPv4', internal: false } ],\n vmnet8: [ { address: '10.88.88.1', family: 'IPv4', internal: false } ],\n ppp0: [ { address: '10.2.0.231', family: 'IPv4', internal: false } ] }<\/code><\/pre>\n","p":[]}} 2 | -------------------------------------------------------------------------------- /docs/nodejs/path.json: -------------------------------------------------------------------------------- 1 | {"normalize":{"y":"path.normalize(p)","s":"Normalize a string path, taking care of '..'<\/code> and '.'<\/code> parts.\n\n<\/p>\n When multiple slashes are found, they're replaced by a single one;\nwhen the path contains a trailing slash, it is preserved.\nOn Windows backslashes are used.\n\n<\/p>\n Example:\n\n<\/p>\npath.normalize('\/foo\/bar\/\/baz\/asdf\/quux\/..')\n\/\/ returns\n'\/foo\/bar\/baz\/asdf'<\/code><\/pre>\n","p":[{"o":false,"t":"p","d":"","type":""}]},"join":{"y":"path.join([path1], [path2], [...])","s":"Join all arguments together and normalize the resulting path.\n\n<\/p>\n Arguments must be strings. In v0.8, non-string arguments were\nsilently ignored. In v0.10 and up, an exception is thrown.\n\n<\/p>\n Example:\n\n<\/p>\npath.join('\/foo', 'bar', 'baz\/asdf', 'quux', '..')\n\/\/ returns\n'\/foo\/bar\/baz\/asdf'\n\npath.join('foo', {}, 'bar')\n\/\/ throws exception\nTypeError: Arguments to path.join must be strings<\/code><\/pre>\n","p":[{"o":true,"t":"path1","d":"","type":""},{"o":true,"t":"path2","d":"","type":""},{"o":true,"t":"...","d":"","type":""}]},"resolve":{"y":"path.resolve([from ...], to)","s":"Resolves to<\/code> to an absolute path.\n\n<\/p>\n If to<\/code> isn't already absolute from<\/code> arguments are prepended in right to left\norder, until an absolute path is found. If after using all from<\/code> paths still\nno absolute path is found, the current working directory is used as well. The\nresulting path is normalized, and trailing slashes are removed unless the path\ngets resolved to the root directory. Non-string from<\/code> arguments are ignored.\n\n<\/p>\n Another way to think of it is as a sequence of cd<\/code> commands in a shell.\n\n<\/p>\npath.resolve('foo\/bar', '\/tmp\/file\/', '..', 'a\/..\/subfile')<\/code><\/pre>\nIs similar to:\n\n<\/p>\ncd foo\/bar\ncd \/tmp\/file\/\ncd ..\ncd a\/..\/subfile\npwd<\/code><\/pre>\nThe difference is that the different paths don't need to exist and may also be\nfiles.\n\n<\/p>\n Examples:\n\n<\/p>\npath.resolve('\/foo\/bar', '.\/baz')\n\/\/ returns\n'\/foo\/bar\/baz'\n\npath.resolve('\/foo\/bar', '\/tmp\/file\/')\n\/\/ returns\n'\/tmp\/file'\n\npath.resolve('wwwroot', 'static_files\/png\/', '..\/gif\/image.gif')\n\/\/ if currently in \/home\/myself\/node, it returns\n'\/home\/myself\/node\/wwwroot\/static_files\/gif\/image.gif'<\/code><\/pre>\n","p":[{"o":true,"t":"from ...","d":"","type":""},{"o":false,"t":"to","d":"","type":""}]},"relative":{"y":"path.relative(from, to)","s":"Solve the relative path from from<\/code> to to<\/code>.\n\n<\/p>\n At times we have two absolute paths, and we need to derive the relative\npath from one to the other. This is actually the reverse transform of\npath.resolve<\/code>, which means we see that:\n\n<\/p>\npath.resolve(from, path.relative(from, to)) == path.resolve(to)<\/code><\/pre>\nExamples:\n\n<\/p>\npath.relative('C:\\\\orandea\\\\test\\\\aaa', 'C:\\\\orandea\\\\impl\\\\bbb')\n\/\/ returns\n'..\\\\..\\\\impl\\\\bbb'\n\npath.relative('\/data\/orandea\/test\/aaa', '\/data\/orandea\/impl\/bbb')\n\/\/ returns\n'..\/..\/impl\/bbb'<\/code><\/pre>\n","p":[{"o":false,"t":"from","d":"","type":""},{"o":false,"t":"to","d":"","type":""}]},"dirname":{"y":"path.dirname(p)","s":"Return the directory name of a path. Similar to the Unix dirname<\/code> command.\n\n<\/p>\n Example:\n\n<\/p>\n path.dirname('\/foo\/bar\/baz\/asdf\/quux')\n\/\/ returns\n'\/foo\/bar\/baz\/asdf'<\/code><\/pre>\n","p":[{"o":false,"t":"p","d":"","type":""}]},"basename":{"y":"path.basename(p, [ext])","s":"Return the last portion of a path. Similar to the Unix basename<\/code> command.\n\n<\/p>\n Example:\n\n<\/p>\n path.basename('\/foo\/bar\/baz\/asdf\/quux.html')\n\/\/ returns\n'quux.html'\n\npath.basename('\/foo\/bar\/baz\/asdf\/quux.html', '.html')\n\/\/ returns\n'quux'<\/code><\/pre>\n","p":[{"o":false,"t":"p","d":"","type":""},{"o":true,"t":"ext","d":"","type":""}]},"extname":{"y":"path.extname(p)","s":"Return the extension of the path, from the last '.' to end of string\nin the last portion of the path. If there is no '.' in the last portion\nof the path or the first character of it is '.', then it returns\nan empty string. Examples:\n\n<\/p>\n path.extname('index.html')\n\/\/ returns\n'.html'\n\npath.extname('index.coffee.md')\n\/\/ returns\n'.md'\n\npath.extname('index.')\n\/\/ returns\n'.'\n\npath.extname('index')\n\/\/ returns\n''<\/code><\/pre>\n","p":[{"o":false,"t":"p","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/nodejs/http.json: -------------------------------------------------------------------------------- 1 | {"createServer":{"y":"http.createServer([requestListener])","s":"Returns a new web server object.\n\n<\/p>\n The requestListener<\/code> is a function which is automatically\nadded to the 'request'<\/code> event.\n\n<\/p>\n","p":[{"o":true,"t":"requestListener","d":"","type":""}]},"createClient":{"y":"http.createClient([port], [host])","s":" This function is deprecated<\/strong>; please use [http.request()][] instead.\nConstructs a new HTTP client. port<\/code> and host<\/code> refer to the server to be\nconnected to.\n\n<\/p>\n","p":[{"o":true,"t":"port","d":"","type":""},{"o":true,"t":"host","d":"","type":""}]},"request":{"y":"http.request(options, [callback])","s":" Node maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.\n\n<\/p>\n options<\/code> can be an object or a string. If options<\/code> is a string, it is\nautomatically parsed with [url.parse()][].\n\n<\/p>\n Options:\n\n<\/p>\n \nhost<\/code>: A domain name or IP address of the server to issue the request to.\nDefaults to 'localhost'<\/code>.<\/li>\n hostname<\/code>: To support url.parse()<\/code> hostname<\/code> is preferred over host<\/code><\/li>\n port<\/code>: Port of remote server. Defaults to 80.<\/li>\n localAddress<\/code>: Local interface to bind for network connections.<\/li>\n socketPath<\/code>: Unix Domain Socket (use one of host:port or socketPath)<\/li>\n method<\/code>: A string specifying the HTTP request method. Defaults to 'GET'<\/code>.<\/li>\n path<\/code>: Request path. Defaults to '\/'<\/code>. Should include query string if any.\nE.G. '\/index.html?page=12'<\/code><\/li>\n headers<\/code>: An object containing request headers.<\/li>\n auth<\/code>: Basic authentication i.e. 'user:password'<\/code> to compute an\nAuthorization header.<\/li>\n agent<\/code>: Controls [Agent][] behavior. When an Agent is used request will\ndefault to Connection: keep-alive<\/code>. Possible values:\nundefined<\/code> (default): use [global Agent][] for this host and port.<\/li>\n Agent<\/code> object: explicitly use the passed in Agent<\/code>.<\/li>\n false<\/code>: opts out of connection pooling with an Agent, defaults request to\nConnection: close<\/code>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nThe optional callback<\/code> parameter will be added as a one time listener for\nthe ['response'][] event.\n\n<\/p>\n http.request()<\/code> returns an instance of the [http.ClientRequest][]\nclass. The ClientRequest<\/code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the ClientRequest<\/code> object.\n\n<\/p>\n Example:\n\n<\/p>\n var options = {\n hostname: 'www.google.com',\n port: 80,\n path: '\/upload',\n method: 'POST'\n};\n\nvar req = http.request(options, function(res) {\n console.log('STATUS: ' + res.statusCode);\n console.log('HEADERS: ' + JSON.stringify(res.headers));\n res.setEncoding('utf8');\n res.on('data', function (chunk) {\n console.log('BODY: ' + chunk);\n });\n});\n\nreq.on('error', function(e) {\n console.log('problem with request: ' + e.message);\n});\n\n\/\/ write data to request body\nreq.write('data\\n');\nreq.write('data\\n');\nreq.end();<\/code><\/pre>\nNote that in the example req.end()<\/code> was called. With http.request()<\/code> one\nmust always call req.end()<\/code> to signify that you're done with the request -\neven if there is no data being written to the request body.\n\n<\/p>\n If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an 'error'<\/code> event is emitted\non the returned request object.\n\n<\/p>\n There are a few special headers that should be noted.\n\n<\/p>\n \nSending a 'Connection: keep-alive' will notify Node that the connection to\nthe server should be persisted until the next request.<\/p>\n<\/li>\n Sending a 'Content-length' header will disable the default chunked encoding.<\/p>\n<\/li>\n Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', you should both set a timeout\nand listen for the continue<\/code> event. See RFC2616 Section 8.2.3 for more\ninformation.<\/p>\n<\/li>\n Sending an Authorization header will override using the auth<\/code> option\nto compute basic authentication.<\/p>\n<\/li>\n<\/ul>\n","p":[{"o":false,"t":"options","d":"","type":""},{"o":true,"t":"callback","d":"","type":""}]},"get":{"y":"http.get(options, [callback])","s":" Since most requests are GET requests without bodies, Node provides this\nconvenience method. The only difference between this method and http.request()<\/code>\nis that it sets the method to GET and calls req.end()<\/code> automatically.\n\n<\/p>\n Example:\n\n<\/p>\n http.get("http:\/\/www.google.com\/index.html", function(res) {\n console.log("Got response: " + res.statusCode);\n}).on('error', function(e) {\n console.log("Got error: " + e.message);\n});<\/code><\/pre>\n","p":[{"o":false,"t":"options","d":"","type":""},{"o":true,"t":"callback","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/nodejs/dns.json: -------------------------------------------------------------------------------- 1 | {"lookup":{"y":"dns.lookup(domain, [family], callback)","s":"Resolves a domain (e.g. 'google.com'<\/code>) into the first found A (IPv4) or\nAAAA (IPv6) record.\nThe family<\/code> can be the integer 4<\/code> or 6<\/code>. Defaults to null<\/code> that indicates\nboth Ip v4 and v6 address family.\n\n<\/p>\n The callback has arguments (err, address, family)<\/code>. The address<\/code> argument\nis a string representation of a IP v4 or v6 address. The family<\/code> argument\nis either the integer 4 or 6 and denotes the family of address<\/code> (not\nnecessarily the value initially passed to lookup<\/code>).\n\n<\/p>\n On error, err<\/code> is an Error<\/code> object, where err.code<\/code> is the error code.\nKeep in mind that err.code<\/code> will be set to 'ENOENT'<\/code> not only when\nthe domain does not exist but also when the lookup fails in other ways\nsuch as no available file descriptors.\n\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":true,"t":"family","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolve":{"y":"dns.resolve(domain, [rrtype], callback)","s":" Resolves a domain (e.g. 'google.com'<\/code>) into an array of the record types\nspecified by rrtype. Valid rrtypes are 'A'<\/code> (IPV4 addresses, default),\n'AAAA'<\/code> (IPV6 addresses), 'MX'<\/code> (mail exchange records), 'TXT'<\/code> (text\nrecords), 'SRV'<\/code> (SRV records), 'PTR'<\/code> (used for reverse IP lookups),\n'NS'<\/code> (name server records) and 'CNAME'<\/code> (canonical name records).\n\n<\/p>\n The callback has arguments (err, addresses)<\/code>. The type of each item\nin addresses<\/code> is determined by the record type, and described in the\ndocumentation for the corresponding lookup methods below.\n\n<\/p>\n On error, err<\/code> is an Error<\/code> object, where err.code<\/code> is\none of the error codes listed below.\n\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":true,"t":"rrtype","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolve4":{"y":"dns.resolve4(domain, callback)","s":" The same as dns.resolve()<\/code>, but only for IPv4 queries (A<\/code> records).\naddresses<\/code> is an array of IPv4 addresses (e.g.\n['74.125.79.104', '74.125.79.105', '74.125.79.106']<\/code>).\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolve6":{"y":"dns.resolve6(domain, callback)","s":" The same as dns.resolve4()<\/code> except for IPv6 queries (an AAAA<\/code> query).\n\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolveMx":{"y":"dns.resolveMx(domain, callback)","s":" The same as dns.resolve()<\/code>, but only for mail exchange queries (MX<\/code> records).\n\n<\/p>\n addresses<\/code> is an array of MX records, each with a priority and an exchange\nattribute (e.g. [{'priority': 10, 'exchange': 'mx.example.com'},...]<\/code>).\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolveTxt":{"y":"dns.resolveTxt(domain, callback)","s":" The same as dns.resolve()<\/code>, but only for text queries (TXT<\/code> records).\naddresses<\/code> is an array of the text records available for domain<\/code> (e.g.,\n['v=spf1 ip4:0.0.0.0 ~all']<\/code>).\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolveSrv":{"y":"dns.resolveSrv(domain, callback)","s":" The same as dns.resolve()<\/code>, but only for service records (SRV<\/code> records).\naddresses<\/code> is an array of the SRV records available for domain<\/code>. Properties\nof SRV records are priority, weight, port, and name (e.g.,\n[{'priority': 10, {'weight': 5, 'port': 21223, 'name': 'service.example.com'}, ...]<\/code>).\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolveNs":{"y":"dns.resolveNs(domain, callback)","s":" The same as dns.resolve()<\/code>, but only for name server records (NS<\/code> records).\naddresses<\/code> is an array of the name server records available for domain<\/code>\n(e.g., ['ns1.example.com', 'ns2.example.com']<\/code>).\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"resolveCname":{"y":"dns.resolveCname(domain, callback)","s":" The same as dns.resolve()<\/code>, but only for canonical name records (CNAME<\/code>\nrecords). addresses<\/code> is an array of the canonical name records available for\ndomain<\/code> (e.g., ['bar.example.com']<\/code>).\n\n<\/p>\n","p":[{"o":false,"t":"domain","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"reverse":{"y":"dns.reverse(ip, callback)","s":" Reverse resolves an ip address to an array of domain names.\n\n<\/p>\n The callback has arguments (err, domains)<\/code>.\n\n<\/p>\n On error, err<\/code> is an Error<\/code> object, where err.code<\/code> is\none of the error codes listed below.\n\n<\/p>\n","p":[{"o":false,"t":"ip","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/nodejs/vm.json: -------------------------------------------------------------------------------- 1 | {"runInThisContext":{"y":"vm.runInThisContext(code, [filename])","s":" vm.runInThisContext()<\/code> compiles code<\/code>, runs it and returns the result. Running\ncode does not have access to local scope. filename<\/code> is optional, it's used only\nin stack traces.\n\n<\/p>\n Example of using vm.runInThisContext<\/code> and eval<\/code> to run the same code:\n\n<\/p>\n var localVar = 123,\n usingscript, evaled,\n vm = require('vm');\n\nusingscript = vm.runInThisContext('localVar = 1;',\n 'myfile.vm');\nconsole.log('localVar: ' + localVar + ', usingscript: ' +\n usingscript);\nevaled = eval('localVar = 1;');\nconsole.log('localVar: ' + localVar + ', evaled: ' +\n evaled);\n\n\/\/ localVar: 123, usingscript: 1\n\/\/ localVar: 1, evaled: 1<\/code><\/pre>\nvm.runInThisContext<\/code> does not have access to the local scope, so localVar<\/code> is unchanged.\neval<\/code> does have access to the local scope, so localVar<\/code> is changed.\n\n<\/p>\n In case of syntax error in code<\/code>, vm.runInThisContext<\/code> emits the syntax error to stderr\nand throws an exception.\n\n\n<\/p>\n","p":[{"o":false,"t":"code","d":"","type":""},{"o":true,"t":"filename","d":"","type":""}]},"runInNewContext":{"y":"vm.runInNewContext(code, [sandbox], [filename])","s":" vm.runInNewContext<\/code> compiles code<\/code>, then runs it in sandbox<\/code> and returns the\nresult. Running code does not have access to local scope. The object sandbox<\/code>\nwill be used as the global object for code<\/code>.\nsandbox<\/code> and filename<\/code> are optional, filename<\/code> is only used in stack traces.\n\n<\/p>\n Example: compile and execute code that increments a global variable and sets a new one.\nThese globals are contained in the sandbox.\n\n<\/p>\n var util = require('util'),\n vm = require('vm'),\n sandbox = {\n animal: 'cat',\n count: 2\n };\n\nvm.runInNewContext('count += 1; name = "kitty"', sandbox, 'myfile.vm');\nconsole.log(util.inspect(sandbox));\n\n\/\/ { animal: 'cat', count: 3, name: 'kitty' }<\/code><\/pre>\nNote that running untrusted code is a tricky business requiring great care. To prevent accidental\nglobal variable leakage, vm.runInNewContext<\/code> is quite useful, but safely running untrusted code\nrequires a separate process.\n\n<\/p>\n In case of syntax error in code<\/code>, vm.runInNewContext<\/code> emits the syntax error to stderr\nand throws an exception.\n\n<\/p>\n","p":[{"o":false,"t":"code","d":"","type":""},{"o":true,"t":"sandbox","d":"","type":""},{"o":true,"t":"filename","d":"","type":""}]},"runInContext":{"y":"vm.runInContext(code, context, [filename])","s":" vm.runInContext<\/code> compiles code<\/code>, then runs it in context<\/code> and returns the\nresult. A (V8) context comprises a global object, together with a set of\nbuilt-in objects and functions. Running code does not have access to local scope\nand the global object held within context<\/code> will be used as the global object\nfor code<\/code>.\nfilename<\/code> is optional, it's used only in stack traces.\n\n<\/p>\n Example: compile and execute code in a existing context.\n\n<\/p>\n var util = require('util'),\n vm = require('vm'),\n initSandbox = {\n animal: 'cat',\n count: 2\n },\n context = vm.createContext(initSandbox);\n\nvm.runInContext('count += 1; name = "CATT"', context, 'myfile.vm');\nconsole.log(util.inspect(context));\n\n\/\/ { animal: 'cat', count: 3, name: 'CATT' }<\/code><\/pre>\nNote that createContext<\/code> will perform a shallow clone of the supplied sandbox object in order to\ninitialize the global object of the freshly constructed context.\n\n<\/p>\n Note that running untrusted code is a tricky business requiring great care. To prevent accidental\nglobal variable leakage, vm.runInContext<\/code> is quite useful, but safely running untrusted code\nrequires a separate process.\n\n<\/p>\n In case of syntax error in code<\/code>, vm.runInContext<\/code> emits the syntax error to stderr\nand throws an exception.\n\n<\/p>\n","p":[{"o":false,"t":"code","d":"","type":""},{"o":false,"t":"context","d":"","type":""},{"o":true,"t":"filename","d":"","type":""}]},"createContext":{"y":"vm.createContext([initSandbox])","s":" vm.createContext<\/code> creates a new context which is suitable for use as the 2nd argument of a subsequent\ncall to vm.runInContext<\/code>. A (V8) context comprises a global object together with a set of\nbuild-in objects and functions. The optional argument initSandbox<\/code> will be shallow-copied\nto seed the initial contents of the global object used by the context.\n\n<\/p>\n","p":[{"o":true,"t":"initSandbox","d":"","type":""}]},"createScript":{"y":"vm.createScript(code, [filename])","s":" createScript<\/code> compiles code<\/code> but does not run it. Instead, it returns a\nvm.Script<\/code> object representing this compiled code. This script can be run\nlater many times using methods below. The returned script is not bound to any\nglobal object. It is bound before each run, just for that run. filename<\/code> is\noptional, it's only used in stack traces.\n\n<\/p>\n In case of syntax error in code<\/code>, createScript<\/code> prints the syntax error to stderr\nand throws an exception.\n\n\n<\/p>\n","p":[{"o":false,"t":"code","d":"","type":""},{"o":true,"t":"filename","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/Math.json: -------------------------------------------------------------------------------- 1 | {"E":{"s":"The Math.E property represents the base of natural logarithms, e, approximately 2.718.","y":"","p":null},"LN2":{"s":"The Math.LN2 property represents the natural logarithm of 2, approximately 0.693.","y":"","p":null},"LN10":{"s":"The Math.LN10 property represents the natural logarithm of 10, approximately 2.302.","y":"","p":null},"LOG2E":{"s":"The Math.LOG2E property represents the base 2 logarithm of E (approximately 1.442).","y":"","p":null},"LOG10E":{"s":"The Math.LOG10E property represents the base 10 logarithm of E (approximately 0.434).","y":"","p":null},"PI":{"s":"The Math.PI property represents the ratio of the circumference of a circle to its diameter, approximately 3.14159.","y":"","p":null},"SQRT1_2":{"s":"","y":"","p":null},"SQRT2abs":{"s":"","y":"","p":null},"acos":{"s":"The Math.acos() function returns the arccosine (in radians) of a number.","y":"Math.acos(x) ","p":null},"acosh":{"s":"The Math.acosh() function returns the hyperbolic arccosine (in radians) of a number.","y":"Math.acosh(x) ","p":null},"asin":{"s":"The Math.asin() function returns the arcsine (in radians) of a number.","y":"Math.asin(x)","p":[{"t":"x","d":"A number."}]},"asinh":{"s":"The Math.asinh() function returns the hyperbolic arcsine (in radians) of a number.","y":"Math.asinh(x)","p":[{"t":"x","d":"A number."}]},"atan":{"s":"The Math.atan() function returns the arctangent (in radians) of a number.","y":"Math.atan(x)","p":[{"t":"x","d":"A number."}]},"atanh":{"s":"The Math.atanh() function returns the hyperbolic arctangent (in radians) of a number.","y":"Math.atanh(x)","p":[{"t":"x","d":"A number."}]},"atan2":{"s":"The Math.atan2() function returns the arctangent of the quotient of its arguments.","y":"Math.atan2(y, x) ","p":null},"cbrt":{"s":"The Math.cbrt() function returns the cube root (x3) of a number.","y":"\nMath.cbrt(x)","p":[{"t":"x","d":"A number."}]},"ceil":{"s":"The Math.ceil() function returns the smallest integer greater than or equal to a number.","y":"Math.ceil(x) ","p":[{"t":"x","d":"A number."}]},"cos":{"s":"The Math.cos() function returns the cosine of a number.","y":"Math.cos(x)","p":[{"t":"x","d":"A number given in unit of radians."}]},"cosh":{"s":"The Math.cosh() function returns the hyperbolic cosine of a number.","y":"Math.cosh(x)","p":[{"t":"x","d":"A number."}]},"exp":{"s":"The Math.exp() function returns Ex, where x is the argument, and E is Euler's constant, the base of the natural logarithms.","y":"Math.exp(x)","p":[{"t":"x","d":"A number."}]},"expm1":{"s":"The Math.expm1() function returns Ex - 1, where x is the argument, and E is Euler's constant, the base of the natural logarithms.","y":"Math.expm1(x)","p":[{"t":"x","d":"A number."}]},"floor":{"s":"The Math.floor() function returns the largest integer less than or equal to a number.","y":"Math.floor(x) ","p":[{"t":"x","d":"A number."}]},"fround":{"s":"The Math.fround() function returns the nearest single precision float representation of a number.","y":"Math.fround(x)","p":[{"t":"x","d":"A number."}]},"hypot":{"s":"The Math.hypot() function returns the square root of the sum of squares of its arguments ( value12+value22+... \\sqrt{\\mathrm{value}_1^2+\\mathrm{value}_2^2+...})","y":"\nMath.hypot([value1[,value2, ...]]) ","p":null},"imul":{"s":"The Math.imul() function returns the result of the C-like 32-bit multiplication of the two parameters.","y":"Math.imul(a, b)","p":[{"t":"a","d":"First number."},{"t":"b","d":"Second number."}]},"log":{"s":"The Math.log() function returns the natural logarithm (base E) of a number.","y":"Math.log(x)","p":[{"t":"x","d":"A number."}]},"log1p":{"s":"The Math.log1p() function returns the natural logarithm (base E) of 1 + a number.","y":"Math.log1p(x)","p":[{"t":"x","d":"A number."}]},"log10":{"s":"The Math.log10() function returns the base 10 logarithm of a number.","y":"Math.log10(x)","p":[{"t":"x","d":"A number."}]},"log2":{"s":"The Math.log2() function returns the base 2 logarithm of a number.","y":"Math.log2(x)","p":[{"t":"x","d":"A number."}]},"max":{"s":"The Math.max() function returns the largest of zero or more numbers.","y":"Math.max([value1[,value2, ...]]) ","p":null},"min":{"s":"The Math.min() function returns the smallest of zero or more numbers.","y":"Math.min([value1[,value2, ...]]) ","p":[{"t":"value1, value2, ...","d":"Numbers."}]},"pow":{"s":"The Math.pow() function returns the base to the\u00a0exponent Power,\u00a0 that is, baseexponent.","y":"Math.pow(base, exponent) ","p":[{"t":"base","d":"The base number."},{"t":"exponent","d":"The exponent used to raise the\u00a0base."}]},"random":{"s":"The Math.random() function returns a floating-point, pseudo-random number in the range [0, 1)\u00a0that is, from 0 (inclusive) up to but not including 1 (exclusive), which you can then scale to your desired range.","y":"Math.random()","p":null},"round":{"s":"The Math.round() function returns the value of a number rounded to the nearest integer.","y":"Math.round(x) ","p":[{"t":"x","d":"A number."}]},"sign":{"s":"The Math.sign() function returns the sign of a number, indicating whether the number is positive, negative or zero.","y":"Math.sign(x)","p":[{"t":"x","d":"A number."}]},"sin":{"s":"The Math.sin() function returns the sine of a number.","y":"Math.sin(x)","p":[{"t":"x","d":"A number (given in radians)."}]},"sinh":{"s":"The Math.sinh() function returns the hyperbolic sine of a number.","y":"Math.sinh(x)","p":[{"t":"x","d":"A number (given in radians)."}]},"sqrt":{"s":"The Math.sqrt() function returns the square root (x\\sqrt{x}) of a number.","y":"\nMath.sqrt(x) ","p":[{"t":"x","d":"A number."}]},"tan":{"s":"The Math.tan() function returns the tangent of a number.","y":"Math.tan(x)","p":[{"t":"x","d":"A number representing an angle in radians."}]},"tanh":{"s":"The Math.tanh() function returns the hyperbolic tangent of a number.","y":"Math.tanh(x)","p":[{"t":"x","d":"A number."}]},"trunc":{"s":"The Math.trunc() function returns the integral part of a number by removing any fractional digits. It does not round any numbers.","y":"Math.trunc(x)","p":[{"t":"x","d":"A number."}]}} -------------------------------------------------------------------------------- /docs/reactjs/component.json: -------------------------------------------------------------------------------- 1 | {"render":{"s":"The render() method is required. When called, it should examine this.props and this.state and return a single child component. This child component can be either a virtual representation of a native DOM component (such as <div /> or React.DOM.div()) or another composite component that you've defined yourself. You can also return null or false to indicate that you don't want anything rendered. Behind the scenes, React renders a <noscript> tag to work with our current diffing algorithm. When returning null or false, this.getDOMNode() will return null.","y":"ReactComponent render()","p":null,"r":{"d":"return null or false if you don't want to render anything. Otherwise return the HTML element you want to render.","type":"Boolean|HTML"},"url":"http://facebook.github.io/react/docs/component-specs.html#render"},"getInitialState":{"s":"Invoked once before the component is mounted.","y":"object getInitialState()","p":null,"r":{"d":"The return value will be used as the initial value of this.state","type":"Object"},"url":"http://facebook.github.io/react/docs/component-specs.html#getinitialstate"},"getDefaultProps":{"s":"Invoked once and cached when the class is created. Values in the mapping will be set on this.props if that prop is not specified by the parent component (i.e. using an in check). This method is invoked before any instances are created and thus cannot rely on this.props. In addition, be aware that any complex objects returned by getDefaultProps() will be shared across instances, not copied.","y":"object getDefaultProps()","p":null,"r":{"d":"The return value will be used as the default value of this.props","type":"Object"},"url":"http://facebook.github.io/react/docs/component-specs.html#getdefaultprops"},"componentWillMount":{"s":"Invoked once, both on the client and server, immediately before the initial rendering occurs. If you call setState within this method, render() will see the updated state and will be executed only once despite the state change","y":"componentWillMount()","p":null,"url":"http://facebook.github.io/react/docs/component-specs.html#mounting-componentwillmount"},"componentDidMount":{"s":"Invoked once, only on the client (not on the server), immediately after the initial rendering occurs. At this point in the lifecycle, the component has a DOM representation which you can access via this.getDOMNode(). If you want to integrate with other JavaScript frameworks, set timers using setTimeout or setInterval, or send AJAX requests, perform those operations in this method.","y":"componentDidMount()","p":null,"url":"http://facebook.github.io/react/docs/component-specs.html#mounting-componentdidmount"},"componentWillReceiveProps":{"s":"Invoked when a component is receiving new props. This method is not called for the initial render. Use this as an opportunity to react to a prop transition before render() is called by updating the state using this.setState(). The old props can be accessed via this.props. Calling this.setState() within this function will not trigger an additional render.","y":"componentWillReceiveProps: function(nextProps) { this.setState({ likesIncreasing: nextProps.likeCount > this.props.likeCount }); }","p":[{"t":"nextProps","type":"object","d":"The new props"}],"url":"http://facebook.github.io/react/docs/component-specs.html#updating-componentwillreceiveprops"},"shouldComponentUpdate":{"s":"Invoked before rendering when new props or state are being received. This method is not called for the initial render or when forceUpdate is used. Use this as an opportunity to return false when you're certain that the transition to the new props and state will not require a component update. If shouldComponentUpdate returns false, then render() will be completely skipped until the next state change. (In addition, componentWillUpdate and componentDidUpdate will not be called.) By default, shouldComponentUpdate always returns true to prevent subtle bugs when state is mutated in place, but if you are careful to always treat state as immutable and to read only from props and state in render() then you can override shouldComponentUpdate with an implementation that compares the old props and state to their replacements. If performance is a bottleneck, especially with dozens or hundreds of components, use shouldComponentUpdate to speed up your app.","y":"shouldComponentUpdate: function(nextProps, nextState) { return nextProps.id !== this.props.id; }","p":[{"t":"nextProps","type":"object","d":"The new props"},{"t":"nextStae","type":"object","d":"The new states"}],"url":"http://facebook.github.io/react/docs/component-specs.html#updating-shouldcomponentupdate"},"componentWillUpdate":{"s":"Invoked immediately before rendering when new props or state are being received. This method is not called for the initial render. Use this as an opportunity to perform preparation before an update occurs.","y":"componentWillUpdate(object nextProps, object nextState)","p":[{"t":"nextProps","type":"object","d":"The new props"},{"t":"nextStae","type":"object","d":"The new states"}],"url":"http://facebook.github.io/react/docs/component-specs.html#updating-componentwillupdate"},"componentDidUpdate":{"s":"Invoked immediately after updating occurs. This method is not called for the initial render. Use this as an opportunity to operate on the DOM when the component has been updated.","y":"componentDidUpdate(object prevProps, object prevState)","p":[{"t":"nextProps","type":"object","d":"The old props"},{"t":"nextStae","type":"object","d":"The old states"}],"url":"http://facebook.github.io/react/docs/component-specs.html#updating-componentdidupdate"},"componentWillUnmount":{"s":"Invoked immediately before a component is unmounted from the DOM. Perform any necessary cleanup in this method, such as invalidating timers or cleaning up any DOM elements that were created in componentDidMount.","y":"componentWillUnmount()","p":null,"url":"http://facebook.github.io/react/docs/component-specs.html#unmounting-componentwillunmount"}} -------------------------------------------------------------------------------- /docs/nodejs/https.json: -------------------------------------------------------------------------------- 1 | {"createServer":{"y":"https.createServer(options, [requestListener])","s":" Returns a new HTTPS web server object. The options<\/code> is similar to\n[tls.createServer()][]. The requestListener<\/code> is a function which is\nautomatically added to the 'request'<\/code> event.\n\n<\/p>\n Example:\n\n<\/p>\n \/\/ curl -k https:\/\/localhost:8000\/\nvar https = require('https');\nvar fs = require('fs');\n\nvar options = {\n key: fs.readFileSync('test\/fixtures\/keys\/agent2-key.pem'),\n cert: fs.readFileSync('test\/fixtures\/keys\/agent2-cert.pem')\n};\n\nhttps.createServer(options, function (req, res) {\n res.writeHead(200);\n res.end("hello world\\n");\n}).listen(8000);<\/code><\/pre>\nOr\n\n<\/p>\n var https = require('https');\nvar fs = require('fs');\n\nvar options = {\n pfx: fs.readFileSync('server.pfx')\n};\n\nhttps.createServer(options, function (req, res) {\n res.writeHead(200);\n res.end("hello world\\n");\n}).listen(8000);<\/code><\/pre>\n","p":[{"o":false,"t":"options","d":"","type":""},{"o":true,"t":"requestListener","d":"","type":""}]},"request":{"y":"https.request(options, callback)","s":"Makes a request to a secure web server.\n\n<\/p>\n options<\/code> can be an object or a string. If options<\/code> is a string, it is\nautomatically parsed with url.parse()<\/a>.\n\n<\/p>\n All options from [http.request()][] are valid.\n\n<\/p>\n Example:\n\n<\/p>\n var https = require('https');\n\nvar options = {\n hostname: 'encrypted.google.com',\n port: 443,\n path: '\/',\n method: 'GET'\n};\n\nvar req = https.request(options, function(res) {\n console.log("statusCode: ", res.statusCode);\n console.log("headers: ", res.headers);\n\n res.on('data', function(d) {\n process.stdout.write(d);\n });\n});\nreq.end();\n\nreq.on('error', function(e) {\n console.error(e);\n});<\/code><\/pre>\nThe options argument has the following options\n\n<\/p>\n\nhost<\/code>: A domain name or IP address of the server to issue the request to.\nDefaults to 'localhost'<\/code>.<\/li>\n hostname<\/code>: To support url.parse()<\/code> hostname<\/code> is preferred over host<\/code><\/li>\n port<\/code>: Port of remote server. Defaults to 443.<\/li>\n method<\/code>: A string specifying the HTTP request method. Defaults to 'GET'<\/code>.<\/li>\n path<\/code>: Request path. Defaults to '\/'<\/code>. Should include query string if any.\nE.G. '\/index.html?page=12'<\/code><\/li>\n headers<\/code>: An object containing request headers.<\/li>\n auth<\/code>: Basic authentication i.e. 'user:password'<\/code> to compute an\nAuthorization header.<\/li>\nagent<\/code>: Controls [Agent][] behavior. When an Agent is used request will\ndefault to Connection: keep-alive<\/code>. Possible values:\nundefined<\/code> (default): use [globalAgent][] for this host and port.<\/li>\n Agent<\/code> object: explicitly use the passed in Agent<\/code>.<\/li>\nfalse<\/code>: opts out of connection pooling with an Agent, defaults request to\nConnection: close<\/code>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nThe following options from [tls.connect()][] can also be specified. However, a\n[globalAgent][] silently ignores these.\n\n<\/p>\n\npfx<\/code>: Certificate, Private key and CA certificates to use for SSL. Default null<\/code>.<\/li>\n key<\/code>: Private key to use for SSL. Default null<\/code>.<\/li>\n passphrase<\/code>: A string of passphrase for the private key or pfx. Default null<\/code>.<\/li>\n cert<\/code>: Public x509 certificate to use. Default null<\/code>.<\/li>\n ca<\/code>: An authority certificate or array of authority certificates to check\nthe remote host against.<\/li>\nciphers<\/code>: A string describing the ciphers to use or exclude. Consult\nhttp:\/\/www.openssl.org\/docs\/apps\/ciphers.html#CIPHER_LIST_FORMAT<\/a> for\ndetails on the format.<\/li>\n rejectUnauthorized<\/code>: If true<\/code>, the server certificate is verified against\nthe list of supplied CAs. An 'error'<\/code> event is emitted if verification\nfails. Verification happens at the connection level, before<\/em> the HTTP\nrequest is sent. Default true<\/code>.<\/li>\n secureProtocol<\/code>: The SSL method to use, e.g. SSLv3_method<\/code> to force\nSSL version 3. The possible values depend on your installation of\nOpenSSL and are defined in the constant [SSL_METHODS][].<\/li>\n<\/ul>\nIn order to specify these options, use a custom Agent<\/code>.\n\n<\/p>\n Example:\n\n<\/p>\nvar options = {\n hostname: 'encrypted.google.com',\n port: 443,\n path: '\/',\n method: 'GET',\n key: fs.readFileSync('test\/fixtures\/keys\/agent2-key.pem'),\n cert: fs.readFileSync('test\/fixtures\/keys\/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nvar req = https.request(options, function(res) {\n ...\n}<\/code><\/pre>\nOr does not use an Agent<\/code>.\n\n<\/p>\n Example:\n\n<\/p>\nvar options = {\n hostname: 'encrypted.google.com',\n port: 443,\n path: '\/',\n method: 'GET',\n key: fs.readFileSync('test\/fixtures\/keys\/agent2-key.pem'),\n cert: fs.readFileSync('test\/fixtures\/keys\/agent2-cert.pem'),\n agent: false\n};\n\nvar req = https.request(options, function(res) {\n ...\n}<\/code><\/pre>\n","p":[{"o":false,"t":"options","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"get":{"y":"https.get(options, callback)","s":"Like http.get()<\/code> but for HTTPS.\n\n<\/p>\noptions<\/code> can be an object or a string. If options<\/code> is a string, it is\nautomatically parsed with url.parse()<\/a>.\n\n<\/p>\n Example:\n\n<\/p>\n var https = require('https');\n\nhttps.get('https:\/\/encrypted.google.com\/', function(res) {\n console.log("statusCode: ", res.statusCode);\n console.log("headers: ", res.headers);\n\n res.on('data', function(d) {\n process.stdout.write(d);\n });\n\n}).on('error', function(e) {\n console.error(e);\n});<\/code><\/pre>\n","p":[{"o":false,"t":"options","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/window.json: -------------------------------------------------------------------------------- 1 | {"addEventListener":{"s":"","y":null,"p":null},"alert":{"s":"The Window.alert() method displays an alert dialog with the optional specified content and an OK button.","y":"window.alert(message<\/em>);","p":null},"atob":{"s":"","y":null,"p":null},"back":{"s":"Returns the window to the previous item in the history. This was a Gecko-specific method. Use the standard history.back method instead.","y":null,"p":null},"blur":{"s":"Shifts focus away from the window.","y":"window.blur()<\/code>","p":null},"btoa":{"s":"","y":null,"p":null},"captureEvents":{"s":"Registers the window to capture all events of the specified type.","y":"window.captureEvents(eventType<\/em>) \n","p":null},"clearImmediate":{"s":"This method clears the action specified by window.setImmediate.","y":"window.clearImmediate(immediateID)\n","p":null},"clearInterval":{"s":"","y":null,"p":null},"clearTimeout":{"s":"","y":null,"p":null},"close":{"s":"Closes the current window, or a referenced window.","y":"window<\/em>.close();\n","p":null},"confirm":{"s":"The Window.confirm() method displays a modal dialog with an optional message and two buttons, OK and Cancel.","y":"result<\/i> = window.confirm(message<\/i>);\n","p":null},"dispatchEvent":{"s":"See EventTarget.dispatchEvent","y":null,"p":null},"dump":{"s":"Prints messages to the (native) console.","y":"window.dump(message<\/em>);\n\ndump(message<\/em>);\n","p":null},"find":{"s":"Finds a string in a window.","y":"window<\/em>.find(aString<\/em>, aCaseSensitive<\/em>, aBackwards<\/em>, aWrapAround<\/em>,\n aWholeWord<\/em>, aSearchInFrames<\/em>, aShowDialog<\/em>);","p":null},"focus":{"s":"Makes a request to bring the window to the front. It may fail due to user settings and the window isn't guaranteed to be frontmost before this method returns.","y":null,"p":null},"forward":{"s":"Moves the window one document forward in the history. This was a Gecko-specific method. Use the standard history.forward method instead.","y":"window.forward() \n","p":null},"getAttention":{"s":"Attempts to get the user's attention. How this happens varies based on OS and window manager.","y":"window.getAttention();\n","p":null},"getComputedStyle":{"s":"The Window.getComputedStyle() method gives the values of all the CSS properties of an element after applying the active stylesheets and resolving any basic computation those values may contain.","y":"var style<\/em> = window.getComputedStyle(element<\/em>[, pseudoElt<\/em>]);\n","p":null},"getSelection":{"s":"Returns a selection object representing the range of text selected by the user. ","y":"selection<\/em> = window<\/em>.getSelection() ;","p":null},"home":{"s":"Returns the window to the home page.","y":"window.home() \n","p":null},"matchMedia":{"s":"Returns a new MediaQueryList object representing the parsed results of the specified media query string.","y":"mql<\/em> = window.matchMedia(mediaQueryString<\/em>)","p":null},"minimize":{"s":"Sets a window to minimized state (a way to undo it programatically is by calling window.moveTo()).","y":null,"p":null},"moveBy":{"s":"Moves the current window by a specified amount.","y":"window.moveBy(deltaX<\/em>, deltaY<\/em>) \n","p":null},"moveTo":{"s":"Moves the window to the specified coordinates.","y":"window.moveTo(x<\/var>, y<\/var>) \n","p":null},"mozRequestAnimationFrame":{"s":"","y":null,"p":null},"open":{"s":"Loads a resource into either a new browsing context (such as a window) or one that already exists, depending on the specified parameters.","y":"var windowObjectReference<\/var> = window.open(strUrl<\/var>, strWindowName<\/var>, [strWindowFeatures<\/var>]);<\/code>","p":null},"openDialog":{"s":"window.openDialog is an extension to window.open. It behaves the same, except that it can optionally take one or more parameters past windowFeatures, and windowFeatures itself is treated a little differently.","y":"newWindow<\/em> = openDialog(url<\/em>, name<\/em>, features<\/em>, arg1<\/em>, arg2<\/em>, ...) \n","p":[{"t":"","d":"The opened window"},{"t":"","d":"The URL to be loaded in the newly opened window."},{"t":"","d":"The window name (optional). See window.open description for detailed information."},{"t":"","d":"See window.open description for description."},{"t":"all","d":"The arguments to be passed to the new window (optional)."}]},"postMessage":{"s":"The window.postMessage method safely enables cross-origin communication. Normally, scripts on different pages are allowed to access each other if and only if the pages that executed them are at locations with the same protocol (usually both http), port number (80 being the default for http), and host (modulo document.domain being set by both pages to the same value). window.postMessage provides a controlled mechanism to circumvent this restriction in a way which is secure when properly used.","y":"otherWindow<\/em>.postMessage(message<\/em>, targetOrigin<\/em>, [transfer<\/em>]);","p":null},"print":{"s":"Opens the Print Dialog to print the current document.","y":"window.print() \n","p":null},"prompt":{"s":"The Window.prompt() displays a dialog with an optional message prompting the user to input some text.","y":"result<\/em> = window.prompt(text<\/em>, value<\/em>);\n","p":null},"releaseEvents":{"s":"Releases the window from trapping events of a specific type.","y":"window.releaseEvents(eventType<\/i>) \n","p":null},"resizeBy":{"s":"Resizes the current window by a certain amount.","y":"window.resizeBy(xDelta<\/em>, yDelta<\/em>) \n","p":null},"resizeTo":{"s":"Dynamically resizes window.","y":"window.resizeTo(aWidth<\/em>, aHeight<\/em>) \n","p":null},"restore":{"s":"This method is currently not working, but you can use:","y":null,"p":null},"scroll":{"s":"Scrolls the window to a particular place in the document.","y":"window.scroll(x-coord<\/i>,y-coord<\/i>) \n","p":null},"scrollBy":{"s":"Scrolls the document in the window by the given amount.","y":"window.scrollBy(X<\/i>,Y<\/i>);\n","p":null},"scrollByLines":{"s":"Scrolls the document by the given number of lines.","y":"window.scrollByLines(lines<\/var>) \n","p":null},"scrollByPages":{"s":"Scrolls the current document by the specified number of pages.","y":"window.scrollByPages(pages<\/em>) \n","p":null},"scrollTo":{"s":"Scrolls to a particular set of coordinates in the document.","y":"window.scrollTo(x-coord<\/i>,y-coord<\/i> )<\/code>","p":null},"setCursor":{"s":"Changes the cursor for the current window.","y":null,"p":null},"setImmediate":{"s":"This method is used to break up long running operations and run a callback function immediately after the browser has completed other operations such as events and display updates.","y":null,"p":null},"setInterval":{"s":"","y":null,"p":null},"setTimeout":{"s":"","y":null,"p":null},"showModalDialog":{"s":"DeprecatedThis feature has been removed from the Web standards. Though some browsers may still support it, it is in the process of being dropped. Do not use it in old or new projects. Pages or Web apps using it may break at any time.","y":"returnVal<\/var> = window.showModalDialog(uri<\/var>[, arguments<\/var>][, options<\/var>]);\n","p":null},"sizeToContent":{"s":"Non-standard \n This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.","y":"window.sizeToContent() \n","p":null},"stop":{"s":"This method stops window loading.","y":"window.stop() \n","p":null},"updateCommands":{"s":"Updates the state of commands of the current chrome window (UI).","y":"window.updateCommands(\"sCommandName\")\n","p":null}} -------------------------------------------------------------------------------- /QuickOpenJS.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2012 Adobe Systems Incorporated. All rights reserved. 3 | * 4 | * Permission is hereby granted, free of charge, to any person obtaining a 5 | * copy of this software and associated documentation files (the "Software"), 6 | * to deal in the Software without restriction, including without limitation 7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 | * and/or sell copies of the Software, and to permit persons to whom the 9 | * Software is furnished to do so, subject to the following conditions: 10 | * 11 | * The above copyright notice and this permission notice shall be included in 12 | * all copies or substantial portions of the Software. 13 | * 14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 20 | * DEALINGS IN THE SOFTWARE. 21 | * 22 | */ 23 | 24 | /*jslint vars: true, plusplus: true, devel: true, nomen: true, regexp: true, indent: 4, maxerr: 50 */ 25 | /*global define, $, brackets */ 26 | 27 | 28 | 29 | define(function (require, exports, module) { 30 | "use strict"; 31 | 32 | var EditorManager = brackets.getModule("editor/EditorManager"), 33 | Editor = brackets.getModule("editor/Editor"), 34 | DocumentManager = brackets.getModule("document/DocumentManager"), 35 | JSUtils = brackets.getModule("language/JSUtils"), 36 | PerfUtils = brackets.getModule("utils/PerfUtils"), 37 | ProjectManager = brackets.getModule("project/ProjectManager"), 38 | LanguageManager = brackets.getModule("language/LanguageManager"), 39 | CommandManager = brackets.getModule("command/CommandManager"), 40 | Commands = brackets.getModule("command/Commands"); 41 | 42 | 43 | /** 44 | * Find function in a project and return the first found function with a specific name 45 | * Using {@link _findFunctionWithoutTern} if tern doesn't work 46 | * @param {String} functionName name of the function 47 | * @returns {Deferred} Object which includes the path and the lines of the function 48 | */ 49 | function findFunctionInProject(functionName) { 50 | var result = new $.Deferred(); 51 | 52 | // Use Tern jump-to-definition helper, if it's available, to find InlineEditor target. 53 | var helper = brackets._jsCodeHintsHelper; 54 | if (helper === null) { 55 | result.reject(); 56 | } 57 | 58 | var response = helper(); 59 | if (response.hasOwnProperty("promise")) { 60 | response.promise.done(function (jumpResp) { 61 | var resolvedPath = jumpResp.fullPath; 62 | if (resolvedPath) { 63 | // Tern doesn't always return entire function extent. 64 | // Use QuickEdit search now that we know which file to look at. 65 | var fileInfos = []; 66 | fileInfos.push({name: jumpResp.resultFile, fullPath: resolvedPath}); 67 | JSUtils.findMatchingFunctions(functionName, fileInfos, true) 68 | .done(function (functions) { 69 | if (functions && functions.length > 0) { 70 | result.resolve(functions[0]); 71 | } else { 72 | console.log('no function found with tern'); 73 | // try without tern 74 | _findFunctionWithoutTern(functionName).done(function (functions) { 75 | if (functions && functions.length > 0) { 76 | result.resolve(functions[0]); 77 | } else { 78 | console.log('no function found'); 79 | result.reject(); 80 | } 81 | }).fail(function () { 82 | result.reject(); 83 | }); 84 | } 85 | }) 86 | .fail(function () { 87 | result.reject(); 88 | }); 89 | 90 | } else { // no result from Tern. 91 | _findFunctionWithoutTern(functionName).done(function (functions) { 92 | if (functions && functions.length > 0) { 93 | result.resolve(functions[0]); 94 | } else { 95 | console.log('no function found'); 96 | result.reject(); 97 | } 98 | }).fail(function () { 99 | result.reject(); 100 | }); 101 | } 102 | 103 | }).fail(function () { 104 | result.reject(); 105 | }); 106 | } 107 | 108 | return result.promise(); 109 | } 110 | 111 | 112 | /* 113 | * Find a function without using tern 114 | * @param {!string} functionName 115 | * @return {$.Promise} a promise that will be resolved with an array of function offset information 116 | */ 117 | function _findFunctionWithoutTern(functionName) { 118 | var result = new $.Deferred(); 119 | 120 | var timerName = PerfUtils.markStart(PerfUtils.JAVASCRIPT_FIND_FUNCTION); 121 | 122 | function _nonBinaryFileFilter(file) { 123 | return !LanguageManager.getLanguageForPath(file.fullPath).isBinary(); 124 | } 125 | 126 | ProjectManager.getAllFiles(_nonBinaryFileFilter) 127 | .done(function (files) { 128 | JSUtils.findMatchingFunctions(functionName, files) 129 | .done(function (functions) { 130 | PerfUtils.addMeasurement(timerName); 131 | result.resolve(functions); 132 | }) 133 | .fail(function () { 134 | PerfUtils.finalizeMeasurement(timerName); 135 | result.reject(); 136 | }); 137 | }) 138 | .fail(function () { 139 | result.reject(); 140 | }); 141 | 142 | return result.promise(); 143 | } 144 | /** 145 | * Jump to a given function 146 | * @param {String} functionName 147 | */ 148 | function itemFocus(functionName) { 149 | if (!functionName) { 150 | return; 151 | } 152 | 153 | findFunctionInProject(functionName).done(function(func) { 154 | if (DocumentManager.getCurrentDocument().file._path != func.document.file._path) { 155 | CommandManager.execute( Commands.FILE_OPEN, { fullPath: func.document.file._path } ).done( function() { 156 | setCursorPos(func.lineStart,0,true); 157 | }); 158 | } else { 159 | setCursorPos(func.lineStart,0,true); 160 | } 161 | }); 162 | } 163 | 164 | /** 165 | * Set the curor position in the current file 166 | * @param {Number} line line number 167 | * @param {Number} ch Column/Char number 168 | * @param {Boolean} center true for center the cursor position 169 | */ 170 | function setCursorPos(line,ch,center) { 171 | // Set focus on editor. 172 | EditorManager.focusEditor(); 173 | EditorManager.getCurrentFullEditor().setCursorPos( 174 | line, 175 | ch, 176 | center ); 177 | } 178 | 179 | 180 | exports.findFunctionInProject = findFunctionInProject; 181 | exports.itemFocus = itemFocus; 182 | }); 183 | -------------------------------------------------------------------------------- /docs/nodejs/util.json: -------------------------------------------------------------------------------- 1 | {"format":{"y":"util.format(format, [...])","s":"Returns a formatted string using the first argument as a printf<\/code>-like format.\n\n<\/p>\n The first argument is a string that contains zero or more placeholders<\/em>.\nEach placeholder is replaced with the converted value from its corresponding\nargument. Supported placeholders are:\n\n<\/p>\n\n%s<\/code> - String.<\/li>\n %d<\/code> - Number (both integer and float).<\/li>\n %j<\/code> - JSON.<\/li>\n%<\/code> - single percent sign ('%'<\/code>). This does not consume an argument.<\/li>\n<\/ul>\nIf the placeholder does not have a corresponding argument, the placeholder is\nnot replaced.\n\n<\/p>\nutil.format('%s:%s', 'foo'); \/\/ 'foo:%s'<\/code><\/pre>\nIf there are more arguments than placeholders, the extra arguments are\nconverted to strings with util.inspect()<\/code> and these strings are concatenated,\ndelimited by a space.\n\n<\/p>\nutil.format('%s:%s', 'foo', 'bar', 'baz'); \/\/ 'foo:bar baz'<\/code><\/pre>\nIf the first argument is not a format string then util.format()<\/code> returns\na string that is the concatenation of all its arguments separated by spaces.\nEach argument is converted to a string with util.inspect()<\/code>.\n\n<\/p>\nutil.format(1, 2, 3); \/\/ '1 2 3'<\/code><\/pre>\n","p":[{"o":false,"t":"format","d":"","type":""},{"o":true,"t":"...","d":"","type":""}]},"debug":{"y":"util.debug(string)","s":"A synchronous output function. Will block the process and\noutput string<\/code> immediately to stderr<\/code>.\n\n<\/p>\nrequire('util').debug('message on stderr');<\/code><\/pre>\n","p":[{"o":false,"t":"string","d":"","type":""}]},"error":{"y":"util.error([...])","s":"Same as util.debug()<\/code> except this will output all arguments immediately to\nstderr<\/code>.\n\n<\/p>\n","p":[{"o":true,"t":"...","d":"","type":""}]},"puts":{"y":"util.puts([...])","s":" A synchronous output function. Will block the process and output all arguments\nto stdout<\/code> with newlines after each argument.\n\n<\/p>\n","p":[{"o":true,"t":"...","d":"","type":""}]},"print":{"y":"util.print([...])","s":" A synchronous output function. Will block the process, cast each argument to a\nstring then output to stdout<\/code>. Does not place newlines after each argument.\n\n<\/p>\n","p":[{"o":true,"t":"...","d":"","type":""}]},"log":{"y":"util.log(string)","s":" Output with timestamp on stdout<\/code>.\n\n<\/p>\nrequire('util').log('Timestamped message.');<\/code><\/pre>\n","p":[{"o":false,"t":"string","d":"","type":""}]},"inspect":{"y":"util.inspect(object, [options])","s":"Return a string representation of object<\/code>, which is useful for debugging.\n\n<\/p>\n An optional options<\/em> object may be passed that alters certain aspects of the\nformatted string:\n\n<\/p>\n\nshowHidden<\/code> - if true<\/code> then the object's non-enumerable properties will be\nshown too. Defaults to false<\/code>.<\/p>\n<\/li>\n depth<\/code> - tells inspect<\/code> how many times to recurse while formatting the\nobject. This is useful for inspecting large complicated objects. Defaults to\n2<\/code>. To make it recurse indefinitely pass null<\/code>.<\/p>\n<\/li>\n colors<\/code> - if true<\/code>, then the output will be styled with ANSI color codes.\nDefaults to false<\/code>. Colors are customizable, see below.<\/p>\n<\/li>\n customInspect<\/code> - if false<\/code>, then custom inspect()<\/code> functions defined on the\nobjects being inspected won't be called. Defaults to true<\/code>.<\/p>\n<\/li>\n<\/ul>\n Example of inspecting all properties of the util<\/code> object:\n\n<\/p>\n var util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));<\/code><\/pre>\n","p":[{"o":false,"t":"object","d":"","type":""},{"o":true,"t":"options","d":"","type":""}]},"isArray":{"y":"util.isArray(object)","s":"Returns true<\/code> if the given "object" is an Array<\/code>. false<\/code> otherwise.\n\n<\/p>\n var util = require('util');\n\nutil.isArray([])\n \/\/ true\nutil.isArray(new Array)\n \/\/ true\nutil.isArray({})\n \/\/ false<\/code><\/pre>\n","p":[{"o":false,"t":"object","d":"","type":""}]},"isRegExp":{"y":"util.isRegExp(object)","s":"Returns true<\/code> if the given "object" is a RegExp<\/code>. false<\/code> otherwise.\n\n<\/p>\n var util = require('util');\n\nutil.isRegExp(\/some regexp\/)\n \/\/ true\nutil.isRegExp(new RegExp('another regexp'))\n \/\/ true\nutil.isRegExp({})\n \/\/ false<\/code><\/pre>\n","p":[{"o":false,"t":"object","d":"","type":""}]},"isDate":{"y":"util.isDate(object)","s":"Returns true<\/code> if the given "object" is a Date<\/code>. false<\/code> otherwise.\n\n<\/p>\n var util = require('util');\n\nutil.isDate(new Date())\n \/\/ true\nutil.isDate(Date())\n \/\/ false (without 'new' returns a String)\nutil.isDate({})\n \/\/ false<\/code><\/pre>\n","p":[{"o":false,"t":"object","d":"","type":""}]},"isError":{"y":"util.isError(object)","s":"Returns true<\/code> if the given "object" is an Error<\/code>. false<\/code> otherwise.\n\n<\/p>\n var util = require('util');\n\nutil.isError(new Error())\n \/\/ true\nutil.isError(new TypeError())\n \/\/ true\nutil.isError({ name: 'Error', message: 'an error occurred' })\n \/\/ false<\/code><\/pre>\n","p":[{"o":false,"t":"object","d":"","type":""}]},"pump":{"y":"util.pump(readableStream, writableStream, [callback])","s":"Read the data from readableStream<\/code> and send it to the writableStream<\/code>.\nWhen writableStream.write(data)<\/code> returns false<\/code> readableStream<\/code> will be\npaused until the drain<\/code> event occurs on the writableStream<\/code>. callback<\/code> gets\nan error as its only argument and is called when writableStream<\/code> is closed or\nwhen an error occurs.\n\n\n<\/p>\n","p":[{"o":false,"t":"readableStream","d":"","type":""},{"o":false,"t":"writableStream","d":"","type":""},{"o":true,"t":"callback","d":"","type":""}]},"inherits":{"y":"util.inherits(constructor, superConstructor)","s":" Inherit the prototype methods from one\nconstructor<\/a>\ninto another. The prototype of constructor<\/code> will be set to a new\nobject created from superConstructor<\/code>.\n\n<\/p>\n As an additional convenience, superConstructor<\/code> will be accessible\nthrough the constructor.super_<\/code> property.\n\n<\/p>\n var util = require("util");\nvar events = require("events");\n\nfunction MyStream() {\n events.EventEmitter.call(this);\n}\n\nutil.inherits(MyStream, events.EventEmitter);\n\nMyStream.prototype.write = function(data) {\n this.emit("data", data);\n}\n\nvar stream = new MyStream();\n\nconsole.log(stream instanceof events.EventEmitter); \/\/ true\nconsole.log(MyStream.super_ === events.EventEmitter); \/\/ true\n\nstream.on("data", function(data) {\n console.log('Received data: "' + data + '"');\n})\nstream.write("It works!"); \/\/ Received data: "It works!"<\/code><\/pre>\n","p":[{"o":false,"t":"constructor","d":"","type":""},{"o":false,"t":"superConstructor","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /WebPlatformDocsJS.less: -------------------------------------------------------------------------------- 1 | /* Colors */ 2 | @body-text-color: #666; 3 | @emphasized-text-color: #454545; 4 | @heading-color: #454545; 5 | @link-color: #0083e8; 6 | @paramtype-color: #6faded; 7 | @optional-color: #56c66c; 8 | 9 | 10 | /* Typography */ 11 | @font-weight-semibold: 500; 12 | 13 | 14 | /* Overall inline widget content container */ 15 | .js-prop-defn { 16 | margin-left: 20px; 17 | 18 | color: @body-text-color; 19 | 20 | /* Enable text selection */ 21 | cursor: auto; 22 | -webkit-user-select: text; 23 | -khtml-user-select: text; 24 | -moz-user-select: text; 25 | -ms-user-select: text; 26 | -o-user-select: text; 27 | user-select: text; 28 | 29 | &:focus { 30 | outline: none; 31 | } 32 | 33 | font-family: SourceSansPro; 34 | font-size: 14px; 35 | 36 | h1 { 37 | color: @heading-color; 38 | font-size: 16px; 39 | font-weight: @font-weight-semibold; 40 | line-height: normal; 41 | margin: 15px 0 9px 0; 42 | } 43 | 44 | a { 45 | color: @link-color; 46 | } 47 | 48 | code { 49 | font-family: SourceCodePro; 50 | font-size: 12px; 51 | color: @emphasized-text-color; 52 | background: none; // revert Bootstrap's styling 53 | padding: 0; 54 | white-space: normal; 55 | } 56 | 57 | b { 58 | font-weight: @font-weight-semibold; 59 | } 60 | 61 | .paramtype { 62 | color: @paramtype-color; 63 | } 64 | } 65 | 66 | /* Left-hand column */ 67 | .js-prop-summary { 68 | box-sizing: border-box; 69 | float: left; 70 | padding-left: 20px; 71 | margin-bottom: 20px; 72 | width: 35%; 73 | word-wrap: break-word; 74 | -webkit-hyphens: auto; 75 | hyphens: auto; 76 | 77 | p { 78 | line-height: 18px; 79 | } 80 | } 81 | 82 | // Used to avoid overlapping CM scrollbar - TODO (#3460): need a cleaner way to do this 83 | @scrollbar-wid: 17px; 84 | 85 | /* Right-hand column */ 86 | .js-prop-values { 87 | box-sizing: border-box; //for exact dimension 88 | float: right; 89 | width: 60%; 90 | 91 | .scroller { 92 | max-height: 300px; 93 | overflow-y: auto; 94 | 95 | margin: 20px (@scrollbar-wid + 4px) 0 0; 96 | 97 | &:focus { 98 | outline: none; 99 | } 100 | } 101 | 102 | dl { 103 | margin-top: 0px; 104 | 105 | dt { 106 | color: @emphasized-text-color; 107 | font-size: 13px; 108 | font-weight: @font-weight-semibold; 109 | margin-bottom: 3px; 110 | } 111 | 112 | dd { 113 | // some styles must specifically be on to override Bootstrap 114 | p, li, b { 115 | font-size: 13px; 116 | font-style: normal; 117 | line-height: 18px; 118 | margin-bottom: 15px; 119 | } 120 | line-height: 18px; 121 | margin-left: 20px; 122 | margin-right: 0px; 123 | margin-bottom: -2px; // remove extra spacing between dt-dd pairs 124 | padding-bottom: 0px; 125 | } 126 | } 127 | .optional { 128 | .bracket { 129 | font-weight: @font-weight-semibold; 130 | } 131 | color: @optional-color; 132 | } 133 | .propsForProps { 134 | text-indent: 40px; 135 | } 136 | 137 | } 138 | 139 | .divider-holder { 140 | // This nesting lets us effectively have 'left: (37% + 12px)' 141 | position: absolute; 142 | left: 37%; 143 | top: 0; 144 | height: 100%; 145 | .divider { 146 | margin-left: 12px; 147 | width: 0px; 148 | height: 100%; 149 | border-left: 1px solid #cccccc; 150 | border-right: 1px solid white; 151 | } 152 | } 153 | 154 | .content-bottom { 155 | // Used to pull bottom edge of .js-prop-defn down below its two floated children. 156 | // Also prevents .more-info (after us in DOM order) from overlapping the float: right content. 157 | clear: both; 158 | } 159 | 160 | 161 | a.bottom-link { 162 | background: #e5e9e9; 163 | background-repeat: no-repeat; 164 | background-size: 15px 15px; 165 | background-position: 8px 4px; 166 | 167 | border: 1px solid #9c9e9e; 168 | border-radius: 3px 3px 0 0; 169 | border-bottom: none; 170 | box-shadow: inset 0 1px 0 white; // white chisel along top edge 171 | 172 | font-size: 12px; 173 | font-weight: @font-weight-semibold; 174 | color: @heading-color; 175 | text-shadow: 0 1px 0 white; 176 | &:hover { 177 | background-color: #edf1f1; 178 | text-decoration: none; 179 | } 180 | } 181 | 182 | /* Link to full docs, at bottom */ 183 | a#more-info { 184 | position: absolute; 185 | bottom: 0px; 186 | right: (33px + @scrollbar-wid); 187 | padding: 4px 10px 4px 10px; 188 | } 189 | 190 | 191 | /* Link to license */ 192 | a#license-js-info { 193 | position: absolute; 194 | bottom: 0px; 195 | left: 85px; 196 | padding: 4px 10px 4px 10px; 197 | } 198 | 199 | 200 | 201 | /* Link to developer.mozilla.org */ 202 | a#js-info { 203 | position: absolute; 204 | bottom: 0px; 205 | left: 10px; 206 | padding: 4px 10px 4px 10px; 207 | } 208 | 209 | 210 | /* Dark UI Theme */ 211 | @dark-bc-bg-highlight: #1671db; 212 | @dark-bc-highlight: rgba(255, 255, 255, 0.06); 213 | @dark-bc-text: #ddd; 214 | @dark-bc-text-link: #6bbeff; 215 | @dark-bc-text-thin-quiet: #bbb; 216 | @dark-bc-highlight-hard: rgba(255, 255, 255, 0.1); 217 | @dark-bc-btn-bg: #3f3f3f; 218 | @dark-bc-btn-border: #202020; 219 | @dark-bc-btn-border-focused: #2893ef; 220 | @dark-bc-btn-border-focused-glow: transparent; 221 | @dark-bc-shadow: rgba(0, 0, 0, 0.24); 222 | @dark-bc-shadow-small: rgba(0, 0, 0, 0.06); 223 | @dark-bc-shadow-medium: rgba(0, 0, 0, 0.12); 224 | @dark-bc-input-bg: #555; 225 | @dark-bc-panel-separator: #343434; 226 | @dark-c-author: #336ecc; 227 | @dark-c-extras: #ddd; 228 | 229 | .dark { 230 | .js-prop-defn { 231 | color: @dark-bc-text-thin-quiet; 232 | 233 | .h1, b { 234 | color: @dark-bc-text; 235 | } 236 | 237 | a { 238 | color: @dark-bc-text-link; 239 | } 240 | 241 | .h1 { 242 | font-size: 20px; 243 | } 244 | 245 | .creationExtras { 246 | padding-right: 13px; 247 | } 248 | 249 | .modifiedExtras { 250 | padding-right: 5px; 251 | } 252 | 253 | .creationExtras,.modifiedExtras { 254 | color: @dark-c-extras; 255 | } 256 | 257 | .creationExtras,.modifiedExtras,.lastmodifiedDate,.lastmodifiedBy, .createDate, .author { 258 | float: left; 259 | } 260 | 261 | .clear { 262 | clear: both; 263 | } 264 | 265 | .lastmodifiedDate,.createDate { 266 | padding-right: 5px; 267 | } 268 | 269 | .author, .lastmodifiedBy { 270 | color: @dark-c-author; 271 | } 272 | 273 | .syntax-code { 274 | font-family: SourceCodePro; 275 | font-size: 12px; 276 | color: @dark-bc-text !important; 277 | background-color: @dark-bc-highlight !important; 278 | padding: 0 !important; 279 | border: none !important; 280 | white-space: normal; 281 | } 282 | 283 | dl dt { 284 | color: @dark-bc-text; 285 | } 286 | 287 | .divider-holder .divider { 288 | border-left: 1px solid @dark-bc-panel-separator; 289 | } 290 | 291 | a.bottom-link{ 292 | background-color: @dark-bc-btn-bg; 293 | border: 1px solid @dark-bc-btn-border; 294 | box-shadow: inset 0 1px 0 @dark-bc-highlight; 295 | color: @dark-bc-text; 296 | text-shadow: 0 1px 0 @dark-bc-highlight; 297 | } 298 | } 299 | } 300 | -------------------------------------------------------------------------------- /docs/nodejs/process.json: -------------------------------------------------------------------------------- 1 | {"abort":{"y":"process.abort()","s":" This causes node to emit an abort. This will cause node to exit and\ngenerate a core file.\n\n<\/p>\n","p":[]},"chdir":{"y":"process.chdir(directory)","s":" Changes the current working directory of the process or throws an exception if that fails.\n\n<\/p>\nconsole.log('Starting directory: ' + process.cwd());\ntry {\n process.chdir('\/tmp');\n console.log('New directory: ' + process.cwd());\n}\ncatch (err) {\n console.log('chdir: ' + err);\n}<\/code><\/pre>\n","p":[{"o":false,"t":"directory","d":"","type":""}]},"cwd":{"y":"process.cwd()","s":"Returns the current working directory of the process.\n\n<\/p>\nconsole.log('Current directory: ' + process.cwd());<\/code><\/pre>\n","p":[]},"exit":{"y":"process.exit([code])","s":"Ends the process with the specified code<\/code>. If omitted, exit uses the\n'success' code 0<\/code>.\n\n<\/p>\n To exit with a 'failure' code:\n\n<\/p>\nprocess.exit(1);<\/code><\/pre>\nThe shell that executed node should see the exit code as 1.\n\n\n<\/p>\n","p":[{"o":true,"t":"code","d":"","type":""}]},"getgid":{"y":"process.getgid()","s":" Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Gets the group identity of the process. (See getgid(2).)\nThis is the numerical group id, not the group name.\n\n<\/p>\nif (process.getgid) {\n console.log('Current gid: ' + process.getgid());\n}<\/code><\/pre>\n","p":[]},"setgid":{"y":"process.setgid(id)","s":"Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Sets the group identity of the process. (See setgid(2).) This accepts either\na numerical ID or a groupname string. If a groupname is specified, this method\nblocks while resolving it to a numerical ID.\n\n<\/p>\nif (process.getgid && process.setgid) {\n console.log('Current gid: ' + process.getgid());\n try {\n process.setgid(501);\n console.log('New gid: ' + process.getgid());\n }\n catch (err) {\n console.log('Failed to set gid: ' + err);\n }\n}<\/code><\/pre>\n","p":[{"o":false,"t":"id","d":"","type":""}]},"getuid":{"y":"process.getuid()","s":"Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Gets the user identity of the process. (See getuid(2).)\nThis is the numerical userid, not the username.\n\n<\/p>\nif (process.getuid) {\n console.log('Current uid: ' + process.getuid());\n}<\/code><\/pre>\n","p":[]},"setuid":{"y":"process.setuid(id)","s":"Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Sets the user identity of the process. (See setuid(2).) This accepts either\na numerical ID or a username string. If a username is specified, this method\nblocks while resolving it to a numerical ID.\n\n<\/p>\nif (process.getuid && process.setuid) {\n console.log('Current uid: ' + process.getuid());\n try {\n process.setuid(501);\n console.log('New uid: ' + process.getuid());\n }\n catch (err) {\n console.log('Failed to set uid: ' + err);\n }\n}<\/code><\/pre>\n","p":[{"o":false,"t":"id","d":"","type":""}]},"getgroups":{"y":"process.getgroups()","s":"Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Returns an array with the supplementary group IDs. POSIX leaves it unspecified\nif the effective group ID is included but node.js ensures it always is.\n\n\n<\/p>\n","p":[]},"setgroups":{"y":"process.setgroups(groups)","s":" Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Sets the supplementary group IDs. This is a privileged operation, meaning you\nneed to be root or have the CAP_SETGID capability.\n\n<\/p>\n The list can contain group IDs, group names or both.\n\n\n<\/p>\n","p":[{"o":false,"t":"groups","d":"","type":""}]},"initgroups":{"y":"process.initgroups(user, extra_group)","s":" Note: this function is only available on POSIX platforms (i.e. not Windows)\n\n<\/p>\n Reads \/etc\/group and initializes the group access list, using all groups of\nwhich the user is a member. This is a privileged operation, meaning you need\nto be root or have the CAP_SETGID capability.\n\n<\/p>\n user<\/code> is a user name or user ID. extra_group<\/code> is a group name or group ID.\n\n<\/p>\n Some care needs to be taken when dropping privileges. Example:\n\n<\/p>\nconsole.log(process.getgroups()); \/\/ [ 0 ]\nprocess.initgroups('bnoordhuis', 1000); \/\/ switch user\nconsole.log(process.getgroups()); \/\/ [ 27, 30, 46, 1000, 0 ]\nprocess.setgid(1000); \/\/ drop root gid\nconsole.log(process.getgroups()); \/\/ [ 27, 30, 46, 1000 ]<\/code><\/pre>\n","p":[{"o":false,"t":"user","d":"","type":""},{"o":false,"t":"extra_group","d":"","type":""}]},"kill":{"y":"process.kill(pid, [signal])","s":"Send a signal to a process. pid<\/code> is the process id and signal<\/code> is the\nstring describing the signal to send. Signal names are strings like\n'SIGINT' or 'SIGHUP'. If omitted, the signal will be 'SIGTERM'.\nSee Signal Events<\/a> and kill(2) for more information.\n\n<\/p>\n Will throw an error if target does not exist, and as a special case, a signal of\n0<\/code> can be used to test for the existence of a process.\n\n<\/p>\n Note that just because the name of this function is process.kill<\/code>, it is\nreally just a signal sender, like the kill<\/code> system call. The signal sent\nmay do something other than kill the target process.\n\n<\/p>\n Example of sending a signal to yourself:\n\n<\/p>\n process.on('SIGHUP', function() {\n console.log('Got SIGHUP signal.');\n});\n\nsetTimeout(function() {\n console.log('Exiting.');\n process.exit(0);\n}, 100);\n\nprocess.kill(process.pid, 'SIGHUP');<\/code><\/pre>\nNote: When SIGUSR1 is received by Node.js it starts the debugger, see\nSignal Events<\/a>.\n\n<\/p>\n","p":[{"o":false,"t":"pid","d":"","type":""},{"o":true,"t":"signal","d":"","type":""}]},"memoryUsage":{"y":"process.memoryUsage()","s":" Returns an object describing the memory usage of the Node process\nmeasured in bytes.\n\n<\/p>\n var util = require('util');\n\nconsole.log(util.inspect(process.memoryUsage()));<\/code><\/pre>\nThis will generate:\n\n<\/p>\n{ rss: 4935680,\n heapTotal: 1826816,\n heapUsed: 650472 }<\/code><\/pre>\nheapTotal<\/code> and heapUsed<\/code> refer to V8's memory usage.\n\n\n<\/p>\n","p":[]},"nextTick":{"y":"process.nextTick(callback)","s":" On the next loop around the event loop call this callback.\nThis is not<\/em> a simple alias to setTimeout(fn, 0)<\/code>, it's much more\nefficient. It typically runs before any other I\/O events fire, but there\nare some exceptions. See process.maxTickDepth<\/code> below.\n\n<\/p>\nprocess.nextTick(function() {\n console.log('nextTick callback');\n});<\/code><\/pre>\nThis is important in developing APIs where you want to give the user the\nchance to assign event handlers after an object has been constructed,\nbut before any I\/O has occurred.\n\n<\/p>\nfunction MyThing(options) {\n this.setupOptions(options);\n\n process.nextTick(function() {\n this.startDoingStuff();\n }.bind(this));\n}\n\nvar thing = new MyThing();\nthing.getReadyForStuff();\n\n\/\/ thing.startDoingStuff() gets called now, not before.<\/code><\/pre>\nIt is very important for APIs to be either 100% synchronous or 100%\nasynchronous. Consider this example:\n\n<\/p>\n\/\/ WARNING! DO NOT USE! BAD UNSAFE HAZARD!\nfunction maybeSync(arg, cb) {\n if (arg) {\n cb();\n return;\n }\n\n fs.stat('file', cb);\n}<\/code><\/pre>\nThis API is hazardous. If you do this:\n\n<\/p>\nmaybeSync(true, function() {\n foo();\n});\nbar();<\/code><\/pre>\nthen it's not clear whether foo()<\/code> or bar()<\/code> will be called first.\n\n<\/p>\n This approach is much better:\n\n<\/p>\nfunction definitelyAsync(arg, cb) {\n if (arg) {\n process.nextTick(cb);\n return;\n }\n\n fs.stat('file', cb);\n}<\/code><\/pre>\n","p":[{"o":false,"t":"callback","d":"","type":""}]},"umask":{"y":"process.umask([mask])","s":"Sets or reads the process's file mode creation mask. Child processes inherit\nthe mask from the parent process. Returns the old mask if mask<\/code> argument is\ngiven, otherwise returns the current mask.\n\n<\/p>\nvar oldmask, newmask = 0644;\n\noldmask = process.umask(newmask);\nconsole.log('Changed umask from: ' + oldmask.toString(8) +\n ' to ' + newmask.toString(8));<\/code><\/pre>\n","p":[{"o":true,"t":"mask","d":"","type":""}]},"uptime":{"y":"process.uptime()","s":"Number of seconds Node has been running.\n\n\n<\/p>\n","p":[]},"hrtime":{"y":"process.hrtime()","s":" Returns the current high-resolution real time in a [seconds, nanoseconds]<\/code>\ntuple Array. It is relative to an arbitrary time in the past. It is not\nrelated to the time of day and therefore not subject to clock drift. The\nprimary use is for measuring performance between intervals.\n\n<\/p>\n You may pass in the result of a previous call to process.hrtime()<\/code> to get\na diff reading, useful for benchmarks and measuring intervals:\n\n<\/p>\nvar time = process.hrtime();\n\/\/ [ 1800216, 25 ]\n\nsetTimeout(function() {\n var diff = process.hrtime(time);\n \/\/ [ 1, 552 ]\n\n console.log('benchmark took %d nanoseconds', diff[0] * 1e9 + diff[1]);\n \/\/ benchmark took 1000000527 nanoseconds\n}, 1000);<\/code><\/pre>\n","p":[]}} 2 | -------------------------------------------------------------------------------- /docs/Statements.json: -------------------------------------------------------------------------------- 1 | {"block":{"s":"A block statement is used to group zero or more statements. The block is delimited by a pair of curly brackets.","y":"{\n statement_1<\/var>\n statement_2<\/var>\n ...\n statement_n<\/var>\n}\n","p":[{"t":"statement_1","d":"Statements grouped within the block statement."}]},"break":{"s":"Terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.","y":"break [label];<\/code>","p":[{"t":"label","d":"Identifier associated with the label of the statement.\u00a0 If the statement is not a loop or switch, this is required."}]},"const":{"s":"Declares a read-only named constant.","y":"const name1 = value1 [<\/em>, name2<\/em> = value2 [<\/em>, name3<\/em> = value3 [<\/em>, ... [<\/em>, nameN<\/em> = valueN]]]]<\/em>;","p":[{"t":"nameN","d":"Constant name. It can be any legal identifier."},{"t":"valueN","d":"Value of the constant. It can be any legal expression."}]},"continue":{"s":"Terminates execution of the statements in the current iteration of the current or labelled loop, and continues execution of the loop with the next iteration.","y":null,"p":[{"t":"label","d":"Identifier associated with the label of the statement."}]},"debugger":{"s":"Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.","y":"debugger;<\/code>","p":null},"do___while":{"s":"Creates a loop that executes a specified statement until the test condition evaluates to false. The condition is evaluated after executing the statement, resulting in the specified statement executing at least once.","y":"do\n statement<\/em>\nwhile (condition<\/em>);\n","p":[{"t":"statement","d":"A statement that is executed at least once and is re-executed each time the condition evaluates to true. To execute multiple statements within the loop, use a block statement ({ ... }) to group those statements."},{"t":"condition","d":"An expression evaluated after each pass through the loop. If condition evaluates to true, the statement is re-executed. When condition evaluates to false, control passes to the statement following the do...while."}]},"export":{"s":"Allows a signed script to provide properties, functions, and objects to other signed or unsigned scripts. This feature is not in ECMA-262, Edition 3.","y":null,"p":[{"t":"nameN","d":"Property, function, or object to be exported."}]},"for":{"s":"Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.","y":"for ([initialization<\/em>]; [condition<\/em>]; [final-expression<\/em>])\n statement<\/em>\n","p":[{"t":"initialization","d":"An expression (including assignment expressions) or variable declaration. Typically used to initialize a counter variable. This expression may optionally declare new variables with the var keyword. These variables are not local to the loop, i.e. they are in the same scope the for loop is in. The result of this expression is discarded."},{"t":"condition","d":"An expression to be evaluated before each loop iteration. If this expression evaluates to true, statement is executed. This conditional test is optional. If omitted, the condition always evaluates to true. If the expression evaluates to false, execution skips to the first expression following the for construct."},{"t":"final-expression","d":"An expression to be evaluated at the end of each loop iteration. This occurs before the next evaluation of condition. Generally used to update or increment the counter variable."},{"t":"statement","d":"A statement that is executed as long as the condition evaluates to true. To execute multiple statements within the loop, use a block statement ({ ... }) to group those statements."}]},"for_each___in":{"s":"","y":null,"p":null},"for___in":{"s":"Iterates over the enumerable properties of an object, in arbitrary order. For each distinct property, statements can be executed.","y":"for (variable<\/var> in object<\/var>) {\n ...<\/i>\n}","p":[{"t":"variable","d":"A different property name is assigned to variable on each iteration."},{"t":"object","d":"Object whose enumerable properties are iterated."}]},"for___of":{"s":"Iterates over iterable objects (including arrays, array-like objects, iterators and generators), invoking a custom iteration hook with statements to be executed for the value of each distinct property.","y":"for (variable<\/em> of object<\/em>)\n statement<\/em>\n","p":[{"t":"variable","d":"On each iteration a value of a different property is assigned to variable."},{"t":"object","d":"Object whose enumerable properties are iterated."}]},"function":{"s":"Declares a function with the specified parameters.","y":"function [name]<\/em>([param<\/em>,[, param<\/em>,[..., param<\/em>]]]) {\n statements<\/em>\n}\n","p":[{"t":"name","d":"The function name."},{"t":"param","d":"The name of an argument to be passed to the function. A function can have up to 255 arguments."},{"t":"statements","d":"The statements which comprise the body of the function."}]},"if___else":{"s":"Executes a statement if a specified condition is true. If the condition is false, another statement can be executed.","y":"if (condition<\/em>)\n statement1<\/em>\n[else\n statement2<\/em>]\n","p":[{"t":"condition","d":"An expression that evaluates to true or false."},{"t":"statement1","d":"Statement that is executed if condition evaluates to true. Can be any statement, including further nested if statements. To execute multiple statements, use a block statement ({ ... }) to group those statements."},{"t":"statement2","d":"Statement that is executed if condition evaluates to false and the else clause exists. Can be any statement, including block statements and further nested if statements."}]},"import":{"s":"Allows a script to import properties, functions, and objects from a signed script that has exported the information. This feature is not in ECMA 262, Edition 3.","y":null,"p":[{"t":"objectName","d":"Name of the object that will receive the imported names."},{"t":"nameN","d":"Property, function, or object to be imported."}]},"label":{"s":"Provides a statement with an identifier that you can refer to using a break or continue statement.","y":"label<\/em> :\n statement<\/em>\n","p":[{"t":"label","d":"Any JavaScript identifier that is not a reserved word."},{"t":"statement","d":"Statements. break can be used with any labeled statement, and continue can be used with looping labeled statements."}]},"let":{"s":"Declares a block scope local variable, optionally initializing it to a value.","y":"let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];","p":null},"return":{"s":"Specifies the value to be returned by a function.","y":null,"p":[{"t":"expression","d":"The expression to return. If omitted, undefined is returned instead."}]},"switch":{"s":"Evaluates an expression, matching the expression's value to a case clause, and executes statements associated with that case.","y":"switch (expression<\/em>) {\n case expression1:\n statements1<\/em>\n [break;]\n case expression2:\n statements2<\/em>\n [break;]\n ...\n case expressionN:\n statementsN<\/em>\n [break;]\n default:\n statements_def<\/em>\n [break;]\n}","p":[{"t":"expression","d":"An expression matched against each case clause."},{"t":"case expressionN","d":"A case clause used to match against expression."},{"t":"statementsN","d":"Statements that are executed if expression matches the associated case clause."},{"t":"statements_def","d":"Statements that are executed if expression does not match any case clause."}]},"throw":{"s":"Throws a user-defined exception.","y":null,"p":[{"t":"expression","d":"The expression to throw."}]},"try___catch":{"s":"Marks a block of statements to try, and specifies a response, should an exception be thrown.","y":"try {\n try_statements<\/em>\n}\n[catch (exception_var_1<\/em> if condition_1<\/em>) {\n catch_statements_1<\/em>\n}]\n...\n[catch (exception_var_2<\/em>) {\n catch_statements_2<\/em>\n}]\n[finally {\n finally_statements<\/em>\n}]\n","p":[{"t":"try_statements","d":"The statements to be executed."},{"t":"catch_statements_1","d":"Statements that are executed if an exception is thrown in the try block."},{"t":"exception_var_1","d":"An identifier to hold an exception object for the associated catch clause."},{"t":"condition_1","d":"A conditional expression."},{"t":"finally_statements","d":"Statements that are executed after the try statement completes. These statements execute regardless of whether or not an exception was thrown or caught."}]},"var":{"s":"Declares a variable, optionally initializing it to a value.","y":"var a = 1;\nb = 2;\n\ndelete this.a; \/\/ Throws a TypeError in strict mode. Fails silently otherwise.\ndelete this.b;\n\nconsole.log(a, b); \/\/ Throws a ReferenceError. Since the 'b' property doesn't exist in the global object,\n\/\/ the 'b' variable stops being a variable\n","p":[{"t":"varnameN","d":"Variable name. It can be any legal identifier."},{"t":"valueN","d":"Initial value of the variable. It can be any legal expression."}]},"while":{"s":"Creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.","y":"while (condition<\/em>) {\n statement<\/em>\n}","p":[{"t":"condition","d":"An expression evaluated before each pass through the loop. If this condition evaluates to true, statement is executed. When condition evaluates to false, execution continues with the statement after the while loop."},{"t":"statement","d":"A statement that is executed as long as the condition evaluates to true. To execute multiple statements within the loop, use a block statement ({ ... }) to group those statements."}]},"with":{"s":"Extends the scope chain for a statement.","y":"with (object<\/em>) {\n statement<\/em>\n}\n","p":[{"t":"object","d":"Adds the given object to the scope chain used when evaluating the statement. The parentheses around object are required."},{"t":"statement","d":"Any statement. To execute multiple statements, use a block statement ({ ... }) to group those statements."}]},"yield":{"s":"See\u00a0New_in_JavaScript 1.7\u00a0&\u00a0Iterators and generators","y":null,"p":null}} -------------------------------------------------------------------------------- /docs/nodejs/crypto.json: -------------------------------------------------------------------------------- 1 | {"getCiphers":{"y":"crypto.getCiphers()","s":"Returns an array with the names of the supported ciphers.\n\n<\/p>\n Example:\n\n<\/p>\n var ciphers = crypto.getCiphers();\nconsole.log(ciphers); \/\/ ['AES-128-CBC', 'AES-128-CBC-HMAC-SHA1', ...]<\/code><\/pre>\n","p":[]},"getHashes":{"y":"crypto.getHashes()","s":"Returns an array with the names of the supported hash algorithms.\n\n<\/p>\n Example:\n\n<\/p>\n var hashes = crypto.getHashes();\nconsole.log(hashes); \/\/ ['sha', 'sha1', 'sha1WithRSAEncryption', ...]<\/code><\/pre>\n","p":[]},"createCredentials":{"y":"crypto.createCredentials(details)","s":"Creates a credentials object, with the optional details being a\ndictionary with keys:\n\n<\/p>\n \npfx<\/code> : A string or buffer holding the PFX or PKCS12 encoded private\nkey, certificate and CA certificates<\/li>\n key<\/code> : A string holding the PEM encoded private key<\/li>\n passphrase<\/code> : A string of passphrase for the private key or pfx<\/li>\n cert<\/code> : A string holding the PEM encoded certificate<\/li>\n ca<\/code> : Either a string or list of strings of PEM encoded CA\ncertificates to trust.<\/li>\n crl<\/code> : Either a string or list of strings of PEM encoded CRLs\n(Certificate Revocation List)<\/li>\n ciphers<\/code>: A string describing the ciphers to use or exclude.\nConsult\nhttp:\/\/www.openssl.org\/docs\/apps\/ciphers.html#CIPHER_LIST_FORMAT<\/a>\nfor details on the format.<\/li>\n<\/ul>\nIf no 'ca' details are given, then node.js will use the default\npublicly trusted list of CAs as given in\n<\/p>\nhttp:\/\/mxr.mozilla.org\/mozilla\/source\/security\/nss\/lib\/ckfw\/builtins\/certdata.txt<\/a>.\n\n\n<\/p>\n","p":[{"o":false,"t":"details","d":"","type":""}]},"createHash":{"y":"crypto.createHash(algorithm)","s":" Creates and returns a hash object, a cryptographic hash with the given\nalgorithm which can be used to generate hash digests.\n\n<\/p>\n algorithm<\/code> is dependent on the available algorithms supported by the\nversion of OpenSSL on the platform. Examples are 'sha1'<\/code>, 'md5'<\/code>,\n'sha256'<\/code>, 'sha512'<\/code>, etc. On recent releases, openssl\nlist-message-digest-algorithms<\/code> will display the available digest\nalgorithms.\n\n<\/p>\n Example: this program that takes the sha1 sum of a file\n\n<\/p>\n var filename = process.argv[2];\nvar crypto = require('crypto');\nvar fs = require('fs');\n\nvar shasum = crypto.createHash('sha1');\n\nvar s = fs.ReadStream(filename);\ns.on('data', function(d) {\n shasum.update(d);\n});\n\ns.on('end', function() {\n var d = shasum.digest('hex');\n console.log(d + ' ' + filename);\n});<\/code><\/pre>\n","p":[{"o":false,"t":"algorithm","d":"","type":""}]},"createHmac":{"y":"crypto.createHmac(algorithm, key)","s":"Creates and returns a hmac object, a cryptographic hmac with the given\nalgorithm and key.\n\n<\/p>\nIt is a stream<\/a> that is both readable and writable. The\nwritten data is used to compute the hmac. Once the writable side of\nthe stream is ended, use the read()<\/code> method to get the computed\ndigest. The legacy update<\/code> and digest<\/code> methods are also supported.\n\n<\/p>\n algorithm<\/code> is dependent on the available algorithms supported by\nOpenSSL - see createHash above. key<\/code> is the hmac key to be used.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""},{"o":false,"t":"key","d":"","type":""}]},"createCipher":{"y":"crypto.createCipher(algorithm, password)","s":" Creates and returns a cipher object, with the given algorithm and\npassword.\n\n<\/p>\n algorithm<\/code> is dependent on OpenSSL, examples are 'aes192'<\/code>, etc. On\nrecent releases, openssl list-cipher-algorithms<\/code> will display the\navailable cipher algorithms. password<\/code> is used to derive key and IV,\nwhich must be a 'binary'<\/code> encoded string or a buffer<\/a>.\n\n<\/p>\n It is a stream<\/a> that is both readable and writable. The\nwritten data is used to compute the hash. Once the writable side of\nthe stream is ended, use the read()<\/code> method to get the enciphered\ncontents. The legacy update<\/code> and final<\/code> methods are also supported.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""},{"o":false,"t":"password","d":"","type":""}]},"createCipheriv":{"y":"crypto.createCipheriv(algorithm, key, iv)","s":" Creates and returns a cipher object, with the given algorithm, key and\niv.\n\n<\/p>\n algorithm<\/code> is the same as the argument to createCipher()<\/code>. key<\/code> is\nthe raw key used by the algorithm. iv<\/code> is an initialization\nvector<\/a>.\n\n<\/p>\n key<\/code> and iv<\/code> must be 'binary'<\/code> encoded strings or\nbuffers<\/a>.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""},{"o":false,"t":"key","d":"","type":""},{"o":false,"t":"iv","d":"","type":""}]},"createDecipher":{"y":"crypto.createDecipher(algorithm, password)","s":" Creates and returns a decipher object, with the given algorithm and\nkey. This is the mirror of the [createCipher()][] above.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""},{"o":false,"t":"password","d":"","type":""}]},"createDecipheriv":{"y":"crypto.createDecipheriv(algorithm, key, iv)","s":" Creates and returns a decipher object, with the given algorithm, key\nand iv. This is the mirror of the [createCipheriv()][] above.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""},{"o":false,"t":"key","d":"","type":""},{"o":false,"t":"iv","d":"","type":""}]},"createSign":{"y":"crypto.createSign(algorithm)","s":" Creates and returns a signing object, with the given algorithm. On\nrecent OpenSSL releases, openssl list-public-key-algorithms<\/code> will\ndisplay the available signing algorithms. Examples are 'RSA-SHA256'<\/code>.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""}]},"createVerify":{"y":"crypto.createVerify(algorithm)","s":" Creates and returns a verification object, with the given algorithm.\nThis is the mirror of the signing object above.\n\n<\/p>\n","p":[{"o":false,"t":"algorithm","d":"","type":""}]},"createDiffieHellman":{"y":"crypto.createDiffieHellman(prime, [encoding])","s":" Creates a Diffie-Hellman key exchange object using the supplied prime.\nThe generator used is 2<\/code>. Encoding can be 'binary'<\/code>, 'hex'<\/code>, or\n'base64'<\/code>. If no encoding is specified, then a buffer is expected.\n\n<\/p>\n","p":[{"o":false,"t":"prime","d":"","type":""},{"o":true,"t":"encoding","d":"","type":""}]},"getDiffieHellman":{"y":"crypto.getDiffieHellman(group_name)","s":" Creates a predefined Diffie-Hellman key exchange object. The\nsupported groups are: 'modp1'<\/code>, 'modp2'<\/code>, 'modp5'<\/code> (defined in [RFC\n2412][]) and 'modp14'<\/code>, 'modp15'<\/code>, 'modp16'<\/code>, 'modp17'<\/code>,\n'modp18'<\/code> (defined in [RFC 3526][]). The returned object mimics the\ninterface of objects created by [crypto.createDiffieHellman()][]\nabove, but will not allow to change the keys (with\n[diffieHellman.setPublicKey()][] for example). The advantage of using\nthis routine is that the parties don't have to generate nor exchange\ngroup modulus beforehand, saving both processor and communication\ntime.\n\n<\/p>\n Example (obtaining a shared secret):\n\n<\/p>\n var crypto = require('crypto');\nvar alice = crypto.getDiffieHellman('modp5');\nvar bob = crypto.getDiffieHellman('modp5');\n\nalice.generateKeys();\nbob.generateKeys();\n\nvar alice_secret = alice.computeSecret(bob.getPublicKey(), null, 'hex');\nvar bob_secret = bob.computeSecret(alice.getPublicKey(), null, 'hex');\n\n\/* alice_secret and bob_secret should be the same *\/\nconsole.log(alice_secret == bob_secret);<\/code><\/pre>\n","p":[{"o":false,"t":"group_name","d":"","type":""}]},"pbkdf2":{"y":"crypto.pbkdf2(password, salt, iterations, keylen, callback)","s":"Asynchronous PBKDF2 applies pseudorandom function HMAC-SHA1 to derive\na key of given length from the given password, salt and iterations.\nThe callback gets two arguments (err, derivedKey)<\/code>.\n\n<\/p>\n","p":[{"o":false,"t":"password","d":"","type":""},{"o":false,"t":"salt","d":"","type":""},{"o":false,"t":"iterations","d":"","type":""},{"o":false,"t":"keylen","d":"","type":""},{"o":false,"t":"callback","d":"","type":""}]},"pbkdf2Sync":{"y":"crypto.pbkdf2Sync(password, salt, iterations, keylen)","s":" Synchronous PBKDF2 function. Returns derivedKey or throws error.\n\n<\/p>\n","p":[{"o":false,"t":"password","d":"","type":""},{"o":false,"t":"salt","d":"","type":""},{"o":false,"t":"iterations","d":"","type":""},{"o":false,"t":"keylen","d":"","type":""}]},"randomBytes":{"y":"crypto.randomBytes(size, [callback])","s":" Generates cryptographically strong pseudo-random data. Usage:\n\n<\/p>\n\/\/ async\ncrypto.randomBytes(256, function(ex, buf) {\n if (ex) throw ex;\n console.log('Have %d bytes of random data: %s', buf.length, buf);\n});\n\n\/\/ sync\ntry {\n var buf = crypto.randomBytes(256);\n console.log('Have %d bytes of random data: %s', buf.length, buf);\n} catch (ex) {\n \/\/ handle error\n \/\/ most likely, entropy sources are drained\n}<\/code><\/pre>\nNOTE: Will throw error or invoke callback with error, if there is not enough\naccumulated entropy to generate cryptographically strong data. In other words,\ncrypto.randomBytes<\/code> without callback will not block even if all entropy sources\nare drained.\n\n<\/p>\n","p":[{"o":false,"t":"size","d":"","type":""},{"o":true,"t":"callback","d":"","type":""}]},"pseudoRandomBytes":{"y":"crypto.pseudoRandomBytes(size, [callback])","s":" Generates non<\/em>-cryptographically strong pseudo-random data. The data\nreturned will be unique if it is sufficiently long, but is not\nnecessarily unpredictable. For this reason, the output of this\nfunction should never be used where unpredictability is important,\nsuch as in the generation of encryption keys.\n\n<\/p>\n Usage is otherwise identical to crypto.randomBytes<\/code>.\n\n<\/p>\n","p":[{"o":false,"t":"size","d":"","type":""},{"o":true,"t":"callback","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/nodejs/child_process.json: -------------------------------------------------------------------------------- 1 | {"spawn":{"y":"child_process.spawn(command, [args], [options])","s":" Launches a new process with the given command<\/code>, with command line arguments in args<\/code>.\nIf omitted, args<\/code> defaults to an empty Array.\n\n<\/p>\n The third argument is used to specify additional options, which defaults to:\n\n<\/p>\n{ cwd: undefined,\n env: process.env\n}<\/code><\/pre>\ncwd<\/code> allows you to specify the working directory from which the process is spawned.\nUse env<\/code> to specify environment variables that will be visible to the new process.\n\n<\/p>\n Example of running ls -lh \/usr<\/code>, capturing stdout<\/code>, stderr<\/code>, and the exit code:\n\n<\/p>\nvar spawn = require('child_process').spawn,\n ls = spawn('ls', ['-lh', '\/usr']);\n\nls.stdout.on('data', function (data) {\n console.log('stdout: ' + data);\n});\n\nls.stderr.on('data', function (data) {\n console.log('stderr: ' + data);\n});\n\nls.on('close', function (code) {\n console.log('child process exited with code ' + code);\n});<\/code><\/pre>\nExample: A very elaborate way to run 'ps ax | grep ssh'\n\n<\/p>\nvar spawn = require('child_process').spawn,\n ps = spawn('ps', ['ax']),\n grep = spawn('grep', ['ssh']);\n\nps.stdout.on('data', function (data) {\n grep.stdin.write(data);\n});\n\nps.stderr.on('data', function (data) {\n console.log('ps stderr: ' + data);\n});\n\nps.on('close', function (code) {\n if (code !== 0) {\n console.log('ps process exited with code ' + code);\n }\n grep.stdin.end();\n});\n\ngrep.stdout.on('data', function (data) {\n console.log('' + data);\n});\n\ngrep.stderr.on('data', function (data) {\n console.log('grep stderr: ' + data);\n});\n\ngrep.on('close', function (code) {\n if (code !== 0) {\n console.log('grep process exited with code ' + code);\n }\n});<\/code><\/pre>\nExample of checking for failed exec:\n\n<\/p>\nvar spawn = require('child_process').spawn,\n child = spawn('bad_command');\n\nchild.stderr.setEncoding('utf8');\nchild.stderr.on('data', function (data) {\n if (\/^execvp\$\$\/.test(data)) {\n console.log('Failed to start child process.');\n }\n});<\/code><\/pre>\nNote that if spawn receives an empty options object, it will result in\nspawning the process with an empty environment rather than using\nprocess.env<\/code>. This due to backwards compatibility issues with a deprecated\nAPI.\n\n<\/p>\n The 'stdio' option to child_process.spawn()<\/code> is an array where each\nindex corresponds to a fd in the child. The value is one of the following:\n\n<\/p>\n\n'pipe'<\/code> - Create a pipe between the child process and the parent process.\nThe parent end of the pipe is exposed to the parent as a property on the\nchild_process<\/code> object as ChildProcess.stdio[fd]<\/code>. Pipes created for\nfds 0 - 2 are also available as ChildProcess.stdin, ChildProcess.stdout\nand ChildProcess.stderr, respectively.<\/li>\n 'ipc'<\/code> - Create an IPC channel for passing messages\/file descriptors\nbetween parent and child. A ChildProcess may have at most one<\/em> IPC stdio\nfile descriptor. Setting this option enables the ChildProcess.send() method.\nIf the child writes JSON messages to this file descriptor, then this will\ntrigger ChildProcess.on('message'). If the child is a Node.js program, then\nthe presence of an IPC channel will enable process.send() and\nprocess.on('message').<\/li>\n 'ignore'<\/code> - Do not set this file descriptor in the child. Note that Node\nwill always open fd 0 - 2 for the processes it spawns. When any of these is\nignored node will open \/dev\/null<\/code> and attach it to the child's fd.<\/li>\n Stream<\/code> object - Share a readable or writable stream that refers to a tty,\nfile, socket, or a pipe with the child process. The stream's underlying\nfile descriptor is duplicated in the child process to the fd that \ncorresponds to the index in the stdio<\/code> array. Note that the stream must\nhave an underlying descriptor (file streams do not until the 'open'<\/code>\nevent has occurred).<\/li>\n Positive integer - The integer value is interpreted as a file descriptor \nthat is is currently open in the parent process. It is shared with the child\nprocess, similar to how Stream<\/code> objects can be shared.<\/li>\nnull<\/code>, undefined<\/code> - Use default value. For stdio fds 0, 1 and 2 (in other\nwords, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the\ndefault is 'ignore'<\/code>.<\/li>\n<\/ol>\nAs a shorthand, the stdio<\/code> argument may also be one of the following\nstrings, rather than an array:\n\n<\/p>\n\nignore<\/code> - ['ignore', 'ignore', 'ignore']<\/code><\/li>\n pipe<\/code> - ['pipe', 'pipe', 'pipe']<\/code><\/li>\ninherit<\/code> - [process.stdin, process.stdout, process.stderr]<\/code> or [0,1,2]<\/code><\/li>\n<\/ul>\nExample:\n\n<\/p>\nvar spawn = require('child_process').spawn;\n\n\/\/ Child will use parent's stdios\nspawn('prg', [], { stdio: 'inherit' });\n\n\/\/ Spawn child sharing only stderr\nspawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });\n\n\/\/ Open an extra fd=4, to interact with programs present a\n\/\/ startd-style interface.\nspawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });<\/code><\/pre>\nIf the detached<\/code> option is set, the child process will be made the leader of a\nnew process group. This makes it possible for the child to continue running \nafter the parent exits.\n\n<\/p>\n By default, the parent will wait for the detached child to exit. To prevent\nthe parent from waiting for a given child<\/code>, use the child.unref()<\/code> method,\nand the parent's event loop will not include the child in its reference count.\n\n<\/p>\n Example of detaching a long-running process and redirecting its output to a\nfile:\n\n<\/p>\n var fs = require('fs'),\n spawn = require('child_process').spawn,\n out = fs.openSync('.\/out.log', 'a'),\n err = fs.openSync('.\/out.log', 'a');\n\n var child = spawn('prg', [], {\n detached: true,\n stdio: [ 'ignore', out, err ]\n });\n\n child.unref();<\/code><\/pre>\nWhen using the detached<\/code> option to start a long-running process, the process\nwill not stay running in the background unless it is provided with a stdio<\/code>\nconfiguration that is not connected to the parent. If the parent's stdio<\/code> is\ninherited, the child will remain attached to the controlling terminal.\n\n<\/p>\n There is a deprecated option called customFds<\/code> which allows one to specify\nspecific file descriptors for the stdio of the child process. This API was\nnot portable to all platforms and therefore removed.\nWith customFds<\/code> it was possible to hook up the new process' [stdin, stdout,\nstderr]<\/code> to existing streams; -1<\/code> meant that a new stream should be created.\nUse at your own risk.\n\n<\/p>\n See also: child_process.exec()<\/code> and child_process.fork()<\/code>\n\n<\/p>\n","p":[{"o":false,"t":"command","d":"The command to run","type":"String"},{"o":true,"t":"args","d":"List of string arguments","type":"Array"},{"o":true,"t":"options","d":"","type":"Object"}]},"exec":{"y":"child_process.exec(command, [options], callback)","s":" Runs a command in a shell and buffers the output.\n\n<\/p>\nvar exec = require('child_process').exec,\n child;\n\nchild = exec('cat *.js bad_file | wc -l',\n function (error, stdout, stderr) {\n console.log('stdout: ' + stdout);\n console.log('stderr: ' + stderr);\n if (error !== null) {\n console.log('exec error: ' + error);\n }\n});<\/code><\/pre>\nThe callback gets the arguments (error, stdout, stderr)<\/code>. On success, error<\/code>\nwill be null<\/code>. On error, error<\/code> will be an instance of Error<\/code> and error.code<\/code>\nwill be the exit code of the child process, and error.signal<\/code> will be set to the\nsignal that terminated the process.\n\n<\/p>\n There is a second optional argument to specify several options. The\ndefault options are\n\n<\/p>\n{ encoding: 'utf8',\n timeout: 0,\n maxBuffer: 200*1024,\n killSignal: 'SIGTERM',\n cwd: null,\n env: null }<\/code><\/pre>\nIf timeout<\/code> is greater than 0, then it will kill the child process\nif it runs longer than timeout<\/code> milliseconds. The child process is killed with\nkillSignal<\/code> (default: 'SIGTERM'<\/code>). maxBuffer<\/code> specifies the largest\namount of data allowed on stdout or stderr - if this value is exceeded then\nthe child process is killed.\n\n\n<\/p>\n","p":[{"o":false,"t":"command","d":"The command to run, with space-separated arguments","type":"String"},{"o":true,"t":"options","d":"","type":"Object"},{"o":false,"t":"callback","d":"called with the output when process terminates","type":"Function"}]},"execFile":{"y":"child_process.execFile(file, [args], [options], [callback])","s":" This is similar to child_process.exec()<\/code> except it does not execute a\nsubshell but rather the specified file directly. This makes it slightly\nleaner than child_process.exec<\/code>. It has the same options.\n\n\n<\/p>\n","p":[{"o":false,"t":"file","d":"The filename of the program to run","type":"String"},{"o":true,"t":"args","d":"List of string arguments","type":"Array"},{"o":true,"t":"options","d":"","type":"Object"},{"o":true,"t":"callback","d":"called with the output when process terminates","type":"Function"}]},"fork":{"y":"child_process.fork(modulePath, [args], [options])","s":" This is a special case of the spawn()<\/code> functionality for spawning Node\nprocesses. In addition to having all the methods in a normal ChildProcess\ninstance, the returned object has a communication channel built-in. See\nchild.send(message, [sendHandle])<\/code> for details.\n\n<\/p>\n These child Nodes are still whole new instances of V8. Assume at least 30ms\nstartup and 10mb memory for each new Node. That is, you cannot create many\nthousands of them.\n\n<\/p>\n The execPath<\/code> property in the options<\/code> object allows for a process to be\ncreated for the child rather than the current node<\/code> executable. This should be\ndone with care and by default will talk over the fd represented an\nenvironmental variable NODE_CHANNEL_FD<\/code> on the child process. The input and\noutput on this fd is expected to be line delimited JSON objects.\n\n<\/p>\n","p":[{"o":false,"t":"modulePath","d":"The module to run in the child","type":"String"},{"o":true,"t":"args","d":"List of string arguments","type":"Array"},{"o":true,"t":"options","d":"","type":"Object"}]}} 2 | -------------------------------------------------------------------------------- /docs/Array.json: -------------------------------------------------------------------------------- 1 | {"length":{"s":"The length property represents an unsigned, 32-bit integer that specifies the number of elements in an array.","y":"arr<\/var>.length<\/code>","p":[]},"pop":{"s":"The pop() method removes the last element from an array and returns that element.","y":"arr<\/var>.pop()<\/code>","p":[]},"push":{"s":"The push() method adds one or more elements to the end of an array and returns the new length of the array.","y":"arr<\/var>.push(element1<\/var>, ..., elementN<\/var>)<\/code>","p":[{"t":"elementN","d":"The elements to add to the end of the array."}]},"reverse":{"s":"The reverse() method reverses an array in place. The first array element becomes the last and the last becomes the first.","y":"arr<\/var>.reverse()<\/code>","p":[]},"shift":{"s":"The shift() method removes the first element from an array and returns that element. This method changes the length of the array.","y":"arr<\/var>.shift()<\/code>","p":[]},"sort":{"s":"The sort() method sorts the elements of an array in place and returns the array. The sort is not necessarily stable. The default sort order is according to string Unicode code points.","y":"arr<\/var>.sort([compareFunction<\/var>])<\/code>","p":[{"t":"compareFunction","d":"Optional. Specifies a function that defines the sort order. If omitted, the array is sorted according to each character's Unicode<\/a> code point value, according to the string conversion of each element."}]},"splice":{"s":"The splice() method changes the content of an array by removing existing elements and\/or adding new elements.","y":"array<\/var>.splice(start<\/var>, deleteCount<\/var>[, item1<\/var>[, item2[, ...<\/span>]]])<\/span>\n<\/code>","p":[{"t":"start","d":"Index at which to start changing the array. If greater than the length of the array, actual starting index will be set to the length of the array. If negative, will begin that many elements from the end."},{"t":"deleteCount","d":"An integer indicating the number of old array elements to remove. If deleteCount<\/code> is 0, no elements are removed. In this case, you should specify at least one new element. If deleteCount<\/code> is greater than the number of elements left in the array starting at index<\/code>, then all of the elements through the end of the array will be deleted."},{"t":"itemN","d":"The element to add to the array. If you don't specify any elements, splice<\/code> will only remove elements from the array."}]},"unshift":{"s":"The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.","y":"arr<\/var>.unshift([element1<\/var>[, ...[, elementN<\/var>]]])<\/code>","p":[{"t":"elementN","d":"The elements to add to the front of the array."}]},"concat":{"s":"The concat() method returns a new array comprised of the array on which it is called joined with the array(s) and\/or value(s) provided as arguments.","y":"var new_array<\/var> = old_array<\/var>.concat(value1<\/var>[, value2<\/var>[, ...[, valueN<\/var>]]])<\/code>","p":[{"t":"valueN","d":"Arrays and\/or values to concatenate into a new array. See the discussion below for details."}]},"join":{"s":"The join() method joins all elements of an array into a string.","y":"str<\/var> = arr<\/var>.join([separator<\/var> = ','])<\/code>","p":[{"t":"separator","d":"Optional. Specifies a string to separate each element of the array. The separator is converted to a string if necessary. If omitted, the array elements are separated with a comma."}]},"slice":{"s":"The slice() method returns a shallow copy of a portion of an array into a new array object.","y":"arr<\/var>.slice([begin<\/var>[, end<\/var>]])<\/code>","p":[]},"toSource":{"s":"The toSource() method returns a string representing the source code of the array.","y":"arr<\/var>.toSource()<\/code>","p":[]},"toString":{"s":"The toString() method returns a string representing the specified array and its elements.","y":"arr<\/var>.toString()<\/code>","p":[]},"toLocaleString":{"s":"The toLocaleString() method returns a string representing the elements of the array. The elements are converted to Strings using their toLocaleString methods and these Strings are separated by a locale-specific String (such as a comma \u201c,\u201d).","y":"arr<\/var>.toLocaleString();<\/code>","p":[]},"indexOf":{"s":"The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.","y":"arr<\/var>.indexOf(searchElement<\/var>[, fromIndex<\/var> = 0])<\/code>","p":[{"t":"searchElement","d":"Element to locate in the array."},{"t":"fromIndex","d":"The index to start the search at. If the index is greater than or equal to the array's length, -1 is returned, which means the array will not be searched. If the provided index value is a negative number, it is taken as the offset from the end of the array. Note: if the provided index is negative, the array is still searched from front to back. If the calculated index is less than 0, then the whole array will be searched. Default: 0 (Entire array is searched)."}]},"lastIndexOf":{"s":"The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.","y":"arr<\/var>.lastIndexOf(searchElement<\/var>[, fromIndex<\/var> = arr.length])<\/code>","p":[]},"forEach":{"s":"The forEach() method executes a provided function once per array element.","y":"arr<\/var>.forEach(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function that produces an element of the new Array, taking three arguments:\n \n ","pa":[{"t":"currentValue","d":"The current element being processed in the array."},{"t":"index","d":"The index of the current element being processed in the array."},{"t":"array","d":"The array forEach<\/code> was called upon."}]},{"t":"thisArg","d":"Optional. Value to use as this<\/code> when executing callback<\/code>."}]},"entries":{"s":"The entries() method returns a new Array Iterator object that contains the key\/value pairs for each index in the array.","y":"arr<\/var>.entries()<\/code>","p":[]},"every":{"s":"The every() method tests whether all elements in the array pass the test implemented by the provided function.","y":"arr<\/var>.every(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function to test for each element, taking three arguments:\n \n every<\/code> was called upon."}]},{"t":"thisArg","d":"Optional. Value to use as this<\/code> when executing callback<\/code>."}]},"some":{"s":"The some() method tests whether some element in the array passes the test implemented by the provided function.","y":"arr<\/var>.some(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function to test for each element."},{"t":"thisArg","d":"Optional. Value to use as this<\/code> when executing callback<\/code>."}]},"filter":{"s":"The filter() method creates a new array with all elements that pass the test implemented by the provided function.","y":"arr<\/var>.filter(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function to test each element of the array. Return true<\/code> to keep the element, false<\/code> otherwise."},{"t":"thisArg","d":"Optional. Value to use as this<\/code> when executing callback<\/code>."}]},"find":{"s":"The find() method returns a value in the array, if an element in the array satisfies the provided testing function. Otherwise undefined is returned.","y":"arr<\/var>.find(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function to execute on each value in the array, taking three arguments:\n \n ","pa":[{"t":"element","d":"The current element being processed in the array."},{"t":"index","d":"The index of the current element being processed in the array."},{"t":"array","d":"The array find<\/code> was called upon."}]},{"t":"thisArg","d":"Optional. Object to use as this<\/code> when executing callback<\/code>."}]},"findIndex":{"s":"The findIndex() method returns an index in the array, if an element in the array satisfies the provided testing function. Otherwise -1 is returned.","y":"arr<\/var>.findIndex(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function to execute on each value in the array, taking three arguments:\n \n findIndex<\/code> was called upon."}]},{"t":"thisArg","d":"Optional. Object to use as this<\/code> when executing callback<\/code>."}]},"keys":{"s":"The keys() method returns a new Array Iterator that contains the keys for each index in the array.","y":"arr<\/var>.keys()<\/code>","p":[]},"map":{"s":"The map() method creates a new array with the results of calling a provided function on every element in this array.","y":"arr<\/var>.map(callback<\/var>[, thisArg<\/var>])<\/code>","p":[{"t":"callback","d":"Function that produces an element of the new Array, taking three arguments:\n \n ","pa":[{"t":"currentValue","d":"The current element being processed in the array."},{"t":"index","d":"The index of the current element being processed in the array."},{"t":"array","d":"The array map<\/code> was called upon."}]},{"t":"thisArg","d":"Optional. Value to use as this<\/code> when executing callback<\/code>."}]},"reduce":{"s":"The reduce() method applies a function against an accumulator and each value of the array (from left-to-right) has to reduce it to a single value.","y":"arr<\/var>.reduce(callback<\/var>[, initialValue<\/var>])<\/code>","p":[{"t":"callback","d":"Function to execute on each value in the array, taking four arguments:\n \n ","pa":[{"t":"previousValue","d":"The value previously returned in the last invocation of the callback, or initialValue<\/code>, if supplied. (See below.)"},{"t":"currentValue","d":"The current element being processed in the array."},{"t":"index","d":"The index of the current element being processed in the array."},{"t":"array","d":"The array reduce<\/code> was called upon."}]},{"t":"initialValue","d":"Optional. Object to use as the first argument to the first call of the callback<\/code>."}]},"reduceRight":{"s":"The reduceRight() method applies a function against an accumulator and each value of the array (from right-to-left) has to reduce it to a single value.","y":"arr<\/var>.reduceRight(callback<\/var>[, initialValue<\/var>])<\/code>","p":[{"t":"callback","d":"Function to execute on each value in the array, taking four arguments:\n \n ","pa":[{"t":"previousValue","d":"The value previously returned in the last invocation of the callback, or initialValue<\/code>, if supplied. (See below.)"},{"t":"currentValue","d":"The current element being processed in the array."},{"t":"index","d":"The index of the current element being processed in the array."},{"t":"array","d":"The array reduce<\/code> was called upon."}]},{"t":"initialValue","d":"Optional. Object to use as the first argument to the first call of the callback<\/code>."}]}} -------------------------------------------------------------------------------- /docs/nodejs/tls.json: -------------------------------------------------------------------------------- 1 | {"getCiphers":{"y":"tls.getCiphers()","s":"Returns an array with the names of the supported SSL ciphers.\n\n<\/p>\n Example:\n\n<\/p>\nvar ciphers = tls.getCiphers();\nconsole.log(ciphers); \/\/ ['AES128-SHA', 'AES256-SHA', ...]<\/code><\/pre>\n","p":[]},"createServer":{"y":"tls.createServer(options, [secureConnectionListener])","s":"Creates a new [tls.Server][]. The connectionListener<\/code> argument is\nautomatically set as a listener for the [secureConnection][] event. The\noptions<\/code> object has these possibilities:\n\n<\/p>\n\npfx<\/code>: A string or Buffer<\/code> containing the private key, certificate and\nCA certs of the server in PFX or PKCS12 format. (Mutually exclusive with\nthe key<\/code>, cert<\/code> and ca<\/code> options.)<\/p>\n<\/li>\n key<\/code>: A string or Buffer<\/code> containing the private key of the server in\nPEM format. (Required)<\/p>\n<\/li>\n passphrase<\/code>: A string of passphrase for the private key or pfx.<\/p>\n<\/li>\n cert<\/code>: A string or Buffer<\/code> containing the certificate key of the server in\nPEM format. (Required)<\/p>\n<\/li>\n ca<\/code>: An array of strings or Buffer<\/code>s of trusted certificates in PEM\nformat. If this is omitted several well known "root" CAs will be used,\nlike VeriSign. These are used to authorize connections.<\/p>\n<\/li>\n crl<\/code> : Either a string or list of strings of PEM encoded CRLs (Certificate\nRevocation List)<\/p>\n<\/li>\nciphers<\/code>: A string describing the ciphers to use or exclude.<\/p>\n To mitigate [BEAST attacks] it is recommended that you use this option in\nconjunction with the honorCipherOrder<\/code> option described below to\nprioritize the non-CBC cipher.<\/p>\n Defaults to AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH<\/code>.\nConsult the [OpenSSL cipher list format documentation] for details on the\nformat. ECDH (Elliptic Curve Diffie-Hellman) ciphers are not yet supported.<\/p>\n<\/li>\n<\/ul>\n`AES128-GCM-SHA256` is used when node.js is linked against OpenSSL 1.0.1\nor newer and the client speaks TLS 1.2, RC4 is used as a secure fallback.\n\n**NOTE**: Previous revisions of this section suggested `AES256-SHA` as an\nacceptable cipher. Unfortunately, `AES256-SHA` is a CBC cipher and therefore\nsusceptible to BEAST attacks. Do *not* use it.<\/code><\/pre>\n\nhandshakeTimeout<\/code>: Abort the connection if the SSL\/TLS handshake does not\nfinish in this many milliseconds. The default is 120 seconds.<\/p>\n A 'clientError'<\/code> is emitted on the tls.Server<\/code> object whenever a handshake\ntimes out.<\/p>\n<\/li>\n honorCipherOrder<\/code> : When choosing a cipher, use the server's preferences\ninstead of the client preferences.<\/p>\n Note that if SSLv2 is used, the server will send its list of preferences\nto the client, and the client chooses the cipher.<\/p>\n Although, this option is disabled by default, it is recommended<\/em> that you\nuse this option in conjunction with the ciphers<\/code> option to mitigate\nBEAST attacks.<\/p>\n<\/li>\n requestCert<\/code>: If true<\/code> the server will request a certificate from\nclients that connect and attempt to verify that certificate. Default:\nfalse<\/code>.<\/p>\n<\/li>\n rejectUnauthorized<\/code>: If true<\/code> the server will reject any connection\nwhich is not authorized with the list of supplied CAs. This option only\nhas an effect if requestCert<\/code> is true<\/code>. Default: false<\/code>.<\/p>\n<\/li>\n NPNProtocols<\/code>: An array or Buffer<\/code> of possible NPN protocols. (Protocols\nshould be ordered by their priority).<\/p>\n<\/li>\n SNICallback<\/code>: A function that will be called if client supports SNI TLS\nextension. Only one argument will be passed to it: servername<\/code>. And\nSNICallback<\/code> should return SecureContext instance.\n(You can use crypto.createCredentials(...).context<\/code> to get proper\nSecureContext). If SNICallback<\/code> wasn't provided - default callback with\nhigh-level API will be used (see below).<\/p>\n<\/li>\n sessionIdContext<\/code>: A string containing a opaque identifier for session\nresumption. If requestCert<\/code> is true<\/code>, the default is MD5 hash value\ngenerated from command-line. Otherwise, the default is not provided.<\/p>\n<\/li>\nsecureProtocol<\/code>: The SSL method to use, e.g. SSLv3_method<\/code> to force\nSSL version 3. The possible values depend on your installation of\nOpenSSL and are defined in the constant [SSL_METHODS][].<\/p>\n<\/li>\n<\/ul>\n Here is a simple example echo server:\n\n<\/p>\nvar tls = require('tls');\nvar fs = require('fs');\n\nvar options = {\n key: fs.readFileSync('server-key.pem'),\n cert: fs.readFileSync('server-cert.pem'),\n\n \/\/ This is necessary only if using the client certificate authentication.\n requestCert: true,\n\n \/\/ This is necessary only if the client uses the self-signed certificate.\n ca: [ fs.readFileSync('client-cert.pem') ]\n};\n\nvar server = tls.createServer(options, function(cleartextStream) {\n console.log('server connected',\n cleartextStream.authorized ? 'authorized' : 'unauthorized');\n cleartextStream.write("welcome!\\n");\n cleartextStream.setEncoding('utf8');\n cleartextStream.pipe(cleartextStream);\n});\nserver.listen(8000, function() {\n console.log('server bound');\n});<\/code><\/pre>\nOr\n\n<\/p>\nvar tls = require('tls');\nvar fs = require('fs');\n\nvar options = {\n pfx: fs.readFileSync('server.pfx'),\n\n \/\/ This is necessary only if using the client certificate authentication.\n requestCert: true,\n\n};\n\nvar server = tls.createServer(options, function(cleartextStream) {\n console.log('server connected',\n cleartextStream.authorized ? 'authorized' : 'unauthorized');\n cleartextStream.write("welcome!\\n");\n cleartextStream.setEncoding('utf8');\n cleartextStream.pipe(cleartextStream);\n});\nserver.listen(8000, function() {\n console.log('server bound');\n});<\/code><\/pre>\nYou can test this server by connecting to it with openssl s_client<\/code>:\n\n\n<\/p>\nopenssl s_client -connect 127.0.0.1:8000<\/code><\/pre>\n","p":[{"o":false,"t":"options","d":"","type":""},{"o":true,"t":"secureConnectionListener","d":"","type":""}]},"connect":{"y":"tls.connect(port, [host], [options], [callback])","s":"Creates a new client connection to the given port<\/code> and host<\/code> (old API) or\noptions.port<\/code> and options.host<\/code>. (If host<\/code> is omitted, it defaults to\nlocalhost<\/code>.) options<\/code> should be an object which specifies:\n\n<\/p>\n\nhost<\/code>: Host the client should connect to<\/p>\n<\/li>\n port<\/code>: Port the client should connect to<\/p>\n<\/li>\n socket<\/code>: Establish secure connection on a given socket rather than\ncreating a new socket. If this option is specified, host<\/code> and port<\/code>\nare ignored.<\/p>\n<\/li>\n pfx<\/code>: A string or Buffer<\/code> containing the private key, certificate and\nCA certs of the client in PFX or PKCS12 format.<\/p>\n<\/li>\n key<\/code>: A string or Buffer<\/code> containing the private key of the client in\nPEM format.<\/p>\n<\/li>\n passphrase<\/code>: A string of passphrase for the private key or pfx.<\/p>\n<\/li>\n cert<\/code>: A string or Buffer<\/code> containing the certificate key of the client in\nPEM format.<\/p>\n<\/li>\n ca<\/code>: An array of strings or Buffer<\/code>s of trusted certificates in PEM\nformat. If this is omitted several well known "root" CAs will be used,\nlike VeriSign. These are used to authorize connections.<\/p>\n<\/li>\n rejectUnauthorized<\/code>: If true<\/code>, the server certificate is verified against\nthe list of supplied CAs. An 'error'<\/code> event is emitted if verification\nfails. Default: true<\/code>.<\/p>\n<\/li>\n NPNProtocols<\/code>: An array of strings or Buffer<\/code>s containing supported NPN\nprotocols. Buffer<\/code>s should have following format: 0x05hello0x05world<\/code>,\nwhere first byte is next protocol name's length. (Passing array should\nusually be much simpler: ['hello', 'world']<\/code>.)<\/p>\n<\/li>\n servername<\/code>: Servername for SNI (Server Name Indication) TLS extension.<\/p>\n<\/li>\nsecureProtocol<\/code>: The SSL method to use, e.g. SSLv3_method<\/code> to force\nSSL version 3. The possible values depend on your installation of\nOpenSSL and are defined in the constant [SSL_METHODS][].<\/p>\n<\/li>\n<\/ul>\n The callback<\/code> parameter will be added as a listener for the\n['secureConnect'][] event.\n\n<\/p>\n tls.connect()<\/code> returns a [CleartextStream][] object.\n\n<\/p>\n Here is an example of a client of echo server as described previously:\n\n<\/p>\nvar tls = require('tls');\nvar fs = require('fs');\n\nvar options = {\n \/\/ These are necessary only if using the client certificate authentication\n key: fs.readFileSync('client-key.pem'),\n cert: fs.readFileSync('client-cert.pem'),\n\n \/\/ This is necessary only if the server uses the self-signed certificate\n ca: [ fs.readFileSync('server-cert.pem') ]\n};\n\nvar cleartextStream = tls.connect(8000, options, function() {\n console.log('client connected',\n cleartextStream.authorized ? 'authorized' : 'unauthorized');\n process.stdin.pipe(cleartextStream);\n process.stdin.resume();\n});\ncleartextStream.setEncoding('utf8');\ncleartextStream.on('data', function(data) {\n console.log(data);\n});\ncleartextStream.on('end', function() {\n server.close();\n});<\/code><\/pre>\nOr\n\n<\/p>\nvar tls = require('tls');\nvar fs = require('fs');\n\nvar options = {\n pfx: fs.readFileSync('client.pfx')\n};\n\nvar cleartextStream = tls.connect(8000, options, function() {\n console.log('client connected',\n cleartextStream.authorized ? 'authorized' : 'unauthorized');\n process.stdin.pipe(cleartextStream);\n process.stdin.resume();\n});\ncleartextStream.setEncoding('utf8');\ncleartextStream.on('data', function(data) {\n console.log(data);\n});\ncleartextStream.on('end', function() {\n server.close();\n});<\/code><\/pre>\n","p":[{"o":false,"t":"port","d":"","type":""},{"o":true,"t":"host","d":"","type":""},{"o":true,"t":"options","d":"","type":""},{"o":true,"t":"callback","d":"","type":""}]},"createSecurePair":{"y":"tls.createSecurePair([credentials], [isServer], [requestCert], [rejectUnauthorized])","s":"Creates a new secure pair object with two streams, one of which reads\/writes\nencrypted data, and one reads\/writes cleartext data.\nGenerally the encrypted one is piped to\/from an incoming encrypted data stream,\nand the cleartext one is used as a replacement for the initial encrypted stream.\n\n<\/p>\n\ncredentials<\/code>: A credentials object from crypto.createCredentials( ... )<\/p>\n<\/li>\n isServer<\/code>: A boolean indicating whether this tls connection should be\nopened as a server or a client.<\/p>\n<\/li>\n requestCert<\/code>: A boolean indicating whether a server should request a\ncertificate from a connecting client. Only applies to server connections.<\/p>\n<\/li>\nrejectUnauthorized<\/code>: A boolean indicating whether a server should\nautomatically reject clients with invalid certificates. Only applies to\nservers with requestCert<\/code> enabled.<\/p>\n<\/li>\n<\/ul>\ntls.createSecurePair()<\/code> returns a SecurePair object with [cleartext][] and\nencrypted<\/code> stream properties.\n\n<\/p>\n","p":[{"o":true,"t":"credentials","d":"","type":""},{"o":true,"t":"isServer","d":"","type":""},{"o":true,"t":"requestCert","d":"","type":""},{"o":true,"t":"rejectUnauthorized","d":"","type":""}]}} 2 | -------------------------------------------------------------------------------- /docs/String.json: -------------------------------------------------------------------------------- 1 | {"length":{"s":"The length property represents the length of a string.","y":"","p":null},"charAt":{"s":"The charAt() method returns the specified character from a string.","y":"str.charAt(index)","p":[{"t":"index","d":"An integer between 0 and 1-less-than the length of the string."}]},"charCodeAt":{"s":"The charCodeAt() method returns the numeric Unicode value of the character at the given index (except for unicode codepoints > 0x10000).","y":"str.charCodeAt(index)","p":[{"t":"index","d":"An integer greater than or equal to 0 and less than the length of the string; if it is not a number, it defaults to 0."}]},"codePointAt":{"s":"The codePointAt() method returns a non-negative integer that is the UTF-16 encoded code point value.","y":"str.codePointAt(pos)","p":[{"t":"pos","d":"Position of an element in the String to return the code point value from."}]},"concat":{"s":"The concat() method combines the text of two or more strings and returns a new string.","y":"str.concat(string2, string3[, ..., stringN])","p":[{"t":"string2...stringN","d":"Strings to concatenate to this string."}]},"contains":{"s":"","y":"str.contains(searchString [, position]);","p":[{"t":"searchString","d":"A string to be searched for within this string."},{"t":"position","d":"The position in this string at which to begin searching for searchString; defaults to 0."}]},"endsWith":{"s":"The endsWith() method determines whether a string ends with the characters of another string, returning true or false as appropriate.","y":"str.endsWith(searchString [, position]);","p":[{"t":"searchString","d":"The characters to be searched for at the end of this string."},{"t":"position","d":"Search within this string as if this string were only this long; defaults to this string's actual length, clamped within the range established by this string's length."}]},"indexOf":{"s":"The indexOf() method returns the index within the calling String object of the first occurrence of the specified value, starting the search at fromIndex,\n returns -1 if the value is not found.","y":"str.indexOf(searchValue[, fromIndex])","p":[{"t":"searchValue","d":"A string representing the value to search for."},{"t":"fromIndex","d":"The location within the calling string to start the search from. It can be any integer between 0 and the length of the string. The default value is 0."}]},"lastIndexOf":{"s":"The lastIndexOf() method returns the index within the calling String object of the last occurrence of the specified value, or -1 if not found. The calling string is searched backward, starting at fromIndex.","y":"str.lastIndexOf(searchValue[, fromIndex])","p":[{"t":"searchValue","d":"A string representing the value to search for."},{"t":"fromIndex","d":"The location within the calling string to start the search at, indexed from left to right. It can be any integer between 0 and the length of the string. The default value is the length of the string."}]},"localeCompare":{"s":"The localeCompare() method returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.","y":"str.localeCompare(compareString [, locales [, options]])","p":[{"t":"compareString","d":"The string against which the referring string is comparing"},{"t":"locales","d":""},{"t":"options","d":"Variant collations for certain locales. Possible values include: \"big5han\", \"dict\", \"direct\", \"ducet\", \"gb2312\", \"phonebk\", \"phonetic\", \"pinyin\", \"reformed\", \"searchjl\", \"stroke\", \"trad\", \"unihan\". The \"standard\" and \"search\" values are ignored; they are replaced by the options property usage (see below)."},{"t":"options","d":"Whether numeric collation should be used, such that \"1\" < \"2\" < \"10\". Possible values are \"true\" and \"false\". This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence."},{"t":"options","d":"Whether upper case or lower case should sort first. Possible values are \"upper\", \"lower\", or \"false\" (use the locale's default). This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence."},{"t":"options","d":""},{"t":"localeMatcher","d":"The locale matching algorithm to use. Possible values are \"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page."},{"t":"usage","d":"Whether the comparison is for sorting or for searching for matching strings. Possible values are \"sort\" and \"search\"; the default is \"sort\"."},{"t":"sensitivity","d":"Which differences in the strings should lead to non-zero result values. Possible values are:\n \"base\": Only strings that differ in base letters compare as unequal. Examples: a =\u0338 b, a = a\u0301, a = A.\n \"accent\": Only strings that differ in base letters or accents and other diacritic marks compare as unequal. Examples: a =\u0338 b, a =\u0338 a\u0301, a = A.\n \"case\": Only strings that differ in base letters or case compare as unequal. Examples: a =\u0338 b, a = a\u0301, a =\u0338 A.\n \"variant\": Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal. Other differences may also be taken into consideration. Examples: a =\u0338 b, a =\u0338 a\u0301, a =\u0338 A.\n The default is \"variant\" for usage \"sort\"; it's locale dependent for usage \"search\"."},{"t":"ignore\u00adPunctua\u00adtion","d":"Whether punctuation should be ignored. Possible values are true and false; the default is false."},{"t":"numeric","d":"Whether numeric collation should be used, such that \"1\" < \"2\" < \"10\". Possible values are true and false; the default is false. This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence. Implementations are not required to support this property."},{"t":"caseFirst","d":"Whether upper case or lower case should sort first. Possible values are \"upper\", \"lower\", or \"false\" (use the locale's default); the default is \"false\". This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence. Implementations are not required to support this property."}]},"match":{"s":"The match() method retrieves the matches when matching a string against a regular expression.","y":"str.match(regexp);","p":[{"t":"regexp","d":"A regular expression object. If a non-RegExp object obj is passed, it is implicitly converted to a RegExp by using new RegExp(obj)."},{"t":"array","d":"An Array containing the matched results or null if there were no matches."}]},"quote":{"s":"The non-standard quote() method returns a copy of the string, replacing various special characters in the string with their escape sequences and wrapping the result in double-quotes (\").","y":"str.quote()","p":null},"repeat":{"s":"The repeat() method copies the current string a given times and returns the new string.","y":"str.repeat(count)","p":[{"t":"count","d":"An integer between 0 and +\u221e : [ 0, +\u221e)."},{"t":"RangeError","d":"The repeat count must be positive and less than infinity."}]},"replace":{"s":"The replace() method returns a new string with some or all matches of a pattern replaced by a replacement.\u00a0 The pattern can be a string or a RegExp, and the replacement can be a string or a function to be called for each match.","y":"str.replace(regexp|substr, newSubStr|function[, flags]);","p":[{"t":"regexp","d":"A RegExp object. The match is replaced by the return value of parameter #2."},{"t":"substr","d":"A String that is to be replaced by newSubStr."},{"t":"newSubStr","d":"The String that replaces the substring received from parameter #1. A number of special replacement patterns are supported; see the \"Specifying a string as a parameter\" section below."},{"t":"function","d":"A function to be invoked to create the new substring (to put in place of the substring received from parameter #1). The arguments supplied to this function are described in the \"Specifying a function as a parameter\" section below."},{"t":"flags","d":"A string specifying a combination of regular expression flags. The use of the flags parameter in the String.replace method is non-standard. Instead of using this parameter, use a RegExp object with the corresponding flags. The value of this parameter if it is used should be a string consisting of one or more of the following characters to affect the operation as described:"},{"t":"g","d":"global match"},{"t":"i","d":"ignore case"},{"t":"m","d":"match over multiple lines"},{"t":"y","d":"sticky"}]},"search":{"s":"The search() method executes a search for a match between a regular expression and this String object.","y":"str.search(regexp)","p":[{"t":"regexp","d":"A regular expression object. If a non-RegExp object obj is passed, it is implicitly converted to a RegExp by using new RegExp(obj)."}]},"slice":{"s":"The slice() method extracts a section of a string and returns a new string.","y":"str.slice(beginSlice[, endSlice])","p":[{"t":"beginSlice","d":"The zero-based index at which to begin extraction. If negative, it is treated as (sourceLength-beginSlice) where sourceLength is the length of the string."},{"t":"endSlice","d":"The zero-based index at which to end extraction. If omitted, slice extracts to the end of the string. If negative, it is treated as (sourceLength-endSlice) where sourceLength is the length of the string."}]},"split":{"s":"The split() method splits a String object into an array of strings by separating the string into substrings.","y":"str.split([separator][, limit])","p":[{"t":"separator","d":"Specifies the character(s) to use for separating the string. The separator is treated as a string or a regular expression. If separator is omitted, the array returned contains one element consisting of the entire string. If separator is an empty string, str is converted to an array of characters."},{"t":"limit","d":"Integer specifying a limit on the number of splits to be found. The split method still splits on every match of separator, but it truncates the returned array to at most limit elements."}]},"startsWith":{"s":"The startsWith() method determines whether a string begins with the characters of another string, returning true or false as appropriate.","y":"str.startsWith(searchString [, position]);","p":[{"t":"searchString","d":"The characters to be searched for at the start of this string."},{"t":"position","d":"The position in this string at which to begin searching for searchString; defaults to 0."}]},"substr":{"s":"The substr() method returns the characters in a string beginning at the specified location through the specified number of characters.","y":"str.substr(start[, length])","p":[{"t":"start","d":"Location at which to begin extracting characters."},{"t":"length","d":"The number of characters to extract."}]},"substring":{"s":"The substring() method returns a subset of a string between one index and another, or through the end of the string.","y":"str.substring(indexA[, indexB])","p":[{"t":"indexA","d":"An integer between 0 and the length of the string."},{"t":"indexB","d":"(optional) An integer between 0 and the length of the string."}]},"toLocaleLowerCase":{"s":"The toLocaleLowerCase() method returns the calling string value converted to lower case, according to any locale-specific case mappings.","y":"str.toLocaleLowerCase()","p":null},"toLocaleUpperCase":{"s":"The toLocaleUpperCase() method returns the calling string value converted to upper case, according to any locale-specific case mappings.","y":"str.toLocaleUpperCase() ","p":null},"toLowerCase":{"s":"The toLowerCase() method returns the calling string value converted to lowercase.","y":"str.toLowerCase()","p":null},"toSource":{"s":"The toSource() method returns a string representing the source code of the object.","y":"String.toSource()\nstr.toSource()\n","p":null},"toString":{"s":"The toString() method returns a string representing the specified object.","y":"str.toString()","p":null},"toUpperCase":{"s":"The toUpperCase() method returns the calling string value converted to uppercase.","y":"str.toUpperCase()","p":null},"trim":{"s":"The trim() method removes whitespace from both ends of the string.","y":"str.trim()","p":null},"trimLeft":{"s":"The trimLeft() removes whitespace from the left end of the string.","y":"str.trimLeft()","p":null},"trimRight":{"s":"The trimRight() method removes whitespace from the right end of the string.","y":"str.trimRight()","p":null},"valueOfanchor":{"s":"","y":"","p":null},"big":{"s":"The big() method creates a <big> HTML element that causes a string to be displayed in a big font.","y":"str.big()","p":null},"blink":{"s":"The blink() method creates a <blink> HTML element that causes a string to blink.","y":"str.blink()","p":null},"bold":{"s":"The bold() method creates a HTML element that causes a string to be displayed as bold.","y":"str.bold()","p":null},"fixed":{"s":"The fixed() method creates a <tt> HTML element that causes a string to be displayed in fixed-pitch font.","y":"str.fixed() ","p":null},"fontcolor":{"s":"The fontcolor(color) method creates a HTML element that causes a string to be displayed in the specified font color.","y":"str.fontcolor(color)","p":[{"t":"color","d":"A string expressing the color as a hexadecimal RGB triplet or as a string literal. String literals for color names are listed in the CSS color reference."}]},"fontsize":{"s":"The fontsize() method creates a HTML element that causes a string to be displayed in the specified font size.","y":"str.fontsize(size)","p":[{"t":"size","d":"An integer between 1 and 7, a string representing a signed integer between 1 and 7."}]},"italics":{"s":"The italics() method creates an HTML element that causes a string to be italic.","y":"str.italics()","p":null},"link":{"s":"The link() method creates an <a> HTML element that causes a string to be displayed as a hypertext link to another URL.","y":"str.link(url) ","p":[{"t":"url","d":"Any string that specifies the href attribute of the a tag; it should be a valid URL (relative or absolute), with any & characters escaped as &, and any \" characters escaped as "."}]},"small":{"s":"The small() method creates a HTML element that causes a string to be displayed in a small font.","y":"str.small()","p":null},"strike":{"s":"The strike() method creates a <strike> HTML element that causes a string to be displayed as struck-out text.","y":"str.strike()","p":null},"sub":{"s":"The sub() method creates a HTML element that causes a string to be displayed as subscript.","y":"str.sub()","p":null},"sup":{"s":"The sup() method creates a HTML element that causes a string to be displayed as superscript.","y":"str.sup()","p":null}} -------------------------------------------------------------------------------- /InlineDocsViewer.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 3 | * 4 | * Permission is hereby granted, free of charge, to any person obtaining a 5 | * copy of this software and associated documentation files (the "Software"), 6 | * to deal in the Software without restriction, including without limitation 7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 | * and/or sell copies of the Software, and to permit persons to whom the 9 | * Software is furnished to do so, subject to the following conditions: 10 | * 11 | * The above copyright notice and this permission notice shall be included in 12 | * all copies or substantial portions of the Software. 13 | * 14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 20 | * DEALINGS IN THE SOFTWARE. 21 | * 22 | */ 23 | 24 | 25 | /*jslint vars: true, plusplus: true, devel: true, nomen: true, indent: 4, maxerr: 50 */ 26 | /*global define, brackets, $, window */ 27 | 28 | /** 29 | * Inline widget to display WebPlatformDocs JSON data nicely formatted 30 | */ 31 | define(function (require, exports, module) { 32 | 'use strict'; 33 | 34 | // Load Brackets modules 35 | var ExtensionUtils = brackets.getModule("utils/ExtensionUtils"), 36 | InlineWidget = brackets.getModule("editor/InlineWidget").InlineWidget, 37 | KeyEvent = brackets.getModule("utils/KeyEvent"), 38 | NativeApp = brackets.getModule("utils/NativeApp"), 39 | Commands = brackets.getModule('command/Commands'), 40 | EditorManager = brackets.getModule('editor/EditorManager'), 41 | MainViewManager = brackets.getModule('view/MainViewManager'), 42 | CommandManager = brackets.getModule('command/CommandManager'), 43 | Strings = brackets.getModule("strings"), 44 | Mustache = brackets.getModule("thirdparty/mustache/mustache"), 45 | QuickOpenJS = require('QuickOpenJS'); 46 | 47 | 48 | var infoUrl,infoUrlName,licenseUrl,licenseUrlName; 49 | 50 | // Load template 51 | var inlineEditorTemplate = require("text!InlineDocsViewer.html"); 52 | 53 | // Lines height for scrolling 54 | var SCROLL_LINE_HEIGHT = 40; 55 | 56 | // Load CSS 57 | ExtensionUtils.loadStyleSheet(module, "WebPlatformDocsJS.less"); 58 | 59 | 60 | /** 61 | * @param {!string} jsPropName 62 | * @param {!{SUMMARY:string, SYNTAX:string, RETURN:string, EXTRAS: Object, URL:string, VALUES:Array.<{TITLE:string, DESCRIPTION:string}>}} jsPropDetails 63 | */ 64 | function InlineDocsViewer(jsPropName, jsPropDetails) { 65 | InlineWidget.call(this); 66 | 67 | // valueInfo.t = title (.d = description) 68 | var propValues = jsPropDetails.VALUES.map(function (valueInfo) { 69 | valueInfo.cssOptionalDefault = 'display:none;'; 70 | if (valueInfo.optional) { 71 | if (valueInfo.default !== null && typeof valueInfo.default !== "undefined") { 72 | valueInfo.default = 'Default: '+valueInfo.default; 73 | valueInfo.cssOptionalDefault = 'display:inline;'; 74 | } 75 | valueInfo.cssOptional = 'display:inline;'; 76 | } else { 77 | valueInfo.cssOptional = 'display:none;'; 78 | } 79 | var propsForProps = false; 80 | if ("pa" in valueInfo) { 81 | propsForProps = valueInfo.pa.map(function (propsForValue) { 82 | propsForValue.cssOptionalDefault = 'display:none;'; 83 | if (propsForValue.optional) { 84 | if (propsForValue.default !== null && typeof propsForValue.default !== "undefined") { 85 | propsForValue.default = 'Default: '+propsForValue.default; 86 | propsForValue.cssOptionalDefault = 'display:inline;'; 87 | } 88 | propsForValue.cssOptional = 'display:inline;'; 89 | } else { 90 | propsForValue.cssOptional = 'display:none;'; 91 | } 92 | 93 | return { 94 | name: propsForValue.t, 95 | description: parseJSDocs(propsForValue.d), 96 | type: propsForValue.type, 97 | default: propsForValue.default, 98 | cssOptional: propsForValue.cssOptional, 99 | cssOptionalDefault: propsForValue.cssOptionalDefault 100 | }; 101 | }); 102 | } 103 | 104 | return { 105 | name: valueInfo.t, 106 | description: parseJSDocs(valueInfo.d), 107 | propsForProps: propsForProps, 108 | type: valueInfo.type, 109 | default: valueInfo.default, 110 | cssOptional: valueInfo.cssOptional, 111 | cssOptionalDefault: valueInfo.cssOptionalDefault 112 | }; 113 | }); 114 | 115 | var returnValues = [{description: parseJSDocs(jsPropDetails.RETURN.d), type: jsPropDetails.RETURN.type}]; 116 | 117 | 118 | var bottom_style = '', syntax_style = '', return_style = ''; 119 | 120 | if (!jsPropDetails.URL) { 121 | bottom_style = 'display: none;'; 122 | } 123 | if (!jsPropDetails.SYNTAX) { 124 | syntax_style = 'display: none;'; 125 | } 126 | 127 | if (!returnValues[0].description && !returnValues[0].type) { 128 | return_style = 'display: none;'; 129 | } 130 | 131 | window.addEventListener 132 | if (jsPropDetails.URL && jsPropDetails.URL.indexOf("http://nodejs.org") === 0) { 133 | infoUrl = "http://nodejs.org"; 134 | infoUrlName = "NodeJS.org"; 135 | licenseUrl = "https://raw.githubusercontent.com/joyent/node/v0.10.32/LICENSE"; 136 | licenseUrlName = "NodeJS License"; 137 | } else if (jsPropDetails.URL && jsPropDetails.URL.indexOf("http://api.jquery.com") === 0) { 138 | infoUrl = "https://api.jquery.com/"; 139 | infoUrlName = "jquery.com" 140 | licenseUrl = "http://en.wikipedia.org/wiki/MIT_License"; 141 | licenseUrlName = "MIT License"; 142 | } else if (jsPropDetails.URL && jsPropDetails.URL.indexOf("http://facebook.github.io") === 0) { 143 | infoUrl = "http://facebook.github.io/react/"; 144 | infoUrlName = "ReactJS"; 145 | licenseUrl = "https://raw.githubusercontent.com/facebook/react/master/LICENSE"; 146 | licenseUrlName = "BSD License"; 147 | } else { 148 | infoUrl = "https://developer.mozilla.org/"; 149 | infoUrlName = "mozilla.org" 150 | licenseUrl = "https://developer.mozilla.org/en-US/docs/MDN/About#Copyrights_and_licenses"; 151 | licenseUrlName = "Creative Commons License"; 152 | } 153 | 154 | 155 | var templateVars = { 156 | propName : jsPropName, 157 | path : jsPropDetails.path, 158 | line : jsPropDetails.line, 159 | pos : jsPropDetails.pos, 160 | summary : parseJSDocs(jsPropDetails.SUMMARY), 161 | creationExtras: ("author" in jsPropDetails.EXTRAS || "createDate" in jsPropDetails.EXTRAS) ? true : false, 162 | modifiedExtras: ("lastmodifiedBy" in jsPropDetails.EXTRAS || "lastmodifiedDate" in jsPropDetails.EXTRAS) ? true : false, 163 | author : "author" in jsPropDetails.EXTRAS ? jsPropDetails.EXTRAS.author : "", 164 | lastmodifiedBy : "lastmodifiedBy" in jsPropDetails.EXTRAS ? jsPropDetails.EXTRAS.lastmodifiedBy : "", 165 | createDate : "createDate" in jsPropDetails.EXTRAS ? jsPropDetails.EXTRAS.createDate : "", 166 | lastmodifiedDate: "lastmodifiedDate" in jsPropDetails.EXTRAS ? jsPropDetails.EXTRAS.lastmodifiedDate : "", 167 | syntax : jsPropDetails.SYNTAX, 168 | returnValues : returnValues, 169 | propValues : propValues, 170 | url : jsPropDetails.URL, 171 | BottomStyle : bottom_style, 172 | SyntaxStyle : syntax_style, 173 | ReturnStyle : return_style, 174 | Strings : Strings, 175 | infoUrl : infoUrl, 176 | infoUrlName : infoUrlName, 177 | licenseUrl : licenseUrl, 178 | licenseUrlName: licenseUrlName 179 | }; 180 | 181 | var html = Mustache.render(inlineEditorTemplate, templateVars); 182 | this.$wrapperDiv = $(html); 183 | this.$htmlContent.append(this.$wrapperDiv); 184 | 185 | // Preprocess link tags to make URLs absolute 186 | this.$wrapperDiv.find("a").each(function (index, elem) { 187 | var $elem = $(elem); 188 | var url = $elem.attr("href"); 189 | if (url && url.substr(0, 4) !== "http" && !$elem.hasClass('jumpToDef')) { 190 | // URLs in JSON data are relative 191 | url = "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/" + url; 192 | $elem.attr("href", url); 193 | } else if (url) { 194 | // URLs in JSON data are relative 195 | $elem.attr("href", url); 196 | } 197 | $elem.attr("title", url); 198 | }); 199 | 200 | this._sizeEditorToContent = this._sizeEditorToContent.bind(this); 201 | this._handleWheelScroll = this._handleWheelScroll.bind(this); 202 | 203 | this.$scroller = this.$wrapperDiv.find(".scroller"); 204 | this.$scroller.on("mousewheel", this._handleWheelScroll); 205 | this._onKeydown = this._onKeydown.bind(this); 206 | 207 | this.$jumpToDef = this.$wrapperDiv.find(".jumpToDef"); 208 | this.$jumpToDef.on('click', function(event) { 209 | event.preventDefault(); 210 | var linkFunc = $(this).attr("href").substr(1); 211 | QuickOpenJS.itemFocus(linkFunc); 212 | }); 213 | 214 | 215 | this.$h1propName = this.$wrapperDiv.find("#h1-propName"); 216 | this.$h1propName.on('click', function(event) { 217 | event.preventDefault(); 218 | var path = $(this).data("path"); 219 | var line = $(this).data("line"); 220 | var pos = $(this).data("pos"); 221 | _jumpToFile(path, {line: line, ch: pos}); 222 | }); 223 | } 224 | 225 | /** 226 | * Jump to a file and set the cursor position 227 | * @param {String} fullPath path to the file 228 | * @param {Object} cursorPos cursor position (.line,.ch) 229 | */ 230 | function _jumpToFile(fullPath,cursorPos) { 231 | CommandManager.execute( Commands.FILE_OPEN, { fullPath: fullPath } ).done( function() { 232 | // Set focus on editor. 233 | MainViewManager.focusActivePane(); 234 | EditorManager.getCurrentFullEditor().setCursorPos( 235 | cursorPos.line, 236 | cursorPos.ch, 237 | true 238 | ); 239 | }); 240 | } 241 | 242 | InlineDocsViewer.prototype = Object.create(InlineWidget.prototype); 243 | InlineDocsViewer.prototype.constructor = InlineDocsViewer; 244 | InlineDocsViewer.prototype.parentClass = InlineWidget.prototype; 245 | 246 | InlineDocsViewer.prototype.$wrapperDiv = null; 247 | InlineDocsViewer.prototype.$scroller = null; 248 | 249 | /** 250 | * Handle scrolling. 251 | * 252 | * @param {Event} event Keyboard event or mouse scrollwheel event 253 | * @param {boolean} scrollingUp Is event to scroll up? 254 | * @param {DOMElement} scroller Element to scroll 255 | * @return {boolean} indication whether key was handled 256 | */ 257 | InlineDocsViewer.prototype._handleScrolling = function (event, scrollingUp, scroller) { 258 | // We need to block the event from both the host CodeMirror code (by stopping bubbling) and the 259 | // browser's native behavior (by preventing default). We preventDefault() *only* when the docs 260 | // scroller is at its limit (when an ancestor would get scrolled instead); otherwise we'd block 261 | // normal scrolling of the docs themselves. 262 | event.stopPropagation(); 263 | if (scrollingUp && scroller.scrollTop === 0) { 264 | event.preventDefault(); 265 | return true; 266 | } else if (!scrollingUp && scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight) { 267 | event.preventDefault(); 268 | return true; 269 | } 270 | 271 | return false; 272 | }; 273 | 274 | /** Don't allow scrollwheel/trackpad to bubble up to host editor - makes scrolling docs painful */ 275 | InlineDocsViewer.prototype._handleWheelScroll = function (event) { 276 | var scrollingUp = (event.originalEvent.wheelDeltaY > 0), 277 | scroller = event.currentTarget; 278 | 279 | // If content has no scrollbar, let host editor scroll normally 280 | if (scroller.clientHeight >= scroller.scrollHeight) { 281 | return; 282 | } 283 | 284 | this._handleScrolling(event, scrollingUp, scroller); 285 | }; 286 | 287 | 288 | /** 289 | * Convert keydown events into navigation actions. 290 | * 291 | * @param {KeyboardEvent} event 292 | * @return {boolean} indication whether key was handled 293 | */ 294 | InlineDocsViewer.prototype._onKeydown = function (event) { 295 | var keyCode = event.keyCode, 296 | scroller = this.$scroller[0], 297 | scrollPos; 298 | 299 | // Ignore key events with modifier keys 300 | if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) { 301 | return false; 302 | } 303 | 304 | // Handle keys that we're interested in 305 | scrollPos = scroller.scrollTop; 306 | 307 | switch (keyCode) { 308 | case KeyEvent.DOM_VK_UP: 309 | scrollPos = Math.max(0, scrollPos - SCROLL_LINE_HEIGHT); 310 | break; 311 | case KeyEvent.DOM_VK_PAGE_UP: 312 | scrollPos = Math.max(0, scrollPos - scroller.clientHeight); 313 | break; 314 | case KeyEvent.DOM_VK_DOWN: 315 | scrollPos = Math.min(scroller.scrollHeight - scroller.clientHeight, 316 | scrollPos + SCROLL_LINE_HEIGHT); 317 | break; 318 | case KeyEvent.DOM_VK_PAGE_DOWN: 319 | scrollPos = Math.min(scroller.scrollHeight - scroller.clientHeight, 320 | scrollPos + scroller.clientHeight); 321 | break; 322 | default: 323 | // Ignore other keys 324 | return false; 325 | } 326 | 327 | scroller.scrollTop = scrollPos; 328 | 329 | // Disallow further processing 330 | event.stopPropagation(); 331 | event.preventDefault(); 332 | return true; 333 | }; 334 | 335 | InlineDocsViewer.prototype.onAdded = function () { 336 | InlineDocsViewer.prototype.parentClass.onAdded.apply(this, arguments); 337 | 338 | // Set height initially, and again whenever width might have changed (word wrap) 339 | this._sizeEditorToContent(); 340 | $(window).on("resize", this._sizeEditorToContent); 341 | 342 | // Set focus 343 | this.$scroller[0].focus(); 344 | this.$wrapperDiv[0].addEventListener("keydown", this._onKeydown, true); 345 | }; 346 | 347 | InlineDocsViewer.prototype.onClosed = function () { 348 | InlineDocsViewer.prototype.parentClass.onClosed.apply(this, arguments); 349 | 350 | $(window).off("resize", this._sizeEditorToContent); 351 | this.$wrapperDiv[0].removeEventListener("keydown", this._onKeydown, true); 352 | }; 353 | 354 | InlineDocsViewer.prototype._sizeEditorToContent = function () { 355 | this.hostEditor.setInlineWidgetHeight(this, this.$wrapperDiv.height() + 20, true); 356 | }; 357 | 358 | 359 | /** 360 | * {@link get_userdefined_tags} 361 | * @param {String} doc [[Description]] 362 | * @returns {String} [[Description]] 363 | */ 364 | function parseJSDocs(doc) { 365 | if (typeof doc == "string") { 366 | doc = doc.replace(/ | /,'\r\n'); 367 | doc = doc.replace(/{@link\s+([^|}]*?)\|\s*(.*?)}/m,function(match,p1,p2) { 368 | if (/^https?:\/\//.test(p1.trim())) { 369 | return ''+p2.trim()+''; 370 | } 371 | return ''+p2.trim()+''; 372 | }); 373 | doc = doc.replace(/(?:\[(.*?)\])?{@link\s+([^| ]*?)(?:\s+(.*?))?}/m,function(match,p1,p2,p3) { 374 | if (p1) { 375 | if (/^https?:\/\//.test(p1.trim())) { 376 | return ''+p1.trim()+''; 377 | } 378 | return ''+p1.trim()+''; 379 | } 380 | if (p3) { 381 | if (/^https?:\/\//.test(p2.trim())) { 382 | return ''+p3.trim()+''; 383 | } 384 | return ''+p3.trim()+''; 385 | } 386 | if (/^https?:\/\//.test(p2.trim())) { 387 | return ''+p2.trim()+''; 388 | } 389 | return ''+p2.trim()+''; 390 | 391 | }); 392 | doc = doc.replace(/\r\n/,' '); 393 | } 394 | return doc; 395 | } 396 | 397 | 398 | 399 | module.exports = InlineDocsViewer; 400 | }); 401 | --------------------------------------------------------------------------------