mrs-toolbox-cli 11.1.2-fd1156b0 → 11.1.3

package/npm-cache/_cacache/content-v2/sha512/{9f/62/0aae3f4c31ee2541eb07524ad9d40e1885246b080fc8977d9f97b6a776df6004eeee19056827f38db32071c93f221cc022aec879438bc7ca5c8ca711a50c → bd/09/e4d1dfb9a0eca13175ae642685ce28bec92a113eb6f7c72fccf168dcc77ca26fabdf2599deddfc744a547f20a364614629e6199e5f2e89edb828d984c217}

@@ -4185,7 +4185,7 @@
   "dist-tags": {
     "latest": "1.4.10"
   },
-  "_rev": "85-1023074414c86888",
+  "_rev": "87-1a2338f2675dd9be",
   "_id": "readline-sync",
   "readme": "# readlineSync\n\n[![npm](https://img.shields.io/npm/v/readline-sync.svg)](https://www.npmjs.com/package/readline-sync) [![GitHub issues](https://img.shields.io/github/issues/anseki/readline-sync.svg)](https://github.com/anseki/readline-sync/issues) [![dependencies](https://img.shields.io/badge/dependencies-No%20dependency-brightgreen.svg)](package.json) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE-MIT)\n\nSynchronous [Readline](http://nodejs.org/api/readline.html) for interactively running to have a conversation with the user via a console(TTY).\n\nreadlineSync tries to let your script have a conversation with the user via a console, even when the input/output stream is redirected like `your-script <foo.dat >bar.log`.\n\n<table>\n<tr><td><a href=\"#basic_options\">Basic Options</a></td><td><a href=\"#utility_methods\">Utility Methods</a></td><td><a href=\"#placeholders\">Placeholders</a></td></tr>\n</table>\n\n* Simple case:\n\n```js\nvar readlineSync = require('readline-sync');\n\n// Wait for user's response.\nvar userName = readlineSync.question('May I have your name? ');\nconsole.log('Hi ' + userName + '!');\n\n// Handle the secret text (e.g. password).\nvar favFood = readlineSync.question('What is your favorite food? ', {\n  hideEchoBack: true // The typed text on screen is hidden by `*` (default).\n});\nconsole.log('Oh, ' + userName + ' loves ' + favFood + '!');\n```\n\n```console\nMay I have your name? CookieMonster\nHi CookieMonster!\nWhat is your favorite food? ****\nOh, CookieMonster loves tofu!\n```\n\n* Get the user's response by a single key without the Enter key:\n\n```js\nvar readlineSync = require('readline-sync');\nif (readlineSync.keyInYN('Do you want this module?')) {\n  // 'Y' key was pressed.\n  console.log('Installing now...');\n  // Do something...\n} else {\n  // Another key was pressed.\n  console.log('Searching another...');\n  // Do something...\n}\n```\n\n* Let the user choose an item from a list:\n\n```js\nvar readlineSync = require('readline-sync'),\n  animals = ['Lion', 'Elephant', 'Crocodile', 'Giraffe', 'Hippo'],\n  index = readlineSync.keyInSelect(animals, 'Which animal?');\nconsole.log('Ok, ' + animals[index] + ' goes to your room.');\n```\n\n```console\n[1] Lion\n[2] Elephant\n[3] Crocodile\n[4] Giraffe\n[5] Hippo\n[0] CANCEL\n\nWhich animal? [1...5 / 0]: 2\nOk, Elephant goes to your room.\n```\n\n* An UI like the Range Slider:  \n(Press `Z` or `X` key to change a value, and Space Bar to exit)\n\n```js\nvar readlineSync = require('readline-sync'),\n  MAX = 60, MIN = 0, value = 30, key;\nconsole.log('\\n\\n' + (new Array(20)).join(' ') +\n  '[Z] <- -> [X]  FIX: [SPACE]\\n');\nwhile (true) {\n  console.log('\\x1B[1A\\x1B[K|' +\n    (new Array(value + 1)).join('-') + 'O' +\n    (new Array(MAX - value + 1)).join('-') + '| ' + value);\n  key = readlineSync.keyIn('',\n    {hideEchoBack: true, mask: '', limit: 'zx '});\n  if (key === 'z') { if (value > MIN) { value--; } }\n  else if (key === 'x') { if (value < MAX) { value++; } }\n  else { break; }\n}\nconsole.log('\\nA value the user requested: ' + value);\n```\n\n![sample](screen_03.gif)\n\n* Handle the commands repeatedly, such as the shell interface:\n\n```js\nreadlineSync.promptCLLoop({\n  add: function(target, into) {\n    console.log(target + ' is added into ' + into + '.');\n    // Do something...\n  },\n  remove: function(target) {\n    console.log(target + ' is removed.');\n    // Do something...\n  },\n  bye: function() { return true; }\n});\nconsole.log('Exited');\n```\n\n```console\n> add pic01.png archive\npic01.png is added into archive.\n> delete pic01.png\nRequested command is not available.\n> remove pic01.png\npic01.png is removed.\n> bye\nExited\n```\n\n## <a name=\"installation\"></a>Installation\n\n```console\nnpm install readline-sync\n```\n\n## <a name=\"quick_start\"></a>Quick Start\n\n**How does the user input?**\n\n- [Type a reply to a question, and press the Enter key](#quick_start-a) (A)\n- [Type a keyword like a command in prompt, and press the Enter key](#quick_start-b) (B)\n- [Press a single key without the Enter key](#quick_start-c) (C)\n\n<a name=\"quick_start-a\"></a>**(A) What does the user input?**\n\n- [E-mail address](#utility_methods-questionemail)\n- [New password](#utility_methods-questionnewpassword)\n- [Integer number](#utility_methods-questionint)\n- [Floating-point number](#utility_methods-questionfloat)\n- [Local file/directory path](#utility_methods-questionpath)\n- [Others](#basic_methods-question)\n\n<a name=\"quick_start-b\"></a>**(B) What does your script do?**\n\n- [Receive a parsed command-name and arguments](#utility_methods-promptcl)\n- [Receive an input repeatedly](#utility_methods-promptloop)\n- [Receive a parsed command-name and arguments repeatedly](#utility_methods-promptclloop)\n- [Receive an input with prompt that is similar to that of the user's shell](#utility_methods-promptsimshell)\n- [Others](#basic_methods-prompt)\n\n<a name=\"quick_start-c\"></a>**(C) What does the user do?**\n\n- [Say \"Yes\" or \"No\"](#utility_methods-keyinyn)\n- [Say \"Yes\" or \"No\" explicitly](#utility_methods-keyinynstrict)\n- [Make the running of script continue when ready](#utility_methods-keyinpause)\n- [Choose an item from a list](#utility_methods-keyinselect)\n- [Others](#basic_methods-keyin)\n\n## <a name=\"basic_methods\"></a>Basic Methods\n\nThese are used to control details of the behavior. It is recommended to use the [Utility Methods](#utility_methods) instead of Basic Methods if it satisfy your request.\n\n### <a name=\"basic_methods-question\"></a>`question`\n\n```js\nanswer = readlineSync.question([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then return the input from the user after it has been typed and the Enter key was pressed.  \nYou can specify an `options` (see [Basic Options](#basic_options)) to control the behavior (e.g. refusing unexpected input, avoiding trimming white spaces, etc.). **If you let the user input the secret text (e.g. password), you should consider [`hideEchoBack`](#basic_options-hideechoback) option.**\n\nThe `query` may be string, or may not be (e.g. number, Date, Object, etc.). It is converted to string (i.e. `toString` method is called) before it is displayed. (see [Note](#note) also)  \nIt can include the [placeholders](#placeholders).\n\nFor example:\n\n```js\nprogram = readlineSync.question('Which program starts do you want? ', {\n  defaultInput: 'firefox'\n});\n```\n\n### <a name=\"basic_methods-prompt\"></a>`prompt`\n\n```js\ninput = readlineSync.prompt([options])\n```\n\nDisplay a prompt-sign (see [`prompt`](#basic_options-prompt) option) to the user, and then return the input from the user after it has been typed and the Enter key was pressed.  \nYou can specify an `options` (see [Basic Options](#basic_options)) to control the behavior (e.g. refusing unexpected input, avoiding trimming white spaces, etc.).\n\nFor example:\n\n```js\nwhile (true) {\n  command = readlineSync.prompt();\n  // Do something...\n}\n```\n\n### <a name=\"basic_methods-keyin\"></a>`keyIn`\n\n```js\npressedKey = readlineSync.keyIn([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then return a character as a key immediately it was pressed by the user, **without pressing the Enter key**. Note that the user has no chance to change the input.  \nYou can specify an `options` (see [Basic Options](#basic_options)) to control the behavior (e.g. ignoring keys except some keys, checking target key, etc.).\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.\n\nFor example:\n\n```js\nmenuId = readlineSync.keyIn('Hit 1...5 key: ', {limit: '$<1-5>'});\n```\n\n### <a name=\"basic_methods-setdefaultoptions\"></a>`setDefaultOptions`\n\n```js\ncurrentDefaultOptions = readlineSync.setDefaultOptions([newDefaultOptions])\n```\n\nChange the [Default Options](#basic_options) to the values of properties of `newDefaultOptions` Object.  \nAll it takes is to specify options that you want change, because unspecified options are not updated.\n\n## <a name=\"basic_options\"></a>Basic Options\n\n[`prompt`](#basic_options-prompt), [`hideEchoBack`](#basic_options-hideechoback), [`mask`](#basic_options-mask), [`limit`](#basic_options-limit), [`limitMessage`](#basic_options-limitmessage), [`defaultInput`](#basic_options-defaultinput), [`trueValue`, `falseValue`](#basic_options-truevalue_falsevalue), [`caseSensitive`](#basic_options-casesensitive), [`keepWhitespace`](#basic_options-keepwhitespace), [`encoding`](#basic_options-encoding), [`bufferSize`](#basic_options-buffersize), [`print`](#basic_options-print), [`history`](#basic_options-history), [`cd`](#basic_options-cd)\n\nAn `options` Object can be specified to the methods to control the behavior of readlineSync. The options that were not specified to the methods are got from the Default Options. You can change the Default Options by [`setDefaultOptions`](#basic_methods-setdefaultoptions) method anytime, and it is kept until a current process is exited.  \nSpecify the options that are often used to the Default Options, and specify temporary options to the methods.\n\nFor example:\n\n```js\nreadlineSync.setDefaultOptions({limit: ['green', 'yellow', 'red']});\na1 = readlineSync.question('Which color of signal? '); // Input is limited to 3 things.\na2 = readlineSync.question('Which color of signal? '); // It's limited yet.\na3 = readlineSync.question('What is your favorite color? ', {limit: null}); // It's unlimited temporarily.\na4 = readlineSync.question('Which color of signal? '); // It's limited again.\nreadlineSync.setDefaultOptions({limit: ['beef', 'chicken']});\na5 = readlineSync.question('Beef or Chicken? ');        // Input is limited to new 2 things.\na6 = readlineSync.question('And you? ');                // It's limited to 2 things yet.\n```\n\nThe Object as `options` can have following properties.\n\n### <a name=\"basic_options-prompt\"></a>`prompt`\n\n_For `prompt*` methods only_  \n*Type:* string or others  \n*Default:* `'> '`\n\nSet the prompt-sign that is displayed to the user by `prompt*` methods. For example you see `> ` that is Node.js's prompt-sign when you run `node` on the command line.  \nThis may be string, or may not be (e.g. number, Date, Object, etc.). It is converted to string every time (i.e. `toString` method is called) before it is displayed. (see [Note](#note) also)  \nIt can include the [placeholders](#placeholders).\n\nFor example:\n\n```js\nreadlineSync.setDefaultOptions({prompt: '$ '});\n```\n\n```js\n// Display the memory usage always.\nreadlineSync.setDefaultOptions({\n  prompt: { // Simple Object that has toString method.\n    toString: function() {\n      var rss = process.memoryUsage().rss;\n      return '[' + (rss > 1024 ? Math.round(rss / 1024) + 'k' : rss) + 'b]$ ';\n    }\n  }\n});\n```\n\n```console\n[13148kb]$ foo\n[13160kb]$ bar\n[13200kb]$\n```\n\n### <a name=\"basic_options-hideechoback\"></a>`hideEchoBack`\n\n*Type:* boolean  \n*Default:* `false`\n\nIf `true` is specified, hide the secret text (e.g. password) which is typed by user on screen by the mask characters (see [`mask`](#basic_options-mask) option).\n\nFor example:\n\n```js\npassword = readlineSync.question('PASSWORD: ', {hideEchoBack: true});\nconsole.log('Login ...');\n```\n\n```console\nPASSWORD: ********\nLogin ...\n```\n\n### <a name=\"basic_options-mask\"></a>`mask`\n\n*Type:* string  \n*Default:* `'*'`\n\nSet the mask characters that are shown instead of the secret text (e.g. password) when `true` is specified to [`hideEchoBack`](#basic_options-hideechoback) option. If you want to show nothing, specify `''`. (But it might be not user friendly in some cases.)  \n**Note:** In some cases (e.g. when the input stream is redirected on Windows XP), `'*'` or `''` might be used whether other one is specified.\n\nFor example:\n\n```js\nsecret = readlineSync.question('Please whisper sweet words: ', {\n  hideEchoBack: true,\n  mask: require('chalk').magenta('\\u2665')\n});\n```\n\n![sample](screen_02.gif)\n\n### <a name=\"basic_options-limit\"></a>`limit`\n\nLimit the user's input.  \nThe usage differ depending on the method.\n\n#### <a name=\"basic_options-limit-for_question_and_prompt_methods\"></a>For `question*` and `prompt*` methods\n\n*Type:* string, number, RegExp, function or Array  \n*Default:* `[]`\n\nAccept only the input that matches value that is specified to this. If the user input others, display a string that is specified to [`limitMessage`](#basic_options-limitmessage) option, and wait for reinput.\n\n* The string is compared with the input. It is affected by [`caseSensitive`](#basic_options-casesensitive) option.\n* The number is compared with the input that is converted to number by `parseFloat()`. For example, it interprets `'   3.14   '`, `'003.1400'`, `'314e-2'` and `'3.14PI'` as `3.14`. And it interprets `'005'`, `'5files'`, `'5kb'` and `'5px'` as `5`.\n* The RegExp tests the input.\n* The function that returns a boolean to indicate whether it matches is called with the input.\n\nOne of above or an Array that includes multiple things (or Array includes Array) can be specified.\n\nFor example:\n\n```js\ncommand = readlineSync.prompt({limit: ['add', 'remove', /^clear( all)?$/]});\n// ** But `promptCL` method should be used instead of this. **\n```\n\n```js\nfile = readlineSync.question('Text File: ', {limit: /\\.txt$/i});\n// ** But `questionPath` method should be used instead of this. **\n```\n\n```js\nip = readlineSync.question('IP Address: ', {limit: function(input) {\n  return require('net').isIP(input); // Valid IP Address\n}});\n```\n\n```js\navailableActions = [];\nif (!blockExists())  { availableActions.push('jump'); }\nif (isLarge(place))  { availableActions.push('run'); }\nif (isNew(shoes))    { availableActions.push('kick'); }\nif (isNearby(enemy)) { availableActions.push('punch'); }\naction = readlineSync.prompt({limit: availableActions});\n// ** But `promptCL` method should be used instead of this. **\n```\n\n#### <a name=\"basic_options-limit-for_keyin_method\"></a>For `keyIn*` method\n\n*Type:* string, number or Array  \n*Default:* `[]`\n\nAccept only the key that matches value that is specified to this, ignore others.  \nSpecify the characters as the key. All strings or Array of those are decomposed into single characters. For example, `'abcde'` or `['a', 'bc', ['d', 'e']]` are the same as `['a', 'b', 'c', 'd', 'e']`.  \nThese strings are compared with the input. It is affected by [`caseSensitive`](#basic_options-casesensitive) option.\n\nThe [placeholders](#placeholders) like `'$<a-e>'` are replaced to an Array that is the character list like `['a', 'b', 'c', 'd', 'e']`.\n\nFor example:\n\n```js\ndirection = readlineSync.keyIn('Left or Right? ', {limit: 'lr'}); // 'l' or 'r'\n```\n\n```js\ndice = readlineSync.keyIn('Roll the dice, What will the result be? ',\n  {limit: '$<1-6>'}); // range of '1' to '6'\n```\n\n### <a name=\"basic_options-limitmessage\"></a>`limitMessage`\n\n_For `question*` and `prompt*` methods only_  \n*Type:* string  \n*Default:* `'Input another, please.$<( [)limit(])>'`\n\nDisplay this to the user when the [`limit`](#basic_options-limit) option is specified and the user input others.  \nThe [placeholders](#placeholders) can be included.\n\nFor example:\n\n```js\nfile = readlineSync.question('Name of Text File: ', {\n  limit: /\\.txt$/i,\n  limitMessage: 'Sorry, $<lastInput> is not text file.'\n});\n```\n\n### <a name=\"basic_options-defaultinput\"></a>`defaultInput`\n\n_For `question*` and `prompt*` methods only_  \n*Type:* string  \n*Default:* `''`\n\nIf the user input empty text (i.e. pressed the Enter key only), return this.\n\nFor example:\n\n```js\nlang = readlineSync.question('Which language? ', {defaultInput: 'javascript'});\n```\n\n### <a name=\"basic_options-truevalue_falsevalue\"></a>`trueValue`, `falseValue`\n\n*Type:* string, number, RegExp, function or Array  \n*Default:* `[]`\n\nIf the input matches `trueValue`, return `true`. If the input matches `falseValue`, return `false`. In any other case, return the input.\n\n* The string is compared with the input. It is affected by [`caseSensitive`](#basic_options-casesensitive) option.\n* The number is compared with the input that is converted to number by `parseFloat()`. For example, it interprets `'   3.14   '`, `'003.1400'`, `'314e-2'` and `'3.14PI'` as `3.14`. And it interprets `'005'`, `'5files'`, `'5kb'` and `'5px'` as `5`. Note that in `keyIn*` method, the input is every time one character (i.e. the number that is specified must be an integer within the range of `0` to `9`).\n* The RegExp tests the input.\n* The function that returns a boolean to indicate whether it matches is called with the input.\n\nOne of above or an Array that includes multiple things (or Array includes Array) can be specified.\n\nFor example:\n\n```js\nanswer = readlineSync.question('How do you like it? ', {\n  trueValue: ['yes', 'yeah', 'yep'],\n  falseValue: ['no', 'nah', 'nope']\n});\nif (answer === true) {\n  console.log('Let\\'s go!');\n} else if (answer === false) {\n  console.log('Oh... It\\'s ok...');\n} else {\n  console.log('Sorry. What does \"' + answer + '\" you said mean?');\n}\n```\n\n### <a name=\"basic_options-casesensitive\"></a>`caseSensitive`\n\n*Type:* boolean  \n*Default:* `false`\n\nBy default, the string comparisons are case-insensitive (i.e. `a` equals `A`). If `true` is specified, it is case-sensitive, the cases are not ignored (i.e. `a` is different from `A`).  \nIt affects: [`limit`](#basic_options-limit), [`trueValue`](#basic_options-truevalue_falsevalue), [`falseValue`](#basic_options-truevalue_falsevalue), some [placeholders](#placeholders), and some [Utility Methods](#utility_methods).\n\n### <a name=\"basic_options-keepwhitespace\"></a>`keepWhitespace`\n\n_For `question*` and `prompt*` methods only_  \n*Type:* boolean  \n*Default:* `false`\n\nBy default, remove the leading and trailing white spaces from the input text. If `true` is specified, don't remove those.\n\n### <a name=\"basic_options-encoding\"></a>`encoding`\n\n*Type:* string  \n*Default:* `'utf8'`\n\nSet the encoding method of the input and output.\n\n### <a name=\"basic_options-buffersize\"></a>`bufferSize`\n\n_For `question*` and `prompt*` methods only_  \n*Type:* number  \n*Default:* `1024`\n\nWhen readlineSync reads from a console directly (without [external program](#note-reading_by_external_program)), use a size `bufferSize` buffer.  \nEven if the input by user exceeds it, it's usually no problem, because the buffer is used repeatedly. But some platforms's (e.g. Windows) console might not accept input that exceeds it. And set an enough size.  \nNote that this might be limited by [version of Node.js](https://nodejs.org/api/buffer.html#buffer_class_method_buffer_alloc_size_fill_encoding) and environment running your script (Big buffer size is usually not required). (See also: [issue](https://github.com/nodejs/node/issues/4660), [PR](https://github.com/nodejs/node/pull/4682))\n\n### <a name=\"basic_options-print\"></a>`print`\n\n*Type:* function or `undefined`  \n*Default:* `undefined`\n\nCall the specified function with every output. The function is given two arguments, `display` as an output text, and a value of [`encoding`](#basic_options-encoding) option.\n\nFor example:\n\n* Pass the plain texts to the Logger (e.g. [log4js](https://github.com/nomiddlename/log4js-node)), after clean the colored texts.\n\n![sample](screen_01.png)\n\n```js\nvar readlineSync = require('readline-sync'),\n  chalk = require('chalk'),\n  log4js = require('log4js'),\n  logger, user, pw, command;\n\nlog4js.configure({appenders: [{type: 'file', filename: 'fooApp.log'}]});\nlogger = log4js.getLogger('fooApp');\n\nreadlineSync.setDefaultOptions({\n  print: function(display, encoding)\n    { logger.info(chalk.stripColor(display)); }, // Remove ctrl-chars.\n  prompt: chalk.red.bold('> ')\n});\n\nconsole.log(chalk.black.bold.bgYellow('    Your Account    '));\nuser = readlineSync.question(chalk.gray.underline(' USER NAME ') + ' : ');\npw = readlineSync.question(chalk.gray.underline(' PASSWORD  ') + ' : ',\n  {hideEchoBack: true});\n// Authorization ...\nconsole.log(chalk.green('Welcome, ' + user + '!'));\ncommand = readlineSync.prompt();\n```\n\n* Output a conversation to a file when an output stream is redirected to record those into a file like `your-script >foo.log`. That is, a conversation isn't outputted to `foo.log` without this code.\n\n```js\nreadlineSync.setDefaultOptions({\n  print: function(display, encoding)\n    { process.stdout.write(display, encoding); }\n});\nvar name = readlineSync.question('May I have your name? ');\nvar loc = readlineSync.question('Hi ' + name + '! Where do you live? ');\n```\n\n* Let somebody hear our conversation in real time.  \nIt just uses a fifo with above sample code that was named `conv.js`.\n\nAnother terminal:\n\n```console\nmkfifo /tmp/fifo\ncat /tmp/fifo\n```\n\nMy terminal:\n\n```console\nnode conv.js >/tmp/fifo\n```\n\n```console\nMay I have your name? Oz\nHi Oz! Where do you live? Emerald City\n```\n\nAnd then, another terminal shows this synchronously:\n\n```console\nMay I have your name? Oz\nHi Oz! Where do you live? Emerald City\n```\n\n### <a name=\"basic_options-history\"></a>`history`\n\n_For `question*` and `prompt*` methods only_  \n*Type:* boolean  \n*Default:* `true`\n\nreadlineSync supports a history expansion feature that is similar to that of the shell. If `false` is specified, disable this feature.  \n*It keeps a previous input only.* That is, only `!!`, `!-1`, `!!:p` and `!-1:p` like bash or zsh etc. are supported.\n\n* `!!` or `!-1`: Return a previous input.\n* `!!:p` or `!-1:p`: Display a previous input but do not return it, and wait for reinput.\n\nFor example:\n\n```js\nwhile (true) {\n  input = readlineSync.prompt();\n  console.log('-- You said \"' + input + '\"');\n}\n```\n\n```console\n> hello\n-- You said \"hello\"\n> !!\nhello\n-- You said \"hello\"\n> !!:p\nhello\n> bye\n-- You said \"bye\"\n```\n\n### <a name=\"basic_options-cd\"></a>`cd`\n\n_For `question*` and `prompt*` methods only_  \n*Type:* boolean  \n*Default:* `false`\n\nreadlineSync supports the changing the current working directory feature that is similar to the `cd` and `pwd` commands in the shell. If `true` is specified, enable this feature.  \nThis helps the user when you let the user input the multiple local files or directories.  \nIt supports `cd` and `pwd` commands.\n\n* `cd <path>`: Change the current working directory to `<path>`. The `<path>` can include `~` as the home directory.\n* `pwd`: Display the current working directory.\n\nWhen these were input, do not return, and wait for reinput.\n\nFor example:\n\n```js\nwhile (true) {\n  file = readlineSync.questionPath('File: ');\n  console.log('-- Specified file is ' + file);\n}\n```\n\n```console\nFile: cd foo-dir/bar-dir\nFile: pwd\n/path/to/foo-dir/bar-dir\nFile: file-a.js\n-- Specified file is /path/to/foo-dir/bar-dir/file-a.js\nFile: file-b.png\n-- Specified file is /path/to/foo-dir/bar-dir/file-b.png\nFile: file-c.html\n-- Specified file is /path/to/foo-dir/bar-dir/file-c.html\n```\n\n## <a name=\"utility_methods\"></a>Utility Methods\n\n[`questionEMail`](#utility_methods-questionemail), [`questionNewPassword`](#utility_methods-questionnewpassword), [`questionInt`](#utility_methods-questionint), [`questionFloat`](#utility_methods-questionfloat), [`questionPath`](#utility_methods-questionpath), [`promptCL`](#utility_methods-promptcl), [`promptLoop`](#utility_methods-promptloop), [`promptCLLoop`](#utility_methods-promptclloop), [`promptSimShell`](#utility_methods-promptsimshell), [`keyInYN`](#utility_methods-keyinyn), [`keyInYNStrict`](#utility_methods-keyinynstrict), [`keyInPause`](#utility_methods-keyinpause), [`keyInSelect`](#utility_methods-keyinselect)\n\nThese are convenient methods that are extended [Basic Methods](#basic_methods) to be used easily.\n\n### <a name=\"utility_methods-questionemail\"></a>`questionEMail`\n\n```js\nemail = readlineSync.questionEMail([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then accept only a valid e-mail address, and then return it after the Enter key was pressed.\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Input e-mail address: '`.\n\n**Note:** The valid e-mail address requirement is a willful violation of [RFC5322](http://tools.ietf.org/html/rfc5322), this is defined in [HTML5](http://www.w3.org/TR/html5/forms.html). This works enough to prevent the user mistaking. If you want to change it, specify [`limit`](#basic_options-limit) option.\n\nFor example:\n\n```js\nemail = readlineSync.questionEMail();\nconsole.log('-- E-mail is ' + email);\n```\n\n```console\nInput e-mail address: abc\nInput valid e-mail address, please.\nInput e-mail address: mail@example.com\n-- E-mail is mail@example.com\n```\n\n#### <a name=\"utility_methods-questionemail-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n| [`limit`](#basic_options-limit) | RegExp by [HTML5](http://www.w3.org/TR/html5/forms.html) |\n| [`limitMessage`](#basic_options-limitmessage) | `'Input valid e-mail address, please.'` |\n| [`trueValue`](#basic_options-truevalue_falsevalue) | `null` |\n| [`falseValue`](#basic_options-truevalue_falsevalue) | `null` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-casesensitive\"><code>caseSensitive</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td></tr>\n<tr><td><a href=\"#basic_options-print\"><code>print</code></a></td><td><a href=\"#basic_options-history\"><code>history</code></a></td></tr>\n</table>\n\n### <a name=\"utility_methods-questionnewpassword\"></a>`questionNewPassword`\n\n```js\npassword = readlineSync.questionNewPassword([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then accept only a valid password, and then request same one again, and then return it after the Enter key was pressed.  \nIt's the password, or something that is the secret text like the password.  \nYou can specify the valid password requirement to the options.\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Input new password: '`.\n\n**Note:** Only the form of password is checked. Check it more if you want. For example, [zxcvbn](https://github.com/dropbox/zxcvbn) is password strength estimation library.\n\nFor example:\n\n```js\npassword = readlineSync.questionNewPassword();\nconsole.log('-- Password is ' + password);\n```\n\n```console\nInput new password: ************\nIt can include: 0...9, A...Z, a...z, !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\nAnd the length must be: 12...24\nInput new password: *************\nReinput a same one to confirm it: *************\nIt differs from first one. Hit only the Enter key if you want to retry from first one.\nReinput a same one to confirm it: *************\n-- Password is _my_password_\n```\n\n#### <a name=\"utility_methods-questionnewpassword-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `true` |\n| [`mask`](#basic_options-mask) | `'*'` |\n| [`limitMessage`](#basic_options-limitmessage) | `'It can include: $<charlist>\\nAnd the length must be: $<length>'` |\n| [`trueValue`](#basic_options-truevalue_falsevalue) | `null` |\n| [`falseValue`](#basic_options-truevalue_falsevalue) | `null` |\n| [`caseSensitive`](#basic_options-casesensitive) | `true` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-keepwhitespace\"><code>keepWhitespace</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td><td><a href=\"#basic_options-print\"><code>print</code></a></td></tr>\n</table>\n\nAnd the following additional options are available.\n\n##### <a name=\"utility_methods-questionnewpassword-options-charlist\"></a>`charlist`\n\n*Type:* string  \n*Default:* `'$<!-~>'`\n\nA string as the characters that can be included in the password. For example, if `'abc123'` is specified, the passwords that include any character other than these 6 characters are refused.  \nThe [placeholders](#placeholders) like `'$<a-e>'` are replaced to the characters like `'abcde'`.  \n\nFor example, let the user input a password that is created with alphabet and some symbols:\n\n```js\npassword = readlineSync.questionNewPassword('PASSWORD: ', {charlist: '$<a-z>#$@%'});\n```\n\n##### <a name=\"utility_methods-questionnewpassword-options-min_max\"></a>`min`, `max`\n\n*Type:* number  \n*Default:* `min`: `12`, `max`: `24`\n\n`min`: A number as a minimum length of the password.  \n`max`: A number as a maximum length of the password.\n\n##### <a name=\"utility_methods-questionnewpassword-options-confirmmessage\"></a>`confirmMessage`\n\n*Type:* string or others  \n*Default:* `'Reinput a same one to confirm it: '`\n\nA message that lets the user input the same password again.  \nIt can include the [placeholders](#placeholders).  \nIf this is not string, it is converted to string (i.e. `toString` method is called).\n\n##### <a name=\"utility_methods-questionnewpassword-options-unmatchmessage\"></a>`unmatchMessage`\n\n*Type:* string or others  \n*Default:* `'It differs from first one. Hit only the Enter key if you want to retry from first one.'`\n\nA warning message that is displayed when the second input did not match first one.  \nThis is converted the same as the [`confirmMessage`](#utility_methods-questionnewpassword-options-confirmmessage) option.\n\n#### <a name=\"utility_methods-questionnewpassword-additional_placeholders\"></a>Additional Placeholders\n\nThe following additional [placeholder](#placeholders) parameters are available.\n\n##### <a name=\"utility_methods-questionnewpassword-additional_placeholders-charlist\"></a>`charlist`\n\nA current value of [`charlist`](#utility_methods-questionnewpassword-options-charlist) option that is converted to human readable if possible. (e.g. `'A...Z'`)\n\n##### <a name=\"utility_methods-questionnewpassword-additional_placeholders-length\"></a>`length`\n\nA current value of [`min` and `max`](#utility_methods-questionnewpassword-options-min_max) option that is converted to human readable. (e.g. `'12...24'`)\n\n### <a name=\"utility_methods-questionint\"></a>`questionInt`\n\n```js\nnumInt = readlineSync.questionInt([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then accept only an input that can be interpreted as an integer, and then return the number (not string) after the Enter key was pressed.  \nThis parses the input as much as possible by `parseInt()`. For example, it interprets `'   5   '`, `'5.6'`, `'005'`, `'5files'`, `'5kb'` and `'5px'` as `5`.\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.\n\n#### <a name=\"utility_methods-questionint-options\"></a>Options\n\nThe following option has independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`limitMessage`](#basic_options-limitmessage) | `'Input valid number, please.'` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-hideechoback\"><code>hideEchoBack</code></a></td><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td></tr>\n<tr><td><a href=\"#basic_options-print\"><code>print</code></a></td><td><a href=\"#basic_options-history\"><code>history</code></a></td></tr>\n</table>\n\n### <a name=\"utility_methods-questionfloat\"></a>`questionFloat`\n\n```js\nnumFloat = readlineSync.questionFloat([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then accept only an input that can be interpreted as a floating-point number, and then return the number (not string) after the Enter key was pressed.  \nThis parses the input as much as possible by `parseFloat()`. For example, it interprets `'   3.14   '`, `'003.1400'`, `'314e-2'` and `'3.14PI'` as `3.14`.\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.\n\n#### <a name=\"utility_methods-questionfloat-options\"></a>Options\n\nThe following option has independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`limitMessage`](#basic_options-limitmessage) | `'Input valid number, please.'` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-hideechoback\"><code>hideEchoBack</code></a></td><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td></tr>\n<tr><td><a href=\"#basic_options-print\"><code>print</code></a></td><td><a href=\"#basic_options-history\"><code>history</code></a></td></tr>\n</table>\n\n### <a name=\"utility_methods-questionpath\"></a>`questionPath`\n\n```js\npath = readlineSync.questionPath([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then accept only a valid local file or directory path, and then return an absolute path after the Enter key was pressed.  \nThe `~` that is input by the user is replaced to the home directory.  \nYou can specify the valid local file or directory path requirement to the options. And you can make it create a new file or directory when it doesn't exist.  \n\nIt is recommended to use this method with the [`cd`](#basic_options-cd) option. (Default: `true`)\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Input path (you can \"cd\" and \"pwd\"): '`.\n\nFor example:\n\n```js\nsourceFile = readlineSync.questionPath('Read from: ', {\n  isFile: true\n});\nconsole.log('-- sourceFile: ' + sourceFile);\n\nsaveDir = readlineSync.questionPath('Save to: ', {\n  isDirectory: true,\n  exists: null,\n  create: true\n});\nconsole.log('-- saveDir: ' + saveDir);\n```\n\n```console\nRead from: ~/fileA\nNo such file or directory: /home/user/fileA\nInput valid path, please.\nRead from: pwd\n/path/to/work\nRead from: cd ~/project-1\nRead from: fileA\n-- sourceFile: /home/user/project-1/fileA\nSave to: ~/deploy/data\n-- saveDir: /home/user/deploy/data\n```\n\n#### <a name=\"utility_methods-questionpath-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n| [`limitMessage`](#basic_options-limitmessage) | `'$<error(\\n)>Input valid path, please.$<( Min:)min>$<( Max:)max>'` |\n| [`history`](#basic_options-history) | `true` |\n| [`cd`](#basic_options-cd) | `true` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td><td><a href=\"#basic_options-print\"><code>print</code></a></td></tr>\n</table>\n\nAnd the following additional options are available.\n\n**Note:** It does not check the coherency about a combination of the options as the path requirement. For example, the `{exists: false, isFile: true}` never check that it is a file because it is limited to the path that does not exist.\n\n##### <a name=\"utility_methods-questionpath-options-exists\"></a>`exists`\n\n*Type:* boolean or others  \n*Default:* `true`\n\nIf `true` is specified, accept only a file or directory path that exists. If `false` is specified, accept only a file or directory path that does *not* exist.  \nIn any other case, the existence is not checked.\n\n##### <a name=\"utility_methods-questionpath-options-min_max\"></a>`min`, `max`\n\n*Type:* number or others  \n*Default:* `undefined`\n\n`min`: A number as a minimum size of the file that is accepted.  \n`max`: A number as a maximum size of the file that is accepted.  \nIf it is not specified or `0` is specified, the size is not checked. (A size of directory is `0`.)\n\n##### <a name=\"utility_methods-questionpath-options-isfile_isdirectory\"></a>`isFile`, `isDirectory`\n\n*Type:* boolean  \n*Default:* `false`\n\n`isFile`: If `true` is specified, accept only a file path.  \n`isDirectory`: If `true` is specified, accept only a directory path.\n\n##### <a name=\"utility_methods-questionpath-options-validate\"></a>`validate`\n\n*Type:* function or `undefined`  \n*Default:* `undefined`\n\nIf a function that returns `true` or an error message is specified, call it with a path that was input, and accept the input when the function returned `true`.  \nIf the function returned a string as an error message, that message is got by the [`error`](#utility_methods-questionpath-additional_placeholders-error) additional [placeholder](#placeholders) parameter.  \nA path that was input is parsed before it is passed to the function. `~` is replaced to a home directory, and a path is converted to an absolute path.  \nThis is also a return value from this method.\n\nFor example, accept only PNG file or tell it to the user:\n\n```js\nimageFile = readlineSync.questionPath('Image File: ', {\n  validate: function(path) { return /\\.png$/i.test(path) || 'It is not PNG'; }\n});\n```\n\n##### <a name=\"utility_methods-questionpath-options-create\"></a>`create`\n\n*Type:* boolean  \n*Default:* `false`\n\nIf `true` is specified, create a file or directory as a path that was input when it doesn't exist. If `true` is specified to the [`isDirectory`](#utility_methods-questionpath-options-isfile_isdirectory) option, create a directory, otherwise a file.  \nIt does not affect the existence check. Therefore, you can get a new file or directory path anytime by specifying: `{exists: false, create: true}`\n\n#### <a name=\"utility_methods-questionpath-additional_placeholders\"></a>Additional Placeholders\n\nThe following additional [placeholder](#placeholders) parameters are available.\n\n##### <a name=\"utility_methods-questionpath-additional_placeholders-error\"></a>`error`\n\nAn error message when the input was not accepted.  \nThis value is set by readlineSync, or the function that was specified to [`validate`](#utility_methods-questionpath-options-validate) option.\n\n##### <a name=\"utility_methods-questionpath-additional_placeholders-min_max\"></a>`min`, `max`\n\nA current value of [`min` and `max`](#utility_methods-questionpath-options-min_max) option.\n\n### <a name=\"utility_methods-promptcl\"></a>`promptCL`\n\n```js\nargsArray = readlineSync.promptCL([commandHandler[, options]])\n```\n\nDisplay a prompt-sign (see [`prompt`](#basic_options-prompt) option) to the user, and then consider the input as a command-line and parse it, and then return a result after the Enter key was pressed.  \nA return value is an Array that includes the tokens that were parsed. It parses the input from the user as the command-line, and it interprets whitespaces, quotes, etc., and it splits it to tokens properly. Usually, a first element of the Array is command-name, and remaining elements are arguments.\n\nFor example:\n\n```js\nargsArray = readlineSync.promptCL();\nconsole.log(argsArray.join('\\n'));\n```\n\n```console\n> command arg \"arg\" \" a r g \" \"\" 'a\"r\"g' \"a\"\"rg\" \"arg\ncommand\narg\narg\n a r g \n\na\"r\"g\narg\narg\n```\n\n#### <a name=\"utility_methods-promptcl-commandhandler\"></a>`commandHandler`\n\nBy using the `commandHandler` argument, this method will come into its own. Specifying the Object to this argument has the more merit. And it has the more merit for [`promptCLLoop`](#utility_methods-promptclloop) method.  \n\nIf a function is specified to `commandHandler` argument, it is just called with a parsed Array as an argument list of the function. And `this` is an original input string, in the function.\n\nFor example, the following 2 codes work same except that `this` is enabled in the second one:\n\n```js\nargsArray = readlineSync.promptCL();\nif (argsArray[0] === 'add') {\n  console.log(argsArray[1] + ' is added.');\n} else if (argsArray[0] === 'copy') {\n  console.log(argsArray[1] + ' is copied to ' + argsArray[2] + '.');\n}\n```\n\n```js\nreadlineSync.promptCL(function(command, arg1, arg2) {\n  console.log('You want to: ' + this); // All of command-line.\n  if (command === 'add') {\n    console.log(arg1 + ' is added.');\n  } else if (command === 'copy') {\n    console.log(arg1 + ' is copied to ' + arg2 + '.');\n  }\n});\n```\n\nIf an Object that has properties named as the command-name is specified, the command-name is interpreted, and a function as the value of matched property is called. A function is chosen properly by handling case of the command-name in accordance with the [`caseSensitive`](#basic_options-casesensitive) option.  \nThe function is called with a parsed Array that excludes a command-name (i.e. first element is removed from the Array) as an argument list of the function.  \nThat is, a structure of the `commandHandler` Object looks like:\n\n```js\n{\n  commandA: function(arg) { ... },        // commandA requires one argument.\n  commandB: function(arg1, arg2) { ... }, // readlineSync doesn't care those.\n  commandC: function() { ... }            // Of course, it can also ignore all.\n}\n```\n\nreadlineSync just receives the arguments from the user and passes those to these functions without checking. The functions may have to check whether the required argument was input by the user, and more validate those.\n\nFor example, the following code works same to the above code:\n\n```js\nreadlineSync.promptCL({\n  add: function(element) { // It's called by also \"ADD\", \"Add\", \"aDd\", etc..\n    console.log(element + ' is added.');\n  },\n  copy: function(from, to) {\n    console.log(from + ' is copied to ' + to + '.');\n  }\n});\n```\n\nIf the matched property is not found in the Object, a `_` property is chosen, and the function as the value of this property is called with a parsed Array as an argument list of the function. Note that this includes a command-name. That is, the function looks like `function(command, arg1, arg2, ...) { ... }`.  \nAnd if the Object doesn't have a `_` property, any command that the matched property is not found in the Object is refused.\n\nFor example:\n\n```js\nreadlineSync.promptCL({\n  copy: function(from, to) { // command-name is not included.\n    console.log(from + ' is copied to ' + to + '.');\n  },\n  _: function(command) { // command-name is included.\n    console.log('Sorry, ' + command + ' is not available.');\n  }\n});\n```\n\n#### <a name=\"utility_methods-promptcl-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n| [`limitMessage`](#basic_options-limitmessage) | `'Requested command is not available.'` |\n| [`caseSensitive`](#basic_options-casesensitive) | `false` |\n| [`history`](#basic_options-history) | `true` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-prompt\"><code>prompt</code></a></td><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td></tr>\n<tr><td><a href=\"#basic_options-print\"><code>print</code></a></td><td><a href=\"#basic_options-cd\"><code>cd</code></a></td></tr>\n</table>\n\n### <a name=\"utility_methods-promptloop\"></a>`promptLoop`\n\n```js\nreadlineSync.promptLoop(inputHandler[, options])\n```\n\nDisplay a prompt-sign (see [`prompt`](#basic_options-prompt) option) to the user, and then call `inputHandler` function with the input from the user after it has been typed and the Enter key was pressed. Do these repeatedly until `inputHandler` function returns `true`.\n\nFor example, the following 2 codes work same:\n\n```js\nwhile (true) {\n  input = readlineSync.prompt();\n  console.log('-- You said \"' + input + '\"');\n  if (input === 'bye') {\n    break;\n  }\n}\nconsole.log('It\\'s exited from loop.');\n```\n\n```js\nreadlineSync.promptLoop(function(input) {\n  console.log('-- You said \"' + input + '\"');\n  return input === 'bye';\n});\nconsole.log('It\\'s exited from loop.');\n```\n\n```console\n> hello\n-- You said \"hello\"\n> good morning\n-- You said \"good morning\"\n> bye\n-- You said \"bye\"\nIt's exited from loop.\n```\n\n#### <a name=\"utility_methods-promptloop-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n| [`trueValue`](#basic_options-truevalue_falsevalue) | `null` |\n| [`falseValue`](#basic_options-truevalue_falsevalue) | `null` |\n| [`caseSensitive`](#basic_options-casesensitive) | `false` |\n| [`history`](#basic_options-history) | `true` |\n\nThe other options work as shown in the [Basic Options](#basic_options) section.\n\n### <a name=\"utility_methods-promptclloop\"></a>`promptCLLoop`\n\n```js\nreadlineSync.promptCLLoop([commandHandler[, options]])\n```\n\nExecute [`promptCL`](#utility_methods-promptcl) method repeatedly until chosen [`commandHandler`](#utility_methods-promptcl-commandhandler) returns `true`.  \nThe [`commandHandler`](#utility_methods-promptcl-commandhandler) may be a function that is called like:\n\n```js\nexit = allCommands(command, arg1, arg2, ...);\n```\n\nor an Object that has the functions that are called like:\n\n```js\nexit = foundCommand(arg1, arg2, ...);\n```\n\nSee [`promptCL`](#utility_methods-promptcl) method for details.  \nThis method looks like a combination of [`promptCL`](#utility_methods-promptcl) method and [`promptLoop`](#utility_methods-promptloop) method.\n\nFor example:\n\n```js\nreadlineSync.promptCLLoop({\n  add: function(element) {\n    console.log(element + ' is added.');\n  },\n  copy: function(from, to) {\n    console.log(from + ' is copied to ' + to + '.');\n  },\n  bye: function() { return true; }\n});\nconsole.log('It\\'s exited from loop.');\n```\n\n```console\n> add \"New Hard Disk\"\nNew Hard Disk is added.\n> move filesOnOld \"New Hard Disk\"\nRequested command is not available.\n> copy filesOnOld \"New Hard Disk\"\nfilesOnOld is copied to New Hard Disk.\n> bye\nIt's exited from loop.\n```\n\n#### <a name=\"utility_methods-promptclloop-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n| [`limitMessage`](#basic_options-limitmessage) | `'Requested command is not available.'` |\n| [`caseSensitive`](#basic_options-casesensitive) | `false` |\n| [`history`](#basic_options-history) | `true` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-prompt\"><code>prompt</code></a></td><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-defaultinput\"><code>defaultInput</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-buffersize\"><code>bufferSize</code></a></td></tr>\n<tr><td><a href=\"#basic_options-print\"><code>print</code></a></td><td><a href=\"#basic_options-cd\"><code>cd</code></a></td></tr>\n</table>\n\n### <a name=\"utility_methods-promptsimshell\"></a>`promptSimShell`\n\n```js\ninput = readlineSync.promptSimShell([options])\n```\n\nDisplay a prompt-sign that is similar to that of the user's shell to the user, and then return the input from the user after it has been typed and the Enter key was pressed.  \nThis method displays a prompt-sign like:\n\nOn Windows:\n\n```console\nC:\\Users\\User\\Path\\To\\Directory>\n```\n\nOn others:\n\n```console\nuser@host:~/path/to/directory$ \n```\n\n#### <a name=\"utility_methods-promptsimshell-options\"></a>Options\n\nThe following options have independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n| [`history`](#basic_options-history) | `true` |\n\nThe other options other than [`prompt`](#basic_options-prompt) option work as shown in the [Basic Options](#basic_options) section.\n\n### <a name=\"utility_methods-keyinyn\"></a>`keyInYN`\n\n```js\nboolYesOrEmpty = readlineSync.keyInYN([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then return a boolean or an empty string immediately a key was pressed by the user, **without pressing the Enter key**. Note that the user has no chance to change the input.  \nThis method works like the `window.confirm` method of web browsers. A return value means \"Yes\" or \"No\" the user said. It differ depending on the pressed key:\n\n* `Y`: `true`\n* `N`: `false`\n* other: `''`\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Are you sure? '`.\n\nThe keys other than `Y` and `N` are also accepted (If you want to know a user's wish explicitly, use [`keyInYNStrict`](#utility_methods-keyinynstrict) method). Therefore, if you let the user make an important decision (e.g. files are removed), check whether the return value is not *falsy*. That is, a default is \"No\".\n\nFor example:\n\n```js\nif (!readlineSync.keyInYN('Do you want to install this?')) {\n  // Key that is not `Y` was pressed.\n  process.exit();\n}\n// Do something...\n```\n\nOr if you let the user stop something that must be done (e.g. something about the security), check whether the return value is `false` explicitly. That is, a default is \"Yes\".\n\nFor example:\n\n```js\n// Don't use `(!readlineSync.keyInYN())`.\nif (readlineSync.keyInYN('Continue virus scan?') === false) {\n  // `N` key was pressed.\n  process.exit();\n}\n// Continue...\n```\n\n#### <a name=\"utility_methods-keyinyn-options\"></a>Options\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-print\"><code>print</code></a></td></tr>\n</table>\n\nAnd the following additional option is available.\n\n##### <a name=\"utility_methods-keyinyn-options-guide\"></a>`guide`\n\n*Type:* boolean  \n*Default:* `true`\n\nIf `true` is specified, a string `'[y/n]'` as guide for the user is added to `query`. And `':'` is moved to the end of `query`, or it is added.\n\nFor example:\n\n```js\nreadlineSync.keyInYN('Do you like me?'); // No colon\nreadlineSync.keyInYN('Really? :'); // Colon already exists\n```\n\n```console\nDo you like me? [y/n]: y\nReally? [y/n]: y\n```\n\n### <a name=\"utility_methods-keyinynstrict\"></a>`keyInYNStrict`\n\n```js\nboolYes = readlineSync.keyInYNStrict([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then accept only `Y` or `N` key, and then return a boolean immediately it was pressed by the user, **without pressing the Enter key**. Note that the user has no chance to change the input.  \nThis method works like the `window.confirm` method of web browsers. A return value means \"Yes\" or \"No\" the user said. It differ depending on the pressed key:\n\n* `Y`: `true`\n* `N`: `false`\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Are you sure? '`.\n\nA key other than `Y` and `N` is not accepted. That is, a return value has no default. Therefore, the user has to tell an own wish explicitly. If you want to know a user's wish easily, use [`keyInYN`](#utility_methods-keyinyn) method.\n\nThis method works same to [`keyInYN`](#utility_methods-keyinyn) method except that this accept only `Y` or `N` key (Therefore, a return value is boolean every time). The options also work same to [`keyInYN`](#utility_methods-keyinyn) method.\n\n### <a name=\"utility_methods-keyinpause\"></a>`keyInPause`\n\n```js\nreadlineSync.keyInPause([query[, options]])\n```\n\nDisplay a `query` to the user if it's specified, and then just wait for a key to be pressed by the user.  \nThis method works like the `window.alert` method of web browsers. This is used to make the running of script pause and show something to the user, or wait for the user to be ready.  \nBy default, any key is accepted (See: [Note](#utility_methods-keyinpause-note)). You can change this behavior by specifying [`limit`](#basic_options-limit) option  (e.g. accept only a Space Bar).\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Continue...'`.\n\nFor example:\n\n```js\n// Have made the preparations for something...\nconsole.log('==== Information of Your Computer ====');\nconsole.log(info); // This can be `query`.\nreadlineSync.keyInPause();\nconsole.log('It\\'s executing now...');\n// Do something...\n```\n\n```console\n==== Information of Your Computer ====\nFOO: 123456\nBAR: abcdef\nContinue... (Hit any key)\nIt's executing now...\n```\n\n#### <a name=\"utility_methods-keyinpause-options\"></a>Options\n\nThe following option has independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`limit`](#basic_options-limit) | `null` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-casesensitive\"><code>caseSensitive</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-print\"><code>print</code></a></td></tr>\n</table>\n\nAnd the following additional option is available.\n\n##### <a name=\"utility_methods-keyinpause-options-guide\"></a>`guide`\n\n*Type:* boolean  \n*Default:* `true`\n\nIf `true` is specified, a string `'(Hit any key)'` as guide for the user is added to `query`.\n\nFor example:\n\n```js\nreadlineSync.keyInPause('It\\'s pausing now...');\n```\n\n```console\nIt's pausing now... (Hit any key)\n```\n\n#### <a name=\"utility_methods-keyinpause-note\"></a>Note\n\nControl keys including Enter key are not accepted by `keyIn*` methods.  \nIf you want to wait until the user presses Enter key, use `question*` methods instead of `keyIn*` methods. For example:\n\n```js\nreadlineSync.question('Hit Enter key to continue.', {hideEchoBack: true, mask: ''});\n```\n\n### <a name=\"utility_methods-keyinselect\"></a>`keyInSelect`\n\n```js\nindex = readlineSync.keyInSelect(items[, query[, options]])\n```\n\nDisplay the list that was created with the `items` Array, and the `query` to the user if it's specified, and then return the number as an index of the `items` Array immediately it was chosen by pressing a key by the user, **without pressing the Enter key**. Note that the user has no chance to change the input.\n\nThe `query` is handled the same as that of the [`question`](#basic_methods-question) method.  \nThe default value of `query` is `'Choose one from list: '`.\n\nThe minimum length of `items` Array is 1 and maximum length is 35. These elements are displayed as item list. A key to let the user choose an item is assigned to each item automatically in sequence like \"1, 2, 3 ... 9, A, B, C ...\". A number as an index of the `items` Array that corresponds to a chosen item by the user is returned.\n\n**Note:** Even if the `items` Array has only less than 35 items, a long Array that forces an user to scroll the list may irritate the user. Remember, the user might be in a console environment that doesn't support scrolling the screen. If you want to use a long `items` Array (e.g. more than 10 items), you should consider a \"Pagination\". (See [example](https://github.com/anseki/readline-sync/issues/60#issuecomment-324533678).)\n\nFor example:\n\n```js\nframeworks = ['Express', 'hapi', 'flatiron', 'MEAN.JS', 'locomotive'];\nindex = readlineSync.keyInSelect(frameworks, 'Which framework?');\nconsole.log(frameworks[index] + ' is enabled.');\n```\n\n```console\n[1] Express\n[2] hapi\n[3] flatiron\n[4] MEAN.JS\n[5] locomotive\n[0] CANCEL\n\nWhich framework? [1...5 / 0]: 2\nhapi is enabled.\n```\n\n#### <a name=\"utility_methods-keyinselect-options\"></a>Options\n\nThe following option has independent default value that is not affected by [Default Options](#basic_options).\n\n| Option Name       | Default Value |\n|-------------------|---------------|\n| [`hideEchoBack`](#basic_options-hideechoback) | `false` |\n\nThe following options work as shown in the [Basic Options](#basic_options) section.\n\n<table>\n<tr><td><a href=\"#basic_options-mask\"><code>mask</code></a></td><td><a href=\"#basic_options-encoding\"><code>encoding</code></a></td><td><a href=\"#basic_options-print\"><code>print</code></a></td></tr>\n</table>\n\nAnd the following additional options are available.\n\n##### <a name=\"utility_methods-keyinselect-options-guide\"></a>`guide`\n\n*Type:* boolean  \n*Default:* `true`\n\nIf `true` is specified, a string like `'[1...5]'` as guide for the user is added to `query`. And `':'` is moved to the end of `query`, or it is added. This is the key list that corresponds to the item list.\n\n##### <a name=\"utility_methods-keyinselect-options-cancel\"></a>`cancel`\n\n*Type:* boolean, string or others  \n*Default:* `'CANCEL'`\n\nIf a value other than `false` is specified, an item to let the user tell \"cancel\" is added to the item list. \"[0] CANCEL\" (default) is displayed, and if `0` key is pressed, `-1` is returned.  \nYou can specify a label of this item other than `'CANCEL'`. A string such as `'Go back'` (empty string `''` also), something that is converted to string such as `Date`, a string that includes [placeholder](#placeholders) such as `'Next $<itemsCount> items'` are accepted.\n\n#### <a name=\"utility_methods-keyinselect-additional_placeholders\"></a>Additional Placeholders\n\nThe following additional [placeholder](#placeholders) parameters are available.\n\n##### <a name=\"utility_methods-keyinselect-additional_placeholders-itemscount\"></a>`itemsCount`\n\nA length of a current `items` Array.\n\nFor example:\n\n```js\nitems = ['item-A', 'item-B', 'item-C', 'item-D', 'item-E'];\nindex = readlineSync.keyInSelect(items, null,\n  {cancel: 'Show more than $<itemsCount> items'});\n```\n\n```console\n[1] item-A\n[2] item-B\n[3] item-C\n[4] item-D\n[5] item-E\n[0] Show more than 5 items\n```\n\n##### <a name=\"utility_methods-keyinselect-additional_placeholders-firstitem\"></a>`firstItem`\n\nA first item in a current `items` Array.\n\nFor example:\n\n```js\nindex = readlineSync.keyInSelect(items, 'Choose $<firstItem> or another: ');\n```\n\n##### <a name=\"utility_methods-keyinselect-additional_placeholders-lastitem\"></a>`lastItem`\n\nA last item in a current `items` Array.\n\nFor example:\n\n```js\nitems = ['January', 'February', 'March', 'April', 'May', 'June'];\nindex = readlineSync.keyInSelect(items, null,\n  {cancel: 'In after $<lastItem>'});\n```\n\n```console\n[1] January\n[2] February\n[3] March\n[4] April\n[5] May\n[6] June\n[0] In after June\n```\n\n## <a name=\"placeholders\"></a>Placeholders\n\n[`hideEchoBack`, `mask`, `defaultInput`, `caseSensitive`, `keepWhitespace`, `encoding`, `bufferSize`, `history`, `cd`, `limit`, `trueValue`, `falseValue`](#placeholders-parameters-hideechoback_mask_defaultinput_casesensitive_keepwhitespace_encoding_buffersize_history_cd_limit_truevalue_falsevalue), [`limitCount`, `limitCountNotZero`](#placeholders-parameters-limitcount_limitcountnotzero), [`lastInput`](#placeholders-parameters-lastinput), [`history_mN`](#placeholders-parameters-historymn), [`cwd`, `CWD`, `cwdHome`](#placeholders-parameters-cwd_cwd_cwdhome), [`date`, `time`, `localeDate`, `localeTime`](#placeholders-parameters-date_time_localedate_localetime), [`C1-C2`](#placeholders-parameters-c1_c2)\n\nThe placeholders in the text are replaced to another string.\n\nFor example, the [`limitMessage`](#basic_options-limitmessage) option to display a warning message that means that the command the user requested is not available:\n\n```js\ncommand = readlineSync.prompt({\n  limit: ['add', 'remove'],\n  limitMessage: '$<lastInput> is not available.'\n});\n```\n\n```console\n> delete\ndelete is not available.\n```\n\nThe placeholders can be included in:\n\n* `query` argument\n* [`prompt`](#basic_options-prompt) and [`limitMessage`](#basic_options-limitmessage) options\n* [`limit` option for `keyIn*` method](#basic_options-limit-for_keyin_method) and [`charlist`](#utility_methods-questionnewpassword-options-charlist) option for [`questionNewPassword`](#utility_methods-questionnewpassword) method ([`C1-C2`](#placeholders-parameters-c1_c2) parameter only)\n* And some additional options for the [Utility Methods](#utility_methods).\n\n### <a name=\"placeholders-syntax\"></a>Syntax\n\n```\n$<parameter>\n```\n\nOr\n\n```\n$<(text1)parameter(text2)>\n```\n\nThe placeholder is replaced to a string that is got by a `parameter`.  \nBoth the `(text1)` and `(text2)` are optional.  \nA more added `'$'` at the left of the placeholder is used as an escape character, it disables a placeholder. For example, `'$$<foo>'` is replaced to `'$<foo>'`. If you want to put a `'$'` which is *not* an escape character at the left of a placeholder, specify it like `'$<($)bufferSize>'`, then it is replaced to `'$1024'`.\n\nAt the each position of `'(text1)'` and `'(text2)'`, `'text1'` and `'text2'` are put when a string that was got by a `parameter` has more than 0 length. If that got string is `''`, a placeholder with or without `'(text1)'` and `'(text2)'` is replaced to `''`.\n\nFor example, a warning message that means that the command the user requested is not available:\n\n```js\ncommand = readlineSync.prompt({\n  limit: ['add', 'remove'],\n  limitMessage: 'Refused $<lastInput> you requested. Please input another.'\n});\n```\n\n```console\n> give-me-car\nRefused give-me-car you requested. Please input another.\n```\n\nIt looks like no problem.  \nBut when the user input nothing (hit only the Enter key), and then a message is displayed:\n\n```console\n> \nRefused  you requested. Please input another.\n```\n\nThis goes well:\n\n```js\ncommand = readlineSync.prompt({\n  limit: ['add', 'remove'],\n  limitMessage: 'Refused $<lastInput( you requested)>. Please input another.'\n});\n```\n\n```console\n> \nRefused . Please input another.\n```\n\n(May be more better: `'$<(Refused )lastInput( you requested. )>Please input another.'`)\n\n**Note:** The syntax `${parameter}` of older version is still supported, but this should not be used because it may be confused with template string syntax of ES6. And this will not be supported in due course of time.\n\n### <a name=\"placeholders-parameters\"></a>Parameters\n\nThe following parameters are available. And some additional parameters are available in the [Utility Methods](#utility_methods).\n\n#### <a name=\"placeholders-parameters-hideechoback_mask_defaultinput_casesensitive_keepwhitespace_encoding_buffersize_history_cd_limit_truevalue_falsevalue\"></a>`hideEchoBack`, `mask`, `defaultInput`, `caseSensitive`, `keepWhitespace`, `encoding`, `bufferSize`, `history`, `cd`, `limit`, `trueValue`, `falseValue`\n\nA current value of each option.  \nIt is converted to human readable if possible. The boolean value is replaced to `'on'` or `'off'`, and the Array is replaced to the list of only string and number elements.  \nAnd in the `keyIn*` method, the parts of the list as characters sequence are suppressed. For example, when `['a', 'b', 'c', 'd', 'e']` is specified to the [`limit`](#basic_options-limit) option, `'$<limit>'` is replaced to `'a...e'`. If `true` is specified to the [`caseSensitive`](#basic_options-casesensitive) option, the characters are converted to lower case.\n\nFor example:\n\n```js\ninput = readlineSync.question(\n  'Input something or the Enter key as \"$<defaultInput>\": ',\n  {defaultInput: 'hello'}\n);\n```\n\n```console\nInput something or the Enter key as \"hello\":\n```\n\n#### <a name=\"placeholders-parameters-limitcount_limitcountnotzero\"></a>`limitCount`, `limitCountNotZero`\n\nA length of a current value of the [`limit`](#basic_options-limit) option.  \nWhen the value of the [`limit`](#basic_options-limit) option is empty, `'$<limitCount>'` is replaced to `'0'`, `'$<limitCountNotZero>'` is replaced to `''`.\n\nFor example:\n\n```js\naction = readlineSync.question(\n  'Choose action$<( from )limitCountNotZero( actions)>: ',\n  {limit: availableActions}\n);\n```\n\n```console\nChoose action from 5 actions:\n```\n\n#### <a name=\"placeholders-parameters-lastinput\"></a>`lastInput`\n\nA last input from the user.  \nIn any case, this is saved.\n\nFor example:\n\n```js\ncommand = readlineSync.prompt({\n  limit: availableCommands,\n  limitMessage: '$<lastInput> is not available.'\n});\n```\n\n```console\n> wrong-command\nwrong-command is not available.\n```\n\n#### <a name=\"placeholders-parameters-historymn\"></a>`history_mN`\n\nWhen the history expansion feature is enabled (see [`history`](#basic_opt",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{66/80/6aa0e69649f449fb0e7f3c46e4ff069bbcd68d4b283aa7c95f417026ce2aad9c49f75180cdf94d3016fe97a4ddb2873f7e921f2a9fc185fd20801c407b0d → bd/7f/e0bff0266845406eb8b4863698a743f3d0634783e21db567c4f9ac90b169b61ad9e071e768ac1ff738ecf04fb98bf823f9572843a460438ecd6c4e0b94cf}

