diff --git a/node_modules/npm-lifecycle/CHANGELOG.md b/node_modules/npm-lifecycle/CHANGELOG.md
index 7e7bc92e2922e..fb74ec450c30f 100644
--- a/node_modules/npm-lifecycle/CHANGELOG.md
+++ b/node_modules/npm-lifecycle/CHANGELOG.md
@@ -2,6 +2,16 @@
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## [2.1.1](https://github.com/npm/lifecycle/compare/v2.1.0...v2.1.1) (2019-05-08)
+
+
+### Bug Fixes
+
+* **test:** update postinstall script for fixture ([220cd70](https://github.com/npm/lifecycle/commit/220cd70))
+
+
+
# [2.1.0](https://github.com/npm/lifecycle/compare/v2.0.3...v2.1.0) (2018-08-13)
diff --git a/node_modules/npm-lifecycle/index.js b/node_modules/npm-lifecycle/index.js
index 4eb83255a94a2..4a664596047ed 100644
--- a/node_modules/npm-lifecycle/index.js
+++ b/node_modules/npm-lifecycle/index.js
@@ -167,7 +167,7 @@ function shouldPrependCurrentNodeDirToPATH (opts) {
var isWindows = process.platform === 'win32'
var foundExecPath
try {
- foundExecPath = which.sync(path.basename(process.execPath), {pathExt: isWindows ? ';' : ':'})
+ foundExecPath = which.sync(path.basename(process.execPath), { pathExt: isWindows ? ';' : ':' })
// Apply `fs.realpath()` here to avoid false positives when `node` is a symlinked executable.
isDifferentNodeInPath = fs.realpathSync(process.execPath).toUpperCase() !==
fs.realpathSync(foundExecPath).toUpperCase()
diff --git a/node_modules/npm-lifecycle/node_modules/.bin/node-gyp b/node_modules/npm-lifecycle/node_modules/.bin/node-gyp
new file mode 120000
index 0000000000000..9b31a4fe437b3
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/.bin/node-gyp
@@ -0,0 +1 @@
+../node-gyp/bin/node-gyp.js
\ No newline at end of file
diff --git a/node_modules/npm-lifecycle/node_modules/.bin/nopt b/node_modules/npm-lifecycle/node_modules/.bin/nopt
new file mode 120000
index 0000000000000..6b6566ea7febb
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/.bin/nopt
@@ -0,0 +1 @@
+../nopt/bin/nopt.js
\ No newline at end of file
diff --git a/node_modules/npm-lifecycle/node_modules/.bin/semver b/node_modules/npm-lifecycle/node_modules/.bin/semver
new file mode 120000
index 0000000000000..317eb293d8e12
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/.bin/semver
@@ -0,0 +1 @@
+../semver/bin/semver
\ No newline at end of file
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/.github/ISSUE_TEMPLATE.md b/node_modules/npm-lifecycle/node_modules/node-gyp/.github/ISSUE_TEMPLATE.md
new file mode 100644
index 0000000000000..dbd053a90b38f
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,26 @@
+
+
+* **Node Version**:
+* **Platform**:
+* **Compiler**:
+* **Module**:
+
+Verbose output (from npm or node-gyp):
+
+
+
+```
+
+```
+
+[\'"])(.*?)(? 0:
+ after = True
+
+ # This catches the special case of a closing brace having something
+ # other than just whitespace ahead of it -- we don't want to
+ # unindent that until after this line is printed so it stays with
+ # the previous indentation level.
+ if cnt < 0 and closing_prefix_re.match(stripline):
+ after = True
+ return (cnt, after)
+
+
+def prettyprint_input(lines):
+ """Does the main work of indenting the input based on the brace counts."""
+ indent = 0
+ basic_offset = 2
+ last_line = ""
+ for line in lines:
+ if COMMENT_RE.match(line):
+ print line
+ else:
+ line = line.strip('\r\n\t ') # Otherwise doesn't strip \r on Unix.
+ if len(line) > 0:
+ (brace_diff, after) = count_braces(line)
+ if brace_diff != 0:
+ if after:
+ print " " * (basic_offset * indent) + line
+ indent += brace_diff
+ else:
+ indent += brace_diff
+ print " " * (basic_offset * indent) + line
+ else:
+ print " " * (basic_offset * indent) + line
+ else:
+ print ""
+ last_line = line
+
+
+def main():
+ if len(sys.argv) > 1:
+ data = open(sys.argv[1]).read().splitlines()
+ else:
+ data = sys.stdin.read().splitlines()
+ # Split up the double braces.
+ lines = split_double_braces(data)
+
+ # Indent and print the output.
+ prettyprint_input(lines)
+ return 0
+
+
+if __name__ == '__main__':
+ sys.exit(main())
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/gyp/tools/pretty_sln.py b/node_modules/npm-lifecycle/node_modules/node-gyp/gyp/tools/pretty_sln.py
new file mode 100755
index 0000000000000..ca8cf4ad3fb83
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/gyp/tools/pretty_sln.py
@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Prints the information in a sln file in a diffable way.
+
+ It first outputs each projects in alphabetical order with their
+ dependencies.
+
+ Then it outputs a possible build order.
+"""
+
+__author__ = 'nsylvain (Nicolas Sylvain)'
+
+import os
+import re
+import sys
+import pretty_vcproj
+
+def BuildProject(project, built, projects, deps):
+ # if all dependencies are done, we can build it, otherwise we try to build the
+ # dependency.
+ # This is not infinite-recursion proof.
+ for dep in deps[project]:
+ if dep not in built:
+ BuildProject(dep, built, projects, deps)
+ print project
+ built.append(project)
+
+def ParseSolution(solution_file):
+ # All projects, their clsid and paths.
+ projects = dict()
+
+ # A list of dependencies associated with a project.
+ dependencies = dict()
+
+ # Regular expressions that matches the SLN format.
+ # The first line of a project definition.
+ begin_project = re.compile(r'^Project\("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942'
+ r'}"\) = "(.*)", "(.*)", "(.*)"$')
+ # The last line of a project definition.
+ end_project = re.compile('^EndProject$')
+ # The first line of a dependency list.
+ begin_dep = re.compile(
+ r'ProjectSection\(ProjectDependencies\) = postProject$')
+ # The last line of a dependency list.
+ end_dep = re.compile('EndProjectSection$')
+ # A line describing a dependency.
+ dep_line = re.compile(' *({.*}) = ({.*})$')
+
+ in_deps = False
+ solution = open(solution_file)
+ for line in solution:
+ results = begin_project.search(line)
+ if results:
+ # Hack to remove icu because the diff is too different.
+ if results.group(1).find('icu') != -1:
+ continue
+ # We remove "_gyp" from the names because it helps to diff them.
+ current_project = results.group(1).replace('_gyp', '')
+ projects[current_project] = [results.group(2).replace('_gyp', ''),
+ results.group(3),
+ results.group(2)]
+ dependencies[current_project] = []
+ continue
+
+ results = end_project.search(line)
+ if results:
+ current_project = None
+ continue
+
+ results = begin_dep.search(line)
+ if results:
+ in_deps = True
+ continue
+
+ results = end_dep.search(line)
+ if results:
+ in_deps = False
+ continue
+
+ results = dep_line.search(line)
+ if results and in_deps and current_project:
+ dependencies[current_project].append(results.group(1))
+ continue
+
+ # Change all dependencies clsid to name instead.
+ for project in dependencies:
+ # For each dependencies in this project
+ new_dep_array = []
+ for dep in dependencies[project]:
+ # Look for the project name matching this cldis
+ for project_info in projects:
+ if projects[project_info][1] == dep:
+ new_dep_array.append(project_info)
+ dependencies[project] = sorted(new_dep_array)
+
+ return (projects, dependencies)
+
+def PrintDependencies(projects, deps):
+ print "---------------------------------------"
+ print "Dependencies for all projects"
+ print "---------------------------------------"
+ print "-- --"
+
+ for (project, dep_list) in sorted(deps.items()):
+ print "Project : %s" % project
+ print "Path : %s" % projects[project][0]
+ if dep_list:
+ for dep in dep_list:
+ print " - %s" % dep
+ print ""
+
+ print "-- --"
+
+def PrintBuildOrder(projects, deps):
+ print "---------------------------------------"
+ print "Build order "
+ print "---------------------------------------"
+ print "-- --"
+
+ built = []
+ for (project, _) in sorted(deps.items()):
+ if project not in built:
+ BuildProject(project, built, projects, deps)
+
+ print "-- --"
+
+def PrintVCProj(projects):
+
+ for project in projects:
+ print "-------------------------------------"
+ print "-------------------------------------"
+ print project
+ print project
+ print project
+ print "-------------------------------------"
+ print "-------------------------------------"
+
+ project_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[1]),
+ projects[project][2]))
+
+ pretty = pretty_vcproj
+ argv = [ '',
+ project_path,
+ '$(SolutionDir)=%s\\' % os.path.dirname(sys.argv[1]),
+ ]
+ argv.extend(sys.argv[3:])
+ pretty.main(argv)
+
+def main():
+ # check if we have exactly 1 parameter.
+ if len(sys.argv) < 2:
+ print 'Usage: %s "c:\\path\\to\\project.sln"' % sys.argv[0]
+ return 1
+
+ (projects, deps) = ParseSolution(sys.argv[1])
+ PrintDependencies(projects, deps)
+ PrintBuildOrder(projects, deps)
+
+ if '--recursive' in sys.argv:
+ PrintVCProj(projects)
+ return 0
+
+
+if __name__ == '__main__':
+ sys.exit(main())
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/gyp/tools/pretty_vcproj.py b/node_modules/npm-lifecycle/node_modules/node-gyp/gyp/tools/pretty_vcproj.py
new file mode 100755
index 0000000000000..6099bd7cc4d8c
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/gyp/tools/pretty_vcproj.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Make the format of a vcproj really pretty.
+
+ This script normalize and sort an xml. It also fetches all the properties
+ inside linked vsprops and include them explicitly in the vcproj.
+
+ It outputs the resulting xml to stdout.
+"""
+
+__author__ = 'nsylvain (Nicolas Sylvain)'
+
+import os
+import sys
+
+from xml.dom.minidom import parse
+from xml.dom.minidom import Node
+
+REPLACEMENTS = dict()
+ARGUMENTS = None
+
+
+class CmpTuple(object):
+ """Compare function between 2 tuple."""
+ def __call__(self, x, y):
+ return cmp(x[0], y[0])
+
+
+class CmpNode(object):
+ """Compare function between 2 xml nodes."""
+
+ def __call__(self, x, y):
+ def get_string(node):
+ node_string = "node"
+ node_string += node.nodeName
+ if node.nodeValue:
+ node_string += node.nodeValue
+
+ if node.attributes:
+ # We first sort by name, if present.
+ node_string += node.getAttribute("Name")
+
+ all_nodes = []
+ for (name, value) in node.attributes.items():
+ all_nodes.append((name, value))
+
+ all_nodes.sort(CmpTuple())
+ for (name, value) in all_nodes:
+ node_string += name
+ node_string += value
+
+ return node_string
+
+ return cmp(get_string(x), get_string(y))
+
+
+def PrettyPrintNode(node, indent=0):
+ if node.nodeType == Node.TEXT_NODE:
+ if node.data.strip():
+ print '%s%s' % (' '*indent, node.data.strip())
+ return
+
+ if node.childNodes:
+ node.normalize()
+ # Get the number of attributes
+ attr_count = 0
+ if node.attributes:
+ attr_count = node.attributes.length
+
+ # Print the main tag
+ if attr_count == 0:
+ print '%s<%s>' % (' '*indent, node.nodeName)
+ else:
+ print '%s<%s' % (' '*indent, node.nodeName)
+
+ all_attributes = []
+ for (name, value) in node.attributes.items():
+ all_attributes.append((name, value))
+ all_attributes.sort(CmpTuple())
+ for (name, value) in all_attributes:
+ print '%s %s="%s"' % (' '*indent, name, value)
+ print '%s>' % (' '*indent)
+ if node.nodeValue:
+ print '%s %s' % (' '*indent, node.nodeValue)
+
+ for sub_node in node.childNodes:
+ PrettyPrintNode(sub_node, indent=indent+2)
+ print '%s' % (' '*indent, node.nodeName)
+
+
+def FlattenFilter(node):
+ """Returns a list of all the node and sub nodes."""
+ node_list = []
+
+ if (node.attributes and
+ node.getAttribute('Name') == '_excluded_files'):
+ # We don't add the "_excluded_files" filter.
+ return []
+
+ for current in node.childNodes:
+ if current.nodeName == 'Filter':
+ node_list.extend(FlattenFilter(current))
+ else:
+ node_list.append(current)
+
+ return node_list
+
+
+def FixFilenames(filenames, current_directory):
+ new_list = []
+ for filename in filenames:
+ if filename:
+ for key in REPLACEMENTS:
+ filename = filename.replace(key, REPLACEMENTS[key])
+ os.chdir(current_directory)
+ filename = filename.strip('"\' ')
+ if filename.startswith('$'):
+ new_list.append(filename)
+ else:
+ new_list.append(os.path.abspath(filename))
+ return new_list
+
+
+def AbsoluteNode(node):
+ """Makes all the properties we know about in this node absolute."""
+ if node.attributes:
+ for (name, value) in node.attributes.items():
+ if name in ['InheritedPropertySheets', 'RelativePath',
+ 'AdditionalIncludeDirectories',
+ 'IntermediateDirectory', 'OutputDirectory',
+ 'AdditionalLibraryDirectories']:
+ # We want to fix up these paths
+ path_list = value.split(';')
+ new_list = FixFilenames(path_list, os.path.dirname(ARGUMENTS[1]))
+ node.setAttribute(name, ';'.join(new_list))
+ if not value:
+ node.removeAttribute(name)
+
+
+def CleanupVcproj(node):
+ """For each sub node, we call recursively this function."""
+ for sub_node in node.childNodes:
+ AbsoluteNode(sub_node)
+ CleanupVcproj(sub_node)
+
+ # Normalize the node, and remove all extranous whitespaces.
+ for sub_node in node.childNodes:
+ if sub_node.nodeType == Node.TEXT_NODE:
+ sub_node.data = sub_node.data.replace("\r", "")
+ sub_node.data = sub_node.data.replace("\n", "")
+ sub_node.data = sub_node.data.rstrip()
+
+ # Fix all the semicolon separated attributes to be sorted, and we also
+ # remove the dups.
+ if node.attributes:
+ for (name, value) in node.attributes.items():
+ sorted_list = sorted(value.split(';'))
+ unique_list = []
+ for i in sorted_list:
+ if not unique_list.count(i):
+ unique_list.append(i)
+ node.setAttribute(name, ';'.join(unique_list))
+ if not value:
+ node.removeAttribute(name)
+
+ if node.childNodes:
+ node.normalize()
+
+ # For each node, take a copy, and remove it from the list.
+ node_array = []
+ while node.childNodes and node.childNodes[0]:
+ # Take a copy of the node and remove it from the list.
+ current = node.childNodes[0]
+ node.removeChild(current)
+
+ # If the child is a filter, we want to append all its children
+ # to this same list.
+ if current.nodeName == 'Filter':
+ node_array.extend(FlattenFilter(current))
+ else:
+ node_array.append(current)
+
+
+ # Sort the list.
+ node_array.sort(CmpNode())
+
+ # Insert the nodes in the correct order.
+ for new_node in node_array:
+ # But don't append empty tool node.
+ if new_node.nodeName == 'Tool':
+ if new_node.attributes and new_node.attributes.length == 1:
+ # This one was empty.
+ continue
+ if new_node.nodeName == 'UserMacro':
+ continue
+ node.appendChild(new_node)
+
+
+def GetConfiguationNodes(vcproj):
+ #TODO(nsylvain): Find a better way to navigate the xml.
+ nodes = []
+ for node in vcproj.childNodes:
+ if node.nodeName == "Configurations":
+ for sub_node in node.childNodes:
+ if sub_node.nodeName == "Configuration":
+ nodes.append(sub_node)
+
+ return nodes
+
+
+def GetChildrenVsprops(filename):
+ dom = parse(filename)
+ if dom.documentElement.attributes:
+ vsprops = dom.documentElement.getAttribute('InheritedPropertySheets')
+ return FixFilenames(vsprops.split(';'), os.path.dirname(filename))
+ return []
+
+def SeekToNode(node1, child2):
+ # A text node does not have properties.
+ if child2.nodeType == Node.TEXT_NODE:
+ return None
+
+ # Get the name of the current node.
+ current_name = child2.getAttribute("Name")
+ if not current_name:
+ # There is no name. We don't know how to merge.
+ return None
+
+ # Look through all the nodes to find a match.
+ for sub_node in node1.childNodes:
+ if sub_node.nodeName == child2.nodeName:
+ name = sub_node.getAttribute("Name")
+ if name == current_name:
+ return sub_node
+
+ # No match. We give up.
+ return None
+
+
+def MergeAttributes(node1, node2):
+ # No attributes to merge?
+ if not node2.attributes:
+ return
+
+ for (name, value2) in node2.attributes.items():
+ # Don't merge the 'Name' attribute.
+ if name == 'Name':
+ continue
+ value1 = node1.getAttribute(name)
+ if value1:
+ # The attribute exist in the main node. If it's equal, we leave it
+ # untouched, otherwise we concatenate it.
+ if value1 != value2:
+ node1.setAttribute(name, ';'.join([value1, value2]))
+ else:
+ # The attribute does nto exist in the main node. We append this one.
+ node1.setAttribute(name, value2)
+
+ # If the attribute was a property sheet attributes, we remove it, since
+ # they are useless.
+ if name == 'InheritedPropertySheets':
+ node1.removeAttribute(name)
+
+
+def MergeProperties(node1, node2):
+ MergeAttributes(node1, node2)
+ for child2 in node2.childNodes:
+ child1 = SeekToNode(node1, child2)
+ if child1:
+ MergeProperties(child1, child2)
+ else:
+ node1.appendChild(child2.cloneNode(True))
+
+
+def main(argv):
+ """Main function of this vcproj prettifier."""
+ global ARGUMENTS
+ ARGUMENTS = argv
+
+ # check if we have exactly 1 parameter.
+ if len(argv) < 2:
+ print ('Usage: %s "c:\\path\\to\\vcproj.vcproj" [key1=value1] '
+ '[key2=value2]' % argv[0])
+ return 1
+
+ # Parse the keys
+ for i in range(2, len(argv)):
+ (key, value) = argv[i].split('=')
+ REPLACEMENTS[key] = value
+
+ # Open the vcproj and parse the xml.
+ dom = parse(argv[1])
+
+ # First thing we need to do is find the Configuration Node and merge them
+ # with the vsprops they include.
+ for configuration_node in GetConfiguationNodes(dom.documentElement):
+ # Get the property sheets associated with this configuration.
+ vsprops = configuration_node.getAttribute('InheritedPropertySheets')
+
+ # Fix the filenames to be absolute.
+ vsprops_list = FixFilenames(vsprops.strip().split(';'),
+ os.path.dirname(argv[1]))
+
+ # Extend the list of vsprops with all vsprops contained in the current
+ # vsprops.
+ for current_vsprops in vsprops_list:
+ vsprops_list.extend(GetChildrenVsprops(current_vsprops))
+
+ # Now that we have all the vsprops, we need to merge them.
+ for current_vsprops in vsprops_list:
+ MergeProperties(configuration_node,
+ parse(current_vsprops).documentElement)
+
+ # Now that everything is merged, we need to cleanup the xml.
+ CleanupVcproj(dom.documentElement)
+
+ # Finally, we use the prett xml function to print the vcproj back to the
+ # user.
+ #print dom.toprettyxml(newl="\n")
+ PrettyPrintNode(dom.documentElement)
+ return 0
+
+
+if __name__ == '__main__':
+ sys.exit(main(sys.argv))
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/Find-VS2017.cs b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/Find-VS2017.cs
new file mode 100644
index 0000000000000..6e7429b771385
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/Find-VS2017.cs
@@ -0,0 +1,273 @@
+// Copyright 2017 - Refael Ackermann
+// Distributed under MIT style license
+// See accompanying file LICENSE at https://github.com/node4good/windows-autoconf
+
+// Usage:
+// powershell -ExecutionPolicy Unrestricted -Version "2.0" -Command "&{Add-Type -Path Find-VS2017.cs; [VisualStudioConfiguration.Main]::Query()}"
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace VisualStudioConfiguration
+{
+ [Flags]
+ public enum InstanceState : uint
+ {
+ None = 0,
+ Local = 1,
+ Registered = 2,
+ NoRebootRequired = 4,
+ NoErrors = 8,
+ Complete = 4294967295,
+ }
+
+ [Guid("6380BCFF-41D3-4B2E-8B2E-BF8A6810C848")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface IEnumSetupInstances
+ {
+
+ void Next([MarshalAs(UnmanagedType.U4), In] int celt,
+ [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Interface), Out] ISetupInstance[] rgelt,
+ [MarshalAs(UnmanagedType.U4)] out int pceltFetched);
+
+ void Skip([MarshalAs(UnmanagedType.U4), In] int celt);
+
+ void Reset();
+
+ [return: MarshalAs(UnmanagedType.Interface)]
+ IEnumSetupInstances Clone();
+ }
+
+ [Guid("42843719-DB4C-46C2-8E7C-64F1816EFD5B")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface ISetupConfiguration
+ {
+ }
+
+ [Guid("26AAB78C-4A60-49D6-AF3B-3C35BC93365D")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface ISetupConfiguration2 : ISetupConfiguration
+ {
+
+ [return: MarshalAs(UnmanagedType.Interface)]
+ IEnumSetupInstances EnumInstances();
+
+ [return: MarshalAs(UnmanagedType.Interface)]
+ ISetupInstance GetInstanceForCurrentProcess();
+
+ [return: MarshalAs(UnmanagedType.Interface)]
+ ISetupInstance GetInstanceForPath([MarshalAs(UnmanagedType.LPWStr), In] string path);
+
+ [return: MarshalAs(UnmanagedType.Interface)]
+ IEnumSetupInstances EnumAllInstances();
+ }
+
+ [Guid("B41463C3-8866-43B5-BC33-2B0676F7F42E")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface ISetupInstance
+ {
+ }
+
+ [Guid("89143C9A-05AF-49B0-B717-72E218A2185C")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface ISetupInstance2 : ISetupInstance
+ {
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetInstanceId();
+
+ [return: MarshalAs(UnmanagedType.Struct)]
+ System.Runtime.InteropServices.ComTypes.FILETIME GetInstallDate();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetInstallationName();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetInstallationPath();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetInstallationVersion();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetDisplayName([MarshalAs(UnmanagedType.U4), In] int lcid);
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetDescription([MarshalAs(UnmanagedType.U4), In] int lcid);
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string ResolvePath([MarshalAs(UnmanagedType.LPWStr), In] string pwszRelativePath);
+
+ [return: MarshalAs(UnmanagedType.U4)]
+ InstanceState GetState();
+
+ [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_UNKNOWN)]
+ ISetupPackageReference[] GetPackages();
+
+ ISetupPackageReference GetProduct();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetProductPath();
+
+ [return: MarshalAs(UnmanagedType.VariantBool)]
+ bool IsLaunchable();
+
+ [return: MarshalAs(UnmanagedType.VariantBool)]
+ bool IsComplete();
+
+ [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_UNKNOWN)]
+ ISetupPropertyStore GetProperties();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetEnginePath();
+ }
+
+ [Guid("DA8D8A16-B2B6-4487-A2F1-594CCCCD6BF5")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface ISetupPackageReference
+ {
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetId();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetVersion();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetChip();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetLanguage();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetBranch();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetType();
+
+ [return: MarshalAs(UnmanagedType.BStr)]
+ string GetUniqueId();
+
+ [return: MarshalAs(UnmanagedType.VariantBool)]
+ bool GetIsExtension();
+ }
+
+ [Guid("c601c175-a3be-44bc-91f6-4568d230fc83")]
+ [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+ [ComImport]
+ public interface ISetupPropertyStore
+ {
+
+ [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_BSTR)]
+ string[] GetNames();
+
+ object GetValue([MarshalAs(UnmanagedType.LPWStr), In] string pwszName);
+ }
+
+ [Guid("42843719-DB4C-46C2-8E7C-64F1816EFD5B")]
+ [CoClass(typeof(SetupConfigurationClass))]
+ [ComImport]
+ public interface SetupConfiguration : ISetupConfiguration2, ISetupConfiguration
+ {
+ }
+
+ [Guid("177F0C4A-1CD3-4DE7-A32C-71DBBB9FA36D")]
+ [ClassInterface(ClassInterfaceType.None)]
+ [ComImport]
+ public class SetupConfigurationClass
+ {
+ }
+
+ public static class Main
+ {
+ public static void Query()
+ {
+ ISetupConfiguration query = new SetupConfiguration();
+ ISetupConfiguration2 query2 = (ISetupConfiguration2)query;
+ IEnumSetupInstances e = query2.EnumAllInstances();
+
+ int pceltFetched;
+ ISetupInstance2[] rgelt = new ISetupInstance2[1];
+ StringBuilder log = new StringBuilder();
+ while (true)
+ {
+ e.Next(1, rgelt, out pceltFetched);
+ if (pceltFetched <= 0)
+ {
+ Console.WriteLine(String.Format("{{\"log\":\"{0}\"}}", log.ToString()));
+ return;
+ }
+ if (CheckInstance(rgelt[0], ref log))
+ return;
+ }
+ }
+
+ private static bool CheckInstance(ISetupInstance2 setupInstance2, ref StringBuilder log)
+ {
+ // Visual Studio Community 2017 component directory:
+ // https://www.visualstudio.com/en-us/productinfo/vs2017-install-product-Community.workloads
+
+ string path = setupInstance2.GetInstallationPath().Replace("\\", "\\\\");
+ log.Append(String.Format("Found installation at: {0}\\n", path));
+
+ bool hasMSBuild = false;
+ bool hasVCTools = false;
+ uint Win10SDKVer = 0;
+ bool hasWin8SDK = false;
+
+ foreach (ISetupPackageReference package in setupInstance2.GetPackages())
+ {
+ const string Win10SDKPrefix = "Microsoft.VisualStudio.Component.Windows10SDK.";
+
+ string id = package.GetId();
+ if (id == "Microsoft.VisualStudio.VC.MSBuild.Base")
+ hasMSBuild = true;
+ else if (id == "Microsoft.VisualStudio.Component.VC.Tools.x86.x64")
+ hasVCTools = true;
+ else if (id.StartsWith(Win10SDKPrefix)) {
+ string[] parts = id.Substring(Win10SDKPrefix.Length).Split('.');
+ if (parts.Length > 1 && parts[1] != "Desktop")
+ continue;
+ uint foundSdkVer;
+ if (UInt32.TryParse(parts[0], out foundSdkVer))
+ Win10SDKVer = Math.Max(Win10SDKVer, foundSdkVer);
+ } else if (id == "Microsoft.VisualStudio.Component.Windows81SDK")
+ hasWin8SDK = true;
+ else
+ continue;
+
+ log.Append(String.Format(" - Found {0}\\n", id));
+ }
+
+ if (!hasMSBuild)
+ log.Append(" - Missing Visual Studio C++ core features (Microsoft.VisualStudio.VC.MSBuild.Base)\\n");
+ if (!hasVCTools)
+ log.Append(" - Missing VC++ 2017 v141 toolset (x86,x64) (Microsoft.VisualStudio.Component.VC.Tools.x86.x64)\\n");
+ if ((Win10SDKVer == 0) && (!hasWin8SDK))
+ log.Append(" - Missing a Windows SDK (Microsoft.VisualStudio.Component.Windows10SDK.* or Microsoft.VisualStudio.Component.Windows81SDK)\\n");
+
+ if (hasMSBuild && hasVCTools)
+ {
+ if (Win10SDKVer > 0)
+ {
+ log.Append(" - Using this installation with Windows 10 SDK"/*\\n*/);
+ Console.WriteLine(String.Format("{{\"log\":\"{0}\",\"path\":\"{1}\",\"sdk\":\"10.0.{2}.0\"}}", log.ToString(), path, Win10SDKVer));
+ return true;
+ }
+ else if (hasWin8SDK)
+ {
+ log.Append(" - Using this installation with Windows 8.1 SDK"/*\\n*/);
+ Console.WriteLine(String.Format("{{\"log\":\"{0}\",\"path\":\"{1}\",\"sdk\":\"8.1\"}}", log.ToString(), path));
+ return true;
+ }
+ }
+
+ log.Append(" - Some required components are missing, not using this installation\\n");
+ return false;
+ }
+ }
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/build.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/build.js
new file mode 100644
index 0000000000000..2f8e14c37429d
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/build.js
@@ -0,0 +1,270 @@
+
+module.exports = exports = build
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('graceful-fs')
+ , rm = require('rimraf')
+ , path = require('path')
+ , glob = require('glob')
+ , log = require('npmlog')
+ , which = require('which')
+ , exec = require('child_process').exec
+ , processRelease = require('./process-release')
+ , win = process.platform === 'win32'
+
+exports.usage = 'Invokes `' + (win ? 'msbuild' : 'make') + '` and builds the module'
+
+function build (gyp, argv, callback) {
+ var platformMake = 'make'
+ if (process.platform === 'aix') {
+ platformMake = 'gmake'
+ } else if (process.platform.indexOf('bsd') !== -1) {
+ platformMake = 'gmake'
+ } else if (win && argv.length > 0) {
+ argv = argv.map(function(target) {
+ return '/t:' + target
+ })
+ }
+
+ var release = processRelease(argv, gyp, process.version, process.release)
+ , makeCommand = gyp.opts.make || process.env.MAKE || platformMake
+ , command = win ? 'msbuild' : makeCommand
+ , buildDir = path.resolve('build')
+ , configPath = path.resolve(buildDir, 'config.gypi')
+ , jobs = gyp.opts.jobs || process.env.JOBS
+ , buildType
+ , config
+ , arch
+ , nodeDir
+
+ loadConfigGypi()
+
+ /**
+ * Load the "config.gypi" file that was generated during "configure".
+ */
+
+ function loadConfigGypi () {
+ fs.readFile(configPath, 'utf8', function (err, data) {
+ if (err) {
+ if (err.code == 'ENOENT') {
+ callback(new Error('You must run `node-gyp configure` first!'))
+ } else {
+ callback(err)
+ }
+ return
+ }
+ config = JSON.parse(data.replace(/\#.+\n/, ''))
+
+ // get the 'arch', 'buildType', and 'nodeDir' vars from the config
+ buildType = config.target_defaults.default_configuration
+ arch = config.variables.target_arch
+ nodeDir = config.variables.nodedir
+
+ if ('debug' in gyp.opts) {
+ buildType = gyp.opts.debug ? 'Debug' : 'Release'
+ }
+ if (!buildType) {
+ buildType = 'Release'
+ }
+
+ log.verbose('build type', buildType)
+ log.verbose('architecture', arch)
+ log.verbose('node dev dir', nodeDir)
+
+ if (win) {
+ findSolutionFile()
+ } else {
+ doWhich()
+ }
+ })
+ }
+
+ /**
+ * On Windows, find the first build/*.sln file.
+ */
+
+ function findSolutionFile () {
+ glob('build/*.sln', function (err, files) {
+ if (err) return callback(err)
+ if (files.length === 0) {
+ return callback(new Error('Could not find *.sln file. Did you run "configure"?'))
+ }
+ guessedSolution = files[0]
+ log.verbose('found first Solution file', guessedSolution)
+ doWhich()
+ })
+ }
+
+ /**
+ * Uses node-which to locate the msbuild / make executable.
+ */
+
+ function doWhich () {
+ // First make sure we have the build command in the PATH
+ which(command, function (err, execPath) {
+ if (err) {
+ if (win && /not found/.test(err.message)) {
+ // On windows and no 'msbuild' found. Let's guess where it is
+ findMsbuild()
+ } else {
+ // Some other error or 'make' not found on Unix, report that to the user
+ callback(err)
+ }
+ return
+ }
+ log.verbose('`which` succeeded for `' + command + '`', execPath)
+ doBuild()
+ })
+ }
+
+ /**
+ * Search for the location of "msbuild.exe" file on Windows.
+ */
+
+ function findMsbuild () {
+ if (config.variables.msbuild_path) {
+ command = config.variables.msbuild_path
+ log.verbose('using MSBuild:', command)
+ doBuild()
+ return
+ }
+
+ log.verbose('could not find "msbuild.exe" in PATH - finding location in registry')
+ var notfoundErr = 'Can\'t find "msbuild.exe". Do you have Microsoft Visual Studio C++ 2008+ installed?'
+ var cmd = 'reg query "HKLM\\Software\\Microsoft\\MSBuild\\ToolsVersions" /s'
+ if (process.arch !== 'ia32')
+ cmd += ' /reg:32'
+ exec(cmd, function (err, stdout, stderr) {
+ if (err) {
+ return callback(new Error(err.message + '\n' + notfoundErr))
+ }
+ var reVers = /ToolsVersions\\([^\\]+)$/i
+ , rePath = /\r\n[ \t]+MSBuildToolsPath[ \t]+REG_SZ[ \t]+([^\r]+)/i
+ , msbuilds = []
+ , r
+ , msbuildPath
+ stdout.split('\r\n\r\n').forEach(function(l) {
+ if (!l) return
+ l = l.trim()
+ if (r = reVers.exec(l.substring(0, l.indexOf('\r\n')))) {
+ var ver = parseFloat(r[1], 10)
+ if (ver >= 3.5) {
+ if (r = rePath.exec(l)) {
+ msbuilds.push({
+ version: ver,
+ path: r[1]
+ })
+ }
+ }
+ }
+ })
+ msbuilds.sort(function (x, y) {
+ return (x.version < y.version ? -1 : 1)
+ })
+ ;(function verifyMsbuild () {
+ if (!msbuilds.length) return callback(new Error(notfoundErr))
+ msbuildPath = path.resolve(msbuilds.pop().path, 'msbuild.exe')
+ fs.stat(msbuildPath, function (err, stat) {
+ if (err) {
+ if (err.code == 'ENOENT') {
+ if (msbuilds.length) {
+ return verifyMsbuild()
+ } else {
+ callback(new Error(notfoundErr))
+ }
+ } else {
+ callback(err)
+ }
+ return
+ }
+ command = msbuildPath
+ doBuild()
+ })
+ })()
+ })
+ }
+
+
+ /**
+ * Actually spawn the process and compile the module.
+ */
+
+ function doBuild () {
+
+ // Enable Verbose build
+ var verbose = log.levels[log.level] <= log.levels.verbose
+ if (!win && verbose) {
+ argv.push('V=1')
+ }
+ if (win && !verbose) {
+ argv.push('/clp:Verbosity=minimal')
+ }
+
+ if (win) {
+ // Turn off the Microsoft logo on Windows
+ argv.push('/nologo')
+ }
+
+ // Specify the build type, Release by default
+ if (win) {
+ var archLower = arch.toLowerCase()
+ var p = archLower === 'x64' ? 'x64' :
+ (archLower === 'arm' ? 'ARM' : 'Win32')
+ argv.push('/p:Configuration=' + buildType + ';Platform=' + p)
+ if (jobs) {
+ var j = parseInt(jobs, 10)
+ if (!isNaN(j) && j > 0) {
+ argv.push('/m:' + j)
+ } else if (jobs.toUpperCase() === 'MAX') {
+ argv.push('/m:' + require('os').cpus().length)
+ }
+ }
+ } else {
+ argv.push('BUILDTYPE=' + buildType)
+ // Invoke the Makefile in the 'build' dir.
+ argv.push('-C')
+ argv.push('build')
+ if (jobs) {
+ var j = parseInt(jobs, 10)
+ if (!isNaN(j) && j > 0) {
+ argv.push('--jobs')
+ argv.push(j)
+ } else if (jobs.toUpperCase() === 'MAX') {
+ argv.push('--jobs')
+ argv.push(require('os').cpus().length)
+ }
+ }
+ }
+
+ if (win) {
+ // did the user specify their own .sln file?
+ var hasSln = argv.some(function (arg) {
+ return path.extname(arg) == '.sln'
+ })
+ if (!hasSln) {
+ argv.unshift(gyp.opts.solution || guessedSolution)
+ }
+ }
+
+ var proc = gyp.spawn(command, argv)
+ proc.on('exit', onExit)
+ }
+
+ /**
+ * Invoked after the make/msbuild command exits.
+ */
+
+ function onExit (code, signal) {
+ if (code !== 0) {
+ return callback(new Error('`' + command + '` failed with exit code: ' + code))
+ }
+ if (signal) {
+ return callback(new Error('`' + command + '` got signal: ' + signal))
+ }
+ callback()
+ }
+
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/clean.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/clean.js
new file mode 100644
index 0000000000000..e69164d45afcc
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/clean.js
@@ -0,0 +1,22 @@
+
+module.exports = exports = clean
+
+exports.usage = 'Removes any generated build files and the "out" dir'
+
+/**
+ * Module dependencies.
+ */
+
+var rm = require('rimraf')
+var log = require('npmlog')
+
+
+function clean (gyp, argv, callback) {
+
+ // Remove the 'build' dir
+ var buildDir = 'build'
+
+ log.verbose('clean', 'removing "%s" directory', buildDir)
+ rm(buildDir, callback)
+
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/configure.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/configure.js
new file mode 100644
index 0000000000000..a42abe59724c7
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/configure.js
@@ -0,0 +1,524 @@
+module.exports = exports = configure
+module.exports.test = {
+ PythonFinder: PythonFinder,
+ findAccessibleSync: findAccessibleSync,
+ findPython: findPython,
+}
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('graceful-fs')
+ , path = require('path')
+ , log = require('npmlog')
+ , osenv = require('osenv')
+ , which = require('which')
+ , semver = require('semver')
+ , mkdirp = require('mkdirp')
+ , cp = require('child_process')
+ , extend = require('util')._extend
+ , processRelease = require('./process-release')
+ , win = process.platform === 'win32'
+ , findNodeDirectory = require('./find-node-directory')
+ , msgFormat = require('util').format
+if (win)
+ var findVS2017 = require('./find-vs2017')
+
+exports.usage = 'Generates ' + (win ? 'MSVC project files' : 'a Makefile') + ' for the current module'
+
+function configure (gyp, argv, callback) {
+
+ var python = gyp.opts.python || process.env.PYTHON || 'python2'
+ , buildDir = path.resolve('build')
+ , configNames = [ 'config.gypi', 'common.gypi' ]
+ , configs = []
+ , nodeDir
+ , release = processRelease(argv, gyp, process.version, process.release)
+
+ findPython(python, function (err, found) {
+ if (err) {
+ callback(err)
+ } else {
+ python = found
+ getNodeDir()
+ }
+ })
+
+ function getNodeDir () {
+
+ // 'python' should be set by now
+ process.env.PYTHON = python
+
+ if (gyp.opts.nodedir) {
+ // --nodedir was specified. use that for the dev files
+ nodeDir = gyp.opts.nodedir.replace(/^~/, osenv.home())
+
+ log.verbose('get node dir', 'compiling against specified --nodedir dev files: %s', nodeDir)
+ createBuildDir()
+
+ } else {
+ // if no --nodedir specified, ensure node dependencies are installed
+ if ('v' + release.version !== process.version) {
+ // if --target was given, then determine a target version to compile for
+ log.verbose('get node dir', 'compiling against --target node version: %s', release.version)
+ } else {
+ // if no --target was specified then use the current host node version
+ log.verbose('get node dir', 'no --target version specified, falling back to host node version: %s', release.version)
+ }
+
+ if (!release.semver) {
+ // could not parse the version string with semver
+ return callback(new Error('Invalid version number: ' + release.version))
+ }
+
+ // If the tarball option is set, always remove and reinstall the headers
+ // into devdir. Otherwise only install if they're not already there.
+ gyp.opts.ensure = gyp.opts.tarball ? false : true
+
+ gyp.commands.install([ release.version ], function (err, version) {
+ if (err) return callback(err)
+ log.verbose('get node dir', 'target node version installed:', release.versionDir)
+ nodeDir = path.resolve(gyp.devDir, release.versionDir)
+ createBuildDir()
+ })
+ }
+ }
+
+ function createBuildDir () {
+ log.verbose('build dir', 'attempting to create "build" dir: %s', buildDir)
+ mkdirp(buildDir, function (err, isNew) {
+ if (err) return callback(err)
+ log.verbose('build dir', '"build" dir needed to be created?', isNew)
+ if (win && (!gyp.opts.msvs_version || gyp.opts.msvs_version === '2017')) {
+ findVS2017(function (err, vsSetup) {
+ if (err) {
+ log.verbose('Not using VS2017:', err.message)
+ createConfigFile()
+ } else {
+ createConfigFile(null, vsSetup)
+ }
+ })
+ } else {
+ createConfigFile()
+ }
+ })
+ }
+
+ function createConfigFile (err, vsSetup) {
+ if (err) return callback(err)
+
+ var configFilename = 'config.gypi'
+ var configPath = path.resolve(buildDir, configFilename)
+
+ log.verbose('build/' + configFilename, 'creating config file')
+
+ var config = process.config || {}
+ , defaults = config.target_defaults
+ , variables = config.variables
+
+ // default "config.variables"
+ if (!variables) variables = config.variables = {}
+
+ // default "config.defaults"
+ if (!defaults) defaults = config.target_defaults = {}
+
+ // don't inherit the "defaults" from node's `process.config` object.
+ // doing so could cause problems in cases where the `node` executable was
+ // compiled on a different machine (with different lib/include paths) than
+ // the machine where the addon is being built to
+ defaults.cflags = []
+ defaults.defines = []
+ defaults.include_dirs = []
+ defaults.libraries = []
+
+ // set the default_configuration prop
+ if ('debug' in gyp.opts) {
+ defaults.default_configuration = gyp.opts.debug ? 'Debug' : 'Release'
+ }
+ if (!defaults.default_configuration) {
+ defaults.default_configuration = 'Release'
+ }
+
+ // set the target_arch variable
+ variables.target_arch = gyp.opts.arch || process.arch || 'ia32'
+
+ // set the node development directory
+ variables.nodedir = nodeDir
+
+ // disable -T "thin" static archives by default
+ variables.standalone_static_library = gyp.opts.thin ? 0 : 1
+
+ if (vsSetup) {
+ // GYP doesn't (yet) have support for VS2017, so we force it to VS2015
+ // to avoid pulling a floating patch that has not landed upstream.
+ // Ref: https://chromium-review.googlesource.com/#/c/433540/
+ gyp.opts.msvs_version = '2015'
+ process.env['GYP_MSVS_VERSION'] = 2015
+ process.env['GYP_MSVS_OVERRIDE_PATH'] = vsSetup.path
+ defaults['msbuild_toolset'] = 'v141'
+ defaults['msvs_windows_target_platform_version'] = vsSetup.sdk
+ variables['msbuild_path'] = path.join(vsSetup.path, 'MSBuild', '15.0',
+ 'Bin', 'MSBuild.exe')
+ }
+
+ // loop through the rest of the opts and add the unknown ones as variables.
+ // this allows for module-specific configure flags like:
+ //
+ // $ node-gyp configure --shared-libxml2
+ Object.keys(gyp.opts).forEach(function (opt) {
+ if (opt === 'argv') return
+ if (opt in gyp.configDefs) return
+ variables[opt.replace(/-/g, '_')] = gyp.opts[opt]
+ })
+
+ // ensures that any boolean values from `process.config` get stringified
+ function boolsToString (k, v) {
+ if (typeof v === 'boolean')
+ return String(v)
+ return v
+ }
+
+ log.silly('build/' + configFilename, config)
+
+ // now write out the config.gypi file to the build/ dir
+ var prefix = '# Do not edit. File was generated by node-gyp\'s "configure" step'
+ , json = JSON.stringify(config, boolsToString, 2)
+ log.verbose('build/' + configFilename, 'writing out config file: %s', configPath)
+ configs.push(configPath)
+ fs.writeFile(configPath, [prefix, json, ''].join('\n'), findConfigs)
+ }
+
+ function findConfigs (err) {
+ if (err) return callback(err)
+ var name = configNames.shift()
+ if (!name) return runGyp()
+ var fullPath = path.resolve(name)
+ log.verbose(name, 'checking for gypi file: %s', fullPath)
+ fs.stat(fullPath, function (err, stat) {
+ if (err) {
+ if (err.code == 'ENOENT') {
+ findConfigs() // check next gypi filename
+ } else {
+ callback(err)
+ }
+ } else {
+ log.verbose(name, 'found gypi file')
+ configs.push(fullPath)
+ findConfigs()
+ }
+ })
+ }
+
+ function runGyp (err) {
+ if (err) return callback(err)
+
+ if (!~argv.indexOf('-f') && !~argv.indexOf('--format')) {
+ if (win) {
+ log.verbose('gyp', 'gyp format was not specified; forcing "msvs"')
+ // force the 'make' target for non-Windows
+ argv.push('-f', 'msvs')
+ } else {
+ log.verbose('gyp', 'gyp format was not specified; forcing "make"')
+ // force the 'make' target for non-Windows
+ argv.push('-f', 'make')
+ }
+ }
+
+ function hasMsvsVersion () {
+ return argv.some(function (arg) {
+ return arg.indexOf('msvs_version') === 0
+ })
+ }
+
+ if (win && !hasMsvsVersion()) {
+ if ('msvs_version' in gyp.opts) {
+ argv.push('-G', 'msvs_version=' + gyp.opts.msvs_version)
+ } else {
+ argv.push('-G', 'msvs_version=auto')
+ }
+ }
+
+ // include all the ".gypi" files that were found
+ configs.forEach(function (config) {
+ argv.push('-I', config)
+ })
+
+ // For AIX and z/OS we need to set up the path to the exports file
+ // which contains the symbols needed for linking.
+ var node_exp_file = undefined
+ if (process.platform === 'aix' || process.platform === 'os390') {
+ var ext = process.platform === 'aix' ? 'exp' : 'x'
+ var node_root_dir = findNodeDirectory()
+ var candidates = undefined
+ if (process.platform === 'aix') {
+ candidates = ['include/node/node',
+ 'out/Release/node',
+ 'out/Debug/node',
+ 'node'
+ ].map(function(file) {
+ return file + '.' + ext
+ })
+ } else {
+ candidates = ['out/Release/obj.target/libnode',
+ 'out/Debug/obj.target/libnode',
+ 'lib/libnode'
+ ].map(function(file) {
+ return file + '.' + ext
+ })
+ }
+ var logprefix = 'find exports file'
+ node_exp_file = findAccessibleSync(logprefix, node_root_dir, candidates)
+ if (node_exp_file !== undefined) {
+ log.verbose(logprefix, 'Found exports file: %s', node_exp_file)
+ } else {
+ var msg = msgFormat('Could not find node.%s file in %s', ext, node_root_dir)
+ log.error(logprefix, 'Could not find exports file')
+ return callback(new Error(msg))
+ }
+ }
+
+ // this logic ported from the old `gyp_addon` python file
+ var gyp_script = path.resolve(__dirname, '..', 'gyp', 'gyp_main.py')
+ var addon_gypi = path.resolve(__dirname, '..', 'addon.gypi')
+ var common_gypi = path.resolve(nodeDir, 'include/node/common.gypi')
+ fs.stat(common_gypi, function (err, stat) {
+ if (err)
+ common_gypi = path.resolve(nodeDir, 'common.gypi')
+
+ var output_dir = 'build'
+ if (win) {
+ // Windows expects an absolute path
+ output_dir = buildDir
+ }
+ var nodeGypDir = path.resolve(__dirname, '..')
+ var nodeLibFile = path.join(nodeDir,
+ !gyp.opts.nodedir ? '<(target_arch)' : '$(Configuration)',
+ release.name + '.lib')
+
+ argv.push('-I', addon_gypi)
+ argv.push('-I', common_gypi)
+ argv.push('-Dlibrary=shared_library')
+ argv.push('-Dvisibility=default')
+ argv.push('-Dnode_root_dir=' + nodeDir)
+ if (process.platform === 'aix' || process.platform === 'os390') {
+ argv.push('-Dnode_exp_file=' + node_exp_file)
+ }
+ argv.push('-Dnode_gyp_dir=' + nodeGypDir)
+ argv.push('-Dnode_lib_file=' + nodeLibFile)
+ argv.push('-Dmodule_root_dir=' + process.cwd())
+ argv.push('-Dnode_engine=' +
+ (gyp.opts.node_engine || process.jsEngine || 'v8'))
+ argv.push('--depth=.')
+ argv.push('--no-parallel')
+
+ // tell gyp to write the Makefile/Solution files into output_dir
+ argv.push('--generator-output', output_dir)
+
+ // tell make to write its output into the same dir
+ argv.push('-Goutput_dir=.')
+
+ // enforce use of the "binding.gyp" file
+ argv.unshift('binding.gyp')
+
+ // execute `gyp` from the current target nodedir
+ argv.unshift(gyp_script)
+
+ // make sure python uses files that came with this particular node package
+ var pypath = [path.join(__dirname, '..', 'gyp', 'pylib')]
+ if (process.env.PYTHONPATH) {
+ pypath.push(process.env.PYTHONPATH)
+ }
+ process.env.PYTHONPATH = pypath.join(win ? ';' : ':')
+
+ var cp = gyp.spawn(python, argv)
+ cp.on('exit', onCpExit)
+ })
+ }
+
+ /**
+ * Called when the `gyp` child process exits.
+ */
+
+ function onCpExit (code, signal) {
+ if (code !== 0) {
+ callback(new Error('`gyp` failed with exit code: ' + code))
+ } else {
+ // we're done
+ callback()
+ }
+ }
+
+}
+
+/**
+ * Returns the first file or directory from an array of candidates that is
+ * readable by the current user, or undefined if none of the candidates are
+ * readable.
+ */
+function findAccessibleSync (logprefix, dir, candidates) {
+ for (var next = 0; next < candidates.length; next++) {
+ var candidate = path.resolve(dir, candidates[next])
+ try {
+ var fd = fs.openSync(candidate, 'r')
+ } catch (e) {
+ // this candidate was not found or not readable, do nothing
+ log.silly(logprefix, 'Could not open %s: %s', candidate, e.message)
+ continue
+ }
+ fs.closeSync(fd)
+ log.silly(logprefix, 'Found readable %s', candidate)
+ return candidate
+ }
+
+ return undefined
+}
+
+function PythonFinder(python, callback) {
+ this.callback = callback
+ this.python = python
+}
+
+PythonFinder.prototype = {
+ checkPythonLauncherDepth: 0,
+ env: process.env,
+ execFile: cp.execFile,
+ log: log,
+ resolve: path.win32 && path.win32.resolve || path.resolve,
+ stat: fs.stat,
+ which: which,
+ win: win,
+
+ checkPython: function checkPython () {
+ this.log.verbose('check python',
+ 'checking for Python executable "%s" in the PATH',
+ this.python)
+ this.which(this.python, function (err, execPath) {
+ if (err) {
+ this.log.verbose('`which` failed', this.python, err)
+ if (this.python === 'python2') {
+ this.python = 'python'
+ return this.checkPython()
+ }
+ if (this.win) {
+ this.checkPythonLauncher()
+ } else {
+ this.failNoPython()
+ }
+ } else {
+ this.log.verbose('`which` succeeded', this.python, execPath)
+ // Found the `python` executable, and from now on we use it explicitly.
+ // This solves #667 and #750 (`execFile` won't run batch files
+ // (*.cmd, and *.bat))
+ this.python = execPath
+ this.checkPythonVersion()
+ }
+ }.bind(this))
+ },
+
+ // Distributions of Python on Windows by default install with the "py.exe"
+ // Python launcher which is more likely to exist than the Python executable
+ // being in the $PATH.
+ // Because the Python launcher supports all versions of Python, we have to
+ // explicitly request a Python 2 version. This is done by supplying "-2" as
+ // the first command line argument. Since "py.exe -2" would be an invalid
+ // executable for "execFile", we have to use the launcher to figure out
+ // where the actual "python.exe" executable is located.
+ checkPythonLauncher: function checkPythonLauncher () {
+ this.checkPythonLauncherDepth += 1
+
+ this.log.verbose(
+ 'could not find "' + this.python + '". checking python launcher')
+ var env = extend({}, this.env)
+ env.TERM = 'dumb'
+
+ var launcherArgs = ['-2', '-c', 'import sys; print sys.executable']
+ this.execFile('py.exe', launcherArgs, { env: env }, function (err, stdout) {
+ if (err) {
+ this.guessPython()
+ } else {
+ this.python = stdout.trim()
+ this.log.verbose('check python launcher',
+ 'python executable found: %j',
+ this.python)
+ this.checkPythonVersion()
+ }
+ this.checkPythonLauncherDepth -= 1
+ }.bind(this))
+ },
+
+ checkPythonVersion: function checkPythonVersion () {
+ var args = ['-c', 'import sys; print("%s.%s.%s" % sys.version_info[:3]);']
+ var env = extend({}, this.env)
+ env.TERM = 'dumb'
+
+ this.execFile(this.python, args, { env: env }, function (err, stdout) {
+ if (err) {
+ return this.callback(err)
+ }
+ this.log.verbose('check python version',
+ '`%s -c "' + args[1] + '"` returned: %j',
+ this.python, stdout)
+ var version = stdout.trim()
+ var range = semver.Range('>=2.5.0 <3.0.0')
+ var valid = false
+ try {
+ valid = range.test(version)
+ } catch (e) {
+ this.log.silly('range.test() error', e)
+ }
+ if (valid) {
+ this.callback(null, this.python)
+ } else if (this.win && this.checkPythonLauncherDepth === 0) {
+ this.checkPythonLauncher()
+ } else {
+ this.failPythonVersion(version)
+ }
+ }.bind(this))
+ },
+
+ failNoPython: function failNoPython () {
+ var errmsg =
+ 'Can\'t find Python executable "' + this.python +
+ '", you can set the PYTHON env variable.'
+ this.callback(new Error(errmsg))
+ },
+
+ failPythonVersion: function failPythonVersion (badVersion) {
+ var errmsg =
+ 'Python executable "' + this.python +
+ '" is v' + badVersion + ', which is not supported by gyp.\n' +
+ 'You can pass the --python switch to point to ' +
+ 'Python >= v2.5.0 & < 3.0.0.'
+ this.callback(new Error(errmsg))
+ },
+
+ // Called on Windows when "python" isn't available in the current $PATH.
+ // We are going to check if "%SystemDrive%\python27\python.exe" exists.
+ guessPython: function guessPython () {
+ this.log.verbose('could not find "' + this.python + '". guessing location')
+ var rootDir = this.env.SystemDrive || 'C:\\'
+ if (rootDir[rootDir.length - 1] !== '\\') {
+ rootDir += '\\'
+ }
+ var pythonPath = this.resolve(rootDir, 'Python27', 'python.exe')
+ this.log.verbose('ensuring that file exists:', pythonPath)
+ this.stat(pythonPath, function (err, stat) {
+ if (err) {
+ if (err.code == 'ENOENT') {
+ this.failNoPython()
+ } else {
+ this.callback(err)
+ }
+ return
+ }
+ this.python = pythonPath
+ this.checkPythonVersion()
+ }.bind(this))
+ },
+}
+
+function findPython (python, callback) {
+ var finder = new PythonFinder(python, callback)
+ finder.checkPython()
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/find-node-directory.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/find-node-directory.js
new file mode 100644
index 0000000000000..3aee8a109ae28
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/find-node-directory.js
@@ -0,0 +1,61 @@
+var path = require('path')
+ , log = require('npmlog')
+
+function findNodeDirectory(scriptLocation, processObj) {
+ // set dirname and process if not passed in
+ // this facilitates regression tests
+ if (scriptLocation === undefined) {
+ scriptLocation = __dirname
+ }
+ if (processObj === undefined) {
+ processObj = process
+ }
+
+ // Have a look to see what is above us, to try and work out where we are
+ npm_parent_directory = path.join(scriptLocation, '../../../..')
+ log.verbose('node-gyp root', 'npm_parent_directory is '
+ + path.basename(npm_parent_directory))
+ node_root_dir = ""
+
+ log.verbose('node-gyp root', 'Finding node root directory')
+ if (path.basename(npm_parent_directory) === 'deps') {
+ // We are in a build directory where this script lives in
+ // deps/npm/node_modules/node-gyp/lib
+ node_root_dir = path.join(npm_parent_directory, '..')
+ log.verbose('node-gyp root', 'in build directory, root = '
+ + node_root_dir)
+ } else if (path.basename(npm_parent_directory) === 'node_modules') {
+ // We are in a node install directory where this script lives in
+ // lib/node_modules/npm/node_modules/node-gyp/lib or
+ // node_modules/npm/node_modules/node-gyp/lib depending on the
+ // platform
+ if (processObj.platform === 'win32') {
+ node_root_dir = path.join(npm_parent_directory, '..')
+ } else {
+ node_root_dir = path.join(npm_parent_directory, '../..')
+ }
+ log.verbose('node-gyp root', 'in install directory, root = '
+ + node_root_dir)
+ } else {
+ // We don't know where we are, try working it out from the location
+ // of the node binary
+ var node_dir = path.dirname(processObj.execPath)
+ var directory_up = path.basename(node_dir)
+ if (directory_up === 'bin') {
+ node_root_dir = path.join(node_dir, '..')
+ } else if (directory_up === 'Release' || directory_up === 'Debug') {
+ // If we are a recently built node, and the directory structure
+ // is that of a repository. If we are on Windows then we only need
+ // to go one level up, everything else, two
+ if (processObj.platform === 'win32') {
+ node_root_dir = path.join(node_dir, '..')
+ } else {
+ node_root_dir = path.join(node_dir, '../..')
+ }
+ }
+ // Else return the default blank, "".
+ }
+ return node_root_dir
+}
+
+module.exports = findNodeDirectory
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/find-vs2017.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/find-vs2017.js
new file mode 100644
index 0000000000000..ad46ceaf88c98
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/find-vs2017.js
@@ -0,0 +1,46 @@
+var log = require('npmlog')
+ , execFile = require('child_process').execFile
+ , path = require('path')
+
+function findVS2017(callback) {
+ var ps = path.join(process.env.SystemRoot, 'System32', 'WindowsPowerShell',
+ 'v1.0', 'powershell.exe')
+ var csFile = path.join(__dirname, 'Find-VS2017.cs')
+ var psArgs = ['-ExecutionPolicy', 'Unrestricted', '-NoProfile',
+ '-Command', '&{Add-Type -Path \'' + csFile + '\';' +
+ '[VisualStudioConfiguration.Main]::Query()}']
+
+ log.silly('find vs2017', 'Running', ps, psArgs)
+ var child = execFile(ps, psArgs, { encoding: 'utf8' },
+ function (err, stdout, stderr) {
+ log.silly('find vs2017', 'PS err:', err)
+ log.silly('find vs2017', 'PS stdout:', stdout)
+ log.silly('find vs2017', 'PS stderr:', stderr)
+
+ if (err)
+ return callback(new Error('Could not use PowerShell to find VS2017'))
+
+ var vsSetup
+ try {
+ vsSetup = JSON.parse(stdout)
+ } catch (e) {
+ log.silly('find vs2017', e)
+ return callback(new Error('Could not use PowerShell to find VS2017'))
+ }
+ log.silly('find vs2017', 'vsSetup:', vsSetup)
+
+ if (vsSetup && vsSetup.log)
+ log.verbose('find vs2017', vsSetup.log.trimRight())
+
+ if (!vsSetup || !vsSetup.path || !vsSetup.sdk) {
+ return callback(new Error('No usable installation of VS2017 found'))
+ }
+
+ log.verbose('find vs2017', 'using installation:', vsSetup.path)
+ callback(null, { "path": vsSetup.path, "sdk": vsSetup.sdk })
+ })
+
+ child.stdin.end()
+}
+
+module.exports = findVS2017
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/install.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/install.js
new file mode 100644
index 0000000000000..8a615dfb38880
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/install.js
@@ -0,0 +1,469 @@
+module.exports = exports = function (gyp, argv, callback) {
+ return install(fs, gyp, argv, callback)
+}
+
+module.exports.test = {
+ download: download,
+ install: install,
+ readCAFile: readCAFile,
+}
+
+exports.usage = 'Install node development files for the specified node version.'
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('graceful-fs')
+ , osenv = require('osenv')
+ , tar = require('tar')
+ , rm = require('rimraf')
+ , path = require('path')
+ , crypto = require('crypto')
+ , log = require('npmlog')
+ , semver = require('semver')
+ , request = require('request')
+ , mkdir = require('mkdirp')
+ , processRelease = require('./process-release')
+ , win = process.platform == 'win32'
+
+function install (fs, gyp, argv, callback) {
+
+ var release = processRelease(argv, gyp, process.version, process.release)
+
+ // ensure no double-callbacks happen
+ function cb (err) {
+ if (cb.done) return
+ cb.done = true
+ if (err) {
+ log.warn('install', 'got an error, rolling back install')
+ // roll-back the install if anything went wrong
+ gyp.commands.remove([ release.versionDir ], function (err2) {
+ callback(err)
+ })
+ } else {
+ callback(null, release.version)
+ }
+ }
+
+ // Determine which node dev files version we are installing
+ log.verbose('install', 'input version string %j', release.version)
+
+ if (!release.semver) {
+ // could not parse the version string with semver
+ return callback(new Error('Invalid version number: ' + release.version))
+ }
+
+ if (semver.lt(release.version, '0.8.0')) {
+ return callback(new Error('Minimum target version is `0.8.0` or greater. Got: ' + release.version))
+ }
+
+ // 0.x.y-pre versions are not published yet and cannot be installed. Bail.
+ if (release.semver.prerelease[0] === 'pre') {
+ log.verbose('detected "pre" node version', release.version)
+ if (gyp.opts.nodedir) {
+ log.verbose('--nodedir flag was passed; skipping install', gyp.opts.nodedir)
+ callback()
+ } else {
+ callback(new Error('"pre" versions of node cannot be installed, use the --nodedir flag instead'))
+ }
+ return
+ }
+
+ // flatten version into String
+ log.verbose('install', 'installing version: %s', release.versionDir)
+
+ // the directory where the dev files will be installed
+ var devDir = path.resolve(gyp.devDir, release.versionDir)
+
+ // If '--ensure' was passed, then don't *always* install the version;
+ // check if it is already installed, and only install when needed
+ if (gyp.opts.ensure) {
+ log.verbose('install', '--ensure was passed, so won\'t reinstall if already installed')
+ fs.stat(devDir, function (err, stat) {
+ if (err) {
+ if (err.code == 'ENOENT') {
+ log.verbose('install', 'version not already installed, continuing with install', release.version)
+ go()
+ } else if (err.code == 'EACCES') {
+ eaccesFallback(err)
+ } else {
+ cb(err)
+ }
+ return
+ }
+ log.verbose('install', 'version is already installed, need to check "installVersion"')
+ var installVersionFile = path.resolve(devDir, 'installVersion')
+ fs.readFile(installVersionFile, 'ascii', function (err, ver) {
+ if (err && err.code != 'ENOENT') {
+ return cb(err)
+ }
+ var installVersion = parseInt(ver, 10) || 0
+ log.verbose('got "installVersion"', installVersion)
+ log.verbose('needs "installVersion"', gyp.package.installVersion)
+ if (installVersion < gyp.package.installVersion) {
+ log.verbose('install', 'version is no good; reinstalling')
+ go()
+ } else {
+ log.verbose('install', 'version is good')
+ cb()
+ }
+ })
+ })
+ } else {
+ go()
+ }
+
+ function getContentSha(res, callback) {
+ var shasum = crypto.createHash('sha256')
+ res.on('data', function (chunk) {
+ shasum.update(chunk)
+ }).on('end', function () {
+ callback(null, shasum.digest('hex'))
+ })
+ }
+
+ function go () {
+
+ log.verbose('ensuring nodedir is created', devDir)
+
+ // first create the dir for the node dev files
+ mkdir(devDir, function (err, created) {
+ if (err) {
+ if (err.code == 'EACCES') {
+ eaccesFallback(err)
+ } else {
+ cb(err)
+ }
+ return
+ }
+
+ if (created) {
+ log.verbose('created nodedir', created)
+ }
+
+ // now download the node tarball
+ var tarPath = gyp.opts.tarball
+ var badDownload = false
+ , extractCount = 0
+
+ var contentShasums = {}
+ var expectShasums = {}
+
+ // checks if a file to be extracted from the tarball is valid.
+ // only .h header files and the gyp files get extracted
+ function isValid (path, entry) {
+ var isValid = valid(path)
+ if (isValid) {
+ log.verbose('extracted file from tarball', path)
+ extractCount++
+ } else {
+ // invalid
+ log.silly('ignoring from tarball', path)
+ }
+ return isValid
+ }
+
+ // download the tarball and extract!
+
+ if (tarPath) {
+ return tar.extract({
+ file: tarPath,
+ strip: 1,
+ filter: isValid,
+ cwd: devDir
+ }).then(afterTarball, cb)
+ }
+
+ try {
+ var req = download(gyp, process.env, release.tarballUrl)
+ } catch (e) {
+ return cb(e)
+ }
+
+ // something went wrong downloading the tarball?
+ req.on('error', function (err) {
+ if (err.code === 'ENOTFOUND') {
+ return cb(new Error('This is most likely not a problem with node-gyp or the package itself and\n' +
+ 'is related to network connectivity. In most cases you are behind a proxy or have bad \n' +
+ 'network settings.'))
+ }
+ badDownload = true
+ cb(err)
+ })
+
+ req.on('close', function () {
+ if (extractCount === 0) {
+ cb(new Error('Connection closed while downloading tarball file'))
+ }
+ })
+
+ req.on('response', function (res) {
+ if (res.statusCode !== 200) {
+ badDownload = true
+ cb(new Error(res.statusCode + ' response downloading ' + release.tarballUrl))
+ return
+ }
+ // content checksum
+ getContentSha(res, function (_, checksum) {
+ var filename = path.basename(release.tarballUrl).trim()
+ contentShasums[filename] = checksum
+ log.verbose('content checksum', filename, checksum)
+ })
+
+ // start unzipping and untaring
+ res.pipe(tar.extract({
+ strip: 1,
+ cwd: devDir,
+ filter: isValid
+ }).on('close', afterTarball).on('error', cb))
+ })
+
+ // invoked after the tarball has finished being extracted
+ function afterTarball () {
+ if (badDownload) return
+ if (extractCount === 0) {
+ return cb(new Error('There was a fatal problem while downloading/extracting the tarball'))
+ }
+ log.verbose('tarball', 'done parsing tarball')
+ var async = 0
+
+ if (win) {
+ // need to download node.lib
+ async++
+ downloadNodeLib(deref)
+ }
+
+ // write the "installVersion" file
+ async++
+ var installVersionPath = path.resolve(devDir, 'installVersion')
+ fs.writeFile(installVersionPath, gyp.package.installVersion + '\n', deref)
+
+ // Only download SHASUMS.txt if not using tarPath override
+ if (!tarPath) {
+ // download SHASUMS.txt
+ async++
+ downloadShasums(deref)
+ }
+
+ if (async === 0) {
+ // no async tasks required
+ cb()
+ }
+
+ function deref (err) {
+ if (err) return cb(err)
+
+ async--
+ if (!async) {
+ log.verbose('download contents checksum', JSON.stringify(contentShasums))
+ // check content shasums
+ for (var k in contentShasums) {
+ log.verbose('validating download checksum for ' + k, '(%s == %s)', contentShasums[k], expectShasums[k])
+ if (contentShasums[k] !== expectShasums[k]) {
+ cb(new Error(k + ' local checksum ' + contentShasums[k] + ' not match remote ' + expectShasums[k]))
+ return
+ }
+ }
+ cb()
+ }
+ }
+ }
+
+ function downloadShasums(done) {
+ log.verbose('check download content checksum, need to download `SHASUMS256.txt`...')
+ var shasumsPath = path.resolve(devDir, 'SHASUMS256.txt')
+
+ log.verbose('checksum url', release.shasumsUrl)
+ try {
+ var req = download(gyp, process.env, release.shasumsUrl)
+ } catch (e) {
+ return cb(e)
+ }
+
+ req.on('error', done)
+ req.on('response', function (res) {
+ if (res.statusCode !== 200) {
+ done(new Error(res.statusCode + ' status code downloading checksum'))
+ return
+ }
+
+ var chunks = []
+ res.on('data', function (chunk) {
+ chunks.push(chunk)
+ })
+ res.on('end', function () {
+ var lines = Buffer.concat(chunks).toString().trim().split('\n')
+ lines.forEach(function (line) {
+ var items = line.trim().split(/\s+/)
+ if (items.length !== 2) return
+
+ // 0035d18e2dcf9aad669b1c7c07319e17abfe3762 ./node-v0.11.4.tar.gz
+ var name = items[1].replace(/^\.\//, '')
+ expectShasums[name] = items[0]
+ })
+
+ log.verbose('checksum data', JSON.stringify(expectShasums))
+ done()
+ })
+ })
+ }
+
+ function downloadNodeLib (done) {
+ log.verbose('on Windows; need to download `' + release.name + '.lib`...')
+ var dir32 = path.resolve(devDir, 'ia32')
+ , dir64 = path.resolve(devDir, 'x64')
+ , libPath32 = path.resolve(dir32, release.name + '.lib')
+ , libPath64 = path.resolve(dir64, release.name + '.lib')
+
+ log.verbose('32-bit ' + release.name + '.lib dir', dir32)
+ log.verbose('64-bit ' + release.name + '.lib dir', dir64)
+ log.verbose('`' + release.name + '.lib` 32-bit url', release.libUrl32)
+ log.verbose('`' + release.name + '.lib` 64-bit url', release.libUrl64)
+
+ var async = 2
+ mkdir(dir32, function (err) {
+ if (err) return done(err)
+ log.verbose('streaming 32-bit ' + release.name + '.lib to:', libPath32)
+
+ try {
+ var req = download(gyp, process.env, release.libUrl32, cb)
+ } catch (e) {
+ return cb(e)
+ }
+
+ req.on('error', done)
+ req.on('response', function (res) {
+ if (res.statusCode !== 200) {
+ done(new Error(res.statusCode + ' status code downloading 32-bit ' + release.name + '.lib'))
+ return
+ }
+
+ getContentSha(res, function (_, checksum) {
+ contentShasums[release.libPath32] = checksum
+ log.verbose('content checksum', release.libPath32, checksum)
+ })
+
+ var ws = fs.createWriteStream(libPath32)
+ ws.on('error', cb)
+ req.pipe(ws)
+ })
+ req.on('end', function () {
+ --async || done()
+ })
+ })
+ mkdir(dir64, function (err) {
+ if (err) return done(err)
+ log.verbose('streaming 64-bit ' + release.name + '.lib to:', libPath64)
+
+ try {
+ var req = download(gyp, process.env, release.libUrl64, cb)
+ } catch (e) {
+ return cb(e)
+ }
+
+ req.on('error', done)
+ req.on('response', function (res) {
+ if (res.statusCode !== 200) {
+ done(new Error(res.statusCode + ' status code downloading 64-bit ' + release.name + '.lib'))
+ return
+ }
+
+ getContentSha(res, function (_, checksum) {
+ contentShasums[release.libPath64] = checksum
+ log.verbose('content checksum', release.libPath64, checksum)
+ })
+
+ var ws = fs.createWriteStream(libPath64)
+ ws.on('error', cb)
+ req.pipe(ws)
+ })
+ req.on('end', function () {
+ --async || done()
+ })
+ })
+ } // downloadNodeLib()
+
+ }) // mkdir()
+
+ } // go()
+
+ /**
+ * Checks if a given filename is "valid" for this installation.
+ */
+
+ function valid (file) {
+ // header files
+ var extname = path.extname(file);
+ return extname === '.h' || extname === '.gypi';
+ }
+
+ /**
+ * The EACCES fallback is a workaround for npm's `sudo` behavior, where
+ * it drops the permissions before invoking any child processes (like
+ * node-gyp). So what happens is the "nobody" user doesn't have
+ * permission to create the dev dir. As a fallback, make the tmpdir() be
+ * the dev dir for this installation. This is not ideal, but at least
+ * the compilation will succeed...
+ */
+
+ function eaccesFallback (err) {
+ var noretry = '--node_gyp_internal_noretry'
+ if (-1 !== argv.indexOf(noretry)) return cb(err)
+ var tmpdir = osenv.tmpdir()
+ gyp.devDir = path.resolve(tmpdir, '.node-gyp')
+ log.warn('EACCES', 'user "%s" does not have permission to access the dev dir "%s"', osenv.user(), devDir)
+ log.warn('EACCES', 'attempting to reinstall using temporary dev dir "%s"', gyp.devDir)
+ if (process.cwd() == tmpdir) {
+ log.verbose('tmpdir == cwd', 'automatically will remove dev files after to save disk space')
+ gyp.todo.push({ name: 'remove', args: argv })
+ }
+ gyp.commands.install([noretry].concat(argv), cb)
+ }
+
+}
+
+function download (gyp, env, url) {
+ log.http('GET', url)
+
+ var requestOpts = {
+ uri: url
+ , headers: {
+ 'User-Agent': 'node-gyp v' + gyp.version + ' (node ' + process.version + ')'
+ }
+ }
+
+ var cafile = gyp.opts.cafile
+ if (cafile) {
+ requestOpts.ca = readCAFile(cafile)
+ }
+
+ // basic support for a proxy server
+ var proxyUrl = gyp.opts.proxy
+ || env.http_proxy
+ || env.HTTP_PROXY
+ || env.npm_config_proxy
+ if (proxyUrl) {
+ if (/^https?:\/\//i.test(proxyUrl)) {
+ log.verbose('download', 'using proxy url: "%s"', proxyUrl)
+ requestOpts.proxy = proxyUrl
+ } else {
+ log.warn('download', 'ignoring invalid "proxy" config setting: "%s"', proxyUrl)
+ }
+ }
+
+ var req = request(requestOpts)
+ req.on('response', function (res) {
+ log.http(res.statusCode, url)
+ })
+
+ return req
+}
+
+function readCAFile (filename) {
+ // The CA file can contain multiple certificates so split on certificate
+ // boundaries. [\S\s]*? is used to match everything including newlines.
+ var ca = fs.readFileSync(filename, 'utf8')
+ var re = /(-----BEGIN CERTIFICATE-----[\S\s]*?-----END CERTIFICATE-----)/g
+ return ca.match(re)
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/list.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/list.js
new file mode 100644
index 0000000000000..9d680a56a434a
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/list.js
@@ -0,0 +1,33 @@
+
+module.exports = exports = list
+
+exports.usage = 'Prints a listing of the currently installed node development files'
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('graceful-fs')
+ , path = require('path')
+ , log = require('npmlog')
+
+function list (gyp, args, callback) {
+
+ var devDir = gyp.devDir
+ log.verbose('list', 'using node-gyp dir:', devDir)
+
+ // readdir() the node-gyp dir
+ fs.readdir(devDir, onreaddir)
+
+ function onreaddir (err, versions) {
+ if (err && err.code != 'ENOENT') {
+ return callback(err)
+ }
+ if (Array.isArray(versions)) {
+ versions = versions.filter(function (v) { return v != 'current' })
+ } else {
+ versions = []
+ }
+ callback(null, versions)
+ }
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/node-gyp.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/node-gyp.js
new file mode 100644
index 0000000000000..a841161e32eec
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/node-gyp.js
@@ -0,0 +1,216 @@
+
+/**
+ * Module exports.
+ */
+
+module.exports = exports = gyp
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('graceful-fs')
+ , path = require('path')
+ , nopt = require('nopt')
+ , log = require('npmlog')
+ , child_process = require('child_process')
+ , EE = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , commands = [
+ // Module build commands
+ 'build'
+ , 'clean'
+ , 'configure'
+ , 'rebuild'
+ // Development Header File management commands
+ , 'install'
+ , 'list'
+ , 'remove'
+ ]
+ , aliases = {
+ 'ls': 'list'
+ , 'rm': 'remove'
+ }
+
+// differentiate node-gyp's logs from npm's
+log.heading = 'gyp'
+
+/**
+ * The `gyp` function.
+ */
+
+function gyp () {
+ return new Gyp()
+}
+
+function Gyp () {
+ var self = this
+
+ this.devDir = ''
+ this.commands = {}
+
+ commands.forEach(function (command) {
+ self.commands[command] = function (argv, callback) {
+ log.verbose('command', command, argv)
+ return require('./' + command)(self, argv, callback)
+ }
+ })
+}
+inherits(Gyp, EE)
+exports.Gyp = Gyp
+var proto = Gyp.prototype
+
+/**
+ * Export the contents of the package.json.
+ */
+
+proto.package = require('../package')
+
+/**
+ * nopt configuration definitions
+ */
+
+proto.configDefs = {
+ help: Boolean // everywhere
+ , arch: String // 'configure'
+ , cafile: String // 'install'
+ , debug: Boolean // 'build'
+ , directory: String // bin
+ , make: String // 'build'
+ , msvs_version: String // 'configure'
+ , ensure: Boolean // 'install'
+ , solution: String // 'build' (windows only)
+ , proxy: String // 'install'
+ , devdir: String // everywhere
+ , nodedir: String // 'configure'
+ , loglevel: String // everywhere
+ , python: String // 'configure'
+ , 'dist-url': String // 'install'
+ , 'tarball': String // 'install'
+ , jobs: String // 'build'
+ , thin: String // 'configure'
+}
+
+/**
+ * nopt shorthands
+ */
+
+proto.shorthands = {
+ release: '--no-debug'
+ , C: '--directory'
+ , debug: '--debug'
+ , j: '--jobs'
+ , silly: '--loglevel=silly'
+ , verbose: '--loglevel=verbose'
+ , silent: '--loglevel=silent'
+}
+
+/**
+ * expose the command aliases for the bin file to use.
+ */
+
+proto.aliases = aliases
+
+/**
+ * Parses the given argv array and sets the 'opts',
+ * 'argv' and 'command' properties.
+ */
+
+proto.parseArgv = function parseOpts (argv) {
+ this.opts = nopt(this.configDefs, this.shorthands, argv)
+ this.argv = this.opts.argv.remain.slice()
+
+ var commands = this.todo = []
+
+ // create a copy of the argv array with aliases mapped
+ argv = this.argv.map(function (arg) {
+ // is this an alias?
+ if (arg in this.aliases) {
+ arg = this.aliases[arg]
+ }
+ return arg
+ }, this)
+
+ // process the mapped args into "command" objects ("name" and "args" props)
+ argv.slice().forEach(function (arg) {
+ if (arg in this.commands) {
+ var args = argv.splice(0, argv.indexOf(arg))
+ argv.shift()
+ if (commands.length > 0) {
+ commands[commands.length - 1].args = args
+ }
+ commands.push({ name: arg, args: [] })
+ }
+ }, this)
+ if (commands.length > 0) {
+ commands[commands.length - 1].args = argv.splice(0)
+ }
+
+ // support for inheriting config env variables from npm
+ var npm_config_prefix = 'npm_config_'
+ Object.keys(process.env).forEach(function (name) {
+ if (name.indexOf(npm_config_prefix) !== 0) return
+ var val = process.env[name]
+ if (name === npm_config_prefix + 'loglevel') {
+ log.level = val
+ } else {
+ // add the user-defined options to the config
+ name = name.substring(npm_config_prefix.length)
+ // gyp@741b7f1 enters an infinite loop when it encounters
+ // zero-length options so ensure those don't get through.
+ if (name) this.opts[name] = val
+ }
+ }, this)
+
+ if (this.opts.loglevel) {
+ log.level = this.opts.loglevel
+ }
+ log.resume()
+}
+
+/**
+ * Spawns a child process and emits a 'spawn' event.
+ */
+
+proto.spawn = function spawn (command, args, opts) {
+ if (!opts) opts = {}
+ if (!opts.silent && !opts.stdio) {
+ opts.stdio = [ 0, 1, 2 ]
+ }
+ var cp = child_process.spawn(command, args, opts)
+ log.info('spawn', command)
+ log.info('spawn args', args)
+ return cp
+}
+
+/**
+ * Returns the usage instructions for node-gyp.
+ */
+
+proto.usage = function usage () {
+ var str = [
+ ''
+ , ' Usage: node-gyp [options]'
+ , ''
+ , ' where is one of:'
+ , commands.map(function (c) {
+ return ' - ' + c + ' - ' + require('./' + c).usage
+ }).join('\n')
+ , ''
+ , 'node-gyp@' + this.version + ' ' + path.resolve(__dirname, '..')
+ , 'node@' + process.versions.node
+ ].join('\n')
+ return str
+}
+
+/**
+ * Version number getter.
+ */
+
+Object.defineProperty(proto, 'version', {
+ get: function () {
+ return this.package.version
+ }
+ , enumerable: true
+})
+
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/process-release.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/process-release.js
new file mode 100644
index 0000000000000..0d177f1c93e4d
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/process-release.js
@@ -0,0 +1,155 @@
+var semver = require('semver')
+ , url = require('url')
+ , path = require('path')
+ , log = require('npmlog')
+
+ // versions where -headers.tar.gz started shipping
+ , headersTarballRange = '>= 3.0.0 || ~0.12.10 || ~0.10.42'
+ , bitsre = /\/win-(x86|x64)\//
+ , bitsreV3 = /\/win-(x86|ia32|x64)\// // io.js v3.x.x shipped with "ia32" but should
+ // have been "x86"
+
+// Captures all the logic required to determine download URLs, local directory and
+// file names. Inputs come from command-line switches (--target, --dist-url),
+// `process.version` and `process.release` where it exists.
+function processRelease (argv, gyp, defaultVersion, defaultRelease) {
+ var version = (semver.valid(argv[0]) && argv[0]) || gyp.opts.target || defaultVersion
+ , versionSemver = semver.parse(version)
+ , overrideDistUrl = gyp.opts['dist-url'] || gyp.opts.disturl
+ , isDefaultVersion
+ , isIojs
+ , name
+ , distBaseUrl
+ , baseUrl
+ , libUrl32
+ , libUrl64
+ , tarballUrl
+ , canGetHeaders
+
+ if (!versionSemver) {
+ // not a valid semver string, nothing we can do
+ return { version: version }
+ }
+ // flatten version into String
+ version = versionSemver.version
+
+ // defaultVersion should come from process.version so ought to be valid semver
+ isDefaultVersion = version === semver.parse(defaultVersion).version
+
+ // can't use process.release if we're using --target=x.y.z
+ if (!isDefaultVersion)
+ defaultRelease = null
+
+ if (defaultRelease) {
+ // v3 onward, has process.release
+ name = defaultRelease.name.replace(/io\.js/, 'iojs') // remove the '.' for directory naming purposes
+ isIojs = name === 'iojs'
+ } else {
+ // old node or alternative --target=
+ // semver.satisfies() doesn't like prerelease tags so test major directly
+ isIojs = versionSemver.major >= 1 && versionSemver.major < 4
+ name = isIojs ? 'iojs' : 'node'
+ }
+
+ // check for the nvm.sh standard mirror env variables
+ if (!overrideDistUrl) {
+ if (isIojs) {
+ if (process.env.IOJS_ORG_MIRROR) {
+ overrideDistUrl = process.env.IOJS_ORG_MIRROR
+ } else if (process.env.NVM_IOJS_ORG_MIRROR) {// remove on next semver-major
+ overrideDistUrl = process.env.NVM_IOJS_ORG_MIRROR
+ log.warn('download',
+ 'NVM_IOJS_ORG_MIRROR is deprecated and will be removed in node-gyp v4, ' +
+ 'please use IOJS_ORG_MIRROR')
+ }
+ } else {
+ if (process.env.NODEJS_ORG_MIRROR) {
+ overrideDistUrl = process.env.NODEJS_ORG_MIRROR
+ } else if (process.env.NVM_NODEJS_ORG_MIRROR) {// remove on next semver-major
+ overrideDistUrl = process.env.NVM_NODEJS_ORG_MIRROR
+ log.warn('download',
+ 'NVM_NODEJS_ORG_MIRROR is deprecated and will be removed in node-gyp v4, ' +
+ 'please use NODEJS_ORG_MIRROR')
+ }
+ }
+ }
+
+ if (overrideDistUrl)
+ log.verbose('download', 'using dist-url', overrideDistUrl)
+
+ if (overrideDistUrl)
+ distBaseUrl = overrideDistUrl.replace(/\/+$/, '')
+ else
+ distBaseUrl = isIojs ? 'https://iojs.org/download/release' : 'https://nodejs.org/dist'
+ distBaseUrl += '/v' + version + '/'
+
+ // new style, based on process.release so we have a lot of the data we need
+ if (defaultRelease && defaultRelease.headersUrl && !overrideDistUrl) {
+ baseUrl = url.resolve(defaultRelease.headersUrl, './')
+ libUrl32 = resolveLibUrl(name, defaultRelease.libUrl || baseUrl || distBaseUrl, 'x86', versionSemver.major)
+ libUrl64 = resolveLibUrl(name, defaultRelease.libUrl || baseUrl || distBaseUrl, 'x64', versionSemver.major)
+
+ return {
+ version: version,
+ semver: versionSemver,
+ name: name,
+ baseUrl: baseUrl,
+ tarballUrl: defaultRelease.headersUrl,
+ shasumsUrl: url.resolve(baseUrl, 'SHASUMS256.txt'),
+ versionDir: (name !== 'node' ? name + '-' : '') + version,
+ libUrl32: libUrl32,
+ libUrl64: libUrl64,
+ libPath32: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl32).path)),
+ libPath64: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl64).path))
+ }
+ }
+
+ // older versions without process.release are captured here and we have to make
+ // a lot of assumptions, additionally if you --target=x.y.z then we can't use the
+ // current process.release
+
+ baseUrl = distBaseUrl
+ libUrl32 = resolveLibUrl(name, baseUrl, 'x86', versionSemver.major)
+ libUrl64 = resolveLibUrl(name, baseUrl, 'x64', versionSemver.major)
+ // making the bold assumption that anything with a version number >3.0.0 will
+ // have a *-headers.tar.gz file in its dist location, even some frankenstein
+ // custom version
+ canGetHeaders = semver.satisfies(versionSemver, headersTarballRange)
+ tarballUrl = url.resolve(baseUrl, name + '-v' + version + (canGetHeaders ? '-headers' : '') + '.tar.gz')
+
+ return {
+ version: version,
+ semver: versionSemver,
+ name: name,
+ baseUrl: baseUrl,
+ tarballUrl: tarballUrl,
+ shasumsUrl: url.resolve(baseUrl, 'SHASUMS256.txt'),
+ versionDir: (name !== 'node' ? name + '-' : '') + version,
+ libUrl32: libUrl32,
+ libUrl64: libUrl64,
+ libPath32: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl32).path)),
+ libPath64: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl64).path))
+ }
+}
+
+function normalizePath (p) {
+ return path.normalize(p).replace(/\\/g, '/')
+}
+
+function resolveLibUrl (name, defaultUrl, arch, versionMajor) {
+ var base = url.resolve(defaultUrl, './')
+ , hasLibUrl = bitsre.test(defaultUrl) || (versionMajor === 3 && bitsreV3.test(defaultUrl))
+
+ if (!hasLibUrl) {
+ // let's assume it's a baseUrl then
+ if (versionMajor >= 1)
+ return url.resolve(base, 'win-' + arch +'/' + name + '.lib')
+ // prior to io.js@1.0.0 32-bit node.lib lives in /, 64-bit lives in /x64/
+ return url.resolve(base, (arch === 'x64' ? 'x64/' : '') + name + '.lib')
+ }
+
+ // else we have a proper url to a .lib, just make sure it's the right arch
+ return defaultUrl.replace(versionMajor === 3 ? bitsreV3 : bitsre, '/win-' + arch + '/')
+}
+
+module.exports = processRelease
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/rebuild.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/rebuild.js
new file mode 100644
index 0000000000000..4c6f472aa7c07
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/rebuild.js
@@ -0,0 +1,14 @@
+
+module.exports = exports = rebuild
+
+exports.usage = 'Runs "clean", "configure" and "build" all at once'
+
+function rebuild (gyp, argv, callback) {
+
+ gyp.todo.push(
+ { name: 'clean', args: [] }
+ , { name: 'configure', args: argv }
+ , { name: 'build', args: [] }
+ )
+ process.nextTick(callback)
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/lib/remove.js b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/remove.js
new file mode 100644
index 0000000000000..eb80981b88feb
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/lib/remove.js
@@ -0,0 +1,52 @@
+
+module.exports = exports = remove
+
+exports.usage = 'Removes the node development files for the specified version'
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs')
+ , rm = require('rimraf')
+ , path = require('path')
+ , log = require('npmlog')
+ , semver = require('semver')
+
+function remove (gyp, argv, callback) {
+
+ var devDir = gyp.devDir
+ log.verbose('remove', 'using node-gyp dir:', devDir)
+
+ // get the user-specified version to remove
+ var version = argv[0] || gyp.opts.target
+ log.verbose('remove', 'removing target version:', version)
+
+ if (!version) {
+ return callback(new Error('You must specify a version number to remove. Ex: "' + process.version + '"'))
+ }
+
+ var versionSemver = semver.parse(version)
+ if (versionSemver) {
+ // flatten the version Array into a String
+ version = versionSemver.version
+ }
+
+ var versionPath = path.resolve(gyp.devDir, version)
+ log.verbose('remove', 'removing development files for version:', version)
+
+ // first check if its even installed
+ fs.stat(versionPath, function (err, stat) {
+ if (err) {
+ if (err.code == 'ENOENT') {
+ callback(null, 'version was already uninstalled: ' + version)
+ } else {
+ callback(err)
+ }
+ return
+ }
+ // Go ahead and delete the dir
+ rm(versionPath, callback)
+ })
+
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/package.json b/node_modules/npm-lifecycle/node_modules/node-gyp/package.json
new file mode 100644
index 0000000000000..7ab372c4ab2f2
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/package.json
@@ -0,0 +1,84 @@
+{
+ "_from": "node-gyp@^4.0.0",
+ "_id": "node-gyp@4.0.0",
+ "_inBundle": false,
+ "_integrity": "sha512-2XiryJ8sICNo6ej8d0idXDEMKfVfFK7kekGCtJAuelGsYHQxhj13KTf95swTCN2dZ/4lTfZ84Fu31jqJEEgjWA==",
+ "_location": "/npm-lifecycle/node-gyp",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "node-gyp@^4.0.0",
+ "name": "node-gyp",
+ "escapedName": "node-gyp",
+ "rawSpec": "^4.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^4.0.0"
+ },
+ "_requiredBy": [
+ "/npm-lifecycle"
+ ],
+ "_resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-4.0.0.tgz",
+ "_shasum": "972654af4e5dd0cd2a19081b4b46fe0442ba6f45",
+ "_spec": "node-gyp@^4.0.0",
+ "_where": "/Users/isaacs/dev/npm/cli/node_modules/npm-lifecycle",
+ "author": {
+ "name": "Nathan Rajlich",
+ "email": "nathan@tootallnate.net",
+ "url": "http://tootallnate.net"
+ },
+ "bin": {
+ "node-gyp": "./bin/node-gyp.js"
+ },
+ "bugs": {
+ "url": "https://github.com/nodejs/node-gyp/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "glob": "^7.0.3",
+ "graceful-fs": "^4.1.2",
+ "mkdirp": "^0.5.0",
+ "nopt": "2 || 3",
+ "npmlog": "0 || 1 || 2 || 3 || 4",
+ "osenv": "0",
+ "request": "^2.87.0",
+ "rimraf": "2",
+ "semver": "~5.3.0",
+ "tar": "^4.4.8",
+ "which": "1"
+ },
+ "deprecated": false,
+ "description": "Node.js native addon build tool",
+ "devDependencies": {
+ "bindings": "~1.2.1",
+ "nan": "^2.0.0",
+ "require-inject": "~1.3.0",
+ "tape": "~4.2.0"
+ },
+ "engines": {
+ "node": ">= 4.0.0"
+ },
+ "homepage": "https://github.com/nodejs/node-gyp#readme",
+ "installVersion": 9,
+ "keywords": [
+ "native",
+ "addon",
+ "module",
+ "c",
+ "c++",
+ "bindings",
+ "gyp"
+ ],
+ "license": "MIT",
+ "main": "./lib/node-gyp.js",
+ "name": "node-gyp",
+ "preferGlobal": true,
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/nodejs/node-gyp.git"
+ },
+ "scripts": {
+ "test": "tape test/test-*"
+ },
+ "version": "4.0.0"
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/src/win_delay_load_hook.cc b/node_modules/npm-lifecycle/node_modules/node-gyp/src/win_delay_load_hook.cc
new file mode 100644
index 0000000000000..e75954b605101
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/src/win_delay_load_hook.cc
@@ -0,0 +1,36 @@
+/*
+ * When this file is linked to a DLL, it sets up a delay-load hook that
+ * intervenes when the DLL is trying to load 'node.exe' or 'iojs.exe'
+ * dynamically. Instead of trying to locate the .exe file it'll just return
+ * a handle to the process image.
+ *
+ * This allows compiled addons to work when node.exe or iojs.exe is renamed.
+ */
+
+#ifdef _MSC_VER
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include
+
+#include
+#include
+
+static FARPROC WINAPI load_exe_hook(unsigned int event, DelayLoadInfo* info) {
+ HMODULE m;
+ if (event != dliNotePreLoadLibrary)
+ return NULL;
+
+ if (_stricmp(info->szDll, "iojs.exe") != 0 &&
+ _stricmp(info->szDll, "node.exe") != 0)
+ return NULL;
+
+ m = GetModuleHandle(NULL);
+ return (FARPROC) m;
+}
+
+decltype(__pfnDliNotifyHook2) __pfnDliNotifyHook2 = load_exe_hook;
+
+#endif
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/docker.sh b/node_modules/npm-lifecycle/node_modules/node-gyp/test/docker.sh
new file mode 100755
index 0000000000000..ac21aa8d75c98
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/docker.sh
@@ -0,0 +1,164 @@
+#!/bin/bash
+
+#set -e
+
+test_node_versions="0.8.28 0.10.40 0.12.7 4.3.0 5.6.0"
+test_iojs_versions="1.8.4 2.4.0 3.3.0"
+
+myuid=$(id -u)
+mygid=$(id -g)
+__dirname="$(CDPATH= cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+dot_node_gyp=${__dirname}/.node-gyp/
+
+# borrows from https://github.com/rvagg/dnt/
+
+# Simple setup function for a container:
+# setup_container(image id, base image, commands to run to set up)
+setup_container() {
+ local container_id="$1"
+ local base_container="$2"
+ local run_cmd="$3"
+
+ # Does this image exist? If yes, ignore
+ docker inspect "$container_id" &> /dev/null
+ if [[ $? -eq 0 ]]; then
+ echo "Found existing container [$container_id]"
+ else
+ # No such image, so make it
+ echo "Did not find container [$container_id], creating..."
+ docker run -i $base_container /bin/bash -c "$run_cmd"
+ sleep 2
+ docker commit $(docker ps -l -q) $container_id
+ fi
+}
+
+# Run tests inside each of the versioned containers, copy cwd into npm's copy of node-gyp
+# so it'll be invoked by npm when a compile is needed
+# run_tests(version, test-commands)
+run_tests() {
+ local version="$1"
+ local run_cmd="$2"
+
+ run_cmd="rsync -aAXx --delete --exclude .git --exclude build /node-gyp-src/ /usr/lib/node_modules/npm/node_modules/node-gyp/;
+ /bin/su -s /bin/bash node-gyp -c 'cd && ${run_cmd}'"
+
+ rm -rf $dot_node_gyp
+ mkdir $dot_node_gyp
+
+ docker run \
+ --rm -i \
+ -v ~/.npm/:/node-gyp/.npm/ \
+ -v ${dot_node_gyp}:/node-gyp/.node-gyp/ \
+ -v $(pwd):/node-gyp-src/:ro \
+ node-gyp-test/${version} /bin/bash -c "${run_cmd}"
+}
+
+# A base image with build tools and a user account
+setup_container "node-gyp-test/base" "ubuntu:14.04" "
+ adduser --gecos node-gyp --home /node-gyp/ --disabled-login node-gyp --uid $myuid &&
+ echo "node-gyp:node-gyp" | chpasswd &&
+ apt-get update &&
+ apt-get install -y build-essential python git rsync curl
+"
+
+# An image on top of the base containing clones of repos we want to use for testing
+setup_container "node-gyp-test/clones" "node-gyp-test/base" "
+ cd /node-gyp/ && git clone https://github.com/justmoon/node-bignum.git &&
+ cd /node-gyp/ && git clone https://github.com/bnoordhuis/node-buffertools.git &&
+ chown -R node-gyp.node-gyp /node-gyp/
+"
+
+# An image for each of the node versions we want to test with that version installed and the latest npm
+for v in $test_node_versions; do
+ setup_container "node-gyp-test/${v}" "node-gyp-test/clones" "
+ curl -sL https://nodejs.org/dist/v${v}/node-v${v}-linux-x64.tar.gz | tar -zxv --strip-components=1 -C /usr/ &&
+ npm install npm@latest -g &&
+ node -v && npm -v
+ "
+done
+
+# An image for each of the io.js versions we want to test with that version installed and the latest npm
+for v in $test_iojs_versions; do
+ setup_container "node-gyp-test/${v}" "node-gyp-test/clones" "
+ curl -sL https://iojs.org/dist/v${v}/iojs-v${v}-linux-x64.tar.gz | tar -zxv --strip-components=1 -C /usr/ &&
+ npm install npm@latest -g &&
+ node -v && npm -v
+ "
+done
+
+# Run the tests for all of the test images we've created,
+# we should see node-gyp doing its download, configure and run thing
+# _NOTE: bignum doesn't compile on 0.8 currently so it'll fail for that version only_
+for v in $test_node_versions $test_iojs_versions; do
+ run_tests $v "
+ cd node-buffertools && npm install --loglevel=info && npm test && cd
+ "
+ # removed for now, too noisy: cd node-bignum && npm install --loglevel=info && npm test
+done
+
+# Test use of --target=x.y.z to compile against alternate versions
+test_download_node_version() {
+ local run_with_ver="$1"
+ local expected_dir="$2"
+ local expected_ver="$3"
+ run_tests $run_with_ver "cd node-buffertools && npm install --loglevel=info --target=${expected_ver}"
+ local node_ver=$(cat "${dot_node_gyp}${expected_dir}/node_version.h" | grep '#define NODE_\w*_VERSION [0-9]*$')
+ node_ver=$(echo $node_ver | sed 's/#define NODE_[A-Z]*_VERSION //g' | sed 's/ /./g')
+ if [ "X$(echo $node_ver)" != "X${expected_ver}" ]; then
+ echo "Did not download v${expected_ver} using --target, instead got: $(echo $node_ver)"
+ exit 1
+ fi
+ echo "Verified correct download of [v${node_ver}]"
+}
+
+test_download_node_version "0.12.7" "0.10.30/src" "0.10.30"
+test_download_node_version "3.3.0" "iojs-1.8.4/src" "1.8.4"
+# should download the headers file
+test_download_node_version "3.3.0" "iojs-3.3.0/include/node" "3.3.0"
+test_download_node_version "4.3.0" "4.3.0/include/node" "4.3.0"
+test_download_node_version "5.6.0" "5.6.0/include/node" "5.6.0"
+
+# TODO: test --dist-url by starting up a localhost server and serving up tarballs
+
+# testing --dist-url, using simple-proxy.js to make localhost work as a distribution
+# point for tarballs
+# we can test whether it uses the proxy because after 2 connections the proxy will
+# die and therefore should not be running at the end of the test, `nc` can tell us this
+run_tests "3.3.0" "
+ (node /node-gyp-src/test/simple-proxy.js 8080 /foobar/ https://iojs.org/dist/ &) &&
+ cd node-buffertools &&
+ /node-gyp-src/bin/node-gyp.js --loglevel=info --dist-url=http://localhost:8080/foobar/ rebuild &&
+ nc -z localhost 8080 && echo -e \"\\n\\n\\033[31mFAILED TO USE LOCAL PROXY\\033[39m\\n\\n\"
+"
+
+# REMOVE after next semver-major
+run_tests "3.3.0" "
+ (node /node-gyp-src/test/simple-proxy.js 8080 /doobar/ https://iojs.org/dist/ &) &&
+ cd node-buffertools &&
+ NVM_IOJS_ORG_MIRROR=http://localhost:8080/doobar/ /node-gyp-src/bin/node-gyp.js --loglevel=info rebuild &&
+ nc -z localhost 8080 && echo -e \"\\n\\n\\033[31mFAILED TO USE LOCAL PROXY\\033[39m\\n\\n\"
+"
+
+# REMOVE after next semver-major
+run_tests "0.12.7" "
+ (node /node-gyp-src/test/simple-proxy.js 8080 /boombar/ https://nodejs.org/dist/ &) &&
+ cd node-buffertools &&
+ NVM_NODEJS_ORG_MIRROR=http://localhost:8080/boombar/ /node-gyp-src/bin/node-gyp.js --loglevel=info rebuild &&
+ nc -z localhost 8080 && echo -e \"\\n\\n\\033[31mFAILED TO USE LOCAL PROXY\\033[39m\\n\\n\"
+"
+
+run_tests "3.3.0" "
+ (node /node-gyp-src/test/simple-proxy.js 8080 /doobar/ https://iojs.org/dist/ &) &&
+ cd node-buffertools &&
+ IOJS_ORG_MIRROR=http://localhost:8080/doobar/ /node-gyp-src/bin/node-gyp.js --loglevel=info rebuild &&
+ nc -z localhost 8080 && echo -e \"\\n\\n\\033[31mFAILED TO USE LOCAL PROXY\\033[39m\\n\\n\"
+"
+
+run_tests "0.12.7" "
+ (node /node-gyp-src/test/simple-proxy.js 8080 /boombar/ https://nodejs.org/dist/ &) &&
+ cd node-buffertools &&
+ NODEJS_ORG_MIRROR=http://localhost:8080/boombar/ /node-gyp-src/bin/node-gyp.js --loglevel=info rebuild &&
+ nc -z localhost 8080 && echo -e \"\\n\\n\\033[31mFAILED TO USE LOCAL PROXY\\033[39m\\n\\n\"
+"
+
+rm -rf $dot_node_gyp
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/ca-bundle.crt b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/ca-bundle.crt
new file mode 100644
index 0000000000000..fb1dea98a78c8
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/ca-bundle.crt
@@ -0,0 +1,40 @@
+-----BEGIN CERTIFICATE-----
+MIIDJjCCAg4CAhnOMA0GCSqGSIb3DQEBBQUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
+VQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQU3Ryb25n
+TG9vcCwgSW5jLjESMBAGA1UECwwJU3Ryb25nT3BzMRowGAYDVQQDDBFjYS5zdHJv
+bmdsb29wLmNvbTAeFw0xNTEyMDgyMzM1MzNaFw00MzA0MjQyMzM1MzNaMBkxFzAV
+BgNVBAMMDnN0cm9uZ2xvb3AuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAwOYI7OZ2FX/YjRgLZoDQlbPc5UZXU/j0e1wwiJNPtPEax9Y5Uoza0Pnt
+Ikzkc2SfvQ+IJrhXo385tI0W5juuqbHnE7UrjUuPjUX6NHevkxcs/flmjan5wnZM
+cPsGhH71WDuUEEflvZihf2Se2x+xgZtMhc5XGmVmRuZFYKvkgUhA2/w8/QrK+jPT
+n9QRJxZjWNh2RBdC1B7u4jffSmOSUljYFH1I2eTeY+Rdi6YUIYSU9gEoZxsv3Tia
+SomfMF5jt2Mouo6MzA+IhLvvFjcrcph1Qxgi9RkfdCMMd+Ipm9YWELkyG1bDRpQy
+0iyHD4gvVsAqz1Y2KdRSdc3Kt+nTqwIDAQABoxkwFzAVBgNVHREEDjAMhwQAAAAA
+hwR/AAABMA0GCSqGSIb3DQEBBQUAA4IBAQAhy4J0hML3NgmDRHdL5/iTucBe22Mf
+jJjg2aifD1S187dHm+Il4qZNO2plWwAhN0h704f+8wpsaALxUvBIu6nvlvcMP5PH
+jGN5JLe2Km3UaPvYOQU2SgacLilu+uBcIo2JSHLV6O7ziqUj5Gior6YxDLCtEZie
+Ea8aX5/YjuACtEMJ1JjRqjgkM66XAoUe0E8onOK3FgTIO3tGoTJwRp0zS50pFuP0
+PsZtT04ck6mmXEXXknNoAyBCvPypfms9OHqcUIW9fiQnrGbS/Ri4QSQYj0DtFk/1
+na4fY1gf3zTHxH8259b/TOOaPfTnCEsOQtjUrWNR4xhmVZ+HJy4yytUW
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDbzCCAlcCAmm6MA0GCSqGSIb3DQEBCwUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
+VQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQU3Ryb25n
+TG9vcCwgSW5jLjESMBAGA1UECwwJU3Ryb25nT3BzMRowGAYDVQQDDBFjYS5zdHJv
+bmdsb29wLmNvbTAeFw0xNTEyMDgyMzM1MzNaFw00MzA0MjQyMzM1MzNaMH0xCzAJ
+BgNVBAYTAlVTMQswCQYDVQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZ
+MBcGA1UECgwQU3Ryb25nTG9vcCwgSW5jLjESMBAGA1UECwwJU3Ryb25nT3BzMRow
+GAYDVQQDDBFjYS5zdHJvbmdsb29wLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBANfj86jkvvYDjHBgiqWhk9Cj+bqiMq3MqnV0CBO4iuK33Fo6XssE
+H+yVdXlIBFbFe6t655MdBVOR2Sfj7WqNh96vhu6PyDHiwcQlTaiLU6nhIed1J4Wv
+lvnJHFmp8Wbtx5AgLT4UYu03ftvXEl2DLi3vhSL2tRM1ebXHB/KPbRWkb25DPX0P
+foOHot3f2dgNe2x6kponf7E/QDmAu3s7Nlkfh+ryDhgGU7wocXEhXbprNqRqOGNo
+xbXgUI+/9XDxYT/7Gn5LF/fPjtN+aB0SKMnTsDhprVlZie83mlqJ46fOOrR+vrsQ
+mi/1m/TadrARtZoIExC/cQRdVM05EK4tUa8CAwEAATANBgkqhkiG9w0BAQsFAAOC
+AQEAQ7k5WhyhDTIGYCNzRnrMHWSzGqa1y4tJMW06wafJNRqTm1cthq1ibc6Hfq5a
+K10K0qMcgauRTfQ1MWrVCTW/KnJ1vkhiTOH+RvxapGn84gSaRmV6KZen0+gMsgae
+KEGe/3Hn+PmDVV+PTamHgPACfpTww38WHIe/7Ce9gHfG7MZ8cKHNZhDy0IAYPln+
+YRwMLd7JNQffHAbWb2CE1mcea4H/12U8JZW5tHCF6y9V+7IuDzqwIrLKcW3lG17n
+VUG6ODF/Ryqn3V5X+TL91YyXi6c34y34IpC7MQDV/67U7+5Bp5CfeDPWW2wVSrW+
+uGZtfEvhbNm6m2i4UNmpCXxUZQ==
+-----END CERTIFICATE-----
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/ca.crt b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/ca.crt
new file mode 100644
index 0000000000000..9d2755a74f6cd
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/ca.crt
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDbzCCAlcCAmm6MA0GCSqGSIb3DQEBCwUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
+VQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQU3Ryb25n
+TG9vcCwgSW5jLjESMBAGA1UECwwJU3Ryb25nT3BzMRowGAYDVQQDDBFjYS5zdHJv
+bmdsb29wLmNvbTAeFw0xNTEyMDgyMzM1MzNaFw00MzA0MjQyMzM1MzNaMH0xCzAJ
+BgNVBAYTAlVTMQswCQYDVQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZ
+MBcGA1UECgwQU3Ryb25nTG9vcCwgSW5jLjESMBAGA1UECwwJU3Ryb25nT3BzMRow
+GAYDVQQDDBFjYS5zdHJvbmdsb29wLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBANfj86jkvvYDjHBgiqWhk9Cj+bqiMq3MqnV0CBO4iuK33Fo6XssE
+H+yVdXlIBFbFe6t655MdBVOR2Sfj7WqNh96vhu6PyDHiwcQlTaiLU6nhIed1J4Wv
+lvnJHFmp8Wbtx5AgLT4UYu03ftvXEl2DLi3vhSL2tRM1ebXHB/KPbRWkb25DPX0P
+foOHot3f2dgNe2x6kponf7E/QDmAu3s7Nlkfh+ryDhgGU7wocXEhXbprNqRqOGNo
+xbXgUI+/9XDxYT/7Gn5LF/fPjtN+aB0SKMnTsDhprVlZie83mlqJ46fOOrR+vrsQ
+mi/1m/TadrARtZoIExC/cQRdVM05EK4tUa8CAwEAATANBgkqhkiG9w0BAQsFAAOC
+AQEAQ7k5WhyhDTIGYCNzRnrMHWSzGqa1y4tJMW06wafJNRqTm1cthq1ibc6Hfq5a
+K10K0qMcgauRTfQ1MWrVCTW/KnJ1vkhiTOH+RvxapGn84gSaRmV6KZen0+gMsgae
+KEGe/3Hn+PmDVV+PTamHgPACfpTww38WHIe/7Ce9gHfG7MZ8cKHNZhDy0IAYPln+
+YRwMLd7JNQffHAbWb2CE1mcea4H/12U8JZW5tHCF6y9V+7IuDzqwIrLKcW3lG17n
+VUG6ODF/Ryqn3V5X+TL91YyXi6c34y34IpC7MQDV/67U7+5Bp5CfeDPWW2wVSrW+
+uGZtfEvhbNm6m2i4UNmpCXxUZQ==
+-----END CERTIFICATE-----
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/server.crt b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/server.crt
new file mode 100644
index 0000000000000..fe13bb96c599c
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/server.crt
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDJjCCAg4CAhnOMA0GCSqGSIb3DQEBBQUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
+VQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQU3Ryb25n
+TG9vcCwgSW5jLjESMBAGA1UECwwJU3Ryb25nT3BzMRowGAYDVQQDDBFjYS5zdHJv
+bmdsb29wLmNvbTAeFw0xNTEyMDgyMzM1MzNaFw00MzA0MjQyMzM1MzNaMBkxFzAV
+BgNVBAMMDnN0cm9uZ2xvb3AuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAwOYI7OZ2FX/YjRgLZoDQlbPc5UZXU/j0e1wwiJNPtPEax9Y5Uoza0Pnt
+Ikzkc2SfvQ+IJrhXo385tI0W5juuqbHnE7UrjUuPjUX6NHevkxcs/flmjan5wnZM
+cPsGhH71WDuUEEflvZihf2Se2x+xgZtMhc5XGmVmRuZFYKvkgUhA2/w8/QrK+jPT
+n9QRJxZjWNh2RBdC1B7u4jffSmOSUljYFH1I2eTeY+Rdi6YUIYSU9gEoZxsv3Tia
+SomfMF5jt2Mouo6MzA+IhLvvFjcrcph1Qxgi9RkfdCMMd+Ipm9YWELkyG1bDRpQy
+0iyHD4gvVsAqz1Y2KdRSdc3Kt+nTqwIDAQABoxkwFzAVBgNVHREEDjAMhwQAAAAA
+hwR/AAABMA0GCSqGSIb3DQEBBQUAA4IBAQAhy4J0hML3NgmDRHdL5/iTucBe22Mf
+jJjg2aifD1S187dHm+Il4qZNO2plWwAhN0h704f+8wpsaALxUvBIu6nvlvcMP5PH
+jGN5JLe2Km3UaPvYOQU2SgacLilu+uBcIo2JSHLV6O7ziqUj5Gior6YxDLCtEZie
+Ea8aX5/YjuACtEMJ1JjRqjgkM66XAoUe0E8onOK3FgTIO3tGoTJwRp0zS50pFuP0
+PsZtT04ck6mmXEXXknNoAyBCvPypfms9OHqcUIW9fiQnrGbS/Ri4QSQYj0DtFk/1
+na4fY1gf3zTHxH8259b/TOOaPfTnCEsOQtjUrWNR4xhmVZ+HJy4yytUW
+-----END CERTIFICATE-----
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/server.key b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/server.key
new file mode 100644
index 0000000000000..f8227f4c0c2d4
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/server.key
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDA5gjs5nYVf9iN
+GAtmgNCVs9zlRldT+PR7XDCIk0+08RrH1jlSjNrQ+e0iTORzZJ+9D4gmuFejfzm0
+jRbmO66psecTtSuNS4+NRfo0d6+TFyz9+WaNqfnCdkxw+waEfvVYO5QQR+W9mKF/
+ZJ7bH7GBm0yFzlcaZWZG5kVgq+SBSEDb/Dz9Csr6M9Of1BEnFmNY2HZEF0LUHu7i
+N99KY5JSWNgUfUjZ5N5j5F2LphQhhJT2AShnGy/dOJpKiZ8wXmO3Yyi6jozMD4iE
+u+8WNytymHVDGCL1GR90Iwx34imb1hYQuTIbVsNGlDLSLIcPiC9WwCrPVjYp1FJ1
+zcq36dOrAgMBAAECggEACg60Xm2xsHNG/ixHw+NpfLSxCr89JGKxlJD88tIDcOK1
+S8AOoxA3BHhTddteeenALmJV7fbkkuC6SICmtgBcnfppmuxyRd6vsGT6o6ut2tR1
+gxRy1WYMYKg8WhOshlH8RspscODeyKDhorvDUJd5cNGBDuTwQ68PwxiUe3La6iac
+EVQoKohg9EmRIhMF1i8I00zXE8p3XENrlTc491ipc+gLPIP5vtqHyQztEUkZHkWd
+dXbs+n1hGCr+4FxrphGYEW80HINzmume7dGChr8nvF4ZZcuWW13DJuNim6pQno1i
+hM8VdXm8XphLh0XEGI5OCfu/CetkBILZRXKltZk6AQKBgQDoBqJzRlp7regYNU4q
+usfS+43tPNaJ0o4DIzcLawqpmK/B/cZStzHl14Sm62BVkKV6cnWAJPeLkENPMFoV
+7Q7wLZBJxpPzqXkpeiDkKN4Wovca891Rffne5Sz6IDB5mOxMjfKIEPd5RkmB5Lkp
+qQLwm3YJ2AJcLagG/Gi1DFDRAQKBgQDU1G9T43Mjke6TXG0u7gCSb+VwyDRsrvJA
+u2vy6+MANRc1EEF31YLmTKOU5XxUmhtIu7TUbgPoNi0HuRFXx4Zul3BPlAosLMJv
+kNQbA/9d0YQAfSgTsploN5CX65dLZ4ejIzVgDZREzpIBWTze6YZTA2DT5iOIet84
+DD5DujY4qwKBgG0PuUo/9oYOD3tZiv1wwD5+uY6auykbTF9TLStzzBY9y9d+hrsY
+mx6zOAoRtz1g+TdeF7b9KVJzo//T9XQ68nuYnyreaWrt7SK+4jj8sK+pOEd1+0Cz
+20CXLpX/jWmKpP+y9R5aA0kA7cpdjV90rwoTuN8Vpr5XQ5TNDhaTzGUBAoGABYig
+fGXlkH8y3NICZL37ddNC+/O4qTrDQbudyusnM9ItkEuj6CG9DY/gkPaGjQyUuQdo
+ZD2YDGmcMh81vDqL3ERDv03yFcP0KkJxwWIRObdA32JhsGFsa7FGKS0O+f7vH+bC
+dITl3gQg97gCRSl9PJtR4TCSq/HF7Acld01YK5ECgYEAwLFB5JIuxrowJe74cCMP
+n5Rwuc8vWdOsg+ytvQTv0/hVCdzcaLet6YvagnWTWaU7PUwTFxZs/mLQ9CAWVutK
+IRzs/GWxGFjH5xotDaJdDDzSdQye4tUqvUVxv7zzzsVycCPBYFkyRQ8Tmr5FLtUJ
+Cl48TZ6J8Rx5avjdtOw3QC8=
+-----END PRIVATE KEY-----
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/test-charmap.py b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/test-charmap.py
new file mode 100644
index 0000000000000..d9fa6fb25e6c6
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/fixtures/test-charmap.py
@@ -0,0 +1,22 @@
+import sys
+import locale
+
+reload(sys)
+
+def main():
+ encoding = locale.getdefaultlocale()[1]
+ if not encoding:
+ return False
+
+ sys.setdefaultencoding(encoding)
+ textmap = {
+ 'cp936': u'\u4e2d\u6587',
+ 'cp1252': u'Lat\u012Bna',
+ 'cp932': u'\u306b\u307b\u3093\u3054'
+ }
+ if textmap.has_key(encoding):
+ print textmap[encoding]
+ return True
+
+if __name__ == '__main__':
+ print main()
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/process-exec-sync.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/process-exec-sync.js
new file mode 100644
index 0000000000000..859cbc1f6fe2b
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/process-exec-sync.js
@@ -0,0 +1,138 @@
+'use strict'
+
+var fs = require('graceful-fs')
+var child_process = require('child_process')
+
+if (!String.prototype.startsWith) {
+ String.prototype.startsWith = function(search, pos) {
+ return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search
+ }
+}
+
+function processExecSync(file, args, options) {
+ var child, error, timeout, tmpdir, command, quote
+ command = makeCommand(file, args)
+
+ /*
+ this function emulates child_process.execSync for legacy node <= 0.10.x
+ derived from https://github.com/gvarsanyi/sync-exec/blob/master/js/sync-exec.js
+ */
+
+ options = options || {}
+ // init timeout
+ timeout = Date.now() + options.timeout
+ // init tmpdir
+ var os_temp_base = '/tmp'
+ var os = determine_os()
+ os_temp_base = '/tmp'
+
+ if (process.env.TMP) {
+ os_temp_base = process.env.TMP
+ }
+
+ if (os_temp_base[os_temp_base.length - 1] !== '/') {
+ os_temp_base += '/'
+ }
+
+ tmpdir = os_temp_base + 'processExecSync.' + Date.now() + Math.random()
+ fs.mkdirSync(tmpdir)
+
+ // init command
+ if (os === 'linux') {
+ command = '(' + command + ' > ' + tmpdir + '/stdout 2> ' + tmpdir +
+ '/stderr); echo $? > ' + tmpdir + '/status'
+ } else {
+ command = '(' + command + ' > ' + tmpdir + '/stdout 2> ' + tmpdir +
+ '/stderr) | echo %errorlevel% > ' + tmpdir + '/status | exit'
+ }
+
+ // init child
+ child = child_process.exec(command, options)
+
+ var maxTry = 100000 // increases the test time by 6 seconds on win-2016-node-0.10
+ var tryCount = 0
+ while (tryCount < maxTry) {
+ try {
+ var x = fs.readFileSync(tmpdir + '/status')
+ if (x.toString() === '0') {
+ break
+ }
+ } catch (ignore) {}
+ tryCount++
+ if (Date.now() > timeout) {
+ error = child
+ break
+ }
+ }
+
+ ['stdout', 'stderr', 'status'].forEach(function (file) {
+ child[file] = fs.readFileSync(tmpdir + '/' + file, options.encoding)
+ setTimeout(unlinkFile, 500, tmpdir + '/' + file)
+ })
+
+ child.status = Number(child.status)
+ if (child.status !== 0) {
+ error = child
+ }
+
+ try {
+ fs.rmdirSync(tmpdir)
+ } catch (ignore) {}
+ if (error) {
+ throw error
+ }
+ return child.stdout
+}
+
+function makeCommand(file, args) {
+ var command, quote
+ command = file
+ if (args.length > 0) {
+ for(var i in args) {
+ command = command + ' '
+ if (args[i][0] === '-') {
+ command = command + args[i]
+ } else {
+ if (!quote) {
+ command = command + '\"'
+ quote = true
+ }
+ command = command + args[i]
+ if (quote) {
+ if (args.length === (parseInt(i) + 1)) {
+ command = command + '\"'
+ }
+ }
+ }
+ }
+ }
+ return command
+}
+
+function determine_os() {
+ var os = ''
+ var tmpVar = ''
+ if (process.env.OSTYPE) {
+ tmpVar = process.env.OSTYPE
+ } else if (process.env.OS) {
+ tmpVar = process.env.OS
+ } else {
+ //default is linux
+ tmpVar = 'linux'
+ }
+
+ if (tmpVar.startsWith('linux')) {
+ os = 'linux'
+ }
+ if (tmpVar.startsWith('win')) {
+ os = 'win'
+ }
+
+ return os
+}
+
+function unlinkFile(file) {
+ fs.unlinkSync(file)
+}
+
+module.exports = processExecSync
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/simple-proxy.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/simple-proxy.js
new file mode 100644
index 0000000000000..e55330c445bf6
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/simple-proxy.js
@@ -0,0 +1,24 @@
+var http = require('http')
+ , https = require('https')
+ , server = http.createServer(handler)
+ , port = +process.argv[2]
+ , prefix = process.argv[3]
+ , upstream = process.argv[4]
+ , calls = 0
+
+server.listen(port)
+
+function handler (req, res) {
+ if (req.url.indexOf(prefix) != 0)
+ throw new Error('request url [' + req.url + '] does not start with [' + prefix + ']')
+
+ var upstreamUrl = upstream + req.url.substring(prefix.length)
+ console.log(req.url + ' -> ' + upstreamUrl)
+ https.get(upstreamUrl, function (ures) {
+ ures.on('end', function () {
+ if (++calls == 2)
+ server.close()
+ })
+ ures.pipe(res)
+ })
+}
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-addon.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-addon.js
new file mode 100644
index 0000000000000..89350effc46b4
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-addon.js
@@ -0,0 +1,113 @@
+'use strict'
+
+var test = require('tape')
+var path = require('path')
+var fs = require('graceful-fs')
+var child_process = require('child_process')
+var addonPath = path.resolve(__dirname, 'node_modules', 'hello_world')
+var nodeGyp = path.resolve(__dirname, '..', 'bin', 'node-gyp.js')
+var execFileSync = child_process.execFileSync || require('./process-exec-sync')
+var execFile = child_process.execFile
+
+function runHello() {
+ var testCode = "console.log(require('hello_world').hello())"
+ return execFileSync(process.execPath, ['-e', testCode], { cwd: __dirname }).toString()
+}
+
+function getEncoding() {
+ var code = 'import locale;print locale.getdefaultlocale()[1]'
+ return execFileSync('python', ['-c', code]).toString().trim()
+}
+
+function checkCharmapValid() {
+ var data
+ try {
+ data = execFileSync('python', ['fixtures/test-charmap.py'],
+ { cwd: __dirname })
+ } catch (err) {
+ return false
+ }
+ var lines = data.toString().trim().split('\n')
+ return lines.pop() === 'True'
+}
+
+test('build simple addon', function (t) {
+ t.plan(3)
+
+ // Set the loglevel otherwise the output disappears when run via 'npm test'
+ var cmd = [nodeGyp, 'rebuild', '-C', addonPath, '--loglevel=verbose']
+ var proc = execFile(process.execPath, cmd, function (err, stdout, stderr) {
+ var logLines = stderr.toString().trim().split(/\r?\n/)
+ var lastLine = logLines[logLines.length-1]
+ t.strictEqual(err, null)
+ t.strictEqual(lastLine, 'gyp info ok', 'should end in ok')
+ t.strictEqual(runHello().trim(), 'world')
+ })
+ proc.stdout.setEncoding('utf-8')
+ proc.stderr.setEncoding('utf-8')
+})
+
+test('build simple addon in path with non-ascii characters', function (t) {
+ t.plan(1)
+
+ if (!checkCharmapValid()) {
+ return t.skip('python console app can\'t encode non-ascii character.')
+ }
+
+ var testDirNames = {
+ 'cp936': '文件夹',
+ 'cp1252': 'Latīna',
+ 'cp932': 'フォルダ'
+ }
+ // Select non-ascii characters by current encoding
+ var testDirName = testDirNames[getEncoding()]
+ // If encoding is UTF-8 or other then no need to test
+ if (!testDirName) {
+ return t.skip('no need to test')
+ }
+
+ t.plan(3)
+
+ var data, configPath = path.join(addonPath, 'build', 'config.gypi')
+ try {
+ data = fs.readFileSync(configPath, 'utf8')
+ } catch (err) {
+ t.error(err)
+ return
+ }
+ var config = JSON.parse(data.replace(/\#.+\n/, ''))
+ var nodeDir = config.variables.nodedir
+ var testNodeDir = path.join(addonPath, testDirName)
+ // Create symbol link to path with non-ascii characters
+ try {
+ fs.symlinkSync(nodeDir, testNodeDir, 'dir')
+ } catch (err) {
+ switch (err.code) {
+ case 'EEXIST': break
+ case 'EPERM':
+ t.error(err, 'Please try to running console as an administrator')
+ return
+ default:
+ t.error(err)
+ return
+ }
+ }
+
+ var cmd = [nodeGyp, 'rebuild', '-C', addonPath,
+ '--loglevel=verbose', '-nodedir=' + testNodeDir]
+ var proc = execFile(process.execPath, cmd, function (err, stdout, stderr) {
+ try {
+ fs.unlink(testNodeDir)
+ } catch (err) {
+ t.error(err)
+ }
+
+ var logLines = stderr.toString().trim().split(/\r?\n/)
+ var lastLine = logLines[logLines.length-1]
+ t.strictEqual(err, null)
+ t.strictEqual(lastLine, 'gyp info ok', 'should end in ok')
+ t.strictEqual(runHello().trim(), 'world')
+ })
+ proc.stdout.setEncoding('utf-8')
+ proc.stderr.setEncoding('utf-8')
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-configure-python.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-configure-python.js
new file mode 100644
index 0000000000000..f235bdbba1c9f
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-configure-python.js
@@ -0,0 +1,74 @@
+'use strict'
+
+var test = require('tape')
+var path = require('path')
+var gyp = require('../lib/node-gyp')
+var requireInject = require('require-inject')
+var configure = requireInject('../lib/configure', {
+ 'graceful-fs': {
+ 'openSync': function (file, mode) { return 0; },
+ 'closeSync': function (fd) { },
+ 'writeFile': function (file, data, cb) { cb() },
+ 'stat': function (file, cb) { cb(null, {}) }
+ }
+})
+
+var EXPECTED_PYPATH = path.join(__dirname, '..', 'gyp', 'pylib')
+var SEPARATOR = process.platform == 'win32' ? ';' : ':'
+var SPAWN_RESULT = { on: function () { } }
+
+test('configure PYTHONPATH with no existing env', function (t) {
+ t.plan(1)
+
+ delete process.env.PYTHONPATH
+
+ var prog = gyp()
+ prog.parseArgv([])
+ prog.spawn = function () {
+ t.equal(process.env.PYTHONPATH, EXPECTED_PYPATH)
+ return SPAWN_RESULT
+ }
+ configure(prog, [], t.fail)
+})
+
+test('configure PYTHONPATH with existing env of one dir', function (t) {
+ t.plan(2)
+
+ var existingPath = path.join('a', 'b')
+ process.env.PYTHONPATH = existingPath
+
+ var prog = gyp()
+ prog.parseArgv([])
+ prog.spawn = function () {
+
+ t.equal(process.env.PYTHONPATH, [EXPECTED_PYPATH, existingPath].join(SEPARATOR))
+
+ var dirs = process.env.PYTHONPATH.split(SEPARATOR)
+ t.deepEqual(dirs, [EXPECTED_PYPATH, existingPath])
+
+ return SPAWN_RESULT
+ }
+ configure(prog, [], t.fail)
+})
+
+test('configure PYTHONPATH with existing env of multiple dirs', function (t) {
+ t.plan(2)
+
+ var pythonDir1 = path.join('a', 'b')
+ var pythonDir2 = path.join('b', 'c')
+ var existingPath = [pythonDir1, pythonDir2].join(SEPARATOR)
+ process.env.PYTHONPATH = existingPath
+
+ var prog = gyp()
+ prog.parseArgv([])
+ prog.spawn = function () {
+
+ t.equal(process.env.PYTHONPATH, [EXPECTED_PYPATH, existingPath].join(SEPARATOR))
+
+ var dirs = process.env.PYTHONPATH.split(SEPARATOR)
+ t.deepEqual(dirs, [EXPECTED_PYPATH, pythonDir1, pythonDir2])
+
+ return SPAWN_RESULT
+ }
+ configure(prog, [], t.fail)
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-download.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-download.js
new file mode 100644
index 0000000000000..6e6f64f058c2e
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-download.js
@@ -0,0 +1,102 @@
+'use strict'
+
+var fs = require('fs')
+var http = require('http')
+var https = require('https')
+var test = require('tape')
+var install = require('../lib/install')
+
+test('download over http', function (t) {
+ t.plan(2)
+
+ var server = http.createServer(function (req, res) {
+ t.strictEqual(req.headers['user-agent'],
+ 'node-gyp v42 (node ' + process.version + ')')
+ res.end('ok')
+ server.close()
+ })
+
+ var host = '127.0.0.1'
+ server.listen(0, host, function () {
+ var port = this.address().port
+ var gyp = {
+ opts: {},
+ version: '42',
+ }
+ var url = 'http://' + host + ':' + port
+ var req = install.test.download(gyp, {}, url)
+ req.on('response', function (res) {
+ var body = ''
+ res.setEncoding('utf8')
+ res.on('data', function(data) {
+ body += data
+ })
+ res.on('end', function() {
+ t.strictEqual(body, 'ok')
+ })
+ })
+ })
+})
+
+test('download over https with custom ca', function (t) {
+ t.plan(3)
+
+ var cert = fs.readFileSync(__dirname + '/fixtures/server.crt', 'utf8')
+ var key = fs.readFileSync(__dirname + '/fixtures/server.key', 'utf8')
+
+ var cafile = __dirname + '/fixtures/ca.crt'
+ var ca = install.test.readCAFile(cafile)
+ t.strictEqual(ca.length, 1)
+
+ var options = { ca: ca, cert: cert, key: key }
+ var server = https.createServer(options, function (req, res) {
+ t.strictEqual(req.headers['user-agent'],
+ 'node-gyp v42 (node ' + process.version + ')')
+ res.end('ok')
+ server.close()
+ })
+
+ server.on('clientError', function (err) {
+ throw err
+ })
+
+ var host = '127.0.0.1'
+ server.listen(8000, host, function () {
+ var port = this.address().port
+ var gyp = {
+ opts: { cafile: cafile },
+ version: '42',
+ }
+ var url = 'https://' + host + ':' + port
+ var req = install.test.download(gyp, {}, url)
+ req.on('response', function (res) {
+ var body = ''
+ res.setEncoding('utf8')
+ res.on('data', function(data) {
+ body += data
+ })
+ res.on('end', function() {
+ t.strictEqual(body, 'ok')
+ })
+ })
+ })
+})
+
+test('download with missing cafile', function (t) {
+ t.plan(1)
+ var gyp = {
+ opts: { cafile: 'no.such.file' },
+ }
+ try {
+ install.test.download(gyp, {}, 'http://bad/')
+ } catch (e) {
+ t.ok(/no.such.file/.test(e.message))
+ }
+})
+
+test('check certificate splitting', function (t) {
+ var cas = install.test.readCAFile(__dirname + '/fixtures/ca-bundle.crt')
+ t.plan(2)
+ t.strictEqual(cas.length, 2)
+ t.notStrictEqual(cas[0], cas[1])
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-accessible-sync.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-accessible-sync.js
new file mode 100644
index 0000000000000..d336243dd0d7b
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-accessible-sync.js
@@ -0,0 +1,86 @@
+'use strict'
+
+var test = require('tape')
+var path = require('path')
+var requireInject = require('require-inject')
+var configure = requireInject('../lib/configure', {
+ 'graceful-fs': {
+ 'closeSync': function (fd) { return undefined },
+ 'openSync': function (path) {
+ if (readableFiles.some(function (f) { return f === path} )) {
+ return 0
+ } else {
+ var error = new Error('ENOENT - not found')
+ throw error
+ }
+ }
+ }
+})
+
+var dir = path.sep + 'testdir'
+var readableFile = 'readable_file'
+var anotherReadableFile = 'another_readable_file'
+var readableFileInDir = 'somedir' + path.sep + readableFile
+var readableFiles = [
+ path.resolve(dir, readableFile),
+ path.resolve(dir, anotherReadableFile),
+ path.resolve(dir, readableFileInDir)
+]
+
+test('find accessible - empty array', function (t) {
+ t.plan(1)
+
+ var candidates = []
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, undefined)
+})
+
+test('find accessible - single item array, readable', function (t) {
+ t.plan(1)
+
+ var candidates = [ readableFile ]
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, path.resolve(dir, readableFile))
+})
+
+test('find accessible - single item array, readable in subdir', function (t) {
+ t.plan(1)
+
+ var candidates = [ readableFileInDir ]
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, path.resolve(dir, readableFileInDir))
+})
+
+test('find accessible - single item array, unreadable', function (t) {
+ t.plan(1)
+
+ var candidates = [ 'unreadable_file' ]
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, undefined)
+})
+
+
+test('find accessible - multi item array, no matches', function (t) {
+ t.plan(1)
+
+ var candidates = [ 'non_existent_file', 'unreadable_file' ]
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, undefined)
+})
+
+
+test('find accessible - multi item array, single match', function (t) {
+ t.plan(1)
+
+ var candidates = [ 'non_existent_file', readableFile ]
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, path.resolve(dir, readableFile))
+})
+
+test('find accessible - multi item array, return first match', function (t) {
+ t.plan(1)
+
+ var candidates = [ 'non_existent_file', anotherReadableFile, readableFile ]
+ var found = configure.test.findAccessibleSync('test', dir, candidates)
+ t.strictEqual(found, path.resolve(dir, anotherReadableFile))
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-node-directory.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-node-directory.js
new file mode 100644
index 0000000000000..46659d0cfe8fa
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-node-directory.js
@@ -0,0 +1,115 @@
+var test = require('tape')
+var path = require('path')
+var findNodeDirectory = require('../lib/find-node-directory')
+
+var platforms = ['darwin', 'freebsd', 'linux', 'sunos', 'win32', 'aix']
+
+// we should find the directory based on the directory
+// the script is running in and it should match the layout
+// in a build tree where npm is installed in
+// .... /deps/npm
+test('test find-node-directory - node install', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj = {execPath: '/x/y/bin/node', platform: platforms[next]}
+ t.equal(
+ findNodeDirectory('/x/deps/npm/node_modules/node-gyp/lib', processObj),
+ path.join('/x'))
+ }
+})
+
+// we should find the directory based on the directory
+// the script is running in and it should match the layout
+// in an installed tree where npm is installed in
+// .... /lib/node_modules/npm or .../node_modules/npm
+// depending on the patform
+test('test find-node-directory - node build', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj = {execPath: '/x/y/bin/node', platform: platforms[next]}
+ if (platforms[next] === 'win32') {
+ t.equal(
+ findNodeDirectory('/y/node_modules/npm/node_modules/node-gyp/lib',
+ processObj), path.join('/y'))
+ } else {
+ t.equal(
+ findNodeDirectory('/y/lib/node_modules/npm/node_modules/node-gyp/lib',
+ processObj), path.join('/y'))
+ }
+ }
+})
+
+// we should find the directory based on the execPath
+// for node and match because it was in the bin directory
+test('test find-node-directory - node in bin directory', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj = {execPath: '/x/y/bin/node', platform: platforms[next]}
+ t.equal(
+ findNodeDirectory('/nothere/npm/node_modules/node-gyp/lib', processObj),
+ path.join('/x/y'))
+ }
+})
+
+// we should find the directory based on the execPath
+// for node and match because it was in the Release directory
+test('test find-node-directory - node in build release dir', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj
+ if (platforms[next] === 'win32') {
+ processObj = {execPath: '/x/y/Release/node', platform: platforms[next]}
+ } else {
+ processObj = {execPath: '/x/y/out/Release/node',
+ platform: platforms[next]}
+ }
+
+ t.equal(
+ findNodeDirectory('/nothere/npm/node_modules/node-gyp/lib', processObj),
+ path.join('/x/y'))
+ }
+})
+
+// we should find the directory based on the execPath
+// for node and match because it was in the Debug directory
+test('test find-node-directory - node in Debug release dir', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj
+ if (platforms[next] === 'win32') {
+ processObj = {execPath: '/a/b/Debug/node', platform: platforms[next]}
+ } else {
+ processObj = {execPath: '/a/b/out/Debug/node', platform: platforms[next]}
+ }
+
+ t.equal(
+ findNodeDirectory('/nothere/npm/node_modules/node-gyp/lib', processObj),
+ path.join('/a/b'))
+ }
+})
+
+// we should not find it as it will not match based on the execPath nor
+// the directory from which the script is running
+test('test find-node-directory - not found', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj = {execPath: '/x/y/z/y', platform:next}
+ t.equal(findNodeDirectory('/a/b/c/d', processObj), '')
+ }
+})
+
+// we should find the directory based on the directory
+// the script is running in and it should match the layout
+// in a build tree where npm is installed in
+// .... /deps/npm
+// same test as above but make sure additional directory entries
+// don't cause an issue
+test('test find-node-directory - node install', function (t) {
+ t.plan(platforms.length)
+ for (var next = 0; next < platforms.length; next++) {
+ var processObj = {execPath: '/x/y/bin/node', platform: platforms[next]}
+ t.equal(
+ findNodeDirectory('/x/y/z/a/b/c/deps/npm/node_modules/node-gyp/lib',
+ processObj), path.join('/x/y/z/a/b/c'))
+ }
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-python.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-python.js
new file mode 100644
index 0000000000000..570eb180de7c7
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-find-python.js
@@ -0,0 +1,339 @@
+'use strict'
+
+var test = require('tape')
+var path = require('path')
+var configure = require('../lib/configure')
+var execFile = require('child_process').execFile
+var PythonFinder = configure.test.PythonFinder
+
+test('find python', function (t) {
+ t.plan(4)
+
+ configure.test.findPython('python', function (err, found) {
+ t.strictEqual(err, null)
+ var proc = execFile(found, ['-V'], function (err, stdout, stderr) {
+ t.strictEqual(err, null)
+ t.strictEqual(stdout, '')
+ t.ok(/Python 2/.test(stderr))
+ })
+ proc.stdout.setEncoding('utf-8')
+ proc.stderr.setEncoding('utf-8')
+ })
+})
+
+function poison(object, property) {
+ function fail() {
+ throw new Error('Property ' + property + ' should not have been accessed.')
+ }
+ var descriptor = {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ getter: fail,
+ setter: fail,
+ }
+ Object.defineProperty(object, property, descriptor)
+}
+
+// Work around a v0.10.x CI issue where path.resolve() on UNIX systems prefixes
+// Windows paths with the current working directory. v0.12 and up are free of
+// this issue because they use path.win32.resolve() which does the right thing.
+var resolve = path.win32 && path.win32.resolve || function() {
+ function rstrip(s) { return s.replace(/\\+$/, '') }
+ return [].slice.call(arguments).map(rstrip).join('\\')
+}
+
+function TestPythonFinder() { PythonFinder.apply(this, arguments) }
+TestPythonFinder.prototype = Object.create(PythonFinder.prototype)
+poison(TestPythonFinder.prototype, 'env')
+poison(TestPythonFinder.prototype, 'execFile')
+poison(TestPythonFinder.prototype, 'resolve')
+poison(TestPythonFinder.prototype, 'stat')
+poison(TestPythonFinder.prototype, 'which')
+poison(TestPythonFinder.prototype, 'win')
+
+test('find python - python', function (t) {
+ t.plan(5)
+
+ var f = new TestPythonFinder('python', done)
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(null, program)
+ }
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'python')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.7.0')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.strictEqual(err, null)
+ t.strictEqual(python, 'python')
+ }
+})
+
+test('find python - python too old', function (t) {
+ t.plan(4)
+
+ var f = new TestPythonFinder('python', done)
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(null, program)
+ }
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'python')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.3.4')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(/is not supported by gyp/.test(err))
+ }
+})
+
+test('find python - python too new', function (t) {
+ t.plan(4)
+
+ var f = new TestPythonFinder('python', done)
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(null, program)
+ }
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'python')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '3.0.0')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(/is not supported by gyp/.test(err))
+ }
+})
+
+test('find python - no python', function (t) {
+ t.plan(2)
+
+ var f = new TestPythonFinder('python', done)
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(new Error('not found'))
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(/Can't find Python executable/.test(err))
+ }
+})
+
+test('find python - no python2', function (t) {
+ t.plan(6)
+
+ var f = new TestPythonFinder('python2', done)
+ f.which = function(program, cb) {
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(null, program)
+ }
+ t.strictEqual(program, 'python2')
+ cb(new Error('not found'))
+ }
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'python')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.7.0')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.strictEqual(err, null)
+ t.strictEqual(python, 'python')
+ }
+})
+
+test('find python - no python2, no python, unix', function (t) {
+ t.plan(3)
+
+ var f = new TestPythonFinder('python2', done)
+ poison(f, 'checkPythonLauncher')
+ f.win = false
+
+ f.which = function(program, cb) {
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(new Error('not found'))
+ }
+ t.strictEqual(program, 'python2')
+ cb(new Error('not found'))
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(/Can't find Python executable/.test(err))
+ }
+})
+
+test('find python - no python, use python launcher', function (t) {
+ t.plan(8)
+
+ var f = new TestPythonFinder('python', done)
+ f.env = {}
+ f.win = true
+
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(new Error('not found'))
+ }
+ f.execFile = function(program, args, opts, cb) {
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'Z:\\snake.exe')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.7.0')
+ }
+ t.strictEqual(program, 'py.exe')
+ t.notEqual(args.indexOf('-2'), -1)
+ t.notEqual(args.indexOf('-c'), -1)
+ cb(null, 'Z:\\snake.exe')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.strictEqual(err, null)
+ t.strictEqual(python, 'Z:\\snake.exe')
+ }
+})
+
+test('find python - python 3, use python launcher', function (t) {
+ t.plan(10)
+
+ var f = new TestPythonFinder('python', done)
+ f.env = {}
+ f.win = true
+
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(null, program)
+ }
+ f.execFile = function(program, args, opts, cb) {
+ f.execFile = function(program, args, opts, cb) {
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'Z:\\snake.exe')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.7.0')
+ }
+ t.strictEqual(program, 'py.exe')
+ t.notEqual(args.indexOf('-2'), -1)
+ t.notEqual(args.indexOf('-c'), -1)
+ cb(null, 'Z:\\snake.exe')
+ }
+ t.strictEqual(program, 'python')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '3.0.0')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.strictEqual(err, null)
+ t.strictEqual(python, 'Z:\\snake.exe')
+ }
+})
+
+test('find python - python 3, use python launcher, python 2 too old',
+ function (t) {
+ t.plan(9)
+
+ var f = new TestPythonFinder('python', done)
+ f.checkedPythonLauncher = false
+ f.env = {}
+ f.win = true
+
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(null, program)
+ }
+ f.execFile = function(program, args, opts, cb) {
+ f.execFile = function(program, args, opts, cb) {
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'Z:\\snake.exe')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.3.4')
+ }
+ t.strictEqual(program, 'py.exe')
+ t.notEqual(args.indexOf('-2'), -1)
+ t.notEqual(args.indexOf('-c'), -1)
+ cb(null, 'Z:\\snake.exe')
+ }
+ t.strictEqual(program, 'python')
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '3.0.0')
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(/is not supported by gyp/.test(err))
+ }
+})
+
+test('find python - no python, no python launcher, good guess', function (t) {
+ t.plan(6)
+
+ var re = /C:[\\\/]Python27[\\\/]python[.]exe/
+ var f = new TestPythonFinder('python', done)
+ f.env = {}
+ f.win = true
+
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(new Error('not found'))
+ }
+ f.execFile = function(program, args, opts, cb) {
+ f.execFile = function(program, args, opts, cb) {
+ t.ok(re.test(program))
+ t.ok(/import sys/.test(args[1]))
+ cb(null, '2.7.0')
+ }
+ t.strictEqual(program, 'py.exe')
+ cb(new Error('not found'))
+ }
+ f.resolve = resolve
+ f.stat = function(path, cb) {
+ t.ok(re.test(path))
+ cb(null, {})
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(re.test(python))
+ }
+})
+
+test('find python - no python, no python launcher, bad guess', function (t) {
+ t.plan(4)
+
+ var f = new TestPythonFinder('python', done)
+ f.env = { SystemDrive: 'Z:\\' }
+ f.win = true
+
+ f.which = function(program, cb) {
+ t.strictEqual(program, 'python')
+ cb(new Error('not found'))
+ }
+ f.execFile = function(program, args, opts, cb) {
+ t.strictEqual(program, 'py.exe')
+ cb(new Error('not found'))
+ }
+ f.resolve = resolve
+ f.stat = function(path, cb) {
+ t.ok(/Z:[\\\/]Python27[\\\/]python.exe/.test(path))
+ var err = new Error('not found')
+ err.code = 'ENOENT'
+ cb(err)
+ }
+ f.checkPython()
+
+ function done(err, python) {
+ t.ok(/Can't find Python executable/.test(err))
+ }
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-install.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-install.js
new file mode 100644
index 0000000000000..f647326a7fc66
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-install.js
@@ -0,0 +1,37 @@
+'use strict'
+
+var test = require('tape')
+var install = require('../lib/install').test.install
+
+test('EACCES retry once', function (t) {
+ t.plan(3)
+
+ var fs = {}
+ fs.stat = function (path, cb) {
+ var err = new Error()
+ err.code = 'EACCES'
+ cb(err)
+ t.ok(true);
+ }
+
+
+ var gyp = {}
+ gyp.devDir = __dirname
+ gyp.opts = {}
+ gyp.opts.ensure = true
+ gyp.commands = {}
+ gyp.commands.install = function (argv, cb) {
+ install(fs, gyp, argv, cb)
+ }
+ gyp.commands.remove = function (argv, cb) {
+ cb()
+ }
+
+ gyp.commands.install([], function (err) {
+ t.ok(true)
+ if (/"pre" versions of node cannot be installed/.test(err.message)) {
+ t.ok(true)
+ t.ok(true)
+ }
+ })
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-options.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-options.js
new file mode 100644
index 0000000000000..d097f81be62c8
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-options.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var test = require('tape')
+var gyp = require('../lib/node-gyp')
+
+test('options in environment', function (t) {
+ t.plan(1)
+
+ // `npm test` dumps a ton of npm_config_* variables in the environment.
+ Object.keys(process.env)
+ .filter(function(key) { return /^npm_config_/.test(key) })
+ .forEach(function(key) { delete process.env[key] })
+
+ // Zero-length keys should get filtered out.
+ process.env.npm_config_ = '42'
+ // Other keys should get added.
+ process.env.npm_config_x = '42'
+ // Except loglevel.
+ process.env.npm_config_loglevel = 'debug'
+
+ var g = gyp();
+ g.parseArgv(['rebuild']) // Also sets opts.argv.
+
+ t.deepEqual(Object.keys(g.opts).sort(), ['argv', 'x'])
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-process-release.js b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-process-release.js
new file mode 100644
index 0000000000000..48411ae0a7d5a
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/test/test-process-release.js
@@ -0,0 +1,637 @@
+var test = require('tape')
+var processRelease = require('../lib/process-release')
+
+test('test process release - process.version = 0.8.20', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v0.8.20', null)
+
+ t.equal(release.semver.version, '0.8.20')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.8.20',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.8.20/',
+ tarballUrl: 'https://nodejs.org/dist/v0.8.20/node-v0.8.20.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.8.20/SHASUMS256.txt',
+ versionDir: '0.8.20',
+ libUrl32: 'https://nodejs.org/dist/v0.8.20/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.8.20/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+test('test process release - process.version = 0.10.21', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v0.10.21', null)
+
+ t.equal(release.semver.version, '0.10.21')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.10.21',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.10.21/',
+ tarballUrl: 'https://nodejs.org/dist/v0.10.21/node-v0.10.21.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.10.21/SHASUMS256.txt',
+ versionDir: '0.10.21',
+ libUrl32: 'https://nodejs.org/dist/v0.10.21/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.10.21/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+// prior to -headers.tar.gz
+test('test process release - process.version = 0.12.9', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v0.12.9', null)
+
+ t.equal(release.semver.version, '0.12.9')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.12.9',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.12.9/',
+ tarballUrl: 'https://nodejs.org/dist/v0.12.9/node-v0.12.9.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.12.9/SHASUMS256.txt',
+ versionDir: '0.12.9',
+ libUrl32: 'https://nodejs.org/dist/v0.12.9/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.12.9/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+// prior to -headers.tar.gz
+test('test process release - process.version = 0.10.41', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v0.10.41', null)
+
+ t.equal(release.semver.version, '0.10.41')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.10.41',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.10.41/',
+ tarballUrl: 'https://nodejs.org/dist/v0.10.41/node-v0.10.41.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.10.41/SHASUMS256.txt',
+ versionDir: '0.10.41',
+ libUrl32: 'https://nodejs.org/dist/v0.10.41/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.10.41/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+// has -headers.tar.gz
+test('test process release - process.release ~ node@0.10.42', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v0.10.42', null)
+
+ t.equal(release.semver.version, '0.10.42')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.10.42',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.10.42/',
+ tarballUrl: 'https://nodejs.org/dist/v0.10.42/node-v0.10.42-headers.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.10.42/SHASUMS256.txt',
+ versionDir: '0.10.42',
+ libUrl32: 'https://nodejs.org/dist/v0.10.42/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.10.42/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+// has -headers.tar.gz
+test('test process release - process.release ~ node@0.12.10', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v0.12.10', null)
+
+ t.equal(release.semver.version, '0.12.10')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.12.10',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.12.10/',
+ tarballUrl: 'https://nodejs.org/dist/v0.12.10/node-v0.12.10-headers.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.12.10/SHASUMS256.txt',
+ versionDir: '0.12.10',
+ libUrl32: 'https://nodejs.org/dist/v0.12.10/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.12.10/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+test('test process release - process.release ~ node@4.1.23', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v4.1.23/',
+ tarballUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v4.1.23/SHASUMS256.txt',
+ versionDir: '4.1.23',
+ libUrl32: 'https://nodejs.org/dist/v4.1.23/win-x86/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v4.1.23/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+})
+
+test('test process release - process.release ~ node@4.1.23 / corp build', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://some.custom.location/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'node',
+ baseUrl: 'https://some.custom.location/',
+ tarballUrl: 'https://some.custom.location/node-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'https://some.custom.location/SHASUMS256.txt',
+ versionDir: '4.1.23',
+ libUrl32: 'https://some.custom.location/win-x86/node.lib',
+ libUrl64: 'https://some.custom.location/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+})
+
+test('test process release - process.version = 1.8.4', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v1.8.4', null)
+
+ t.equal(release.semver.version, '1.8.4')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '1.8.4',
+ name: 'iojs',
+ baseUrl: 'https://iojs.org/download/release/v1.8.4/',
+ tarballUrl: 'https://iojs.org/download/release/v1.8.4/iojs-v1.8.4.tar.gz',
+ shasumsUrl: 'https://iojs.org/download/release/v1.8.4/SHASUMS256.txt',
+ versionDir: 'iojs-1.8.4',
+ libUrl32: 'https://iojs.org/download/release/v1.8.4/win-x86/iojs.lib',
+ libUrl64: 'https://iojs.org/download/release/v1.8.4/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+})
+
+test('test process release - process.release ~ iojs@3.2.24', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v3.2.24', {
+ name: 'io.js',
+ headersUrl: 'https://iojs.org/download/release/v3.2.24/iojs-v3.2.24-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '3.2.24')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '3.2.24',
+ name: 'iojs',
+ baseUrl: 'https://iojs.org/download/release/v3.2.24/',
+ tarballUrl: 'https://iojs.org/download/release/v3.2.24/iojs-v3.2.24-headers.tar.gz',
+ shasumsUrl: 'https://iojs.org/download/release/v3.2.24/SHASUMS256.txt',
+ versionDir: 'iojs-3.2.24',
+ libUrl32: 'https://iojs.org/download/release/v3.2.24/win-x86/iojs.lib',
+ libUrl64: 'https://iojs.org/download/release/v3.2.24/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+})
+
+test('test process release - process.release ~ iojs@3.2.11 +libUrl32', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v3.2.11', {
+ name: 'io.js',
+ headersUrl: 'https://iojs.org/download/release/v3.2.11/iojs-v3.2.11-headers.tar.gz',
+ libUrl: 'https://iojs.org/download/release/v3.2.11/win-x86/iojs.lib' // custom
+ })
+
+ t.equal(release.semver.version, '3.2.11')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '3.2.11',
+ name: 'iojs',
+ baseUrl: 'https://iojs.org/download/release/v3.2.11/',
+ tarballUrl: 'https://iojs.org/download/release/v3.2.11/iojs-v3.2.11-headers.tar.gz',
+ shasumsUrl: 'https://iojs.org/download/release/v3.2.11/SHASUMS256.txt',
+ versionDir: 'iojs-3.2.11',
+ libUrl32: 'https://iojs.org/download/release/v3.2.11/win-x86/iojs.lib',
+ libUrl64: 'https://iojs.org/download/release/v3.2.11/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+})
+
+test('test process release - process.release ~ iojs@3.2.101 +libUrl64', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v3.2.101', {
+ name: 'io.js',
+ headersUrl: 'https://iojs.org/download/release/v3.2.101/iojs-v3.2.101-headers.tar.gz',
+ libUrl: 'https://iojs.org/download/release/v3.2.101/win-x64/iojs.lib' // custom
+ })
+
+ t.equal(release.semver.version, '3.2.101')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '3.2.101',
+ name: 'iojs',
+ baseUrl: 'https://iojs.org/download/release/v3.2.101/',
+ tarballUrl: 'https://iojs.org/download/release/v3.2.101/iojs-v3.2.101-headers.tar.gz',
+ shasumsUrl: 'https://iojs.org/download/release/v3.2.101/SHASUMS256.txt',
+ versionDir: 'iojs-3.2.101',
+ libUrl32: 'https://iojs.org/download/release/v3.2.101/win-x86/iojs.lib',
+ libUrl64: 'https://iojs.org/download/release/v3.2.101/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+})
+
+test('test process release - process.release ~ iojs@3.3.0 - borked win-ia32', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v3.2.101', {
+ name: 'io.js',
+ headersUrl: 'https://iojs.org/download/release/v3.2.101/iojs-v3.2.101-headers.tar.gz',
+ libUrl: 'https://iojs.org/download/release/v3.2.101/win-ia32/iojs.lib' // custom
+ })
+
+ t.equal(release.semver.version, '3.2.101')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '3.2.101',
+ name: 'iojs',
+ baseUrl: 'https://iojs.org/download/release/v3.2.101/',
+ tarballUrl: 'https://iojs.org/download/release/v3.2.101/iojs-v3.2.101-headers.tar.gz',
+ shasumsUrl: 'https://iojs.org/download/release/v3.2.101/SHASUMS256.txt',
+ versionDir: 'iojs-3.2.101',
+ libUrl32: 'https://iojs.org/download/release/v3.2.101/win-x86/iojs.lib',
+ libUrl64: 'https://iojs.org/download/release/v3.2.101/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+})
+
+test('test process release - process.release ~ node@4.1.23 --target=0.10.40', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: { target: '0.10.40' } }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '0.10.40')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '0.10.40',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/dist/v0.10.40/',
+ tarballUrl: 'https://nodejs.org/dist/v0.10.40/node-v0.10.40.tar.gz',
+ shasumsUrl: 'https://nodejs.org/dist/v0.10.40/SHASUMS256.txt',
+ versionDir: '0.10.40',
+ libUrl32: 'https://nodejs.org/dist/v0.10.40/node.lib',
+ libUrl64: 'https://nodejs.org/dist/v0.10.40/x64/node.lib',
+ libPath32: 'node.lib',
+ libPath64: 'x64/node.lib'
+ })
+})
+
+test('test process release - process.release ~ node@4.1.23 --target=1.8.4', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: { target: '1.8.4' } }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '1.8.4')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '1.8.4',
+ name: 'iojs',
+ baseUrl: 'https://iojs.org/download/release/v1.8.4/',
+ tarballUrl: 'https://iojs.org/download/release/v1.8.4/iojs-v1.8.4.tar.gz',
+ shasumsUrl: 'https://iojs.org/download/release/v1.8.4/SHASUMS256.txt',
+ versionDir: 'iojs-1.8.4',
+ libUrl32: 'https://iojs.org/download/release/v1.8.4/win-x86/iojs.lib',
+ libUrl64: 'https://iojs.org/download/release/v1.8.4/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+})
+
+test('test process release - process.release ~ node@4.1.23 --dist-url=https://foo.bar/baz', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: { 'dist-url': 'https://foo.bar/baz' } }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'node',
+ baseUrl: 'https://foo.bar/baz/v4.1.23/',
+ tarballUrl: 'https://foo.bar/baz/v4.1.23/node-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'https://foo.bar/baz/v4.1.23/SHASUMS256.txt',
+ versionDir: '4.1.23',
+ libUrl32: 'https://foo.bar/baz/v4.1.23/win-x86/node.lib',
+ libUrl64: 'https://foo.bar/baz/v4.1.23/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+})
+
+test('test process release - process.release ~ frankenstein@4.1.23', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v4.1.23', {
+ name: 'frankenstein',
+ headersUrl: 'https://frankensteinjs.org/dist/v4.1.23/frankenstein-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'frankenstein',
+ baseUrl: 'https://frankensteinjs.org/dist/v4.1.23/',
+ tarballUrl: 'https://frankensteinjs.org/dist/v4.1.23/frankenstein-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'https://frankensteinjs.org/dist/v4.1.23/SHASUMS256.txt',
+ versionDir: 'frankenstein-4.1.23',
+ libUrl32: 'https://frankensteinjs.org/dist/v4.1.23/win-x86/frankenstein.lib',
+ libUrl64: 'https://frankensteinjs.org/dist/v4.1.23/win-x64/frankenstein.lib',
+ libPath32: 'win-x86/frankenstein.lib',
+ libPath64: 'win-x64/frankenstein.lib'
+ })
+})
+
+
+test('test process release - process.release ~ frankenstein@4.1.23 --dist-url=http://foo.bar/baz/', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: { 'dist-url': 'http://foo.bar/baz/' } }, 'v4.1.23', {
+ name: 'frankenstein',
+ headersUrl: 'https://frankensteinjs.org/dist/v4.1.23/frankenstein-v4.1.23.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'frankenstein',
+ baseUrl: 'http://foo.bar/baz/v4.1.23/',
+ tarballUrl: 'http://foo.bar/baz/v4.1.23/frankenstein-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'http://foo.bar/baz/v4.1.23/SHASUMS256.txt',
+ versionDir: 'frankenstein-4.1.23',
+ libUrl32: 'http://foo.bar/baz/v4.1.23/win-x86/frankenstein.lib',
+ libUrl64: 'http://foo.bar/baz/v4.1.23/win-x64/frankenstein.lib',
+ libPath32: 'win-x86/frankenstein.lib',
+ libPath64: 'win-x64/frankenstein.lib'
+ })
+})
+
+test('test process release - process.release ~ node@4.0.0-rc.4', function (t) {
+ t.plan(2)
+
+ var release = processRelease([], { opts: {} }, 'v4.0.0-rc.4', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/node-v4.0.0-rc.4-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.0.0-rc.4')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.0.0-rc.4',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/',
+ tarballUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/node-v4.0.0-rc.4-headers.tar.gz',
+ shasumsUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/SHASUMS256.txt',
+ versionDir: '4.0.0-rc.4',
+ libUrl32: 'https://nodejs.org/download/rc/v4.0.0-rc.4/win-x86/node.lib',
+ libUrl64: 'https://nodejs.org/download/rc/v4.0.0-rc.4/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+})
+
+
+test('test process release - process.release ~ node@4.0.0-rc.4 passed as argv[0]', function (t) {
+ t.plan(2)
+
+ // note the missing 'v' on the arg, it should normalise when checking
+ // whether we're on the default or not
+ var release = processRelease([ '4.0.0-rc.4' ], { opts: {} }, 'v4.0.0-rc.4', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/node-v4.0.0-rc.4-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.0.0-rc.4')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.0.0-rc.4',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/',
+ tarballUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/node-v4.0.0-rc.4-headers.tar.gz',
+ shasumsUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/SHASUMS256.txt',
+ versionDir: '4.0.0-rc.4',
+ libUrl32: 'https://nodejs.org/download/rc/v4.0.0-rc.4/win-x86/node.lib',
+ libUrl64: 'https://nodejs.org/download/rc/v4.0.0-rc.4/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+})
+
+
+test('test process release - process.release ~ node@4.0.0-rc.4 - bogus string passed as argv[0]', function (t) {
+ t.plan(2)
+
+ // additional arguments can be passed in on the commandline that should be ignored if they
+ // are not specifying a valid version @ position 0
+ var release = processRelease([ 'this is no version!' ], { opts: {} }, 'v4.0.0-rc.4', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/node-v4.0.0-rc.4-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.0.0-rc.4')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.0.0-rc.4',
+ name: 'node',
+ baseUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/',
+ tarballUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/node-v4.0.0-rc.4-headers.tar.gz',
+ shasumsUrl: 'https://nodejs.org/download/rc/v4.0.0-rc.4/SHASUMS256.txt',
+ versionDir: '4.0.0-rc.4',
+ libUrl32: 'https://nodejs.org/download/rc/v4.0.0-rc.4/win-x86/node.lib',
+ libUrl64: 'https://nodejs.org/download/rc/v4.0.0-rc.4/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+})
+
+test('test process release - NODEJS_ORG_MIRROR', function (t) {
+ t.plan(2)
+
+ process.env.NODEJS_ORG_MIRROR = 'http://foo.bar'
+
+ var release = processRelease([], { opts: {} }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'node',
+ baseUrl: 'http://foo.bar/v4.1.23/',
+ tarballUrl: 'http://foo.bar/v4.1.23/node-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'http://foo.bar/v4.1.23/SHASUMS256.txt',
+ versionDir: '4.1.23',
+ libUrl32: 'http://foo.bar/v4.1.23/win-x86/node.lib',
+ libUrl64: 'http://foo.bar/v4.1.23/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+
+ delete process.env.NODEJS_ORG_MIRROR
+})
+
+test('test process release - NVM_NODEJS_ORG_MIRROR', function (t) {
+ t.plan(2)
+
+ process.env.NVM_NODEJS_ORG_MIRROR = 'http://foo.bar'
+
+ var release = processRelease([], { opts: {} }, 'v4.1.23', {
+ name: 'node',
+ headersUrl: 'https://nodejs.org/dist/v4.1.23/node-v4.1.23-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '4.1.23')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '4.1.23',
+ name: 'node',
+ baseUrl: 'http://foo.bar/v4.1.23/',
+ tarballUrl: 'http://foo.bar/v4.1.23/node-v4.1.23-headers.tar.gz',
+ shasumsUrl: 'http://foo.bar/v4.1.23/SHASUMS256.txt',
+ versionDir: '4.1.23',
+ libUrl32: 'http://foo.bar/v4.1.23/win-x86/node.lib',
+ libUrl64: 'http://foo.bar/v4.1.23/win-x64/node.lib',
+ libPath32: 'win-x86/node.lib',
+ libPath64: 'win-x64/node.lib'
+ })
+
+ delete process.env.NVM_NODEJS_ORG_MIRROR
+})
+
+test('test process release - IOJS_ORG_MIRROR', function (t) {
+ t.plan(2)
+
+ process.env.IOJS_ORG_MIRROR = 'http://foo.bar'
+
+ var release = processRelease([], { opts: {} }, 'v3.2.24', {
+ name: 'io.js',
+ headersUrl: 'https://iojs.org/download/release/v3.2.24/iojs-v3.2.24-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '3.2.24')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '3.2.24',
+ name: 'iojs',
+ baseUrl: 'http://foo.bar/v3.2.24/',
+ tarballUrl: 'http://foo.bar/v3.2.24/iojs-v3.2.24-headers.tar.gz',
+ shasumsUrl: 'http://foo.bar/v3.2.24/SHASUMS256.txt',
+ versionDir: 'iojs-3.2.24',
+ libUrl32: 'http://foo.bar/v3.2.24/win-x86/iojs.lib',
+ libUrl64: 'http://foo.bar/v3.2.24/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+
+ delete process.env.IOJS_ORG_MIRROR
+})
+
+
+test('test process release - NVM_IOJS_ORG_MIRROR', function (t) {
+ t.plan(2)
+
+ process.env.NVM_IOJS_ORG_MIRROR = 'http://foo.bar'
+
+ var release = processRelease([], { opts: {} }, 'v3.2.24', {
+ name: 'io.js',
+ headersUrl: 'https://iojs.org/download/release/v3.2.24/iojs-v3.2.24-headers.tar.gz'
+ })
+
+ t.equal(release.semver.version, '3.2.24')
+ delete release.semver
+
+ t.deepEqual(release, {
+ version: '3.2.24',
+ name: 'iojs',
+ baseUrl: 'http://foo.bar/v3.2.24/',
+ tarballUrl: 'http://foo.bar/v3.2.24/iojs-v3.2.24-headers.tar.gz',
+ shasumsUrl: 'http://foo.bar/v3.2.24/SHASUMS256.txt',
+ versionDir: 'iojs-3.2.24',
+ libUrl32: 'http://foo.bar/v3.2.24/win-x86/iojs.lib',
+ libUrl64: 'http://foo.bar/v3.2.24/win-x64/iojs.lib',
+ libPath32: 'win-x86/iojs.lib',
+ libPath64: 'win-x64/iojs.lib'
+ })
+
+ delete process.env.NVM_IOJS_ORG_MIRROR
+})
diff --git a/node_modules/npm-lifecycle/node_modules/node-gyp/tools/gyp/pylib/gyp/generator/compile_commands_json.py b/node_modules/npm-lifecycle/node_modules/node-gyp/tools/gyp/pylib/gyp/generator/compile_commands_json.py
new file mode 100644
index 0000000000000..575db63c4e194
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/node-gyp/tools/gyp/pylib/gyp/generator/compile_commands_json.py
@@ -0,0 +1,115 @@
+# Copyright (c) 2016 Ben Noordhuis . All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import gyp.common
+import gyp.xcode_emulation
+import json
+import os
+
+generator_additional_non_configuration_keys = []
+generator_additional_path_sections = []
+generator_extra_sources_for_rules = []
+generator_filelist_paths = None
+generator_supports_multiple_toolsets = True
+generator_wants_sorted_dependencies = False
+
+# Lifted from make.py. The actual values don't matter much.
+generator_default_variables = {
+ 'CONFIGURATION_NAME': '$(BUILDTYPE)',
+ 'EXECUTABLE_PREFIX': '',
+ 'EXECUTABLE_SUFFIX': '',
+ 'INTERMEDIATE_DIR': '$(obj).$(TOOLSET)/$(TARGET)/geni',
+ 'PRODUCT_DIR': '$(builddir)',
+ 'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s',
+ 'RULE_INPUT_EXT': '$(suffix $<)',
+ 'RULE_INPUT_NAME': '$(notdir $<)',
+ 'RULE_INPUT_PATH': '$(abspath $<)',
+ 'RULE_INPUT_ROOT': '%(INPUT_ROOT)s',
+ 'SHARED_INTERMEDIATE_DIR': '$(obj)/gen',
+ 'SHARED_LIB_PREFIX': 'lib',
+ 'STATIC_LIB_PREFIX': 'lib',
+ 'STATIC_LIB_SUFFIX': '.a',
+}
+
+
+def IsMac(params):
+ return 'mac' == gyp.common.GetFlavor(params)
+
+
+def CalculateVariables(default_variables, params):
+ default_variables.setdefault('OS', gyp.common.GetFlavor(params))
+
+
+def AddCommandsForTarget(cwd, target, params, per_config_commands):
+ output_dir = params['generator_flags']['output_dir']
+ for configuration_name, configuration in target['configurations'].iteritems():
+ builddir_name = os.path.join(output_dir, configuration_name)
+
+ if IsMac(params):
+ xcode_settings = gyp.xcode_emulation.XcodeSettings(target)
+ cflags = xcode_settings.GetCflags(configuration_name)
+ cflags_c = xcode_settings.GetCflagsC(configuration_name)
+ cflags_cc = xcode_settings.GetCflagsCC(configuration_name)
+ else:
+ cflags = configuration.get('cflags', [])
+ cflags_c = configuration.get('cflags_c', [])
+ cflags_cc = configuration.get('cflags_cc', [])
+
+ cflags_c = cflags + cflags_c
+ cflags_cc = cflags + cflags_cc
+
+ defines = configuration.get('defines', [])
+ defines = ['-D' + s for s in defines]
+
+ # TODO(bnoordhuis) Handle generated source files.
+ sources = target.get('sources', [])
+ sources = [s for s in sources if s.endswith('.c') or s.endswith('.cc')]
+
+ def resolve(filename):
+ return os.path.abspath(os.path.join(cwd, filename))
+
+ # TODO(bnoordhuis) Handle generated header files.
+ include_dirs = configuration.get('include_dirs', [])
+ include_dirs = [s for s in include_dirs if not s.startswith('$(obj)')]
+ includes = ['-I' + resolve(s) for s in include_dirs]
+
+ defines = gyp.common.EncodePOSIXShellList(defines)
+ includes = gyp.common.EncodePOSIXShellList(includes)
+ cflags_c = gyp.common.EncodePOSIXShellList(cflags_c)
+ cflags_cc = gyp.common.EncodePOSIXShellList(cflags_cc)
+
+ commands = per_config_commands.setdefault(configuration_name, [])
+ for source in sources:
+ file = resolve(source)
+ isc = source.endswith('.c')
+ cc = 'cc' if isc else 'c++'
+ cflags = cflags_c if isc else cflags_cc
+ command = ' '.join((cc, defines, includes, cflags,
+ '-c', gyp.common.EncodePOSIXShellArgument(file)))
+ commands.append(dict(command=command, directory=output_dir, file=file))
+
+
+def GenerateOutput(target_list, target_dicts, data, params):
+ per_config_commands = {}
+ for qualified_target, target in target_dicts.iteritems():
+ build_file, target_name, toolset = (
+ gyp.common.ParseQualifiedTarget(qualified_target))
+ if IsMac(params):
+ settings = data[build_file]
+ gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(settings, target)
+ cwd = os.path.dirname(build_file)
+ AddCommandsForTarget(cwd, target, params, per_config_commands)
+
+ output_dir = params['generator_flags']['output_dir']
+ for configuration_name, commands in per_config_commands.iteritems():
+ filename = os.path.join(output_dir,
+ configuration_name,
+ 'compile_commands.json')
+ gyp.common.EnsureDirExists(filename)
+ fp = open(filename, 'w')
+ json.dump(commands, fp=fp, indent=0, check_circular=False)
+
+
+def PerformBuild(data, configurations, params):
+ pass
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/.npmignore b/node_modules/npm-lifecycle/node_modules/nopt/.npmignore
new file mode 100644
index 0000000000000..3c3629e647f5d
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/.npmignore
@@ -0,0 +1 @@
+node_modules
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/.travis.yml b/node_modules/npm-lifecycle/node_modules/nopt/.travis.yml
new file mode 100644
index 0000000000000..99f2bbf5068a8
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/.travis.yml
@@ -0,0 +1,9 @@
+language: node_js
+language: node_js
+node_js:
+ - '0.8'
+ - '0.10'
+ - '0.12'
+ - 'iojs'
+before_install:
+ - npm install -g npm@latest
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/LICENSE b/node_modules/npm-lifecycle/node_modules/nopt/LICENSE
new file mode 100644
index 0000000000000..19129e315fe59
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/README.md b/node_modules/npm-lifecycle/node_modules/nopt/README.md
new file mode 100644
index 0000000000000..f21a4b31c5d48
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/README.md
@@ -0,0 +1,211 @@
+If you want to write an option parser, and have it be good, there are
+two ways to do it. The Right Way, and the Wrong Way.
+
+The Wrong Way is to sit down and write an option parser. We've all done
+that.
+
+The Right Way is to write some complex configurable program with so many
+options that you hit the limit of your frustration just trying to
+manage them all, and defer it with duct-tape solutions until you see
+exactly to the core of the problem, and finally snap and write an
+awesome option parser.
+
+If you want to write an option parser, don't write an option parser.
+Write a package manager, or a source control system, or a service
+restarter, or an operating system. You probably won't end up with a
+good one of those, but if you don't give up, and you are relentless and
+diligent enough in your procrastination, you may just end up with a very
+nice option parser.
+
+## USAGE
+
+ // my-program.js
+ var nopt = require("nopt")
+ , Stream = require("stream").Stream
+ , path = require("path")
+ , knownOpts = { "foo" : [String, null]
+ , "bar" : [Stream, Number]
+ , "baz" : path
+ , "bloo" : [ "big", "medium", "small" ]
+ , "flag" : Boolean
+ , "pick" : Boolean
+ , "many1" : [String, Array]
+ , "many2" : [path]
+ }
+ , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
+ , "b7" : ["--bar", "7"]
+ , "m" : ["--bloo", "medium"]
+ , "p" : ["--pick"]
+ , "f" : ["--flag"]
+ }
+ // everything is optional.
+ // knownOpts and shorthands default to {}
+ // arg list defaults to process.argv
+ // slice defaults to 2
+ , parsed = nopt(knownOpts, shortHands, process.argv, 2)
+ console.log(parsed)
+
+This would give you support for any of the following:
+
+```bash
+$ node my-program.js --foo "blerp" --no-flag
+{ "foo" : "blerp", "flag" : false }
+
+$ node my-program.js ---bar 7 --foo "Mr. Hand" --flag
+{ bar: 7, foo: "Mr. Hand", flag: true }
+
+$ node my-program.js --foo "blerp" -f -----p
+{ foo: "blerp", flag: true, pick: true }
+
+$ node my-program.js -fp --foofoo
+{ foo: "Mr. Foo", flag: true, pick: true }
+
+$ node my-program.js --foofoo -- -fp # -- stops the flag parsing.
+{ foo: "Mr. Foo", argv: { remain: ["-fp"] } }
+
+$ node my-program.js --blatzk -fp # unknown opts are ok.
+{ blatzk: true, flag: true, pick: true }
+
+$ node my-program.js --blatzk=1000 -fp # but you need to use = if they have a value
+{ blatzk: 1000, flag: true, pick: true }
+
+$ node my-program.js --no-blatzk -fp # unless they start with "no-"
+{ blatzk: false, flag: true, pick: true }
+
+$ node my-program.js --baz b/a/z # known paths are resolved.
+{ baz: "/Users/isaacs/b/a/z" }
+
+# if Array is one of the types, then it can take many
+# values, and will always be an array. The other types provided
+# specify what types are allowed in the list.
+
+$ node my-program.js --many1 5 --many1 null --many1 foo
+{ many1: ["5", "null", "foo"] }
+
+$ node my-program.js --many2 foo --many2 bar
+{ many2: ["/path/to/foo", "path/to/bar"] }
+```
+
+Read the tests at the bottom of `lib/nopt.js` for more examples of
+what this puppy can do.
+
+## Types
+
+The following types are supported, and defined on `nopt.typeDefs`
+
+* String: A normal string. No parsing is done.
+* path: A file system path. Gets resolved against cwd if not absolute.
+* url: A url. If it doesn't parse, it isn't accepted.
+* Number: Must be numeric.
+* Date: Must parse as a date. If it does, and `Date` is one of the options,
+ then it will return a Date object, not a string.
+* Boolean: Must be either `true` or `false`. If an option is a boolean,
+ then it does not need a value, and its presence will imply `true` as
+ the value. To negate boolean flags, do `--no-whatever` or `--whatever
+ false`
+* NaN: Means that the option is strictly not allowed. Any value will
+ fail.
+* Stream: An object matching the "Stream" class in node. Valuable
+ for use when validating programmatically. (npm uses this to let you
+ supply any WriteStream on the `outfd` and `logfd` config options.)
+* Array: If `Array` is specified as one of the types, then the value
+ will be parsed as a list of options. This means that multiple values
+ can be specified, and that the value will always be an array.
+
+If a type is an array of values not on this list, then those are
+considered valid values. For instance, in the example above, the
+`--bloo` option can only be one of `"big"`, `"medium"`, or `"small"`,
+and any other value will be rejected.
+
+When parsing unknown fields, `"true"`, `"false"`, and `"null"` will be
+interpreted as their JavaScript equivalents.
+
+You can also mix types and values, or multiple types, in a list. For
+instance `{ blah: [Number, null] }` would allow a value to be set to
+either a Number or null. When types are ordered, this implies a
+preference, and the first type that can be used to properly interpret
+the value will be used.
+
+To define a new type, add it to `nopt.typeDefs`. Each item in that
+hash is an object with a `type` member and a `validate` method. The
+`type` member is an object that matches what goes in the type list. The
+`validate` method is a function that gets called with `validate(data,
+key, val)`. Validate methods should assign `data[key]` to the valid
+value of `val` if it can be handled properly, or return boolean
+`false` if it cannot.
+
+You can also call `nopt.clean(data, types, typeDefs)` to clean up a
+config object and remove its invalid properties.
+
+## Error Handling
+
+By default, nopt outputs a warning to standard error when invalid values for
+known options are found. You can change this behavior by assigning a method
+to `nopt.invalidHandler`. This method will be called with
+the offending `nopt.invalidHandler(key, val, types)`.
+
+If no `nopt.invalidHandler` is assigned, then it will console.error
+its whining. If it is assigned to boolean `false` then the warning is
+suppressed.
+
+## Abbreviations
+
+Yes, they are supported. If you define options like this:
+
+```javascript
+{ "foolhardyelephants" : Boolean
+, "pileofmonkeys" : Boolean }
+```
+
+Then this will work:
+
+```bash
+node program.js --foolhar --pil
+node program.js --no-f --pileofmon
+# etc.
+```
+
+## Shorthands
+
+Shorthands are a hash of shorter option names to a snippet of args that
+they expand to.
+
+If multiple one-character shorthands are all combined, and the
+combination does not unambiguously match any other option or shorthand,
+then they will be broken up into their constituent parts. For example:
+
+```json
+{ "s" : ["--loglevel", "silent"]
+, "g" : "--global"
+, "f" : "--force"
+, "p" : "--parseable"
+, "l" : "--long"
+}
+```
+
+```bash
+npm ls -sgflp
+# just like doing this:
+npm ls --loglevel silent --global --force --long --parseable
+```
+
+## The Rest of the args
+
+The config object returned by nopt is given a special member called
+`argv`, which is an object with the following fields:
+
+* `remain`: The remaining args after all the parsing has occurred.
+* `original`: The args as they originally appeared.
+* `cooked`: The args after flags and shorthands are expanded.
+
+## Slicing
+
+Node programs are called with more or less the exact argv as it appears
+in C land, after the v8 and node-specific options have been plucked off.
+As such, `argv[0]` is always `node` and `argv[1]` is always the
+JavaScript program being run.
+
+That's usually not very useful to you. So they're sliced off by
+default. If you want them, then you can pass in `0` as the last
+argument, or any other number that you'd like to slice off the start of
+the list.
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/bin/nopt.js b/node_modules/npm-lifecycle/node_modules/nopt/bin/nopt.js
new file mode 100755
index 0000000000000..3232d4c570fdc
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/bin/nopt.js
@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+var nopt = require("../lib/nopt")
+ , path = require("path")
+ , types = { num: Number
+ , bool: Boolean
+ , help: Boolean
+ , list: Array
+ , "num-list": [Number, Array]
+ , "str-list": [String, Array]
+ , "bool-list": [Boolean, Array]
+ , str: String
+ , clear: Boolean
+ , config: Boolean
+ , length: Number
+ , file: path
+ }
+ , shorthands = { s: [ "--str", "astring" ]
+ , b: [ "--bool" ]
+ , nb: [ "--no-bool" ]
+ , tft: [ "--bool-list", "--no-bool-list", "--bool-list", "true" ]
+ , "?": ["--help"]
+ , h: ["--help"]
+ , H: ["--help"]
+ , n: [ "--num", "125" ]
+ , c: ["--config"]
+ , l: ["--length"]
+ , f: ["--file"]
+ }
+ , parsed = nopt( types
+ , shorthands
+ , process.argv
+ , 2 )
+
+console.log("parsed", parsed)
+
+if (parsed.help) {
+ console.log("")
+ console.log("nopt cli tester")
+ console.log("")
+ console.log("types")
+ console.log(Object.keys(types).map(function M (t) {
+ var type = types[t]
+ if (Array.isArray(type)) {
+ return [t, type.map(function (type) { return type.name })]
+ }
+ return [t, type && type.name]
+ }).reduce(function (s, i) {
+ s[i[0]] = i[1]
+ return s
+ }, {}))
+ console.log("")
+ console.log("shorthands")
+ console.log(shorthands)
+}
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/examples/my-program.js b/node_modules/npm-lifecycle/node_modules/nopt/examples/my-program.js
new file mode 100755
index 0000000000000..142447e18e756
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/examples/my-program.js
@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+//process.env.DEBUG_NOPT = 1
+
+// my-program.js
+var nopt = require("../lib/nopt")
+ , Stream = require("stream").Stream
+ , path = require("path")
+ , knownOpts = { "foo" : [String, null]
+ , "bar" : [Stream, Number]
+ , "baz" : path
+ , "bloo" : [ "big", "medium", "small" ]
+ , "flag" : Boolean
+ , "pick" : Boolean
+ }
+ , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
+ , "b7" : ["--bar", "7"]
+ , "m" : ["--bloo", "medium"]
+ , "p" : ["--pick"]
+ , "f" : ["--flag", "true"]
+ , "g" : ["--flag"]
+ , "s" : "--flag"
+ }
+ // everything is optional.
+ // knownOpts and shorthands default to {}
+ // arg list defaults to process.argv
+ // slice defaults to 2
+ , parsed = nopt(knownOpts, shortHands, process.argv, 2)
+
+console.log("parsed =\n"+ require("util").inspect(parsed))
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/lib/nopt.js b/node_modules/npm-lifecycle/node_modules/nopt/lib/nopt.js
new file mode 100644
index 0000000000000..97707e784243b
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/lib/nopt.js
@@ -0,0 +1,415 @@
+// info about each config option.
+
+var debug = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG
+ ? function () { console.error.apply(console, arguments) }
+ : function () {}
+
+var url = require("url")
+ , path = require("path")
+ , Stream = require("stream").Stream
+ , abbrev = require("abbrev")
+
+module.exports = exports = nopt
+exports.clean = clean
+
+exports.typeDefs =
+ { String : { type: String, validate: validateString }
+ , Boolean : { type: Boolean, validate: validateBoolean }
+ , url : { type: url, validate: validateUrl }
+ , Number : { type: Number, validate: validateNumber }
+ , path : { type: path, validate: validatePath }
+ , Stream : { type: Stream, validate: validateStream }
+ , Date : { type: Date, validate: validateDate }
+ }
+
+function nopt (types, shorthands, args, slice) {
+ args = args || process.argv
+ types = types || {}
+ shorthands = shorthands || {}
+ if (typeof slice !== "number") slice = 2
+
+ debug(types, shorthands, args, slice)
+
+ args = args.slice(slice)
+ var data = {}
+ , key
+ , remain = []
+ , cooked = args
+ , original = args.slice(0)
+
+ parse(args, data, remain, types, shorthands)
+ // now data is full
+ clean(data, types, exports.typeDefs)
+ data.argv = {remain:remain,cooked:cooked,original:original}
+ Object.defineProperty(data.argv, 'toString', { value: function () {
+ return this.original.map(JSON.stringify).join(" ")
+ }, enumerable: false })
+ return data
+}
+
+function clean (data, types, typeDefs) {
+ typeDefs = typeDefs || exports.typeDefs
+ var remove = {}
+ , typeDefault = [false, true, null, String, Array]
+
+ Object.keys(data).forEach(function (k) {
+ if (k === "argv") return
+ var val = data[k]
+ , isArray = Array.isArray(val)
+ , type = types[k]
+ if (!isArray) val = [val]
+ if (!type) type = typeDefault
+ if (type === Array) type = typeDefault.concat(Array)
+ if (!Array.isArray(type)) type = [type]
+
+ debug("val=%j", val)
+ debug("types=", type)
+ val = val.map(function (val) {
+ // if it's an unknown value, then parse false/true/null/numbers/dates
+ if (typeof val === "string") {
+ debug("string %j", val)
+ val = val.trim()
+ if ((val === "null" && ~type.indexOf(null))
+ || (val === "true" &&
+ (~type.indexOf(true) || ~type.indexOf(Boolean)))
+ || (val === "false" &&
+ (~type.indexOf(false) || ~type.indexOf(Boolean)))) {
+ val = JSON.parse(val)
+ debug("jsonable %j", val)
+ } else if (~type.indexOf(Number) && !isNaN(val)) {
+ debug("convert to number", val)
+ val = +val
+ } else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
+ debug("convert to date", val)
+ val = new Date(val)
+ }
+ }
+
+ if (!types.hasOwnProperty(k)) {
+ return val
+ }
+
+ // allow `--no-blah` to set 'blah' to null if null is allowed
+ if (val === false && ~type.indexOf(null) &&
+ !(~type.indexOf(false) || ~type.indexOf(Boolean))) {
+ val = null
+ }
+
+ var d = {}
+ d[k] = val
+ debug("prevalidated val", d, val, types[k])
+ if (!validate(d, k, val, types[k], typeDefs)) {
+ if (exports.invalidHandler) {
+ exports.invalidHandler(k, val, types[k], data)
+ } else if (exports.invalidHandler !== false) {
+ debug("invalid: "+k+"="+val, types[k])
+ }
+ return remove
+ }
+ debug("validated val", d, val, types[k])
+ return d[k]
+ }).filter(function (val) { return val !== remove })
+
+ if (!val.length) delete data[k]
+ else if (isArray) {
+ debug(isArray, data[k], val)
+ data[k] = val
+ } else data[k] = val[0]
+
+ debug("k=%s val=%j", k, val, data[k])
+ })
+}
+
+function validateString (data, k, val) {
+ data[k] = String(val)
+}
+
+function validatePath (data, k, val) {
+ if (val === true) return false
+ if (val === null) return true
+
+ val = String(val)
+ var homePattern = process.platform === 'win32' ? /^~(\/|\\)/ : /^~\//
+ if (val.match(homePattern) && process.env.HOME) {
+ val = path.resolve(process.env.HOME, val.substr(2))
+ }
+ data[k] = path.resolve(String(val))
+ return true
+}
+
+function validateNumber (data, k, val) {
+ debug("validate Number %j %j %j", k, val, isNaN(val))
+ if (isNaN(val)) return false
+ data[k] = +val
+}
+
+function validateDate (data, k, val) {
+ debug("validate Date %j %j %j", k, val, Date.parse(val))
+ var s = Date.parse(val)
+ if (isNaN(s)) return false
+ data[k] = new Date(val)
+}
+
+function validateBoolean (data, k, val) {
+ if (val instanceof Boolean) val = val.valueOf()
+ else if (typeof val === "string") {
+ if (!isNaN(val)) val = !!(+val)
+ else if (val === "null" || val === "false") val = false
+ else val = true
+ } else val = !!val
+ data[k] = val
+}
+
+function validateUrl (data, k, val) {
+ val = url.parse(String(val))
+ if (!val.host) return false
+ data[k] = val.href
+}
+
+function validateStream (data, k, val) {
+ if (!(val instanceof Stream)) return false
+ data[k] = val
+}
+
+function validate (data, k, val, type, typeDefs) {
+ // arrays are lists of types.
+ if (Array.isArray(type)) {
+ for (var i = 0, l = type.length; i < l; i ++) {
+ if (type[i] === Array) continue
+ if (validate(data, k, val, type[i], typeDefs)) return true
+ }
+ delete data[k]
+ return false
+ }
+
+ // an array of anything?
+ if (type === Array) return true
+
+ // NaN is poisonous. Means that something is not allowed.
+ if (type !== type) {
+ debug("Poison NaN", k, val, type)
+ delete data[k]
+ return false
+ }
+
+ // explicit list of values
+ if (val === type) {
+ debug("Explicitly allowed %j", val)
+ // if (isArray) (data[k] = data[k] || []).push(val)
+ // else data[k] = val
+ data[k] = val
+ return true
+ }
+
+ // now go through the list of typeDefs, validate against each one.
+ var ok = false
+ , types = Object.keys(typeDefs)
+ for (var i = 0, l = types.length; i < l; i ++) {
+ debug("test type %j %j %j", k, val, types[i])
+ var t = typeDefs[types[i]]
+ if (t &&
+ ((type && type.name && t.type && t.type.name) ? (type.name === t.type.name) : (type === t.type))) {
+ var d = {}
+ ok = false !== t.validate(d, k, val)
+ val = d[k]
+ if (ok) {
+ // if (isArray) (data[k] = data[k] || []).push(val)
+ // else data[k] = val
+ data[k] = val
+ break
+ }
+ }
+ }
+ debug("OK? %j (%j %j %j)", ok, k, val, types[i])
+
+ if (!ok) delete data[k]
+ return ok
+}
+
+function parse (args, data, remain, types, shorthands) {
+ debug("parse", args, data, remain)
+
+ var key = null
+ , abbrevs = abbrev(Object.keys(types))
+ , shortAbbr = abbrev(Object.keys(shorthands))
+
+ for (var i = 0; i < args.length; i ++) {
+ var arg = args[i]
+ debug("arg", arg)
+
+ if (arg.match(/^-{2,}$/)) {
+ // done with keys.
+ // the rest are args.
+ remain.push.apply(remain, args.slice(i + 1))
+ args[i] = "--"
+ break
+ }
+ var hadEq = false
+ if (arg.charAt(0) === "-" && arg.length > 1) {
+ if (arg.indexOf("=") !== -1) {
+ hadEq = true
+ var v = arg.split("=")
+ arg = v.shift()
+ v = v.join("=")
+ args.splice.apply(args, [i, 1].concat([arg, v]))
+ }
+
+ // see if it's a shorthand
+ // if so, splice and back up to re-parse it.
+ var shRes = resolveShort(arg, shorthands, shortAbbr, abbrevs)
+ debug("arg=%j shRes=%j", arg, shRes)
+ if (shRes) {
+ debug(arg, shRes)
+ args.splice.apply(args, [i, 1].concat(shRes))
+ if (arg !== shRes[0]) {
+ i --
+ continue
+ }
+ }
+ arg = arg.replace(/^-+/, "")
+ var no = null
+ while (arg.toLowerCase().indexOf("no-") === 0) {
+ no = !no
+ arg = arg.substr(3)
+ }
+
+ if (abbrevs[arg]) arg = abbrevs[arg]
+
+ var isArray = types[arg] === Array ||
+ Array.isArray(types[arg]) && types[arg].indexOf(Array) !== -1
+
+ // allow unknown things to be arrays if specified multiple times.
+ if (!types.hasOwnProperty(arg) && data.hasOwnProperty(arg)) {
+ if (!Array.isArray(data[arg]))
+ data[arg] = [data[arg]]
+ isArray = true
+ }
+
+ var val
+ , la = args[i + 1]
+
+ var isBool = typeof no === 'boolean' ||
+ types[arg] === Boolean ||
+ Array.isArray(types[arg]) && types[arg].indexOf(Boolean) !== -1 ||
+ (typeof types[arg] === 'undefined' && !hadEq) ||
+ (la === "false" &&
+ (types[arg] === null ||
+ Array.isArray(types[arg]) && ~types[arg].indexOf(null)))
+
+ if (isBool) {
+ // just set and move along
+ val = !no
+ // however, also support --bool true or --bool false
+ if (la === "true" || la === "false") {
+ val = JSON.parse(la)
+ la = null
+ if (no) val = !val
+ i ++
+ }
+
+ // also support "foo":[Boolean, "bar"] and "--foo bar"
+ if (Array.isArray(types[arg]) && la) {
+ if (~types[arg].indexOf(la)) {
+ // an explicit type
+ val = la
+ i ++
+ } else if ( la === "null" && ~types[arg].indexOf(null) ) {
+ // null allowed
+ val = null
+ i ++
+ } else if ( !la.match(/^-{2,}[^-]/) &&
+ !isNaN(la) &&
+ ~types[arg].indexOf(Number) ) {
+ // number
+ val = +la
+ i ++
+ } else if ( !la.match(/^-[^-]/) && ~types[arg].indexOf(String) ) {
+ // string
+ val = la
+ i ++
+ }
+ }
+
+ if (isArray) (data[arg] = data[arg] || []).push(val)
+ else data[arg] = val
+
+ continue
+ }
+
+ if (types[arg] === String && la === undefined)
+ la = ""
+
+ if (la && la.match(/^-{2,}$/)) {
+ la = undefined
+ i --
+ }
+
+ val = la === undefined ? true : la
+ if (isArray) (data[arg] = data[arg] || []).push(val)
+ else data[arg] = val
+
+ i ++
+ continue
+ }
+ remain.push(arg)
+ }
+}
+
+function resolveShort (arg, shorthands, shortAbbr, abbrevs) {
+ // handle single-char shorthands glommed together, like
+ // npm ls -glp, but only if there is one dash, and only if
+ // all of the chars are single-char shorthands, and it's
+ // not a match to some other abbrev.
+ arg = arg.replace(/^-+/, '')
+
+ // if it's an exact known option, then don't go any further
+ if (abbrevs[arg] === arg)
+ return null
+
+ // if it's an exact known shortopt, same deal
+ if (shorthands[arg]) {
+ // make it an array, if it's a list of words
+ if (shorthands[arg] && !Array.isArray(shorthands[arg]))
+ shorthands[arg] = shorthands[arg].split(/\s+/)
+
+ return shorthands[arg]
+ }
+
+ // first check to see if this arg is a set of single-char shorthands
+ var singles = shorthands.___singles
+ if (!singles) {
+ singles = Object.keys(shorthands).filter(function (s) {
+ return s.length === 1
+ }).reduce(function (l,r) {
+ l[r] = true
+ return l
+ }, {})
+ shorthands.___singles = singles
+ debug('shorthand singles', singles)
+ }
+
+ var chrs = arg.split("").filter(function (c) {
+ return singles[c]
+ })
+
+ if (chrs.join("") === arg) return chrs.map(function (c) {
+ return shorthands[c]
+ }).reduce(function (l, r) {
+ return l.concat(r)
+ }, [])
+
+
+ // if it's an arg abbrev, and not a literal shorthand, then prefer the arg
+ if (abbrevs[arg] && !shorthands[arg])
+ return null
+
+ // if it's an abbr for a shorthand, then use that
+ if (shortAbbr[arg])
+ arg = shortAbbr[arg]
+
+ // make it an array, if it's a list of words
+ if (shorthands[arg] && !Array.isArray(shorthands[arg]))
+ shorthands[arg] = shorthands[arg].split(/\s+/)
+
+ return shorthands[arg]
+}
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/package.json b/node_modules/npm-lifecycle/node_modules/nopt/package.json
new file mode 100644
index 0000000000000..4d0200dfb5ca5
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/package.json
@@ -0,0 +1,57 @@
+{
+ "_from": "nopt@2 || 3",
+ "_id": "nopt@3.0.6",
+ "_inBundle": false,
+ "_integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=",
+ "_location": "/npm-lifecycle/nopt",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "nopt@2 || 3",
+ "name": "nopt",
+ "escapedName": "nopt",
+ "rawSpec": "2 || 3",
+ "saveSpec": null,
+ "fetchSpec": "2 || 3"
+ },
+ "_requiredBy": [
+ "/npm-lifecycle/node-gyp"
+ ],
+ "_resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz",
+ "_shasum": "c6465dbf08abcd4db359317f79ac68a646b28ff9",
+ "_spec": "nopt@2 || 3",
+ "_where": "/Users/isaacs/dev/npm/cli/node_modules/npm-lifecycle/node_modules/node-gyp",
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me",
+ "url": "http://blog.izs.me/"
+ },
+ "bin": {
+ "nopt": "./bin/nopt.js"
+ },
+ "bugs": {
+ "url": "https://github.com/npm/nopt/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "abbrev": "1"
+ },
+ "deprecated": false,
+ "description": "Option parsing for Node, supporting types, shorthands, etc. Used by npm.",
+ "devDependencies": {
+ "tap": "^1.2.0"
+ },
+ "homepage": "https://github.com/npm/nopt#readme",
+ "license": "ISC",
+ "main": "lib/nopt.js",
+ "name": "nopt",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/npm/nopt.git"
+ },
+ "scripts": {
+ "test": "tap test/*.js"
+ },
+ "version": "3.0.6"
+}
diff --git a/node_modules/npm-lifecycle/node_modules/nopt/test/basic.js b/node_modules/npm-lifecycle/node_modules/nopt/test/basic.js
new file mode 100644
index 0000000000000..d399de9209932
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/nopt/test/basic.js
@@ -0,0 +1,273 @@
+var nopt = require("../")
+ , test = require('tap').test
+
+
+test("passing a string results in a string", function (t) {
+ var parsed = nopt({ key: String }, {}, ["--key", "myvalue"], 0)
+ t.same(parsed.key, "myvalue")
+ t.end()
+})
+
+// https://github.com/npm/nopt/issues/31
+test("Empty String results in empty string, not true", function (t) {
+ var parsed = nopt({ empty: String }, {}, ["--empty"], 0)
+ t.same(parsed.empty, "")
+ t.end()
+})
+
+test("~ path is resolved to $HOME", function (t) {
+ var path = require("path")
+ if (!process.env.HOME) process.env.HOME = "/tmp"
+ var parsed = nopt({key: path}, {}, ["--key=~/val"], 0)
+ t.same(parsed.key, path.resolve(process.env.HOME, "val"))
+ t.end()
+})
+
+// https://github.com/npm/nopt/issues/24
+test("Unknown options are not parsed as numbers", function (t) {
+ var parsed = nopt({"parse-me": Number}, null, ['--leave-as-is=1.20', '--parse-me=1.20'], 0)
+ t.equal(parsed['leave-as-is'], '1.20')
+ t.equal(parsed['parse-me'], 1.2)
+ t.end()
+});
+
+// https://github.com/npm/nopt/issues/48
+test("Check types based on name of type", function (t) {
+ var parsed = nopt({"parse-me": {name: "Number"}}, null, ['--parse-me=1.20'], 0)
+ t.equal(parsed['parse-me'], 1.2)
+ t.end()
+})
+
+
+test("Missing types are not parsed", function (t) {
+ var parsed = nopt({"parse-me": {}}, null, ['--parse-me=1.20'], 0)
+ //should only contain argv
+ t.equal(Object.keys(parsed).length, 1)
+ t.end()
+})
+
+test("Types passed without a name are not parsed", function (t) {
+ var parsed = nopt({"parse-me": {}}, {}, ['--parse-me=1.20'], 0)
+ //should only contain argv
+ t.equal(Object.keys(parsed).length, 1)
+ t.end()
+})
+
+test("other tests", function (t) {
+
+ var util = require("util")
+ , Stream = require("stream")
+ , path = require("path")
+ , url = require("url")
+
+ , shorthands =
+ { s : ["--loglevel", "silent"]
+ , d : ["--loglevel", "info"]
+ , dd : ["--loglevel", "verbose"]
+ , ddd : ["--loglevel", "silly"]
+ , noreg : ["--no-registry"]
+ , reg : ["--registry"]
+ , "no-reg" : ["--no-registry"]
+ , silent : ["--loglevel", "silent"]
+ , verbose : ["--loglevel", "verbose"]
+ , h : ["--usage"]
+ , H : ["--usage"]
+ , "?" : ["--usage"]
+ , help : ["--usage"]
+ , v : ["--version"]
+ , f : ["--force"]
+ , desc : ["--description"]
+ , "no-desc" : ["--no-description"]
+ , "local" : ["--no-global"]
+ , l : ["--long"]
+ , p : ["--parseable"]
+ , porcelain : ["--parseable"]
+ , g : ["--global"]
+ }
+
+ , types =
+ { aoa: Array
+ , nullstream: [null, Stream]
+ , date: Date
+ , str: String
+ , browser : String
+ , cache : path
+ , color : ["always", Boolean]
+ , depth : Number
+ , description : Boolean
+ , dev : Boolean
+ , editor : path
+ , force : Boolean
+ , global : Boolean
+ , globalconfig : path
+ , group : [String, Number]
+ , gzipbin : String
+ , logfd : [Number, Stream]
+ , loglevel : ["silent","win","error","warn","info","verbose","silly"]
+ , long : Boolean
+ , "node-version" : [false, String]
+ , npaturl : url
+ , npat : Boolean
+ , "onload-script" : [false, String]
+ , outfd : [Number, Stream]
+ , parseable : Boolean
+ , pre: Boolean
+ , prefix: path
+ , proxy : url
+ , "rebuild-bundle" : Boolean
+ , registry : url
+ , searchopts : String
+ , searchexclude: [null, String]
+ , shell : path
+ , t: [Array, String]
+ , tag : String
+ , tar : String
+ , tmp : path
+ , "unsafe-perm" : Boolean
+ , usage : Boolean
+ , user : String
+ , username : String
+ , userconfig : path
+ , version : Boolean
+ , viewer: path
+ , _exit : Boolean
+ , path: path
+ }
+
+ ; [["-v", {version:true}, []]
+ ,["---v", {version:true}, []]
+ ,["ls -s --no-reg connect -d",
+ {loglevel:"info",registry:null},["ls","connect"]]
+ ,["ls ---s foo",{loglevel:"silent"},["ls","foo"]]
+ ,["ls --registry blargle", {}, ["ls"]]
+ ,["--no-registry", {registry:null}, []]
+ ,["--no-color true", {color:false}, []]
+ ,["--no-color false", {color:true}, []]
+ ,["--no-color", {color:false}, []]
+ ,["--color false", {color:false}, []]
+ ,["--color --logfd 7", {logfd:7,color:true}, []]
+ ,["--color=true", {color:true}, []]
+ ,["--logfd=10", {logfd:10}, []]
+ ,["--tmp=/tmp -tar=gtar",{tmp:"/tmp",tar:"gtar"},[]]
+ ,["--tmp=tmp -tar=gtar",
+ {tmp:path.resolve(process.cwd(), "tmp"),tar:"gtar"},[]]
+ ,["--logfd x", {}, []]
+ ,["a -true -- -no-false", {true:true},["a","-no-false"]]
+ ,["a -no-false", {false:false},["a"]]
+ ,["a -no-no-true", {true:true}, ["a"]]
+ ,["a -no-no-no-false", {false:false}, ["a"]]
+ ,["---NO-no-No-no-no-no-nO-no-no"+
+ "-No-no-no-no-no-no-no-no-no"+
+ "-no-no-no-no-NO-NO-no-no-no-no-no-no"+
+ "-no-body-can-do-the-boogaloo-like-I-do"
+ ,{"body-can-do-the-boogaloo-like-I-do":false}, []]
+ ,["we are -no-strangers-to-love "+
+ "--you-know=the-rules --and=so-do-i "+
+ "---im-thinking-of=a-full-commitment "+
+ "--no-you-would-get-this-from-any-other-guy "+
+ "--no-gonna-give-you-up "+
+ "-no-gonna-let-you-down=true "+
+ "--no-no-gonna-run-around false "+
+ "--desert-you=false "+
+ "--make-you-cry false "+
+ "--no-tell-a-lie "+
+ "--no-no-and-hurt-you false"
+ ,{"strangers-to-love":false
+ ,"you-know":"the-rules"
+ ,"and":"so-do-i"
+ ,"you-would-get-this-from-any-other-guy":false
+ ,"gonna-give-you-up":false
+ ,"gonna-let-you-down":false
+ ,"gonna-run-around":false
+ ,"desert-you":false
+ ,"make-you-cry":false
+ ,"tell-a-lie":false
+ ,"and-hurt-you":false
+ },["we", "are"]]
+ ,["-t one -t two -t three"
+ ,{t: ["one", "two", "three"]}
+ ,[]]
+ ,["-t one -t null -t three four five null"
+ ,{t: ["one", "null", "three"]}
+ ,["four", "five", "null"]]
+ ,["-t foo"
+ ,{t:["foo"]}
+ ,[]]
+ ,["--no-t"
+ ,{t:["false"]}
+ ,[]]
+ ,["-no-no-t"
+ ,{t:["true"]}
+ ,[]]
+ ,["-aoa one -aoa null -aoa 100"
+ ,{aoa:["one", null, '100']}
+ ,[]]
+ ,["-str 100"
+ ,{str:"100"}
+ ,[]]
+ ,["--color always"
+ ,{color:"always"}
+ ,[]]
+ ,["--no-nullstream"
+ ,{nullstream:null}
+ ,[]]
+ ,["--nullstream false"
+ ,{nullstream:null}
+ ,[]]
+ ,["--notadate=2011-01-25"
+ ,{notadate: "2011-01-25"}
+ ,[]]
+ ,["--date 2011-01-25"
+ ,{date: new Date("2011-01-25")}
+ ,[]]
+ ,["-cl 1"
+ ,{config: true, length: 1}
+ ,[]
+ ,{config: Boolean, length: Number, clear: Boolean}
+ ,{c: "--config", l: "--length"}]
+ ,["--acount bla"
+ ,{"acount":true}
+ ,["bla"]
+ ,{account: Boolean, credentials: Boolean, options: String}
+ ,{a:"--account", c:"--credentials",o:"--options"}]
+ ,["--clear"
+ ,{clear:true}
+ ,[]
+ ,{clear:Boolean,con:Boolean,len:Boolean,exp:Boolean,add:Boolean,rep:Boolean}
+ ,{c:"--con",l:"--len",e:"--exp",a:"--add",r:"--rep"}]
+ ,["--file -"
+ ,{"file":"-"}
+ ,[]
+ ,{file:String}
+ ,{}]
+ ,["--file -"
+ ,{"file":true}
+ ,["-"]
+ ,{file:Boolean}
+ ,{}]
+ ,["--path"
+ ,{"path":null}
+ ,[]]
+ ,["--path ."
+ ,{"path":process.cwd()}
+ ,[]]
+ ].forEach(function (test) {
+ var argv = test[0].split(/\s+/)
+ , opts = test[1]
+ , rem = test[2]
+ , actual = nopt(test[3] || types, test[4] || shorthands, argv, 0)
+ , parsed = actual.argv
+ delete actual.argv
+ for (var i in opts) {
+ var e = JSON.stringify(opts[i])
+ , a = JSON.stringify(actual[i] === undefined ? null : actual[i])
+ if (e && typeof e === "object") {
+ t.deepEqual(e, a)
+ } else {
+ t.equal(e, a)
+ }
+ }
+ t.deepEqual(rem, parsed.remain)
+ })
+ t.end()
+})
diff --git a/node_modules/npm-lifecycle/node_modules/semver/LICENSE b/node_modules/npm-lifecycle/node_modules/semver/LICENSE
new file mode 100644
index 0000000000000..19129e315fe59
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/semver/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/npm-lifecycle/node_modules/semver/README.md b/node_modules/npm-lifecycle/node_modules/semver/README.md
new file mode 100644
index 0000000000000..cbd956549dbb0
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/semver/README.md
@@ -0,0 +1,350 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Usage
+
+ $ npm install semver
+ $ node
+ var semver = require('semver')
+
+ semver.valid('1.2.3') // '1.2.3'
+ semver.valid('a.b.c') // null
+ semver.clean(' =v1.2.3 ') // '1.2.3'
+ semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+ semver.gt('1.2.3', '9.8.7') // false
+ semver.lt('1.2.3', '9.8.7') // true
+
+As a command-line utility:
+
+ $ semver -h
+
+ SemVer 5.1.0
+
+ A JavaScript implementation of the http://semver.org/ specification
+ Copyright Isaac Z. Schlueter
+
+ Usage: semver [options] [ [...]]
+ Prints valid versions sorted by SemVer precedence
+
+ Options:
+ -r --range
+ Print versions that match the specified range.
+
+ -i --increment []
+ Increment a version by the specified level. Level can
+ be one of: major, minor, patch, premajor, preminor,
+ prepatch, or prerelease. Default level is 'patch'.
+ Only one version may be specified.
+
+ --preid
+ Identifier to be used to prefix premajor, preminor,
+ prepatch or prerelease version increments.
+
+ -l --loose
+ Interpret versions and ranges loosely
+
+ Program exits successfully if any valid version satisfies
+ all supplied ranges, and prints all satisfying versions.
+
+ If no satisfying versions are found, then exits failure.
+
+ Versions are printed in ascending order, so supplying
+ multiple versions to the utility will just sort them.
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`. The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal. If no operator is specified, then equality is assumed,
+ so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`. A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules. The version
+range only accepts prerelease tags on the `1.2.3` version. The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold. First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions. By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk. However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+> semver.inc('1.2.3', 'prerelease', 'beta')
+'1.2.4-beta.0'
+```
+
+command-line example:
+
+```shell
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```shell
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any version satisfies)
+* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator. Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
+ the `1.2.3` version will be allowed, if they are greater than or
+ equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
+ `1.2.4-beta.2` would not, because it is a prerelease of a
+ different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero digit in the
+`[major, minor, patch]` tuple. In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`. It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0`
+* `^0.2.3` := `>=0.2.3 <0.3.0`
+* `^0.0.3` := `>=0.0.3 <0.0.4`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
+ the `1.2.3` version will be allowed, if they are greater than or
+ equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
+ `1.2.4-beta.2` would not, because it is a prerelease of a
+ different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the
+ `0.0.3` version *only* will be allowed, if they are greater than or
+ equal to `beta`. So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0`
+* `^0.0.x` := `>=0.0.0 <0.1.0`
+* `^0.0` := `>=0.0.0 <0.1.0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0`
+* `^0.x` := `>=0.0.0 <1.0.0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen ::= partial ' - ' partial
+simple ::= primitive | partial | tilde | caret
+primitive ::= ( '<' | '>' | '>=' | '<=' | '=' | ) partial
+partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr ::= 'x' | 'X' | '*' | nr
+nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde ::= '~' partial
+caret ::= '^' partial
+qualifier ::= ( '-' pre )? ( '+' build )?
+pre ::= parts
+build ::= parts
+parts ::= part ( '.' part ) *
+part ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `loose` boolean argument that, if
+true, will be more forgiving about not-quite-valid semver strings.
+The resulting output will always be 100% strict, of course.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+ type (`major`, `premajor`, `minor`, `preminor`, `patch`,
+ `prepatch`, or `prerelease`), or null if it's not valid
+ * `premajor` in one call will bump the version up to the next major
+ version and down to a prerelease of that major version.
+ `preminor`, and `prepatch` work the same way.
+ * If called from a non-prerelease version, the `prerelease` will work the
+ same as `prepatch`. It increments the patch version, then makes a
+ prerelease. If the input version is already a prerelease it simply
+ increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+ if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+ even if they're not the exact same string. You already know how to
+ compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+ the corresponding function above. `"==="` and `"!=="` do simple
+ string comparison, but are included for completeness. Throws if an
+ invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+ `v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions
+ in descending order when passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+ (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+ or null if the versions are the same.
+
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+ range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+ that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+ that satisfies the range, or `null` if none of them do.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+ versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+ versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+ the bounds of the range in either the high or low direction. The
+ `hilo` argument must be either the string `'>'` or `'<'`. (This is
+ the function called by `gtr` and `ltr`.)
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range! For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
diff --git a/node_modules/npm-lifecycle/node_modules/semver/bin/semver b/node_modules/npm-lifecycle/node_modules/semver/bin/semver
new file mode 100755
index 0000000000000..c5f2e857e8279
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/semver/bin/semver
@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+ , versions = []
+ , range = []
+ , gt = []
+ , lt = []
+ , eq = []
+ , inc = null
+ , version = require("../package.json").version
+ , loose = false
+ , identifier = undefined
+ , semver = require("../semver")
+ , reverse = false
+
+main()
+
+function main () {
+ if (!argv.length) return help()
+ while (argv.length) {
+ var a = argv.shift()
+ var i = a.indexOf('=')
+ if (i !== -1) {
+ a = a.slice(0, i)
+ argv.unshift(a.slice(i + 1))
+ }
+ switch (a) {
+ case "-rv": case "-rev": case "--rev": case "--reverse":
+ reverse = true
+ break
+ case "-l": case "--loose":
+ loose = true
+ break
+ case "-v": case "--version":
+ versions.push(argv.shift())
+ break
+ case "-i": case "--inc": case "--increment":
+ switch (argv[0]) {
+ case "major": case "minor": case "patch": case "prerelease":
+ case "premajor": case "preminor": case "prepatch":
+ inc = argv.shift()
+ break
+ default:
+ inc = "patch"
+ break
+ }
+ break
+ case "--preid":
+ identifier = argv.shift()
+ break
+ case "-r": case "--range":
+ range.push(argv.shift())
+ break
+ case "-h": case "--help": case "-?":
+ return help()
+ default:
+ versions.push(a)
+ break
+ }
+ }
+
+ versions = versions.filter(function (v) {
+ return semver.valid(v, loose)
+ })
+ if (!versions.length) return fail()
+ if (inc && (versions.length !== 1 || range.length))
+ return failInc()
+
+ for (var i = 0, l = range.length; i < l ; i ++) {
+ versions = versions.filter(function (v) {
+ return semver.satisfies(v, range[i], loose)
+ })
+ if (!versions.length) return fail()
+ }
+ return success(versions)
+}
+
+function failInc () {
+ console.error("--inc can only be used on a single version with no range")
+ fail()
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+ var compare = reverse ? "rcompare" : "compare"
+ versions.sort(function (a, b) {
+ return semver[compare](a, b, loose)
+ }).map(function (v) {
+ return semver.clean(v, loose)
+ }).map(function (v) {
+ return inc ? semver.inc(v, inc, loose, identifier) : v
+ }).forEach(function (v,i,_) { console.log(v) })
+}
+
+function help () {
+ console.log(["SemVer " + version
+ ,""
+ ,"A JavaScript implementation of the http://semver.org/ specification"
+ ,"Copyright Isaac Z. Schlueter"
+ ,""
+ ,"Usage: semver [options] [ [...]]"
+ ,"Prints valid versions sorted by SemVer precedence"
+ ,""
+ ,"Options:"
+ ,"-r --range "
+ ," Print versions that match the specified range."
+ ,""
+ ,"-i --increment []"
+ ," Increment a version by the specified level. Level can"
+ ," be one of: major, minor, patch, premajor, preminor,"
+ ," prepatch, or prerelease. Default level is 'patch'."
+ ," Only one version may be specified."
+ ,""
+ ,"--preid "
+ ," Identifier to be used to prefix premajor, preminor,"
+ ," prepatch or prerelease version increments."
+ ,""
+ ,"-l --loose"
+ ," Interpret versions and ranges loosely"
+ ,""
+ ,"Program exits successfully if any valid version satisfies"
+ ,"all supplied ranges, and prints all satisfying versions."
+ ,""
+ ,"If no satisfying versions are found, then exits failure."
+ ,""
+ ,"Versions are printed in ascending order, so supplying"
+ ,"multiple versions to the utility will just sort them."
+ ].join("\n"))
+}
diff --git a/node_modules/npm-lifecycle/node_modules/semver/package.json b/node_modules/npm-lifecycle/node_modules/semver/package.json
new file mode 100644
index 0000000000000..073de5dd164f2
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/semver/package.json
@@ -0,0 +1,54 @@
+{
+ "_from": "semver@~5.3.0",
+ "_id": "semver@5.3.0",
+ "_inBundle": false,
+ "_integrity": "sha1-myzl094C0XxgEq0yaqa00M9U+U8=",
+ "_location": "/npm-lifecycle/semver",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "semver@~5.3.0",
+ "name": "semver",
+ "escapedName": "semver",
+ "rawSpec": "~5.3.0",
+ "saveSpec": null,
+ "fetchSpec": "~5.3.0"
+ },
+ "_requiredBy": [
+ "/npm-lifecycle/node-gyp"
+ ],
+ "_resolved": "https://registry.npmjs.org/semver/-/semver-5.3.0.tgz",
+ "_shasum": "9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f",
+ "_spec": "semver@~5.3.0",
+ "_where": "/Users/isaacs/dev/npm/cli/node_modules/npm-lifecycle/node_modules/node-gyp",
+ "bin": {
+ "semver": "./bin/semver"
+ },
+ "bugs": {
+ "url": "https://github.com/npm/node-semver/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "The semantic version parser used by npm.",
+ "devDependencies": {
+ "tap": "^2.0.0"
+ },
+ "files": [
+ "bin",
+ "range.bnf",
+ "semver.js"
+ ],
+ "homepage": "https://github.com/npm/node-semver#readme",
+ "license": "ISC",
+ "main": "semver.js",
+ "name": "semver",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/npm/node-semver.git"
+ },
+ "scripts": {
+ "test": "tap test/*.js"
+ },
+ "version": "5.3.0"
+}
diff --git a/node_modules/npm-lifecycle/node_modules/semver/range.bnf b/node_modules/npm-lifecycle/node_modules/semver/range.bnf
new file mode 100644
index 0000000000000..25ebd5c832548
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/semver/range.bnf
@@ -0,0 +1,16 @@
+range-set ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen ::= partial ' - ' partial
+simple ::= primitive | partial | tilde | caret
+primitive ::= ( '<' | '>' | '>=' | '<=' | '=' | ) partial
+partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr ::= 'x' | 'X' | '*' | nr
+nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde ::= '~' partial
+caret ::= '^' partial
+qualifier ::= ( '-' pre )? ( '+' build )?
+pre ::= parts
+build ::= parts
+parts ::= part ( '.' part ) *
+part ::= nr | [-0-9A-Za-z]+
diff --git a/node_modules/npm-lifecycle/node_modules/semver/semver.js b/node_modules/npm-lifecycle/node_modules/semver/semver.js
new file mode 100644
index 0000000000000..5f1a3c5c9e5dc
--- /dev/null
+++ b/node_modules/npm-lifecycle/node_modules/semver/semver.js
@@ -0,0 +1,1203 @@
+exports = module.exports = SemVer;
+
+// The debug function is excluded entirely from the minified version.
+/* nomin */ var debug;
+/* nomin */ if (typeof process === 'object' &&
+ /* nomin */ process.env &&
+ /* nomin */ process.env.NODE_DEBUG &&
+ /* nomin */ /\bsemver\b/i.test(process.env.NODE_DEBUG))
+ /* nomin */ debug = function() {
+ /* nomin */ var args = Array.prototype.slice.call(arguments, 0);
+ /* nomin */ args.unshift('SEMVER');
+ /* nomin */ console.log.apply(console, args);
+ /* nomin */ };
+/* nomin */ else
+ /* nomin */ debug = function() {};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0';
+
+var MAX_LENGTH = 256;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
+// The actual regexps go on exports.re
+var re = exports.re = [];
+var src = exports.src = [];
+var R = 0;
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++;
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+var NUMERICIDENTIFIERLOOSE = R++;
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++;
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')';
+
+var MAINVERSIONLOOSE = R++;
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')';
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+var PRERELEASEIDENTIFIERLOOSE = R++;
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++;
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))';
+
+var PRERELEASELOOSE = R++;
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++;
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+ '(?:\\.' + src[BUILDIDENTIFIER] + ')*))';
+
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++;
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+ src[PRERELEASE] + '?' +
+ src[BUILD] + '?';
+
+src[FULL] = '^' + FULLPLAIN + '$';
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+ src[PRERELEASELOOSE] + '?' +
+ src[BUILD] + '?';
+
+var LOOSE = R++;
+src[LOOSE] = '^' + LOOSEPLAIN + '$';
+
+var GTLT = R++;
+src[GTLT] = '((?:<|>)?=?)';
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++;
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+var XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*';
+
+var XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:' + src[PRERELEASE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGEPLAINLOOSE = R++;
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:' + src[PRERELEASELOOSE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGE = R++;
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$';
+var XRANGELOOSE = R++;
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$';
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++;
+src[LONETILDE] = '(?:~>?)';
+
+var TILDETRIM = R++;
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+';
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');
+var tildeTrimReplace = '$1~';
+
+var TILDE = R++;
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';
+var TILDELOOSE = R++;
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++;
+src[LONECARET] = '(?:\\^)';
+
+var CARETTRIM = R++;
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+';
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');
+var caretTrimReplace = '$1^';
+
+var CARET = R++;
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';
+var CARETLOOSE = R++;
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++;
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$';
+var COMPARATOR = R++;
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$';
+
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++;
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+ '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');
+var comparatorTrimReplace = '$1$2$3';
+
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++;
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAIN] + ')' +
+ '\\s*$';
+
+var HYPHENRANGELOOSE = R++;
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s*$';
+
+// Star ranges basically just allow anything at all.
+var STAR = R++;
+src[STAR] = '(<|>)?=?\\s*\\*';
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+ debug(i, src[i]);
+ if (!re[i])
+ re[i] = new RegExp(src[i]);
+}
+
+exports.parse = parse;
+function parse(version, loose) {
+ if (version instanceof SemVer)
+ return version;
+
+ if (typeof version !== 'string')
+ return null;
+
+ if (version.length > MAX_LENGTH)
+ return null;
+
+ var r = loose ? re[LOOSE] : re[FULL];
+ if (!r.test(version))
+ return null;
+
+ try {
+ return new SemVer(version, loose);
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.valid = valid;
+function valid(version, loose) {
+ var v = parse(version, loose);
+ return v ? v.version : null;
+}
+
+
+exports.clean = clean;
+function clean(version, loose) {
+ var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
+ return s ? s.version : null;
+}
+
+exports.SemVer = SemVer;
+
+function SemVer(version, loose) {
+ if (version instanceof SemVer) {
+ if (version.loose === loose)
+ return version;
+ else
+ version = version.version;
+ } else if (typeof version !== 'string') {
+ throw new TypeError('Invalid Version: ' + version);
+ }
+
+ if (version.length > MAX_LENGTH)
+ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+
+ if (!(this instanceof SemVer))
+ return new SemVer(version, loose);
+
+ debug('SemVer', version, loose);
+ this.loose = loose;
+ var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);
+
+ if (!m)
+ throw new TypeError('Invalid Version: ' + version);
+
+ this.raw = version;
+
+ // these are actually numbers
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0)
+ throw new TypeError('Invalid major version')
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)
+ throw new TypeError('Invalid minor version')
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)
+ throw new TypeError('Invalid patch version')
+
+ // numberify any prerelease numeric ids
+ if (!m[4])
+ this.prerelease = [];
+ else
+ this.prerelease = m[4].split('.').map(function(id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER)
+ return num;
+ }
+ return id;
+ });
+
+ this.build = m[5] ? m[5].split('.') : [];
+ this.format();
+}
+
+SemVer.prototype.format = function() {
+ this.version = this.major + '.' + this.minor + '.' + this.patch;
+ if (this.prerelease.length)
+ this.version += '-' + this.prerelease.join('.');
+ return this.version;
+};
+
+SemVer.prototype.toString = function() {
+ return this.version;
+};
+
+SemVer.prototype.compare = function(other) {
+ debug('SemVer.compare', this.version, this.loose, other);
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return this.compareMain(other) || this.comparePre(other);
+};
+
+SemVer.prototype.compareMain = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch);
+};
+
+SemVer.prototype.comparePre = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length)
+ return -1;
+ else if (!this.prerelease.length && other.prerelease.length)
+ return 1;
+ else if (!this.prerelease.length && !other.prerelease.length)
+ return 0;
+
+ var i = 0;
+ do {
+ var a = this.prerelease[i];
+ var b = other.prerelease[i];
+ debug('prerelease compare', i, a, b);
+ if (a === undefined && b === undefined)
+ return 0;
+ else if (b === undefined)
+ return 1;
+ else if (a === undefined)
+ return -1;
+ else if (a === b)
+ continue;
+ else
+ return compareIdentifiers(a, b);
+ } while (++i);
+};
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function(release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc('pre', identifier);
+ break;
+ case 'preminor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc('pre', identifier);
+ break;
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0;
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0)
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0)
+ this.major++;
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0)
+ this.minor++;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0)
+ this.patch++;
+ this.prerelease = [];
+ break;
+ // This probably shouldn't be used publicly.
+ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0)
+ this.prerelease = [0];
+ else {
+ var i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) // didn't increment anything
+ this.prerelease.push(0);
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1]))
+ this.prerelease = [identifier, 0];
+ } else
+ this.prerelease = [identifier, 0];
+ }
+ break;
+
+ default:
+ throw new Error('invalid increment argument: ' + release);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+};
+
+exports.inc = inc;
+function inc(version, release, loose, identifier) {
+ if (typeof(loose) === 'string') {
+ identifier = loose;
+ loose = undefined;
+ }
+
+ try {
+ return new SemVer(version, loose).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.diff = diff;
+function diff(version1, version2) {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ var v1 = parse(version1);
+ var v2 = parse(version2);
+ if (v1.prerelease.length || v2.prerelease.length) {
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return 'pre'+key;
+ }
+ }
+ }
+ return 'prerelease';
+ }
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return key;
+ }
+ }
+ }
+ }
+}
+
+exports.compareIdentifiers = compareIdentifiers;
+
+var numeric = /^[0-9]+$/;
+function compareIdentifiers(a, b) {
+ var anum = numeric.test(a);
+ var bnum = numeric.test(b);
+
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+
+ return (anum && !bnum) ? -1 :
+ (bnum && !anum) ? 1 :
+ a < b ? -1 :
+ a > b ? 1 :
+ 0;
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers;
+function rcompareIdentifiers(a, b) {
+ return compareIdentifiers(b, a);
+}
+
+exports.major = major;
+function major(a, loose) {
+ return new SemVer(a, loose).major;
+}
+
+exports.minor = minor;
+function minor(a, loose) {
+ return new SemVer(a, loose).minor;
+}
+
+exports.patch = patch;
+function patch(a, loose) {
+ return new SemVer(a, loose).patch;
+}
+
+exports.compare = compare;
+function compare(a, b, loose) {
+ return new SemVer(a, loose).compare(b);
+}
+
+exports.compareLoose = compareLoose;
+function compareLoose(a, b) {
+ return compare(a, b, true);
+}
+
+exports.rcompare = rcompare;
+function rcompare(a, b, loose) {
+ return compare(b, a, loose);
+}
+
+exports.sort = sort;
+function sort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.compare(a, b, loose);
+ });
+}
+
+exports.rsort = rsort;
+function rsort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.rcompare(a, b, loose);
+ });
+}
+
+exports.gt = gt;
+function gt(a, b, loose) {
+ return compare(a, b, loose) > 0;
+}
+
+exports.lt = lt;
+function lt(a, b, loose) {
+ return compare(a, b, loose) < 0;
+}
+
+exports.eq = eq;
+function eq(a, b, loose) {
+ return compare(a, b, loose) === 0;
+}
+
+exports.neq = neq;
+function neq(a, b, loose) {
+ return compare(a, b, loose) !== 0;
+}
+
+exports.gte = gte;
+function gte(a, b, loose) {
+ return compare(a, b, loose) >= 0;
+}
+
+exports.lte = lte;
+function lte(a, b, loose) {
+ return compare(a, b, loose) <= 0;
+}
+
+exports.cmp = cmp;
+function cmp(a, op, b, loose) {
+ var ret;
+ switch (op) {
+ case '===':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a === b;
+ break;
+ case '!==':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a !== b;
+ break;
+ case '': case '=': case '==': ret = eq(a, b, loose); break;
+ case '!=': ret = neq(a, b, loose); break;
+ case '>': ret = gt(a, b, loose); break;
+ case '>=': ret = gte(a, b, loose); break;
+ case '<': ret = lt(a, b, loose); break;
+ case '<=': ret = lte(a, b, loose); break;
+ default: throw new TypeError('Invalid operator: ' + op);
+ }
+ return ret;
+}
+
+exports.Comparator = Comparator;
+function Comparator(comp, loose) {
+ if (comp instanceof Comparator) {
+ if (comp.loose === loose)
+ return comp;
+ else
+ comp = comp.value;
+ }
+
+ if (!(this instanceof Comparator))
+ return new Comparator(comp, loose);
+
+ debug('comparator', comp, loose);
+ this.loose = loose;
+ this.parse(comp);
+
+ if (this.semver === ANY)
+ this.value = '';
+ else
+ this.value = this.operator + this.semver.version;
+
+ debug('comp', this);
+}
+
+var ANY = {};
+Comparator.prototype.parse = function(comp) {
+ var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var m = comp.match(r);
+
+ if (!m)
+ throw new TypeError('Invalid comparator: ' + comp);
+
+ this.operator = m[1];
+ if (this.operator === '=')
+ this.operator = '';
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2])
+ this.semver = ANY;
+ else
+ this.semver = new SemVer(m[2], this.loose);
+};
+
+Comparator.prototype.toString = function() {
+ return this.value;
+};
+
+Comparator.prototype.test = function(version) {
+ debug('Comparator.test', version, this.loose);
+
+ if (this.semver === ANY)
+ return true;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ return cmp(version, this.operator, this.semver, this.loose);
+};
+
+
+exports.Range = Range;
+function Range(range, loose) {
+ if ((range instanceof Range) && range.loose === loose)
+ return range;
+
+ if (!(this instanceof Range))
+ return new Range(range, loose);
+
+ this.loose = loose;
+
+ // First, split based on boolean or ||
+ this.raw = range;
+ this.set = range.split(/\s*\|\|\s*/).map(function(range) {
+ return this.parseRange(range.trim());
+ }, this).filter(function(c) {
+ // throw out any that are not relevant for whatever reason
+ return c.length;
+ });
+
+ if (!this.set.length) {
+ throw new TypeError('Invalid SemVer Range: ' + range);
+ }
+
+ this.format();
+}
+
+Range.prototype.format = function() {
+ this.range = this.set.map(function(comps) {
+ return comps.join(' ').trim();
+ }).join('||').trim();
+ return this.range;
+};
+
+Range.prototype.toString = function() {
+ return this.range;
+};
+
+Range.prototype.parseRange = function(range) {
+ var loose = this.loose;
+ range = range.trim();
+ debug('range', range, loose);
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace);
+ debug('hyphen replace', range);
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);
+ debug('comparator trim', range, re[COMPARATORTRIM]);
+
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re[TILDETRIM], tildeTrimReplace);
+
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re[CARETTRIM], caretTrimReplace);
+
+ // normalize spaces
+ range = range.split(/\s+/).join(' ');
+
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
+
+ var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var set = range.split(' ').map(function(comp) {
+ return parseComparator(comp, loose);
+ }).join(' ').split(/\s+/);
+ if (this.loose) {
+ // in loose mode, throw out any that are not valid comparators
+ set = set.filter(function(comp) {
+ return !!comp.match(compRe);
+ });
+ }
+ set = set.map(function(comp) {
+ return new Comparator(comp, loose);
+ });
+
+ return set;
+};
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators;
+function toComparators(range, loose) {
+ return new Range(range, loose).set.map(function(comp) {
+ return comp.map(function(c) {
+ return c.value;
+ }).join(' ').trim().split(' ');
+ });
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator(comp, loose) {
+ debug('comp', comp);
+ comp = replaceCarets(comp, loose);
+ debug('caret', comp);
+ comp = replaceTildes(comp, loose);
+ debug('tildes', comp);
+ comp = replaceXRanges(comp, loose);
+ debug('xrange', comp);
+ comp = replaceStars(comp, loose);
+ debug('stars', comp);
+ return comp;
+}
+
+function isX(id) {
+ return !id || id.toLowerCase() === 'x' || id === '*';
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceTilde(comp, loose);
+ }).join(' ');
+}
+
+function replaceTilde(comp, loose) {
+ var r = loose ? re[TILDELOOSE] : re[TILDE];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('tilde', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p))
+ // ~1.2 == >=1.2.0 <1.3.0
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else if (pr) {
+ debug('replaceTilde pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ // ~1.2.3 == >=1.2.3 <1.3.0
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+
+ debug('tilde return', ret);
+ return ret;
+ });
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceCaret(comp, loose);
+ }).join(' ');
+}
+
+function replaceCaret(comp, loose) {
+ debug('caret', comp, loose);
+ var r = loose ? re[CARETLOOSE] : re[CARET];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('caret', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p)) {
+ if (M === '0')
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else
+ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
+ } else if (pr) {
+ debug('replaceCaret pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + (+M + 1) + '.0.0';
+ } else {
+ debug('no pr');
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + (+M + 1) + '.0.0';
+ }
+
+ debug('caret return', ret);
+ return ret;
+ });
+}
+
+function replaceXRanges(comp, loose) {
+ debug('replaceXRanges', comp, loose);
+ return comp.split(/\s+/).map(function(comp) {
+ return replaceXRange(comp, loose);
+ }).join(' ');
+}
+
+function replaceXRange(comp, loose) {
+ comp = comp.trim();
+ var r = loose ? re[XRANGELOOSE] : re[XRANGE];
+ return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+ debug('xRange', comp, ret, gtlt, M, m, p, pr);
+ var xM = isX(M);
+ var xm = xM || isX(m);
+ var xp = xm || isX(p);
+ var anyX = xp;
+
+ if (gtlt === '=' && anyX)
+ gtlt = '';
+
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0';
+ } else {
+ // nothing is forbidden
+ ret = '*';
+ }
+ } else if (gtlt && anyX) {
+ // replace X with 0
+ if (xm)
+ m = 0;
+ if (xp)
+ p = 0;
+
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ // >1.2.3 => >= 1.2.4
+ gtlt = '>=';
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else if (xp) {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<';
+ if (xm)
+ M = +M + 1;
+ else
+ m = +m + 1;
+ }
+
+ ret = gtlt + M + '.' + m + '.' + p;
+ } else if (xm) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ } else if (xp) {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ }
+
+ debug('xRange return', ret);
+
+ return ret;
+ });
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp, loose) {
+ debug('replaceStars', comp, loose);
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re[STAR], '');
+}
+
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) {
+
+ if (isX(fM))
+ from = '';
+ else if (isX(fm))
+ from = '>=' + fM + '.0.0';
+ else if (isX(fp))
+ from = '>=' + fM + '.' + fm + '.0';
+ else
+ from = '>=' + from;
+
+ if (isX(tM))
+ to = '';
+ else if (isX(tm))
+ to = '<' + (+tM + 1) + '.0.0';
+ else if (isX(tp))
+ to = '<' + tM + '.' + (+tm + 1) + '.0';
+ else if (tpr)
+ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;
+ else
+ to = '<=' + to;
+
+ return (from + ' ' + to).trim();
+}
+
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function(version) {
+ if (!version)
+ return false;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ for (var i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version))
+ return true;
+ }
+ return false;
+};
+
+function testSet(set, version) {
+ for (var i = 0; i < set.length; i++) {
+ if (!set[i].test(version))
+ return false;
+ }
+
+ if (version.prerelease.length) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (var i = 0; i < set.length; i++) {
+ debug(set[i].semver);
+ if (set[i].semver === ANY)
+ continue;
+
+ if (set[i].semver.prerelease.length > 0) {
+ var allowed = set[i].semver;
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch)
+ return true;
+ }
+ }
+
+ // Version has a -pre, but it's not one of the ones we like.
+ return false;
+ }
+
+ return true;
+}
+
+exports.satisfies = satisfies;
+function satisfies(version, range, loose) {
+ try {
+ range = new Range(range, loose);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version);
+}
+
+exports.maxSatisfying = maxSatisfying;
+function maxSatisfying(versions, range, loose) {
+ return versions.filter(function(version) {
+ return satisfies(version, range, loose);
+ }).sort(function(a, b) {
+ return rcompare(a, b, loose);
+ })[0] || null;
+}
+
+exports.minSatisfying = minSatisfying;
+function minSatisfying(versions, range, loose) {
+ return versions.filter(function(version) {
+ return satisfies(version, range, loose);
+ }).sort(function(a, b) {
+ return compare(a, b, loose);
+ })[0] || null;
+}
+
+exports.validRange = validRange;
+function validRange(range, loose) {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range(range, loose).range || '*';
+ } catch (er) {
+ return null;
+ }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr;
+function ltr(version, range, loose) {
+ return outside(version, range, '<', loose);
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr;
+function gtr(version, range, loose) {
+ return outside(version, range, '>', loose);
+}
+
+exports.outside = outside;
+function outside(version, range, hilo, loose) {
+ version = new SemVer(version, loose);
+ range = new Range(range, loose);
+
+ var gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case '>':
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = '>';
+ ecomp = '>=';
+ break;
+ case '<':
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = '<';
+ ecomp = '<=';
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+
+ // If it satisifes the range it is not outside
+ if (satisfies(version, range, loose)) {
+ return false;
+ }
+
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
+
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i];
+
+ var high = null;
+ var low = null;
+
+ comparators.forEach(function(comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator('>=0.0.0')
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, loose)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, loose)) {
+ low = comparator;
+ }
+ });
+
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+exports.prerelease = prerelease;
+function prerelease(version, loose) {
+ var parsed = parse(version, loose);
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null;
+}
diff --git a/node_modules/npm-lifecycle/package.json b/node_modules/npm-lifecycle/package.json
index 6f63b06fd51c4..527432939be12 100644
--- a/node_modules/npm-lifecycle/package.json
+++ b/node_modules/npm-lifecycle/package.json
@@ -1,29 +1,41 @@
{
- "_from": "npm-lifecycle@2.1.0",
- "_id": "npm-lifecycle@2.1.0",
+ "_from": "npm-lifecycle@2.1.1",
+ "_id": "npm-lifecycle@2.1.1",
"_inBundle": false,
- "_integrity": "sha512-QbBfLlGBKsktwBZLj6AviHC6Q9Y3R/AY4a2PYSIRhSKSS0/CxRyD/PfxEX6tPeOCXQgMSNdwGeECacstgptc+g==",
+ "_integrity": "sha512-+Vg6I60Z75V/09pdcH5iUo/99Q/vop35PaI99elvxk56azSVVsdsSsS/sXqKDNwbRRNN1qSxkcO45ZOu0yOWew==",
"_location": "/npm-lifecycle",
- "_phantomChildren": {},
+ "_phantomChildren": {
+ "abbrev": "1.1.1",
+ "glob": "7.1.4",
+ "graceful-fs": "4.2.0",
+ "mkdirp": "0.5.1",
+ "npmlog": "4.1.2",
+ "osenv": "0.1.5",
+ "request": "2.88.0",
+ "rimraf": "2.6.3",
+ "tar": "4.4.10",
+ "which": "1.3.1"
+ },
"_requested": {
"type": "version",
"registry": true,
- "raw": "npm-lifecycle@2.1.0",
+ "raw": "npm-lifecycle@2.1.1",
"name": "npm-lifecycle",
"escapedName": "npm-lifecycle",
- "rawSpec": "2.1.0",
+ "rawSpec": "2.1.1",
"saveSpec": null,
- "fetchSpec": "2.1.0"
+ "fetchSpec": "2.1.1"
},
"_requiredBy": [
"#USER",
"/",
- "/libcipm"
+ "/libcipm",
+ "/libnpm"
],
- "_resolved": "https://registry.npmjs.org/npm-lifecycle/-/npm-lifecycle-2.1.0.tgz",
- "_shasum": "1eda2eedb82db929e3a0c50341ab0aad140ed569",
- "_spec": "npm-lifecycle@2.1.0",
- "_where": "/Users/zkat/Documents/code/work/npm",
+ "_resolved": "https://registry.npmjs.org/npm-lifecycle/-/npm-lifecycle-2.1.1.tgz",
+ "_shasum": "0027c09646f0fd346c5c93377bdaba59c6748fdf",
+ "_spec": "npm-lifecycle@2.1.1",
+ "_where": "/Users/isaacs/dev/npm/cli",
"author": {
"name": "Mike Sherov"
},
@@ -33,8 +45,8 @@
"bundleDependencies": false,
"dependencies": {
"byline": "^5.0.0",
- "graceful-fs": "^4.1.11",
- "node-gyp": "^3.8.0",
+ "graceful-fs": "^4.1.15",
+ "node-gyp": "^4.0.0",
"resolve-from": "^4.0.0",
"slide": "^1.1.6",
"uid-number": "0.0.6",
@@ -44,11 +56,11 @@
"deprecated": false,
"description": "JavaScript package lifecycle hook runner",
"devDependencies": {
- "nyc": "^12.0.2",
- "sinon": "^6.1.5",
- "standard": "^11.0.1",
+ "nyc": "^14.1.0",
+ "sinon": "^7.2.3",
+ "standard": "^12.0.1",
"standard-version": "^4.4.0",
- "tap": "^12.0.1",
+ "tap": "^13.1.3",
"weallbehave": "^1.2.0",
"weallcontribute": "^1.0.8"
},
@@ -76,9 +88,9 @@
"prerelease": "npm t",
"pretest": "standard",
"release": "standard-version -s",
- "test": "tap -J --coverage test/*.js",
+ "test": "tap",
"update-coc": "weallbehave -o . && git add CODE_OF_CONDUCT.md && git commit -m 'docs(coc): updated CODE_OF_CONDUCT.md'",
"update-contrib": "weallcontribute -o . && git add CONTRIBUTING.md && git commit -m 'docs(contributing): updated CONTRIBUTING.md'"
},
- "version": "2.1.0"
+ "version": "2.1.1"
}
diff --git a/package-lock.json b/package-lock.json
index a0c797b9a4160..5bc7131cadc54 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -3825,18 +3825,51 @@
"dev": true
},
"npm-lifecycle": {
- "version": "2.1.0",
- "resolved": "https://registry.npmjs.org/npm-lifecycle/-/npm-lifecycle-2.1.0.tgz",
- "integrity": "sha512-QbBfLlGBKsktwBZLj6AviHC6Q9Y3R/AY4a2PYSIRhSKSS0/CxRyD/PfxEX6tPeOCXQgMSNdwGeECacstgptc+g==",
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/npm-lifecycle/-/npm-lifecycle-2.1.1.tgz",
+ "integrity": "sha512-+Vg6I60Z75V/09pdcH5iUo/99Q/vop35PaI99elvxk56azSVVsdsSsS/sXqKDNwbRRNN1qSxkcO45ZOu0yOWew==",
"requires": {
"byline": "^5.0.0",
- "graceful-fs": "^4.1.11",
- "node-gyp": "^3.8.0",
+ "graceful-fs": "^4.1.15",
+ "node-gyp": "^4.0.0",
"resolve-from": "^4.0.0",
"slide": "^1.1.6",
"uid-number": "0.0.6",
"umask": "^1.1.0",
"which": "^1.3.1"
+ },
+ "dependencies": {
+ "node-gyp": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-4.0.0.tgz",
+ "integrity": "sha512-2XiryJ8sICNo6ej8d0idXDEMKfVfFK7kekGCtJAuelGsYHQxhj13KTf95swTCN2dZ/4lTfZ84Fu31jqJEEgjWA==",
+ "requires": {
+ "glob": "^7.0.3",
+ "graceful-fs": "^4.1.2",
+ "mkdirp": "^0.5.0",
+ "nopt": "2 || 3",
+ "npmlog": "0 || 1 || 2 || 3 || 4",
+ "osenv": "0",
+ "request": "^2.87.0",
+ "rimraf": "2",
+ "semver": "~5.3.0",
+ "tar": "^4.4.8",
+ "which": "1"
+ }
+ },
+ "nopt": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz",
+ "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=",
+ "requires": {
+ "abbrev": "1"
+ }
+ },
+ "semver": {
+ "version": "5.3.0",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.3.0.tgz",
+ "integrity": "sha1-myzl094C0XxgEq0yaqa00M9U+U8="
+ }
}
},
"npm-logical-tree": {
diff --git a/package.json b/package.json
index 1bfa1be08db6a..7dfcff123bf29 100644
--- a/package.json
+++ b/package.json
@@ -95,7 +95,7 @@
"npm-audit-report": "^1.3.2",
"npm-cache-filename": "~1.0.2",
"npm-install-checks": "~3.0.0",
- "npm-lifecycle": "^2.1.0",
+ "npm-lifecycle": "^2.1.1",
"npm-package-arg": "^6.1.0",
"npm-packlist": "^1.4.4",
"npm-pick-manifest": "^2.2.3",