@@ -1251,7 +1251,7 @@
   "dist-tags": {
     "latest": "1.2.1"
   },
-  "_rev": "2503-02a13672ecc561dd",
+  "_rev": "2506-fc368f4628cb0cc2",
   "_id": "ieee754",
   "readme": "# ieee754 [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]\n\n[travis-image]: https://img.shields.io/travis/feross/ieee754/master.svg\n[travis-url]: https://travis-ci.org/feross/ieee754\n[npm-image]: https://img.shields.io/npm/v/ieee754.svg\n[npm-url]: https://npmjs.org/package/ieee754\n[downloads-image]: https://img.shields.io/npm/dm/ieee754.svg\n[downloads-url]: https://npmjs.org/package/ieee754\n[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg\n[standard-url]: https://standardjs.com\n\n[![saucelabs][saucelabs-image]][saucelabs-url]\n\n[saucelabs-image]: https://saucelabs.com/browser-matrix/ieee754.svg\n[saucelabs-url]: https://saucelabs.com/u/ieee754\n\n### Read/write IEEE754 floating point numbers from/to a Buffer or array-like object.\n\n## install\n\n```\nnpm install ieee754\n```\n\n## methods\n\n`var ieee754 = require('ieee754')`\n\nThe `ieee754` object has the following functions:\n\n```\nieee754.read = function (buffer, offset, isLE, mLen, nBytes)\nieee754.write = function (buffer, value, offset, isLE, mLen, nBytes)\n```\n\nThe arguments mean the following:\n\n- buffer = the buffer\n- offset = offset into the buffer\n- value = value to set (only for `write`)\n- isLe = is little endian?\n- mLen = mantissa length\n- nBytes = number of bytes\n\n## what is ieee754?\n\nThe IEEE Standard for Floating-Point Arithmetic (IEEE 754) is a technical standard for floating-point computation. [Read more](http://en.wikipedia.org/wiki/IEEE_floating_point).\n\n## license\n\nBSD 3 Clause. Copyright (c) 2008, Fair Oaks Labs, Inc.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{54/02/09cad3b811005be3807d6189a05b73c3674d709488e16ecb3b1308db0d2028cbe83f14e1812b3f8f8ae12f9383449e5bcd50ed815f563b870296f6b69011 → bd/a4/2d2aa01f2cf3b3318dfe8944e77970711de68f25075af4ccb267104b5b2956207892628e400e4f680a22c8a1ec26cab223252a389966806a4d7a4019262d}

@@ -1186,7 +1186,7 @@
   "dist-tags": {
     "latest": "0.11.10"
   },
-  "_rev": "1147-3ef83aa83a45bf25",
+  "_rev": "1150-cea7497e7dcbd8bf",
   "_id": "process",
   "readme": "# process\n\n```require('process');``` just like any other module.\n\nWorks in node.js and browsers via the browser.js shim provided with the module.\n\n## browser implementation\n\nThe goal of this module is not to be a full-fledged alternative to the builtin process module. This module mostly exists to provide the nextTick functionality and little more. We keep this module lean because it will often be included by default by tools like browserify when it detects a module has used the `process` global.\n\nIt also exposes a \"browser\" member (i.e. `process.browser`) which is `true` in this implementation but `undefined` in node. This can be used in isomorphic code that adjusts it's behavior depending on which environment it's running in. \n\nIf you are looking to provide other process methods, I suggest you monkey patch them onto the process global in your app. A list of user created patches is below.\n\n* [hrtime](https://github.com/kumavis/browser-process-hrtime)\n* [stdout](https://github.com/kumavis/browser-stdout)\n\n## package manager notes\n\nIf you are writing a bundler to package modules for client side use, make sure you use the ```browser``` field hint in package.json.\n\nSee https://gist.github.com/4339901 for details.\n\nThe [browserify](https://github.com/substack/node-browserify) module will properly handle this field when bundling your files.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{e3/43/8247d0fcf30834bd8078fcbdaa3178c74db799673fd552c239fb227fc190473cee9e5343713b02d47836921514584a120929643367924908b88c6220c720 → c2/25/29e9835937cffb7e906b1695d4599b3aba53823fbdefa249a39e84ebff47701dbf01475525b77bc5d3f76971b00785f638eef68c21c5400e80e618f385b3}

@@ -19812,7 +19812,7 @@
     "gamma": "1.0.0-gamma.7",
     "rc": "1.0.0-rc.10"
   },
-  "_rev": "459-c235560123bc6fa1",
+  "_rev": "461-aee68686111b944e",
   "_id": "@aws-sdk/types",
   "readme": "# @aws-sdk/types\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/types/latest.svg)](https://www.npmjs.com/package/@aws-sdk/types)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/types.svg)](https://www.npmjs.com/package/@aws-sdk/types)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{5a/77/782bd29a877c5ac11915f09385aab2ff6d9f012b8ebe4f656c725fd74796ef70c136c6fcc7e9e75b855f64855ad4865c1f04ab6e2ab5a3f8226609ef5d99 → c3/5e/40426f63c5b662baa0bb2ff8f1efb4c60c1817f1c982d295796b88c68703f54ca15eb1818ac443f34278aba8aff2f2b5dd0897d5a389763bfcda38dd449f}

@@ -1470,7 +1470,7 @@
   "dist-tags": {
     "latest": "1.5.1"
   },
-  "_rev": "3413-fbf3a27f283a4f63",
+  "_rev": "3417-d0a88585a44ef7a9",
   "_id": "base64-js",
   "readme": "base64-js\n=========\n\n`base64-js` does basic base64 encoding/decoding in pure JS.\n\n[![build status](https://secure.travis-ci.org/beatgammit/base64-js.png)](http://travis-ci.org/beatgammit/base64-js)\n\nMany browsers already have base64 encoding/decoding functionality, but it is for text data, not all-purpose binary data.\n\nSometimes encoding/decoding binary data in the browser is useful, and that is what this module does.\n\n## install\n\nWith [npm](https://npmjs.org) do:\n\n`npm install base64-js` and `var base64js = require('base64-js')`\n\nFor use in web browsers do:\n\n`<script src=\"base64js.min.js\"></script>`\n\n[Get supported base64-js with the Tidelift Subscription](https://tidelift.com/subscription/pkg/npm-base64-js?utm_source=npm-base64-js&utm_medium=referral&utm_campaign=readme)\n\n## methods\n\n`base64js` has three exposed functions, `byteLength`, `toByteArray` and `fromByteArray`, which both take a single argument.\n\n* `byteLength` - Takes a base64 string and returns length of byte array\n* `toByteArray` - Takes a base64 string and returns a byte array\n* `fromByteArray` - Takes a byte array and returns a base64 string\n\n## license\n\nMIT",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{fc/2e/034e20669aa95c51d8306903f5b0105b79aa331253c307476eeeba2e664b719525a7965e0c680730fa728a4be6c14a0cd658b1de9bfd17b97bedea418d2e → c5/bf/ad24c2ab9d2fd27178239e798f68f284b51998bc587e000373e3cdf2be0bcc650aad31d87938513637e11a204e378969d351c9bcc7f462de6eaf8ef3b128}

@@ -2346,7 +2346,7 @@
   "dist-tags": {
     "latest": "2.9.2"
   },
-  "_rev": "1176-cbf323884a54c397",
+  "_rev": "1179-963d9a2c58b4ecd0",
   "_id": "bare-events",
   "readme": "# bare-events\n\nEvent emitters for JavaScript.\n\n```\nnpm install bare-events\n```\n\n## Usage\n\n```js\nconst EventEmitter = require('bare-events')\n\nconst e = new EventEmitter()\n\ne.on('hello', function (data) {\n  console.log(data)\n})\n\ne.emit('hello', 'world')\n```\n\n## License\n\nApache-2.0",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{2d/b5/28bbceeffd418b70b855bbad3cfe0cdacad1b1994ce5cd8e1f7d837c72fe982dece513c23f2355cf4d57a7c7795964b08d227f51169baf4c31b5d9a71a19 → c5/d7/c734dc6461c3018563469d6f6947ae29d608ef13ac2400bdccb4c8eed859251974812b9bd24fbcb9627e7137158fdc8ebe0f7b6e21b903238ba7f43c17b1}

@@ -33994,7 +33994,7 @@
   "dist-tags": {
     "latest": "3.974.55"
   },
-  "_rev": "448-6a5d65a2d1a90bb6",
+  "_rev": "450-a42edfb451838f43",
   "_id": "@aws-sdk/middleware-flexible-checksums",
   "readme": "# @aws-sdk/middleware-flexible-checksums\n\n[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-flexible-checksums/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-flexible-checksums)\n[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-flexible-checksums.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-flexible-checksums)\n\nThis package provides AWS SDK for JavaScript middleware that applies a checksum\nof the request body as a header.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{70/3c/efd8bbc17d534743be38577a626fe5e6148b29da915983e3b2ae54040a828787c83613470697348627fc98bdd0240c901b55ea50f4c9d27ef1189c0e69cf → c8/44/edfb79456324ec04c399e1445b17634703de1bb7a419f2fd550f9a15fc826c7c879fb5852c2d5fa7f886767f337dd6926493e68c98097f22c8ea7d7e9b9c}

@@ -999,7 +999,7 @@
   "dist-tags": {
     "latest": "1.3.0"
   },
-  "_rev": "2802-ccf561e7eb585db8",
+  "_rev": "2806-fe837cadd2adad67",
   "_id": "string_decoder",
   "readme": "# string_decoder\n\n***Node-core v8.9.4 string_decoder for userland***\n\n\n[![NPM](https://nodei.co/npm/string_decoder.png?downloads=true&downloadRank=true)](https://nodei.co/npm/string_decoder/)\n[![NPM](https://nodei.co/npm-dl/string_decoder.png?&months=6&height=3)](https://nodei.co/npm/string_decoder/)\n\n\n```bash\nnpm install --save string_decoder\n```\n\n***Node-core string_decoder for userland***\n\nThis package is a mirror of the string_decoder implementation in Node-core.\n\nFull documentation may be found on the [Node.js website](https://nodejs.org/dist/v8.9.4/docs/api/).\n\nAs of version 1.0.0 **string_decoder** uses semantic versioning.\n\n## Previous versions\n\nPrevious version numbers match the versions found in Node core, e.g. 0.10.24 matches Node 0.10.24, likewise 0.11.10 matches Node 0.11.10.\n\n## Update\n\nThe *build/* directory contains a build script that will scrape the source from the [nodejs/node](https://github.com/nodejs/node) repo given a specific Node version.\n\n## Streams Working Group\n\n`string_decoder` is maintained by the Streams Working Group, which\noversees the development and maintenance of the Streams API within\nNode.js. The responsibilities of the Streams Working Group include:\n\n* Addressing stream issues on the Node.js issue tracker.\n* Authoring and editing stream documentation within the Node.js project.\n* Reviewing changes to stream subclasses within the Node.js project.\n* Redirecting changes to streams from the Node.js project to this\n  project.\n* Assisting in the implementation of stream providers within Node.js.\n* Recommending versions of `readable-stream` to be included in Node.js.\n* Messaging about the future of streams to give the community advance\n  notice of changes.\n\nSee [readable-stream](https://github.com/nodejs/readable-stream) for\nmore details.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{f4/40/35ccff85605e12c684306bec72ce8508b0903d62f53c5d186d519a9621a51f6f013d7e4c7a9e92d68dcd5b36800288b8d6edec2da18b9f4a9929faebcddc → c8/8e/dfa1ae62c5dcb306d2a77d01140f5262191fc41b7b77f5a19ca5452b581e75d5ddefa75cfba2ac5e58e1657f7f059cda95da48dd657f0c4ad12f33ef0ebb}

@@ -8107,7 +8107,7 @@
     "latest": "3.2.6",
     "next": "3.1.0"
   },
-  "_rev": "1651-c9747d3fd07702f6",
+  "_rev": "1654-baf5a848431313a5",
   "_id": "async",
   "readme": "![Async Logo](https://raw.githubusercontent.com/caolan/async/master/logo/async-logo_readme.jpg)\n\n![Github Actions CI status](https://github.com/caolan/async/actions/workflows/ci.yml/badge.svg)\n[![NPM version](https://img.shields.io/npm/v/async.svg)](https://www.npmjs.com/package/async)\n[![Coverage Status](https://coveralls.io/repos/caolan/async/badge.svg?branch=master)](https://coveralls.io/r/caolan/async?branch=master)\n[![Join the chat at https://gitter.im/caolan/async](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/caolan/async?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)\n[![jsDelivr Hits](https://data.jsdelivr.com/v1/package/npm/async/badge?style=rounded)](https://www.jsdelivr.com/package/npm/async)\n\n<!--\n|Linux|Windows|MacOS|\n|-|-|-|\n|[![Linux Build Status](https://dev.azure.com/caolanmcmahon/async/_apis/build/status/caolan.async?branchName=master&jobName=Linux&configuration=Linux%20node_10_x)](https://dev.azure.com/caolanmcmahon/async/_build/latest?definitionId=1&branchName=master) | [![Windows Build Status](https://dev.azure.com/caolanmcmahon/async/_apis/build/status/caolan.async?branchName=master&jobName=Windows&configuration=Windows%20node_10_x)](https://dev.azure.com/caolanmcmahon/async/_build/latest?definitionId=1&branchName=master) | [![MacOS Build Status](https://dev.azure.com/caolanmcmahon/async/_apis/build/status/caolan.async?branchName=master&jobName=OSX&configuration=OSX%20node_10_x)](https://dev.azure.com/caolanmcmahon/async/_build/latest?definitionId=1&branchName=master)| -->\n\nAsync is a utility module which provides straight-forward, powerful functions for working with [asynchronous JavaScript](http://caolan.github.io/async/v3/global.html). Although originally designed for use with [Node.js](https://nodejs.org/) and installable via `npm i async`, it can also be used directly in the browser.  An ESM/MJS version is included in the main `async` package that should automatically be used with compatible bundlers such as Webpack and Rollup.\n\nA pure ESM version of Async is available as [`async-es`](https://www.npmjs.com/package/async-es).\n\nFor Documentation, visit <https://caolan.github.io/async/>\n\n*For Async v1.5.x documentation, go [HERE](https://github.com/caolan/async/blob/v1.5.2/README.md)*\n\n\n```javascript\n// for use with Node-style callbacks...\nvar async = require(\"async\");\n\nvar obj = {dev: \"/dev.json\", test: \"/test.json\", prod: \"/prod.json\"};\nvar configs = {};\n\nasync.forEachOf(obj, (value, key, callback) => {\n    fs.readFile(__dirname + value, \"utf8\", (err, data) => {\n        if (err) return callback(err);\n        try {\n            configs[key] = JSON.parse(data);\n        } catch (e) {\n            return callback(e);\n        }\n        callback();\n    });\n}, err => {\n    if (err) console.error(err.message);\n    // configs is now a map of JSON data\n    doSomethingWith(configs);\n});\n```\n\n```javascript\nvar async = require(\"async\");\n\n// ...or ES2017 async functions\nasync.mapLimit(urls, 5, async function(url) {\n    const response = await fetch(url)\n    return response.body\n}, (err, results) => {\n    if (err) throw err\n    // results is now an array of the response bodies\n    console.log(results)\n})\n```",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{c9/4c/ae5df984664207381ad99861c124ae399f15a5e58d9519277967587be6c1daaf393a2dca46bf8dfd0b2d5b82b9372621b8d906daaeb8f7beb002adbdde37 → c8/db/60cda8aac0886f11916ae6a663900c02a0c95ef50659f27480b7864a6d8a3399a39e8b8c159d672efbae495ec98f50822cd657db2657cc60b542b8fa5f99}

@@ -3714,7 +3714,7 @@
   "dist-tags": {
     "latest": "0.5.21"
   },
-  "_rev": "4741-650c5dcdef5a63e9",
+  "_rev": "4745-a534603e811f17a6",
   "_id": "source-map-support",
   "readme": "# Source Map Support\n[![Build Status](https://travis-ci.org/evanw/node-source-map-support.svg?branch=master)](https://travis-ci.org/evanw/node-source-map-support)\n\nThis module provides source map support for stack traces in node via the [V8 stack trace API](https://github.com/v8/v8/wiki/Stack-Trace-API). It uses the [source-map](https://github.com/mozilla/source-map) module to replace the paths and line numbers of source-mapped files with their original paths and line numbers. The output mimics node's stack trace format with the goal of making every compile-to-JS language more of a first-class citizen. Source maps are completely general (not specific to any one language) so you can use source maps with multiple compile-to-JS languages in the same node process.\n\n## Installation and Usage\n\n#### Node support\n\n```\n$ npm install source-map-support\n```\n\nSource maps can be generated using libraries such as [source-map-index-generator](https://github.com/twolfson/source-map-index-generator). Once you have a valid source map, place a source mapping comment somewhere in the file (usually done automatically or with an option by your transpiler):\n\n```\n//# sourceMappingURL=path/to/source.map\n```\n\nIf multiple sourceMappingURL comments exist in one file, the last sourceMappingURL comment will be\nrespected (e.g. if a file mentions the comment in code, or went through multiple transpilers).\nThe path should either be absolute or relative to the compiled file.\n\nFrom here you have two options.\n\n##### CLI Usage\n\n```bash\nnode -r source-map-support/register compiled.js\n```\n\n##### Programmatic Usage\n\nPut the following line at the top of the compiled file.\n\n```js\nrequire('source-map-support').install();\n```\n\nIt is also possible to install the source map support directly by\nrequiring the `register` module which can be handy with ES6:\n\n```js\nimport 'source-map-support/register'\n\n// Instead of:\nimport sourceMapSupport from 'source-map-support'\nsourceMapSupport.install()\n```\nNote: if you're using babel-register, it includes source-map-support already.\n\nIt is also very useful with Mocha:\n\n```\n$ mocha --require source-map-support/register tests/\n```\n\n#### Browser support\n\nThis library also works in Chrome. While the DevTools console already supports source maps, the V8 engine doesn't and `Error.prototype.stack` will be incorrect without this library. Everything will just work if you deploy your source files using [browserify](http://browserify.org/). Just make sure to pass the `--debug` flag to the browserify command so your source maps are included in the bundled code.\n\nThis library also works if you use another build process or just include the source files directly. In this case, include the file `browser-source-map-support.js` in your page and call `sourceMapSupport.install()`. It contains the whole library already bundled for the browser using browserify.\n\n```html\n<script src=\"browser-source-map-support.js\"></script>\n<script>sourceMapSupport.install();</script>\n```\n\nThis library also works if you use AMD (Asynchronous Module Definition), which is used in tools like [RequireJS](http://requirejs.org/). Just list `browser-source-map-support` as a dependency:\n\n```html\n<script>\n  define(['browser-source-map-support'], function(sourceMapSupport) {\n    sourceMapSupport.install();\n  });\n</script>\n```\n\n## Options\n\nThis module installs two things: a change to the `stack` property on `Error` objects and a handler for uncaught exceptions that mimics node's default exception handler (the handler can be seen in the demos below). You may want to disable the handler if you have your own uncaught exception handler. This can be done by passing an argument to the installer:\n\n```js\nrequire('source-map-support').install({\n  handleUncaughtExceptions: false\n});\n```\n\nThis module loads source maps from the filesystem by default. You can provide alternate loading behavior through a callback as shown below. For example, [Meteor](https://github.com/meteor) keeps all source maps cached in memory to avoid disk access.\n\n```js\nrequire('source-map-support').install({\n  retrieveSourceMap: function(source) {\n    if (source === 'compiled.js') {\n      return {\n        url: 'original.js',\n        map: fs.readFileSync('compiled.js.map', 'utf8')\n      };\n    }\n    return null;\n  }\n});\n```\n\nThe module will by default assume a browser environment if XMLHttpRequest and window are defined. If either of these do not exist it will instead assume a node environment.\nIn some rare cases, e.g. when running a browser emulation and where both variables are also set, you can explictly specify the environment to be either 'browser' or 'node'.\n\n```js\nrequire('source-map-support').install({\n  environment: 'node'\n});\n```\n\nTo support files with inline source maps, the `hookRequire` options can be specified, which will monitor all source files for inline source maps.\n\n\n```js\nrequire('source-map-support').install({\n  hookRequire: true\n});\n```\n\nThis monkey patches the `require` module loading chain, so is not enabled by default and is not recommended for any sort of production usage.\n\n## Demos\n\n#### Basic Demo\n\noriginal.js:\n\n```js\nthrow new Error('test'); // This is the original code\n```\n\ncompiled.js:\n\n```js\nrequire('source-map-support').install();\n\nthrow new Error('test'); // This is the compiled code\n// The next line defines the sourceMapping.\n//# sourceMappingURL=compiled.js.map\n```\n\ncompiled.js.map:\n\n```json\n{\n  \"version\": 3,\n  \"file\": \"compiled.js\",\n  \"sources\": [\"original.js\"],\n  \"names\": [],\n  \"mappings\": \";;AAAA,MAAM,IAAI\"\n}\n```\n\nRun compiled.js using node (notice how the stack trace uses original.js instead of compiled.js):\n\n```\n$ node compiled.js\n\noriginal.js:1\nthrow new Error('test'); // This is the original code\n      ^\nError: test\n    at Object.<anonymous> (original.js:1:7)\n    at Module._compile (module.js:456:26)\n    at Object.Module._extensions..js (module.js:474:10)\n    at Module.load (module.js:356:32)\n    at Function.Module._load (module.js:312:12)\n    at Function.Module.runMain (module.js:497:10)\n    at startup (node.js:119:16)\n    at node.js:901:3\n```\n\n#### TypeScript Demo\n\ndemo.ts:\n\n```typescript\ndeclare function require(name: string);\nrequire('source-map-support').install();\nclass Foo {\n  constructor() { this.bar(); }\n  bar() { throw new Error('this is a demo'); }\n}\nnew Foo();\n```\n\nCompile and run the file using the TypeScript compiler from the terminal:\n\n```\n$ npm install source-map-support typescript\n$ node_modules/typescript/bin/tsc -sourcemap demo.ts\n$ node demo.js\n\ndemo.ts:5\n  bar() { throw new Error('this is a demo'); }\n                ^\nError: this is a demo\n    at Foo.bar (demo.ts:5:17)\n    at new Foo (demo.ts:4:24)\n    at Object.<anonymous> (demo.ts:7:1)\n    at Module._compile (module.js:456:26)\n    at Object.Module._extensions..js (module.js:474:10)\n    at Module.load (module.js:356:32)\n    at Function.Module._load (module.js:312:12)\n    at Function.Module.runMain (module.js:497:10)\n    at startup (node.js:119:16)\n    at node.js:901:3\n```\n\nThere is also the option to use `-r source-map-support/register` with typescript, without the need add the `require('source-map-support').install()` in the code base:\n\n```\n$ npm install source-map-support typescript\n$ node_modules/typescript/bin/tsc  -sourcemap demo.ts\n$ node -r source-map-support/register demo.js\n\ndemo.ts:5\n  bar() { throw new Error('this is a demo'); }\n                ^\nError: this is a demo\n    at Foo.bar (demo.ts:5:17)\n    at new Foo (demo.ts:4:24)\n    at Object.<anonymous> (demo.ts:7:1)\n    at Module._compile (module.js:456:26)\n    at Object.Module._extensions..js (module.js:474:10)\n    at Module.load (module.js:356:32)\n    at Function.Module._load (module.js:312:12)\n    at Function.Module.runMain (module.js:497:10)\n    at startup (node.js:119:16)\n    at node.js:901:3\n```\n\n#### CoffeeScript Demo\n\ndemo.coffee:\n\n```coffee\nrequire('source-map-support').install()\nfoo = ->\n  bar = -> throw new Error 'this is a demo'\n  bar()\nfoo()\n```\n\nCompile and run the file using the CoffeeScript compiler from the terminal:\n\n```sh\n$ npm install source-map-support coffeescript\n$ node_modules/.bin/coffee --map --compile demo.coffee\n$ node demo.js\n\ndemo.coffee:3\n  bar = -> throw new Error 'this is a demo'\n                     ^\nError: this is a demo\n    at bar (demo.coffee:3:22)\n    at foo (demo.coffee:4:3)\n    at Object.<anonymous> (demo.coffee:5:1)\n    at Object.<anonymous> (demo.coffee:1:1)\n    at Module._compile (module.js:456:26)\n    at Object.Module._extensions..js (module.js:474:10)\n    at Module.load (module.js:356:32)\n    at Function.Module._load (module.js:312:12)\n    at Function.Module.runMain (module.js:497:10)\n    at startup (node.js:119:16)\n```\n\n## Tests\n\nThis repo contains both automated tests for node and manual tests for the browser. The automated tests can be run using mocha (type `mocha` in the root directory). To run the manual tests:\n\n* Build the tests using `build.js`\n* Launch the HTTP server (`npm run serve-tests`) and visit\n  * http://127.0.0.1:1336/amd-test\n  * http://127.0.0.1:1336/browser-test\n  * http://127.0.0.1:1336/browserify-test - **Currently not working** due to a bug with browserify (see [pull request #66](https://github.com/evanw/node-source-map-support/pull/66) for details).\n* For `header-test`, run `server.js` inside that directory and visit http://127.0.0.1:1337/\n\n## License\n\nThis code is available under the [MIT license](http://opensource.org/licenses/MIT).",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{8b/dd/0d34c8cfe02d61661ebd8b0f3f26301b33ce5a29db41ec8c3039f7f89abe03bcdaa44cec11a4d4e33fe34a0da317c006a982f5f7e5f6c708d32f5ea09185 → c9/82/7ef8330fb15222b575703eafcd6e378288b591f2186384fa72f82dbc9cc4842211e247013c33f2bb738264d13eff73d72a80c1d0e9ed3069c1a95cd6c157}

@@ -116466,7 +116466,7 @@
     "ts6.0": "19.3.0",
     "undefined": "19.2.14"
   },
-  "_rev": "14574-6fa82f849750faa8",
+  "_rev": "14578-e61cfa30a0d86fc4",
   "_id": "@types/react",
   "readme": "# Installation\r\n> `npm install --save @types/react`\r\n\r\n# Summary\r\nThis package contains type definitions for react (https://react.dev/).\r\n\r\n# Details\r\nFiles were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react.\r\n\r\n### Additional Details\r\n * Last updated: Wed, 09 Sep 2026 18:05:03 GMT\r\n * Dependencies: [csstype](https://npmjs.com/package/csstype)\r\n\r\n# Credits\r\nThese definitions were written by [Asana](https://asana.com), [AssureSign](http://www.assuresign.com), [Microsoft](https://microsoft.com), [John Reilly](https://github.com/johnnyreilly), [Benoit Benezech](https://github.com/bbenezech), [Patricio Zavolinsky](https://github.com/pzavolinsky), [Eric Anderson](https://github.com/ericanderson), [Dovydas Navickas](https://github.com/DovydasNavickas), [Josh Rutherford](https://github.com/theruther4d), [Guilherme Hübner](https://github.com/guilhermehubner), [Ferdy Budhidharma](https://github.com/ferdaber), [Johann Rakotoharisoa](https://github.com/jrakotoharisoa), [Olivier Pascal](https://github.com/pascaloliv), [Martin Hochel](https://github.com/hotell), [Frank Li](https://github.com/franklixuefei), [Jessica Franco](https://github.com/Jessidhia), [Saransh Kataria](https://github.com/saranshkataria), [Kanitkorn Sujautra](https://github.com/lukyth), [Sebastian Silbermann](https://github.com/eps1lon), [Kyle Scully](https://github.com/zieka), [Cong Zhang](https://github.com/dancerphil), [Dimitri Mitropoulos](https://github.com/dimitropoulos), [JongChan Choi](https://github.com/disjukr), [Victor Magalhães](https://github.com/vhfmag), [Priyanshu Rav](https://github.com/priyanshurav), [Dmitry Semigradsky](https://github.com/Semigradsky), and [Matt Pocock](https://github.com/mattpocock).",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{8b/85/d27803dd7e2d87100b590f5c58b6435ced33836b8f807ea800af068deb30b8b8eea460dc75889473a0265e527172cb704baffbcb828f716fb05f1d09ce6e → cb/36/78973707719783a4e170c3b47f707f9f4ecd3c8ee481ec3a05a44fdc96a9b58d0e063edaebdb38161cda847732499ff949a6c46936380b0d01587ad196a6}

@@ -1172,7 +1172,7 @@
   "dist-tags": {
     "latest": "3.3.0"
   },
-  "_rev": "4451-dbdff8331e268994",
+  "_rev": "4455-4dec27e096b5dd98",
   "_id": "events",
   "readme": "# events [![Build Status](https://travis-ci.org/Gozala/events.png?branch=master)](https://travis-ci.org/Gozala/events)\n\n> Node's event emitter for all engines.\n\nThis implements the Node.js [`events`][node.js docs] module for environments that do not have it, like browsers.\n\n> `events` currently matches the **Node.js 11.13.0** API.\n\nNote that the `events` module uses ES5 features. If you need to support very old browsers like IE8, use a shim like [`es5-shim`](https://www.npmjs.com/package/es5-shim). You need both the shim and the sham versions of `es5-shim`.\n\nThis module is maintained, but only by very few people. If you'd like to help, let us know in the [Maintainer Needed](https://github.com/Gozala/events/issues/43) issue!\n\n## Install\n\nYou usually do not have to install `events` yourself! If your code runs in Node.js, `events` is built in. If your code runs in the browser, bundlers like [browserify](https://github.com/browserify/browserify) or [webpack](https://github.com/webpack/webpack) also include the `events` module.\n\nBut if none of those apply, with npm do:\n\n```\nnpm install events\n```\n\n## Usage\n\n```javascript\nvar EventEmitter = require('events')\n\nvar ee = new EventEmitter()\nee.on('message', function (text) {\n  console.log(text)\n})\nee.emit('message', 'hello world')\n```\n\n## API\n\nSee the [Node.js EventEmitter docs][node.js docs]. `events` currently matches the Node.js 11.13.0 API.\n\n## Contributing\n\nPRs are very welcome! The main way to contribute to `events` is by porting features, bugfixes and tests from Node.js. Ideally, code contributions to this module are copy-pasted from Node.js and transpiled to ES5, rather than reimplemented from scratch. Matching the Node.js code as closely as possible makes maintenance simpler when new changes land in Node.js.\nThis module intends to provide exactly the same API as Node.js, so features that are not available in the core `events` module will not be accepted. Feature requests should instead be directed at [nodejs/node](https://github.com/nodejs/node) and will be added to this module once they are implemented in Node.js.\n\nIf there is a difference in behaviour between Node.js's `events` module and this module, please open an issue!\n\n## License\n\n[MIT](./LICENSE)\n\n[node.js docs]: https://nodejs.org/dist/v11.13.0/docs/api/events.html",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{bb/b6/47e686d67c283f11268a0ea8ff8aa614a7595ce3253f7e96617ef83d972cd5d93d76e47dbcbaaa368f396f12af13b19b6572123ef662673b5e206421efbd → cd/8d/75a04550bd26a98d9631912e0922e7e6c58534d0ebe4328a255272a6bce0b2a43b793fc7fc6ec7077f35d8f35fcb58a31add5e46160ed03166704e8c3b78}

@@ -13538,7 +13538,7 @@
     "legacy-v6": "6.2.3",
     "legacy-v3": "3.1.5"
   },
-  "_rev": "5460-c80d7c450d6ca6dd",
+  "_rev": "5464-da67c550da6b0767",
   "_id": "minimatch",
   "readme": "# minimatch\n\nA minimal matching utility.\n\nThis is the matching library used internally by npm.\n\nIt works by converting glob expressions into JavaScript `RegExp`\nobjects.\n\n## Important Security Consideration!\n\n> [!WARNING]  \n> This library uses JavaScript regular expressions. Please read\n> the following warning carefully, and be thoughtful about what\n> you provide to this library in production systems.\n\n_Any_ library in JavaScript that deals with matching string\npatterns using regular expressions will be subject to\n[ReDoS](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS)\nif the pattern is generated using untrusted input.\n\nEfforts have been made to mitigate risk as much as is feasible in\nsuch a library, providing maximum recursion depths and so forth,\nbut these measures can only ultimately protect against accidents,\nnot malice. A dedicated attacker can _always_ find patterns that\ncannot be defended against by a bash-compatible glob pattern\nmatching system that uses JavaScript regular expressions.\n\nTo be extremely clear:\n\n> [!WARNING]  \n> **If you create a system where you take user input, and use\n> that input as the source of a Regular Expression pattern, in\n> this or any extant glob matcher in JavaScript, you will be\n> pwned.**\n\nA future version of this library _may_ use a different matching\nalgorithm which does not exhibit backtracking problems. If and\nwhen that happens, it will likely be a sweeping change, and those\nimprovements will **not** be backported to legacy versions.\n\nIn the near term, it is not reasonable to continue to play\nwhack-a-mole with security advisories, and so any future ReDoS\nreports will be considered \"working as intended\", and resolved\nentirely by this warning.\n\n## Usage\n\n```js\n// hybrid module, load with require() or import\nimport { minimatch } from 'minimatch'\n// or:\nconst { minimatch } = require('minimatch')\n\nminimatch('bar.foo', '*.foo') // true!\nminimatch('bar.foo', '*.bar') // false!\nminimatch('bar.foo', '*.+(bar|foo)', { debug: true }) // true, and noisy!\n```\n\n## Features\n\nSupports these glob features:\n\n- Brace Expansion\n- Extended glob matching\n- \"Globstar\" `**` matching\n- [Posix character\n  classes](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html),\n  like `[[:alpha:]]`, supporting the full range of Unicode\n  characters. For example, `[[:alpha:]]` will match against\n  `'é'`, though `[a-zA-Z]` will not. Collating symbol and set\n  matching is not supported, so `[[=e=]]` will _not_ match `'é'`\n  and `[[.ch.]]` will not match `'ch'` in locales where `ch` is\n  considered a single character.\n\nSee:\n\n- `man sh`\n- `man bash` [Pattern\n  Matching](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html)\n- `man 3 fnmatch`\n- `man 5 gitignore`\n\n## Windows\n\n**Please only use forward-slashes in glob expressions.**\n\nThough windows uses either `/` or `\\` as its path separator, only `/`\ncharacters are used by this glob implementation. You must use\nforward-slashes **only** in glob expressions. Back-slashes in patterns\nwill always be interpreted as escape characters, not path separators.\n\nNote that `\\` or `/` _will_ be interpreted as path separators in paths on\nWindows, and will match against `/` in glob expressions.\n\nSo just always use `/` in patterns.\n\n### UNC Paths\n\nOn Windows, UNC paths like `//?/c:/...` or\n`//ComputerName/Share/...` are handled specially.\n\n- Patterns starting with a double-slash followed by some\n  non-slash characters will preserve their double-slash. As a\n  result, a pattern like `//*` will match `//x`, but not `/x`.\n- Patterns staring with `//?/<drive letter>:` will _not_ treat\n  the `?` as a wildcard character. Instead, it will be treated\n  as a normal string.\n- Patterns starting with `//?/<drive letter>:/...` will match\n  file paths starting with `<drive letter>:/...`, and vice versa,\n  as if the `//?/` was not present. This behavior only is\n  present when the drive letters are a case-insensitive match to\n  one another. The remaining portions of the path/pattern are\n  compared case sensitively, unless `nocase:true` is set.\n\nNote that specifying a UNC path using `\\` characters as path\nseparators is always allowed in the file path argument, but only\nallowed in the pattern argument when `windowsPathsNoEscape: true`\nis set in the options.\n\n## Minimatch Class\n\nCreate a minimatch object by instantiating the `minimatch.Minimatch` class.\n\n```javascript\nvar Minimatch = require('minimatch').Minimatch\nvar mm = new Minimatch(pattern, options)\n```\n\n### Properties\n\n- `pattern` The original pattern the minimatch object represents.\n- `options` The options supplied to the constructor.\n- `set` A 2-dimensional array of regexp or string expressions.\n  Each row in the\n  array corresponds to a brace-expanded pattern. Each item in the row\n  corresponds to a single path-part. For example, the pattern\n  `{a,b/c}/d` would expand to a set of patterns like:\n\n        [ [ a, d ]\n        , [ b, c, d ] ]\n\n  If a portion of the pattern doesn't have any \"magic\" in it\n  (that is, it's something like `\"foo\"` rather than `fo*o?`), then it\n  will be left as a string rather than converted to a regular\n  expression.\n\n- `regexp` Created by the `makeRe` method. A single regular expression\n  expressing the entire pattern. This is useful in cases where you wish\n  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.\n- `negate` True if the pattern is negated.\n- `comment` True if the pattern is a comment.\n- `empty` True if the pattern is `\"\"`.\n\n### Methods\n\n- `makeRe()` Generate the `regexp` member if necessary, and return it.\n  Will return `false` if the pattern is invalid.\n- `match(fname)` Return true if the filename matches the pattern, or\n  false otherwise.\n- `matchOne(fileArray, patternArray, partial)` Take a `/`-split\n  filename, and match it against a single row in the `regExpSet`. This\n  method is mainly for internal use, but is exposed so that it can be\n  used by a glob-walker that needs to avoid excessive filesystem calls.\n- `hasMagic()` Returns true if the parsed pattern contains any\n  magic characters. Returns false if all comparator parts are\n  string literals. If the `magicalBraces` option is set on the\n  constructor, then it will consider brace expansions which are\n  not otherwise magical to be magic. If not set, then a pattern\n  like `a{b,c}d` will return `false`, because neither `abd` nor\n  `acd` contain any special glob characters.\n\n  This does **not** mean that the pattern string can be used as a\n  literal filename, as it may contain magic glob characters that\n  are escaped. For example, the pattern `\\\\*` or `[*]` would not\n  be considered to have magic, as the matching portion parses to\n  the literal string `'*'` and would match a path named `'*'`,\n  not `'\\\\*'` or `'[*]'`. The `minimatch.unescape()` method may\n  be used to remove escape characters.\n\nAll other methods are internal, and will be called as necessary.\n\n### minimatch(path, pattern, options)\n\nMain export. Tests a path against the pattern using the options.\n\n```javascript\nvar isJS = minimatch(file, '*.js', { matchBase: true })\n```\n\n### minimatch.filter(pattern, options)\n\nReturns a function that tests its\nsupplied argument, suitable for use with `Array.filter`. Example:\n\n```javascript\nvar javascripts = fileList.filter(\n  minimatch.filter('*.js', { matchBase: true }),\n)\n```\n\n### minimatch.escape(pattern, options = {})\n\nEscape all magic characters in a glob pattern, so that it will\nonly ever match literal strings.\n\nIf the `windowsPathsNoEscape` option is used, then characters are\nescaped by wrapping in `[]`, because a magic character wrapped in\na character class can only be satisfied by that exact character.\n\nSlashes (and backslashes in `windowsPathsNoEscape` mode) cannot\nbe escaped or unescaped.\n\n### minimatch.unescape(pattern, options = {})\n\nUn-escape a glob string that may contain some escaped characters.\n\nIf the `windowsPathsNoEscape` option is used, then square-brace\nescapes are removed, but not backslash escapes. For example, it\nwill turn the string `'[*]'` into `*`, but it will not turn\n`'\\\\*'` into `'*'`, because `\\` is a path separator in\n`windowsPathsNoEscape` mode.\n\nWhen `windowsPathsNoEscape` is not set, then both brace escapes\nand backslash escapes are removed.\n\nSlashes (and backslashes in `windowsPathsNoEscape` mode) cannot\nbe escaped or unescaped.\n\n### minimatch.match(list, pattern, options)\n\nMatch against the list of\nfiles, in the style of fnmatch or glob. If nothing is matched, and\noptions.nonull is set, then return a list containing the pattern itself.\n\n```javascript\nvar javascripts = minimatch.match(fileList, '*.js', { matchBase: true })\n```\n\n### minimatch.makeRe(pattern, options)\n\nMake a regular expression object from the pattern.\n\n## Options\n\nAll options are `false` by default.\n\n### debug\n\nDump a ton of stuff to stderr.\n\n### nobrace\n\nDo not expand `{a,b}` and `{1..3}` brace sets.\n\n### noglobstar\n\nDisable `**` matching against multiple folder names.\n\n### dot\n\nAllow patterns to match filenames starting with a period, even if\nthe pattern does not explicitly have a period in that spot.\n\nNote that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`\nis set.\n\n### noext\n\nDisable \"extglob\" style patterns like `+(a|b)`.\n\n### nocase\n\nPerform a case-insensitive match.\n\n### nocaseMagicOnly\n\nWhen used with `{nocase: true}`, create regular expressions that\nare case-insensitive, but leave string match portions untouched.\nHas no effect when used without `{nocase: true}`.\n\nUseful when some other form of case-insensitive matching is used,\nor if the original string representation is useful in some other\nway.\n\n### nonull\n\nWhen a match is not found by `minimatch.match`, return a list containing\nthe pattern itself if this option is set. When not set, an empty list\nis returned if there are no matches.\n\n### magicalBraces\n\nThis only affects the results of the `Minimatch.hasMagic` method.\n\nIf the pattern contains brace expansions, such as `a{b,c}d`, but\nno other magic characters, then the `Minimatch.hasMagic()` method\nwill return `false` by default. When this option set, it will\nreturn `true` for brace expansion as well as other magic glob\ncharacters.\n\n### matchBase\n\nIf set, then patterns without slashes will be matched\nagainst the basename of the path if it contains slashes. For example,\n`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.\n\n### nocomment\n\nSuppress the behavior of treating `#` at the start of a pattern as a\ncomment.\n\n### nonegate\n\nSuppress the behavior of treating a leading `!` character as negation.\n\n### flipNegate\n\nReturns from negate expressions the same as if they were not negated.\n(Ie, true on a hit, false on a miss.)\n\n### partial\n\nCompare a partial path to a pattern. As long as the parts of the path that\nare present are not contradicted by the pattern, it will be treated as a\nmatch. This is useful in applications where you're walking through a\nfolder structure, and don't yet have the full path, but want to ensure that\nyou do not walk down paths that can never be a match.\n\nFor example,\n\n```js\nminimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d\nminimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d\nminimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a\n```\n\n### windowsPathsNoEscape\n\nUse `\\\\` as a path separator _only_, and _never_ as an escape\ncharacter. If set, all `\\\\` characters are replaced with `/` in\nthe pattern. Note that this makes it **impossible** to match\nagainst paths containing literal glob pattern characters, but\nallows matching with patterns constructed using `path.join()` and\n`path.resolve()` on Windows platforms, mimicking the (buggy!)\nbehavior of earlier versions on Windows. Please use with\ncaution, and be mindful of [the caveat about Windows\npaths](#windows).\n\nFor legacy reasons, this is also set if\n`options.allowWindowsEscape` is set to the exact value `false`.\n\n### windowsNoMagicRoot\n\nWhen a pattern starts with a UNC path or drive letter, and in\n`nocase:true` mode, do not convert the root portions of the\npattern into a case-insensitive regular expression, and instead\nleave them as strings.\n\nThis is the default when the platform is `win32` and\n`nocase:true` is set.\n\n### preserveMultipleSlashes\n\nBy default, multiple `/` characters (other than the leading `//`\nin a UNC path, see \"UNC Paths\" above) are treated as a single\n`/`.\n\nThat is, a pattern like `a///b` will match the file path `a/b`.\n\nSet `preserveMultipleSlashes: true` to suppress this behavior.\n\n### optimizationLevel\n\nA number indicating the level of optimization that should be done\nto the pattern prior to parsing and using it for matches.\n\nGlobstar parts `**` are always converted to `*` when `noglobstar`\nis set, and multiple adjacent `**` parts are converted into a\nsingle `**` (ie, `a/**/**/b` will be treated as `a/**/b`, as this\nis equivalent in all cases).\n\n- `0` - Make no further changes. In this mode, `.` and `..` are\n  maintained in the pattern, meaning that they must also appear\n  in the same position in the test path string. Eg, a pattern\n  like `a/*/../c` will match the string `a/b/../c` but not the\n  string `a/c`.\n- `1` - (default) Remove cases where a double-dot `..` follows a\n  pattern portion that is not `**`, `.`, `..`, or empty `''`. For\n  example, the pattern `./a/b/../*` is converted to `./a/*`, and\n  so it will match the path string `./a/c`, but not the path\n  string `./a/b/../c`. Dots and empty path portions in the\n  pattern are preserved.\n- `2` (or higher) - Much more aggressive optimizations, suitable\n  for use with file-walking cases:\n  - Remove cases where a double-dot `..` follows a pattern\n    portion that is not `**`, `.`, or empty `''`. Remove empty\n    and `.` portions of the pattern, where safe to do so (ie,\n    anywhere other than the last position, the first position, or\n    the second position in a pattern starting with `/`, as this\n    may indicate a UNC path on Windows).\n  - Convert patterns containing `<pre>/**/../<p>/<rest>` into the\n    equivalent `<pre>/{..,**}/<p>/<rest>`, where `<p>` is a\n    a pattern portion other than `.`, `..`, `**`, or empty\n    `''`.\n  - Dedupe patterns where a `**` portion is present in one and\n    omitted in another, and it is not the final path portion, and\n    they are otherwise equivalent. So `{a/**/b,a/b}` becomes\n    `a/**/b`, because `**` matches against an empty path portion.\n  - Dedupe patterns where a `*` portion is present in one, and a\n    non-dot pattern other than `**`, `.`, `..`, or `''` is in the\n    same position in the other. So `a/{*,x}/b` becomes `a/*/b`,\n    because `*` can match against `x`.\n\n  While these optimizations improve the performance of\n  file-walking use cases such as [glob](http://npm.im/glob) (ie,\n  the reason this module exists), there are cases where it will\n  fail to match a literal string that would have been matched in\n  optimization level 1 or 0.\n\n  Specifically, while the `Minimatch.match()` method will\n  optimize the file path string in the same ways, resulting in\n  the same matches, it will fail when tested with the regular\n  expression provided by `Minimatch.makeRe()`, unless the path\n  string is first processed with\n  `minimatch.levelTwoFileOptimize()` or similar.\n\n### platform\n\nWhen set to `win32`, this will trigger all windows-specific\nbehaviors (special handling for UNC paths, and treating `\\` as\nseparators in file paths for comparison.)\n\nDefaults to the value of `process.platform`.\n\n### maxGlobstarRecursion\n\nMax number of non-adjacent `**` patterns to recursively walk\ndown.\n\nThe default of `200` is almost certainly high enough for most\npurposes, and can handle absurdly excessive patterns.\n\nIf the limit is exceeded (which would require very excessively\nlong patterns and paths containing lots of `**` patterns!), then\nit is treated as non-matching, even if the path would normally\nmatch the pattern provided.\n\nThat is, this is an intentional false negative, deemed an\nacceptable break in correctness for security and performance.\n\n### maxExtglobRecursion\n\nMax depth to traverse for nested extglobs like `*(a|b|c)`\n\nDefault is 2, which is quite low, but any higher value swiftly\nresults in punishing performance impacts. Note that this is _not_\nrelevant when the globstar types can be safely coalesced into a\nsingle set.\n\nFor example, `*(a|@(b|c)|d)` would be flattened into\n`*(a|b|c|d)`. Thus, many common extglobs will retain good\nperformance and never hit this limit, even if they are\nexcessively deep and complicated.\n\nIf the limit is hit, then the extglob characters are simply not\nparsed, and the pattern effectively switches into `noextglob:\ntrue` mode for the contents of that nested sub-pattern. This will\ntypically _not_ result in a match, but is considered a valid\ntrade-off for security and performance.\n\n## Comparisons to other fnmatch/glob implementations\n\nWhile strict compliance with the existing standards is a\nworthwhile goal, some discrepancies exist between minimatch and\nother implementations. Some are intentional, and some are\nunavoidable.\n\nIf the pattern starts with a `!` character, then it is negated. Set the\n`nonegate` flag to suppress this behavior, and treat leading `!`\ncharacters normally. This is perhaps relevant if you wish to start the\npattern with a negative extglob pattern like `!(a|B)`. Multiple `!`\ncharacters at the start of a pattern will negate the pattern multiple\ntimes.\n\nIf a pattern starts with `#`, then it is treated as a comment, and\nwill not match anything. Use `\\#` to match a literal `#` at the\nstart of a line, or set the `nocomment` flag to suppress this behavior.\n\nThe double-star character `**` is supported by default, unless the\n`noglobstar` flag is set. This is supported in the manner of bsdglob\nand bash 4.1, where `**` only has special significance if it is the only\nthing in a path part. That is, `a/**/b` will match `a/x/y/b`, but\n`a/**b` will not.\n\nIf an escaped pattern has no matches, and the `nonull` flag is set,\nthen minimatch.match returns the pattern as-provided, rather than\ninterpreting the character escapes. For example,\n`minimatch.match([], \"\\\\*a\\\\?\")` will return `\"\\\\*a\\\\?\"` rather than\n`\"*a?\"`. This is akin to setting the `nullglob` option in bash, except\nthat it does not resolve escaped pattern characters.\n\nIf brace expansion is not disabled, then it is performed before any\nother interpretation of the glob pattern. Thus, a pattern like\n`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded\n**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are\nchecked for validity. Since those two are valid, matching proceeds.\n\nNegated extglob patterns are handled as closely as possible to\nBash semantics, but there are some cases with negative extglobs\nwhich are exceedingly difficult to express in a JavaScript\nregular expression. In particular the negated pattern\n`<start>!(<pattern>*|)*` will in bash match anything that does\nnot start with `<start><pattern>`. However,\n`<start>!(<pattern>*)*` _will_ match paths starting with\n`<start><pattern>`, because the empty string can match against\nthe negated portion. In this library, `<start>!(<pattern>*|)*`\nwill _not_ match any pattern starting with `<start>`, due to a\ndifference in precisely which patterns are considered \"greedy\" in\nRegular Expressions vs bash path expansion. This may be fixable,\nbut not without incurring some complexity and performance costs,\nand the trade-off seems to not be worth pursuing.\n\nNote that `fnmatch(3)` in libc is an extremely naive string comparison\nmatcher, which does not do anything special for slashes. This library is\ndesigned to be used in glob searching and file walkers, and so it does do\nspecial things with `/`. Thus, `foo*` will not match `foo/bar` in this\nlibrary, even though it would in `fnmatch(3)`.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{3d/ab/69cb81a132025c65a2fb2c6e30e8d1954bddf8fe636e86e698c025b7e05b3c7a63834392374c4f8e68efa6915a2ac217bc70a892031ae04f1782fdadfb58 → d3/35/ecbce3df1cf4f9f65d1e3af7b96629ef27d4c9cd3700deff093eab8ebbedf2c850b628c26a87697d241d6ef7f36789edee207a5d6b29c9fba47e98544c34}

@@ -378,7 +378,7 @@
   "dist-tags": {
     "latest": "1.1.2"
   },
-  "_rev": "4681-e0988ed81caaa51b",
+  "_rev": "4685-27ab5f77d7552c53",
   "_id": "buffer-from",
   "readme": "# Buffer From\n\nA [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.\n\n## Installation\n\n```sh\nnpm install --save buffer-from\n```\n\n## Usage\n\n```js\nconst bufferFrom = require('buffer-from')\n\nconsole.log(bufferFrom([1, 2, 3, 4]))\n//=> <Buffer 01 02 03 04>\n\nconst arr = new Uint8Array([1, 2, 3, 4])\nconsole.log(bufferFrom(arr.buffer, 1, 2))\n//=> <Buffer 02 03>\n\nconsole.log(bufferFrom('test', 'utf8'))\n//=> <Buffer 74 65 73 74>\n\nconst buf = bufferFrom('test')\nconsole.log(bufferFrom(buf))\n//=> <Buffer 74 65 73 74>\n```\n\n## API\n\n### bufferFrom(array)\n\n- `array` &lt;Array&gt;\n\nAllocates a new `Buffer` using an `array` of octets.\n\n### bufferFrom(arrayBuffer[, byteOffset[, length]])\n\n- `arrayBuffer` &lt;ArrayBuffer&gt; The `.buffer` property of a TypedArray or ArrayBuffer\n- `byteOffset` &lt;Integer&gt; Where to start copying from `arrayBuffer`. **Default:** `0`\n- `length` &lt;Integer&gt; How many bytes to copy from `arrayBuffer`. **Default:** `arrayBuffer.length - byteOffset`\n\nWhen passed a reference to the `.buffer` property of a TypedArray instance, the\nnewly created `Buffer` will share the same allocated memory as the TypedArray.\n\nThe optional `byteOffset` and `length` arguments specify a memory range within\nthe `arrayBuffer` that will be shared by the `Buffer`.\n\n### bufferFrom(buffer)\n\n- `buffer` &lt;Buffer&gt; An existing `Buffer` to copy data from\n\nCopies the passed `buffer` data onto a new `Buffer` instance.\n\n### bufferFrom(string[, encoding])\n\n- `string` &lt;String&gt; A string to encode.\n- `encoding` &lt;String&gt; The encoding of `string`. **Default:** `'utf8'`\n\nCreates a new `Buffer` containing the given JavaScript string `string`. If\nprovided, the `encoding` parameter identifies the character encoding of\n`string`.\n\n## See also\n\n- [buffer-alloc](https://github.com/LinusU/buffer-alloc) A ponyfill for `Buffer.alloc`\n- [buffer-alloc-unsafe](https://github.com/LinusU/buffer-alloc-unsafe) A ponyfill for `Buffer.allocUnsafe`",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{88/80/f87a25c397421fbfefd00b503274d38075e089168e93608a24ece635956a5324e6eb1dff41ef72d56ba7bd6950455647d3690f1e51ae4f82fa2cfd28ec9e → e2/8d/b8cf235d73dfa06394368b6c14d7b4c15a83425e2e9f7272874e9e0b7b77e0ce9d5476886e88aa7191a276c8a0b32b58aa100938206315890991ac7d17ea}

@@ -937,7 +937,7 @@
   "dist-tags": {
     "latest": "3.0.0"
   },
-  "_rev": "2845-c534c2e72b75adbb",
+  "_rev": "2849-7104f1c9d70ffa24",
   "_id": "normalize-path",
   "readme": "# normalize-path [![NPM version](https://img.shields.io/npm/v/normalize-path.svg?style=flat)](https://www.npmjs.com/package/normalize-path) [![NPM monthly downloads](https://img.shields.io/npm/dm/normalize-path.svg?style=flat)](https://npmjs.org/package/normalize-path) [![NPM total downloads](https://img.shields.io/npm/dt/normalize-path.svg?style=flat)](https://npmjs.org/package/normalize-path) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/normalize-path.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/normalize-path)\n\n> Normalize slashes in a file path to be posix/unix-like forward slashes. Also condenses repeat slashes to a single slash and removes and trailing slashes, unless disabled.\n\nPlease consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.\n\n## Install\n\nInstall with [npm](https://www.npmjs.com/):\n\n```sh\n$ npm install --save normalize-path\n```\n\n## Usage\n\n```js\nconst normalize = require('normalize-path');\n\nconsole.log(normalize('\\\\foo\\\\bar\\\\baz\\\\')); \n//=> '/foo/bar/baz'\n```\n\n**win32 namespaces**\n\n```js\nconsole.log(normalize('\\\\\\\\?\\\\UNC\\\\Server01\\\\user\\\\docs\\\\Letter.txt')); \n//=> '//?/UNC/Server01/user/docs/Letter.txt'\n\nconsole.log(normalize('\\\\\\\\.\\\\CdRomX')); \n//=> '//./CdRomX'\n```\n\n**Consecutive slashes**\n\nCondenses multiple consecutive forward slashes (except for leading slashes in win32 namespaces) to a single slash.\n\n```js\nconsole.log(normalize('.//foo//bar///////baz/')); \n//=> './foo/bar/baz'\n```\n\n### Trailing slashes\n\nBy default trailing slashes are removed. Pass `false` as the last argument to disable this behavior and _**keep** trailing slashes_:\n\n```js\nconsole.log(normalize('foo\\\\bar\\\\baz\\\\', false)); //=> 'foo/bar/baz/'\nconsole.log(normalize('./foo/bar/baz/', false)); //=> './foo/bar/baz/'\n```\n\n## Release history\n\n### v3.0\n\nNo breaking changes in this release.\n\n* a check was added to ensure that [win32 namespaces](https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces) are handled properly by win32 `path.parse()` after a path has been normalized by this library.\n* a minor optimization was made to simplify how the trailing separator was handled\n\n## About\n\n<details>\n<summary><strong>Contributing</strong></summary>\n\nPull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).\n\n</details>\n\n<details>\n<summary><strong>Running Tests</strong></summary>\n\nRunning and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:\n\n```sh\n$ npm install && npm test\n```\n\n</details>\n\n<details>\n<summary><strong>Building docs</strong></summary>\n\n_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_\n\nTo generate the readme, run the following command:\n\n```sh\n$ npm install -g verbose/verb#dev verb-generate-readme && verb\n```\n\n</details>\n\n### Related projects\n\nOther useful path-related libraries:\n\n* [contains-path](https://www.npmjs.com/package/contains-path): Return true if a file path contains the given path. | [homepage](https://github.com/jonschlinkert/contains-path \"Return true if a file path contains the given path.\")\n* [is-absolute](https://www.npmjs.com/package/is-absolute): Returns true if a file path is absolute. Does not rely on the path module… [more](https://github.com/jonschlinkert/is-absolute) | [homepage](https://github.com/jonschlinkert/is-absolute \"Returns true if a file path is absolute. Does not rely on the path module and can be used as a polyfill for node.js native `path.isAbolute`.\")\n* [is-relative](https://www.npmjs.com/package/is-relative): Returns `true` if the path appears to be relative. | [homepage](https://github.com/jonschlinkert/is-relative \"Returns `true` if the path appears to be relative.\")\n* [parse-filepath](https://www.npmjs.com/package/parse-filepath): Pollyfill for node.js `path.parse`, parses a filepath into an object. | [homepage](https://github.com/jonschlinkert/parse-filepath \"Pollyfill for node.js `path.parse`, parses a filepath into an object.\")\n* [path-ends-with](https://www.npmjs.com/package/path-ends-with): Return `true` if a file path ends with the given string/suffix. | [homepage](https://github.com/jonschlinkert/path-ends-with \"Return `true` if a file path ends with the given string/suffix.\")\n* [unixify](https://www.npmjs.com/package/unixify): Convert Windows file paths to unix paths. | [homepage](https://github.com/jonschlinkert/unixify \"Convert Windows file paths to unix paths.\")\n\n### Contributors\n\n| **Commits** | **Contributor** | \n| --- | --- |\n| 35 | [jonschlinkert](https://github.com/jonschlinkert) |\n| 1 | [phated](https://github.com/phated) |\n\n### Author\n\n**Jon Schlinkert**\n\n* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)\n* [GitHub Profile](https://github.com/jonschlinkert)\n* [Twitter Profile](https://twitter.com/jonschlinkert)\n\n### License\n\nCopyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).\nReleased under the [MIT License](LICENSE).\n\n***\n\n_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on April 19, 2018._",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{0d/42/6014b4af17e726d5ba291fdf316660fcf8f7c8d16bde1fa88e7430149756b39383ff6e9fe703d6175b2e8028198b827dd7e3d5421ecc99349de8ab59b119 → e3/85/c6a19c9c28d40098ca40f05fba131532fcaf6b9017e3c400258aa092e1a4e4cafb6e0c02b57b885964b8d476235cecc0b904d1638b0069664e36485df8cc}

@@ -237,7 +237,7 @@
   "dist-tags": {
     "latest": "1.0.3"
   },
-  "_rev": "2509-99c890ab1d0cf97d",
+  "_rev": "2513-9658158b947fa969",
   "_id": "core-util-is",
   "readme": "# core-util-is\n\nThe `util.is*` functions introduced in Node v0.12.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{91/fb/67b4be13e21402798a37d2e82f92639aec0ee449ef52766ddfd6036208c8dd12777b6c3a271c1af7f5e696dcf63bb76c0f74717d47e905c85b654f26130f → e8/3e/03613db68daf2e66a114355953aaccbd0572cdf538e561c37cb3e90ccdc7bfe6172fa10273759ab298ab1b1cd5623b3912ee3fcfdf47595c10e7fd8676f3}

@@ -1599,7 +1599,7 @@
   "dist-tags": {
     "latest": "0.3.0"
   },
-  "_rev": "76-634e992ca574dabf",
+  "_rev": "78-1469e4aac33bffdc",
   "_id": "@aws/lambda-invoke-store",
   "readme": "# Node.js Invoke Store for AWS Lambda\n\n`@aws/lambda-invoke-store` provides a generic, per-invocation context store for\nAWS Lambda Node.js Runtime Environment. It enables storing and retrieving data\nwithin the scope of a single Lambda invocation, with proper isolation between\nconcurrent executions.\n\n## Features\n\n- **Invocation Isolation**: Safely store and retrieve data within a single Lambda invocation.\n- **Protected Lambda Context**: Built-in protection for Lambda execution metadata (requestId, [traceId](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-traces), [W3C Trace Context](https://www.w3.org/TR/trace-context/), [W3C Baggage](https://www.w3.org/TR/baggage/))\n- **Custom Data Storage**: Store any custom data within the invocation context\n- **Async/Await Support**: Full support for asynchronous operations with context preservation\n- **Type Safety**: Complete TypeScript type definitions\n- **Singleton Pattern**: Ensures a single shared instance across all imports\n- **Global Namespace Integration**: Integrates with the Lambda runtime global namespace\n\n## Installation\n\n```bash\nnpm install @aws/lambda-invoke-store\n```\n\n## Quick Start\n\n> **Note**: In the AWS Lambda environment, the Runtime Interface Client (RIC) automatically initializes the InvokeStore context at the beginning of each invocation. Lambda function developers typically don't need to call `InvokeStore.run()` directly.\n\n```typescript\nimport { InvokeStore } from \"@aws/lambda-invoke-store\";\n\n// Lambda handler with invoke store\nexport const handler = async (event, context) => {\n  // The RIC has already initialized the InvokeStore with requestId and X-Ray traceId\n\n  // Access Lambda context data\n  const invokeStore = await InvokeStore.getInstanceAsync();\n  console.log(`Processing request: ${invokeStore.getRequestId()}`);\n\n  // Store custom data\n  invokeStore.set(\"userId\", event.userId);\n\n  // Data persists across async operations\n  await processData(event);\n\n  // Retrieve custom data\n  const userId = invokeStore.get(\"userId\");\n\n  return {\n    requestId: invokeStore.getRequestId(),\n    userId,\n  };\n};\n\n// Context is preserved in async operations\nasync function processData(event) {\n  // Still has access to the same invoke context\n  const invokeStore = await InvokeStore.getInstanceAsync();\n  console.log(`Processing in same context: ${invokeStore.getRequestId()}`);\n\n  // Can set additional data\n  invokeStore.set(\"processedData\", { result: \"success\" });\n}\n```\n\n## API Reference\n\n### InvokeStore.getInstanceAsync()\nFirst, get an instance of the InvokeStore:\n```typescript\nconst invokeStore = await InvokeStore.getInstanceAsync();\n```\n\n### invokeStore.getContext()\n\nReturns the complete current context or `undefined` if outside a context.\n\n```typescript\nconst context = invokeStore.getContext();\n```\n\n### invokeStore.get(key)\n\nGets a value from the current context.\n\n```typescript\nconst requestId = invokeStore.get(InvokeStoreBase.PROTECTED_KEYS.REQUEST_ID);\nconst customValue = invokeStore.get(\"customKey\");\n```\n\n### invokeStore.set(key, value)\n\nSets a custom value in the current context. Protected Lambda fields cannot be modified.\n\n```typescript\ninvokeStore.set(\"userId\", \"user-123\");\ninvokeStore.set(\"timestamp\", Date.now());\n\n// This will throw an error:\n// invokeStore.set(InvokeStoreBase.PROTECTED_KEYS.REQUEST_ID, 'new-id');\n```\n\n### invokeStore.getRequestId()\n\nConvenience method to get the current request ID.\n\n```typescript\nconst requestId = invokeStore.getRequestId(); // Returns '-' if outside context\n```\n\n### invokeStore.getTenantId()\n\nConvenience method to get the tenant ID.\n\n```typescript\nconst requestId = invokeStore.getTenantId();\n```\n\n### invokeStore.getXRayTraceId()\n\nConvenience method to get the current [X-Ray trace ID](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-traces). This ID is used for distributed tracing across AWS services.\n\n```typescript\nconst traceId = invokeStore.getXRayTraceId(); // Returns undefined if not set or outside context\n```\n\n### invokeStore.getTraceparent()\n\nConvenience method to get the [W3C `traceparent`](https://www.w3.org/TR/trace-context/#traceparent-header) header value.\n\n```typescript\nconst traceparent = invokeStore.getTraceparent(); // e.g. \"00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01\"\n```\n\n### invokeStore.getTracestate()\n\nConvenience method to get the [W3C `tracestate`](https://www.w3.org/TR/trace-context/#tracestate-header) header value.\n\n```typescript\nconst tracestate = invokeStore.getTracestate(); // e.g. \"congo=t61rcWkgMzE,rojo=00f067aa0ba902b7\"\n```\n\n### invokeStore.getBaggage()\n\nConvenience method to get the [W3C Baggage](https://www.w3.org/TR/baggage/) header value.\n\n```typescript\nconst baggage = invokeStore.getBaggage(); // e.g. \"userId=alice,serverNode=DF28\"\n```\n\n### invokeStore.hasContext()\n\nChecks if code is currently running within an invoke context.\n\n```typescript\nif (invokeStore.hasContext()) {\n  // We're inside an invoke context\n}\n```\n\n### invokeStore.run(context, fn)\n\n> **Note**: This method is primarily used by the Lambda Runtime Interface Client (RIC) to initialize the context for each invocation. Lambda function developers typically don't need to call this method directly.\n\nRuns a function within an invoke context.\n\n```typescript\ninvokeStore.run(\n  {\n    [InvokeStoreBase.PROTECTED_KEYS.REQUEST_ID]: \"request-123\",\n    [InvokeStoreBase.PROTECTED_KEYS.X_RAY_TRACE_ID]: \"trace-456\", // Optional X-Ray trace ID\n    customField: \"value\", // Optional custom fields\n  },\n  () => {\n    // Function to execute within context\n  }\n);\n```\n\n## Integration with AWS Lambda Runtime\n\nThe `@aws/lambda-invoke-store` package is designed to be integrated with the AWS Lambda Node.js Runtime Interface Client (RIC). The RIC automatically:\n\n1. Initializes the InvokeStore context at the beginning of each Lambda invocation\n2. Sets the `requestId` and [X-Ray `traceId`](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-traces) in the context\n3. Ensures proper context isolation between concurrent invocations\n4. Cleans up the context after the invocation completes\n\nLambda function developers can focus on using the context without worrying about initialization or cleanup.\n\n## Global Namespace and Singleton Pattern\n\nThe InvokeStore uses a singleton pattern to ensure that all imports of the module use the same instance, which is critical for maintaining proper context isolation across different parts of your application.\n\n### Global Namespace Integration\n\nThe InvokeStore integrates with the Lambda runtime's global namespace:\n\n```typescript\n// The InvokeStore is available globally\nconst globalInstance = globalThis.awslambda.InvokeStore;\n```\n\nThis enables seamless integration between the Lambda Runtime Interface Client (RIC), AWS SDK, and your function code, ensuring they all share the same context.\n\n### Environment Variable Opt-Out\n\nIf you prefer not to modify the global namespace, you can opt out by setting the environment variable:\n\n```bash\n# Disable global namespace modification\nAWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA=1\n```\n\nWhen this environment variable is set, the InvokeStore will still function correctly, but it won't be stored in the global namespace.\n\n## Security\n\nSee [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.\n\n## License\n\nThis project is licensed under the Apache-2.0 License.",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{9f/af/059752f77991560afefd1c6a4059dc5b9e00ff648141114273ef1335cdab889a23742f32d92783ab16f1401e90215b1429b17275b31734d7e2b316066bf3 → ea/95/ba42d659c16f6f2e0ee3791b66a849cd54f3ae9ad7ac7a423a513afc1706b61b37a98323fe90f5cfbb133c9c93b448a0f6a1a51966c3773c6ffe2d08cd8c}

@@ -1754,7 +1754,7 @@
   "dist-tags": {
     "latest": "5.2.0"
   },
-  "_rev": "435-6f965556b32087fe",
+  "_rev": "437-a24a15709daedaca",
   "_id": "@aws-crypto/sha256-js",
   "readme": "# crypto-sha256-js\n\nA pure JS implementation SHA256.\n\n## Usage\n\n- To hash \"some data\"\n```\nimport {Sha256} from '@aws-crypto/sha256-js';\n\nconst hash = new Sha256();\nhash.update('some data');\nconst result = await hash.digest();\n\n```\n\n- To hmac \"some data\" with \"a key\"\n```\nimport {Sha256} from '@aws-crypto/sha256-js';\n\nconst hash = new Sha256('a key');\nhash.update('some data');\nconst result = await hash.digest();\n\n```\n\n## Test\n\n`npm test`",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{48/5b/1640c4f6c7f358ce32767f9c9572a8356ab4e721b31dec60d5bf5a3acf7fc80ae1cfd94f155a61a544a68b2e7fafd4b2808ebaa5355ba10a1bb7d1d1d075 → eb/bc/5c9531d147c6523bdf81fa537131a639c15736699cef97a7b8e735350dd1b6f1cf6965e38c6e16e1296bf10bbe229345695a3be131887587424f5a73fba6}

@@ -2702,7 +2702,7 @@
     "latest": "6.0.6",
     "n-api": "4.0.0-napi"
   },
-  "_rev": "501-e791b02f8661cb5c",
+  "_rev": "503-0028b7df87060660",
   "_id": "utf-8-validate",
   "readme": "# utf-8-validate\n\n[![Version npm](https://img.shields.io/npm/v/utf-8-validate.svg?logo=npm)](https://www.npmjs.com/package/utf-8-validate)\n[![Linux/macOS/Windows Build](https://img.shields.io/github/actions/workflow/status/websockets/utf-8-validate/ci.yml?branch=master&label=build&logo=github)](https://github.com/websockets/utf-8-validate/actions?query=workflow%3ACI+branch%3Amaster)\n\nCheck if a buffer contains valid UTF-8 encoded text.\n\n## Installation\n\n```\nnpm install utf-8-validate --save-optional\n```\n\nThe `--save-optional` flag tells npm to save the package in your package.json\nunder the\n[`optionalDependencies`](https://docs.npmjs.com/files/package.json#optionaldependencies)\nkey.\n\n## API\n\nThe module exports a single function that takes one argument. To maximize\nperformance, the argument is not validated. It is the caller's responsibility to\nensure that it is correct.\n\n### `isValidUTF8(buffer)`\n\nChecks whether a buffer contains valid UTF-8.\n\n#### Arguments\n\n- `buffer` - The buffer to check.\n\n#### Return value\n\n`true` if the buffer contains only correct UTF-8, else `false`.\n\n#### Example\n\n```js\n'use strict';\n\nconst isValidUTF8 = require('utf-8-validate');\n\nconst buf = Buffer.from([0xf0, 0x90, 0x80, 0x80]);\n\nconsole.log(isValidUTF8(buf));\n// => true\n```\n\n## License\n\n[MIT](LICENSE)",
   "_attachments": {}

package/npm-cache/_cacache/content-v2/sha512/{2f/32/f83288a165538c7b27b5eb484fe089b38a125c4ac36108b6de769c776096fbeab576e56ef09ec1062d6bad36185a1f3fb4bd98b83af61b131b48017f0233 → ec/f5/d0a2863058da34ffcf8519fc0d4c620357e0da21b396a95ee8d0cafb3088a1f3574bd3ace3d4f42ecfafee48189dae956efd3ba5b94569b8eb5303331d31}

@@ -5155,7 +5155,7 @@
   "dist-tags": {
     "latest": "2.28.1"
   },
-  "_rev": "1181-f12a0da123995dc8",
+  "_rev": "1184-486aa8abd5a035bb",
   "_id": "streamx",
   "readme": "# streamx\n\nAn iteration of the Node.js core streams with a series of improvements.\n\n```\nnpm install streamx\n```\n\n[![Build Status](https://github.com/streamxorg/streamx/workflows/Build%20Status/badge.svg)](https://github.com/streamxorg/streamx/actions?query=workflow%3A%22Build+Status%22)\n\n## Main improvements from Node.js core stream\n\n#### Proper lifecycle support.\n\nStreams have an `_open` function that is called before any read/write operation and a `_destroy`\nfunction that is always run as the last part of the stream.\n\nThis makes it easy to maintain state.\n\n#### Easy error handling\n\nFully integrates a `.destroy()` function. When called the stream will wait for any\npending operation to finish and call the stream destroy logic.\n\nClose is _always_ the last event emitted and `destroy` is always run.\n\n#### `pipe()` error handles\n\n`pipe` accepts a callback that is called when the pipeline is fully drained.\nIt also error handles the streams provided and destroys both streams if either\nof them fail.\n\n#### All streams are both binary and object mode streams\n\nA `map` function can be provided to map your input data into buffers\nor other formats. To indicate how much buffer space each data item takes\nan `byteLength` function can be provided as well.\n\nThis removes the need for two modes of streams.\n\n#### Simplicity\n\nThis is a full rewrite, all contained in one file.\n\nLots of stream methods are simplified based on how I and devs I work with actually use streams in the wild.\n\n#### Backwards compat\n\nstreamx aims to be compatible with Node.js streams whenever it is reasonable to do so.\n\nThis means that streamx streams behave a lot like Node.js streams from the outside but still provides the\nimprovements above.\n\n#### Smaller browser footprint\n\nstreamx has a much smaller footprint when compiled for the browser:\n\n```\n$ for x in stream{,x}; do echo $x: $(browserify -r $x | wc -c) bytes; done\nstream: 173844 bytes\nstreamx: 46943 bytes\n```\n\nWith optimizations turned on, the difference is even more stark:\n\n```\n$ for x in stream{,x}; do echo $x: $(browserify -r $x -p tinyify | wc -c) bytes; done\nstream: 62649 bytes\nstreamx: 8460 bytes\n$ for x in stream{,x}; do echo $x: $(browserify -r $x -p tinyify | gzip | wc -c) \"bytes (gzipped)\"; done\nstream: 18053 bytes (gzipped)\nstreamx: 2806 bytes (gzipped)\n```\n\n#### AbortSignal support\n\nTo make it easier to integrate streams in a `async/await` flow, all streams support a `signal` option\nthat accepts a [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) to as an\nalternative means to `.destroy` streams.\n\n## Usage\n\n```js\nconst { Readable } = require('streamx')\n\nconst rs = new Readable({\n  read(cb) {\n    this.push('Cool data')\n    cb(null)\n  }\n})\n\nrs.on('data', (data) => console.log('data:', data))\n```\n\n## API\n\nThis streamx package contains 4 streams similar to Node.js core.\n\n## Readable Stream\n\n#### `rs = new stream.Readable([options])`\n\nCreate a new readable stream.\n\nOptions include:\n\n```\n{\n  highWaterMark: 16384, // max buffer size in bytes\n  map: (data) => data, // optional function to map input data\n  byteLength: (data) => size, // optional function that calculates the byte size of input data\n  signal: abortController.signal, // optional AbortSignal that triggers `.destroy` when on `abort`\n  eagerOpen: false // eagerly open the stream\n}\n```\n\nIn addition you can pass the `open`, `read`, and `destroy` functions as shorthands in\nthe constructor instead of overwrite the methods below.\n\nThe default byteLength function returns the byte length of buffers and `1024`\nfor any other object. This means the buffer will contain around 16 non buffers\nor buffers worth 16kb when full if the defaults are used.\n\nIf you set highWaterMark to `0` then all read ahead buffering on the stream\nis disabled and it will only call `_read` when a user reads rather than ahead of time.\n\n#### `rs._read(cb)`\n\nThis function is called when the stream wants you to push new data.\nOverwrite this and add your own read logic.\nYou should call the callback when you are fully done with the read.\n\nCan also be set using `options.read` in the constructor.\n\nNote that this function differs from Node.js streams in that it takes\nthe \"read finished\" callback.\n\n#### `drained = rs.push(data)`\n\nPush new data to the stream. Returns true if the buffer is not full\nand you should push more data if you can.\n\nIf you call `rs.push(null)` you signal to the stream that no more\ndata will be pushed and that you want to end the stream.\n\n#### `data = rs.read()`\n\nRead a piece of data from the stream buffer. If the buffer is currently empty\n`null` will be returned and you should wait for `readable` to be emitted before\ntrying again. If the stream has been ended it will also return `null`.\n\nNote that this method differs from Node.js streams in that it does not accept\nan optional amounts of bytes to consume.\n\n#### `rs.unshift(data)`\n\nAdd a piece of data to the front of the buffer. Use this if you read too much\ndata using the `rs.read()` function.\n\n#### `rs._open(cb)`\n\nThis function is called once before the first read is issued. Use this function\nto implement your own open logic.\n\nCan also be set using `options.open` in the constructor.\n\n#### `rs._destroy(cb)`\n\nThis function is called just before the stream is fully destroyed. You should\nuse this to implement whatever teardown logic you need. The final part of the\nstream life cycle is always to call destroy itself so this function will always\nbe called whether or not the stream ends gracefully or forcefully.\n\nCan also be set using `options.destroy` in the constructor.\n\nNote that the `_destroy` might be called without the open function being called\nin case no read was ever performed on the stream.\n\n#### `rs._predestroy()`\n\nA simple hook that is called as soon as the first `stream.destroy()` call is invoked.\n\nUse this in case you need to cancel pending reads (if possible) instead of waiting for them to finish.\n\nCan also be set using `options.predestroy` in the constructor.\n\n#### `rs.destroy([error])`\n\nForcefully destroy the stream. Will call `_destroy` as soon as all pending reads have finished.\nOnce the stream is fully destroyed `close` will be emitted.\n\nIf you pass an error this error will be emitted just before `close` is, signifying a reason\nas to why this stream was destroyed.\n\n#### `rs.pause()`\n\nPauses the stream. You will only need to call this if you want to pause a resumed stream.\n\nReturns this stream instance.\n\n#### `rs.resume()`\n\nWill start reading data from the stream as fast as possible.\n\nIf you do not call this, you need to use the `read()` method to read data or the `pipe()` method to\npipe the stream somewhere else or the `data` handler.\n\nIf none of these option are used the stream will stay paused.\n\nReturns this stream instance.\n\n#### `rs.setEncoding(encoding)`\n\nSet an encoding to change how data is interpreted. E.g. `utf-8`.\n\n#### `bool = Readable.isPaused(rs)`\n\nReturns `true` if the stream is paused, else `false`.\n\n#### `writableStream = rs.pipe(writableStream, [callback])`\n\nEfficently pipe the readable stream to a writable stream (can be Node.js core stream or a stream from this package).\nIf you provide a callback the callback is called when the pipeline has fully finished with an optional error in case\nit failed.\n\nTo cancel the pipeline destroy either of the streams.\n\n#### `rs.on('readable')`\n\nEmitted when data is pushed to the stream if the buffer was previously empty.\n\n#### `rs.on('data', data)`\n\nEmitted when data is being read from the stream. If you attach a data handler you are implicitly resuming the stream.\n\n#### `rs.on('end')`\n\nEmitted when the readable stream has ended and no data is left in it's buffer.\n\n#### `rs.on('close')`\n\nEmitted when the readable stream has fully closed (i.e. it's destroy function has completed)\n\n#### `rs.on('error', err)`\n\nEmitted if any of the stream operations fail with an error. `close` is always emitted right after this.\n\n#### `rs.on('piping', dest)`\n\nEmitted when the readable stream is pipeing to a destination.\n\n#### `rs.on('open')`\n\nEmitted after `rs._open(cb)` execution.\n\n#### `rs.destroying`\n\nBoolean property indicating whether or not this stream has started to be destroyed.\n\n#### `rs.destroyed`\n\nBoolean property indicating whether or not this stream has been destroyed.\n\n#### `rs.readable`\n\nReturns `true` if the stream is an active streamx readable stream. Returns `undefined` if not.\n\n#### `bool = Readable.isBackpressured(rs)`\n\nStatic method to check if a readable stream is currently under backpressure.\n\n#### `stream = Readable.from(arrayOrBufferOrStringOrAsyncIterator)`\n\nStatic method to turn an array or buffer or string or AsyncIterator into a readable stream.\n\n## Writable Stream\n\n#### `ws = new stream.Writable([options])`\n\nCreate a new writable stream.\n\nOptions include:\n\n```\n{\n  highWaterMark: 16384, // max buffer size in bytes\n  map: (data) => data, // optional function to map input data\n  byteLength: (data) => size, // optional function that calculates the byte size of input data\n  signal: abortController.signal // optional AbortSignal that triggers `.destroy` when on `abort`\n}\n```\n\nIn addition you can pass the `open`, `write`, `final`, and `destroy` functions as shorthands in\nthe constructor instead of overwrite the methods below.\n\nThe default byteLength function returns the byte length of buffers and `1024`\nfor any other object. This means the buffer will contain around 16 non buffers\nor buffers worth 16kb when full if the defaults are used.\n\n#### `ws._open(cb)`\n\nThis function is called once before the first write is issued. Use this function\nto implement your own open logic.\n\nCan also be set using `options.open` in the constructor.\n\n#### `ws._destroy(cb)`\n\nThis function is called just before the stream is fully destroyed. You should\nuse this to implement whatever teardown logic you need. The final part of the\nstream life cycle is always to call destroy itself so this function will always\nbe called whether or not the stream ends gracefully or forcefully.\n\nCan also be set using `options.destroy` in the constructor.\n\nNote that the `_destroy` might be called without the open function being called\nin case no write was ever performed on the stream.\n\n#### `ws._predestroy()`\n\nA simple hook that is called as soon as the first `stream.destroy()` call is invoked.\n\nUse this in case you need to cancel pending writes (if possible) instead of waiting for them to finish.\n\nCan also be set using `options.predestroy` in the constructor.\n\n#### `ws.destroy([error])`\n\nForcefully destroy the stream. Will call `_destroy` as soon as all pending reads have finished.\nOnce the stream is fully destroyed `close` will be emitted.\n\nIf you pass an error this error will be emitted just before `close` is, signifying a reason\nas to why this stream was destroyed.\n\n#### `drained = ws.write(data)`\n\nWrite a piece of data to the stream. Returns `true` if the stream buffer is not full and you\nshould keep writing to it if you can. If `false` is returned the stream will emit `drain`\nonce it's buffer is fully drained.\n\n#### `ws._write(data, callback)`\n\nThis function is called when the stream want to write some data. Use this to implement your own\nwrite logic. When done call the callback and the stream will call it again if more data exists in the buffer.\n\nCan also be set using `options.write` in the constructor.\n\n#### `ws._writev(batch, callback)`\n\nSimilar to `_write` but passes an array of all data in the current write buffer instead of the oldest one.\nUseful if the destination you are writing the data to supports batching.\n\nCan also be set using `options.writev` in the constructor.\n\n#### `ws.end()`\n\nGracefully end the writable stream. Call this when you no longer want to write to the stream.\n\nOnce all writes have been fully drained `finish` will be emitted.\n\nReturns this stream instance.\n\n#### `ws.cork()`\n\nBuffer written data in memory. Useful for accumulating small chunks of data into a batch to be consumed by `writev`.\n\n#### `ws.uncork()`\n\nDisable `ws.cork()`.\n\n#### `ws._final(callback)`\n\nThis function is called just before `finish` is emitted, i.e. when all writes have flushed but `ws.end()`\nhave been called. Use this to implement any logic that should happen after all writes but before finish.\n\nCan also be set using `options.final` in the constructor.\n\n#### `ws.on('finish')`\n\nEmitted when the stream has been ended and all writes have been drained.\n\n#### `ws.on('close')`\n\nEmitted when the readable stream has fully closed (i.e. it's destroy function has completed)\n\n#### `ws.on('error', err)`\n\nEmitted if any of the stream operations fail with an error. `close` is always emitted right after this.\n\n#### `ws.on('pipe', src)`\n\nEmitted when a readable stream is being piped to the writable one.\n\n#### `ws.on('open')`\n\nEmitted after `ws._open(cb)` execution.\n\n#### `ws.on('drain')`\n\nEmitted after all data was drained if `ws.write(data)` returned `false`.\n\n#### `ws.destroying`\n\nBoolean property indicating whether or not this stream has started to be destroyed.\n\n#### `ws.destroyed`\n\nBoolean property indicating whether or not this stream has been destroyed.\n\n#### `ws.writable`\n\nReturns `true` if the stream is an active streamx writable stream. Returns `undefined` if not.\n\n#### `bool = Writable.isBackpressured(ws)`\n\nStatic method to check if a writable stream is currently under backpressure.\n\n#### `bool = await Writable.drained(ws)`\n\nStatic helper to wait for a stream to drain the currently queued writes.\nReturns true if they were drained and false otherwise if the stream was destroyed.\n\n## Duplex Stream\n\n#### `s = new stream.Duplex([options])`\n\nA duplex stream is a stream that is both readable and writable.\n\nSince JS does not support multiple inheritance it inherits directly from Readable\nbut implements the Writable API as well.\n\nIf you want to provide only a map function for the readable side use `mapReadable` instead.\nIf you want to provide only a byteLength function for the readable side use `byteLengthReadable` instead.\n\nSame goes for the writable side but using `mapWritable` and `byteLengthWritable` instead.\n\n## Transform Stream\n\nA Transform stream is a duplex stream with an `._transform` template method that allows to\nasynchronously map the input to a different output.\n\nThe transform stream overrides the `_write` and `_read` operations of `Readable` and `Writable` but\nstill allows the setting of these options in the constructor. Usually it is unnecessary to pass\nin `read` or `write`/`writev` or to override the corresponding `._read`, `._write` or `._writev` operation.\n\n#### `ts = new stream.Transform([options])`\n\nA transform stream is a duplex stream that maps the data written to it and emits that as readable data.\n\nHas the same options as a duplex stream except you can provide a `transform` function also.\n\n#### `ts._transform(data, callback)`\n\nTransform the incoming data. Call `callback(null, mappedData)` or use `ts.push(mappedData)` to\nreturn data to the readable side of the stream.\n\nPer default the transform function just remits the incoming data making it act as a pass-through stream.\n\n## Pipeline\n\n`pipeline` allows to stream form a readable through a set of duplex streams to a writable entry.\n\n```js\nconst { pipeline, Readable, Transform, Writable } = require('streamx')\nconst lastStream = pipeline(\n  Readable.from([1, 2, 3]),\n  new Transform({\n    transform (from, cb) {\n      this.push(from.toString())\n      cb()\n    }\n  }),\n  new Writable({\n    write (data, cb) {\n      console.log(data)\n      cb()\n    }\n  })\n  error => {\n    // Callback once write has finished\n  }\n)\n```\n\n#### `lastStream = stream.pipeline(...streams, [done])`\n\nPipe all streams together and return the last stream piped to.\nWhen the last stream finishes the pipeline ended succesfully.\n\nIf any of the streams error, whether they are Node.js core streams\nor streamx streams, all streams in the pipeline are shutdown.\n\nOptionally you can pass a done callback to know when the pipeline is done.\n\n#### `promise = stream.pipelinePromise(...streams)`\n\nSame as normal pipeline except instead of returning the last stream it returns\na promise representing the done callback. Note you should error handle this\npromise if you use this version.\n\n## Helpers\n\n#### `bool = isStream(stream)`\n\n#### `bool = isStreamx(stream)`\n\n#### `bool = isDisturbed(stream)`\n\nIndicates if the stream has been opened or started to be destroyed.\n\n#### `bool = isEnding(stream)`\n\nIndicates if a readable stream has started it's ending process.\n\n#### `bool = isEnded(stream)`\n\nIndicates if a readable stream ended, so all it's readings.\n\n#### `bool = isFinishing(stream)`\n\nIndicates if a writable stream has started it's ending process.\n\n#### `bool = isFinished(stream)`\n\nIndicates if a writable stream ended, so all it's writings.\n\n#### `err = getStreamError(stream, [options])`\n\nReturns `null` if the stream has no errors.\n\n## Utilities\n\nStreamx aims to be minimal and stable. It therefore only contains a minimal set of utilities.\nTo help discover of other modules that help you build streamx apps, we link some useful utilities here\n\n- [stream-composer](https://github.com/mafintosh/stream-composer) - Compose streams like Node's `stream.compose` and the `duplexify` and `pumpify` modules.\n- [teex](https://github.com/mafintosh/teex) - Clone a readable stream into multiple new readable instances.\n- [merge-readable](https://github.com/holepunchto/merge-readable) - Merge multiple readers into a new readable with optional mapping of data\n\n## Contributing\n\nIf you want to help contribute to streamx a good way to start is to help writing more test\ncases, compatibility tests, documentation, or performance benchmarks.\n\nIf in doubt open an issue :)\n\n## License\n\nMIT",
   "_attachments": {}