diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/AclUI.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/AclUI.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..4e035a0cd002c3eb5a866dbc886236891c96dadd
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/AclUI.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/ActiveDS.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/ActiveDS.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..078b5d0e5d5b6da9a04fb5ec30b44a64bd04423e
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/ActiveDS.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/AuthZ.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/AuthZ.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..347531131352804fb1d59077d2bd77bc5708bbc6
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/AuthZ.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/BluetoothApis.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/BluetoothApis.lib
new file mode 100644
index 0000000000000000000000000000000000000000..8a25ad84540b70cb1ec7309d09cc0f5e847397d1
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/BluetoothApis.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/Cabinet.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/Cabinet.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..c9e70bfab62cf478cae66239286bc44ebe7ee4c7
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/Cabinet.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/advpack.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/advpack.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..8a1095dd644c3de88ec3b64435cb5766a7762041
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/advpack.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/ahadmin.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/ahadmin.lib
new file mode 100644
index 0000000000000000000000000000000000000000..203a74a5eddc0ef82ffca0f3ff7fe076fc5e2262
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/ahadmin.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/amsi.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/amsi.lib
new file mode 100644
index 0000000000000000000000000000000000000000..2af6fd4e27cd8f68bc7261e8566cdef55d094fe3
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/amsi.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appmgmts.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appmgmts.lib
new file mode 100644
index 0000000000000000000000000000000000000000..0e44e541717c1aafe6e5d42acf8467c2235f6287
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appmgmts.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appmgr.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appmgr.lib
new file mode 100644
index 0000000000000000000000000000000000000000..423b9ac13ceea9c81d494bf903946bb9cf4c1d25
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appmgr.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appnotify.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appnotify.lib
new file mode 100644
index 0000000000000000000000000000000000000000..0a95f83f6e7898880abdddaeb68265e3105f2b34
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/appnotify.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/audioeng.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/audioeng.lib
new file mode 100644
index 0000000000000000000000000000000000000000..86b8d23003c1147cf4209ef444cab95e38bbc64d
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/audioeng.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/avifil32.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/avifil32.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..b2bdcfb256081421f1e8e871e6498a8786f30dce
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/avifil32.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/avrt.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/avrt.lib
new file mode 100644
index 0000000000000000000000000000000000000000..7bc76f6d301532d5bdb74f5b366a8a0e7b981933
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/avrt.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/basesrv.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/basesrv.lib
new file mode 100644
index 0000000000000000000000000000000000000000..8a8b11dd40cd47738f05daba437e878d11cffeba
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/basesrv.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bcp47mrm.Lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bcp47mrm.Lib
new file mode 100644
index 0000000000000000000000000000000000000000..b6af3dbc9c9a8558cd7e64ee3e20087f3b56f808
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bcp47mrm.Lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bcrypt.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bcrypt.lib
new file mode 100644
index 0000000000000000000000000000000000000000..0fce72eaaff6f189b04fd07fa315f9aa0cc58ec2
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bcrypt.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bindlink.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bindlink.lib
new file mode 100644
index 0000000000000000000000000000000000000000..247c488f784b35ff7c1e5bb5ffaff5fb49004117
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bindlink.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bthprops.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bthprops.lib
new file mode 100644
index 0000000000000000000000000000000000000000..9f6568ab9572dc43f01505032f3f0187306332f8
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/bthprops.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/certadm.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/certadm.lib
new file mode 100644
index 0000000000000000000000000000000000000000..bdc8add33b6659f797d67a9dca565a697c946af6
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/certadm.lib differ
diff --git a/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/certca.lib b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/certca.lib
new file mode 100644
index 0000000000000000000000000000000000000000..2feada019f9794bb73e730441282125fee731929
Binary files /dev/null and b/msvc/Windows Kits/10/Lib/10.0.26100.0/um/x64/certca.lib differ
diff --git a/msvc/Windows Kits/10/Redist/MBN/arm64/microsoft.mbn.dll b/msvc/Windows Kits/10/Redist/MBN/arm64/microsoft.mbn.dll
new file mode 100644
index 0000000000000000000000000000000000000000..85a6e6afc257434a7e9e36a1f3bed06325733943
Binary files /dev/null and b/msvc/Windows Kits/10/Redist/MBN/arm64/microsoft.mbn.dll differ
diff --git a/msvc/Windows Kits/10/Redist/MBN/x64/microsoft.mbn.dll b/msvc/Windows Kits/10/Redist/MBN/x64/microsoft.mbn.dll
new file mode 100644
index 0000000000000000000000000000000000000000..b96b4726f9529bd7e83e97a735d10f8e95a2e14a
Binary files /dev/null and b/msvc/Windows Kits/10/Redist/MBN/x64/microsoft.mbn.dll differ
diff --git a/msvc/Windows Kits/10/Redist/MBN/x86/microsoft.mbn.dll b/msvc/Windows Kits/10/Redist/MBN/x86/microsoft.mbn.dll
new file mode 100644
index 0000000000000000000000000000000000000000..29ca9dcbfe6c1e8d548f492edd6dd7bc6331f580
Binary files /dev/null and b/msvc/Windows Kits/10/Redist/MBN/x86/microsoft.mbn.dll differ
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgets.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgets.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e25ff3e4dba17054d610ae58756812aef3cf442
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgets.cpp	
@@ -0,0 +1,128 @@
+//
+// cgets.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cgets() and _cgets_s(), which read a string from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_securecrt.h>
+#include <stdlib.h>
+
+
+
+extern "C" extern intptr_t __dcrt_lowio_console_input_handle;
+
+
+
+// Use of the following buffer variables is primarily for syncronizing with
+// _cgets_s. _cget_s fills the MBCS buffer and if the user passes in single
+// character buffer and the unicode character is not converted to single byte
+// MBC, then _cget_s should buffer that character so that next call to
+// _cgetws_s can return the same character.
+extern "C" extern wchar_t __console_wchar_buffer;
+extern "C" extern int     __console_wchar_buffer_used;
+
+
+
+// Reads a string from the console; always null-terminates the buffer.  Returns
+// 0 on success; returns an errno error code on failure.
+extern "C" errno_t __cdecl _cgets_s(char* const source_string, size_t const size_in_bytes, size_t* const size_read)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(source_string != nullptr, EINVAL);
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_in_bytes > 0,        EINVAL);
+    _RESET_STRING(source_string, size_in_bytes);
+
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_read != nullptr, EINVAL);
+
+    errno_t error  = 0;
+    char*   string = source_string;
+
+    __acrt_lock(__acrt_conio_lock);
+    __try
+    {
+        // The implementation of cgets is slightly tricky. The reason being,
+        // the code page for console is different from the CRT code page.
+        // What this means is the program may interpret character
+        // differently from it's acctual value. To fix this, what we really
+        // want to do is read the input as unicode string and then convert
+        // it to proper MBCS representation.
+        //
+        // This fix this we are really converting from Unicode to MBCS.
+        // This adds performance problem as we may endup doing this
+        // character by character. The basic problem here is that we have
+        // no way to know how many UNICODE characters will be needed to fit
+        // them in given size of MBCS buffer. To fix this issue we will be
+        // converting one Unicode character at a time to MBCS. This makes
+        // this slow, but then this is already console input,
+        *size_read = 0;
+
+        size_t available = size_in_bytes - 1;
+        do
+        {
+            wchar_t wchar_buff[2];
+            size_t sizeRead = 0;
+
+            error = _cgetws_s(wchar_buff, _countof(wchar_buff), &sizeRead);
+            if (error != 0)
+                break;
+
+            if (wchar_buff[0] == '\0')
+                break;
+
+            int size_converted = 0;
+            errno_t const wctomb_result = wctomb_s(&size_converted, string, available, wchar_buff[0]);
+            if (wctomb_result != 0)
+            {
+                // Put the wide character back in the buffer so that the
+                // unutilized wide character is still in the stream:
+                __console_wchar_buffer = wchar_buff[0];
+                __console_wchar_buffer_used = 1;
+                break;
+            }
+
+            string     += size_converted;
+            *size_read += size_converted;
+            available  -= size_converted;
+        }
+        while (available > 0);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+
+    *string++ = '\0';
+
+    if (error != 0)
+        errno = error;
+
+    return error;
+}
+
+
+
+// Reads a string from the console via ReadConsole on a cooked console handle.
+// string[0] must contain the maximum length of the string.  The number of
+// characters written is stored in string[1].  The return value is a pointer to
+// string[2] on success; nullptr on failure.
+extern "C" char* __cdecl _cgets(_Inout_z_ char* const string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(string != nullptr, EINVAL, nullptr);
+    _VALIDATE_CLEAR_OSSERR_RETURN(string[0] > 0,     EINVAL, nullptr);
+
+    size_t const size_in_bytes = static_cast<size_t>(string[0]);
+
+    size_t size_read = 0;
+    // warning 26018: Potential overflow of null terminated buffer using expression string+2
+    // Suppressing warning since _cgets is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    errno_t const result = _cgets_s(string + 2, size_in_bytes, &size_read);
+
+    // warning 26018: Potential overflow of null terminated buffer using expression string[1]
+    // Suppressing warning since _cgets is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    string[1] = static_cast<char>(size_read);
+
+    return result == 0 ? string + 2 : nullptr;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgetws.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgetws.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8e5205b678b5044b7d6f74325e7a8e51f4b188d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cgetws.cpp	
@@ -0,0 +1,156 @@
+//
+// cgetws.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cgetws() and _cgetws_s(), which read a wide string from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_securecrt.h>
+#include <stdlib.h>
+
+// Use of the following buffer variables is primarily for syncronizing with
+// _cgets_s. _cget_s fills the MBCS buffer and if the user passes in single
+// character buffer and the unicode character is not converted to single byte
+// MBC, then _cget_s should buffer that character so that next call to
+// _cgetws_s can return the same character.
+extern "C" wchar_t __console_wchar_buffer      = 0;
+extern "C" int     __console_wchar_buffer_used = 0;
+
+
+
+// Reads a string from the console; always null-terminates the buffer.  Returns
+// 0 on success; returns an errno error code on failure.
+extern "C" errno_t __cdecl _cgetws_s(wchar_t* const string_buffer, size_t const size_in_words, size_t* const size_read)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(string_buffer != nullptr, EINVAL);
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_in_words > 0, EINVAL);
+    _RESET_STRING(string_buffer, size_in_words);
+
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(size_read != nullptr, EINVAL);
+
+    __acrt_lock(__acrt_conio_lock);
+    errno_t retval = 0;
+    __try
+    {
+        wchar_t* string = string_buffer;
+
+        // We need to decrement size_in_words because ReadConsole reads as many
+        // characters as the parameter passed.  It doesn't null-terminate:
+        size_t size_remaining = size_in_words - 1;
+        *size_read = 0;
+
+        // If size_in_words was 1, then there's only room for the null terminator:
+        if (size_remaining == 0)
+            __leave;
+
+        // If there is a buffered character, first fill with the buffered
+        // character then proceed with reading from the console:
+        if (__console_wchar_buffer_used != 0)
+        {
+            *string++ = __console_wchar_buffer;
+            --size_remaining;
+            (*size_read)++;
+
+            if (__console_wchar_buffer == L'\0')
+                size_remaining = 0;
+
+            __console_wchar_buffer = 0;
+        }
+
+        if (size_remaining == 0)
+            __leave;
+
+        /*
+        * __dcrt_lowio_console_input_handle, the handle to the console input, is created the first
+        * time that either _getch() or _cgets() or _kbhit() is called.
+        */
+
+        if (__dcrt_lowio_ensure_console_input_initialized() == FALSE)
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            retval = errno;
+            __leave;
+        }
+
+        ULONG old_state;
+        __dcrt_get_input_console_mode(&old_state);
+        __dcrt_set_input_console_mode(ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT | ENABLE_ECHO_INPUT);
+
+        ULONG wchars_read;
+        BOOL read_console_result = __dcrt_read_console(
+            string,
+            static_cast<DWORD>(size_remaining),
+            &wchars_read);
+
+        if (!read_console_result)
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            retval = errno;
+            __leave;
+        }
+
+        // Set the length of the string and null terminate it:
+        if (wchars_read >= 2 && string[wchars_read - 2] == L'\r')
+        {
+            *size_read += wchars_read - 2;
+            string[wchars_read - 2] = L'\0';
+        }
+        else if (wchars_read == size_remaining && string[wchars_read - 1] == L'\r')
+        {
+            // Special case 1:  \r\n straddles the boundary:
+            string[wchars_read - 1] = L'\0';
+            *size_read += wchars_read - 1;
+        }
+        else if (wchars_read == 1 && string[0] == L'\n')
+        {
+            // Special case 2:  Read a single \n:
+            string[0] = L'\0';
+            *size_read += 0;
+        }
+        else
+        {
+            *size_read += wchars_read;
+            string[wchars_read] = L'\0';
+        }
+
+        __dcrt_set_input_console_mode(old_state);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+
+    return retval;
+}
+
+
+
+// Reads a string from the console via ReadConsole on a cooked console handle.
+// string[0] must contain the maximum length of the string.  The number of
+// characters written is stored in string[1].  The return value is a pointer to
+// string[2] on success; nullptr on failure.
+//
+// Note that _cgetws() does NOT check the pushback character buffer, so it will
+// not return any character that is pushed back by a call to _ungetwch().
+extern "C" wchar_t* __cdecl _cgetws(_Inout_z_ wchar_t* const string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(string != nullptr, EINVAL, nullptr);
+    _VALIDATE_CLEAR_OSSERR_RETURN(string[0] > 0,     EINVAL, nullptr);
+
+    size_t const size_in_words = static_cast<size_t>(string[0]);
+
+    size_t size_read = 0;
+    // warning 26018: Potential overflow of null terminated buffer using expression string+2
+    // Suppressing warning since _cgetws is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    errno_t const result = _cgetws_s(string + 2, size_in_words, &size_read);
+
+    // warning 26018: Potential overflow of null terminated buffer using expression string[1]
+    // Suppressing warning since _cgetws is purposefully unsafe.
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+    string[1] = static_cast<wchar_t>(size_read);
+
+    return result == 0 ? string + 2 : nullptr;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cprintf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cprintf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..98993fb707511766e3e51f6be2903564bffb1d86
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cprintf.cpp	
@@ -0,0 +1,104 @@
+//
+// cprintf.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The standard output functions, which perform formatted output to the
+// console.
+//
+#include <corecrt_internal_stdio_output.h>
+
+
+using namespace __crt_stdio_output;
+
+
+
+template <template <typename, typename> class Base, typename Character>
+static int __cdecl common_vcprintf(
+    unsigned __int64   const options,
+    Character const*   const format,
+    __crt_cached_ptd_host&   ptd,
+    va_list            const arglist
+    )
+{
+    typedef output_processor<
+        Character,
+        console_output_adapter<Character>,
+        Base<Character, console_output_adapter<Character>>
+    > processor_type;
+
+    processor_type processor(
+        console_output_adapter<Character>(),
+        options,
+        format,
+        ptd,
+        arglist);
+
+    return processor.process();
+}
+
+extern "C" int __cdecl __conio_common_vcprintf(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<standard_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcprintf_s(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<format_validation_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcprintf_p(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<positional_parameter_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwprintf(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<standard_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwprintf_s(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<format_validation_base>(options, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwprintf_p(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd{locale};
+    return common_vcprintf<positional_parameter_base>(options, format, ptd, arglist);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..485a01a984acf3deb63ef3d34df7d5fe108c0eaf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputs.cpp	
@@ -0,0 +1,38 @@
+//
+// cputs.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cputs(), which writes a string directly to the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+
+// Writes the given string directly to the console.  No newline is appended.
+// Returns 0 on success; nonzero on failure.
+extern "C" int __cdecl _cputs(char const* const string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(string != nullptr, EINVAL, -1);
+
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        // Write the string directly to the console.  Each character is written
+        // individually, as performance of this function is not considered
+        // critical.
+        for (char const* p = string; *p; ++p)
+        {
+            if (_putch_nolock(*p) == EOF)
+            {
+                result = -1;
+                __leave;
+            }
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputws.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputws.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df5e74d31cc839ff7bcab3078ee562492546a90b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cputws.cpp	
@@ -0,0 +1,63 @@
+//
+// cputws.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _cputws(), which writes a wide string directly to the console.
+//
+#include <conio.h>
+#include <errno.h>
+#include <corecrt_internal_lowio.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Writes the given string directly to the console.  No newline is appended.
+//
+// Returns 0 on success; nonzero on failure.
+extern "C" int __cdecl _cputws(wchar_t const* string)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN((string != nullptr), EINVAL, -1);
+
+    if (__dcrt_lowio_ensure_console_output_initialized() == FALSE)
+        return -1;
+
+    // Write string to console file handle:
+    ptrdiff_t length = wcslen(string);
+
+    __acrt_lock(__acrt_conio_lock);
+
+    int result = 0;
+
+    __try
+    {
+        while (length > 0)
+        {
+            static size_t const max_write_bytes = 65535;
+            static size_t const max_write_wchars = max_write_bytes / sizeof(wchar_t);
+
+            DWORD const wchars_to_write = length > max_write_wchars
+                ? max_write_wchars
+                : static_cast<DWORD>(length);
+
+            DWORD wchars_written;
+            if (__dcrt_write_console(
+                string,
+                wchars_to_write,
+                &wchars_written) == FALSE)
+            {
+                result = -1;
+                __leave;
+            }
+
+            string += wchars_to_write;
+            length -= wchars_to_write;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+
+    return result;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cscanf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cscanf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8e7df22004dcabb02b7318705ea5ca4a891ae55
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/cscanf.cpp	
@@ -0,0 +1,56 @@
+//
+// cscanf.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The core formatted input functions for direct console I/O.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_stdio_input.h>
+
+using namespace __crt_stdio_input;
+
+template <typename Character>
+static int __cdecl common_cscanf(
+    unsigned __int64 const options,
+    Character const* const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    ) throw()
+{
+    typedef input_processor<
+        Character,
+        console_input_adapter<Character>
+    > processor_type;
+
+    _LocaleUpdate locale_update(locale);
+
+    processor_type processor(
+        console_input_adapter<Character>(),
+        options,
+        format,
+        locale_update.GetLocaleT(),
+        arglist);
+
+    return processor.process();
+}
+
+extern "C" int __cdecl __conio_common_vcscanf(
+    unsigned __int64 const options,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_cscanf(options, format, locale, arglist);
+}
+
+extern "C" int __cdecl __conio_common_vcwscanf(
+    unsigned __int64 const options,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_cscanf(options, format, locale, arglist);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getch.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b24cb670062742998f1035611a5324ff220fbea
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getch.cpp	
@@ -0,0 +1,569 @@
+//
+// getch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _getch(), _getche(), and _ungetch(), which get and unget
+// characters directly from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+namespace
+{
+    struct CharPair
+    {
+        unsigned char LeadChar;
+        unsigned char SecondChar;
+    };
+
+    struct EnhKeyVals
+    {
+        unsigned short ScanCode;
+        CharPair RegChars;
+        CharPair ShiftChars;
+        CharPair CtrlChars;
+        CharPair AltChars;
+    };
+
+    struct NormKeyVals
+    {
+        CharPair RegChars;
+        CharPair ShiftChars;
+        CharPair CtrlChars;
+        CharPair AltChars;
+    };
+}
+
+
+
+// Table of enhanced key values:
+static EnhKeyVals const EnhancedKeys[] =
+{
+    { 28, {  13,   0 }, {  13,   0 }, {  10,   0 }, {   0, 166 } },
+    { 53, {  47,   0 }, {  63,   0 }, {   0, 149 }, {   0, 164 } },
+    { 71, { 224,  71 }, { 224,  71 }, { 224, 119 }, {   0, 151 } },
+    { 72, { 224,  72 }, { 224,  72 }, { 224, 141 }, {   0, 152 } },
+    { 73, { 224,  73 }, { 224,  73 }, { 224, 134 }, {   0, 153 } },
+    { 75, { 224,  75 }, { 224,  75 }, { 224, 115 }, {   0, 155 } },
+    { 77, { 224,  77 }, { 224,  77 }, { 224, 116 }, {   0, 157 } },
+    { 79, { 224,  79 }, { 224,  79 }, { 224, 117 }, {   0, 159 } },
+    { 80, { 224,  80 }, { 224,  80 }, { 224, 145 }, {   0, 160 } },
+    { 81, { 224,  81 }, { 224,  81 }, { 224, 118 }, {   0, 161 } },
+    { 82, { 224,  82 }, { 224,  82 }, { 224, 146 }, {   0, 162 } },
+    { 83, { 224,  83 }, { 224,  83 }, { 224, 147 }, {   0, 163 } }
+};
+
+// The number of elements in EnhancedKeys:
+#define NUM_EKA_ELTS (sizeof(EnhancedKeys) / sizeof(EnhKeyVals))
+
+
+
+// Table of key values for normal keys.  Note that the table is padded so that
+// the key scan code serves as an index into the table.
+static NormKeyVals const NormalKeys[] =
+{
+    /* padding */
+    { /*  0 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /*  1 */ {  27,   0 }, {  27,   0 }, {  27,   0 }, {   0,   1 } },
+    { /*  2 */ {  49,   0 }, {  33,   0 }, {   0,   0 }, {   0, 120 } },
+    { /*  3 */ {  50,   0 }, {  64,   0 }, {   0,   3 }, {   0, 121 } },
+    { /*  4 */ {  51,   0 }, {  35,   0 }, {   0,   0 }, {   0, 122 } },
+    { /*  5 */ {  52,   0 }, {  36,   0 }, {   0,   0 }, {   0, 123 } },
+    { /*  6 */ {  53,   0 }, {  37,   0 }, {   0,   0 }, {   0, 124 } },
+    { /*  7 */ {  54,   0 }, {  94,   0 }, {  30,   0 }, {   0, 125 } },
+    { /*  8 */ {  55,   0 }, {  38,   0 }, {   0,   0 }, {   0, 126 } },
+    { /*  9 */ {  56,   0 }, {  42,   0 }, {   0,   0 }, {   0, 127 } },
+    { /* 10 */ {  57,   0 }, {  40,   0 }, {   0,   0 }, {   0, 128 } },
+    { /* 11 */ {  48,   0 }, {  41,   0 }, {   0,   0 }, {   0, 129 } },
+    { /* 12 */ {  45,   0 }, {  95,   0 }, {  31,   0 }, {   0, 130 } },
+    { /* 13 */ {  61,   0 }, {  43,   0 }, {   0,   0 }, {   0, 131 } },
+    { /* 14 */ {   8,   0 }, {   8,   0 }, { 127,   0 }, {   0,  14 } },
+    { /* 15 */ {   9,   0 }, {   0,  15 }, {   0, 148 }, {   0,  15 } },
+    { /* 16 */ { 113,   0 }, {  81,   0 }, {  17,   0 }, {   0,  16 } },
+    { /* 17 */ { 119,   0 }, {  87,   0 }, {  23,   0 }, {   0,  17 } },
+    { /* 18 */ { 101,   0 }, {  69,   0 }, {   5,   0 }, {   0,  18 } },
+    { /* 19 */ { 114,   0 }, {  82,   0 }, {  18,   0 }, {   0,  19 } },
+    { /* 20 */ { 116,   0 }, {  84,   0 }, {  20,   0 }, {   0,  20 } },
+    { /* 21 */ { 121,   0 }, {  89,   0 }, {  25,   0 }, {   0,  21 } },
+    { /* 22 */ { 117,   0 }, {  85,   0 }, {  21,   0 }, {   0,  22 } },
+    { /* 23 */ { 105,   0 }, {  73,   0 }, {   9,   0 }, {   0,  23 } },
+    { /* 24 */ { 111,   0 }, {  79,   0 }, {  15,   0 }, {   0,  24 } },
+    { /* 25 */ { 112,   0 }, {  80,   0 }, {  16,   0 }, {   0,  25 } },
+    { /* 26 */ {  91,   0 }, { 123,   0 }, {  27,   0 }, {   0,  26 } },
+    { /* 27 */ {  93,   0 }, { 125,   0 }, {  29,   0 }, {   0,  27 } },
+    { /* 28 */ {  13,   0 }, {  13,   0 }, {  10,   0 }, {   0,  28 } },
+
+    /* padding */
+    { /* 29 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 30 */ {  97,   0 }, {  65,   0 }, {   1,   0 }, {   0,  30 } },
+    { /* 31 */ { 115,   0 }, {  83,   0 }, {  19,   0 }, {   0,  31 } },
+    { /* 32 */ { 100,   0 }, {  68,   0 }, {   4,   0 }, {   0,  32 } },
+    { /* 33 */ { 102,   0 }, {  70,   0 }, {   6,   0 }, {   0,  33 } },
+    { /* 34 */ { 103,   0 }, {  71,   0 }, {   7,   0 }, {   0,  34 } },
+    { /* 35 */ { 104,   0 }, {  72,   0 }, {   8,   0 }, {   0,  35 } },
+    { /* 36 */ { 106,   0 }, {  74,   0 }, {  10,   0 }, {   0,  36 } },
+    { /* 37 */ { 107,   0 }, {  75,   0 }, {  11,   0 }, {   0,  37 } },
+    { /* 38 */ { 108,   0 }, {  76,   0 }, {  12,   0 }, {   0,  38 } },
+    { /* 39 */ {  59,   0 }, {  58,   0 }, {   0,   0 }, {   0,  39 } },
+    { /* 40 */ {  39,   0 }, {  34,   0 }, {   0,   0 }, {   0,  40 } },
+    { /* 41 */ {  96,   0 }, { 126,   0 }, {   0,   0 }, {   0,  41 } },
+
+    /* padding */
+    { /* 42 */ {    0,  0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 43 */ {  92,   0 }, { 124,   0 }, {  28,   0 }, {   0,   0 } },
+    { /* 44 */ { 122,   0 }, {  90,   0 }, {  26,   0 }, {   0,  44 } },
+    { /* 45 */ { 120,   0 }, {  88,   0 }, {  24,   0 }, {   0,  45 } },
+    { /* 46 */ {  99,   0 }, {  67,   0 }, {   3,   0 }, {   0,  46 } },
+    { /* 47 */ { 118,   0 }, {  86,   0 }, {  22,   0 }, {   0,  47 } },
+    { /* 48 */ {  98,   0 }, {  66,   0 }, {   2,   0 }, {   0,  48 } },
+    { /* 49 */ { 110,   0 }, {  78,   0 }, {  14,   0 }, {   0,  49 } },
+    { /* 50 */ { 109,   0 }, {  77,   0 }, {  13,   0 }, {   0,  50 } },
+    { /* 51 */ {  44,   0 }, {  60,   0 }, {   0,   0 }, {   0,  51 } },
+    { /* 52 */ {  46,   0 }, {  62,   0 }, {   0,   0 }, {   0,  52 } },
+    { /* 53 */ {  47,   0 }, {  63,   0 }, {   0,   0 }, {   0,  53 } },
+
+    /* padding */
+    { /* 54 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 55 */ {  42,   0 }, {   0,   0 }, { 114,   0 }, {   0,   0 } },
+
+    /* padding */
+    { /* 56 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 57 */ {  32,   0 }, {  32,   0 }, {  32,   0 }, {  32,   0 } },
+
+    /* padding */
+    { /* 58 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 59 */ {   0,  59 }, {   0,  84 }, {   0,  94 }, {   0, 104 } },
+    { /* 60 */ {   0,  60 }, {   0,  85 }, {   0,  95 }, {   0, 105 } },
+    { /* 61 */ {   0,  61 }, {   0,  86 }, {   0,  96 }, {   0, 106 } },
+    { /* 62 */ {   0,  62 }, {   0,  87 }, {   0,  97 }, {   0, 107 } },
+    { /* 63 */ {   0,  63 }, {   0,  88 }, {   0,  98 }, {   0, 108 } },
+    { /* 64 */ {   0,  64 }, {   0,  89 }, {   0,  99 }, {   0, 109 } },
+    { /* 65 */ {   0,  65 }, {   0,  90 }, {   0, 100 }, {   0, 110 } },
+    { /* 66 */ {   0,  66 }, {   0,  91 }, {   0, 101 }, {   0, 111 } },
+    { /* 67 */ {   0,  67 }, {   0,  92 }, {   0, 102 }, {   0, 112 } },
+    { /* 68 */ {   0,  68 }, {   0,  93 }, {   0, 103 }, {   0, 113 } },
+
+    /* padding */
+    { /* 69 */ {    0,  0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 70 */ {    0,  0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 71 */ {   0,  71 }, {  55,   0 }, {   0, 119 }, {   0,   0 } },
+    { /* 72 */ {   0,  72 }, {  56,   0 }, {   0, 141 }, {   0,   0 } },
+    { /* 73 */ {   0,  73 }, {  57,   0 }, {   0, 132 }, {   0,   0 } },
+    { /* 74 */ {   0,   0 }, {  45,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 75 */ {   0,  75 }, {  52,   0 }, {   0, 115 }, {   0,   0 } },
+    { /* 76 */ {   0,   0 }, {  53,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 77 */ {   0,  77 }, {  54,   0 }, {   0, 116 }, {   0,   0 } },
+    { /* 78 */ {   0,   0 }, {  43,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 79 */ {   0,  79 }, {  49,   0 }, {   0, 117 }, {   0,   0 } },
+    { /* 80 */ {   0,  80 }, {  50,   0 }, {   0, 145 }, {   0,   0 } },
+    { /* 81 */ {   0,  81 }, {  51,   0 }, {   0, 118 }, {   0,   0 } },
+    { /* 82 */ {   0,  82 }, {  48,   0 }, {   0, 146 }, {   0,   0 } },
+    { /* 83 */ {   0,  83 }, {  46,   0 }, {   0, 147 }, {   0,   0 } },
+
+    /* padding */
+    { /* 84 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 85 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+    { /* 86 */ {   0,   0 }, {   0,   0 }, {   0,   0 }, {   0,   0 } },
+
+    { /* 87 */ { 224, 133 }, { 224, 135 }, { 224, 137 }, { 224, 139 } },
+    { /* 88 */ { 224, 134 }, { 224, 136 }, { 224, 138 }, { 224, 140 } }
+};
+
+// The primary purpose of the pushback buffer is so that if a
+// multi-byte character or extended key code is read, we can return
+// the first byte and store the rest of the data in the buffer for
+// subsequent calls. UTF-8 characters can be up to 4 bytes long, so
+// the pushback buffer must be able to store the 3 remaining bytes.
+size_t const getch_pushback_buffer_capacity = 3;
+
+static int getch_pushback_buffer[getch_pushback_buffer_capacity];
+static int getch_pushback_buffer_index = 0;
+static int getch_pushback_buffer_current_size = 0;
+
+static bool is_getch_pushback_buffer_full()
+{
+    return getch_pushback_buffer_current_size >= getch_pushback_buffer_capacity;
+}
+
+static void add_to_getch_pushback_buffer(int const c)
+{
+    _ASSERTE(!is_getch_pushback_buffer_full());
+    getch_pushback_buffer[getch_pushback_buffer_current_size++] = c;
+}
+
+static int peek_next_getch_pushback_buffer()
+{
+    if (getch_pushback_buffer_current_size == 0) {
+        return EOF;
+    }
+
+    return getch_pushback_buffer[getch_pushback_buffer_index];
+}
+
+static int get_next_getch_pushback_buffer()
+{
+    if (getch_pushback_buffer_current_size == 0) {
+        return EOF;
+    }
+
+    int const ret_val = getch_pushback_buffer[getch_pushback_buffer_index++];
+
+    if (getch_pushback_buffer_index == getch_pushback_buffer_current_size) {
+        getch_pushback_buffer_index = 0;
+        getch_pushback_buffer_current_size = 0;
+    }
+
+    return ret_val;
+}
+
+extern "C" extern intptr_t __dcrt_lowio_console_input_handle;
+
+extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD*);
+extern "C" int __cdecl _kbhit_nolock();
+
+
+
+// These functions read a single character from the console.  _getch() does not
+// echo the character; _getche() does echo the character.  If the push-back
+// buffer is nonempty, the buffered character is returned immediately, without
+// being echoed.
+//
+// On success, the read character is returned; on failure, EOF is returned.
+extern "C" int __cdecl _getch()
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _getch_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+extern "C" int __cdecl _getche()
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _getche_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+extern "C" int __cdecl _getch_nolock()
+{
+    // Check the pushback buffer for a character.  If one is present, return it:
+    int const pushback = get_next_getch_pushback_buffer();
+    if (pushback != EOF)
+    {
+        return pushback;
+    }
+
+    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) {
+        return EOF;
+    }
+
+    // Switch console to raw mode:
+    DWORD old_console_mode;
+    __dcrt_get_input_console_mode(&old_console_mode);
+    __dcrt_set_input_console_mode(0);
+
+    int result = 0;
+
+    __try
+    {
+        for ( ; ; )
+        {
+            // Get a console input event:
+            INPUT_RECORD input_record;
+            DWORD num_read;
+
+            if (__dcrt_read_console_input(&input_record, 1, &num_read) == FALSE || num_read == 0)
+            {
+                result = EOF;
+                __leave;
+            }
+
+            // Look for, and decipher, key events.
+            if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown)
+            {
+                // Simple case:  if UnicodeChar is non-zero, we can convert it to char and return it.
+                wchar_t const c = input_record.Event.KeyEvent.uChar.UnicodeChar;
+                if (c != 0)
+                {
+                    wchar_t const c_buffer[2] = {c, L'\0'};
+                    char mb_chars[4];
+
+                    size_t const amount_written = __acrt_wcs_to_mbs_cp_array(
+                        c_buffer,
+                        mb_chars,
+                        GetConsoleCP()
+                        );
+
+                    // Mask with 0xFF to just get lowest byte
+                    if (amount_written >= 1) {
+                        result = mb_chars[0] & 0xFF;
+                    }
+
+                    if (amount_written >= 2) {
+                        for (size_t i = 1; i < amount_written; ++i) {
+                            add_to_getch_pushback_buffer(mb_chars[i] & 0xFF);
+                        }
+                    }
+                    __leave;
+                }
+
+                // Hard case:  either it is an extended code or an event which
+                // should not be recognized.  Let _getextendedkeycode do the work:
+                CharPair const* const cp = _getextendedkeycode(&input_record.Event.KeyEvent);
+                if (cp != nullptr)
+                {
+                    // Mask with 0xFF to just get lowest byte
+                    add_to_getch_pushback_buffer(cp->SecondChar & 0xFF);
+                    result = cp->LeadChar & 0xFF;
+                    __leave;
+                }
+            }
+        }
+    }
+    __finally
+    {
+        // Restore the previous console mode:
+        __dcrt_set_input_console_mode(old_console_mode);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _getche_nolock()
+{
+    // Check the pushback buffer for a character.  If one is present, return
+    // it without echoing:
+    int const pushback = get_next_getch_pushback_buffer();
+    if (pushback != EOF)
+    {
+        return pushback;
+    }
+
+    // Otherwise, read the next character from the console and echo it:
+    int const c = _getch_nolock();
+    if (c == EOF)
+        return EOF;
+
+    if (_putch_nolock(c) == EOF)
+        return EOF;
+
+    return c;
+}
+
+
+
+// Returns nonzero if a keystroke is waiting to be read; otherwise returns zero.
+extern "C" int __cdecl _kbhit()
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _kbhit_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _kbhit_nolock()
+{
+    // If a character has been pushed back, return TRUE:
+    if (peek_next_getch_pushback_buffer() != EOF) {
+        return TRUE;
+    }
+
+    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) {
+        return FALSE;
+    }
+
+    // Peek at all pending console events:
+    DWORD num_pending;
+    if (__dcrt_get_number_of_console_input_events(&num_pending) == FALSE) {
+        return FALSE;
+    }
+
+    if (num_pending == 0) {
+        return FALSE;
+    }
+
+    __crt_scoped_stack_ptr<INPUT_RECORD> const input_buffer(_malloca_crt_t(INPUT_RECORD, num_pending));
+    if (input_buffer.get() == nullptr) {
+        return FALSE;
+    }
+
+    DWORD num_peeked;
+    // AsciiChar is not read, so using the narrow Win32 API is permitted.
+    if (__dcrt_peek_console_input_a(input_buffer.get(), num_pending, &num_peeked) == FALSE) {
+        return FALSE;
+    }
+
+    if (num_peeked == 0 || num_peeked > num_pending) {
+        return FALSE;
+    }
+
+    // Scan all of the peeked events to determine if any is a key event
+    // that should be recognized:
+    for (INPUT_RECORD* p = input_buffer.get(); num_peeked > 0; --num_peeked, ++p)
+    {
+        if (p->EventType != KEY_EVENT)
+            continue;
+
+        if (!p->Event.KeyEvent.bKeyDown)
+            continue;
+
+        if (p->Event.KeyEvent.uChar.AsciiChar == 0 &&
+            _getextendedkeycode(&p->Event.KeyEvent) == nullptr)
+            continue;
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+
+// Pushes back ("ungets") one character to be read next by _getwch() or
+// _getwche().  On success, returns the character that was pushed back; on
+// failure, returns EOF.
+extern "C" int __cdecl _ungetch(int const c)
+{
+    __acrt_lock(__acrt_conio_lock);
+    int result = 0;
+    __try
+    {
+        result = _ungetch_nolock(c);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _ungetch_nolock(int const c)
+{
+    // Fail if the character is EOF or the pusback buffer is nonempty:
+    if (c == EOF || is_getch_pushback_buffer_full()) {
+        return EOF;
+    }
+
+    add_to_getch_pushback_buffer(c);
+    return c;
+}
+
+
+
+// Returns the extended code (if there is one) for a key event.  This is the
+// core function for the _getch() and _getche() functions and their wide
+// character equivalents, and is essential to _kbhit().  This is the function
+// that determines whether or not a key event NOT accompanied by an ASCII
+// character has an extended code and returns that code.
+//
+// On success, a pointer to a CharPair value holding the lead and second
+// characters of the extended code is returned.  On failure, nullptr is returned.
+extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD* const pKE)
+{
+    DWORD const CKS = pKE->dwControlKeyState;
+
+    if (CKS & ENHANCED_KEY)
+    {
+        // Find the appropriate entry in EnhancedKeys[]:
+        for (int i = 0 ; i < NUM_EKA_ELTS; ++i)
+        {
+            if (EnhancedKeys[i].ScanCode != pKE->wVirtualScanCode)
+            {
+                continue;
+            }
+
+            // We found a match!  Determine which pair to return:
+            if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
+            {
+                return &EnhancedKeys[i].AltChars;
+            }
+            else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
+            {
+                return &EnhancedKeys[i].CtrlChars;
+            }
+            else if (CKS & SHIFT_PRESSED)
+            {
+                return &EnhancedKeys[i].ShiftChars;
+            }
+            else
+            {
+                return &EnhancedKeys[i].RegChars;
+            }
+        }
+
+        return nullptr;
+    }
+    else
+    {
+        // Regular key or keyboard event which shouldn't be recognized.
+        // Determine which by getting the proper field of the proper entry in
+        // NormalKeys[] and examining the extended code.
+        CharPair const* pCP;
+
+        if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].AltChars;
+        }
+        else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].CtrlChars;
+        }
+        else if (CKS & SHIFT_PRESSED)
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].ShiftChars;
+        }
+        else
+        {
+            pCP = &NormalKeys[pKE->wVirtualScanCode].RegChars;
+        }
+
+        // Make sure it wasn't a keyboard event which should not be recognized
+        // (e.g. the shift key was pressed):
+        if ((pCP->LeadChar != 0 && pCP->LeadChar != 224) || pCP->SecondChar == 0)
+        {
+            return nullptr;
+        }
+
+        return pCP;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getwch.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getwch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a25ab25980e7644dee3843522b3277758dbbc6b4
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/getwch.cpp	
@@ -0,0 +1,201 @@
+//
+// getwch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _getwch(), _getwche(), and _ungetwch(), which get and unget
+// characters directly from the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+
+
+namespace
+{
+    struct CharPair
+    {
+        unsigned char LeadChar;
+        unsigned char SecondChar;
+    };
+}
+
+
+static wint_t wchbuf = WEOF; // The push-back buffer
+
+extern "C" extern intptr_t __dcrt_lowio_console_input_handle;
+
+extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD*);
+
+
+
+// Reads one character directly from the console.  The _getwche() form also
+// echoes the character back to the console.  If the push-back buffer is
+// nonempty, then its value is returned and the push-back buffer is marked as
+// empty.
+//
+// Returns the character that is read on success; returns WEOF on failure.
+extern "C" wint_t __cdecl _getwch()
+{
+    __acrt_lock(__acrt_conio_lock);
+    wint_t result = 0;
+    __try
+    {
+        result = _getwch_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+extern "C" wint_t __cdecl _getwche()
+{
+    __acrt_lock(__acrt_conio_lock);
+    wint_t result = 0;
+    __try
+    {
+        result = _getwche_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" wint_t __cdecl _getwch_nolock()
+{
+    // First check the pushback buffer for a character.  If it has one, return
+    // it without echoing and reset the buffer:
+    if (wchbuf != WEOF)
+    {
+        wchar_t const buffered_wchar = static_cast<wchar_t>(wchbuf & 0xFFFF);
+        wchbuf = WEOF;
+        return buffered_wchar;
+    }
+
+    // The console input handle is created the first time that _getwch(),
+    // _cgetws(), or _kbhit() is called:
+    if (__dcrt_lowio_ensure_console_input_initialized() == FALSE)
+        return WEOF;
+
+    // Switch to raw mode (no line input, no echo input):
+    DWORD old_console_mode;
+    __dcrt_get_input_console_mode(&old_console_mode);
+    __dcrt_set_input_console_mode(0);
+    wint_t result = 0;
+    __try
+    {
+        for ( ; ; )
+        {
+            // Get a console input event:
+            INPUT_RECORD input_record;
+            DWORD num_read;
+            if (__dcrt_read_console_input(&input_record, 1, &num_read) == FALSE)
+            {
+                result = WEOF;
+                __leave;
+            }
+
+            if (num_read == 0)
+            {
+                result = WEOF;
+                __leave;
+            }
+
+            // Look for, and decipher, key events.
+            if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown)
+            {
+                // Easy case:  if UnicodeChar is non-zero, we can just return it:
+                wchar_t const c = static_cast<wchar_t>(input_record.Event.KeyEvent.uChar.UnicodeChar);
+                if (c != 0)
+                {
+                    result = c;
+                    __leave;
+                }
+
+                // Hard case:  either it is an extended code or an event which
+                // should not be recognized.  Let _getextendedkeycode do the work:
+                CharPair const* const cp = _getextendedkeycode(&input_record.Event.KeyEvent);
+                if (cp != nullptr)
+                {
+                    wchbuf = cp->SecondChar;
+                    result = cp->LeadChar;
+                    __leave;
+                }
+            }
+        }
+    }
+    __finally
+    {
+        // Restore the previous console mode:
+        __dcrt_set_input_console_mode(old_console_mode);
+    }
+    return result;
+}
+
+
+
+extern "C" wint_t __cdecl _getwche_nolock()
+{
+    // First check the pushback buffer for a character.  If it has one, return
+    // it without echoing and reset the buffer:
+    if (wchbuf != WEOF)
+    {
+        wchar_t const buffered_wchar = static_cast<wchar_t>(wchbuf & 0xFFFF);
+        wchbuf = WEOF;
+        return buffered_wchar;
+    }
+
+    // Othwrwise, read the character, echo it, and return it.  If anything fails,
+    // we immediately return WEOF.
+    wchar_t const gotten_wchar = _getwch_nolock();
+    if (gotten_wchar == WEOF)
+        return WEOF;
+
+    if (_putwch_nolock(gotten_wchar) == WEOF)
+        return WEOF;
+
+    return gotten_wchar;
+}
+
+
+
+// Pushes back ("ungets") one character to be read next by _getwch() or
+// _getwche().  On success, returns the character that was pushed back; on
+// failure, returns EOF.
+extern "C" wint_t __cdecl _ungetwch(wint_t const c)
+{
+    __acrt_lock(__acrt_conio_lock);
+    wint_t result = 0;
+    __try
+    {
+        result = _ungetwch_nolock(c);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_conio_lock);
+    }
+    return result;
+}
+
+
+
+extern "C" wint_t __cdecl _ungetwch_nolock(wint_t const c)
+{
+    // Fail if the char is EOF or the pushback buffer is non-empty:
+    if (c == WEOF || wchbuf != WEOF)
+        return static_cast<wint_t>(EOF);
+
+    wchbuf = (c & 0xFF);
+    return wchbuf;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initcon.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initcon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..899349002a21f3d5f3756429f3ca0fa07286620d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initcon.cpp	
@@ -0,0 +1,83 @@
+//
+// initcon.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global console output handle and the __dcrt_lowio_initialize_console_output() and
+// __dcrt_terminate_console_output() functions, which initialize and close that handle.
+// Also defines functions that can be used instead of the Console API to enable retry behavior
+// in case the cached console handle is freed.
+
+#include <corecrt_internal_lowio.h>
+
+_CRT_LINKER_FORCE_INCLUDE(__dcrt_console_output_terminator);
+
+// The global console output handle.
+static HANDLE __dcrt_lowio_console_output_handle = _console_uninitialized_handle;
+
+// Initializes the global console output handle
+static void __dcrt_lowio_initialize_console_output()
+{
+    __dcrt_lowio_console_output_handle = CreateFileW(
+        L"CONOUT$",
+        GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nullptr,
+        OPEN_EXISTING,
+        0,
+        nullptr);
+}
+
+extern "C" BOOL __cdecl __dcrt_lowio_ensure_console_output_initialized()
+{
+    if (__dcrt_lowio_console_output_handle == _console_uninitialized_handle)
+    {
+        __dcrt_lowio_initialize_console_output();
+    }
+
+    if (__dcrt_lowio_console_output_handle == _console_invalid_handle)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+// Closes the global console output handle
+extern "C" void __cdecl __dcrt_terminate_console_output()
+{
+    if (   __dcrt_lowio_console_output_handle != _console_invalid_handle
+        && __dcrt_lowio_console_output_handle != _console_uninitialized_handle)
+    {
+        CloseHandle(__dcrt_lowio_console_output_handle);
+    }
+}
+
+template <typename Func>
+static BOOL console_output_reopen_and_retry(Func const& fp) throw()
+{
+    BOOL result = fp();
+    if (!result && GetLastError() == ERROR_INVALID_HANDLE) {
+        __dcrt_terminate_console_output();
+        __dcrt_lowio_initialize_console_output();
+        result = fp();
+    }
+    return result;
+}
+
+extern "C" BOOL __cdecl __dcrt_write_console(
+    _In_  void const * lpBuffer,
+    _In_  DWORD        nNumberOfCharsToWrite,
+    _Out_ LPDWORD      lpNumberOfCharsWritten
+    )
+{
+    return console_output_reopen_and_retry(
+        [lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten]()
+        {
+            return ::WriteConsoleW(
+                __dcrt_lowio_console_output_handle,
+                lpBuffer,
+                nNumberOfCharsToWrite,
+                lpNumberOfCharsWritten,
+                nullptr);
+        });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initconin.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initconin.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89e299a8eb345544f977d0a383a432a98a874451
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/initconin.cpp	
@@ -0,0 +1,162 @@
+//
+// initconin.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global console input handle and the __dcrt_lowio_initialize_console_input() and
+// __dcrt_terminate_console_input() functions, which initialize and close that handle.
+// Also defines functions that can be used instead of the Console API to enable retry behavior
+// in case the cached console handle is freed.
+
+#include <corecrt_internal_lowio.h>
+
+_CRT_LINKER_FORCE_INCLUDE(__dcrt_console_input_terminator);
+
+// The global console input handle.
+static HANDLE __dcrt_lowio_console_input_handle = _console_uninitialized_handle;
+
+// Initializes the global console input handle
+static void __dcrt_lowio_initialize_console_input()
+{
+    __dcrt_lowio_console_input_handle = CreateFileW(
+        L"CONIN$",
+        GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nullptr,
+        OPEN_EXISTING,
+        0,
+        nullptr);
+}
+
+extern "C" BOOL __cdecl __dcrt_lowio_ensure_console_input_initialized()
+{
+    if (__dcrt_lowio_console_input_handle == _console_uninitialized_handle)
+    {
+        __dcrt_lowio_initialize_console_input();
+    }
+
+    if (__dcrt_lowio_console_input_handle == _console_invalid_handle)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+// Closes the global console input handle
+extern "C" void __cdecl __dcrt_terminate_console_input()
+{
+    if (   __dcrt_lowio_console_input_handle != _console_invalid_handle
+        && __dcrt_lowio_console_input_handle != _console_uninitialized_handle)
+    {
+        CloseHandle(__dcrt_lowio_console_input_handle);
+    }
+}
+
+template <typename Func>
+static BOOL console_input_reopen_and_retry(Func const& fp) throw()
+{
+    BOOL result = fp();
+    if (!result && GetLastError() == ERROR_INVALID_HANDLE) {
+        __dcrt_terminate_console_input();
+        __dcrt_lowio_initialize_console_input();
+        result = fp();
+    }
+    return result;
+}
+
+extern "C" BOOL __cdecl __dcrt_read_console_input(
+    _Out_ PINPUT_RECORD lpBuffer,
+    _In_  DWORD         nLength,
+    _Out_ LPDWORD       lpNumberOfEventsRead
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpBuffer, nLength, lpNumberOfEventsRead]()
+        {
+            return ::ReadConsoleInputW(
+                __dcrt_lowio_console_input_handle,
+                lpBuffer,
+                nLength,
+                lpNumberOfEventsRead
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_read_console(
+    _Out_ LPVOID  lpBuffer,
+    _In_  DWORD   nNumberOfCharsToRead,
+    _Out_ LPDWORD lpNumberOfCharsRead
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead]()
+        {
+            return ::ReadConsoleW(
+                __dcrt_lowio_console_input_handle,
+                lpBuffer,
+                nNumberOfCharsToRead,
+                lpNumberOfCharsRead,
+                nullptr
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_get_number_of_console_input_events(
+    _Out_ LPDWORD lpcNumberOfEvents
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpcNumberOfEvents]()
+        {
+            return ::GetNumberOfConsoleInputEvents(
+                __dcrt_lowio_console_input_handle,
+                lpcNumberOfEvents
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_peek_console_input_a(
+    _Out_ PINPUT_RECORD lpBuffer,
+    _In_  DWORD         nLength,
+    _Out_ LPDWORD       lpNumberOfEventsRead
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpBuffer, nLength, lpNumberOfEventsRead]()
+        {
+            return ::PeekConsoleInputA(
+                __dcrt_lowio_console_input_handle,
+                lpBuffer,
+                nLength,
+                lpNumberOfEventsRead
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_get_input_console_mode(
+    _Out_ LPDWORD lpMode
+    )
+{
+    return console_input_reopen_and_retry(
+        [lpMode]()
+        {
+            return ::GetConsoleMode(
+                __dcrt_lowio_console_input_handle,
+                lpMode
+                );
+        });
+}
+
+extern "C" BOOL __cdecl __dcrt_set_input_console_mode(
+    _In_ DWORD dwMode
+    )
+{
+    return console_input_reopen_and_retry(
+        [dwMode]()
+        {
+            return ::SetConsoleMode(
+                __dcrt_lowio_console_input_handle,
+                dwMode
+                );
+        });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/pipe.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/pipe.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..831e35a57c3193dc5e53cdda28f8422fbbe427ba
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/pipe.cpp	
@@ -0,0 +1,113 @@
+//
+// pipe.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _pipe(), which creates a pipe.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdlib.h>
+
+
+
+// Creates a pipe.  The phandles pointer must be a pointer to an array of two
+// int objects.  Upon successful return, phandles[0] is the read handle, and
+// phandles[1] is the write handle for the pipe.  On success, 0 is returned; on
+// failure, -1 is returned and errno is set.
+//
+// The psize is the amount of memory, in bytes, to ask the OS to reserve for the
+// pipe.  The textmode is the text mode that will be given to the pipe.
+extern "C" int __cdecl _pipe(int* const phandles, unsigned const psize, int const textmode)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(phandles != nullptr, EINVAL, -1);
+    phandles[0] = phandles[1] = -1;
+
+    _VALIDATE_CLEAR_OSSERR_RETURN((textmode & ~(_O_NOINHERIT | _O_BINARY | _O_TEXT)) == 0, EINVAL, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN((textmode & (_O_BINARY | _O_TEXT)) != (_O_BINARY | _O_TEXT), EINVAL, -1);
+
+
+    SECURITY_ATTRIBUTES security_attributes;
+    security_attributes.nLength = sizeof(security_attributes);
+    security_attributes.lpSecurityDescriptor = nullptr;
+    security_attributes.bInheritHandle = (textmode & _O_NOINHERIT) == 0;
+
+
+    // Create the pipe:
+    HANDLE read_handle, write_handle;
+    if (!CreatePipe(&read_handle, &write_handle, &security_attributes, psize))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    // Create the CRT read handle for the pipe:
+    int const crt_read_handle = _alloc_osfhnd();
+    if (crt_read_handle == -1)
+    {
+        errno = EMFILE;
+        _doserrno = 0;
+        CloseHandle(read_handle);
+        CloseHandle(write_handle);
+        return -1;
+    }
+
+    __try
+    {
+        _osfile(crt_read_handle)     = FOPEN | FPIPE | FTEXT;
+        _textmode(crt_read_handle)   = __crt_lowio_text_mode::ansi;
+        _tm_unicode(crt_read_handle) = false;
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(crt_read_handle);
+    }
+
+    // Create the CRT write handle for the pipe:
+    int const crt_write_handle = _alloc_osfhnd();
+    if (crt_write_handle == -1)
+    {
+        _osfile(crt_read_handle) = 0;
+        errno = EMFILE;
+        _doserrno = 0;
+        CloseHandle(read_handle);
+        CloseHandle(write_handle);
+        return -1;
+    }
+
+    __try
+    {
+        _osfile(crt_write_handle)     = FOPEN | FPIPE | FTEXT;
+        _textmode(crt_write_handle)   = __crt_lowio_text_mode::ansi;
+        _tm_unicode(crt_write_handle) = false;
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(crt_write_handle);
+    }
+
+    // Figure out which textmode the file gets:
+    int fmode = 0;
+    _ERRCHECK(_get_fmode(&fmode));
+
+    // The pipe gets binary mode if (a) binary was requested or (b) the
+    // global default fmode was changed to binary.
+    if ((textmode & _O_BINARY) || ((textmode & _O_TEXT) == 0 && fmode == _O_BINARY))
+    {
+        _osfile(crt_read_handle)  &= ~FTEXT;
+        _osfile(crt_write_handle) &= ~FTEXT;
+    }
+
+    if (textmode & _O_NOINHERIT)
+    {
+        _osfile(crt_read_handle)  |= FNOINHERIT;
+        _osfile(crt_write_handle) |= FNOINHERIT;
+    }
+
+    __acrt_lowio_set_os_handle(crt_read_handle,  reinterpret_cast<intptr_t>(read_handle));
+    __acrt_lowio_set_os_handle(crt_write_handle, reinterpret_cast<intptr_t>(write_handle));
+
+    phandles[0] = crt_read_handle;
+    phandles[1] = crt_write_handle;
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/popen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/popen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65d63f42563159694224230cd44b0bf9dabf5f0f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/popen.cpp	
@@ -0,0 +1,488 @@
+//
+// popen.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// The _popen() and _pclose() functions, which open a pipe to a child process.
+//
+#include <corecrt_internal_stdio.h>
+#include <process.h>
+
+
+
+#define STDIN     0
+#define STDOUT    1
+
+
+
+namespace {
+
+    template <typename Character>
+    struct fdopen_mode
+    {
+        Character mode[3];
+    };
+
+    // This is the entry type for the stream pointer / process handle pairs that
+    // are stored for each outstanding popen.
+    struct process_handle_pair
+    {
+        FILE*    stream;
+        intptr_t process_handle;
+    };
+
+    struct stream_traits
+    {
+        typedef FILE* type;
+
+        static bool close(_In_ type h) throw()
+        {
+            fclose(h);
+            return true;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return nullptr;
+        }
+    };
+
+    struct process_handle_pair_traits
+    {
+        typedef process_handle_pair* type;
+
+        static bool close(_In_ type h) throw()
+        {
+            h->process_handle = 0;
+            h->stream         = nullptr;
+            return true;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return nullptr;
+        }
+    };
+
+    typedef __crt_unique_handle_t<stream_traits>              unique_stream;
+    typedef __crt_unique_handle_t<process_handle_pair_traits> unique_process_handle_pair;
+}
+
+
+
+// The global table of stream pointer / process handle pairs.  Access to this
+// global tbale is only done via the idtab function.  The table is expanded as
+// necessary (by idtab), and free table entries are reused.  (An entry is free
+// if its stream is null.)  The table is never contracted.
+static unsigned             __idtabsiz;
+static process_handle_pair* __idpairs;
+
+
+
+// Finds the entry for the given stream in the global table.  If the stream is
+// found, a pointer to it is returned; if the stream is not found, null is
+// returned.
+//
+// If the stream is null, a new entry is allocated and a pointer to it is
+// returned.  If no entries are available and expansion of the table fails,
+// null is returned.
+//
+// This function assumes the caller has acquired the lock on the table already.
+static process_handle_pair* __cdecl idtab(FILE* const stream) throw()
+{
+    // Search the table, and return the matching entry if one is found:
+    process_handle_pair* const first = __idpairs;
+    process_handle_pair* const last  = first + __idtabsiz;
+    for (process_handle_pair* it = first; it != last; ++it)
+    {
+        if (it->stream == stream)
+            return it;
+    }
+
+    // We did not find an entry in the table.  If the stream is null, then we
+    // try creating or expanding the table.  Otherwise, we return null.  Note
+    // that when the table is created or expanded, exactly one new entry is
+    // produced.  This must not be changed unless code is added to mark the
+    // extra entries as being free (e.g., by setting their stream fields to null.
+    if (stream != nullptr)
+        return nullptr;
+
+    if (__idtabsiz + 1 < __idtabsiz)
+        return nullptr;
+
+    if (__idtabsiz + 1 >= SIZE_MAX / sizeof(process_handle_pair))
+        return nullptr;
+
+    process_handle_pair* const newptr = _recalloc_crt_t(process_handle_pair, __idpairs, __idtabsiz + 1).detach();
+    if (newptr == nullptr)
+        return nullptr;
+
+    __idpairs = newptr;
+    process_handle_pair* const pairptr = newptr + __idtabsiz;
+    ++__idtabsiz;
+
+    return pairptr;
+}
+
+
+
+template <typename Character>
+static fdopen_mode<Character> __cdecl convert_popen_type_to_fdopen_mode(
+    Character const* const type
+    ) throw()
+{
+    fdopen_mode<Character> result = fdopen_mode<Character>();
+
+    Character const* type_it = type;
+
+    while (*type_it == ' ')
+        ++type_it;
+
+    _VALIDATE_RETURN(*type_it == 'w' || *type_it == 'r', EINVAL, result);
+    result.mode[0] = *type_it++;
+
+    while (*type_it == ' ')
+        ++type_it;
+
+    _VALIDATE_RETURN(*type_it == '\0' || *type_it == 't' || *type_it == 'b', EINVAL, result);
+    result.mode[1] = *type_it;
+
+    return result;
+}
+
+
+
+template <typename Character>
+static Character const* __cdecl get_comspec() throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    static Character const comspec_name[] = { 'C', 'O', 'M', 'S', 'P', 'E', 'C', '\0' };
+
+    Character* comspec_value = nullptr;
+    if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&comspec_value, nullptr, comspec_name)) != 0)
+        return nullptr;
+
+    return comspec_value;
+}
+
+
+
+template <typename Character>
+static Character const* __cdecl get_path() throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    static Character const path_name[] = { 'P', 'A', 'T', 'H', '\0' };
+
+    Character* path_value = nullptr;
+    if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&path_value, nullptr, path_name)) != 0)
+        return nullptr;
+
+    return path_value;
+}
+
+
+
+template <typename Character>
+static Character const* __cdecl get_executable_path(
+    Character const* const executable
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    // If we can access the given path, just use it:
+    if (stdio_traits::taccess_s(executable, 0) == 0)
+        return executable;
+
+    // Otherwise, we need to search the PATH:
+    __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, MAX_PATH));
+    if (buffer.get() == nullptr)
+        return nullptr;
+
+    __crt_unique_heap_ptr<Character const> path(get_path<Character>());
+
+    Character const* current = path.get();
+    while ((current = stdio_traits::tgetpath(current, buffer.get(), MAX_PATH - 1)) != 0)
+    {
+        if (__crt_stdio_path_requires_backslash(buffer.get()))
+        {
+            static Character const backslash[] = { '\\', '\0' };
+            _ERRCHECK(stdio_traits::tcscat_s(buffer.get(), MAX_PATH, backslash));
+        }
+
+        if (stdio_traits::tcslen(buffer.get()) + stdio_traits::tcslen(executable) >= MAX_PATH)
+            return nullptr;
+
+        _ERRCHECK(stdio_traits::tcscat_s(buffer.get(), MAX_PATH, executable));
+
+        if (stdio_traits::taccess_s(buffer.get(), 0) == 0)
+            return buffer.detach();
+    }
+
+    return nullptr;
+}
+
+
+
+template <typename Character>
+static FILE* __cdecl common_popen_nolock(
+    Character const* const command,
+    Character const* const fdopen_mode,
+    int              const std_fh,
+    int (&pipe_handles)[2]
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    HANDLE const process_handle = GetCurrentProcess();
+
+    // We only return the second pipe handle to the caller; for the first pipe,
+    // we just need to use the HANDLE:
+    __crt_unique_handle new_pipe_handle;
+    if (!DuplicateHandle(
+            process_handle,
+            reinterpret_cast<HANDLE>(_osfhnd(pipe_handles[0])),
+            process_handle,
+            new_pipe_handle.get_address_of(),
+            0,
+            TRUE,
+            DUPLICATE_SAME_ACCESS))
+    {
+        return nullptr;
+    }
+
+    _close(pipe_handles[0]);
+    pipe_handles[0] = -1;
+
+    // Associate a stream with the pipe handle to be returned to the caller:
+    unique_stream pipe_stream(stdio_traits::tfdopen(pipe_handles[1], fdopen_mode));
+    if (!pipe_stream)
+        return nullptr;
+
+    // Obtain a proces handle pair in which to store the process handle:
+    unique_process_handle_pair id_pair(idtab(nullptr));
+    if (!id_pair)
+        return nullptr;
+
+    // Determine which command processor to use:  command.com or cmd.exe:
+    static Character const default_cmd_exe[] = { 'c', 'm', 'd', '.', 'e', 'x', 'e', '\0' };
+
+    __crt_unique_heap_ptr<Character const> const comspec_variable(get_comspec<Character>());
+    Character const* const cmd_exe = comspec_variable.get() != nullptr
+        ? comspec_variable.get()
+        : default_cmd_exe;
+
+    STARTUPINFOW startup_info = { 0 };
+    startup_info.cb = sizeof(startup_info);
+
+    // The following arguments are used by the OS for duplicating the handles:
+    startup_info.dwFlags = STARTF_USESTDHANDLES;
+    startup_info.hStdInput  = std_fh == STDIN  ? new_pipe_handle.get() : reinterpret_cast<HANDLE>(_osfhnd(0));
+    startup_info.hStdOutput = std_fh == STDOUT ? new_pipe_handle.get() : reinterpret_cast<HANDLE>(_osfhnd(1));
+    startup_info.hStdError  = reinterpret_cast<HANDLE>(_osfhnd(2));
+
+    static Character const slash_c[] = { ' ', '/', 'c', ' ', '\0' };
+
+    size_t const command_line_count =
+        stdio_traits::tcslen(cmd_exe) +
+        stdio_traits::tcslen(slash_c) +
+        stdio_traits::tcslen(command) +
+        1;
+
+    __crt_unique_heap_ptr<Character> const command_line(_calloc_crt_t(Character, command_line_count));
+    if (command_line.get() == nullptr)
+        return nullptr;
+
+    _ERRCHECK(stdio_traits::tcscpy_s(command_line.get(), command_line_count, cmd_exe));
+    _ERRCHECK(stdio_traits::tcscat_s(command_line.get(), command_line_count, slash_c));
+    _ERRCHECK(stdio_traits::tcscat_s(command_line.get(), command_line_count, command));
+
+    // Find the path at which the executable is accessible:
+    Character const* const selected_cmd_exe(get_executable_path(cmd_exe));
+    if (selected_cmd_exe == nullptr)
+        return nullptr;
+
+    // If get_executable_path() returned a path other than the one we gave it,
+    // we must be sure to free the string when we return:
+    __crt_unique_heap_ptr<Character const> const owned_final_exe_path(selected_cmd_exe != cmd_exe
+        ? selected_cmd_exe
+        : nullptr);
+
+    PROCESS_INFORMATION process_info = PROCESS_INFORMATION();
+    BOOL const child_status = stdio_traits::create_process(
+        selected_cmd_exe,
+        command_line.get(),
+        nullptr,
+        nullptr,
+        TRUE,
+        0,
+        nullptr,
+        nullptr,
+        &startup_info,
+        &process_info);
+
+    if (!child_status)
+        return nullptr;
+
+    FILE* const result_stream = pipe_stream.detach();
+
+    CloseHandle(process_info.hThread);
+    id_pair.get()->process_handle = reinterpret_cast<intptr_t>(process_info.hProcess);
+    id_pair.get()->stream         = result_stream;
+    id_pair.detach();
+    return result_stream;
+}
+
+
+
+template <typename Character>
+static FILE* __cdecl common_popen(
+    Character const* const command,
+    Character const* const type
+    ) throw()
+{
+    _VALIDATE_RETURN(command != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(type    != nullptr, EINVAL, nullptr);
+
+    fdopen_mode<Character> const fdopen_mode = convert_popen_type_to_fdopen_mode(type);
+    if (fdopen_mode.mode[0] == '\0')
+        return nullptr;
+
+    // Do the _pipe().  Note that neither of the resulting handles is inheritable.
+    int pipe_mode = _O_NOINHERIT;
+    if (fdopen_mode.mode[1] == 't') { pipe_mode |= _O_TEXT;   }
+    if (fdopen_mode.mode[1] == 'b') { pipe_mode |= _O_BINARY; }
+
+    int pipe_handles[2];
+    if (_pipe(pipe_handles, 1024, pipe_mode) == -1)
+        return nullptr;
+
+    int const std_fh = fdopen_mode.mode[0] == 'w'
+        ? STDIN
+        : STDOUT;
+
+    int ordered_pipe_handles[] =
+    {
+        std_fh == STDIN ? pipe_handles[0] : pipe_handles[1],
+        std_fh == STDIN ? pipe_handles[1] : pipe_handles[0]
+    };
+
+    FILE* return_value = nullptr;
+
+    __acrt_lock(__acrt_popen_lock);
+    __try
+    {
+        errno_t const saved_errno = errno;
+
+        return_value = common_popen_nolock(
+            command,
+            fdopen_mode.mode,
+            std_fh,
+            ordered_pipe_handles);
+
+        errno = saved_errno;
+
+        if (return_value != nullptr)
+            __leave;
+
+        // If the implementation function returned successfully, everything was
+        // cleaned up except the lock.
+        int* const first = ordered_pipe_handles;
+        int* const last  = first + _countof(ordered_pipe_handles);
+        for (int* it = first; it != last; ++it)
+        {
+            if (*it != -1)
+                _close(*it);
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_popen_lock);
+    }
+
+    return return_value;
+}
+
+
+
+// Starts a child process using the given 'command' and opens a pipe to it, as
+// requested via the 'type'.  If the 'type' string contains an 'r', the calling
+// process can read the child command's standard output via the returned stream.
+// If the 'type' string contains a 'w', the calling process can write to the
+// child command's standard input via the returned stream.
+//
+// Returns a usable stream on success; returns null on failure.
+extern "C" FILE* __cdecl _popen(
+    char const* const command,
+    char const* const type
+    )
+{
+    return common_popen(command, type);
+}
+
+
+
+extern "C" FILE* __cdecl _wpopen(
+    wchar_t const* const command,
+    wchar_t const* const type
+    )
+{
+    return common_popen(command, type);
+}
+
+
+
+// Waits on the child command with which the 'stream' is associated, then closes
+// the stream and its associated pipe.  The 'stream' must have been returned from
+// a previous call to _popen().  This function looks up the process handle in the
+// global table, waits on it, then closes the stream.
+//
+// On success, the exit status of the child command is returned.  The format of
+// the return value is the same as for cwait(), except that the low order and
+// high order bytes are swapped.  If an error occurs, -1 is returned.
+extern "C" int __cdecl _pclose(FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, -1);
+
+    int return_value = -1;
+
+    __acrt_lock(__acrt_popen_lock);
+    __try
+    {
+        process_handle_pair* const id_pair = idtab(stream);
+        if (id_pair == nullptr)
+        {
+            errno = EBADF;
+            __leave;
+        }
+
+        fclose(stream);
+
+        intptr_t const process_handle = id_pair->process_handle;
+
+        // Mark the id pair as free (we will close the handle in the call to _cwait):
+        id_pair->stream         = nullptr;
+        id_pair->process_handle = 0;
+
+        // Wait on the child copy of the command processor and its children:
+        errno_t const saved_errno = errno;
+        errno = 0;
+
+        int status = 0;
+        if (_cwait(&status, process_handle, _WAIT_GRANDCHILD) != -1 || errno == EINTR)
+        {
+            errno = saved_errno;
+            return_value = status;
+            __leave;
+        }
+
+        errno = saved_errno;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_popen_lock);
+    }
+
+    return return_value;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putch.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e75c244a59a16ade4f46c9abb49f4653ef8de97c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putch.cpp	
@@ -0,0 +1,82 @@
+//
+// putch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _putch(), which writes a character to the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stdlib.h>
+
+// Writes a wide character to the console.  Returns the character on success,
+// EOF on failure.
+extern "C" int __cdecl _putch(int const c)
+{
+    return __acrt_lock_and_call(__acrt_conio_lock, [&]
+    {
+        return _putch_nolock(c);
+    });
+}
+
+extern "C" int __cdecl _putch_nolock_internal(int const c, __crt_cached_ptd_host& ptd)
+{
+    __acrt_ptd*     const raw_ptd      = ptd.get_raw_ptd();
+    unsigned char*  const ch_buf       = raw_ptd->_putch_buffer;
+    unsigned short* const pch_buf_used = &raw_ptd->_putch_buffer_used;
+
+    // We can only use the character directly if we are sure that the machine
+    // is big-endian.
+    int result = c;
+
+    // Why are we using putwch to write to Console when we could have
+    // written straight away to Console? The problem we have in writing to
+    // Console is that CRT codepage is different from Console codepage and
+    // thus to write to console, we will need to convert the codepage. Here
+    // we can use unicode version of these routines and this way we will
+    // only have to do one conversion and rest will be handled by putwch.
+
+    // The usual way people call putch is character by character. Also
+    // there is no way we can convert partial MBCS to unicode character. To
+    // address this issue, we buffer all the lead bytes and combine them
+    // with trail bytes and then do the conversion.
+    if (*pch_buf_used == 1)
+    {
+        _ASSERTE(isleadbyte(ch_buf[0]) != 0);
+
+        ch_buf[1] = static_cast<unsigned char>(c);
+    }
+    else
+    {
+        ch_buf[0] = static_cast<unsigned char>(c);
+    }
+
+    if (*pch_buf_used == 0 && isleadbyte(ch_buf[0]))
+    {
+        // We still need trail byte, wait for it.
+        *pch_buf_used = 1;
+    }
+    else
+    {
+        wchar_t wchar;
+        if (_mbtowc_internal(&wchar, reinterpret_cast<char const*>(ch_buf), *pch_buf_used + 1, ptd) == -1 ||
+            _putwch_nolock(wchar) == WEOF)
+        {
+            result = EOF;
+        }
+
+        // Since we have processed full MBCS character, we should reset ch_buf_used.
+        *pch_buf_used = 0;
+    }
+
+    return result;
+}
+
+extern "C" int __cdecl _putch_nolock(int const c)
+{
+     __crt_cached_ptd_host ptd;
+     return _putch_nolock_internal(c, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putwch.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putwch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b4f70c8977856b859faa227a2e7e1ca9b028ce1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/conio/putwch.cpp	
@@ -0,0 +1,39 @@
+//
+// putwch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _putwch(), which writes a wide character to the console.
+//
+#include <conio.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+// Writes a wide character to the console.  Returns the character on success,
+// WEOF on failure.
+extern "C" wint_t __cdecl _putwch(wchar_t const c)
+{
+    return __acrt_lock_and_call(__acrt_conio_lock, [&]
+    {
+        return _putwch_nolock(c);
+    });
+}
+
+extern "C" wint_t __cdecl _putwch_nolock(wchar_t const c)
+{
+    if (__dcrt_lowio_ensure_console_output_initialized() == FALSE)
+        return WEOF;
+
+    // Write character to console:
+    DWORD charsWritten;
+    if (__dcrt_write_console(&c, 1, &charsWritten) == FALSE)
+        return WEOF;
+
+    return c;
+}
+
+extern "C" wint_t __cdecl _putwch_nolock_internal(wchar_t const c, __crt_cached_ptd_host&)
+{
+    // Currently _putwch_nolock does not require any PTD access. Do not need to propagate __crt_cached_ptd_host&.
+    return _putwch_nolock(c);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_ctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_ctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86e7e21b2458d5c627d40d48604e5f8b59beeba0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_ctype.cpp	
@@ -0,0 +1,254 @@
+//
+// _ctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the function equivalents of the character classification macros in
+// <ctype.h>.  These function definitions make use of the macros.  The functions
+// return zero if the character does not meet the requirements, and nonzero if
+// the character does meet the requirements.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+// The ctype functions (isalnum(), isupper(), etc) are very small and quick.
+// Optimizing for size has a measurable negative impact, so we optimize for speed here.
+#pragma optimize("t", on)
+
+static __forceinline int fast_check_initial_locale(int const c, int const mask) throw()
+{
+    #ifdef _DEBUG
+    return _chvalidator(c, mask);
+    #else
+    return __acrt_locale_get_ctype_array_value(__acrt_initial_locale_data._public._locale_pctype, c, mask);
+    #endif
+}
+
+static __forceinline int fast_check_current_locale(int const c, int const mask) throw()
+{
+    // Avoid PTD lookup when locale is unchanged.
+    if (!__acrt_locale_changed())
+    {
+        return fast_check_initial_locale(c, mask);
+    }
+
+    // Avoid _LocaleUpdate overhead:
+    // * Extra un-inlined function calls
+    // * Multibyte locale synchronization
+    // * Marking/unmarking current thread as using per-thread-locales.
+
+    __acrt_ptd * const ptd{__acrt_getptd()};
+    __crt_locale_data * locale_info{ptd->_locale_info};
+    __acrt_update_locale_info(ptd, &locale_info);
+
+    // Common case
+    if (c >= -1 && c <= 255)
+    {
+        return locale_info->_public._locale_pctype[c] & mask;
+    }
+
+    // Microsoft Extension: Translate int values outside of unsigned char range for DBCS locales
+    // Note that our documentation also clearly states this is undefined.
+    if (locale_info->_public._locale_mb_cur_max > 1)
+    {
+        return _isctype_l(c, mask, nullptr);
+    }
+
+    return 0;
+}
+
+static __forceinline int fast_check_given_locale(int const c, int const mask, _locale_t const locale) throw()
+{
+    // Avoid _LocaleUpdate overhead - just check whether it's nullptr.
+    if (locale == nullptr) {
+        return fast_check_current_locale(c, mask);
+    }
+
+    // Common case
+    if (c >= -1 && c <= 255)
+    {
+        return locale->locinfo->_public._locale_pctype[c] & mask;
+    }
+
+    // Microsoft Extension: Translate int values outside of unsigned char range for DBCS locales
+    // Note that our documentation also clearly states this is undefined.
+    if (locale->locinfo->_public._locale_mb_cur_max > 1)
+    {
+        return _isctype_l(c, mask, locale);
+    }
+
+    return 0;
+}
+
+
+extern "C" int (__cdecl _isalpha_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _ALPHA, locale);
+}
+
+extern "C" int (__cdecl isalpha)(int const c)
+{
+    return fast_check_current_locale(c, _ALPHA);
+}
+
+
+extern "C" int (__cdecl _isupper_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _UPPER, locale);
+}
+
+extern "C" int (__cdecl isupper)(int const c)
+{
+    return fast_check_current_locale(c, _UPPER);
+}
+
+
+extern "C" int (__cdecl _islower_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _LOWER, locale);
+}
+
+extern "C" int (__cdecl islower)(int const c)
+{
+    return fast_check_current_locale(c, _LOWER);
+}
+
+
+extern "C" int (__cdecl _isdigit_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isdigit)(int const c)
+{
+    return fast_check_current_locale(c, _DIGIT);
+}
+
+
+extern "C" int (__cdecl _isxdigit_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _HEX, locale);
+}
+
+extern "C" int (__cdecl isxdigit)(int const c)
+{
+    return fast_check_current_locale(c, _HEX);
+}
+
+
+extern "C" int (__cdecl _isspace_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _SPACE, locale);
+}
+
+extern "C" int (__cdecl isspace)(int const c)
+{
+    return fast_check_current_locale(c, _SPACE);
+}
+
+
+extern "C" int (__cdecl _ispunct_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _PUNCT, locale);
+}
+
+extern "C" int (__cdecl ispunct)(int const c)
+{
+    return fast_check_current_locale(c, _PUNCT);
+}
+
+
+extern "C" int (__cdecl _isblank_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _BLANK, locale);
+}
+
+extern "C" int (__cdecl isblank)(int const c)
+{
+    // \t is a blank character, but is not registered as _Blank on the table, because that will make it
+    //printable. Also Windows (via GetStringType()) considered all _BLANK characters to also be _PRINT characters,
+    //so does not have a way to specify blank, non-printable.
+    if (c == '\t') {
+        return _BLANK;
+    }
+
+    return fast_check_current_locale(c, _BLANK);
+}
+
+
+extern "C" int (__cdecl _isalnum_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _ALPHA | _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isalnum)(int const c)
+{
+    return fast_check_current_locale(c, _ALPHA | _DIGIT);
+}
+
+
+extern "C" int (__cdecl _isprint_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _BLANK | _PUNCT | _ALPHA | _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isprint)(int const c)
+{
+    return fast_check_current_locale(c, _BLANK | _PUNCT | _ALPHA | _DIGIT);
+}
+
+
+extern "C" int (__cdecl _isgraph_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _PUNCT | _ALPHA | _DIGIT, locale);
+}
+
+extern "C" int (__cdecl isgraph)(int const c)
+{
+    return fast_check_current_locale(c, _PUNCT | _ALPHA | _DIGIT);
+}
+
+
+extern "C" int (__cdecl _iscntrl_l)(int const c, _locale_t const locale)
+{
+    return fast_check_given_locale(c, _CONTROL, locale);
+}
+
+extern "C" int (__cdecl iscntrl)(int const c)
+{
+    return fast_check_current_locale(c, _CONTROL);
+}
+
+
+extern "C" int (__cdecl __isascii)(int const c)
+{
+    return __isascii(c);
+}
+
+extern "C" int (__cdecl __toascii)(int const c)
+{
+    return __toascii(c);
+}
+
+
+extern "C" int (__cdecl _iscsymf_l)(int const c, _locale_t const locale)
+{
+    return (_isalpha_l)(c, locale) || c == '_';
+}
+
+extern "C" int (__cdecl __iscsymf)(int const c)
+{
+    return __iscsymf(c);
+}
+
+
+extern "C" int (__cdecl _iscsym_l)(int const c, _locale_t const locale)
+{
+    return (_isalnum_l)(c, locale) || c == '_';
+}
+
+extern "C" int (__cdecl __iscsym)(int const c)
+{
+    return __iscsym(static_cast<unsigned char>(c));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_fptostr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_fptostr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..025d8c9c2eef55bcaf562553b6ac3c738e535799
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_fptostr.cpp	
@@ -0,0 +1,173 @@
+//
+// _fptostr.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the internal function that writes a mantissa (in a STRFLT) into a
+// buffer.  This function puts all of the digits into the buffer, handles
+// rounding based on the requested precision (digits), and updates the decimal
+// point position in the STRFLT object.  Note that this function does not change
+// the mantissa field of the STRFLT, so callers of this function may rely on it
+// being unmodified.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <fenv.h>
+#include <string.h>
+#include <stddef.h>
+
+// __acrt_has_trailing_digits::no_trailing isn't indicative of how to round if we're rounding to a point before the end of the generated digits.
+// __acrt_has_trailing_digits::no_trailing only says if there are any digits after the mantisa we got.
+// We need to ensure the remaining generated digits are all zero before choosing rounds-to-even behavior intended for exactly representable floating point numbers.
+static bool check_trailing(char const * mantissa_it, __acrt_has_trailing_digits const trailing_digits)
+{
+    if (trailing_digits == __acrt_has_trailing_digits::trailing)
+    {
+        return true;
+    }
+
+    while (*mantissa_it == '0')
+    {
+        mantissa_it++;
+    }
+
+    if (*mantissa_it != '\0')
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static bool should_round_up(
+    char const *               const mantissa_base,
+    char const *               const mantissa_it,
+    int                        const sign,
+    __acrt_has_trailing_digits const trailing_digits,
+    __acrt_rounding_mode       const rounding_mode
+)
+{
+    if (rounding_mode == __acrt_rounding_mode::legacy)
+    {
+        return *mantissa_it >= '5';
+    }
+
+    int const round_mode = fegetround();
+
+    if (round_mode == FE_TONEAREST)
+    {
+        if (*mantissa_it > '5')
+        {
+            return true;
+        }
+
+        if (*mantissa_it < '5')
+        {
+            return false;
+        }
+
+        // If there are trailing digits we are in a scenario like this .5000000001 and should round up
+        if (check_trailing(mantissa_it + 1, trailing_digits))
+        {
+            return true;
+        }
+
+        // At this point, the number is exactly representable and we are rounding 5.
+        // In this case, IEEE 754 states to round towards the nearest even number.
+        // Therefore: if the previous digit is odd, we round up (1.5 -> 2).
+        //            if the previous digit is even, we round down (2.5 -> 2).
+
+        // If there is no preceding digit, it is considered zero, so round down.
+        if (mantissa_it == mantissa_base)
+        {
+            return false;
+        }
+
+        // If the previous digit is odd, we should round up to the closest even.
+        return *(mantissa_it - 1) % 2;
+    }
+
+    if (round_mode == FE_UPWARD)
+    {
+        return check_trailing(mantissa_it, trailing_digits) && sign != '-';
+    }
+
+    if (round_mode == FE_DOWNWARD)
+    {
+        return check_trailing(mantissa_it, trailing_digits) && sign == '-';
+    }
+
+    return false;
+}
+
+extern "C" errno_t __cdecl __acrt_fp_strflt_to_string(
+    char*                        const buffer,
+    size_t                       const buffer_count,
+    int                                digits,
+    STRFLT                       const pflt,
+    __acrt_has_trailing_digits   const trailing_digits,
+    __acrt_rounding_mode         const rounding_mode,
+    __crt_cached_ptd_host&             ptd
+)
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > 0,  EINVAL);
+    buffer[0] = '\0';
+
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > static_cast<size_t>((digits > 0 ? digits : 0) + 1), ERANGE);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, pflt != nullptr, EINVAL);
+
+    char* buffer_it           = buffer;
+    char* const mantissa_base = pflt->mantissa;
+    char* mantissa_it         = pflt->mantissa;
+
+    // The buffer will contain 'digits' decimal digits plus an optional overflow
+    // digit for the rounding.
+
+    // Initialize the first digit in the buffer to '0' (Note: not '\0') and set
+    // the pointer to the second digit of the buffer.  The first digit is used
+    // to handle overflow on rounding (e.g. 9.999... becomes 10.000...), which
+    // requires a carry into the first digit.
+    *buffer_it++ = '0';
+
+    // Copy the digits of the value into the buffer (with '0' padding) and
+    // insert the null terminator:
+    while (digits > 0)
+    {
+        *buffer_it++ = *mantissa_it ? *mantissa_it++ : '0';
+        --digits;
+    }
+
+    *buffer_it = '\0';
+
+    // Do any rounding which may be needed.  Note:  if digits < 0, we don't do
+    // any rounding because in this case, the rounding occurs in a digit which
+    // will not be output because of the precision requested.
+    if (digits >= 0 && should_round_up(mantissa_base, mantissa_it, pflt->sign, trailing_digits, rounding_mode))
+    {
+        buffer_it--;
+
+        while (*buffer_it == '9')
+        {
+            *buffer_it-- = '0';
+        }
+
+        *buffer_it += 1;
+    }
+
+    if (*buffer == '1')
+    {
+        // The rounding caused overflow into the leading digit (e.g. 9.999...
+        // became 10.000...), so increment the decimal point position by 1:
+        pflt->decpt++;
+    }
+    else
+    {
+        // Move the entire string to the left one digit to remove the unused
+        // overflow digit:
+        memmove(buffer, buffer + 1, strlen(buffer + 1) + 1);
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_mbslen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_mbslen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9954bccb74fd298dcaa124c13848194700a2621
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_mbslen.cpp	
@@ -0,0 +1,119 @@
+//
+// _mbslen.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the mbstrlen functions, which return the number of multibyte
+// characters in a multibyte string, excluding the null terminator.  This
+// function is locale-dependent.  If the string contains invalid multibyte
+// characters, -1 is returned and errno is set to EILSEQ.
+//
+// There are two variations of these functions:  mbstrnlen (note the 'n'),
+// which takes a max_size, which is the maximum number of bytes to scan
+// in the string.  These variations also validate their arguments.  The
+// variations without the 'n' (mbstrlen) stop only when the null terminator
+// is reached and do not validate their arguments.
+//
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+
+
+_Check_return_
+_Post_satisfies_((return <= _String_length_(string) && return <= max_size) || return == (size_t)-1)
+static size_t __cdecl common_mbstrlen_l(
+    char const* const string,
+    size_t      const max_size,
+    _locale_t   const locale
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    _ASSERTE(
+        locale_update.GetLocaleT()->locinfo->_public._locale_mb_cur_max == 1 ||
+        locale_update.GetLocaleT()->locinfo->_public._locale_mb_cur_max == 2);
+
+    // Handle single byte character sets:
+    if (locale_update.GetLocaleT()->locinfo->_public._locale_mb_cur_max == 1)
+    {
+        return strnlen(string, max_size);
+    }
+
+    // Verify that all of the multibyte characters are valid:
+    if (__acrt_MultiByteToWideChar(
+            locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            string,
+            static_cast<int>(max_size),
+            nullptr,
+            0
+        ) == 0)
+    {
+        // There was a bad multibyte character:
+        errno = EILSEQ;
+        return static_cast<size_t>(-1);
+    }
+
+    // Count multibyte characters:
+    size_t n    = 0; // Number of multibyte characters read
+    size_t size = 0; // Number of bytes read
+    for (char const* it = string; size < max_size && *it; ++n, ++it, ++size)
+    {
+        if (_isleadbyte_fast_internal(static_cast<unsigned char>(*it), locale_update.GetLocaleT()))
+        {
+            ++size;
+            if (size >= max_size)
+                break;
+
+            ++it;
+            if (*it == '\0')
+                break;
+        }
+    }
+
+    return size >= max_size ? max_size : n;
+}
+
+
+
+extern "C" size_t __cdecl _mbstrlen_l(
+    char const* const string,
+    _locale_t   const locale
+    )
+{
+    return common_mbstrlen_l(string, _CRT_UNBOUNDED_BUFFER_SIZE, locale);
+}
+
+extern "C" size_t __cdecl _mbstrlen(char const* const string)
+{
+    if (!__acrt_locale_changed())
+    {
+        return strlen(string);
+    }
+    else
+    {
+        return _mbstrlen_l(string, nullptr);
+    }
+}
+
+
+
+extern "C" size_t __cdecl _mbstrnlen_l(
+    char const* const string,
+    size_t      const max_size,
+    _locale_t   const locale
+    )
+{
+    _VALIDATE_RETURN(string != nullptr,   EINVAL, static_cast<size_t>(-1));
+    _VALIDATE_RETURN(max_size <= INT_MAX, EINVAL, static_cast<size_t>(-1));
+
+    return common_mbstrlen_l(string, max_size, locale);
+}
+
+extern "C" size_t __cdecl _mbstrnlen(
+    char const* const string,
+    size_t      const max_size
+    )
+{
+    return _mbstrnlen_l(string, max_size, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_wctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_wctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0541acb57402af205d7106ab3f380f49ae0f416e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/_wctype.cpp	
@@ -0,0 +1,171 @@
+//
+// _wctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the function equivalents of the wide character classification macros
+// in <ctype.h>.  These function definitions make use of the macros.  The
+// functions return zero if the character does not meet the requirements, and
+// nonzero if the character does meet the requirements.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+
+
+extern "C" extern __inline int (__cdecl _isleadbyte_l)(int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+    return __acrt_locale_get_ctype_array_value(locale_update.GetLocaleT()->locinfo->_public._locale_pctype, c, _LEADBYTE);
+}
+
+extern "C" extern __inline int (__cdecl isleadbyte)(int const c)
+{
+    return (_isleadbyte_l)(c, nullptr);
+}
+
+extern "C" extern __inline int (__cdecl _iswalpha_l)(wint_t const c, _locale_t)
+{
+    return iswalpha(c);
+}
+
+extern "C" extern __inline int (__cdecl iswalpha)(wint_t const c)
+{
+    return iswalpha(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswupper_l)(wint_t const c, _locale_t)
+{
+    return iswupper(c);
+}
+
+extern "C" extern __inline int (__cdecl iswupper)(wint_t const c)
+{
+    return iswupper(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswlower_l)(wint_t const c, _locale_t)
+{
+    return iswlower(c);
+}
+
+extern "C" extern __inline int (__cdecl iswlower)(wint_t const c)
+{
+    return iswlower(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswdigit_l)(wint_t const c, _locale_t)
+{
+    return iswdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl iswdigit)(wint_t const c)
+{
+    return iswdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswxdigit_l)(wint_t const c, _locale_t)
+{
+    return iswxdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl iswxdigit)(wint_t const c)
+{
+    return iswxdigit(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswspace_l)(wint_t const c, _locale_t)
+{
+    return iswspace(c);
+}
+
+extern "C" extern __inline int (__cdecl iswspace)(wint_t const c)
+{
+    return iswspace(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswpunct_l)(wint_t const c, _locale_t)
+{
+    return iswpunct(c);
+}
+
+extern "C" extern __inline int (__cdecl iswpunct)(wint_t const c)
+{
+    return iswpunct(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswblank_l)(wint_t const c, _locale_t)
+{
+    return iswblank(c);
+}
+
+extern "C" extern __inline int (__cdecl iswblank)(wint_t const c)
+{
+    return iswblank(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswalnum_l)(wint_t const c, _locale_t)
+{
+    return iswalnum(c);
+}
+
+extern "C" extern __inline int (__cdecl iswalnum)(wint_t const c)
+{
+    return iswalnum(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswprint_l)(wint_t const c, _locale_t)
+{
+    return iswprint(c);
+}
+
+extern "C" extern __inline int (__cdecl iswprint)(wint_t const c)
+{
+    return iswprint(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswgraph_l)(wint_t const c, _locale_t)
+{
+    return iswgraph(c);
+}
+
+extern "C" extern __inline int (__cdecl iswgraph)(wint_t const c)
+{
+    return iswgraph(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswcntrl_l)(wint_t const c, _locale_t)
+{
+    return iswcntrl(c);
+}
+
+extern "C" extern __inline int (__cdecl iswcntrl)(wint_t const c)
+{
+    return iswcntrl(c);
+}
+
+extern "C" extern __inline int (__cdecl iswascii)(wint_t const c)
+{
+    return iswascii(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswcsym_l)(wint_t const c, _locale_t)
+{
+    return __iswcsym(c);
+}
+
+extern "C" extern __inline int (__cdecl __iswcsym)(wint_t const c)
+{
+    return __iswcsym(c);
+}
+
+extern "C" extern __inline int (__cdecl _iswcsymf_l)(wint_t const c, _locale_t)
+{
+    return __iswcsymf(c);
+}
+
+extern "C" extern __inline int (__cdecl __iswcsymf)(wint_t const c)
+{
+    return __iswcsymf(c);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atof.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atof.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b1f4294a423276905516a2c575f09d780cd280d2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atof.cpp	
@@ -0,0 +1,96 @@
+//
+// atof.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of the functions that convert strings to floating point numbers.
+// Note that the str- and wcs-prefixed functions are defined elsewhere.  The
+// functions defined here are provided for legacy support.
+//
+// The _atoxxx family of functions convert a string into a floating point
+// number and return either zero (success), or _UNDERFLOW or _OVERFLOW.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_strtox.h>
+
+
+
+template <typename FloatingType, typename Character>
+static int __cdecl common_atodbl_l(
+    FloatingType*    const result,
+    Character const* const string,
+    _locale_t        const locale
+    ) throw()
+{
+    _VALIDATE_RETURN(result != nullptr, EINVAL, _DOMAIN);
+
+    _LocaleUpdate locale_update(locale);
+    SLD_STATUS const status = __crt_strtox::parse_floating_point(
+        locale_update.GetLocaleT(),
+        __crt_strtox::make_c_string_character_source(string, nullptr),
+        result);
+
+    switch (status)
+    {
+    case SLD_OVERFLOW:  return _OVERFLOW;
+    case SLD_UNDERFLOW: return _UNDERFLOW;
+    default:            return 0;
+    }
+}
+
+extern "C" int __cdecl _atoflt_l(_CRT_FLOAT* const result, char const* const string, _locale_t const locale)
+{
+    return common_atodbl_l(&result->f, string, locale);
+}
+
+extern "C" int __cdecl _atoflt(_CRT_FLOAT* const result, char const* const string)
+{
+    return common_atodbl_l(&result->f, string, nullptr);
+}
+
+extern "C" int __cdecl _atodbl_l(_CRT_DOUBLE* const result, char* const string, _locale_t const locale)
+{
+    return common_atodbl_l(&result->x, string, locale);
+}
+
+extern "C" int __cdecl _atodbl(_CRT_DOUBLE* const result, char* const string)
+{
+    return common_atodbl_l(&result->x, string, nullptr);
+}
+
+
+
+template <typename Character>
+static double __cdecl common_atof_l(Character const* const string, _locale_t const locale) throw()
+{
+    _VALIDATE_RETURN(string != nullptr, EINVAL, 0.0);
+
+    _LocaleUpdate locale_update(locale);
+
+    double result{};
+    __crt_strtox::parse_floating_point(
+        locale_update.GetLocaleT(),
+        __crt_strtox::make_c_string_character_source(string, nullptr),
+        &result);
+    return result;
+}
+
+extern "C" double __cdecl _atof_l(char const* const string, _locale_t const locale)
+{
+    return common_atof_l(string, locale);
+}
+
+extern "C" double __cdecl atof(char const* const string)
+{
+    return common_atof_l(string, nullptr);
+}
+
+extern "C" double __cdecl _wtof_l(wchar_t const* const string, _locale_t const locale)
+{
+    return common_atof_l(string, locale);
+}
+
+extern "C" double __cdecl _wtof(wchar_t const* const string)
+{
+    return common_atof_l(string, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atoldbl.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atoldbl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed7e70c4967a1270177b45aa4f70e6e680693c45
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atoldbl.cpp	
@@ -0,0 +1,833 @@
+//
+// atoldbl.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _atoldbl and _atoldbl_l functions, which convert a string representation
+// of a floating point number into a 10-byte _LDOUBLE object.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_strtox.h>
+#include <float.h>
+#include <locale.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+#define PTR_12(x) ((uint8_t*)(&(x)->ld12))
+
+#define MSB_USHORT  ((uint16_t)     0x8000)
+#define MSB_ULONG   ((uint32_t) 0x80000000)
+
+#define TMAX10  5200       /* maximum temporary decimal exponent */
+#define TMIN10 -5200       /* minimum temporary decimal exponent */
+#define LD_MAX_EXP_LEN   4 /* maximum number of decimal exponent digits */
+#define LD_MAX_MAN_LEN  24 /* maximum length of mantissa (decimal)*/
+#define LD_MAX_MAN_LEN1 25 /* MAX_MAN_LEN+1 */
+
+#define LD_BIAS   0x3fff  /* exponent bias for long double */
+#define LD_BIASM1 0x3ffe  /* LD_BIAS - 1 */
+#define LD_MAXEXP 0x7fff  /* maximum biased exponent */
+
+#define D_BIAS   0x3ff  /* exponent bias for double */
+#define D_BIASM1 0x3fe  /* D_BIAS - 1 */
+#define D_MAXEXP 0x7ff  /* maximum biased exponent */
+
+// Macros for manipulation of a 12-byte long double number (an ordinary 10-byte
+// long double plus two extra bytes of mantissa).
+// byte layout:
+//
+//              +-----+--------+--------+-------+
+//              |XT(2)|MANLO(4)|MANHI(4)|EXP(2) |
+//              +-----+--------+--------+-------+
+//              |<-UL_LO->|<-UL_MED->|<-UL_HI ->|
+//                  (4)       (4)        (4)
+#define ALIGN(x) ((unsigned long _UNALIGNED*)(x))
+
+#define U_EXP_12(p)    ((uint16_t           *)(PTR_12(p) + 10))
+#define UL_MANHI_12(p) ((uint32_t _UNALIGNED*)(PTR_12(p) +  6))
+#define UL_MANLO_12(p) ((uint32_t _UNALIGNED*)(PTR_12(p) +  2))
+#define U_XT_12(p)     ((uint16_t           *)(PTR_12(p)     ))
+
+// Pointers to the four low, mid, and high order bytes of the extended mantissa
+#define UL_LO_12(p)  ((uint32_t*)(PTR_12(p)    ))
+#define UL_MED_12(p) ((uint32_t*)(PTR_12(p) + 4))
+#define UL_HI_12(p)  ((uint32_t*)(PTR_12(p) + 8))
+
+// Pointers to the uint8_t, uint16_t, and uint32_t of order i (LSB = 0; MSB = 9)
+#define UCHAR_12(p, i)   ((uint8_t *)(          PTR_12(p) + (i)))
+#define USHORT_12(p, i)  ((uint16_t*)((uint8_t*)PTR_12(p) + (i)))
+#define ULONG_12(p, i)   ((uint32_t*)((uint8_t*)PTR_12(p) + (i)))
+#define TEN_BYTE_PART(p) ((uint8_t *)(          PTR_12(p) +  2 ))
+
+// Manipulation of a 10-byte long double number
+#define U_EXP_LD(p)    ((uint16_t*)(_PTR_LD(p) + 8))
+#define UL_MANHI_LD(p) ((uint32_t*)(_PTR_LD(p) + 4))
+#define UL_MANLO_LD(p) ((uint32_t*)(_PTR_LD(p)    ))
+
+// Manipulation of a 64bit IEEE double
+#define U_SHORT4_D(p) ((uint16_t*)(p) + 3)
+#define UL_HI_D(p)    ((uint32_t*)(p) + 1)
+#define UL_LO_D(p)    ((uint32_t*)(p)    )
+
+#define PUT_INF_12(p, sign)                           \
+    *UL_HI_12 (p) = (sign) ? 0xffff8000 : 0x7fff8000; \
+    *UL_MED_12(p) = 0;                                \
+    *UL_LO_12 (p) = 0;
+
+#define PUT_ZERO_12(p) \
+    *UL_HI_12 (p) = 0; \
+    *UL_MED_12(p) = 0; \
+    *UL_LO_12 (p) = 0;
+
+#define ISZERO_12(p) \
+    ((*UL_HI_12 (p) & 0x7fffffff) == 0 && \
+      *UL_MED_12(p)               == 0 && \
+      *UL_LO_12 (p)               == 0)
+
+#define PUT_INF_LD(p, sign)                     \
+    *U_EXP_LD   (p) = (sign) ? 0xffff : 0x7fff; \
+    *UL_MANHI_LD(p) = 0x8000;                   \
+    *UL_MANLO_LD(p) = 0;
+
+#define PUT_ZERO_LD(p)   \
+    *U_EXP_LD   (p) = 0; \
+    *UL_MANHI_LD(p) = 0; \
+    *UL_MANLO_LD(p) = 0;
+
+#define ISZERO_LD(p)                    \
+    ((*U_EXP_LD   (p) & 0x7fff) == 0 && \
+      *UL_MANHI_LD(p)           == 0 && \
+      *UL_MANLO_LD(p)           == 0)
+
+
+
+static _LDBL12 const ld12_pow10_positive[] =
+{
+    /*P0001*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA0,0x02,0x40}},
+    /*P0002*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC8,0x05,0x40}},
+    /*P0003*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFA,0x08,0x40}},
+    /*P0004*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x9C,0x0C,0x40}},
+    /*P0005*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x50,0xC3,0x0F,0x40}},
+    /*P0006*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x24,0xF4,0x12,0x40}},
+    /*P0007*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x80,0x96,0x98,0x16,0x40}},
+    /*P0008*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x20,0xBC,0xBE,0x19,0x40}},
+    /*P0016*/ {{0x00,0x00, 0x00,0x00,0x00,0x04,0xBF,0xC9,0x1B,0x8E,0x34,0x40}},
+    /*P0024*/ {{0x00,0x00, 0x00,0xA1,0xED,0xCC,0xCE,0x1B,0xC2,0xD3,0x4E,0x40}},
+    /*P0032*/ {{0x20,0xF0, 0x9E,0xB5,0x70,0x2B,0xA8,0xAD,0xC5,0x9D,0x69,0x40}},
+    /*P0040*/ {{0xD0,0x5D, 0xFD,0x25,0xE5,0x1A,0x8E,0x4F,0x19,0xEB,0x83,0x40}},
+    /*P0048*/ {{0x71,0x96, 0xD7,0x95,0x43,0x0E,0x05,0x8D,0x29,0xAF,0x9E,0x40}},
+    /*P0056*/ {{0xF9,0xBF, 0xA0,0x44,0xED,0x81,0x12,0x8F,0x81,0x82,0xB9,0x40}},
+    /*P0064*/ {{0xBF,0x3C, 0xD5,0xA6,0xCF,0xFF,0x49,0x1F,0x78,0xC2,0xD3,0x40}},
+    /*P0128*/ {{0x6F,0xC6, 0xE0,0x8C,0xE9,0x80,0xC9,0x47,0xBA,0x93,0xA8,0x41}},
+    /*P0192*/ {{0xBC,0x85, 0x6B,0x55,0x27,0x39,0x8D,0xF7,0x70,0xE0,0x7C,0x42}},
+    /*P0256*/ {{0xBC,0xDD, 0x8E,0xDE,0xF9,0x9D,0xFB,0xEB,0x7E,0xAA,0x51,0x43}},
+    /*P0320*/ {{0xA1,0xE6, 0x76,0xE3,0xCC,0xF2,0x29,0x2F,0x84,0x81,0x26,0x44}},
+    /*P0384*/ {{0x28,0x10, 0x17,0xAA,0xF8,0xAE,0x10,0xE3,0xC5,0xC4,0xFA,0x44}},
+    /*P0448*/ {{0xEB,0xA7, 0xD4,0xF3,0xF7,0xEB,0xE1,0x4A,0x7A,0x95,0xCF,0x45}},
+    /*P0512*/ {{0x65,0xCC, 0xC7,0x91,0x0E,0xA6,0xAE,0xA0,0x19,0xE3,0xA3,0x46}},
+    /*P1024*/ {{0x0D,0x65, 0x17,0x0C,0x75,0x81,0x86,0x75,0x76,0xC9,0x48,0x4D}},
+    /*P1536*/ {{0x58,0x42, 0xE4,0xA7,0x93,0x39,0x3B,0x35,0xB8,0xB2,0xED,0x53}},
+    /*P2048*/ {{0x4D,0xA7, 0xE5,0x5D,0x3D,0xC5,0x5D,0x3B,0x8B,0x9E,0x92,0x5A}},
+    /*P2560*/ {{0xFF,0x5D, 0xA6,0xF0,0xA1,0x20,0xC0,0x54,0xA5,0x8C,0x37,0x61}},
+    /*P3072*/ {{0xD1,0xFD, 0x8B,0x5A,0x8B,0xD8,0x25,0x5D,0x89,0xF9,0xDB,0x67}},
+    /*P3584*/ {{0xAA,0x95, 0xF8,0xF3,0x27,0xBF,0xA2,0xC8,0x5D,0xDD,0x80,0x6E}},
+    /*P4096*/ {{0x4C,0xC9, 0x9B,0x97,0x20,0x8A,0x02,0x52,0x60,0xC4,0x25,0x75}}
+};
+
+static _LDBL12 const ld12_pow10_negative[] =
+{
+    /*N0001*/ {{0xCD,0xCC, 0xCD,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFB,0x3F}},
+    /*N0002*/ {{0x71,0x3D, 0x0A,0xD7,0xA3,0x70,0x3D,0x0A,0xD7,0xA3,0xF8,0x3F}},
+    /*N0003*/ {{0x5A,0x64, 0x3B,0xDF,0x4F,0x8D,0x97,0x6E,0x12,0x83,0xF5,0x3F}},
+    /*N0004*/ {{0xC3,0xD3, 0x2C,0x65,0x19,0xE2,0x58,0x17,0xB7,0xD1,0xF1,0x3F}},
+    /*N0005*/ {{0xD0,0x0F, 0x23,0x84,0x47,0x1B,0x47,0xAC,0xC5,0xA7,0xEE,0x3F}},
+    /*N0006*/ {{0x40,0xA6, 0xB6,0x69,0x6C,0xAF,0x05,0xBD,0x37,0x86,0xEB,0x3F}},
+    /*N0007*/ {{0x33,0x3D, 0xBC,0x42,0x7A,0xE5,0xD5,0x94,0xBF,0xD6,0xE7,0x3F}},
+    /*N0008*/ {{0xC2,0xFD, 0xFD,0xCE,0x61,0x84,0x11,0x77,0xCC,0xAB,0xE4,0x3F}},
+    /*N0016*/ {{0x2F,0x4C, 0x5B,0xE1,0x4D,0xC4,0xBE,0x94,0x95,0xE6,0xC9,0x3F}},
+    /*N0024*/ {{0x92,0xC4, 0x53,0x3B,0x75,0x44,0xCD,0x14,0xBE,0x9A,0xAF,0x3F}},
+    /*N0032*/ {{0xDE,0x67, 0xBA,0x94,0x39,0x45,0xAD,0x1E,0xB1,0xCF,0x94,0x3F}},
+    /*N0040*/ {{0x24,0x23, 0xC6,0xE2,0xBC,0xBA,0x3B,0x31,0x61,0x8B,0x7A,0x3F}},
+    /*N0048*/ {{0x61,0x55, 0x59,0xC1,0x7E,0xB1,0x53,0x7C,0x12,0xBB,0x5F,0x3F}},
+    /*N0056*/ {{0xD7,0xEE, 0x2F,0x8D,0x06,0xBE,0x92,0x85,0x15,0xFB,0x44,0x3F}},
+    /*N0064*/ {{0x24,0x3F, 0xA5,0xE9,0x39,0xA5,0x27,0xEA,0x7F,0xA8,0x2A,0x3F}},
+    /*N0128*/ {{0x7D,0xAC, 0xA1,0xE4,0xBC,0x64,0x7C,0x46,0xD0,0xDD,0x55,0x3E}},
+    /*N0192*/ {{0x63,0x7B, 0x06,0xCC,0x23,0x54,0x77,0x83,0xFF,0x91,0x81,0x3D}},
+    /*N0256*/ {{0x91,0xFA, 0x3A,0x19,0x7A,0x63,0x25,0x43,0x31,0xC0,0xAC,0x3C}},
+    /*N0320*/ {{0x21,0x89, 0xD1,0x38,0x82,0x47,0x97,0xB8,0x00,0xFD,0xD7,0x3B}},
+    /*N0384*/ {{0xDC,0x88, 0x58,0x08,0x1B,0xB1,0xE8,0xE3,0x86,0xA6,0x03,0x3B}},
+    /*N0448*/ {{0xC6,0x84, 0x45,0x42,0x07,0xB6,0x99,0x75,0x37,0xDB,0x2E,0x3A}},
+    /*N0512*/ {{0x33,0x71, 0x1C,0xD2,0x23,0xDB,0x32,0xEE,0x49,0x90,0x5A,0x39}},
+    /*N1024*/ {{0xA6,0x87, 0xBE,0xC0,0x57,0xDA,0xA5,0x82,0xA6,0xA2,0xB5,0x32}},
+    /*N1536*/ {{0xE2,0x68, 0xB2,0x11,0xA7,0x52,0x9F,0x44,0x59,0xB7,0x10,0x2C}},
+    /*N2048*/ {{0x25,0x49, 0xE4,0x2D,0x36,0x34,0x4F,0x53,0xAE,0xCE,0x6B,0x25}},
+    /*N2560*/ {{0x8F,0x59, 0x04,0xA4,0xC0,0xDE,0xC2,0x7D,0xFB,0xE8,0xC6,0x1E}},
+    /*N3072*/ {{0x9E,0xE7, 0x88,0x5A,0x57,0x91,0x3C,0xBF,0x50,0x83,0x22,0x18}},
+    /*N3584*/ {{0x4E,0x4B, 0x65,0x62,0xFD,0x83,0x8F,0xAF,0x06,0x94,0x7D,0x11}},
+    /*N4096*/ {{0xE4,0x2D, 0xDE,0x9F,0xCE,0xD2,0xC8,0x04,0xDD,0xA6,0xD8,0x0A}}
+};
+
+
+
+// Adds x and y, storing the result in *sum.  Returns true if overflow occurred;
+// false otherwise.
+static __forceinline bool __cdecl add_uint32_carry(uint32_t const x, uint32_t const y, uint32_t* const sum) throw()
+{
+    uint32_t const r = x + y;
+
+    *sum = r;
+
+    return r < x || r < y; // carry
+}
+
+// Adds *x and *y as 12-byte integers, storing the result in *x.  Overflow is ignored.
+static __forceinline void __cdecl add_ld12(_LDBL12* const x, _LDBL12 const* const y) throw()
+{
+    if (add_uint32_carry(*UL_LO_12(x), *UL_LO_12(y), UL_LO_12(x)))
+    {
+        if (add_uint32_carry(*UL_MED_12(x), 1, UL_MED_12(x)))
+        {
+            ++*UL_HI_12(x);
+        }
+    }
+
+    if (add_uint32_carry(*UL_MED_12(x), *UL_MED_12(y), UL_MED_12(x)))
+    {
+        ++*UL_HI_12(x);
+    }
+
+    // Ignore next carry -- assume no overflow will occur
+    add_uint32_carry(*UL_HI_12(x), *UL_HI_12(y), UL_HI_12(x));
+}
+
+// Shifts *p N bits to the left.  The number is shifted as a 12-byte integer.
+template <uint32_t N>
+static __forceinline void __cdecl shl_ld12(_LDBL12* const p) throw()
+{
+    uint32_t const total_bits{sizeof(uint32_t) * CHAR_BIT};
+    uint32_t const msb_bits{N};
+    uint32_t const lsb_bits{total_bits - N};
+
+    static_assert(msb_bits <= total_bits, "shift too large");
+
+    uint32_t const lsb_mask{(1 << (lsb_bits - 1)) - 1};
+    uint32_t const msb_mask{static_cast<uint32_t>(-1) ^ lsb_mask};
+
+    uint32_t const lo_carry {(*UL_LO_12 (p) & msb_mask) >> lsb_bits};
+    uint32_t const med_carry{(*UL_MED_12(p) & msb_mask) >> lsb_bits};
+
+    *UL_LO_12 (p) = (*UL_LO_12 (p) << msb_bits);
+    *UL_MED_12(p) = (*UL_MED_12(p) << msb_bits) | lo_carry;
+    *UL_HI_12 (p) = (*UL_HI_12 (p) << msb_bits) | med_carry;
+}
+
+// Shifts *p one bit to the right.  The number is shifted as a 12-byte integer.
+static __forceinline void __cdecl shr_ld12(_LDBL12* const p) throw()
+{
+    uint32_t const c2 = *UL_HI_12 (p) & 0x1 ? MSB_ULONG : 0;
+    uint32_t const c1 = *UL_MED_12(p) & 0x1 ? MSB_ULONG : 0;
+
+    *UL_HI_12 (p) >>= 1;
+    *UL_MED_12(p) = *UL_MED_12(p) >> 1 | c2;
+    *UL_LO_12 (p) = *UL_LO_12 (p) >> 1 | c1;
+}
+
+// Multiplies *px and *py, storing the result in *px.
+static __forceinline void __cdecl multiply_ld12(_LDBL12* const px, _LDBL12 const* const py) throw()
+{
+    _LDBL12 tempman; // This is actually a 12-byte mantissa, not a 12-byte long double
+    *UL_LO_12 (&tempman) = 0;
+    *UL_MED_12(&tempman) = 0;
+    *UL_HI_12 (&tempman) = 0;
+
+    uint16_t expx = *U_EXP_12(px);
+    uint16_t expy = *U_EXP_12(py);
+
+    uint16_t const sign = (expx ^ expy) & static_cast<uint16_t>(0x8000);
+    expx &= 0x7fff;
+    expy &= 0x7fff;
+    uint16_t expsum = expx + expy;
+
+    if (expx   >= LD_MAXEXP ||
+        expy   >= LD_MAXEXP ||
+        expsum >  LD_MAXEXP + LD_BIASM1)
+    {
+        // Overflow to infinity
+        PUT_INF_12(px, sign);
+        return;
+    }
+
+    if (expsum <= LD_BIASM1 - 63)
+    {
+        // Underflow to zero
+        PUT_ZERO_12(px);
+        return;
+    }
+
+    if (expx == 0)
+    {
+        // If this is a denormal temp real then the mantissa was shifted right
+        // once to set bit 63 to zero.
+        ++expsum; // Correct for this
+
+        if (ISZERO_12(px))
+        {
+            // Put positive sign:
+            *U_EXP_12(px) = 0;
+            return;
+        }
+    }
+
+    if (expy == 0)
+    {
+        ++expsum; // Because arg2 is denormal
+        if (ISZERO_12(py))
+        {
+            PUT_ZERO_12(px);
+            return;
+        }
+    }
+
+    int roffs = 0;
+    for (int i = 0; i < 5; ++i)
+    {
+        int poffs = i << 1;
+        int qoffs = 8;
+        for (int j = 5 - i; j > 0; --j)
+        {
+            bool carry = false;
+
+            uint16_t* const p = USHORT_12(px, poffs);
+            uint16_t* const q = USHORT_12(py, qoffs);
+            uint32_t* const r = ULONG_12(&tempman, roffs);
+            uint32_t  const prod = static_cast<uint32_t>(*p) * static_cast<uint32_t>(*q);
+
+            #if defined _M_X64 || defined _M_ARM
+            // handle misalignment problems
+            if (i & 0x1) // i is odd
+            {
+                uint32_t sum = 0;
+                carry = add_uint32_carry(*ALIGN(r), prod, &sum);
+                *ALIGN(r) = sum;
+            }
+            else // i is even
+            {
+                carry = add_uint32_carry(*r, prod, r);
+            }
+            #else
+            carry = add_uint32_carry(*r, prod, r);
+            #endif
+
+            if (carry)
+            {
+                // roffs should be less than 8 in this case
+                ++*USHORT_12(&tempman, roffs + 4);
+            }
+
+            poffs += 2;
+            qoffs -= 2;
+        }
+
+        roffs += 2;
+    }
+
+    expsum -= LD_BIASM1;
+
+    // Normalize
+    while (static_cast<int16_t>(expsum) > 0 && (*UL_HI_12(&tempman) & MSB_ULONG) == 0)
+    {
+         shl_ld12<1>(&tempman);
+         expsum--;
+    }
+
+    if (static_cast<int16_t>(expsum) <= 0)
+    {
+        bool sticky = false;
+
+        expsum--;
+        while (static_cast<int16_t>(expsum) < 0)
+        {
+            if (*U_XT_12(&tempman) & 0x1)
+                sticky = true;
+
+            shr_ld12(&tempman);
+            expsum++;
+        }
+
+        if (sticky)
+        {
+            *U_XT_12(&tempman) |= 0x1;
+        }
+    }
+
+    if (*U_XT_12(&tempman) > 0x8000 || (*UL_LO_12(&tempman) & 0x1ffff) == 0x18000)
+    {
+        // Round up:
+        if (*UL_MANLO_12(&tempman) == UINT32_MAX)
+        {
+            *UL_MANLO_12(&tempman) = 0;
+
+            if (*UL_MANHI_12(&tempman) == UINT32_MAX)
+            {
+                *UL_MANHI_12(&tempman) = 0;
+
+                if (*U_EXP_12(&tempman) == UINT16_MAX)
+                {
+                    // 12-byte mantissa overflow:
+                    *U_EXP_12(&tempman) = MSB_USHORT;
+                    ++expsum;
+                }
+                else
+                {
+                    ++*U_EXP_12(&tempman);
+                }
+            }
+            else
+            {
+                ++*UL_MANHI_12(&tempman);
+            }
+        }
+        else
+        {
+            ++*UL_MANLO_12(&tempman);
+        }
+    }
+
+
+    // Check for exponent overflow:
+    if (expsum >= 0x7fff)
+    {
+        PUT_INF_12(px, sign);
+        return;
+    }
+
+    // Put result in px:
+    *U_XT_12    (px) = *USHORT_12(&tempman, 2);
+    *UL_MANLO_12(px) = *UL_MED_12(&tempman);
+    *UL_MANHI_12(px) = *UL_HI_12 (&tempman);
+    *U_EXP_12   (px) = expsum | sign;
+}
+
+// Multiplies *pld12 by 10^pow.
+static __forceinline void __cdecl multiply_ten_pow_ld12(_LDBL12* const pld12, int pow) throw()
+{
+    if (pow == 0)
+        return;
+
+    _LDBL12 const* pow_10p = ld12_pow10_positive - 8;
+    if (pow < 0)
+    {
+        pow     = -pow;
+        pow_10p = ld12_pow10_negative-8;
+    }
+
+    while (pow != 0)
+    {
+        pow_10p += 7;
+        int const last3 = pow & 0x7; // The three least significant bits of pow
+        pow >>= 3;
+
+        if (last3 == 0)
+            continue;
+
+        _LDBL12 const* py = pow_10p + last3;
+
+        _LDBL12 unround;
+
+        // Do an exact 12byte multiplication:
+        if (*U_XT_12(py) >= 0x8000)
+        {
+            // Copy number:
+            unround = *py;
+
+            // Unround adjacent byte:
+            --*UL_MANLO_12(&unround);
+
+            // Point to new operand:
+            py = &unround;
+        }
+
+        multiply_ld12(pld12, py);
+    }
+}
+
+// Multiplies *ld12 by 2^power.
+static __forceinline void __cdecl multiply_two_pow_ld12(_LDBL12* const ld12, int const power) throw()
+{
+    _LDBL12 multiplicand{};
+    *U_XT_12    (&multiplicand) = 0;
+    *UL_MANLO_12(&multiplicand) = 0;
+    *UL_MANHI_12(&multiplicand) = (1u << (sizeof(uint32_t) * CHAR_BIT - 1));
+    *U_EXP_12   (&multiplicand) = static_cast<uint16_t>(power + LD_BIAS);
+
+    multiply_ld12(ld12, &multiplicand);
+}
+
+
+// These multiply a 12-byte integer stored in an _LDBL12 by N.  N must be 10 or 16.
+template <uint32_t N>
+static __forceinline void __cdecl multiply_ld12_by(_LDBL12*) throw();
+
+template <>
+__forceinline void __cdecl multiply_ld12_by<10>(_LDBL12* const ld12) throw()
+{
+    _LDBL12 const original_ld12 = *ld12;
+    shl_ld12<2>(ld12);
+    add_ld12(ld12, &original_ld12);
+    shl_ld12<1>(ld12);
+}
+
+template <>
+__forceinline void __cdecl multiply_ld12_by<16>(_LDBL12* const ld12) throw()
+{
+    shl_ld12<4>(ld12);
+}
+
+// Converts a mantissa into an _LDBL12.  The mantissa to be converted must be
+// represented as an array of BCD digits, one per byte, read from the byte range
+// [mantissa, mantissa + mantissa_count).
+template <uint32_t Base>
+static __forceinline void __cdecl convert_mantissa_to_ld12(
+    uint8_t const* const mantissa,
+    size_t         const mantissa_count,
+    _LDBL12*       const ld12
+    ) throw()
+{
+    *UL_LO_12 (ld12) = 0;
+    *UL_MED_12(ld12) = 0;
+    *UL_HI_12 (ld12) = 0;
+
+    uint8_t const* const mantissa_last = mantissa + mantissa_count;
+    for (uint8_t const* it = mantissa; it != mantissa_last; ++it)
+    {
+        multiply_ld12_by<Base>(ld12);
+
+        // Add the new digit into the mantissa:
+        _LDBL12 digit_ld12{};
+        *UL_LO_12 (&digit_ld12) = *it;
+        *UL_MED_12(&digit_ld12) = 0;
+        *UL_HI_12 (&digit_ld12) = 0;
+        add_ld12(ld12, &digit_ld12);
+    }
+
+    uint16_t expn = LD_BIASM1 + 80;
+
+    // Normalize mantissa.  First shift word-by-word:
+    while (*UL_HI_12(ld12) == 0)
+    {
+        *UL_HI_12 (ld12) = *UL_MED_12(ld12) >> 16;
+        *UL_MED_12(ld12) = *UL_MED_12(ld12) << 16 | *UL_LO_12(ld12) >> 16;
+        *UL_LO_12 (ld12) <<= 16;
+        expn -= 16;
+    }
+
+    while ((*UL_HI_12(ld12) & MSB_USHORT) == 0)
+    {
+        shl_ld12<1>(ld12);
+        --expn;
+    }
+
+    *U_EXP_12(ld12) = expn;
+}
+
+namespace __crt_strtox {
+
+void __cdecl assemble_floating_point_zero(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    // Zero is all zero bits with an optional sign bit:
+    *U_XT_12    (&result) = 0;
+    *UL_MANLO_12(&result) = 0;
+    *UL_MANHI_12(&result) = 0;
+    *U_EXP_12   (&result) = sign_bit;
+}
+
+void __cdecl assemble_floating_point_infinity(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    // Infinity has an all-zero mantissa and an all-one exponent
+    *U_XT_12    (&result) = 0;
+    *UL_MANLO_12(&result) = 0;
+    *UL_MANHI_12(&result) = 0;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+void __cdecl assemble_floating_point_qnan(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    *U_XT_12    (&result) = 0xffff;
+    *UL_MANLO_12(&result) = 0xffffffff;
+    *UL_MANHI_12(&result) = 0xffffffff;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+void __cdecl assemble_floating_point_snan(bool const is_negative, _LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
+
+    *U_XT_12    (&result) = 0xffff;
+    *UL_MANLO_12(&result) = 0xffffffff;
+    *UL_MANHI_12(&result) = 0xbfffffff;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+void __cdecl assemble_floating_point_ind(_LDBL12& result) throw()
+{
+    uint16_t const sign_bit{static_cast<uint16_t>(MSB_USHORT)};
+
+    *U_XT_12    (&result) = 0x0000;
+    *UL_MANLO_12(&result) = 0x00000000;
+    *UL_MANHI_12(&result) = 0xc0000000;
+    *U_EXP_12   (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
+}
+
+static SLD_STATUS __cdecl common_convert_to_ldbl12(
+    floating_point_string const& immutable_data,
+    bool                  const  is_hexadecimal,
+    _LDBL12                    & result
+    ) throw()
+{
+    floating_point_string data = immutable_data;
+
+    // Cap the number of digits to LD_MAX_MAN_LEN, and round the last digit:
+    if (data._mantissa_count > LD_MAX_MAN_LEN)
+    {
+        if (data._mantissa[LD_MAX_MAN_LEN] >= (is_hexadecimal ? 8 : 5))
+        {
+            ++data._mantissa[LD_MAX_MAN_LEN - 1];
+        }
+
+        data._mantissa_count = LD_MAX_MAN_LEN;
+    }
+
+    // The input exponent is an adjustment from the left (so 12.3456 is represented
+    // as a mantiss a of 123456 with an exponent of 2), but the legacy functions
+    // used here expect an adjustment from the right (so 12.3456 is represented
+    // with an exponent of -4).
+    int const exponent_adjustment_multiplier = is_hexadecimal ? 4 : 1;
+    data._exponent -= data._mantissa_count * exponent_adjustment_multiplier;
+
+    if (is_hexadecimal)
+    {
+        convert_mantissa_to_ld12<16>(data._mantissa, data._mantissa_count, &result);
+        multiply_two_pow_ld12(&result, data._exponent);
+    }
+    else
+    {
+        convert_mantissa_to_ld12<10>(data._mantissa, data._mantissa_count, &result);
+        multiply_ten_pow_ld12(&result, data._exponent);
+    }
+
+    if (data._is_negative)
+    {
+        *U_EXP_12(&result) |= 0x8000;
+    }
+
+    // If the combination of the mantissa and the exponent produced an infinity,
+    // we've overflowed the range of the _LDBL12.
+    if ((*U_EXP_12(&result) & LD_MAXEXP) == LD_MAXEXP)
+    {
+        return SLD_OVERFLOW;
+    }
+
+    return SLD_OK;
+}
+
+SLD_STATUS __cdecl convert_decimal_string_to_floating_type(
+    floating_point_string const& data,
+    _LDBL12                    & result
+    ) throw()
+{
+    return common_convert_to_ldbl12(data, false, result);
+}
+
+SLD_STATUS __cdecl convert_hexadecimal_string_to_floating_type(
+    floating_point_string const& data,
+    _LDBL12                    & result
+    ) throw()
+{
+    return common_convert_to_ldbl12(data, true, result);
+}
+
+} // namespace __crt_strtox
+
+using namespace __crt_strtox;
+
+
+
+static int __cdecl transform_into_return_value(SLD_STATUS const status) throw()
+{
+    switch (status)
+    {
+    case SLD_OVERFLOW:  return _OVERFLOW;
+    case SLD_UNDERFLOW: return _UNDERFLOW;
+    default:            return 0;
+    }
+}
+
+// The internal mantissa length in ints
+#define INTRNMAN_LEN 3
+
+// Internal mantissaa representation for string conversion routines
+typedef uint32_t* mantissa_t;
+
+
+// Tests whether a mantissa ends in nbit zeroes.  Returns true if all mantissa
+// bits after (and including) nbit are zero; returns false otherwise.
+static __forceinline bool __cdecl mantissa_has_zero_tail(mantissa_t const mantissa, int const nbit) throw()
+{
+    int nl = nbit / 32;
+    int const nb = 31 - nbit % 32;
+
+    //
+    //             |<---- tail to be checked --->
+    //
+    //    --  ------------------------           ----
+    //    |...    |          |  ...      |
+    //    --  ------------------------           ----
+    //    ^    ^    ^
+    //    |    |    |<----nb----->
+    //    man    nl   nbit
+    //
+
+    uint32_t const bitmask = ~(UINT32_MAX << nb);
+
+    if (mantissa[nl] & bitmask)
+        return false;
+
+    ++nl;
+
+    for (; nl < INTRNMAN_LEN; ++nl)
+    {
+        if (mantissa[nl])
+            return false;
+    }
+
+    return true;
+}
+
+
+
+// Increments a mantissa.  The nbit argument specifies the end of the part to
+// be incremented.  Returns true if overflow occurs; false otherwise.
+static __forceinline bool __cdecl increment_mantissa(mantissa_t const mantissa, int const nbit) throw()
+{
+    int nl = nbit / 32;
+    int const nb = 31 - nbit % 32;
+
+    //
+    //    |<--- part to be incremented -->|
+    //
+    //    ---------------------------------
+    //    |...          |            |   ...      |
+    //    ---------------------------------
+    //    ^          ^        ^
+    //    |          |        |<--nb-->
+    //    man          nl        nbit
+    //
+
+    uint32_t const one = static_cast<uint32_t>(1) << nb;
+
+    bool carry = add_uint32_carry(mantissa[nl], one, &mantissa[nl]);
+
+    --nl;
+
+    for (; nl >= 0 && carry; --nl)
+    {
+        carry = add_uint32_carry(mantissa[nl], 1, &mantissa[nl]);
+    }
+
+    return carry;
+}
+
+// Rounds a mantissa to the given precision.  Returns true if overflow occurs;
+// returns false otherwise.
+static __forceinline bool __cdecl round_mantissa(mantissa_t const mantissa, int const precision) throw()
+{
+    // The order of the n'th bit is n-1, since the first bit is bit 0
+    // therefore decrement precision to get the order of the last bit
+    // to be kept
+
+    int const nbit = precision - 1;
+
+    int const rndbit = nbit + 1;
+
+    int const nl = rndbit / 32;
+    int const nb = 31 - rndbit % 32;
+
+    // Get value of round bit
+    uint32_t const rndmask = static_cast<uint32_t>(1) << nb;
+
+    bool retval = false;
+    if ((mantissa[nl] & rndmask) && !mantissa_has_zero_tail(mantissa, rndbit))
+    {
+        // round up
+        retval = increment_mantissa(mantissa, nbit);
+    }
+
+    // Fill rest of mantissa with zeroes
+    mantissa[nl] &= UINT32_MAX << nb;
+    for (int i = nl + 1; i < INTRNMAN_LEN; ++i)
+    {
+        mantissa[i] = 0;
+    }
+
+    return retval;
+}
+
+static void __cdecl convert_ld12_to_ldouble(
+    _LDBL12 const* const pld12,
+    _LDOUBLE*      const result
+    ) throw()
+{
+    // This implementation is based on the fact that the _LDBL12 format is
+    // identical to the long double and has 2 extra bytes of mantissa
+    uint16_t       exponent = *U_EXP_12(pld12) & static_cast<uint16_t>(0x7fff);
+    uint16_t const sign     = *U_EXP_12(pld12) & static_cast<uint16_t>(0x8000);
+
+    uint32_t mantissa[] =
+    {
+        *UL_MANHI_12(pld12),
+        *UL_MANLO_12(pld12),
+        uint32_t ((*U_XT_12(pld12)) << 16)
+    };
+
+    if (round_mantissa(mantissa, 64))
+    {
+        // The MSB of the mantissa is explicit and should be 1
+        // since we had a carry, the mantissa is now 0.
+        mantissa[0] = MSB_ULONG;
+        ++exponent;
+    }
+
+    *UL_MANHI_LD(result) = mantissa[0];
+    *UL_MANLO_LD(result) = mantissa[1];
+    *U_EXP_LD   (result) = sign | exponent;
+}
+
+extern "C" int __cdecl _atoldbl_l(_LDOUBLE* const result, char* const string, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    _LDBL12 intermediate_result{};
+    SLD_STATUS const conversion_status = parse_floating_point(
+        locale_update.GetLocaleT(),
+        make_c_string_character_source(string, nullptr),
+        &intermediate_result);
+
+    convert_ld12_to_ldouble(&intermediate_result, result);
+    return transform_into_return_value(conversion_status);
+}
+
+extern "C" int __cdecl _atoldbl(_LDOUBLE* const result, char* const string)
+{
+    return _atoldbl_l(result, string, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atox.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atox.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc96ca220e932f19dda65d9e85bf3318f0f97011
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/atox.cpp	
@@ -0,0 +1,107 @@
+//
+// atox.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The "simple" string conversion functions:  atoi, atol, atoll, and their wide
+// string functions.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_strtox.h>
+#include <stdlib.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Narrow Strings => Various Integers (Simple Functions, wtox)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" int __cdecl atoi(char const* const string)
+{
+    // Note:  We parse as a long to avoid an extra specialization of parse_integer_from_string
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" int __cdecl _atoi_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long __cdecl atol(char const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long __cdecl _atol_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long long __cdecl atoll(char const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long long __cdecl _atoll_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, locale);
+}
+
+extern "C" __int64 __cdecl _atoi64(char const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, nullptr);
+}
+
+extern "C" __int64 __cdecl _atoi64_l(char const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, locale);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Wide Strings => Various Integers (Simple Functions, wtox)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" int __cdecl _wtoi(wchar_t const* const string)
+{
+    // Note:  We parse as a long to avoid an extra specialization of parse_integer_from_string
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" int __cdecl _wtoi_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long __cdecl _wtol(wchar_t const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long __cdecl _wtol_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, nullptr, 10, locale);
+}
+
+extern "C" long long __cdecl _wtoll(wchar_t const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, nullptr);
+}
+
+extern "C" long long __cdecl _wtoll_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, nullptr, 10, locale);
+}
+
+extern "C" __int64 __cdecl _wtoi64(wchar_t const* const string)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, nullptr);
+}
+
+extern "C" __int64 __cdecl _wtoi64_l(wchar_t const* const string, _locale_t const locale)
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, nullptr, 10, locale);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c16rtomb.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c16rtomb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2927f36b5150b1b386791b09ecc5506c441eecba
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c16rtomb.cpp	
@@ -0,0 +1,94 @@
+//
+// c16rtomb.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <uchar.h>
+
+using namespace __crt_mbstring;
+
+namespace
+{
+    inline void store_first_surrogate(char16_t c16, mbstate_t* ps)
+    {
+        // Store the first (high) surrogate masked and shifted, so that all that's left to do
+        // is to add the maksed second surrogate.
+        // Note: _Wchar is the only field used in mbstate_t for this function
+        const char32_t c32 = ((c16 & ~0xd800) << 10) + 0x10000;
+        ps->_Wchar = c32;
+    }
+
+    inline char32_t combine_second_surrogate(char16_t c16, mbstate_t* ps)
+    {
+        return ps->_Wchar + (c16 & ~0xdc00);
+    }
+
+    inline constexpr bool has_surrogate(mbstate_t* ps)
+    {
+        return ps->_Wchar != 0;
+    }
+
+    inline constexpr bool is_first_surrogate(char16_t c16)
+    {
+        // UTF-16 high surrogate
+        return 0xd800 <= c16 && c16 <= 0xdbff;
+    }
+
+    inline constexpr bool is_second_surrogate(char16_t c16)
+    {
+        // UTF-16 low surrogate
+        return 0xdc00 <= c16 && c16 <= 0xdfff;
+    }
+}
+
+extern "C" size_t __cdecl c16rtomb(char* s, char16_t c16, mbstate_t* ps)
+{
+    // TODO: Bug 13307590 says this is always assuming UTF-8.
+    __crt_cached_ptd_host ptd;
+    return __c16rtomb_utf8(s, c16, ps, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__c16rtomb_utf8(char* s, char16_t c16, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    static mbstate_t internal_pst{};
+    if (ps == nullptr)
+    {
+        ps = &internal_pst;
+    }
+
+    if (!has_surrogate(ps))
+    {
+        if (is_second_surrogate(c16))
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        else if (is_first_surrogate(c16))
+        {
+            store_first_surrogate(c16, ps);
+            return 0;
+        }
+        else
+        {
+            return __c32rtomb_utf8(s, static_cast<char32_t>(c16), ps, ptd);
+        }
+    }
+    else
+    {
+        // We've already seen the first (high) surrogate, so we're
+        // expecting to complete this code point with its other half
+        // in the second (low) surrogate
+        if (!is_second_surrogate(c16))
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        const char32_t c32 = combine_second_surrogate(c16, ps);
+
+        mbstate_t temp{};
+        const size_t retval = __c32rtomb_utf8(s, c32, &temp, ptd);
+        return reset_and_return(retval, ps);
+    }
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c32rtomb.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c32rtomb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53dd06d9054ef4c6d85cfd3141ec57de7b9ee614
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/c32rtomb.cpp	
@@ -0,0 +1,93 @@
+//
+// c32rtomb.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stdint.h>
+#include <uchar.h>
+
+using namespace __crt_mbstring;
+
+extern "C" size_t __cdecl c32rtomb(char* s, char32_t c32, mbstate_t* ps)
+{
+    // TODO: Bug 13307590 says this is always assuming UTF-8.
+    __crt_cached_ptd_host ptd;
+    return __c32rtomb_utf8(s, c32, ps, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__c32rtomb_utf8(char* s, char32_t c32, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    if (!s)
+    {
+        // Equivalent to c32rtomb(buf, U'\0', ps) for some internal buffer buf
+        *ps = {};
+        return 1;
+    }
+
+    if (c32 == U'\0')
+    {
+        *s = '\0';
+        *ps = {};
+        return 1;
+    }
+
+    // Fast path for ASCII
+    if ((c32 & ~0x7f) == 0)
+    {
+        *s = static_cast<char>(c32);
+        return 1;
+    }
+
+    // Figure out how many trail bytes we need
+    size_t trail_bytes;
+    uint8_t lead_byte;
+    if ((c32 & ~0x7ff) == 0)
+    {
+        trail_bytes = 1;
+        lead_byte = 0xc0;
+    }
+    else if ((c32 & ~0xffff) == 0)
+    {
+        // high/low surrogates are only valid in UTF-16 encoded data
+        if (0xd800 <= c32 && c32 <= 0xdfff)
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        trail_bytes = 2;
+        lead_byte = 0xe0;
+    }
+    else if ((c32 & ~0x001fffff) == 0)
+    {
+        // Unicode's max code point is 0x10ffff
+        if (0x10ffff < c32)
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+        trail_bytes = 3;
+        lead_byte = 0xf0;
+    }
+    else
+    {
+        return return_illegal_sequence(ps, ptd);
+    }
+    _ASSERTE(1 <= trail_bytes && trail_bytes <= 3);
+
+    // Put six bits into each of the trail bytes
+    // Lowest bits are in the last UTF-8 byte.
+    // Filling back to front.
+    for (size_t i = trail_bytes; i > 0; --i)
+    {
+        s[i] = (c32 & 0x3f) | 0x80;
+        c32 >>= 6;
+    }
+
+    // The first byte needs the upper (trail_bytes + 1) bits to store the length
+    // And the lower (7 - trail_bytes) to store the upper bits of the code point
+    _ASSERTE(c32 < (1u << (7 - trail_bytes)));
+    s[0] = static_cast<uint8_t>(c32) | lead_byte;
+
+    return reset_and_return(trail_bytes + 1, ps);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cfout.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cfout.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4400d65dd4188434cc028c372ea428acc3fc6ba4
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cfout.cpp	
@@ -0,0 +1,367 @@
+//
+// cfout.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Floating point binary to decimal conversion routines
+//
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_big_integer.h>
+#include <fenv.h>
+#include <string.h>
+
+
+
+using namespace __crt_strtox;
+
+namespace
+{
+    // Guard class for floating point control word modifications in the interrupt exception mask.
+    class fp_control_word_guard
+    {
+    public:
+        explicit fp_control_word_guard(unsigned int const mask = ~0u) : _mask(mask)
+        {
+            _controlfp_s(&_original_control_word, 0, 0);
+        }
+
+        fp_control_word_guard(unsigned int const new_control, unsigned int const mask) : _mask(mask)
+        {
+            unsigned int float_control;
+            _controlfp_s(&_original_control_word, 0, 0);
+            _controlfp_s(&float_control, new_control, _mask);
+        }
+
+        ~fp_control_word_guard()
+        {
+            unsigned int reset_cw;
+            _controlfp_s(&reset_cw, _original_control_word, _mask);
+        }
+
+    private:
+        unsigned int _original_control_word;
+        unsigned int _mask;
+    };
+
+    class scoped_fp_state_reset
+    {
+    public:
+
+        scoped_fp_state_reset() throw()
+        {
+            // The calls to feholdexcept and fesetenv are relatively expensive,
+            // so we only call them if there are any unmasked exceptions.
+            fegetenv(&_environment);
+            if ((_environment._Fe_ctl & FE_ALL_EXCEPT) == FE_ALL_EXCEPT)
+            {
+                _requires_reset = false;
+            }
+            else
+            {
+                feholdexcept(&_environment);
+                _requires_reset = true;
+            }
+        }
+
+        ~scoped_fp_state_reset() throw()
+        {
+            if (_requires_reset)
+            {
+                fesetenv(&_environment);
+            }
+        }
+
+    private:
+
+        scoped_fp_state_reset(scoped_fp_state_reset const&);
+        scoped_fp_state_reset& operator=(scoped_fp_state_reset const&);
+
+        fenv_t _environment;
+        bool   _requires_reset;
+    };
+}
+
+
+
+// This function converts a finite, positive floating point value into its
+// decimal representation. The decimal mantissa and exponent are returned
+// via the out parameters and the return value affirms if there were trailing
+// digits. If the value is zero, negative, infinity, or nan, the behavior is
+// undefined.
+//
+// This function is based on the digit generation algorithm described in the
+// paper "Printing floating point numbers quickly and accurately," by Robert G.
+// Burger and R. Kent Dybvig, from ACM SIGPLAN 1996 Conference on Programming
+// Language Design and Implementation, June 1996.  This function deviates from
+// that algorithm in its termination conditions:  the Burger-Dybvig algorithm
+// terminates when it runs out of significant digits; this function continues
+// generating digits, even if they are insignificant (this allows us to print
+// large, exactly representable values exactly, e.g. large powers of two).
+//
+// This function stops generating digits when the first of the following
+// conditions is true:  [1] the mantissa buffer is exhausted, [2] sufficient
+// digits have been generated for a %f specifier with the requested precision,
+// or [3] all remaining digits are known to be zero.
+template <typename FloatingType>
+__forceinline static __acrt_has_trailing_digits __cdecl convert_to_fos_high_precision(
+    FloatingType           const value,
+    uint32_t               const precision,
+    __acrt_precision_style const precision_style,
+    int*                   const exponent,
+    char*                  const mantissa_buffer,
+    size_t                 const mantissa_buffer_count
+    ) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    _ASSERTE(mantissa_buffer_count > 0);
+
+    components_type const& value_components = reinterpret_cast<components_type const&>(value);
+
+    // Special handling is required for denormal values:  because the implicit
+    // high order bit is a zero, not a one, we need to [1] not set that bit when
+    // we expand the mantissa, and [2] increment the exponent to account for the
+    // extra shift.
+    bool const is_denormal = value_components._exponent == 0;
+
+    uint64_t const mantissa_adjustment = is_denormal
+        ? 0
+        : static_cast<uint64_t>(1) << (floating_traits::mantissa_bits - 1);
+
+    int32_t const exponent_adjustment = is_denormal
+        ? 2
+        : 1;
+
+    // f and e are the unbiased mantissa and exponent, respectively.  (Where one-
+    // -letter variable names are used, they match the same variables from the
+    // Burger-Dybvig paper.)
+    uint64_t const f = value_components._mantissa + mantissa_adjustment;
+    int32_t  const e =
+        static_cast<int32_t>(value_components._exponent) -
+        floating_traits::exponent_bias -
+        floating_traits::mantissa_bits +
+        exponent_adjustment;
+
+    // k is the decimal exponent, such that the resulting decimal number is of
+    // the form 0.mmmmm * 10^k, where mmmm are the mantissa digits we generate.
+    // Note that the use of log10 here may not give the correct result:  it may
+    // be off by one, e.g. as is the case for powers of ten (log10(100) is two,
+    // but the correct value of k for 100 is 3).  We detect off-by-one errors
+    // later and correct for them.
+    int32_t k = static_cast<int32_t>(ceil(log10(value)));
+    if (k == INT32_MAX || k == INT32_MIN)
+    {
+        _ASSERTE(("unexpected input value; log10 failed", 0));
+        k = 0;
+    }
+
+    // The floating point number is represented as a fraction, r / s.  The
+    // initialization of these two values is as described in the Burger-Dybvig
+    // paper.
+    big_integer r = make_big_integer(f);
+    big_integer s{};
+
+    if (e >= 0)
+    {
+        if (r != make_big_integer_power_of_two(floating_traits::mantissa_bits - 1))
+        {
+            shift_left(r, e + 1);   // f * b^e * 2
+            s = make_big_integer(2); // 2
+        }
+        else
+        {
+            shift_left(r, e + 2);   // f * b^(e+1) * 2
+            s = make_big_integer(4); // b * 2
+        }
+    }
+    else
+    {
+        if (e == floating_traits::minimum_binary_exponent ||
+            r != make_big_integer_power_of_two(floating_traits::mantissa_bits - 1))
+        {
+            shift_left(r, 1);                          // f * 2
+            s = make_big_integer_power_of_two(-e + 1); // b^-e * 2
+        }
+        else
+        {
+            shift_left(r, 2);                          // f * b * 2
+            s = make_big_integer_power_of_two(-e + 2); // b^(-e+1) * 2
+        }
+    }
+
+    if (k >= 0)
+    {
+        multiply_by_power_of_ten(s, k);
+    }
+    else
+    {
+        multiply_by_power_of_ten(r, -k);
+    }
+
+    char* mantissa_it = mantissa_buffer;
+
+    // Perform a trial digit generation to handle off-by-one errors in the
+    // computation of 'k':  There are three possible cases, which we handle
+    // in turn:
+    multiply(r, 10);
+    uint32_t const initial_digit = static_cast<uint32_t>(divide(r, s));
+
+    // If the initial digit was computed as 10, k is too small.  We increment k
+    // and adjust s as if it had been computed with the correct k above.  We
+    // then treat the digit as a one, which is what it would have been extracted
+    // as had k, r, and s been correct to begin with.
+    if (initial_digit == 10)
+    {
+        ++k;
+        *mantissa_it++ = '1';
+        multiply(s, 10);
+    }
+    // If the initial digit is zero, k is too large.  We decrement k and ignore
+    // the zero that we read (the next digit that we read will be the "real"
+    // initial digit.
+    else if (initial_digit == 0)
+    {
+        --k;
+    }
+    // Otherwise, k was correct and the digit we read was the actual initial
+    // digit of the number; just store it.
+    else
+    {
+        *mantissa_it++ = static_cast<char>('0' + initial_digit);
+    }
+
+    *exponent = k; // k is now correct; store it for our caller
+
+    // convert_to_fos_high_precision() generates digits assuming we're formatting with %f
+    // When %e is the format specifier, adding the exponent to the number of required digits
+    // is not needed.
+    uint32_t const required_digits = k >= 0 && precision <= INT_MAX && precision_style == __acrt_precision_style::fixed
+        ? k + precision
+        : precision;
+
+    char* const mantissa_last = mantissa_buffer + __min(mantissa_buffer_count - 1, required_digits);
+
+    // We must track whether there are any non-zero digits that were not written to the mantissa,
+    // since just checking whether 'r' is zero is insufficient for knowing whether there are any
+    // remaining zeros after the generated digits.
+    bool unwritten_nonzero_digits_in_chunk = false;
+    for (;;)
+    {
+        if (mantissa_it == mantissa_last)
+        {
+            break;
+        }
+
+        if (is_zero(r))
+        {
+            break;
+        }
+
+        // To reduce the number of expensive high precision division operations,
+        // we generate multiple digits per iteration.  Our quotient type is a
+        // uint32_t, and the largest power of ten representable by a uint32_t is
+        // 10^9, so we generate nine digits per iteration.
+        uint32_t const digits_per_iteration            = 9;
+        uint32_t const digits_per_iteration_multiplier = 1000 * 1000 * 1000;
+
+        multiply(r, digits_per_iteration_multiplier);
+        uint32_t quotient = static_cast<uint32_t>(divide(r, s));
+
+        _ASSERTE(quotient < digits_per_iteration_multiplier);
+
+        // Decompose the quotient into its nine component digits by repeatedly
+        // dividing by ten.  This generates digits in reverse order.
+        #pragma warning(suppress: 6293) // For-loop counts down from minimum
+        for (uint32_t i = digits_per_iteration - 1; i != static_cast<uint32_t>(-1); --i)
+        {
+            char const d = static_cast<char>('0' + quotient % 10);
+            quotient /= 10;
+
+            // We may not have room in the mantissa buffer for all of the digits.
+            // Ignore the ones for which we do not have room.
+            // Last value in mantissa must be null terminator, account for one place after digit generation.
+            if (static_cast<uint32_t>(mantissa_last - mantissa_it) <= i)
+            {
+                if (d != '0')
+                {
+                    unwritten_nonzero_digits_in_chunk = true;
+                }
+
+                continue;
+            }
+
+            mantissa_it[i] = d;
+        }
+
+        mantissa_it += __min(digits_per_iteration, mantissa_last - mantissa_it);
+    }
+
+    *mantissa_it = '\0';
+
+    // To detect whether there are zeros after the generated digits for the purposes of rounding,
+    // we must check whether 'r' is zero, but also whether there were any non-zero numbers that were
+    // not written to the mantissa in the last evaluated chunk.
+    bool const all_zeros_after_chunk = is_zero(r);
+
+    if (all_zeros_after_chunk && !unwritten_nonzero_digits_in_chunk)
+    {
+        return __acrt_has_trailing_digits::no_trailing;
+    }
+
+    return __acrt_has_trailing_digits::trailing;
+}
+
+extern "C" __acrt_has_trailing_digits __cdecl __acrt_fltout(
+    _CRT_DOUBLE                  value,
+    unsigned               const precision,
+    __acrt_precision_style const precision_style,
+    STRFLT                 const flt,
+    char*                  const result,
+    size_t                 const result_count
+    )
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    scoped_fp_state_reset const reset_fp_state;
+
+    components_type& components = reinterpret_cast<components_type&>(value);
+
+    flt->sign     = components._sign == 1 ? '-' : ' ';
+    flt->mantissa = result;
+
+    unsigned int float_control;
+    _controlfp_s(&float_control, 0, 0);
+    bool const value_is_zero = components._exponent == 0 && (components._mantissa == 0 || float_control & _DN_FLUSH);
+    if (value_is_zero)
+    {
+        flt->decpt = 0;
+        _ERRCHECK(strcpy_s(result, result_count, "0"));
+        return __acrt_has_trailing_digits::no_trailing;
+    }
+
+    // Handle special cases:
+    __acrt_fp_class const classification = __acrt_fp_classify(value.x);
+    if (classification != __acrt_fp_class::finite)
+    {
+        flt->decpt = 1;
+    }
+
+    switch (classification)
+    {
+    case __acrt_fp_class::infinity:      _ERRCHECK(strcpy_s(result, result_count, "1#INF" )); return __acrt_has_trailing_digits::trailing;
+    case __acrt_fp_class::quiet_nan:     _ERRCHECK(strcpy_s(result, result_count, "1#QNAN")); return __acrt_has_trailing_digits::no_trailing;
+    case __acrt_fp_class::signaling_nan: _ERRCHECK(strcpy_s(result, result_count, "1#SNAN")); return __acrt_has_trailing_digits::no_trailing;
+    case __acrt_fp_class::indeterminate: _ERRCHECK(strcpy_s(result, result_count, "1#IND" )); return __acrt_has_trailing_digits::no_trailing;
+    }
+
+    // Make the number positive before we pass it to the digit generator:
+    components._sign = 0;
+
+    // The digit generator produces a truncated sequence of digits.  To allow
+    // our caller to correctly round the mantissa, we need to generate an extra
+    // digit.
+    fp_control_word_guard const fpc(_MCW_EM, _MCW_EM);
+    return convert_to_fos_high_precision(value.x, precision + 1, precision_style, &flt->decpt, result, result_count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/common_utf8.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/common_utf8.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9c665ca1efda60179518b60cd3ea216456e54e1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/common_utf8.cpp	
@@ -0,0 +1,27 @@
+//
+// common_utf8.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Common UTF-8 utilities
+//
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+namespace __crt_mbstring
+{
+    size_t return_illegal_sequence(mbstate_t* ps, __crt_cached_ptd_host& ptd)
+    {
+        *ps = {};
+        ptd.get_errno().set(EILSEQ);
+        return INVALID;
+    }
+
+    size_t reset_and_return(size_t retval, mbstate_t* ps)
+    {
+        *ps = {};
+        return retval;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cvt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cvt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..251eb017f87e3ea635397372b1d747b5e915ffdf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/cvt.cpp	
@@ -0,0 +1,849 @@
+//
+// cvt.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Functions for formatting floating point values with the %a, %e, %f, and %g
+// printf format specifiers.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <locale.h>
+#include <corecrt_internal_fltintrn.h>
+#include <fenv.h>
+#include <float.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+
+// The C String pointed to by string is shifted distance bytes to the right.
+// If distance is negative, the string is shifted to the left.
+// The C String pointed to by string and all shifting operations must be
+// contained within buffer_base or buffer_count.
+static void __cdecl shift_bytes(
+    _Maybe_unsafe_(_Inout_updates_z_, buffer_count)          char * const buffer_base,
+    _In_                                                     size_t const buffer_count,
+    _In_range_(buffer_base, buffer_base + buffer_count)      char*  const string,
+    _In_                                                     int    const distance
+    ) throw()
+{
+    UNREFERENCED_PARAMETER(buffer_base);
+    UNREFERENCED_PARAMETER(buffer_count);
+
+    if (distance != 0)
+    {
+        memmove(string + distance, string, strlen(string) + 1);
+    }
+}
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// NaN and Infinity Formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+_Success_(return == 0)
+static errno_t __cdecl fp_format_nan_or_infinity(
+    _In_                                                __acrt_fp_class const classification,
+    _In_range_(0,1)                                     bool            const is_negative,
+    _Maybe_unsafe_(_Out_writes_z_, result_buffer_count) char*                 result_buffer,
+    _In_range_(1,SIZE_MAX)                              size_t                result_buffer_count,
+    _In_range_(0,1)                                     bool            const use_capitals
+    ) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    // Ensure that we have sufficient space to store at least the basic three-
+    // character INF or NAN string, plus the minus sign if required:
+    if (result_buffer_count < _countof("INF") + is_negative)
+    {
+        *result_buffer = '\0';
+        return ENOMEM;
+    }
+
+    if (is_negative)
+    {
+        *result_buffer++ = '-';
+        *result_buffer   = '\0';
+        if (result_buffer_count != _CRT_UNBOUNDED_BUFFER_SIZE)
+        {
+            --result_buffer_count;
+        }
+    }
+
+    static char const* const strings[][4] =
+    {
+        { "INF",       "INF", "inf",       "inf" }, // Infinity
+        { "NAN",       "NAN", "nan",       "nan" }, // Quiet NAN
+        { "NAN(SNAN)", "NAN", "nan(snan)", "nan" }, // Signaling NAN
+        { "NAN(IND)",  "NAN", "nan(ind)",  "nan" }, // Indeterminate
+    };
+
+    uint32_t const row    = static_cast<uint32_t>(classification) - 1;
+    uint32_t const column = use_capitals ? 0 : 2;
+
+    bool const long_string_will_fit = result_buffer_count > strlen(strings[row][column]);
+    _ERRCHECK(strcpy_s(
+        result_buffer,
+        result_buffer_count,
+        strings[row][column + !long_string_will_fit]));
+    return 0;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %e formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %e
+// printf format.  This format has the form [-]d.ddde(+/-)ddd, where there will
+// be 'precision' digits following the decimal point.  If the precision is less
+// than or equal to zero, no decimal point will appear.  The low order digit is
+// rounded.  If 'capitals' is true, then the exponent will appear as E(+/-)ddd.
+_Success_(return == 0)
+static errno_t fp_format_e_internal(
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*              const result_buffer,
+    _In_fits_precision_(precision)                         size_t             const result_buffer_count,
+    _In_                                                   int                const precision,
+    _In_                                                   bool               const capitals,
+    _In_                                                   unsigned           const min_exponent_digits,
+    _In_                                                   STRFLT             const pflt,
+    _In_                                                   bool               const g_fmt,
+    _Inout_                                                __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    // The max length if calculated like this:
+    // 3 = sign + first digit + decimal point
+    // precision = decimal digits
+    // 5 = exponent letter (e or E), exponent sign, three digits exponent
+    // 1 = extra space for rounding
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > static_cast<size_t>(3 + (precision > 0 ? precision : 0) + 5 + 1), ERANGE);
+
+    // Place the output in the buffer and round.  Leave space in the buffer
+    // for the '-' sign (if any) and the decimal point (if any):
+    if (g_fmt)
+    {
+        // Shift it right one place if nec. for decimal point:
+        char* const p = result_buffer + (pflt->sign == '-');
+        shift_bytes(result_buffer, result_buffer_count, p, precision > 0);
+    }
+
+    // Now fix the number up to be in e format:
+    char* p = result_buffer;
+
+    // Put in negative sign if needed:
+    if (pflt->sign == '-')
+        *p++ = '-';
+
+    // Put in decimal point if needed.  Copy the first digit to the place left
+    // for it and put the decimal point in its place:
+    if (precision > 0)
+    {
+        *p = *(p + 1);
+        *++p = *ptd.get_locale()->locinfo->lconv->decimal_point;
+    }
+
+    // Find the end of the string, attach the exponent field and save the
+    // exponent position:
+    p = p + precision + (g_fmt ? 0 : 1);
+    _ERRCHECK(strcpy_s(
+        p,
+        result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE
+            ? result_buffer_count
+            : result_buffer_count - (p - result_buffer), "e+000"));
+    char* exponentpos = p + 2;
+
+    // Adjust exponent indicator according to capitals flag and increment
+    // pointer to point to exponent sign:
+    if (capitals)
+        *p = 'E';
+
+    ++p;
+
+    // If mantissa is zero, then the number is 0 and we are done; otherwise
+    // adjust the exponent sign (if necessary) and value:
+    if (*pflt->mantissa != '0')
+    {
+        // Check to see if exponent is negative; if so adjust exponent sign and
+        // exponent value:
+        int exp = pflt->decpt - 1;
+        if (exp < 0)
+        {
+            exp = -exp;
+            *p = '-';
+        }
+
+        ++p;
+
+        if (exp >= 100)
+        {
+            *p += static_cast<char>(exp / 100);
+            exp %= 100;
+        }
+
+        ++p;
+
+        if (exp >= 10)
+        {
+            *p += static_cast<char>(exp / 10);
+            exp %= 10;
+        }
+
+        *++p += static_cast<char>(exp);
+    }
+
+    if (min_exponent_digits == 2)
+    {
+        // If possible, reduce the exponent to two digits:
+        if (*exponentpos == '0')
+        {
+            memmove(exponentpos, exponentpos + 1, 3);
+        }
+    }
+
+    return 0;
+}
+
+_Success_(return == 0)
+static errno_t __cdecl fp_format_e(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                const result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                  const precision,
+    _In_                                                   bool                 const capitals,
+    _In_                                                   unsigned             const min_exponent_digits,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&     ptd
+    ) throw()
+{
+    // The precision passed to __acrt_fltout is the number of fractional digits.
+    // To ensure that we get enough digits, we require a total of precision + 1 digits,
+    // to account for the digit placed to the left of the decimal point when all digits are fractional.
+    _strflt strflt;
+
+    __acrt_has_trailing_digits const trailing_digits = __acrt_fltout(
+        *reinterpret_cast<_CRT_DOUBLE const*>(argument),
+        precision + 1,
+        __acrt_precision_style::scientific,
+        &strflt,
+        scratch_buffer,
+        scratch_buffer_count
+        );
+
+    errno_t const e = __acrt_fp_strflt_to_string(
+        result_buffer + (strflt.sign == '-') + (precision > 0),
+        (result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE
+            ? result_buffer_count
+            : result_buffer_count - (strflt.sign == '-') - (precision > 0)),
+        precision + 1,
+        &strflt,
+        trailing_digits,
+        rounding_mode,
+        ptd);
+
+    if (e != 0)
+    {
+        result_buffer[0] = '\0';
+        return e;
+    }
+
+    return fp_format_e_internal(result_buffer, result_buffer_count, precision, capitals, min_exponent_digits, &strflt, false, ptd);
+}
+
+static bool fe_to_nearest(double const* const argument, unsigned __int64 const mask, short const maskpos)
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+    components_type const* const components = reinterpret_cast<components_type const*>(argument);
+
+    unsigned short digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
+
+    if (digit > 8)
+    {
+        return true;
+    }
+
+    if (digit < 8)
+    {
+        return false;
+    }
+
+    unsigned __int64 const roundBitsMask = (static_cast<unsigned __int64>(1) << maskpos) - 1;
+    if (components->_mantissa & roundBitsMask)
+    {
+        return true;
+    }
+
+    //if we still have digits to the left to compare
+    if (maskpos != DBL_MANT_DIG - 5)
+    {
+        // We divide the mantisa by 16 to move the digits to the right, after that we apply the mask
+        // to get the digit at the left.
+        digit = static_cast<unsigned short>(((components->_mantissa / 16) & mask) >> maskpos);
+    }
+    else
+    {
+        digit = components->_exponent == 0 ? 0 : 1;
+    }
+
+    return digit % 2 == 1;
+}
+
+static bool should_round_up(double const* const argument, unsigned __int64 const mask, short const maskpos, __acrt_rounding_mode const rounding_mode)
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+    components_type const* const components = reinterpret_cast<components_type const*>(argument);
+
+    unsigned short const digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
+
+    if (rounding_mode == __acrt_rounding_mode::legacy)
+    {
+        return digit >= 8;
+    }
+    int const round_mode = fegetround();
+
+    if (round_mode == FE_TONEAREST)
+    {
+        return fe_to_nearest(argument, mask, maskpos);
+    }
+
+    if (round_mode == FE_UPWARD)
+    {
+        return digit != 0 && !components->_sign;
+    }
+
+    if (round_mode == FE_DOWNWARD)
+    {
+        return digit != 0 && components->_sign;
+    }
+
+    return false;
+}
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %a formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %a
+// printf format.  This format has the form [-]0xh.hhhhp(+/-)d, where there will
+// be 'precision' hex digits following the decimal point.  If the precision is
+// less than or equal to zero, no decimal point will appear.  If 'capitals' is
+// true, then the number will appear as [-]0xH.HHHHP(+/-)d.
+_Success_(return == 0)
+static errno_t __cdecl fp_format_a(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                      result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                        precision,
+    _In_                                                   bool                 const capitals,
+    _In_                                                   unsigned             const min_exponent_digits,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&     ptd
+    )
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    if (precision < 0)
+    {
+        precision = 0;
+    }
+
+    result_buffer[0] = '\0';
+
+    // the constraint for the size of buffer is:
+    // 1 (sign)
+    // 4 ("0xh.")
+    // precision (decimal digits)
+    // 6 ("p+0000")
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > static_cast<size_t>(1 + 4 + precision + 6), ERANGE);
+
+    // Let __acrt_fp_format_e handle the special cases like SNAN, etc.:
+    components_type const* const components = reinterpret_cast<components_type const*>(argument);
+    if (components->_exponent == floating_traits::exponent_mask)
+    {
+        errno_t const e = fp_format_e(
+            argument,
+            result_buffer,
+            result_buffer_count,
+            scratch_buffer,
+            scratch_buffer_count,
+            precision,
+            false,
+            min_exponent_digits,
+            rounding_mode,
+            ptd);
+
+        if (e != 0)
+        {
+            // An error occurred
+            result_buffer[0] = '\0';
+            return e;
+        }
+
+        // Substitute the e with p:
+        char* p = strrchr(result_buffer, 'e');
+        if (p)
+        {
+            *p = capitals ? 'P' : 'p';
+
+            // Trim the exponent (which is 0) to only one digit; skip the
+            // exponent sign and the first digit and put the terminating 0:
+            p += 3;
+            *p = 0;
+        }
+        return e;
+    }
+
+    // Sign:
+    if (components->_sign)
+    {
+        *result_buffer++ = '-';
+    }
+
+    int const hexadd = (capitals ? 'A' : 'a') - '9' - 1;
+
+    // Leading digit (and set the debias):
+    unsigned __int64 debias = floating_traits::exponent_bias;
+    if (components->_exponent == 0)
+    {
+        *result_buffer++ = '0';
+        if (components->_mantissa == 0)
+        {
+            // Zero:
+            debias = 0;
+        }
+        else
+        {
+            // Denormal:
+            debias--;
+        }
+    }
+    else
+    {
+        *result_buffer++ = '1';
+    }
+
+    // Decimal point (save the position in pos):
+    char* pos = result_buffer++;
+    if (precision == 0)
+    {
+        // If precision is 0, then we don't have to print the decimal point:
+        // we mark this putting 0 instead of the decimal point itself
+        *pos = 0;
+    }
+    else
+    {
+        *pos = *ptd.get_locale()->locinfo->lconv->decimal_point;
+    }
+
+    // Mantissa:
+    if (components->_mantissa > 0)
+    {
+        // Print 4 bits at a time, and skip the initial zeroes
+        // Prepare the mask to read the first 4 bits
+        short maskpos = (floating_traits::mantissa_bits - 1) - 4;
+
+        unsigned __int64 mask = 0xf;
+        mask <<= maskpos;
+
+        while (maskpos >= 0 && precision > 0)
+        {
+            unsigned short digit = static_cast<unsigned short>((components->_mantissa & mask) >> maskpos);
+            digit += '0';
+            if (digit > '9')
+            {
+                digit += static_cast<unsigned short>(hexadd);
+            }
+            *result_buffer++ = static_cast<char>(digit);
+            mask >>= 4;
+            maskpos -= 4;
+            --precision;
+        }
+
+        // Round the mantissa:
+        if (maskpos >= 0)
+        {
+            if (should_round_up(argument, mask, maskpos, rounding_mode))
+            {
+                char* p = result_buffer;
+                --p;
+                // If the last digit is 'f', we need to add one to the previous
+                // digit, too; pos is the position of the decimal point
+                while (*p == 'f' || *p == 'F')
+                {
+                    *p-- = '0';
+                }
+                // If we reached the decimal point, it means we are rounding
+                // something like 0x0.fffff so this will become 0x1.00000 :
+                if (p != pos)
+                {
+                    if (*p == '9')
+                    {
+                        *p += static_cast<char>(1 + hexadd);
+                    }
+                    else
+                    {
+                        *p += 1;
+                    }
+                }
+                else // p == pos
+                {
+                    // Skip the decimal point:
+                    --p;
+
+                    // The first digit is always 0 or 1, so we don't need to
+                    // add hexadd:
+                    *p += 1;
+                }
+            }
+        }
+    }
+
+    // Add the final zeroes, if needed:
+    for (; precision > 0; --precision)
+    {
+        *result_buffer++ = '0';
+    }
+
+    // Move back the buffer pointer if there is no decimal point:
+    if (*pos == 0)
+    {
+        result_buffer = pos;
+    }
+
+    // Exponent:
+    *result_buffer++ = capitals ? 'P' : 'p';
+    __int64 exponent = components->_exponent - debias;
+    if (exponent >= 0)
+    {
+        *result_buffer++ = '+';
+    }
+    else
+    {
+        *result_buffer++ = '-';
+        exponent = -exponent;
+    }
+    // Save the position in pos and write a '0':
+    pos = result_buffer;
+    *pos = '0';
+
+    if (exponent >= 1000)
+    {
+        *result_buffer++ = '0' + static_cast<char>(exponent / 1000);
+        exponent %= 1000;
+    }
+    if (result_buffer != pos || exponent >= 100)
+    {
+        *result_buffer++ = '0' + static_cast<char>(exponent / 100);
+        exponent %= 100;
+    }
+    if (result_buffer != pos || exponent >= 10)
+    {
+        *result_buffer++ = '0' + static_cast<char>(exponent / 10);
+        exponent %= 10;
+    }
+
+    *result_buffer++ = '0' + static_cast<char>(exponent);
+
+    // Terminate the string:
+    *result_buffer = '\0';
+
+    return 0;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %f formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %f
+// printf format.  This format has the form [-]ddddd.ddddd, where there will be
+// precision digits following the decimal point.  If precision is less than or
+// equal to zero, no decimal point will appear.  The low order digit is rounded.
+_Success_(return == 0)
+static errno_t fp_format_f_internal(
+    _Pre_z_ _Maybe_unsafe_(_Inout_updates_z_, buffer_count) char*              const buffer,
+    _In_fits_precision_(precision)                          size_t             const buffer_count,
+    _In_                                                    int                const precision,
+    _In_                                                    STRFLT             const pflt,
+    _In_                                                    bool               const g_fmt,
+    _Inout_                                                 __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    int const g_magnitude = pflt->decpt - 1;
+
+    // Place the output in the user's buffer and round.  Save space for the
+    // minus sign now if it will be needed:
+    if (g_fmt && g_magnitude == precision)
+    {
+        char* const p = g_magnitude + buffer + (pflt->sign == '-');
+        p[0] = '0';
+        p[1] = '\0';
+
+        // Allows for extra place-holding '0' in the exponent == precision case
+        // of the %g format.
+    }
+
+    // Now fix up the number to be in the correct %f format:
+    char* p = buffer;
+
+    // Put in a negative sign, if necessary:
+    if (pflt->sign == '-')
+        *p++ = '-';
+
+    // Insert a leading zero for purely fractional values and position ourselves
+    // at the correct spot for inserting the decimal point:
+    if (pflt->decpt <= 0)
+    {
+        // In the specific scenario of the 0 when using g format this would cause
+        // to have an extra zero at the end
+        bool const is_zero_pflt = pflt->decpt == 0 && *pflt->mantissa == '0';
+        if (!g_fmt || !is_zero_pflt) {
+            shift_bytes(buffer, buffer_count, p, 1);
+        }
+        *p++ = '0';
+    }
+    else
+    {
+        p += pflt->decpt;
+    }
+
+    // Put a decimal point if required, and add any needed zero padding:
+    if (precision > 0)
+    {
+        shift_bytes(buffer, buffer_count, p, 1);
+        *p++ = *ptd.get_locale()->locinfo->lconv->decimal_point;
+
+        // If the value is less than 1 then we may need to put zeroes out in
+        // front of the first non-zero digit of the mantissa:
+        if (pflt->decpt < 0)
+        {
+            int const computed_precision = (g_fmt || -pflt->decpt < precision)
+                ? -pflt->decpt
+                : precision;
+
+            shift_bytes(buffer, buffer_count, p, computed_precision);
+            memset(p, '0', computed_precision);
+        }
+    }
+
+    return 0;
+}
+
+_Success_(return == 0)
+static errno_t __cdecl fp_format_f(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                const result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                  const precision,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&     ptd
+    ) throw()
+{
+    _strflt strflt{};
+    __acrt_has_trailing_digits const trailing_digits = __acrt_fltout(
+        *reinterpret_cast<_CRT_DOUBLE const*>(argument),
+        precision,
+        __acrt_precision_style::fixed,
+        &strflt,
+        scratch_buffer,
+        scratch_buffer_count
+        );
+
+    errno_t const e = __acrt_fp_strflt_to_string(
+        result_buffer + (strflt.sign == '-'),
+        (result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE ? result_buffer_count : result_buffer_count - (strflt.sign == '-')),
+        precision + strflt.decpt,
+        &strflt,
+        trailing_digits,
+        rounding_mode,
+        ptd);
+
+    if (e != 0)
+    {
+        result_buffer[0] = '\0';
+        return e;
+    }
+
+    return fp_format_f_internal(result_buffer, result_buffer_count, precision, &strflt, false, ptd);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// %g formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions handle the formatting of floating point values in the %g
+// printf format.  The form used depends on the value converted.  The printf %e
+// form will be used if the magnitude of the value is less than -4 or is greater
+// than 'precision', otherwise %f will be used.  The 'precision' always specifies
+// the number of digits following the decimal point.  The low order digit is
+// appropriately rounded.
+_Success_(return == 0)
+static errno_t __cdecl fp_format_g(
+    _In_                                                   double const*        const argument,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                const result_buffer,
+    _In_fits_precision_(precision)                         size_t               const result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                const scratch_buffer,
+    _In_                                                   size_t               const scratch_buffer_count,
+    _In_                                                   int                  const precision,
+    _In_                                                   bool                 const capitals,
+    _In_                                                   unsigned             const min_exponent_digits,
+    _In_                                                   __acrt_rounding_mode const rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    _strflt strflt{};
+
+    // Generate digits as though we will use %f formatting, then decide based on the result
+    // whether to use %f or %e formatting. %f always requires more generated digits than %e,
+    // so generating them all now will avoid generating more later (generation isn't resumable).
+    __acrt_has_trailing_digits const trailing_digits = __acrt_fltout(
+        *reinterpret_cast<_CRT_DOUBLE const*>(argument),
+        precision,
+        __acrt_precision_style::fixed,
+        &strflt,
+        scratch_buffer,
+        scratch_buffer_count
+        );
+
+    size_t const minus_sign_length = strflt.sign == '-' ? 1 : 0;
+
+    int g_magnitude = strflt.decpt - 1;
+    char* p = result_buffer + minus_sign_length;
+
+    size_t const buffer_count_for_fptostr = result_buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE
+        ? result_buffer_count
+        : result_buffer_count - minus_sign_length;
+
+    errno_t const fptostr_result = __acrt_fp_strflt_to_string(p, buffer_count_for_fptostr, precision, &strflt, trailing_digits, rounding_mode, ptd);
+    if (fptostr_result != 0)
+    {
+        result_buffer[0] = '\0';
+        return fptostr_result;
+    }
+
+    bool const g_round_expansion = g_magnitude < (strflt.decpt - 1);
+
+    // Compute the magnitude of value:
+    g_magnitude = strflt.decpt - 1;
+
+    // Convert value to the C Language g format:
+    if (g_magnitude < -4 || g_magnitude >= precision) // Use e format
+    {
+        // We can ignore the round expansion flag here:  the extra digit will be
+        // overwritten by "e+xxx".
+        return fp_format_e_internal(result_buffer, result_buffer_count, precision, capitals, min_exponent_digits, &strflt, true, ptd);
+    }
+    else // Use f format
+    {
+        if (g_round_expansion)
+        {
+            // Throw away extra final digit from expansion:
+            while (*p++)
+            {
+                // Iterate to the end of the string
+            }
+
+            *(p - 2) = '\0';
+        }
+
+        return fp_format_f_internal(result_buffer, result_buffer_count, precision, &strflt, true, ptd);
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Format Dispatch
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The main floating point formatting dispatch function.  This function just
+// looks at the 'format' character, calls the right formatting function, and
+// returns the result.  The other parameters are passed on to the selected
+// formatting function and are used as described in the documentation for
+// those functions.
+extern "C" errno_t __cdecl __acrt_fp_format(
+    double const*        const value,
+    char*                const result_buffer,
+    size_t               const result_buffer_count,
+    char*                const scratch_buffer,
+    size_t               const scratch_buffer_count,
+    int                  const format,
+    int                  const precision,
+    uint64_t             const options,
+    __acrt_rounding_mode       rounding_mode,
+    __crt_cached_ptd_host&     ptd
+    )
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer != nullptr,  EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, result_buffer_count > 0,   EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, scratch_buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, scratch_buffer_count > 0,  EINVAL);
+
+    bool const use_capitals = format == 'A' || format == 'E' || format == 'F' || format == 'G';
+
+    // Detect special cases (NaNs and infinities) and handle them specially.
+    // Note that the underlying __acrt_fltout function will also handle these
+    // special cases, but it does so using the legacy strings (e.g. 1.#INF).
+    // Our special handling here uses the C99 strings (e.g. INF).
+    if ((options & _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
+    {
+        __acrt_fp_class const classification = __acrt_fp_classify(*value);
+        if (classification != __acrt_fp_class::finite)
+        {
+            return fp_format_nan_or_infinity(
+                classification,
+                __acrt_fp_is_negative(*value),
+                result_buffer,
+                result_buffer_count,
+                use_capitals);
+        }
+    }
+
+    unsigned const min_exponent_digits = (options & _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS) != 0 ? 3 : 2;
+    if ((options & _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING) == 0) {
+        rounding_mode = __acrt_rounding_mode::legacy;
+    }
+
+    switch (format)
+    {
+    case 'a':
+    case 'A':
+        return fp_format_a(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
+
+    case 'e':
+    case 'E':
+        return fp_format_e(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
+
+    case 'f':
+    case 'F':
+        return fp_format_f(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, rounding_mode, ptd);
+
+    default:
+        _ASSERTE(("Unsupported format specifier", 0));
+    case 'g':
+    case 'G':
+        return fp_format_g(value, result_buffer, result_buffer_count, scratch_buffer, scratch_buffer_count, precision, use_capitals, min_exponent_digits, rounding_mode, ptd);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/fcvt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/fcvt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4367a831ef667ccf7f4b622e4f5bf00e0549102e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/fcvt.cpp	
@@ -0,0 +1,296 @@
+//
+// fcvt.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the _ecvt and _fcvt families of functions.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_securecrt.h>
+#include <minmax.h>
+#include <stdlib.h>
+
+
+
+// Tries to get the pre-thread conversion buffer; returns nullptr on failure.
+static char* __cdecl try_get_ptd_buffer(__crt_cached_ptd_host& ptd)
+{
+    __acrt_ptd* const raw_ptd = ptd.get_raw_ptd_noexit();
+    if (!raw_ptd)
+    {
+        return nullptr;
+    }
+
+    if (raw_ptd->_cvtbuf)
+    {
+        return raw_ptd->_cvtbuf;
+    }
+
+    raw_ptd->_cvtbuf = _malloc_crt_t(char, _CVTBUFSIZE).detach();
+
+    return raw_ptd->_cvtbuf;
+}
+
+
+
+// An internal helper that wraps the call to convert the STRFLT to a string and
+// updates all of the data that is used by its callers.
+static errno_t __cdecl internal_to_string(
+    _Out_writes_z_(buffer_count) char* const buffer,
+    size_t                             const buffer_count,
+    STRFLT                             const strflt,
+    int                                const requested_digits,
+    int*                               const decimal_point,
+    int*                               const sign,
+    __crt_cached_ptd_host&                   ptd
+    ) throw()
+{
+    // Make sure we don't overflow the buffer.  If the user asks for more digits
+    // than the buffer can handle, truncate it to the maximum size allowed in
+    // the buffer.  The maximum size is two less than the buffer size because we
+    // use one character for overflow and one for the null terminator.
+    size_t const minimum_buffer_count = static_cast<size_t>((requested_digits > 0 ? requested_digits : 0) + 2);
+
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count >= minimum_buffer_count, ERANGE);
+
+    int const capped_digits = min(requested_digits, static_cast<int>(buffer_count - 2));
+
+    errno_t const e = __acrt_fp_strflt_to_string(buffer, buffer_count, capped_digits, strflt, __acrt_has_trailing_digits::trailing, __acrt_rounding_mode::legacy, ptd);
+
+    if (e != 0)
+    {
+        return ptd.get_errno().set(e);
+    }
+
+    *sign          = strflt->sign == '-' ? 1 : 0;
+    *decimal_point = strflt->decpt;
+
+    return 0;
+}
+
+
+
+// The _fcvt functions, like the _ecvt functions, convert a floating point value
+// to a narrow character string.  The functions prepare the data for the Fortran
+// F-format with the number of digits following the decimal point specified by
+// requested_digits.  The position of the decimal point is returned indirectly
+// through *decimal_point.  The correct digit for Fortran F-format is rounded.
+//
+// These functions update either (a) the user-provided string (_s-suffixed
+// function) or (b) the per-thread conversion buffer.  The _s-suffixed
+// function returns zero on success, or an error code on failure.  The
+// *decimal_point and *sign values are updated with the results of the
+// conversion.
+static errno_t __cdecl _fcvt_s_internal(
+    char*              const buffer,
+    size_t             const buffer_count,
+    double             const value,
+    int                const requested_digits,
+    int*               const decimal_point,
+    int*               const sign,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > 0,  EINVAL);
+    _RESET_STRING(buffer, buffer_count);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, decimal_point != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, sign != nullptr,          EINVAL);
+
+    char result_string[_CVTBUFSIZE + 1];
+
+    _strflt strflt{};
+    __acrt_fltout(
+        reinterpret_cast<_CRT_DOUBLE const&>(value),
+        _countof(result_string),
+        __acrt_precision_style::fixed,
+        &strflt,
+        result_string,
+        _countof(result_string));
+
+    int const actual_digits = strflt.decpt + requested_digits;
+
+    bool const buffer_insufficiently_large =
+        requested_digits > 0 && strflt.decpt > 0 &&
+        actual_digits < requested_digits;
+
+    int const capped_digits = buffer_insufficiently_large ? INT_MAX : actual_digits;
+
+    return internal_to_string(buffer, buffer_count, &strflt, capped_digits, decimal_point, sign, ptd);
+}
+
+extern "C" errno_t __cdecl _fcvt_s(
+    char*  const buffer,
+    size_t const buffer_count,
+    double const value,
+    int    const requested_digits,
+    int*   const decimal_point,
+    int*   const sign
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _fcvt_s_internal(buffer, buffer_count, value, requested_digits, decimal_point, sign, ptd);
+}
+
+static char* __cdecl _fcvt_internal(
+    double             const value,
+    int                const requested_digits,
+    int*               const decimal_point,
+    int*               const sign,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    char* const buffer = try_get_ptd_buffer(ptd);
+    if (!buffer)
+    {
+        return nullptr;
+    }
+
+    char result_string[_CVTBUFSIZE + 1];
+
+    _strflt strflt{};
+    __acrt_fltout(
+        reinterpret_cast<_CRT_DOUBLE const&>(value),
+        _countof(result_string),
+        __acrt_precision_style::fixed,
+        &strflt,
+        result_string,
+        _countof(result_string));
+
+    // Make sure we don't overflow the buffer.  If the user asks for more digits
+    // than the buffer can handle, truncate it to the maximum size allowed in
+    // the buffer.  The maximum size is two less than the buffer size because we
+    // use one character for overflow and one for the null terminator.
+    int const capped_digits = min(requested_digits, _CVTBUFSIZE - 2 - strflt.decpt);
+
+    errno_t const status = _fcvt_s_internal(buffer, _CVTBUFSIZE, value, capped_digits, decimal_point, sign, ptd);
+    if (status != 0)
+    {
+        return nullptr;
+    }
+
+    return buffer;
+}
+
+extern "C" char* __cdecl _fcvt(
+    double const value,
+    int    const requested_digits,
+    int*   const decimal_point,
+    int*   const sign
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _fcvt_internal(value, requested_digits, decimal_point, sign, ptd);
+}
+
+
+// The _ecvt functions, which convert a floating point value to a string.  The
+// position of the decimal point relative to the beginning of the string is
+// stored indirectly through the decimal_point argument, where a negative value
+// means that the decimal point is to the left of the returned digits.  If the
+// sign of the result is negative, the word pointed to by sign is nonzero;
+// otherwise it is zero.  The low order digit is rounded.
+//
+// These functions update either (a) the user-provided string (_s-suffixed
+// function) or (b) the per-thread conversion buffer.  The _s-suffixed
+// function returns zero on success, or an error code on failure.  The
+// *decimal_point and *sign values are updated with the results of the
+// conversion.
+static errno_t __cdecl _ecvt_s_internal(
+    char*              const buffer,
+    size_t             const buffer_count,
+    double             const value,
+    int                const requested_digits,
+    int*               const decimal_point,
+    int*               const sign,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > 0,  EINVAL);
+    _RESET_STRING(buffer, buffer_count);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, decimal_point != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, sign != nullptr,          EINVAL);
+
+    char result_string[_CVTBUFSIZE + 1];
+
+    _strflt strflt{};
+    __acrt_fltout(
+        reinterpret_cast<_CRT_DOUBLE const&>(value),
+        _countof(result_string),
+        __acrt_precision_style::fixed,
+        &strflt,
+        result_string,
+        _countof(result_string));
+
+    errno_t const e = internal_to_string(buffer, buffer_count, &strflt, requested_digits, decimal_point, sign, ptd);
+
+    // Make sure we don't overflow the buffer.  If the user asks for more digits
+    // than the buffer can handle, truncate it to the maximum size allowed in
+    // the buffer.  The maximum size is two less than the buffer size because we
+    // use one character for overflow and one for the null terminator.
+    int const capped_digits = min(requested_digits, static_cast<int>(buffer_count - 2));
+
+    // The conversion function occasionally returns an extra char in the buffer:
+    if (capped_digits >= 0 && buffer[capped_digits])
+    {
+        buffer[capped_digits] = '\0';
+    }
+
+    return e;
+}
+
+extern "C" errno_t __cdecl _ecvt_s(
+    char*  const buffer,
+    size_t const buffer_count,
+    double const value,
+    int    const requested_digits,
+    int*   const decimal_point,
+    int*   const sign
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _ecvt_s_internal(buffer, buffer_count, value, requested_digits, decimal_point, sign, ptd);
+}
+
+static char* __cdecl _ecvt_internal(
+    double             const value,
+    int                const requested_digits,
+    int*               const decimal_point,
+    int*               const sign,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    char* const buffer = try_get_ptd_buffer(ptd);
+    if (!buffer)
+    {
+        return nullptr;
+    }
+
+    // Make sure we don't overflow the buffer.  If the user asks for more digits
+    // than the buffer can handle, truncate it to the maximum size allowed in
+    // the buffer.  The maximum size is two less than the buffer size because we
+    // use one character for overflow and one for the null terminator.
+    int const capped_digits = min(requested_digits, _CVTBUFSIZE - 2);
+
+    errno_t const e = _ecvt_s_internal(buffer, _CVTBUFSIZE, value, capped_digits, decimal_point, sign, ptd);
+    if (e != 0)
+    {
+        return nullptr;
+    }
+
+    return buffer;
+}
+
+extern "C" char* __cdecl _ecvt(
+    double const value,
+    int    const requested_digits,
+    int*   const decimal_point,
+    int*   const sign
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _ecvt_internal(value, requested_digits, decimal_point, sign, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/fp_flags.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/fp_flags.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8c19399154b8af61acb515b67b862c1d345704a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/fp_flags.cpp	
@@ -0,0 +1,20 @@
+//
+// fp_flags.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Public data used by the floating point library
+//
+
+extern "C" int __fastflag{0};
+
+
+
+// Routine to set the fast flag in order to speed up computation
+// of transcendentals at the expense of limiting error checking
+extern "C" int __cdecl __setfflag(int const new_flag)
+{
+    int const old_flag = __fastflag;
+    __fastflag = new_flag;
+    return old_flag;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/gcvt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/gcvt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a79cda0bcca92ab22eba437e46ebf1f2c5b9496
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/gcvt.cpp	
@@ -0,0 +1,159 @@
+//
+// gcvt.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the _gcvt functions, which convert a floating point value to a narrow
+// character string.  It attempts to produce 'precision' significant digits in
+// the Fortran F format if possible, otherwise the E format.  Trailing zeroes may
+// be suppressed.  The _s-suffixed function returns zero on success; an error
+// code on failure.  If the buffer is too small, that is an error.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_stdio_config.h>
+#include <locale.h>
+#include <stdlib.h>
+
+
+
+static errno_t __cdecl _gcvt_s_internal(
+    char*              const buffer,
+    size_t             const buffer_count,
+    double             const value,
+    int                const precision,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer != nullptr, EINVAL);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, buffer_count > 0,  EINVAL);
+    _RESET_STRING(buffer, buffer_count);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, static_cast<size_t>(precision) < buffer_count, ERANGE);
+    // Additional validation will be performed in the fp_format functions.
+
+    char const decimal_point = *ptd.get_locale()->locinfo->lconv->decimal_point;
+
+    // We only call __acrt_fltout in order to parse the correct exponent value (strflt.decpt).
+    // Therefore, we don't want to generate any digits, so we pass a buffer size only large
+    // enough to hold the inf, nan, or ind string to prevent failure.
+
+    size_t const restricted_count = 7; // "1#SNAN" + 1 null terminator
+    char result_string[restricted_count];
+
+    _strflt strflt{};
+
+    __acrt_fltout(
+        reinterpret_cast<_CRT_DOUBLE const&>(value),
+        precision,
+        __acrt_precision_style::fixed,
+        &strflt,
+        result_string,
+        restricted_count);
+
+    int const magnitude = strflt.decpt - 1;
+
+    // Output the result according to the Fortran G format as outlined in the
+    // Fortran language specification.
+    if (magnitude < -1 || magnitude > precision - 1)
+    {
+        // Ew.d where d = precision
+        char scratch_buffer[_CVTBUFSIZE + 1];
+        errno_t const e = __acrt_fp_format(
+            &value,
+            buffer,
+            buffer_count,
+            scratch_buffer,
+            _countof(scratch_buffer),
+            'e',
+            precision - 1,
+            _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS,
+            __acrt_rounding_mode::legacy,
+            ptd);
+
+        if (e != 0)
+        {
+            return ptd.get_errno().set(e);
+        }
+    }
+    else
+    {
+        // Fw.d where d = precision-string->decpt
+        char scratch_buffer[_CVTBUFSIZE + 1];
+        errno_t const e = __acrt_fp_format(
+            &value,
+            buffer,
+            buffer_count,
+            scratch_buffer,
+            _countof(scratch_buffer),
+            'f',
+            precision - strflt.decpt,
+            _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS,
+            __acrt_rounding_mode::legacy,
+            ptd);
+
+        if (e != 0)
+        {
+            return ptd.get_errno().set(e);
+        }
+    }
+
+    // Remove the trailing zeroes before the exponent; we don't need to check
+    // for buffer_count:
+    char* p = buffer;
+    while (*p && *p != decimal_point)
+    {
+        ++p;
+    }
+
+    if (*p == '\0')
+    {
+        return 0;
+    }
+
+    ++p;
+
+    while (*p && *p != 'e')
+    {
+        ++p;
+    }
+
+    char* stop = p;
+    --p;
+
+    while (*p == '0')
+    {
+        --p;
+    }
+
+    while ((*++p = *stop++) != '\0') { }
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _gcvt_s(
+    char*  const buffer,
+    size_t const buffer_count,
+    double const value,
+    int    const precision
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _gcvt_s_internal(buffer, buffer_count, value, precision, ptd);
+}
+
+extern "C" char* __cdecl _gcvt(
+    double const value,
+    int    const precision,
+    char*  const buffer
+    )
+{
+    errno_t const e = _gcvt_s(buffer, _CRT_UNBOUNDED_BUFFER_SIZE, value, precision);
+    if (e != 0)
+    {
+        return nullptr;
+    }
+
+    return buffer;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/isctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/isctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93f99518ca87f54bdf34503839082cc26507276a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/isctype.cpp	
@@ -0,0 +1,116 @@
+//
+// isctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Multibyte and debug support functionality for the character classification
+// functions and macros.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+
+
+// Ensure that the masks used by GetCharType() match the CRT masks, so that we
+// can simply reinterpret the masks.
+#if _UPPER   != C1_UPPER || \
+    _LOWER   != C1_LOWER || \
+    _DIGIT   != C1_DIGIT || \
+    _SPACE   != C1_SPACE || \
+    _PUNCT   != C1_PUNCT || \
+    _CONTROL != C1_CNTRL
+    #error Character type masks do not agree in ctype and winnls
+#endif
+
+
+
+// The _chvalidator function is called by the character classification functions
+// in the debug CRT.  This function tests the character argument to ensure that
+// it is not out of range.  For performance reasons, this function is not used
+// in the retail CRT.
+#if defined _DEBUG
+
+extern "C" int __cdecl _chvalidator(int const c, int const mask)
+{
+    _ASSERTE(c >= -1 && c <= 255);
+    return _chvalidator_l(nullptr, c, mask);
+}
+
+extern "C" int __cdecl _chvalidator_l(_locale_t const locale, int const c, int const mask)
+{
+    _ASSERTE(c >= -1 && c <= 255);
+
+    _LocaleUpdate locale_update(locale);
+
+    return __acrt_locale_get_ctype_array_value(locale_update.GetLocaleT()->locinfo->_public._locale_pctype, c, mask);
+}
+
+#endif // _DEBUG
+
+
+
+// The _isctype and _isctype_l functions provide support to the character
+// classification functions and macros for two-byte multibyte characters.
+// It returns nonzero or zero depending on whether the character argument
+// does or does not satisfy the character class property encoded by the mask.
+//
+// The leadbyte and trailbyte should be packed into the integer c like so:
+//     H.......|.......|.......|.......L
+//         0       0   leadbyte trailbyte
+//
+extern "C" int __cdecl _isctype_l(int const c, int const mask, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c >= -1 && c <= 255)
+    {
+        // Direct access to _locale_pctype is allowed due to bounds check.
+        return locale_update.GetLocaleT()->locinfo->_public._locale_pctype[c] & mask;
+    }
+
+    size_t const buffer_count{3};
+
+    int  buffer_length;
+    char buffer[buffer_count];
+    if (_isleadbyte_fast_internal(c >> 8 & 0xff, locale_update.GetLocaleT()))
+    {
+        buffer[0] = (c >> 8 & 0xff); // Put lead-byte at start of the string
+        buffer[1] = static_cast<char>(c);
+        buffer[2] = '\0';
+        buffer_length = 2;
+    }
+    else
+    {
+        buffer[0] = static_cast<char>(c);
+        buffer[1] = '\0';
+        buffer_length = 1;
+    }
+
+
+    unsigned short character_type[buffer_count]{};
+    if (__acrt_GetStringTypeA(
+            locale_update.GetLocaleT(),
+            CT_CTYPE1,
+            buffer,
+            buffer_length,
+            character_type,
+            locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage,
+            TRUE
+        ) == 0)
+    {
+        return 0;
+    }
+
+    return static_cast<int>(character_type[0] & mask);
+}
+
+extern "C" int __cdecl _isctype(int const c, int const mask)
+{
+    if (__acrt_locale_changed())
+    {
+        return _isctype_l(c, mask, nullptr);
+    }
+
+    return __acrt_locale_get_ctype_array_value(__acrt_initial_locale_data._public._locale_pctype, c, mask);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/ismbstr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/ismbstr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9bbcee79e805c93f1168c8d7bc2dec4983ab881d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/ismbstr.cpp	
@@ -0,0 +1,64 @@
+//
+// ismbstr.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _ismbstrail, which is the context-sensitive MBCS trail-byte function.
+// While much less efficient than _ismbbtrail, it is also much more sophisticated.
+// It determines whether a given sub-string pointer points to a trail byte or not,
+// taking into account the context of the string.
+//
+// These functions return -1 if the pointer points to a trail byte; 0 if it does
+// not.
+//
+// These functions are intended for use with single/double byte character sets (DBCS)
+// and are meaningless for UTF-8 which has more than just a lead/trail byte pair.
+// for UTF-8 these functions always return FALSE.
+//
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+
+extern "C" int __cdecl _ismbstrail_l(
+    unsigned char const*       string,
+    unsigned char const*       current,
+    _locale_t            const locale
+    )
+{
+    _VALIDATE_RETURN(string != nullptr,  EINVAL, 0);
+    _VALIDATE_RETURN(current != nullptr, EINVAL, 0);
+
+    _LocaleUpdate locale_update(locale);
+
+    if (locale_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+        return 0;
+
+    while (string <= current && *string)
+    {
+        if (_ismbblead_l((*string), locale_update.GetLocaleT()))
+        {
+            if (++string == current) // check trail byte
+                return -1;
+
+            if (*string == 0)
+                return 0;
+        }
+        ++string;
+    }
+
+    return 0;
+}
+
+extern "C" int __cdecl _ismbstrail(
+    unsigned char const* const string,
+    unsigned char const* const current
+    )
+{
+    return _ismbstrail_l(string, current, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/iswctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/iswctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0807f816f3892a70cbbf4954d23e66d45a96b647
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/iswctype.cpp	
@@ -0,0 +1,55 @@
+//
+// iswctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Support functionality for the wide character classification functions and
+// macros.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+
+
+// Ensure that the masks used by GetCharType() match the CRT masks, so that we
+// can simply reinterpret the masks.
+#if _UPPER   != C1_UPPER || \
+    _LOWER   != C1_LOWER || \
+    _DIGIT   != C1_DIGIT || \
+    _SPACE   != C1_SPACE || \
+    _PUNCT   != C1_PUNCT || \
+    _CONTROL != C1_CNTRL
+    #error Character type masks do not agree in ctype and winnls
+#endif
+
+
+
+// The iswctype functions are called by the wide character classification
+// functions and macros (e.g. iswalpha) when their argument is a wide
+// character greater than 255.  It is also a standard function and can be
+// called by the user, even for characters less than 256.  The function
+// returns nonzero if the argument c satisfies the character class property
+// encoded by the mask.  Returns zero otherwise, or for WEOF.  These functions
+// are neither locale nor codepage dependent.
+extern "C" int __cdecl _iswctype_l(wint_t const c, wctype_t const mask, _locale_t)
+{
+    return iswctype(c, mask);
+}
+
+extern "C" int __cdecl iswctype(wint_t const c, wctype_t const mask)
+{
+    if (c == WEOF)
+        return 0;
+
+    if (c < 256)
+        return static_cast<int>(_pwctype[c] & mask);
+
+    wchar_t const wide_character = c;
+
+    wint_t char_type = 0;
+    if (__acrt_GetStringTypeW(CT_CTYPE1, &wide_character, 1, &char_type) == 0)
+        return 0;
+
+    return static_cast<int>(char_type & mask);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mblen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mblen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dff1b8ac10d6fb4f200fbf4b6f05e32f3a6b2b9f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mblen.cpp	
@@ -0,0 +1,124 @@
+//
+// mblen.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The mblen() and _mblen_l() functions, which return the number of bytes
+// contained in a multibyte character.
+//
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+using namespace __crt_mbstring;
+
+// Computes the number of bytes contained in a multibyte character.  If the string
+// is null, zero is returned to indicate that we support only state-independent
+// character encodings.  If the next max_count bytes of the string are not a valid
+// multibyte character, -1 is returned.  Otherwise, the number of bytes that
+// compose the next multibyte character are returned.
+static int __cdecl _mblen_internal(
+    char const*        const string,
+    size_t             const max_count,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    mbstate_t internal_state{};
+    if (!string || *string == '\0' || max_count == 0)
+    {
+        internal_state = {};
+        return 0;
+    }
+
+    _locale_t const locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        int result = static_cast<int>(__mbrtowc_utf8(nullptr, string, max_count, &internal_state, ptd));
+        if (result < 0)
+        {
+            result = -1;
+        }
+        return result;
+    }
+
+    _ASSERTE(
+        locale->locinfo->_public._locale_mb_cur_max == 1 ||
+        locale->locinfo->_public._locale_mb_cur_max == 2);
+
+    if (_isleadbyte_fast_internal(static_cast<unsigned char>(*string), locale))
+    {
+        _ASSERTE(locale->locinfo->_public._locale_lc_codepage != CP_UTF8 && L"UTF-8 isn't supported in this _mblen_l function yet!!!");
+
+        // If this is a lead byte, then the codepage better be a multibyte codepage
+        _ASSERTE(locale->locinfo->_public._locale_mb_cur_max > 1);
+
+        // Multi-byte character; verify that it is valid:
+        if (locale->locinfo->_public._locale_mb_cur_max <= 1)
+        {
+            return -1;
+        }
+
+        if (max_count > INT_MAX || static_cast<int>(max_count) < locale->locinfo->_public._locale_mb_cur_max)
+        {
+            return -1;
+        }
+
+        int const status = __acrt_MultiByteToWideChar(
+            locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            string,
+            locale->locinfo->_public._locale_mb_cur_max,
+            nullptr,
+            0);
+
+        if (status == 0)
+        {
+            return -1;
+        }
+
+        return locale->locinfo->_public._locale_mb_cur_max;
+    }
+    else
+    {
+        // Single byte character; verify that it is valid:
+        // CP_ACP is known to be valid for all values
+        if (locale->locinfo->_public._locale_lc_codepage != CP_ACP)
+        {
+            int const status = __acrt_MultiByteToWideChar(
+                locale->locinfo->_public._locale_lc_codepage,
+                MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+                string,
+                1,
+                nullptr,
+                0);
+
+            if (status == 0)
+            {
+                return -1;
+            }
+        }
+
+        return sizeof(char);
+    }
+}
+
+extern "C" int __cdecl _mblen_l(
+    char const* const string,
+    size_t      const max_count,
+    _locale_t   const locale
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return _mblen_internal(string, max_count, ptd);
+}
+
+
+
+extern "C" int __cdecl mblen(
+    char const* const string,
+    size_t      const max_count
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _mblen_internal(string, max_count, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtoc16.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtoc16.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d8040a7c9f68dcaf327217348530b53b2b134416
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtoc16.cpp	
@@ -0,0 +1,88 @@
+//
+// mbrtoc16.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <errno.h>
+#include <uchar.h>
+#include <wchar.h>
+
+using namespace __crt_mbstring;
+
+namespace
+{
+    inline size_t begin_surrogate_state(char16_t* pc16, char32_t c32, size_t retval, mbstate_t* ps)
+    {
+        ps->_Wchar = c32;
+        ps->_State = static_cast<decltype(ps->_State)>(-1);
+        if (pc16)
+        {
+            *pc16 = static_cast<char16_t>((((c32 - 0x10000) & 0xfffff) >> 10) | 0xd800);
+        }
+        return retval;
+    }
+
+    inline size_t end_surrogate_state(char16_t* pc16, mbstate_t* ps)
+    {
+        if (pc16)
+        {
+            *pc16 = ((ps->_Wchar - 0x10000) & 0x03ff) | 0xdc00;
+        }
+        return reset_and_return(static_cast<size_t>(-3), ps);
+    }
+
+    inline bool is_surrogate_state(const mbstate_t* ps)
+    {
+        return ps->_State == static_cast<decltype(ps->_State)>(-1);
+    }
+}
+
+extern "C" size_t __cdecl mbrtoc16(char16_t* pc16, const char* s, size_t n, mbstate_t* ps)
+{
+    // TODO: Bug 13307590 says this is always assuming UTF-8.
+     __crt_cached_ptd_host ptd;
+    return __mbrtoc16_utf8(pc16, s, n, ps, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__mbrtoc16_utf8(char16_t* pc16, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    static mbstate_t internal_pst{};
+    if (ps == nullptr)
+    {
+        ps = &internal_pst;
+    }
+
+    if (is_surrogate_state(ps))
+    {
+        return end_surrogate_state(pc16, ps);
+    }
+
+    char32_t c32;
+    const size_t retval = __mbrtoc32_utf8(&c32, s, n, ps, ptd);
+    if (!s || retval == INVALID || retval == INCOMPLETE)
+    {
+        return retval;
+    }
+    else if (c32 > 0x10ffff)
+    {
+        // Input is out of range for UTF-16
+        return return_illegal_sequence(ps, ptd);
+    }
+
+    // Got a valid character
+    if (c32 <= 0xffff)
+    {
+        if (pc16)
+        {
+            *pc16 = static_cast<char16_t>(c32);
+        }
+        return reset_and_return(retval, ps);
+    }
+    else
+    {
+        return begin_surrogate_state(pc16, c32, retval, ps);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtoc32.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtoc32.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d3b8734cc0ee39a66bfc5c559a7d4c57142fa508
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtoc32.cpp	
@@ -0,0 +1,167 @@
+//
+// mbrtoc32.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <errno.h>
+#include <stdint.h>
+#include <uchar.h>
+
+using namespace __crt_mbstring;
+
+int __cdecl __crt_mbstring::__mblen_utf8(const char *s)
+{
+    // Optimize for ASCII if in initial state
+    const uint8_t first_byte = *s;
+    if ((first_byte & 0x80) == 0)
+    {
+        return first_byte == '\0' ? 0 : 1;
+    }
+    else if ((first_byte & 0xe0) == 0xc0)
+    {
+        return 2;
+    }
+    else if ((first_byte & 0xf0) == 0xe0)
+    {
+        return 3;
+    }
+    else if ((first_byte & 0xf8) == 0xf0)
+    {
+        return 4;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+extern "C" size_t __cdecl mbrtoc32(char32_t* pc32, const char* s, size_t n, mbstate_t* ps)
+{
+    // TODO: Bug 13307590 says this is always assuming UTF-8.
+    __crt_cached_ptd_host ptd;
+    return __mbrtoc32_utf8(pc32, s, n, ps, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__mbrtoc32_utf8(char32_t* pc32, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    const char* begin = s;
+    static mbstate_t internal_pst{};
+    if (ps == nullptr)
+    {
+        ps = &internal_pst;
+    }
+
+    if (!s)
+    {
+        s = "";
+        n = 1;
+        pc32 = nullptr;
+    }
+
+    if (n == 0)
+    {
+        return INCOMPLETE;
+    }
+
+    // Retrieve the first byte from the string, or from the previous state
+    uint8_t length;
+    uint8_t bytes_needed;
+    char32_t c32;
+    const bool init_state = (ps->_State == 0);
+    if (init_state)
+    {
+        const int code_point_length = __mblen_utf8(s);
+        const uint8_t first_byte = static_cast<uint8_t>(*s++);
+
+        if (code_point_length == 0 || code_point_length == 1)
+        {
+            if (pc32 != nullptr)
+            {
+                *pc32 = first_byte;
+            }
+            return code_point_length;
+        }
+
+        if (code_point_length >= 2 && code_point_length <= 4)
+        {
+            length = static_cast<uint8_t>(code_point_length);
+        }
+        else
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+
+        bytes_needed = length;
+        // Mask out the length bits
+        c32 = first_byte & ((1 << (7 - length)) - 1);
+    }
+    else
+    {
+        c32 = ps->_Wchar;
+        length = static_cast<uint8_t>(ps->_Byte);
+        bytes_needed = static_cast<uint8_t>(ps->_State);
+
+        // Make sure we don't have some sort of invalid/corrupted state.
+        // Any input that left behind state would have been more than one byte long
+        // and the first byte should have been processed already.
+        if (length < 2 || length > 4 || bytes_needed < 1 || bytes_needed >= length)
+        {
+            return return_illegal_sequence(ps, ptd);
+        }
+    }
+
+    // Don't read more bytes than we're allowed
+    if (bytes_needed < n)
+    {
+        n = bytes_needed;
+    }
+
+    // We've already read the first byte.
+    // All remaining bytes should be continuation bytes
+    while (static_cast<size_t>(s - begin) < n)
+    {
+        uint8_t current_byte = static_cast<uint8_t>(*s++);
+        if ((current_byte & 0xc0) != 0x80)
+        {
+            // Not a continuation character
+            return return_illegal_sequence(ps, ptd);
+        }
+        c32 = (c32 << 6) | (current_byte & 0x3f);
+    }
+
+    if (n < bytes_needed)
+    {
+        // Store state and return incomplete
+        auto bytes_remaining = static_cast<uint8_t>(bytes_needed - n);
+        static_assert(sizeof(mbstate_t::_Wchar) >= sizeof(char32_t), "mbstate_t has broken mbrtoc32");
+        ps->_Wchar = c32;
+        ps->_Byte = length;
+        ps->_State = bytes_remaining;
+        return INCOMPLETE;
+    }
+
+    if ((0xd800 <= c32 && c32 <= 0xdfff) || (0x10ffff < c32))
+    {
+        // Invalid code point (surrogate or out of range)
+        return return_illegal_sequence(ps, ptd);
+    }
+
+    constexpr char32_t min_legal[3]{ 0x80, 0x800, 0x10000 };
+    if (c32 < min_legal[length - 2])
+    {
+        // Overlong encoding
+        return return_illegal_sequence(ps, ptd);
+    }
+
+    // Success! Store results
+    if (pc32 != nullptr)
+    {
+        *pc32 = c32;
+    }
+
+    return reset_and_return(c32 == U'\0' ? 0 : bytes_needed, ps);
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtowc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtowc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d326cb0a74b9144c2371f41f5d74b2cd03000667
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbrtowc.cpp	
@@ -0,0 +1,610 @@
+/***
+*mbrtowc.c - Convert multibyte char to wide char.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Convert a multibyte character into the equivalent wide character.
+*
+*******************************************************************************/
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_securecrt.h>
+#include <limits.h>
+#include <locale.h>
+#include <stdio.h>
+#include <uchar.h>
+#include <wchar.h>
+
+using namespace __crt_mbstring;
+
+/***
+*errno_t _mbrtowc_internal() - Helper function to convert multibyte char to wide character.
+*
+*Purpose:
+*       Convert a multi-byte character into the equivalent wide character,
+*       according to the specified LC_CTYPE category, or the current locale.
+*       [ANSI].
+*
+*       NOTE:  Currently, the C libraries support the "C" locale only.
+*              Non-C locale support now available under _INTL switch.
+*Entry:
+*       wchar_t *dst       = pointer to (single) destination wide character
+*       const char *s      = pointer to multibyte character
+*       size_t n           = maximum length of multibyte character to consider
+*       mbstate_t *pmbst   = pointer to state (must be not nullptr)
+*       _locale_t plocinfo = locale info
+*
+*Exit:
+*       returns, in *pRetValue:
+*       If s = nullptr, 0, indicating we only use state-independent
+*       character encodings.
+*       If s != nullptr:  0 (if *s = null char)
+*                      -1 (if the next n or fewer bytes not valid mbc)
+*                      number of bytes comprising converted mbc
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+_Success_(return != 0)
+_Post_satisfies_(*pRetValue <= _String_length_(s))
+static errno_t __cdecl _mbrtowc_internal(
+    _Inout_ _Out_range_(<=, 1)              int *                  pRetValue,
+    _Pre_maybenull_ _Out_writes_opt_z_(1)   wchar_t *              dst,
+    _In_opt_z_                              const char *           s,
+    _In_                                    size_t                 n,
+    _Inout_                                 mbstate_t *            pmbst,
+    _Inout_                                 __crt_cached_ptd_host& ptd
+    ) throw()
+{
+    _ASSERTE(pmbst != nullptr);
+    _ASSIGN_IF_NOT_NULL(dst, 0);
+
+    if (!s || n == 0)
+    {
+        /* indicate do not have state-dependent encodings,
+        handle zero length string */
+        _ASSIGN_IF_NOT_NULL(pRetValue, 0);
+        return 0;
+    }
+
+    if (!*s)
+    {
+        /* handle nullptr char */
+        _ASSIGN_IF_NOT_NULL(pRetValue, 0);
+        return 0;
+    }
+
+    const _locale_t locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        const size_t retval = __mbrtowc_utf8(dst, s, n, pmbst, ptd);
+        _ASSIGN_IF_NOT_NULL(pRetValue, static_cast<int>(retval));
+        return ptd.get_errno().value_or(0);
+    }
+
+    const int locale_mb_cur_max = locale->locinfo->_public._locale_mb_cur_max;
+    _ASSERTE(locale_mb_cur_max == 1 || locale_mb_cur_max == 2);
+
+    if (locale->locinfo->locale_name[LC_CTYPE] == nullptr)
+    {
+        _ASSIGN_IF_NOT_NULL(dst, (wchar_t) (unsigned char) *s);
+        _ASSIGN_IF_NOT_NULL(pRetValue, 1);
+        return 0;
+    }
+
+    if (pmbst->_Wchar != 0)
+    {
+        /* complete two-byte multibyte character */
+        ((char *) pmbst)[1] = *s;
+        if (locale_mb_cur_max <= 1 ||
+            (__acrt_MultiByteToWideChar(
+            locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            (char *) pmbst,
+            2,
+            dst,
+            (dst != nullptr ? 1 : 0)) == 0))
+        {
+            /* translation failed */
+            pmbst->_Wchar = 0;
+            _ASSIGN_IF_NOT_NULL(dst, 0);
+            _ASSIGN_IF_NOT_NULL(pRetValue, -1);
+            return ptd.get_errno().set(EILSEQ);
+        }
+        pmbst->_Wchar = 0;
+        _ASSIGN_IF_NOT_NULL(pRetValue, locale_mb_cur_max);
+        return 0;
+    }
+    else if (_isleadbyte_fast_internal((unsigned char) *s, locale))
+    {
+        /* multi-byte char */
+        if (n < (size_t) locale_mb_cur_max)
+        {
+            /* save partial multibyte character */
+            ((char *) pmbst)[0] = *s;
+            _ASSIGN_IF_NOT_NULL(pRetValue, -2);
+            return 0;
+        }
+        else if (locale_mb_cur_max <= 1 ||
+            (__acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            s,
+            static_cast<int>(__min(strlen(s), INT_MAX)),
+            dst,
+            (dst != nullptr ? 1 : 0)) == 0))
+        {
+            /* validate high byte of mbcs char */
+            if (!*(s + 1))
+            {
+                pmbst->_Wchar = 0;
+                _ASSIGN_IF_NOT_NULL(dst, 0);
+                _ASSIGN_IF_NOT_NULL(pRetValue, -1);
+                return ptd.get_errno().set(EILSEQ);
+            }
+        }
+        _ASSIGN_IF_NOT_NULL(pRetValue, locale_mb_cur_max);
+        return 0;
+    }
+    else {
+        /* single byte char */
+        if (__acrt_MultiByteToWideChar(
+            locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            s,
+            1,
+            dst,
+            (dst != nullptr ? 1 : 0)) == 0)
+        {
+            _ASSIGN_IF_NOT_NULL(dst, 0);
+            _ASSIGN_IF_NOT_NULL(pRetValue, -1);
+            return ptd.get_errno().set(EILSEQ);
+        }
+
+        _ASSIGN_IF_NOT_NULL(pRetValue, sizeof(char) );
+        return 0;
+    }
+}
+
+
+/***
+*wint_t btowc(c) - translate single byte to wide char
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" wint_t __cdecl btowc(
+    int c
+    )
+{
+    if (c == EOF)
+    {
+        return WEOF;
+    }
+    else
+    {
+        /* convert as one-byte string */
+        char ch = (char) c;
+        mbstate_t mbst = {};
+        wchar_t wc = 0;
+        int retValue = -1;
+
+        __crt_cached_ptd_host ptd;
+        _mbrtowc_internal(&retValue, &wc, &ch, 1, &mbst, ptd);
+        return (retValue < 0 ? WEOF : wc);
+    }
+}
+
+
+/***
+*size_t mbrlen(s, n, pst) - determine next multibyte code, restartably
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl mbrlen(
+    const char *s,
+    size_t n,
+    mbstate_t *pst
+    )
+{
+    static mbstate_t mbst = {};
+    int retValue = -1;
+
+    __crt_cached_ptd_host ptd;
+    _mbrtowc_internal(&retValue, nullptr, s, n, (pst != nullptr ? pst : &mbst), ptd);
+    return retValue;
+}
+
+
+/***
+*size_t mbrtowc(pwc, s, n, pst) - translate multibyte to wchar_t, restartably
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl mbrtowc(
+    wchar_t *dst,
+    const char *s,
+    size_t n,
+    mbstate_t *pst
+    )
+{
+    static mbstate_t mbst = {};
+    int retValue = -1;
+
+    __crt_cached_ptd_host ptd;
+
+    if (s != nullptr)
+    {
+        _mbrtowc_internal(&retValue, dst, s, n, (pst != nullptr ? pst : &mbst), ptd);
+    }
+    else
+    {
+        _mbrtowc_internal(&retValue, nullptr, "", 1, (pst != nullptr ? pst : &mbst), ptd);
+    }
+    return retValue;
+}
+
+
+/***
+*size_t mbsrtowcs(wcs, ps, n, pst) - translate multibyte string to wide,
+*       restartably
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/* Helper function shared by the secure and non-secure versions. */
+
+_Success_(return == 0)
+static size_t __cdecl _mbsrtowcs_helper(
+    _Out_writes_opt_z_(n)               wchar_t *              wcs,
+    _Deref_pre_opt_z_                   const char **          ps,
+    _In_                                size_t                 n,
+    _Inout_                             mbstate_t *            pst,
+    _Inout_                             __crt_cached_ptd_host& ptd
+    ) throw()
+{
+    /* validation section */
+    _UCRT_VALIDATE_RETURN(ptd, ps != nullptr, EINVAL, (size_t) - 1);
+
+    static mbstate_t mbst = {};
+    const char *s = *ps;
+    int i = 0;
+    size_t nwc = 0;
+
+    // Use the static cached state if necessary
+    if (pst == nullptr)
+    {
+        pst = &mbst;
+    }
+
+    const _locale_t locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        return __mbsrtowcs_utf8(wcs, ps, n, pst, ptd);
+    }
+
+    if (wcs == nullptr)
+    {
+        for (;; ++nwc, s += i)
+        {
+            /* translate but don't store */
+            wchar_t wc;
+            _mbrtowc_internal(&i, &wc, s, INT_MAX, pst, ptd);
+            if (i < 0)
+            {
+                return (size_t) - 1;
+            }
+            else if (i == 0)
+            {
+                return nwc;
+            }
+        }
+    }
+
+    for (; 0 < n; ++nwc, s += i, ++wcs, --n)
+    {
+        /* translate and store */
+        _mbrtowc_internal(&i, wcs, s, INT_MAX, pst, ptd);
+        if (i < 0)
+        {
+            /* encountered invalid sequence */
+            nwc = (size_t) - 1;
+            break;
+        }
+        else if (i == 0)
+        {
+            /* encountered terminating null */
+            s = 0;
+            break;
+        }
+    }
+
+    *ps = s;
+    return nwc;
+}
+
+/***
+*size_t mbsrtowcs() - Convert multibyte char string to wide char string.
+*
+*Purpose:
+*       Convert a multi-byte char string into the equivalent wide char string,
+*       according to the LC_CTYPE category of the current locale.
+*       Same as mbsrtowcs_s(), but the destination may not be null terminated.
+*       If there's not enough space, we return EINVAL.
+*
+*Entry:
+*       wchar_t *pwcs = pointer to destination wide character string buffer
+*       const char **s = pointer to source multibyte character string
+*       size_t n = maximum number of wide characters to store (not including the terminating null character)
+*       mbstate_t *pst = pointer to the conversion state
+*
+*Exit:
+*       The nunber if wide characters written to *wcs, not including any terminating null character)
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+extern "C" size_t __cdecl mbsrtowcs(
+    wchar_t *     wcs,
+    const char ** ps,
+    size_t        n,
+    mbstate_t *   pst
+    )
+{
+    /* Call a non-deprecated helper to do the work. */
+    __crt_cached_ptd_host ptd;
+    return _mbsrtowcs_helper(wcs, ps, n, pst, ptd);
+}
+
+
+/***
+*errno_t mbsrtowcs_s() - Convert multibyte char string to wide char string.
+*
+*Purpose:
+*       Convert a multi-byte char string into the equivalent wide char string,
+*       according to the LC_CTYPE category of the current locale.
+*       Same as mbsrtowcs(), but the destination is ensured to be null terminated.
+*       If there's not enough space, we return EINVAL.
+*
+*Entry:
+*       size_t *pRetValue = Number of bytes modified including the terminating nullptr
+*                           This pointer can be nullptr.
+*       wchar_t *pwcs = pointer to destination wide character string buffer
+*       size_t sizeInWords = size of the destination buffer
+*       const char **s = pointer to source multibyte character string
+*       size_t n = maximum number of wide characters to store (not including the terminating null character)
+*       mbstate_t *pst = pointer to the conversion state
+*
+*Exit:
+*       The error code.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static errno_t __cdecl mbsrtowcs_s_internal(
+    size_t *               pRetValue,
+    wchar_t *              dst,
+    size_t                 sizeInWords,
+    const char **          ps,
+    size_t                 n,
+    mbstate_t *            pmbst,
+    __crt_cached_ptd_host& ptd
+    )
+{
+    size_t retsize;
+
+    /* validation section */
+    _ASSIGN_IF_NOT_NULL(pRetValue, (size_t) - 1);
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, (dst == nullptr && sizeInWords == 0) || (dst != nullptr && sizeInWords > 0), EINVAL);
+    if (dst != nullptr)
+    {
+        _RESET_STRING(dst, sizeInWords);
+    }
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, ps != nullptr, EINVAL);
+
+    /* Call a non-deprecated helper to do the work. */
+
+    retsize = _mbsrtowcs_helper(dst, ps, (n > sizeInWords ? sizeInWords : n), pmbst, ptd);
+
+    if (retsize == (size_t) - 1)
+    {
+        if (dst != nullptr)
+        {
+            _RESET_STRING(dst, sizeInWords);
+        }
+        return ptd.get_errno().value_or(0);
+    }
+
+    /* count the null terminator */
+    retsize++;
+
+    if (dst != nullptr)
+    {
+        /* return error if the string does not fit */
+        if (retsize > sizeInWords)
+        {
+            _RESET_STRING(dst, sizeInWords);
+            _UCRT_VALIDATE_RETURN_ERRCODE(ptd, sizeInWords <= retsize, ERANGE);
+        }
+        else
+        {
+            /* ensure the string is null terminated */
+            dst[retsize - 1] = '\0';
+        }
+    }
+
+    _ASSIGN_IF_NOT_NULL(pRetValue, retsize);
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl mbsrtowcs_s(
+    size_t *      pRetValue,
+    wchar_t *     dst,
+    size_t        sizeInWords,
+    const char ** ps,
+    size_t        n,
+    mbstate_t *   pmbst
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return mbsrtowcs_s_internal(pRetValue, dst, sizeInWords, ps, n, pmbst, ptd);
+}
+
+size_t __cdecl __crt_mbstring::__mbrtowc_utf8(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    static_assert(sizeof(wchar_t) == 2, "wchar_t is assumed to be 16 bits");
+    char32_t c32;
+    const size_t retval = __mbrtoc32_utf8(&c32, s, n, ps, ptd);
+    // If we succesfully consumed a character, write the result after a quick range check
+    if (retval <= 4)
+    {
+        if (c32 > 0xffff)
+        {
+            // A 4-byte UTF-8 character won't fit into a single UTF-16 wchar
+            // So return the "replacement char"
+            c32 = 0xfffd;
+        }
+        _ASSIGN_IF_NOT_NULL(pwc, static_cast<wchar_t>(c32));
+    }
+    return retval;
+}
+
+size_t __cdecl __crt_mbstring::__mbsrtowcs_utf8(wchar_t* dst, const char** src, size_t len, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    const char* current_src = *src;
+
+    auto compute_available = [](const char* s) -> size_t
+    {
+        // We shouldn't just blindly request to read 4 bytes, because there might not be 4 bytes left to read.
+        if (s[0] == '\0')
+        {
+            return 1;
+        }
+        else if (s[1] == '\0')
+        {
+            return 2;
+        }
+        else if (s[2] == '\0')
+        {
+            return 3;
+        }
+        return 4;
+    };
+
+    if (dst != nullptr)
+    {
+        wchar_t* current_dest = dst;
+        for (; len > 0; --len)
+        {
+            const size_t avail = compute_available(current_src);
+            char32_t c32;
+            const size_t retval = __mbrtoc32_utf8(&c32, current_src, avail, ps, ptd);
+            if (retval == __crt_mbstring::INVALID)
+            {
+                // Set src to the beginning of the invalid char
+                *src = current_src;
+                ptd.get_errno().set(EILSEQ);
+                return retval;
+            }
+            else if (retval == 0)
+            {
+                current_src = nullptr;
+                *current_dest = L'\0';
+                break;
+            }
+            else if (c32 > 0xffff)
+            {
+                // This is going to take two output wchars. Make sure we have enough room for this output.
+                if (len > 1)
+                {
+                    --len;
+                    c32 -= 0x10000;
+                    const char16_t high_surrogate = static_cast<char16_t>((c32 >> 10) | 0xd800);
+                    const char16_t low_surrogate = static_cast<char16_t>((c32 & 0x03ff) | 0xdc00);
+                    *current_dest++ = high_surrogate;
+                    *current_dest++ = low_surrogate;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            else
+            {
+                *current_dest++ = static_cast<wchar_t>(c32);
+            }
+            current_src += retval;
+        }
+        *src = current_src;
+        return current_dest - dst;
+    }
+    else
+    {
+        size_t total_count = 0;
+        for (;; ++total_count)
+        {
+            const size_t avail = compute_available(current_src);
+
+            const size_t retval = __mbrtoc32_utf8(nullptr, current_src, avail, ps, ptd);
+            if (retval == __crt_mbstring::INVALID)
+            {
+                ptd.get_errno().set(EILSEQ);
+                return retval;
+            }
+            else if (retval == 0)
+            {
+                break;
+            }
+            else if (retval == 4)
+            {
+                // SMP characters take two UTF-16 wide chars
+                ++total_count;
+            }
+            else
+            {
+                // This should be impossible. Means we encountered a multibyte char
+                // that extended past the null terminator, or is more than 4 bytes long
+                _ASSERTE(retval != __crt_mbstring::INCOMPLETE);
+            }
+            current_src += retval;
+        }
+        return total_count;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbstowcs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbstowcs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c0a2d35916687be9ea01ae254c71bfa7da7b5dbc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbstowcs.cpp	
@@ -0,0 +1,326 @@
+/***
+*mbstowcs.c - Convert multibyte char string to wide char string.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Convert a multibyte char string into the equivalent wide char string.
+*
+*******************************************************************************/
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_securecrt.h>
+#include <ctype.h>
+#include <errno.h>
+#include <locale.h>
+#include <stdlib.h>
+
+using namespace __crt_mbstring;
+
+/***
+*size_t mbstowcs() - Convert multibyte char string to wide char string.
+*
+*Purpose:
+*       Convert a multi-byte char string into the equivalent wide char string,
+*       according to the LC_CTYPE category of the current locale.
+*       [ANSI].
+*
+*Entry:
+*       wchar_t *pwcs = pointer to destination wide character string buffer
+*       const char *s = pointer to source multibyte character string
+*       size_t      n = maximum number of wide characters to store
+*
+*Exit:
+*       If pwcs != nullptr returns the number of words modified (<=n): note that
+*       if the return value == n, then no destination string is not 0 terminated.
+*       If pwcs == nullptr returns the length (not size) needed for the destination buffer.
+*
+*Exceptions:
+*       Returns (size_t)-1 if s is nullptr or invalid mbcs character encountered
+*       and errno is set to EILSEQ.
+*
+*******************************************************************************/
+
+/* Helper shared by secure and non-secure functions */
+
+static size_t __cdecl _mbstowcs_l_helper(
+    _Out_writes_opt_z_(n)               wchar_t *              pwcs,
+    _In_reads_or_z_(n) _Pre_z_          const char *           s,
+    _In_                                size_t                 n,
+    _In_opt_                            __crt_cached_ptd_host& ptd
+    ) throw()
+{
+    size_t count = 0;
+
+    if (pwcs && n == 0)
+    {
+        /* dest string exists, but 0 bytes converted */
+        return (size_t) 0;
+    }
+
+    if (pwcs && n > 0)
+    {
+        *pwcs = '\0';
+    }
+
+    /* validation section */
+    _UCRT_VALIDATE_RETURN(ptd, s != nullptr, EINVAL, (size_t) - 1);
+
+    _locale_t const locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        mbstate_t state{};
+        return __mbsrtowcs_utf8(pwcs, &s, n, &state, ptd);
+    }
+
+    /* if destination string exists, fill it in */
+    if (pwcs)
+    {
+        if (locale->locinfo->locale_name[LC_CTYPE] == nullptr)
+        {
+            /* C locale: easy and fast */
+            while (count < n)
+            {
+                *pwcs = (wchar_t) ((unsigned char) s[count]);
+                if (!s[count])
+                {
+                    return count;
+                }
+                count++;
+                pwcs++;
+            }
+            return count;
+
+        }
+        else {
+            int bytecnt, charcnt;
+            unsigned char *p;
+
+            /* Assume that the buffer is large enough */
+            if ((count = __acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage,
+                MB_PRECOMPOSED |
+                MB_ERR_INVALID_CHARS,
+                s,
+                -1,
+                pwcs,
+                (int) n)) != 0)
+            {
+                return count - 1; /* don't count NUL */
+            }
+
+            if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+            {
+                ptd.get_errno().set(EILSEQ);
+                *pwcs = '\0';
+                return (size_t) - 1;
+            }
+
+            /* User-supplied buffer not large enough. */
+
+            /* How many bytes are in n characters of the string? */
+            charcnt = (int) n;
+            for (p = (unsigned char *) s; (charcnt-- && *p); p++)
+            {
+                if (_isleadbyte_fast_internal(*p, locale))
+                {
+                    if (p[1] == '\0')
+                    {
+                        /*  this is a leadbyte followed by EOS -- a dud MBCS string
+                        We choose not to assert here because this
+                        function is defined to deal with dud strings on
+                        input and return a known value
+                        */
+                        ptd.get_errno().set(EILSEQ);
+                        *pwcs = '\0';
+                        return (size_t) - 1;
+                    }
+                    else
+                    {
+                        p++;
+                    }
+                }
+            }
+            bytecnt = ((int) ((char *) p - (char *) s));
+
+            if ((count = __acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage,
+                MB_PRECOMPOSED,
+                s,
+                bytecnt,
+                pwcs,
+                (int) n)) == 0)
+            {
+                ptd.get_errno().set(EILSEQ);
+                *pwcs = '\0';
+                return (size_t) - 1;
+            }
+
+            return count; /* no NUL in string */
+        }
+    }
+    else {
+        /* pwcs == nullptr, get size only, s must be NUL-terminated */
+        if (locale->locinfo->locale_name[LC_CTYPE] == nullptr)
+        {
+            return strlen(s);
+        }
+        else if ((count = __acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            s,
+            -1,
+            nullptr,
+            0)) == 0)
+        {
+                ptd.get_errno().set(EILSEQ);
+                return (size_t) - 1;
+        }
+        else
+        {
+            return count - 1;
+        }
+    }
+
+}
+
+extern "C" size_t __cdecl _mbstowcs_l(
+    wchar_t  *pwcs,
+    const char *s,
+    size_t n,
+    _locale_t plocinfo
+    )
+{
+    /* Call a non-deprecated helper to do the work. */
+    __crt_cached_ptd_host ptd(plocinfo);
+    return _mbstowcs_l_helper(pwcs, s, n, ptd);
+}
+
+extern "C" size_t __cdecl mbstowcs(
+    wchar_t  *pwcs,
+    const char *s,
+    size_t n
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _mbstowcs_l_helper(pwcs, s, n, ptd);
+}
+
+/***
+*errno_t mbstowcs_s() - Convert multibyte char string to wide char string.
+*
+*Purpose:
+*       Convert a multi-byte char string into the equivalent wide char string,
+*       according to the LC_CTYPE category of the current locale.
+*       Same as mbstowcs(), but the destination is ensured to be null terminated.
+*       If there's not enough space, we return EINVAL.
+*
+*Entry:
+*       size_t *pConvertedChars = Number of bytes modified including the terminating nullptr
+*                                 This pointer can be nullptr.
+*       wchar_t *pwcs = pointer to destination wide character string buffer
+*       size_t sizeInWords = size of the destination buffer
+*       const char *s = pointer to source multibyte character string
+*       size_t n = maximum number of wide characters to store (not including the terminating nullptr)
+*
+*Exit:
+*       The error code.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static errno_t __cdecl _mbstowcs_internal(
+    size_t *               pConvertedChars,
+    wchar_t *              pwcs,
+    size_t                 sizeInWords,
+    const char *           s,
+    size_t                 n,
+    __crt_cached_ptd_host& ptd
+    )
+{
+    size_t retsize;
+    errno_t retvalue = 0;
+
+    /* validation section */
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, (pwcs == nullptr && sizeInWords == 0) || (pwcs != nullptr && sizeInWords > 0), EINVAL);
+
+    if (pwcs != nullptr)
+    {
+        _RESET_STRING(pwcs, sizeInWords);
+    }
+
+    if (pConvertedChars != nullptr)
+    {
+        *pConvertedChars = 0;
+    }
+
+    size_t bufferSize = n > sizeInWords ? sizeInWords : n;
+    /* n must fit into an int for MultiByteToWideChar */
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, bufferSize <= INT_MAX, EINVAL);
+
+    /* Call a non-deprecated helper to do the work. */
+
+    retsize = _mbstowcs_l_helper(pwcs, s, bufferSize, ptd);
+
+    if (retsize == (size_t) - 1)
+    {
+        if (pwcs != nullptr)
+        {
+            _RESET_STRING(pwcs, sizeInWords);
+        }
+        return ptd.get_errno().value_or(0);
+    }
+
+    /* count the null terminator */
+    retsize++;
+
+    if (pwcs != nullptr)
+    {
+        /* return error if the string does not fit, unless n == _TRUNCATE */
+        if (retsize > sizeInWords)
+        {
+            if (n != _TRUNCATE)
+            {
+                _RESET_STRING(pwcs, sizeInWords);
+                _UCRT_VALIDATE_RETURN_ERRCODE(ptd, retsize <= sizeInWords, ERANGE);
+            }
+            retsize = sizeInWords;
+            retvalue = STRUNCATE;
+        }
+
+        /* ensure the string is null terminated */
+        pwcs[retsize - 1] = '\0';
+    }
+
+    if (pConvertedChars != nullptr)
+    {
+        *pConvertedChars = retsize;
+    }
+
+    return retvalue;
+}
+
+extern "C" errno_t __cdecl _mbstowcs_s_l(
+    size_t *     pConvertedChars,
+    wchar_t *    pwcs,
+    size_t       sizeInWords,
+    const char * s,
+    size_t       n,
+    _locale_t    plocinfo
+    )
+{
+    __crt_cached_ptd_host ptd(plocinfo);
+    return _mbstowcs_internal(pConvertedChars, pwcs, sizeInWords, s, n, ptd);
+}
+
+extern "C" errno_t __cdecl mbstowcs_s(
+    size_t *pConvertedChars,
+    wchar_t  *pwcs,
+    size_t sizeInWords,
+    const char *s,
+    size_t n
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _mbstowcs_internal(pConvertedChars, pwcs, sizeInWords, s, n, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbtowc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbtowc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bca95edffb07331651559c77b13114fb4c0601a6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/mbtowc.cpp	
@@ -0,0 +1,153 @@
+/***
+*mbtowc.c - Convert multibyte char to wide char.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Convert a multibyte character into the equivalent wide character.
+*
+*******************************************************************************/
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <wchar.h>
+
+using namespace __crt_mbstring;
+
+/***
+*int mbtowc() - Convert multibyte char to wide character.
+*
+*Purpose:
+*       Convert a multi-byte character into the equivalent wide character,
+*       according to the LC_CTYPE category of the current locale.
+*       [ANSI].
+*
+*       NOTE:  Currently, the C libraries support the "C" locale only.
+*              Non-C locale support now available under _INTL switch.
+*Entry:
+*       wchar_t  *pwc = pointer to destination wide character
+*       const char *s = pointer to multibyte character
+*       size_t      n = maximum length of multibyte character to consider
+*
+*Exit:
+*       If s = nullptr, returns 0, indicating we only use state-independent
+*       character encodings.
+*       If s != nullptr, returns:  0 (if *s = null char)
+*                               -1 (if the next n or fewer bytes not valid mbc)
+*                               number of bytes comprising converted mbc
+*
+*Exceptions:
+*       If errors are encountered, -1 is returned and errno is set to EILSEQ.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbtowc_internal(
+    wchar_t *              pwc,
+    const char *           s,
+    size_t                 n,
+    __crt_cached_ptd_host& ptd
+    )
+{
+    static mbstate_t internal_state{};
+    if (!s || n == 0)
+    {
+        /* indicate do not have state-dependent encodings,
+        handle zero length string */
+        internal_state = {};
+        return 0;
+    }
+
+    if (!*s)
+    {
+        /* handle NULL char */
+        if (pwc)
+        {
+            *pwc = 0;
+        }
+        return 0;
+    }
+
+    const _locale_t locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        int result = static_cast<int>(__mbrtowc_utf8(pwc, s, n, &internal_state, ptd));
+        if (result < 0)
+            result = -1;
+        return result;
+    }
+
+    _ASSERTE(locale->locinfo->_public._locale_mb_cur_max == 1 ||
+             locale->locinfo->_public._locale_mb_cur_max == 2);
+
+    if (locale->locinfo->locale_name[LC_CTYPE] == nullptr)
+    {
+        if (pwc)
+        {
+            *pwc = (wchar_t) (unsigned char) *s;
+        }
+        return sizeof(char);
+    }
+
+    if (_isleadbyte_fast_internal((unsigned char) *s, locale))
+    {
+        _ASSERTE(locale->locinfo->_public._locale_lc_codepage != CP_UTF8 && L"UTF-8 isn't supported in this _mbtowc_l function yet!!!");
+
+        /* multi-byte char */
+        // If this is a lead byte, then the codepage better be a multibyte codepage
+        _ASSERTE(locale->locinfo->_public._locale_mb_cur_max > 1);
+
+        if ((locale->locinfo->_public._locale_mb_cur_max <= 1) || ((int) n < locale->locinfo->_public._locale_mb_cur_max) ||
+            (__acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            s,
+            locale->locinfo->_public._locale_mb_cur_max,
+            pwc,
+            (pwc) ? 1 : 0) == 0))
+        {
+            /* validate high byte of mbcs char */
+            if ((n < (size_t) locale->locinfo->_public._locale_mb_cur_max) || (!*(s + 1)))
+            {
+                ptd.get_errno().set(EILSEQ);
+                return -1;
+            }
+        }
+        return locale->locinfo->_public._locale_mb_cur_max;
+    }
+    else {
+        /* single byte char */
+        if (__acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            s,
+            1,
+            pwc,
+            (pwc) ? 1 : 0) == 0)
+        {
+            ptd.get_errno().set(EILSEQ);
+            return -1;
+        }
+        return sizeof(char);
+    }
+}
+
+extern "C" int __cdecl _mbtowc_l(
+    wchar_t  *pwc,
+    const char *s,
+    size_t n,
+    _locale_t plocinfo
+    )
+{
+    __crt_cached_ptd_host ptd(plocinfo);
+    return _mbtowc_internal(pwc, s, n, ptd);
+}
+
+extern "C" int __cdecl mbtowc(
+    wchar_t  *pwc,
+    const char *s,
+    size_t n
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _mbtowc_internal(pwc, s, n, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/strtod.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/strtod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77b16edd9c8448926df835ba46ffdaf551ab675f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/strtod.cpp	
@@ -0,0 +1,164 @@
+//
+// strtod.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of the functions that convert strings to floating point numbers.
+// These functions, the strtox and wcstox functions for floating point types,
+// recogize an optional sequence of tabs and space, then an optional sign, then
+// a sequence of digits optionally containing a decimal point, then an optional
+// e or E followed by an optionally signed integer, and converts all of this to
+// a floating point number.  The first unrecognized character ends the string.
+// The *end_ptr pointer is updated to point to the last character of the string
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_strtox.h>
+#include <stdlib.h>
+
+
+
+template <typename FloatingType, typename Character>
+static FloatingType __cdecl common_strtod_l(
+    _In_z_                      Character const*    const   string,
+    _Out_opt_ _Deref_post_z_    Character**         const   end_ptr,
+                                _locale_t           const   locale
+    ) throw()
+{
+    if (end_ptr)
+    {
+        *end_ptr = const_cast<Character*>(string);
+    }
+
+    _VALIDATE_RETURN(string != nullptr, EINVAL, 0.0);
+
+    _LocaleUpdate locale_update(locale);
+
+    FloatingType result{};
+    SLD_STATUS const status = __crt_strtox::parse_floating_point(
+        locale_update.GetLocaleT(),
+        __crt_strtox::make_c_string_character_source(string, end_ptr),
+        &result);
+
+    if (status == SLD_OVERFLOW || status == SLD_UNDERFLOW)
+    {
+        errno = ERANGE;
+    }
+
+    return result;
+}
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Narrow Strings => Floating Point
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" float __cdecl strtof(
+    char const* const string,
+    char**      const end_ptr
+    )
+{
+    return common_strtod_l<float>(string, end_ptr, nullptr);
+}
+
+extern "C" float __cdecl _strtof_l(
+    char const* const string,
+    char**      const end_ptr,
+    _locale_t   const locale
+    )
+{
+    return common_strtod_l<float>(string, end_ptr, locale);
+}
+
+extern "C" double __cdecl strtod(
+    char const* const string,
+    char**      const end_ptr
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, nullptr);
+}
+
+extern "C" double __cdecl _strtod_l(
+    char const* const string,
+    char**      const end_ptr,
+    _locale_t   const locale
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, locale);
+}
+
+extern "C" long double __cdecl strtold(
+    char const* const string,
+    char**      const end_ptr
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, nullptr);
+}
+
+
+extern "C" long double __cdecl _strtold_l(
+    char const* const string,
+    char**      const end_ptr,
+    _locale_t   const locale
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, locale);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Wide Strings => Floating Point
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" float __cdecl wcstof(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr
+    )
+{
+    return common_strtod_l<float>(string, end_ptr, nullptr);
+}
+
+extern "C" float __cdecl _wcstof_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    _locale_t      const locale
+    )
+{
+    return common_strtod_l<float>(string, end_ptr, locale);
+}
+
+extern "C" double __cdecl wcstod(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, nullptr);
+}
+
+extern "C" double __cdecl _wcstod_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    _locale_t      const locale
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, locale);
+}
+
+extern "C" long double __cdecl wcstold(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, nullptr);
+}
+
+
+extern "C" long double __cdecl _wcstold_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    _locale_t      const locale
+    )
+{
+    return common_strtod_l<double>(string, end_ptr, locale);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/strtox.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/strtox.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d09406cdac1c35c509a3e394a0aa3bb2a92ef378
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/strtox.cpp	
@@ -0,0 +1,400 @@
+//
+// strtox.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The many string-to-integer conversion functions, including strtol, strtoul,
+// strtoll, strtoull, wcstol, wcstoul, wcstoll, wcstoull, and various variations
+// of these functions.  All of these share a common implementation that converts
+// a narrow or wide character string to a 32-bit or 64-bit signed or unsigned
+// integer.
+//
+// The base must be zero or in the range [2,36].  If the base zero is passed,
+// the functions attempt to determine the base from the prefix of the string: a
+// prefix of "0" indicates an octal string, a prefix of "0x" or "0X" indicates a
+// hexadecimal string, and any other character indicates base 10.
+//
+// If the end_ptr is non-null, then if the number is successfully parsed, the
+// *end_ptr is set to point to the last digit of the number (note:  it does NOT
+// point one-past-the-end, STL style).
+//
+// The string format must be:
+//
+//     [whitespace] [sign] [0|0x] [digits/letters]
+//
+// If the string does not start with a valid number, zero is returned and end_ptr
+// is set to point to the initial character in the string.
+//
+// If the string starts with a valid number that is representable in the target
+// integer type, the number is returned and end_ptr is set to point to the last
+// character of the number.
+//
+// If the string starts with a valid number that is not representable in the
+// target integer type, end_ptr is set to point to the last character of the
+// number and a sentinel value is returned:
+//
+//                              32-bit      64-bit
+//     Unsigned / too large:    UINT_MAX    _UI64_MAX
+//     Signed   / too large:    INT_MAX     _I64_MAX
+//     Signed   / too small:    INT_MIN     _I64_MIN
+//
+// See also atox.cpp, which defines the "simple" functions--the atox and wtox
+// families of functions.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal.h>
+#include <corecrt_internal_strtox.h>
+#include <corecrt_wstdlib.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <locale.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Narrow Strings => 32-bit Integers
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" long __cdecl strtol(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" long __cdecl _strtol_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, end_ptr, base, locale);
+}
+
+
+
+extern "C" unsigned long __cdecl strtoul(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" unsigned long __cdecl _strtoul_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long>(string, end_ptr, base, locale);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Narrow Strings => 64-bit Integers
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" __int64 __cdecl _strtoi64(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, end_ptr, base, nullptr);
+}
+
+extern "C" long long __cdecl strtoll(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" intmax_t __cdecl strtoimax(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<intmax_t>(string, end_ptr, base, nullptr);
+}
+
+
+
+extern "C" __int64 __cdecl _strtoi64_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, end_ptr, base, locale);
+}
+
+extern "C" long long __cdecl _strtoll_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, end_ptr, base, locale);
+}
+
+extern "C" intmax_t __cdecl _strtoimax_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<intmax_t>(string, end_ptr, base, locale);
+}
+
+
+
+extern "C" unsigned __int64 __cdecl _strtoui64(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned __int64>(string, end_ptr, base, nullptr);
+}
+
+extern "C" unsigned long long __cdecl strtoull(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" uintmax_t __cdecl strtoumax(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<uintmax_t>(string, end_ptr, base, nullptr);
+}
+
+
+
+extern "C" unsigned __int64 __cdecl _strtoui64_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned __int64>(string, end_ptr, base, locale);
+}
+
+extern "C" unsigned long long __cdecl _strtoull_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long long>(string, end_ptr, base, locale);
+}
+
+extern "C" uintmax_t __cdecl _strtoumax_l(
+    char const* const string,
+    char**      const end_ptr,
+    int         const base,
+    _locale_t   const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<uintmax_t>(string, end_ptr, base, locale);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Wide Strings => 32-bit Integers
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" long __cdecl wcstol(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" long __cdecl _wcstol_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long>(string, end_ptr, base, locale);
+}
+
+extern "C" unsigned long __cdecl wcstoul(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" unsigned long __cdecl _wcstoul_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long>(string, end_ptr, base, locale);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Wide Strings => 64-bit Integers
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" __int64 __cdecl _wcstoi64(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, end_ptr, base, nullptr);
+}
+
+extern "C" long long __cdecl wcstoll(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" intmax_t __cdecl wcstoimax(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<intmax_t>(string, end_ptr, base, nullptr);
+}
+
+
+
+extern "C" __int64 __cdecl _wcstoi64_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<__int64>(string, end_ptr, base, locale);
+}
+
+extern "C" long long __cdecl _wcstoll_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<long long>(string, end_ptr, base, locale);
+}
+
+extern "C" intmax_t __cdecl _wcstoimax_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<intmax_t>(string, end_ptr, base, locale);
+}
+
+
+
+extern "C" unsigned __int64 __cdecl _wcstoui64(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned __int64>(string, end_ptr, base, nullptr);
+}
+
+extern "C" unsigned long long __cdecl wcstoull(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long long>(string, end_ptr, base, nullptr);
+}
+
+extern "C" uintmax_t __cdecl wcstoumax(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base
+    )
+{
+    return __crt_strtox::parse_integer_from_string<uintmax_t>(string, end_ptr, base, nullptr);
+}
+
+
+
+extern "C" unsigned __int64 __cdecl _wcstoui64_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned __int64>(string, end_ptr, base, locale);
+}
+
+extern "C" unsigned long long __cdecl _wcstoull_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<unsigned long long>(string, end_ptr, base, locale);
+}
+
+extern "C" uintmax_t __cdecl _wcstoumax_l(
+    wchar_t const* const string,
+    wchar_t**      const end_ptr,
+    int            const base,
+    _locale_t      const locale
+    )
+{
+    return __crt_strtox::parse_integer_from_string<uintmax_t>(string, end_ptr, base, locale);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/swab.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/swab.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f15b9f1f143b6c4b8d57ec3593f1911857fbdca
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/swab.cpp	
@@ -0,0 +1,34 @@
+//
+// swab.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the _swab function, which copies a source buffer into a destination
+// buffer, swapping the odd and even bytes of each word as it does so.
+//
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+
+
+extern "C" void __cdecl _swab(
+    char* source,
+    char* destination,
+    int   bytes
+    )
+{
+    _VALIDATE_RETURN_VOID(source      != nullptr, EINVAL);
+    _VALIDATE_RETURN_VOID(destination != nullptr, EINVAL);
+    _VALIDATE_RETURN_VOID(bytes >= 0,             EINVAL);
+
+    while (bytes > 1)
+    {
+        char const b1 = *source++;
+        char const b2 = *source++;
+
+        *destination++ = b2;
+        *destination++ = b1;
+
+        bytes -= 2;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/tolower_toupper.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/tolower_toupper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc2fbdfa0cb4c8ee466e29c249e0afe49e487d44
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/tolower_toupper.cpp	
@@ -0,0 +1,117 @@
+//
+// tolower_toupper.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The narrow-string tolower and toupper functions, which convert the integer
+// representation of a character to its lowercase equivalent.  These functions
+// are defined as macros in the headers.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <stdio.h>
+
+typedef unsigned char  (__cdecl internal_map_type)(unsigned char, _locale_t);
+
+static __forceinline int __cdecl common_tox_win_lookup(int const c, DWORD const map_flag, _locale_t const locale) throw()
+{
+    // Convert the character to a multibyte string:
+    size_t        in_count    {};
+    unsigned char in_buffer[3]{};
+    if (locale->locinfo->_public._locale_mb_cur_max > 1 && _isleadbyte_fast_internal(c >> 8 & 0xff, locale))
+    {
+        in_buffer[0] = c >> 8 & 0xff; // Put the lead byte at start of the string
+        in_buffer[1] = static_cast<unsigned char>(c);
+        in_buffer[2] = 0;
+        in_count     = 2;
+    }
+    else
+    {
+        // This is undefined behavior: should probably use the wide form instead
+        errno = EILSEQ;
+        in_buffer[0] = static_cast<unsigned char>(c);
+        in_buffer[1] = 0;
+        in_count     = 1;
+    }
+
+    // Convert the wide character equivalent to the target case:
+    unsigned char out_buffer[3]{};
+    int const out_count = __acrt_LCMapStringA(
+        locale,
+        locale->locinfo->locale_name[LC_CTYPE],
+        map_flag,
+        reinterpret_cast<char const*>(in_buffer),
+        static_cast<int>(in_count),
+        reinterpret_cast<char*>(out_buffer),
+        static_cast<int>(_countof(out_buffer)),
+        locale->locinfo->_public._locale_lc_codepage,
+        TRUE);
+
+    if (out_count == 0)
+    {
+        return c;
+    }
+
+    // Form the integer return value:
+    if (out_count == 1)
+    {
+        return static_cast<int>(out_buffer[0]);
+    }
+
+    return static_cast<int>(out_buffer[1]) | (static_cast<int>(out_buffer[0]) << 8);
+}
+
+template <internal_map_type& MapType>
+static __forceinline int __cdecl common_tox_l(int const c, DWORD const map_flag, _locale_t const locale) throw()
+{
+    if (c == EOF)
+    {
+        return EOF;
+    }
+
+    _LocaleUpdate locale_update(locale);
+
+    if (static_cast<unsigned>(c) < 256)
+    {
+        return MapType(static_cast<unsigned char>(c), locale_update.GetLocaleT());
+    }
+
+    return common_tox_win_lookup(c, map_flag, locale_update.GetLocaleT());
+}
+
+extern "C" int __cdecl _tolower_l(int const c, _locale_t const locale)
+{
+    return common_tox_l<_tolower_fast_internal>(c, LCMAP_LOWERCASE, locale);
+}
+
+extern "C" int __cdecl tolower(int const c)
+{
+    return __acrt_locale_changed()
+        ? _tolower_l(c, nullptr)
+        : __ascii_tolower(c);
+}
+
+extern "C" int (__cdecl _tolower)(int const c)
+{
+    return c - 'A' + 'a';
+}
+
+
+
+extern "C" int __cdecl _toupper_l(int const c, _locale_t const locale)
+{
+    return common_tox_l<_toupper_fast_internal>(c, LCMAP_UPPERCASE, locale);
+}
+
+extern "C" int __cdecl toupper(int const c)
+{
+    return __acrt_locale_changed()
+        ? _toupper_l(c, nullptr)
+        : __ascii_toupper(c);
+}
+
+extern "C" int (__cdecl _toupper)(int const c)
+{
+    return c - 'a' + 'A';
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/towlower.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/towlower.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10717e4f94d56a0af6cc0b14764e8233784ed594
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/towlower.cpp	
@@ -0,0 +1,105 @@
+/***
+*towlower.cpp - convert wide character to lower case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines towlower().
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+/***
+*wint_t _towlower_l(c, ptloci) - convert wide character to lower case
+*
+*Purpose:
+*       Multi-thread function only! Non-locking version of towlower.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" wint_t __cdecl _towlower_l(
+        wint_t const c,
+        _locale_t const plocinfo
+        )
+{
+    if (c == WEOF)
+    {
+        return c;
+    }
+
+    _LocaleUpdate _loc_update(plocinfo);
+    auto const locinfo = _loc_update.GetLocaleT()->locinfo;
+
+    if (locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        // For 128 <= c < 256, the tolower map would consider the wide character as it is in UTF-8, not UTF-16.
+        // Below 128, UTF-8 and UTF-16 have the same encodings, so we can use the table.
+        if (c < 128)
+        {
+            return _towlower_fast_internal(static_cast<unsigned char>(c), _loc_update.GetLocaleT());
+        }
+    }
+    else
+    {
+        // For 128 <= c < 256, the tolower map will consider the wide character as it would be in the current narrow code page,
+        // which can lead to unexpected behavior. This behavior is maintained for backwards compatibility.
+        if (c < 256)
+        {
+            return _towlower_fast_internal(static_cast<unsigned char>(c), _loc_update.GetLocaleT());
+        }
+
+        if (locinfo->locale_name[LC_CTYPE] == nullptr)
+        {
+            // If the locale is C, then the only characters that would be transformed are <256
+            // and have been processed already.
+            return c;
+        }
+    }
+
+    wint_t widechar;
+    if (0 == __acrt_LCMapStringW(
+                locinfo->locale_name[LC_CTYPE],
+                LCMAP_LOWERCASE,
+                (LPCWSTR)&c,
+                1,
+                (LPWSTR)&widechar,
+                1))
+    {
+        return c;
+    }
+
+    return widechar;
+}
+
+/***
+*wint_t towlower(c) - convert wide character to lower case
+*
+*Purpose:
+*       towlower() returns the lowercase equivalent of its argument
+*
+*Entry:
+*       c - wint_t value of character to be converted
+*
+*Exit:
+*       if c is an upper case letter, returns wint_t value of lower case
+*       representation of c. otherwise, it returns c.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" wint_t __cdecl towlower (
+        wint_t c
+        )
+{
+
+    return _towlower_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/towupper.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/towupper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f228e23084d97b064260a4b6c11b61087ab80951
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/towupper.cpp	
@@ -0,0 +1,105 @@
+/***
+*towupper.cpp - convert wide character to upper case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines towupper().
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+
+/***
+*wint_t _towupper_l(c, ptloci) - convert wide character to upper case
+*
+*Purpose:
+*       Multi-thread function only! Non-locking version of towupper.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" wint_t __cdecl _towupper_l(
+        wint_t const c,
+        _locale_t const plocinfo
+        )
+{
+    if (c == WEOF)
+    {
+        return c;
+    }
+
+    _LocaleUpdate _loc_update(plocinfo);
+    auto const locinfo = _loc_update.GetLocaleT()->locinfo;
+
+    if (locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        // For 128 <= c < 256, the toupper map would consider the wide character as it is in UTF-8, not UTF-16.
+        // Below 128, UTF-8 and UTF-16 have the same encodings, so we can use the table.
+        if (c < 128)
+        {
+            return _towupper_fast_internal(static_cast<unsigned char>(c), _loc_update.GetLocaleT());
+        }
+    }
+    else
+    {
+        // For 128 <= c < 256, the toupper map will consider the wide character as it would be in the current narrow code page,
+        // which can lead to unexpected behavior. This behavior is maintained for backwards compatibility.
+        if (c < 256)
+        {
+            return _towupper_fast_internal(static_cast<unsigned char>(c), _loc_update.GetLocaleT());
+        }
+
+        if (locinfo->locale_name[LC_CTYPE] == nullptr)
+        {
+            // If the locale is C, then the only characters that would be transformed are <256
+            // and have been processed already.
+            return c;
+        }
+    }
+
+    wint_t widechar;
+    if (0 == __acrt_LCMapStringW(
+                locinfo->locale_name[LC_CTYPE],
+                LCMAP_UPPERCASE,
+                (LPCWSTR)&c,
+                1,
+                (LPWSTR)&widechar,
+                1))
+    {
+        return c;
+    }
+
+    return widechar;
+}
+
+/***
+*wint_t towupper(c) - convert wide character to upper case
+*
+*Purpose:
+*       towupper() returns the uppercase equivalent of its argument
+*
+*Entry:
+*       c - wint_t value of character to be converted
+*
+*Exit:
+*       if c is a lower case letter, returns wint_t value of upper case
+*       representation of c. otherwise, it returns c.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" wint_t __cdecl towupper (
+        wint_t c
+        )
+{
+
+    return _towupper_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wcrtomb.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wcrtomb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..858ce32185327cbbbb07888ab6ca7dc35cf24b36
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wcrtomb.cpp	
@@ -0,0 +1,533 @@
+/***
+*wcrtomb.cpp - Convert wide character to multibyte character, with locale.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Convert a wide character into the equivalent multibyte character.
+*
+*******************************************************************************/
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_securecrt.h>
+#include <limits.h>
+#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+using namespace __crt_mbstring;
+
+/***
+*errno_t _wcrtomb_internal() - Helper function to convert wide character to multibyte character.
+*
+*Purpose:
+*       Convert a wide character into the equivalent multi-byte character,
+*       according to the specified LC_CTYPE category, or the current locale.
+*       [ANSI].
+*
+*       NOTE:  Currently, the C libraries support the "C" locale only.
+*              Non-C locale support now available under _INTL switch.
+*Entry:
+*       int *return_value      = the number of chars written (-1 in error case)
+*       char *destination           = pointer to multibyte character
+*       size_t destination_count  = size of the destinarion buffer
+*       wchar_t wchar       = source wide character
+*       mbstate_t *state      = pointer to state (not used)
+*       _locale_t locale  = locale info
+*
+*Exit:
+*       Returns:
+*       Value of errno if errors, 0 otherwise. *return_value is set to -1 in error case.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+_Success_(return == 0)
+static errno_t __cdecl _wcrtomb_internal(
+                                            int*               const return_value,
+    __out_bcount_z_opt(destination_count)   char*              const destination,
+                                            size_t             const destination_count,
+                                            wchar_t            const wchar,
+                                            mbstate_t*         const state,
+    _Inout_                                 __crt_cached_ptd_host&   ptd
+    )
+{
+    _ASSERTE(destination != nullptr && destination_count > 0);
+
+    _locale_t const locale = ptd.get_locale();
+
+    _ASSERTE(
+        locale->locinfo->_public._locale_mb_cur_max == 1 ||
+        locale->locinfo->_public._locale_mb_cur_max == 2 ||
+        locale->locinfo->_public._locale_lc_codepage == CP_UTF8);
+
+    if (state)
+    {
+        state->_Wchar = 0;
+    }
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        // Unlike c16rtomb. wctomb/wcrtomb have no ability to process a partial code point.
+        // So, we could call c16rtomb and check for a lone surrogate or other error, or for simplicity
+        // We can instead just call c32rtomb and check for any error. I choose the latter.
+        static mbstate_t local_state{};
+        int result = static_cast<int>(__crt_mbstring::__c32rtomb_utf8(destination, static_cast<char32_t>(wchar), (state != nullptr ? state : &local_state), ptd));
+        if (return_value != nullptr)
+        {
+            *return_value = result;
+        }
+        if (result <= 4)
+        {
+            return 0;
+        }
+        else
+        {
+            return ptd.get_errno().value_or(0);
+        }
+    }
+
+    if (!locale->locinfo->locale_name[LC_CTYPE])
+    {
+        if (wchar > 255) // Validate high byte
+        {
+            if (return_value)
+                *return_value = -1;
+
+            return ptd.get_errno().set(EILSEQ);
+        }
+
+        *destination = static_cast<char>(wchar);
+        if (return_value)
+        {
+            *return_value = 1;
+        }
+
+        return 0;
+    }
+
+    BOOL default_used{};
+    int const size = __acrt_WideCharToMultiByte(
+        locale->locinfo->_public._locale_lc_codepage,
+        0,
+        &wchar,
+        1,
+        destination,
+        static_cast<int>(destination_count),
+        nullptr,
+        &default_used);
+
+    if (size == 0 || default_used)
+    {
+        if (return_value)
+        {
+            *return_value = -1;
+        }
+
+        return ptd.get_errno().set(EILSEQ);
+    }
+
+    if (return_value)
+    {
+        *return_value = size;
+    }
+
+    return 0;
+}
+
+/***
+*errno_t wcrtomb_s(retValue, destination, destination_count, wchar, state) - translate wchar_t to multibyte, restartably
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static errno_t __cdecl wcrtomb_s_internal(
+    size_t*            const return_value,
+    char*              const destination,
+    size_t             const destination_count,
+    wchar_t            const wchar,
+    mbstate_t*         const state,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    // Note that we do not force destination_count > 0 in the destination !=
+    // nullptr case because we do not need to add a null terminator, due to
+    // the fact that the destination will receive a character and not a string.
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, (destination == nullptr && destination_count == 0) || (destination != nullptr), EINVAL);
+
+    errno_t e = 0;
+    int     int_return_value = -1;
+    if (destination == nullptr)
+    {
+        char buf[MB_LEN_MAX];
+        e = _wcrtomb_internal(&int_return_value, buf, MB_LEN_MAX, wchar, state, ptd);
+    }
+    else
+    {
+        e = _wcrtomb_internal(&int_return_value, destination, destination_count, wchar, state, ptd);
+    }
+
+    if (return_value != nullptr)
+    {
+        *return_value = static_cast<size_t>(int_return_value);
+    }
+
+    return e;
+}
+
+extern "C" errno_t __cdecl wcrtomb_s(
+    size_t*    const return_value,
+    char*      const destination,
+    size_t     const destination_count,
+    wchar_t    const wchar,
+    mbstate_t* const state
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return wcrtomb_s_internal(return_value, destination, destination_count, wchar, state, ptd);
+}
+
+extern "C" size_t __cdecl wcrtomb(
+    char*      const destination,
+    wchar_t    const wchar,
+    mbstate_t* const state
+    )
+{
+    size_t return_value = static_cast<size_t>(-1);
+    wcrtomb_s(&return_value, destination, (destination == nullptr ? 0 : MB_LEN_MAX), wchar, state);
+    return return_value;
+}
+
+/***
+*errno_t wcsrtombs_s(retValue, destination, destination_count, pwcs, n, state) - translate wide char string to multibyte
+*       string
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/* Helper shared by secure and non-secure functions. */
+
+static size_t __cdecl _wcsrtombs_internal(
+    _Pre_maybenull_ _Post_z_    char*                   destination,
+    _Inout_ _Deref_prepost_z_   wchar_t const** const   source,
+    _In_                        size_t                  n,
+    _Out_opt_                   mbstate_t*      const   state,
+    _Inout_                     __crt_cached_ptd_host&  ptd
+    ) throw()
+{
+    /* validation section */
+    _UCRT_VALIDATE_RETURN(ptd, source != nullptr, EINVAL, (size_t)-1);
+
+    _locale_t const locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        return __wcsrtombs_utf8(destination, source, n, state, ptd);
+    }
+
+    char buf[MB_LEN_MAX];
+    int i = 0;
+    size_t nc = 0;
+    wchar_t const* wcs = *source;
+
+    if (!destination)
+    {
+        for (; ; nc += i, ++wcs)
+        {
+            /* translate but don't store */
+            _wcrtomb_internal(&i, buf, MB_LEN_MAX, *wcs, state, ptd);
+            if (i <= 0)
+            {
+                return static_cast<size_t>(-1);
+            }
+            else if (buf[i - 1] == '\0')
+            {
+                return nc + i - 1;
+            }
+        }
+    }
+
+    for (; 0 < n; nc += i, ++wcs, destination += i, n -= i)
+    {
+        /* translate and store */
+        char *t = nullptr;
+
+        if (n < (size_t)locale->locinfo->_public._locale_mb_cur_max)
+        {
+            t = buf;
+        }
+        else
+        {
+            t = destination;
+        }
+
+        _wcrtomb_internal(&i, t, MB_LEN_MAX, *wcs, state, ptd);
+        if (i <= 0)
+        {
+            /* encountered invalid sequence */
+            nc = (size_t)-1;
+            break;
+        }
+
+        if (destination == t)
+        {
+            /* do nothing */
+        }
+        else if (n < static_cast<size_t>(i))
+        {
+            break;  // Won't all fit
+        }
+        else
+        {
+            memcpy_s(destination, n, buf, i);
+        }
+
+        if (destination[i - 1] == '\0')
+        {
+            // Encountered terminating null
+            *source = 0;
+            return nc + i - 1;
+        }
+    }
+
+    *source = wcs;
+    return nc;
+}
+
+extern "C" size_t __cdecl wcsrtombs(
+    char*           const destination,
+    wchar_t const** const source,
+    size_t          const n,
+    mbstate_t*      const state
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _wcsrtombs_internal(destination, source, n, state, ptd);
+}
+
+/***
+*errno_t wcstombs_s() - Convert wide char string to multibyte char string.
+*
+*Purpose:
+*       Convert a wide char string into the equivalent multibyte char string,
+*       according to the LC_CTYPE category of the current locale.
+*
+*       The destination string is always null terminated.
+*
+*Entry:
+*       size_t *return_value = Number of bytes modified including the terminating nullptr
+*                           This pointer can be nullptr.
+*       char *destination = pointer to destination multibyte char string
+*       size_t destination_count = size of the destination buffer
+*       const wchar_t *source = pointer to source wide character string
+*       size_t n = maximum number of bytes to store in s (not including the terminating nullptr)
+*       mbstate_t *state = pointer to state
+*
+*Exit:
+*       The error code.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" errno_t __cdecl wcsrtombs_s(
+    size_t*         const return_value,
+    char*           const destination,
+    size_t          const destination_count,
+    wchar_t const** const source,
+    size_t          const n,
+    mbstate_t*      const state
+    )
+{
+    __crt_cached_ptd_host ptd;
+
+    if (return_value != nullptr)
+    {
+        *return_value = static_cast<size_t>(-1);
+    }
+
+    _UCRT_VALIDATE_RETURN_ERRCODE(
+        ptd,
+        (destination == nullptr && destination_count == 0) ||
+        (destination != nullptr && destination_count >  0),
+    EINVAL);
+
+    if (destination != nullptr)
+    {
+        _RESET_STRING(destination, destination_count);
+    }
+
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, source != nullptr, EINVAL);
+
+    size_t retsize = _wcsrtombs_internal(destination, source, (n > destination_count ? destination_count : n), state, ptd);
+    if (retsize == static_cast<size_t>(-1))
+    {
+        if (destination != nullptr)
+        {
+            _RESET_STRING(destination, destination_count);
+        }
+
+        return ptd.get_errno().value_or(0);
+    }
+
+    ++retsize; // Account for the null terminator
+
+    if (destination != nullptr)
+    {
+        // Return error if the string does not fit:
+        if (retsize > destination_count)
+        {
+            _RESET_STRING(destination, destination_count);
+            _UCRT_VALIDATE_RETURN_ERRCODE(ptd, retsize <= destination_count, ERANGE);
+        }
+
+        // Ensure the string is null terminated:
+        destination[retsize - 1] = '\0';
+    }
+
+    if (return_value != nullptr)
+    {
+        *return_value = retsize;
+    }
+
+    return 0;
+}
+
+
+
+// Converts a wide character into a one-byte character
+extern "C" int __cdecl wctob(wint_t const wchar)
+{
+    __crt_cached_ptd_host ptd;
+
+    if (wchar == WEOF)
+    {
+        return EOF;
+    }
+
+    int  return_value = -1;
+    char local_buffer[MB_LEN_MAX];
+
+    mbstate_t state{};
+    errno_t const e = _wcrtomb_internal(&return_value, local_buffer, MB_LEN_MAX, wchar, &state, ptd);
+    if (e == 0 && return_value == 1)
+    {
+        return local_buffer[0];
+    }
+
+    return EOF;
+}
+
+size_t __cdecl __crt_mbstring::__wcsrtombs_utf8(char* dst, const wchar_t** src, size_t len, mbstate_t* ps, __crt_cached_ptd_host& ptd)
+{
+    const wchar_t* current_src = *src;
+    char buf[MB_LEN_MAX];
+
+    if (dst != nullptr)
+    {
+        char* current_dest = dst;
+
+        // Wide chars are actually UTF-16, so a code point might take 2 input units (a surrogate pair)
+        // In case of a failure, keep track of where the current code point began, which might be the previous
+        // wchar for a surrogate pair
+        const wchar_t* start_of_code_point = current_src;
+        for (;;)
+        {
+            // If we don't have at least 4 MB_CUR_LEN bytes available in the buffer
+            // the next char isn't guaranteed to fit, so put it into a temp buffer
+            char* temp;
+            if (len < 4)
+            {
+                temp = buf;
+            }
+            else
+            {
+                temp = current_dest;
+            }
+            const size_t retval = __c16rtomb_utf8(temp, *current_src, ps, ptd);
+
+            if (retval == __crt_mbstring::INVALID)
+            {
+                // Set src to the beginning of the invalid char
+                // If this was the second half of a surrogate pair, return the beginning of the surrogate pair
+                *src = start_of_code_point;
+                return retval;
+            }
+
+            if (temp == current_dest)
+            {
+                // We wrote in-place. Nothing to do.
+            }
+            else if (len < retval)
+            {
+                // Won't fit, so bail out
+                // If this was the second half of a surrogate pair, make sure we return that location
+                current_src = start_of_code_point;
+                break;
+            }
+            else
+            {
+                // Will fit in remaining buffer, so let's copy it over
+                memcpy(current_dest, temp, retval);
+            }
+
+            if (retval > 0 && current_dest[retval - 1] == '\0')
+            {
+                // Reached null terminator, so break out, but don't count that last terminating byte
+                current_src = nullptr;
+                current_dest += retval - 1;
+                break;
+            }
+
+            ++current_src;
+            if (retval > 0)
+            {
+                start_of_code_point = current_src;
+            }
+
+            len -= retval;
+            current_dest += retval;
+        }
+        *src = current_src;
+        return current_dest - dst;
+    }
+    else
+    {
+        size_t total_count = 0;
+        for (;;)
+        {
+            const size_t retval = __c16rtomb_utf8(buf, *current_src, ps, ptd);
+            if (retval == __crt_mbstring::INVALID)
+            {
+                return retval;
+            }
+            else if (retval > 0 && buf[retval - 1] == '\0')
+            {
+                // Hit null terminator. Don't count it in the return value.
+                total_count += retval - 1;
+                break;
+            }
+            total_count += retval;
+            ++current_src;
+        }
+        return total_count;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wcstombs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wcstombs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9eb6c21bd6027489df73445b22b71ce2ca774981
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wcstombs.cpp	
@@ -0,0 +1,417 @@
+/***
+*wcstombs.c - Convert wide char string to multibyte char string.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Convert a wide char string into the equivalent multibyte char string.
+*
+*******************************************************************************/
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_securecrt.h>
+#include <ctype.h>
+#include <errno.h>
+#include <locale.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/***
+*size_t __cdecl wcsncnt - count wide characters in a string, up to n.
+*
+*Purpose:
+*       Internal local support function. Counts characters in string including nullptr.
+*       If nullptr not found in n chars, then return n.
+*
+*Entry:
+*       const wchar_t *string   - start of string
+*       size_t n                - character count
+*
+*Exit:
+*       returns number of wide characters from start of string to
+*       nullptr (inclusive), up to n.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+_Post_satisfies_(return <= cnt && return <= _String_length_(string + 1))
+static size_t __cdecl wcsncnt (
+        _In_reads_or_z_(cnt) const wchar_t *string,
+        _In_                 size_t cnt
+        )
+{
+        size_t n = cnt+1;
+        wchar_t *cp = (wchar_t *)string;
+
+        while (--n && *cp)
+            cp++;
+
+        if (n && !*cp)
+            return cp - string + 1;
+        return cnt;
+}
+
+/***
+*size_t wcstombs() - Convert wide char string to multibyte char string.
+*
+*Purpose:
+*       Convert a wide char string into the equivalent multibyte char string,
+*       according to the LC_CTYPE category of the current locale.
+*       [ANSI].
+*
+*       The destination string is null terminated only if the null terminator
+*       is copied from the source string.
+*
+*Entry:
+*       char *s            = pointer to destination multibyte char string
+*       const wchar_t *pwc = pointer to source wide character string
+*       size_t           n = maximum number of bytes to store in s
+*
+*Exit:
+*       If s != nullptr, returns    (size_t)-1 (if a wchar cannot be converted)
+*       Otherwise:       Number of bytes modified (<=n), not including
+*                    the terminating NUL, if any.
+*
+*Exceptions:
+*       Returns (size_t)-1 if an error is encountered.
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+_Success_(return != static_cast<size_t>(-1))
+static size_t __cdecl _wcstombs_l_helper(
+    _Out_writes_(n) char *                 s,
+    _In_z_          const wchar_t *        pwcs,
+    _In_            size_t                 n,
+    _Inout_         __crt_cached_ptd_host& ptd
+    )
+{
+    size_t count = 0;
+    int i, retval;
+    char buffer[MB_LEN_MAX];
+    BOOL defused = 0;
+
+    if (s && n == 0)
+        /* dest string exists, but 0 bytes converted */
+        return 0;
+
+    /* validation section */
+    _UCRT_VALIDATE_RETURN(ptd, pwcs != nullptr, EINVAL, (size_t)-1);
+
+
+    /* if destination string exists, fill it in */
+    const _locale_t locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        mbstate_t state{};
+        return __crt_mbstring::__wcsrtombs_utf8(s, &pwcs, n, &state, ptd);
+    }
+
+    if (s)
+    {
+        if ( locale->locinfo->locale_name[LC_CTYPE] == nullptr )
+        {
+            /* C locale: easy and fast */
+            /* Actually, there are such wchar_t characters which are > 255,
+             * but they can be transformed to a valid single byte char
+             * (i.e. a char in the C locale case). Like, for example,
+             * alternative digits in unicode like Arabic-Indic U+0660..U+0669.
+             * The problem is that WideCharToMultiByte() does not translate those
+             * wchar_t unless we pass the correct codepage (1256, Arabic).
+             * See bug VSW:192653.
+             */
+            while(count < n)
+            {
+                if (static_cast<uint16_t>(*pwcs) > 0xFF)  /* validate high byte */
+                {
+                    ptd.get_errno().set(EILSEQ);
+                    return (size_t)-1;  /* error */
+                }
+                s[count] = (char) *pwcs;
+                if (*pwcs++ == L'\0')
+                {
+                    return count;
+                }
+                count++;
+            }
+            return count;
+        }
+        else
+        {
+
+            if (1 == locale->locinfo->_public._locale_mb_cur_max)
+            {
+                /* If SBCS, one wchar_t maps to one char */
+
+                /* WideCharToMultiByte will compare past nullptr - reset n */
+                if (n > 0)
+                {
+                    n = wcsncnt(pwcs, n);
+                }
+                if ( ((count = __acrt_WideCharToMultiByte( locale->locinfo->_public._locale_lc_codepage,
+                                                    0,
+                                                    pwcs,
+                                                    (int)n,
+                                                    s,
+                                                    (int)n,
+                                                    nullptr,
+                                                    &defused )) != 0) &&
+                     (!defused) )
+                {
+                    if (s[count - 1] == '\0')
+                    {
+                        count--; /* don't count NUL */
+                    }
+
+                    return count;
+                }
+
+                ptd.get_errno().set(EILSEQ);
+                return (size_t)-1;
+            }
+            else
+            {
+
+                /* If MBCS, wchar_t to char mapping unknown */
+
+                /* Assume that usually the buffer is large enough */
+                if ( ((count = __acrt_WideCharToMultiByte( locale->locinfo->_public._locale_lc_codepage,
+                                                    0,
+                                                    pwcs,
+                                                    -1,
+                                                    s,
+                                                    (int)n,
+                                                    nullptr,
+                                                    &defused )) != 0) &&
+                     (!defused) )
+                {
+                    return count - 1; /* don't count NUL */
+                }
+
+                if (defused || GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+                {
+                    ptd.get_errno().set(EILSEQ);
+                    return (size_t)-1;
+                }
+
+                /* buffer not large enough, must do char by char */
+                while (count < n)
+                {
+                    int mb_cur_max = locale->locinfo->_public._locale_mb_cur_max;
+                    if ( ((retval = __acrt_WideCharToMultiByte( locale->locinfo->_public._locale_lc_codepage,
+                                                         0,
+                                                         pwcs,
+                                                         1,
+                                                         buffer,
+                                                         __min(MB_LEN_MAX, mb_cur_max),
+                                                         nullptr,
+                                                         &defused )) == 0)
+                         || defused )
+                    {
+                        ptd.get_errno().set(EILSEQ);
+                        return (size_t)-1;
+                    }
+
+                    /* enforce this for prefast */
+                    if (retval < 0 ||
+                        retval > _countof(buffer))
+                    {
+                        ptd.get_errno().set(EILSEQ);
+                        return (size_t)-1;
+                    }
+
+                    if (count + retval > n)
+                        return count;
+
+                    for (i = 0; i < retval; i++, count++) /* store character */
+                    {
+                        if((s[count] = buffer[i])=='\0')
+                        {
+                            return count;
+                        }
+                    }
+
+                    pwcs++;
+                }
+
+                return count;
+            }
+        }
+    }
+    else
+    { /* s == nullptr, get size only, pwcs must be NUL-terminated */
+        if ( locale->locinfo->locale_name[LC_CTYPE] == nullptr )
+        {
+            size_t len = 0;
+            for (wchar_t *pw = (wchar_t *)pwcs; *pw != 0; pw++)  /* validate high byte */
+            {
+                if (*pw > 255)  /* validate high byte */
+                {
+                    ptd.get_errno().set(EILSEQ);
+                    return (size_t)-1;  /* error */
+                }
+                ++len;
+            }
+
+            return len;
+        }
+        else
+        {
+            if ( ((count = __acrt_WideCharToMultiByte( locale->locinfo->_public._locale_lc_codepage,
+                                                0,
+                                                pwcs,
+                                                -1,
+                                                nullptr,
+                                                0,
+                                                nullptr,
+                                                &defused )) == 0) ||
+                 (defused) )
+            {
+                ptd.get_errno().set(EILSEQ);
+                return (size_t)-1;
+            }
+
+            return count - 1;
+        }
+    }
+}
+
+extern "C" size_t __cdecl _wcstombs_l(
+    char * s,
+    const wchar_t * pwcs,
+    size_t n,
+    _locale_t plocinfo
+    )
+{
+    __crt_cached_ptd_host ptd(plocinfo);
+    return _wcstombs_l_helper(s, pwcs, n, ptd);
+}
+
+extern "C" size_t __cdecl wcstombs(
+        char * s,
+        const wchar_t * pwcs,
+        size_t n
+        )
+{
+    __crt_cached_ptd_host ptd;
+    return _wcstombs_l_helper(s, pwcs, n, ptd);
+}
+
+/***
+*errno_t wcstombs_s() - Convert wide char string to multibyte char string.
+*
+*Purpose:
+*       Convert a wide char string into the equivalent multibyte char string,
+*       according to the LC_CTYPE category of the current locale.
+*
+*       The destination string is always null terminated.
+*
+*Entry:
+*       size_t *pConvertedChars = Number of bytes modified including the terminating nullptr
+*                                 This pointer can be nullptr.
+*       char *dst = pointer to destination multibyte char string
+*       size_t sizeInBytes = size of the destination buffer
+*       const wchar_t *src = pointer to source wide character string
+*       size_t n = maximum number of bytes to store in s (not including the terminating nullptr)
+*
+*Exit:
+*       The error code.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static errno_t __cdecl _wcstombs_internal (
+    size_t *               pConvertedChars,
+    char *                 dst,
+    size_t                 sizeInBytes,
+    const wchar_t *        src,
+    size_t                 n,
+    __crt_cached_ptd_host& ptd
+    )
+{
+    size_t retsize;
+    errno_t retvalue = 0;
+
+    /* validation section */
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, (dst != nullptr && sizeInBytes > 0) || (dst == nullptr && sizeInBytes == 0), EINVAL);
+    if (dst != nullptr)
+    {
+        _RESET_STRING(dst, sizeInBytes);
+    }
+
+    if (pConvertedChars != nullptr)
+    {
+        *pConvertedChars = 0;
+    }
+
+    size_t bufferSize = n > sizeInBytes ? sizeInBytes : n;
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, bufferSize <= INT_MAX, EINVAL);
+
+    retsize = _wcstombs_l_helper(dst, src, bufferSize, ptd);
+
+    if (retsize == (size_t)-1)
+    {
+        if (dst != nullptr)
+        {
+            _RESET_STRING(dst, sizeInBytes);
+        }
+        return ptd.get_errno().value_or(0);
+    }
+
+    /* count the null terminator */
+    retsize++;
+
+    if (dst != nullptr)
+    {
+        /* return error if the string does not fit, unless n == _TRUNCATE */
+        if (retsize > sizeInBytes)
+        {
+            if (n != _TRUNCATE)
+            {
+                _RESET_STRING(dst, sizeInBytes);
+                _UCRT_VALIDATE_RETURN_ERRCODE(ptd, sizeInBytes > retsize, ERANGE);
+            }
+            retsize = sizeInBytes;
+            retvalue = STRUNCATE;
+        }
+
+        /* ensure the string is null terminated */
+        dst[retsize - 1] = '\0';
+    }
+
+    if (pConvertedChars != nullptr)
+    {
+        *pConvertedChars = retsize;
+    }
+
+    return retvalue;
+}
+
+extern "C" errno_t __cdecl _wcstombs_s_l (
+    size_t *pConvertedChars,
+    char * dst,
+    size_t sizeInBytes,
+    const wchar_t * src,
+    size_t n,
+    _locale_t plocinfo
+    )
+{
+    __crt_cached_ptd_host ptd(plocinfo);
+    return _wcstombs_internal(pConvertedChars, dst, sizeInBytes, src, n, ptd);
+}
+
+extern "C" errno_t __cdecl wcstombs_s (
+    size_t *pConvertedChars,
+    char * dst,
+    size_t sizeInBytes,
+    const wchar_t * src,
+    size_t n
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _wcstombs_internal(pConvertedChars, dst, sizeInBytes, src, n, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctomb.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctomb.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1e94ef49adcc6e63ae53921969d72cce1e24582
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctomb.cpp	
@@ -0,0 +1,217 @@
+//
+// wctomb.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Functions to convert a wide character to the equivalent multibyte character,
+// according to the LC_CTYPE category of the current locale.  The return value
+// (or *return_value, for the _s-suffixed functions) depends on the destination
+// and destination_count:
+//  * If destination == nullptr && count == 0, number of bytes needed for conversion
+//  * If destination != nullptr:  the number of bytes used for the conversion
+//  * If destination == nullptr && count >  0, the state information
+//    (0 for no state dependency, 1 if a state dependent encoding)
+//
+// Historically Windows has not supported state-dependent encodings for wctomb,
+// however UTF-8 can possible require more than one input wchar_t and maintain
+// state between calls.
+//
+// The return_value pointer may be null.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <errno.h>
+#include <limits.h>
+#include <locale.h>
+#include <stdlib.h>
+
+
+extern "C" int __cdecl _wctomb_internal(
+    int*               const return_value,
+    char*              const destination,
+    size_t             const destination_count,
+    wchar_t            const wchar,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    // Did the caller request if this is a state dependent encoding?
+    if (!destination && destination_count > 0)
+    {
+        // Indicate do not have state-dependent encodings:
+        if (return_value != nullptr)
+            *return_value = 0;
+
+        return 0;
+    }
+
+    if (return_value)
+        *return_value = -1;
+
+    // We need to cast destination_count to int, so we make sure we are not
+    // going to truncate destination_count:
+    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, destination_count <= INT_MAX, EINVAL);
+    _locale_t const locale = ptd.get_locale();
+
+    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+    {
+        // Unlike c16rtomb. wctomb/wcrtomb have no ability to process a partial code point.
+        // So, we could call c16rtomb and check for a lone surrogate or other error, or for simplicity
+        // We can instead just call c32rtomb and check for any error. I choose the latter.
+        mbstate_t state{};
+        int result = static_cast<int>(__crt_mbstring::__c32rtomb_utf8(destination, static_cast<char32_t>(wchar), &state, ptd));
+        if (return_value != nullptr)
+        {
+            *return_value = result;
+        }
+        if (result <= 4)
+        {
+            return 0;
+        }
+        else
+        {
+            return ptd.get_errno().value_or(0);
+        }
+    }
+
+    // Check for C-locale behavior, which merely casts it to char (if in range)
+    // for ASCII-ish behavior.
+    if (!locale->locinfo->locale_name[LC_CTYPE])
+    {
+        // See if the WCHAR is > ASCII-ish range
+        if (wchar > 255)  // Validate high byte
+        {
+            // Too big, can't convert, clear buffer and return error
+            if (destination != nullptr && destination_count > 0)
+            {
+                memset(destination, 0, destination_count);
+            }
+
+            return ptd.get_errno().set(EILSEQ);
+        }
+
+        // ASCII-ish, just cast to a (char)
+        if (destination != nullptr)
+        {
+            _UCRT_VALIDATE_RETURN_ERRCODE(ptd, destination_count > 0, ERANGE);
+            *destination = static_cast<char>(wchar);
+        }
+
+        if (return_value != nullptr)
+        {
+            // casting one WCHAR emits a single char
+            *return_value = 1;
+        }
+
+        // We're done
+        return 0;
+    }
+    else
+    {
+        BOOL default_used{};
+        int const size = __acrt_WideCharToMultiByte(
+            locale->locinfo->_public._locale_lc_codepage,
+            0,
+            &wchar,
+            1,
+            destination,
+            static_cast<int>(destination_count),
+            nullptr,
+            &default_used);
+
+        if (size == 0 || default_used)
+        {
+            if (size == 0 && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+            {
+                if (destination && destination_count > 0)
+                {
+                    memset(destination, 0, destination_count);
+                }
+
+                _UCRT_VALIDATE_RETURN_ERRCODE(ptd, ("Buffer too small", 0), ERANGE);
+            }
+
+            return ptd.get_errno().set(EILSEQ);
+        }
+
+        if (return_value)
+        {
+            *return_value = size;
+        }
+
+        return 0;
+    }
+
+    // The last thing was an if/else, so we already returned.
+}
+
+extern "C" int __cdecl _wctomb_s_l(
+    int*      const return_value,
+    char*     const destination,
+    size_t    const destination_count,
+    wchar_t   const wchar,
+    _locale_t const locale
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return _wctomb_internal(return_value, destination, destination_count, wchar, ptd);
+}
+
+extern "C" errno_t __cdecl wctomb_s (
+    int*    const return_value,
+    char*   const destination,
+    size_t  const destination_count,
+    wchar_t const wchar
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _wctomb_internal(return_value, destination, destination_count, wchar, ptd);
+}
+
+extern "C" int __cdecl _wctomb_l(
+    char*     const destination,
+    wchar_t   const wchar,
+    _locale_t const locale
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+
+    int return_value{};
+    errno_t const e = _wctomb_internal(
+        &return_value,
+        destination,
+        ptd.get_locale()->locinfo->_public._locale_mb_cur_max,
+        wchar,
+        ptd);
+
+    if (e != 0)
+    {
+        return -1;
+    }
+
+    return return_value;
+}
+
+// Disable the OACR error that warns that 'MB_CUR_MAX' doesn't properly constrain buffer 'destination'.
+// wctomb() doesn't take a buffer size, so the function's contract is inherently dangerous.
+__pragma(warning(push))
+__pragma(warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY)) // 26015
+
+extern "C" int __cdecl wctomb(
+    char*   const destination,
+    wchar_t const wchar
+    )
+{
+    __crt_cached_ptd_host ptd;
+
+    int return_value{};
+    errno_t const e = _wctomb_internal(&return_value, destination, MB_CUR_MAX, wchar, ptd);
+    if (e != 0)
+    {
+        return -1;
+    }
+
+    return return_value;
+}
+
+__pragma(warning(pop))
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctrans.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctrans.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1ac7dcd182e2f2b43fa9c4b49fae712b7ed1414
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctrans.cpp	
@@ -0,0 +1,52 @@
+//
+// wctrans.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Implementations of the towctrans and wctrans functions.
+//
+#include <corecrt.h>
+#include <ctype.h>
+#include <string.h>
+#include <wctype.h>
+
+#pragma warning(disable:4244)
+
+
+
+typedef wchar_t wctrans_t;
+
+static struct wctab
+{
+    char const* s;
+    wctype_t    value;
+}
+const tab[] =
+{
+    { "tolower", 2 },
+    { "toupper", 1 },
+    { nullptr,   0 }
+};
+
+
+
+extern "C" wint_t __cdecl towctrans(wint_t const c, wctrans_t const value)
+{
+    return value == 1 ? towupper(c) : towlower(c);
+}
+
+extern "C" wctrans_t __cdecl wctrans(char const* const name)
+{
+    for (unsigned n = 0; tab[n].s != 0; ++n)
+    {
+        if (strcmp(tab[n].s, name) == 0)
+            return tab[n].value;
+    }
+
+    return 0;
+}
+
+/*
+ * Copyright (c) 1992-2007 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+ V5.03:0009 */
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28c9ad51b71322d782f28d4b68413456f2b9a153
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/wctype.cpp	
@@ -0,0 +1,57 @@
+//
+// wctype.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Implementations of the wctype function.
+//
+#include <corecrt.h>
+#include <string.h>
+#include <wctype.h>
+
+
+
+static struct wctab
+{
+    char const* s;
+    wctype_t    value;
+}
+const tab[] =
+{
+    { "alnum",  _ALPHA | _DIGIT                   },
+    { "alpha",  _ALPHA                            },
+    { "cntrl",  _CONTROL                          },
+    { "digit",  _DIGIT                            },
+    { "graph",  _PUNCT | _ALPHA | _DIGIT          },
+    { "lower",  _LOWER                            },
+    { "print",  _BLANK | _PUNCT | _ALPHA | _DIGIT },
+    { "punct",  _PUNCT                            },
+    { "blank",  _BLANK                            },
+    { "space",  _SPACE                            },
+    { "upper",  _UPPER                            },
+    { "xdigit", _HEX                              },
+    { nullptr,  0                                 }
+};
+
+
+
+#pragma warning(push)
+#pragma warning(disable: 4273)
+
+extern "C" wctype_t __cdecl wctype(char const* const name)
+{
+    for (unsigned n = 0; tab[n].s != 0; ++n)
+    {
+        if (strcmp(tab[n].s, name) == 0)
+            return tab[n].value;
+    }
+
+    return 0;
+}
+
+#pragma warning(pop)
+
+/*
+ * Copyright (c) 1992-2007 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+ V5.03:0009 */
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/xtoa.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/xtoa.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5276ff0f87fce7d491ce874ebf128f33c0245ff6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/convert/xtoa.cpp	
@@ -0,0 +1,369 @@
+//
+// _ctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Functions for converting integers to strings.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_securecrt.h>
+#include <limits.h>
+#include <stdlib.h>
+
+#pragma warning(disable:__WARNING_NOT_SATISFIED) // 28020 Prefast thinks that 18446744073709551615 < 1.
+#pragma warning(disable:__WARNING_RANGE_PRECONDITION_VIOLATION) // 26060 Prefast thinks that 18446744073709551615 < 1.
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Common Conversion Implementation
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+namespace
+{
+    template <typename T> struct make_signed;
+    template <> struct make_signed<unsigned long>    { typedef long    type; };
+    template <> struct make_signed<unsigned __int64> { typedef __int64 type; };
+}
+
+
+
+template <typename UnsignedInteger, typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_xtox(
+                                    UnsignedInteger const   original_value,
+    _Out_writes_z_(buffer_count)    Character*      const   buffer,
+    _When_(is_negative == true, _In_range_(>=, 2)) _In_range_(>=, 1)
+                                    size_t          const   buffer_count,
+                                    unsigned        const   radix,
+                                    bool            const   is_negative
+    ) throw()
+{
+// OACR isn't able to track that p stays within the bounds of [buffer, buffer + buffer_count) so manually verified and disabled warning
+#pragma warning(push)
+#pragma warning(disable:26014)
+    Character* p      = buffer; // pointer to traverse the string
+    size_t     length = 0;      // current length of string
+
+    UnsignedInteger remaining_value = original_value;;
+
+    if (is_negative)
+    {
+        *p++ = '-';
+        ++length;
+
+        remaining_value = static_cast<UnsignedInteger>(
+            -static_cast<typename make_signed<UnsignedInteger>::type>(remaining_value)
+        );
+    }
+
+    Character* first_digit = p;
+
+    do
+    {
+        unsigned const digit = static_cast<unsigned>(remaining_value % radix);
+        remaining_value /= radix;
+
+        // Convert to ASCII and store:
+        if (digit > 9)
+        {
+            *p++ = static_cast<Character>(digit - 10 + 'a');
+        }
+        else
+        {
+            *p++ = static_cast<Character>(digit + '0');
+        }
+
+        ++length;
+    }
+    while (remaining_value > 0 && length < buffer_count);
+
+    if (length >= buffer_count)
+    {
+        buffer[0] = '\0';
+        _VALIDATE_RETURN_ERRCODE(length < buffer_count, ERANGE);
+    }
+
+    // We now have the digits of the number in the buffer, but in reverse order.
+    // Reverse the order, but first terminate the string:
+    *p-- = '\0';
+
+    do
+    {
+        Character const t = *p;
+        *p = *first_digit;
+        *first_digit = t;
+        --p;
+        ++first_digit;
+    }
+    while (first_digit < p);
+
+    return 0;
+#pragma warning(pop)
+}
+
+template <typename UnsignedInteger, typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_xtox_s(
+                                    UnsignedInteger const   value,
+    _Out_writes_z_(buffer_count)    Character*      const   buffer,
+                                    size_t          const   buffer_count,
+                                    unsigned        const   radix,
+                                    bool            const   is_negative
+    ) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(buffer != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(buffer_count > 0,  EINVAL);
+    _RESET_STRING(buffer, buffer_count);
+    _VALIDATE_RETURN_ERRCODE(buffer_count > static_cast<size_t>(is_negative ? 2 : 1), ERANGE);
+    _VALIDATE_RETURN_ERRCODE(2 <= radix && radix <= 36, EINVAL);
+
+    return common_xtox(value, buffer, buffer_count, radix, is_negative);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// 32-bit Integers => Narrow Strings
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" errno_t __cdecl _itoa_s(
+    int    const value,
+    char*  const buffer,
+    size_t const buffer_count,
+    int    const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    return common_xtox_s(static_cast<unsigned long>(value), buffer, buffer_count, radix, is_negative);
+}
+
+extern "C" errno_t __cdecl _ltoa_s(
+    long   const value,
+    char*  const buffer,
+    size_t const buffer_count,
+    int    const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    return common_xtox_s(static_cast<unsigned long>(value), buffer, buffer_count, radix, is_negative);
+}
+
+extern "C" errno_t __cdecl _ultoa_s(
+    unsigned long   const value,
+    char*           const buffer,
+    size_t          const buffer_count,
+    int             const radix
+    )
+{
+    return common_xtox_s(value, buffer, buffer_count, radix, false);
+}
+
+
+
+extern "C" char* __cdecl _itoa(
+    int   const value,
+    char* const buffer,
+    int   const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    common_xtox(static_cast<unsigned long>(value), buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, is_negative);
+    return buffer;
+}
+
+extern "C" char* __cdecl _ltoa(
+    long  const value,
+    char* const buffer,
+    int   const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    common_xtox(static_cast<unsigned long>(value), buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, is_negative);
+    return buffer;
+}
+
+extern "C" char* __cdecl _ultoa(
+    unsigned long const value,
+    char*         const buffer,
+    int           const radix
+    )
+{
+    common_xtox(value, buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, false);
+    return buffer;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// 64-bit Integers => Narrow Strings
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" errno_t __cdecl _i64toa_s(
+    __int64 const value,
+    char*   const buffer,
+    size_t  const buffer_count,
+    int     const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    return common_xtox_s(static_cast<unsigned __int64>(value), buffer, buffer_count, radix, is_negative);
+}
+
+extern "C" errno_t __cdecl _ui64toa_s(
+    unsigned __int64 const value,
+    char*            const buffer,
+    size_t           const buffer_count,
+    int              const radix
+    )
+{
+    return common_xtox_s(value, buffer, buffer_count, radix, false);
+}
+
+
+
+extern "C" char* __cdecl _i64toa(
+    __int64 const value,
+    char*   const buffer,
+    int     const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    common_xtox(static_cast<unsigned __int64>(value), buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, is_negative);
+    return buffer;
+}
+
+extern "C" char* __cdecl _ui64toa(
+    unsigned __int64 const value,
+    char*            const buffer,
+    int              const radix
+    )
+{
+    common_xtox(value, buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, false);
+    return buffer;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// 32-bit Integers => Wide Strings
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" errno_t __cdecl _itow_s(
+    int      const value,
+    wchar_t* const buffer,
+    size_t   const buffer_count,
+    int      const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    return common_xtox_s(static_cast<unsigned long>(value), buffer, buffer_count, radix, is_negative);
+}
+
+extern "C" errno_t __cdecl _ltow_s(
+    long     const value,
+    wchar_t* const buffer,
+    size_t   const buffer_count,
+    int      const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    return common_xtox_s(static_cast<unsigned long>(value), buffer, buffer_count, radix, is_negative);
+}
+
+extern "C" errno_t __cdecl _ultow_s(
+    unsigned long const value,
+    wchar_t*      const buffer,
+    size_t        const buffer_count,
+    int           const radix
+    )
+{
+    return common_xtox_s(value, buffer, buffer_count, radix, false);
+}
+
+
+
+extern "C" wchar_t* __cdecl _itow(
+    int      const value,
+    wchar_t* const buffer,
+    int      const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    common_xtox(static_cast<unsigned long>(value), buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, is_negative);
+    return buffer;
+}
+
+extern "C" wchar_t* __cdecl _ltow(
+    long     const value,
+    wchar_t* const buffer,
+    int      const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    common_xtox(static_cast<unsigned long>(value), buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, is_negative);
+    return buffer;
+}
+
+extern "C" wchar_t* __cdecl _ultow(
+    unsigned long const value,
+    wchar_t*      const buffer,
+    int           const radix
+    )
+{
+    common_xtox(value, buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, false);
+    return buffer;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// 64-bit Integers => Wide Strings
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" errno_t __cdecl _i64tow_s(
+    __int64  const value,
+    wchar_t* const buffer,
+    size_t   const buffer_count,
+    int      const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    return common_xtox_s(static_cast<unsigned __int64>(value), buffer, buffer_count, radix, is_negative);
+}
+
+extern "C" errno_t __cdecl _ui64tow_s(
+    unsigned __int64 const value,
+    wchar_t*         const buffer,
+    size_t           const buffer_count,
+    int              const radix
+    )
+{
+    return common_xtox_s(value, buffer, buffer_count, radix, false);
+}
+
+
+
+extern "C" wchar_t* __cdecl _i64tow(
+    __int64  const value,
+    wchar_t* const buffer,
+    int      const radix
+    )
+{
+    bool const is_negative = radix == 10 && value < 0;
+    common_xtox(static_cast<unsigned __int64>(value), buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, is_negative);
+    return buffer;
+}
+
+extern "C" wchar_t* __cdecl _ui64tow(
+    unsigned __int64 const value,
+    wchar_t*         const buffer,
+    int              const radix
+    )
+{
+    common_xtox(value, buffer, _CRT_UNBOUNDED_BUFFER_SIZE, radix, false);
+    return buffer;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/dll/appcrt_dllmain.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/dll/appcrt_dllmain.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c19f9075801e6c40109d2b9d76ce44129f93353
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/dll/appcrt_dllmain.cpp	
@@ -0,0 +1,121 @@
+//
+// appcrt_dllmain.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// The entry point for the AppCRT dynamic library.
+//
+#include <corecrt_internal.h>
+
+#ifndef CRTDLL
+    #error This file should only be built into the CRT DLLs
+#endif
+
+extern "C" {
+
+// Flag set iff DllMain was called with DLL_PROCESS_ATTACH
+static int __acrt_process_attached = 0;
+
+static BOOL DllMainProcessAttach()
+{
+    if (!__vcrt_initialize())
+        return FALSE;
+
+    if (!__acrt_initialize())
+    {
+        __vcrt_uninitialize(false);
+        return FALSE;
+    }
+
+    // Increment flag indicating the process attach completed successfully:
+    ++__acrt_process_attached;
+    return TRUE;
+}
+
+static BOOL DllMainProcessDetach(bool const terminating)
+{
+    // If there was no prior process attach or if it failed, return immediately:
+    if (__acrt_process_attached <= 0)
+        return FALSE;
+
+    --__acrt_process_attached;
+    if (!__acrt_uninitialize(terminating))
+        return FALSE;
+
+    // The VCRuntime is uninitialized during the AppCRT uninitialization; we do
+    // not need to uninitialize it here.
+    return TRUE;
+}
+
+
+// Make sure this function is not inlined so that we can use it as a place to put a breakpoint for debugging.
+__declspec(noinline) void __acrt_end_boot()
+{
+    // Do nothing.  This function is used to mark the end of the init process.
+}
+
+static __declspec(noinline) BOOL DllMainDispatch(HINSTANCE, DWORD const fdwReason, LPVOID const lpReserved)
+{
+    BOOL result = FALSE;
+    switch (fdwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+        result = DllMainProcessAttach();
+        break;
+
+    case DLL_PROCESS_DETACH:
+        result = DllMainProcessDetach(lpReserved != nullptr);
+        break;
+
+    case DLL_THREAD_ATTACH:
+        result = __acrt_thread_attach() ? TRUE : FALSE;
+        break;
+
+    case DLL_THREAD_DETACH:
+        result = __acrt_thread_detach() ? TRUE : FALSE;
+        break;
+    }
+
+    __acrt_end_boot();
+    return result;
+}
+
+BOOL WINAPI __acrt_DllMain(HINSTANCE const hInstance, DWORD const fdwReason, LPVOID const lpReserved)
+{
+    if (fdwReason == DLL_PROCESS_ATTACH)
+    {
+        // The /GS security cookie must be initialized before any exception
+        // handling targeting the current image is registered.  No function
+        // using exception handling can be called in the current image until
+        // after __security_init_cookie has been called.
+        __security_init_cookie();
+    }
+
+    // The remainder of the DllMain implementation is in a separate, noinline
+    // function to ensure that no code that might touch the security cookie
+    // runs before the __security_init_cookie function is called.  (If code
+    // that uses EH or array-type local variables were to be inlined into
+    // this function, that would cause the compiler to introduce use of the
+    // cookie into this function, before the call to __security_init_cookie.
+    // The separate, noinline function ensures that this does not occur.)
+    return DllMainDispatch(hInstance, fdwReason, lpReserved);
+}
+
+#ifdef _UCRT_ENCLAVE_BUILD
+
+#include <enclaveids.h>
+
+const IMAGE_ENCLAVE_CONFIG __enclave_config = {
+    sizeof(IMAGE_ENCLAVE_CONFIG),
+    0,
+    0,
+    0,
+    0,
+    0,
+    { 0 },
+    ENCLAVE_IMAGE_ID_UCRT,
+};
+
+#endif
+
+} // extern "C"
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/dll/empty.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/dll/empty.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/environment_initialization.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/environment_initialization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d5f0fef424a95ec7c204428e2da9d3ed923c345
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/environment_initialization.cpp	
@@ -0,0 +1,336 @@
+//
+// environment_initialization.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines functions for initializing and uninitializing the global environments
+// and for constructing and destroying environments.  The logic for manipulating
+// the environment data structures is split across this file and the setenv.cpp
+// file.
+//
+#include <corecrt_internal_traits.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+// The global environment data.  The initial environments store the pointer to
+// the environment that is passed to main or wmain.  This is used only to
+// ensure that we do not modify that environment block after we pass it to
+// user code.  The _environ_table and _wenviron_table hold the current CRT environment.
+// Their names cannot change; they are publicly documented.
+extern "C"
+{
+    char**    __dcrt_initial_narrow_environment = nullptr;
+    wchar_t** __dcrt_initial_wide_environment   = nullptr;
+
+    __crt_state_management::dual_state_global<char**>    _environ_table;
+    __crt_state_management::dual_state_global<wchar_t**> _wenviron_table;
+
+    char***    __cdecl __p__environ()  { return &_environ_table.value();  }
+    wchar_t*** __cdecl __p__wenviron() { return &_wenviron_table.value(); }
+}
+
+
+
+_Ret_opt_z_
+static char**&    get_environment_nolock(char)    throw() { return _environ_table.value();  }
+
+_Ret_opt_z_
+static wchar_t**& get_environment_nolock(wchar_t) throw() { return _wenviron_table.value(); }
+
+_Ret_opt_z_
+static char**&    __cdecl get_initial_environment(char)    throw() { return __dcrt_initial_narrow_environment; }
+
+_Ret_opt_z_
+static wchar_t**& __cdecl get_initial_environment(wchar_t) throw() { return __dcrt_initial_wide_environment;   }
+
+static __crt_state_management::dual_state_global<char**>&    get_dual_state_environment_nolock(char)    throw() { return _environ_table;  }
+static __crt_state_management::dual_state_global<wchar_t**>& get_dual_state_environment_nolock(wchar_t) throw() { return _wenviron_table; }
+
+
+
+// Counts the number of environment variables in the provided 'environment_block',
+// excluding those that start with '=' (these are drive letter settings).
+template <typename Character>
+static size_t const count_variables_in_environment_block(Character* const environment_block) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    // Count the number of variables in the environment block, ignoring drive
+    // letter settings, which begin with '=':
+    size_t count = 0;
+
+    Character* it = environment_block;
+    while (*it != '\0')
+    {
+        if (*it != '=')
+            ++count;
+
+        // This advances the iterator to the next string:
+        it += traits::tcslen(it) + 1;
+    }
+
+    return count;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Environment Create and Free (These do not modify any global data)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Frees the environment pointed-to by 'environment'.  This function ensures that
+// each of the environment strings is freed and that the array itself is freed.
+// This function requires that 'environment' is either nullptr or that it points
+// to a valid environment (i.e., one composed of a sequence of zero or more non-
+// null pointers terminated by a null pointer).
+template <typename Character>
+static void free_environment(Character** const environment) throw()
+{
+    if (!environment)
+        return;
+
+    for (Character** it = environment; *it; ++it)
+        _free_crt(*it);
+
+    _free_crt(environment);
+}
+
+
+
+// Creates a new environment, populating it with the strings from the provided
+// 'environment_block', which must be a double-null-terminated sequence of
+// environment variable strings of the form "name=value".  Variables beginning
+// with '=' are ignored (these are drive letter settings).  Returns the newly
+// created environment on succes; returns nullptr on failure.
+template <typename Character>
+static Character** const create_environment(Character* const environment_block) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    size_t const variable_count = count_variables_in_environment_block(environment_block);
+
+    __crt_unique_heap_ptr<Character*> environment(_calloc_crt_t(Character*, variable_count + 1));
+    if (!environment)
+        return nullptr;
+
+    Character*  source_it = environment_block;
+    Character** result_it = environment.get();
+
+    while (*source_it != '\0')
+    {
+        size_t const required_count = traits::tcslen(source_it) + 1;
+
+        // Don't copy drive letter settings, which start with '=':
+        if (*source_it != '=')
+        {
+            __crt_unique_heap_ptr<Character> variable(_calloc_crt_t(Character, required_count));
+            if (!variable)
+            {
+                free_environment(environment.detach());
+                return nullptr;
+            }
+
+            _ERRCHECK(traits::tcscpy_s(variable.get(), required_count, source_it));
+            *result_it++ = variable.detach();
+        }
+
+        // This advances the iterator to the next string:
+        source_it += required_count;
+    }
+
+    // The sequence of pointers is already null-terminated; return it:
+    return environment.detach();
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Environment Initialize and Uninitialize
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// In the initialize function below, we need to ensure that we've initialized
+// the mbc table before we start performing character transformations.
+static void pre_initialize(char)    throw() { __acrt_initialize_multibyte(); }
+static void pre_initialize(wchar_t) throw() { /* no-op */                    }
+
+
+
+// Gets the current environment from the operating system and initializes the
+// CRT environment from that environment.  Returns 0 on success; -1 on failure.
+// If this function returns successfully, the global environment pointer for
+// the requested environment will be non-null and valid.
+template <typename Character>
+static int __cdecl common_initialize_environment_nolock() throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    // We only initialize the environment once.  Once the environment has been
+    // initialized, all updates and modifications go through the other functions
+    // that manipulate the environment.
+    if (get_environment_nolock(Character()))
+        return 0;
+
+    pre_initialize(Character());
+
+    __crt_unique_heap_ptr<Character> const os_environment(traits::get_environment_from_os());
+    if (!os_environment)
+        return -1;
+
+    __crt_unique_heap_ptr<Character*> crt_environment(create_environment(os_environment.get()));
+    if (!crt_environment)
+        return -1;
+
+    get_initial_environment(Character()) = crt_environment.get();
+    get_dual_state_environment_nolock(Character()).initialize(crt_environment.detach());
+    return 0;
+}
+
+extern "C" int __cdecl _initialize_narrow_environment()
+{
+    return common_initialize_environment_nolock<char>();
+}
+
+extern "C" int __cdecl _initialize_wide_environment()
+{
+    return common_initialize_environment_nolock<wchar_t>();
+}
+
+
+
+// Frees the global wide and narrow environments and returns.
+template <typename Character>
+static void __cdecl uninitialize_environment_internal(Character**& environment) throw()
+{
+    if (environment == get_initial_environment(Character()))
+    {
+        return;
+    }
+
+    free_environment(environment);
+}
+
+extern "C" void __cdecl __dcrt_uninitialize_environments_nolock()
+{
+    _environ_table .uninitialize(uninitialize_environment_internal<char>);
+    _wenviron_table.uninitialize(uninitialize_environment_internal<wchar_t>);
+
+    free_environment(__dcrt_initial_narrow_environment);
+    free_environment(__dcrt_initial_wide_environment);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Environment Get-Or-Create
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions help with synchronization between the narrow and wide
+// environments.  If the requested environment has not yet been initialized but
+// the other environment has been initialized, the other environment is cloned
+// to create the requested environment.  Note that if the other environment has
+// not yet been initialized, these functions do not do anything.
+
+// Gets the other environment and copies each of the environment variables from
+// it into the requested environment.  Returns 0 on success; -1 on failure.
+template <typename Character>
+static int __cdecl initialize_environment_by_cloning_nolock() throw()
+{
+    typedef __crt_char_traits<Character> traits;
+    typedef typename traits::other_char_type other_char_type;
+
+    other_char_type** const other_environment = get_environment_nolock(other_char_type());
+    if (!other_environment)
+        return -1;
+
+    for (other_char_type** it = other_environment; *it; ++it)
+    {
+        size_t const required_count = __crt_compute_required_transform_buffer_count(CP_ACP, *it);
+        if (required_count == 0)
+            return -1;
+
+        __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, required_count));
+        if (!buffer)
+            return -1;
+
+        size_t const actual_count = __crt_transform_string(CP_ACP, *it, buffer.get(), required_count);
+        if (actual_count == 0)
+            return -1;
+
+        // Ignore a failed attempt to set a variable; continue with the rest...
+        traits::set_variable_in_environment_nolock(buffer.detach(), 0);
+    }
+
+    return 0;
+}
+
+
+
+// If the requested environment exists, this function returns it unmodified.  If
+// the requested environment does not exist but the other environment does, the
+// other environment is cloned to create the requested environment, and the new
+// requested environment is returned.  Otherwise, nullptr is returned.
+template <typename Character>
+_Deref_ret_opt_z_
+static Character** __cdecl common_get_or_create_environment_nolock() throw()
+{
+    typedef __crt_char_traits<Character> traits;
+    typedef typename traits::other_char_type other_char_type;
+
+    // Check to see if the required environment already exists:
+    Character** const existing_environment = get_environment_nolock(Character());
+    if (existing_environment)
+        return existing_environment;
+
+    // Check to see if the other environment exists.  We will only initialize
+    // the environment here if the other environment was already initialized.
+    other_char_type** const other_environment = get_environment_nolock(other_char_type());
+    if (!other_environment)
+        return nullptr;
+
+    if (common_initialize_environment_nolock<Character>() != 0)
+    {
+        if (initialize_environment_by_cloning_nolock<Character>() != 0)
+        {
+            return nullptr;
+        }
+    }
+
+    return get_environment_nolock(Character());
+}
+
+extern "C" char** __cdecl __dcrt_get_or_create_narrow_environment_nolock()
+{
+    return common_get_or_create_environment_nolock<char>();
+}
+
+extern "C" wchar_t** __cdecl __dcrt_get_or_create_wide_environment_nolock()
+{
+    return common_get_or_create_environment_nolock<wchar_t>();
+}
+
+template <typename Character>
+static Character** __cdecl common_get_initial_environment() throw()
+{
+    Character**& initial_environment = get_initial_environment(Character());
+    if (!initial_environment)
+    {
+        initial_environment = common_get_or_create_environment_nolock<Character>();
+    }
+
+    return initial_environment;
+}
+
+extern "C" char** __cdecl _get_initial_narrow_environment()
+{
+    return common_get_initial_environment<char>();
+}
+
+extern "C" wchar_t** __cdecl _get_initial_wide_environment()
+{
+    return common_get_initial_environment<wchar_t>();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/get_environment_from_os.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/get_environment_from_os.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..55f2b3555ce825ac6e3f65665968008db1099209
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/get_environment_from_os.cpp	
@@ -0,0 +1,121 @@
+//
+// get_environment_from_os.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines a pair of functions to get the environment strings from the operating
+// system.  These functions copy the environment strings into a CRT-allocated
+// buffer and return a pointer to that buffer.  The caller is responsible for
+// freeing the returned buffer (via _crt_free).
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <stdlib.h>
+
+
+
+namespace
+{
+    struct environment_strings_traits
+    {
+        typedef wchar_t* type;
+
+        static bool close(_In_ type p) throw()
+        {
+            FreeEnvironmentStringsW(p);
+            return true;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return nullptr;
+        }
+    };
+
+    typedef __crt_unique_handle_t<environment_strings_traits> environment_strings_handle;
+}
+
+
+
+static wchar_t const* __cdecl find_end_of_double_null_terminated_sequence(wchar_t const* const first) throw()
+{
+    wchar_t const* last = first;
+    for (; *last != '\0'; last += wcslen(last) + 1)
+    {
+    }
+
+    return last + 1; // Return the pointer one-past-the-end of the double null terminator
+}
+
+
+
+extern "C" wchar_t* __cdecl __dcrt_get_wide_environment_from_os() throw()
+{
+    environment_strings_handle const environment(GetEnvironmentStringsW());
+    if (!environment)
+        return nullptr;
+
+    // Find the
+    wchar_t const* const first = environment.get();
+    wchar_t const* const last = find_end_of_double_null_terminated_sequence(first);
+
+    size_t const required_count = last - first;
+
+    __crt_unique_heap_ptr<wchar_t> buffer(_malloc_crt_t(wchar_t, required_count));
+    if (!buffer)
+        return nullptr;
+
+    // Note that the multiplication here cannot overflow:
+    memcpy(buffer.get(), environment.get(), required_count * sizeof(wchar_t));
+    return buffer.detach();
+}
+
+
+
+extern "C" char* __cdecl __dcrt_get_narrow_environment_from_os() throw()
+{
+    // Note that we call GetEnvironmentStringsW and convert to multibyte.  The
+    // GetEnvironmentStringsA function returns the environment in the OEM code
+    // page, but we need the strings in ANSI.
+    environment_strings_handle const environment(GetEnvironmentStringsW());
+    if (!environment.is_valid())
+        return nullptr;
+
+    wchar_t const* const first = environment.get();
+    wchar_t const* const last = find_end_of_double_null_terminated_sequence(first);
+
+    size_t const required_wide_count = last - first;
+#pragma warning(suppress:__WARNING_W2A_BEST_FIT) // 38021 Prefast recommends WC_NO_BEST_FIT_CHARS.
+    size_t const required_narrow_count = static_cast<size_t>(__acrt_WideCharToMultiByte(
+        CP_ACP,
+        0,
+        environment.get(),
+        static_cast<int>(required_wide_count),
+        nullptr,
+        0,
+        nullptr,
+        nullptr));
+
+    if (required_narrow_count == 0)
+        return nullptr;
+
+    __crt_unique_heap_ptr<char> buffer(_malloc_crt_t(char, required_narrow_count));
+    if (!buffer)
+        return nullptr;
+
+#pragma warning(suppress:__WARNING_W2A_BEST_FIT) // 38021 Prefast recommends WC_NO_BEST_FIT_CHARS.
+    int const conversion_result = __acrt_WideCharToMultiByte(
+        CP_ACP,
+        0,
+        environment.get(),
+        static_cast<int>(required_wide_count),
+        buffer.get(),
+        static_cast<int>(required_narrow_count),
+        nullptr,
+        nullptr);
+
+    if (conversion_result == 0)
+        return nullptr;
+
+    return buffer.detach();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/getenv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/getenv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d242a7d2dd80c23e0c921fa8c7b13793a31ff02f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/getenv.cpp	
@@ -0,0 +1,329 @@
+//
+// getenv.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the getenv family of functions, which search the environment for a
+// variable and return its value.
+//
+#include <corecrt_internal_traits.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// getenv() and _wgetenv()
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions search the environment for a variable with the given name.
+// If such a variable is found, a pointer to its value is returned.  Otherwise,
+// nullptr is returned.  Note that if the environment is access and manipulated
+// from multiple threads, this function cannot be safely used:  the returned
+// pointer may not be valid when the function returns.
+template <typename Character>
+static Character* __cdecl common_getenv_nolock(Character const* const name) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+    
+    Character** const environment = traits::get_or_create_environment_nolock();
+    if (environment == nullptr || name == nullptr)
+        return nullptr;
+
+    size_t const name_length = traits::tcslen(name);
+
+    for (Character** current = environment; *current; ++current)
+    {
+        if (traits::tcslen(*current) <= name_length)
+            continue;
+
+        if (*(*current + name_length) != '=')
+            continue;
+
+        if (traits::tcsnicoll(*current, name, name_length) != 0)
+            continue;
+
+        // Internal consistency check:  The environment string should never use
+        // a bigger buffer than _MAX_ENV.  See also the SetEnvironmentVariable
+        // SDK function.
+        _ASSERTE(traits::tcsnlen(*current + name_length + 1, _MAX_ENV) < _MAX_ENV);
+
+        return *current + name_length + 1;
+    }
+
+    return nullptr;
+}
+
+
+
+template <typename Character>
+static Character* __cdecl common_getenv(Character const* const name) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(name != nullptr,                            EINVAL, nullptr);
+    _VALIDATE_RETURN(traits::tcsnlen(name, _MAX_ENV) < _MAX_ENV, EINVAL, nullptr);
+
+    Character* result = 0;
+
+    __acrt_lock(__acrt_environment_lock);
+    __try
+    {
+        result = common_getenv_nolock(name);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_environment_lock);
+    }
+    
+    return result;
+}
+
+extern "C" char* __cdecl getenv(char const* const name)
+{
+    return common_getenv(name);
+}
+
+extern "C" wchar_t* __cdecl _wgetenv(wchar_t const* const name)
+{
+    return common_getenv(name);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// getenv_s() and _wgetenv_s()
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions search the environment for a variable with the given name.
+// If such a variable is found, its value is copied into the provided buffer.
+// The number of characters in the value (including the null terminator) is
+// stored in '*required_count'.  Returns 0 on success; returns ERANGE if the
+// provided buffer is too small; otherwise returns an error code on failure.
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_getenv_s_nolock(
+                                    size_t*             const   required_count,
+    _Out_writes_z_(buffer_count)    Character*          const   buffer,
+                                    size_t              const   buffer_count,
+                                    Character const*    const   name
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(required_count != nullptr, EINVAL);
+    *required_count = 0;
+
+    _VALIDATE_RETURN_ERRCODE(
+        (buffer != nullptr && buffer_count >  0) ||
+        (buffer == nullptr && buffer_count == 0), EINVAL);
+
+    if (buffer)
+        buffer[0] = '\0';
+
+    Character const* const value = common_getenv_nolock(name);
+    if (!value)
+        return 0;
+
+    *required_count = traits::tcslen(value) + 1;
+    if (buffer_count == 0)
+        return 0;
+
+    // The buffer is too small; we return an error code and the caller can have
+    // the opportunity to try again with a larger buffer:
+    if (*required_count > buffer_count)
+        return ERANGE;
+
+    _ERRCHECK(traits::tcscpy_s(buffer, buffer_count, value));
+    return 0;
+}
+
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_getenv_s(
+                                    size_t*             const   required_count,
+    _Out_writes_z_(buffer_count)    Character*          const   buffer,
+                                    size_t              const   buffer_count,
+                                    Character const*    const   name
+    ) throw()
+{
+    errno_t status = 0;
+
+    __acrt_lock(__acrt_environment_lock);
+    __try
+    {
+        status = common_getenv_s_nolock(required_count, buffer, buffer_count, name);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_environment_lock);
+    }
+    
+    return status;
+}
+
+extern "C" errno_t __cdecl getenv_s(
+    size_t*     const required_count,
+    char*       const buffer,
+    size_t      const buffer_count,
+    char const* const name
+    )
+{
+    return common_getenv_s(required_count, buffer, buffer_count, name);
+}
+
+extern "C" errno_t __cdecl _wgetenv_s(
+    size_t*        const required_count,
+    wchar_t*       const buffer,
+    size_t         const buffer_count,
+    wchar_t const* const name
+    )
+{
+    return common_getenv_s(required_count, buffer, buffer_count, name);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// _dupenv_s() and _wdupenv_s()
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions search the environment for a variable with the given name.
+// If a variable is found, a buffer is allocated using the public malloc to hold
+// the value of the variable. The value is copied into the buffer and the buffer
+// is returned to the caller via 'buffer_pointer' and 'buffer_count'. The caller
+// is responsible for freeing the buffer.
+//
+// Returns zero on success; returns an error code on failure.  Note that if a
+// variable with the specified name is not found, that is still considered a
+// success; in this case, the 'value' is an empty string ('*buffer_count' will
+// be zero and '*buffer_pointer' will be nullptr).
+template <typename Character>
+static errno_t __cdecl common_dupenv_s_nolock(
+    _Outptr_result_buffer_maybenull_(*buffer_count) _Outptr_result_maybenull_z_ Character**         const   buffer_pointer,
+    _Out_opt_                                                                   size_t*             const   buffer_count,
+                                                                                Character const*    const   name,
+                                                                                int                 const   block_use,
+                                                                                char const*         const   file_name,
+                                                                                int                 const   line_number
+    ) throw()
+{
+    // These are referenced only in the Debug CRT build
+    UNREFERENCED_PARAMETER(block_use);
+    UNREFERENCED_PARAMETER(file_name);
+    UNREFERENCED_PARAMETER(line_number);
+
+    typedef __crt_char_traits<Character> traits;
+
+     _VALIDATE_RETURN_ERRCODE(buffer_pointer != nullptr, EINVAL);
+    *buffer_pointer = nullptr;
+
+    if (buffer_count != nullptr)
+        *buffer_count = 0;
+
+    _VALIDATE_RETURN_ERRCODE(name != nullptr, EINVAL);
+
+    Character const* const value = common_getenv_nolock(name);
+    if (value == nullptr)
+        return 0;
+
+    size_t const value_count = traits::tcslen(value) + 1;
+
+    *buffer_pointer = static_cast<Character*>(_calloc_dbg(
+        value_count,
+        sizeof(Character),
+        block_use,
+        file_name,
+        line_number));
+    _VALIDATE_RETURN_ERRCODE_NOEXC(*buffer_pointer != nullptr, ENOMEM);
+
+    _ERRCHECK(traits::tcscpy_s(*buffer_pointer, value_count, value));
+    if (buffer_count != nullptr)
+        *buffer_count = value_count;
+
+    return 0;
+}
+
+template <typename Character>
+_Success_(return != 0)
+static errno_t __cdecl common_dupenv_s(
+    _Outptr_result_buffer_maybenull_(*buffer_count) _Outptr_result_maybenull_z_ Character**         const   buffer_pointer,
+    _Out_opt_                                                                   size_t*             const   buffer_count,
+                                                                                Character const*    const   name,
+                                                                                int                 const   block_use,
+                                                                                char const*         const   file_name,
+                                                                                int                 const   line_number
+    ) throw()
+{
+    errno_t status = 0;
+
+    __acrt_lock(__acrt_environment_lock);
+    __try
+    {
+        status = common_dupenv_s_nolock(
+            buffer_pointer,
+            buffer_count,
+            name,
+            block_use,
+            file_name,
+            line_number);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_environment_lock);
+    }
+    
+    return status;
+}
+
+extern "C" errno_t __cdecl _dupenv_s(
+    char**      const buffer_pointer,
+    size_t*     const buffer_count,
+    char const* const name
+    )
+{
+    return common_dupenv_s(buffer_pointer, buffer_count, name, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" errno_t __cdecl _wdupenv_s(
+    wchar_t**      const buffer_pointer,
+    size_t*        const buffer_count,
+    wchar_t const* const name
+    )
+{
+    return common_dupenv_s(buffer_pointer, buffer_count, name, _NORMAL_BLOCK, nullptr, 0);
+}
+
+#ifdef _DEBUG
+
+#undef _dupenv_s_dbg
+#undef _wdupenv_s_dbg
+
+extern "C" errno_t __cdecl _dupenv_s_dbg(
+    char**      const buffer_pointer,
+    size_t*     const buffer_count,
+    char const* const name,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return common_dupenv_s(buffer_pointer, buffer_count, name, block_use, file_name, line_number);
+}
+
+extern "C" errno_t __cdecl _wdupenv_s_dbg(
+    wchar_t**      const buffer_pointer,
+    size_t*        const buffer_count,
+    wchar_t const* const name,
+    int            const block_use,
+    char const*    const file_name,
+    int            const line_number
+    )
+{
+    return common_dupenv_s(buffer_pointer, buffer_count, name, block_use, file_name, line_number);
+}
+
+#endif // _DEBUG
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/getpath.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/getpath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ddc88d2d4bbc2d30c62b49f8f427ea40c7364054
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/getpath.cpp	
@@ -0,0 +1,159 @@
+/***
+*getpath.c - extract a pathname from an environment variable
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Extract pathnames from a string of semicolon delimited pathnames
+*       (generally the value of an environment variable such as PATH).
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <stddef.h>
+
+/***
+*_getpath() - extract a pathname from a semicolon-delimited list of pathnames
+*
+*Purpose:
+*       To extract the next pathname from a semicolon-delimited list of
+*       pathnames (usually the value on an environment variable) and copy
+*       it to a caller-specified buffer. No check is done to see if the path
+*       is valid. The maximum number of characters copied to the buffer is
+*       maxlen - 1 (and then a '\0' is appended).
+*
+*ifdef _HPFS_
+*       If we hit a quoted string, then allow any characters inside.
+*       For example, to put a semi-colon in a path, the user could have
+*       an environment variable that looks like:
+*
+*               PATH=C:\BIN;"D:\CRT\TOOLS;B1";C:\BINP
+*endif
+*
+*       NOTE: Semi-colons in sequence are skipped over; pointers to 0-length
+*       pathnames are NOT returned (this includes leading semi-colons).
+*
+*       NOTE: If this routine is made user-callable, the near attribute
+*       must be replaced by _LOAD_DS and the prototype moved from INTERNAL.H
+*       to STDLIB.H. The source files MISC\SEARCHEN.C and EXEC\SPAWNVPE.C
+*       will need to be recompiled, but should not require any changes.
+*
+*Entry:
+*       src    - Pointer to a string of 0 or more path specificiations,
+*                delimited by semicolons (';'), and terminated by a null
+*                character
+*       dst    - Pointer to the buffer where the next path specification is to
+*                be copied
+*       maxlen - Maximum number of characters to be copied, counting the
+*                terminating null character. Note that a value of 0 is treated
+*                as UINT_MAX + 1.
+*
+*Exit:
+*       If a pathname is successfully extracted and copied, a pointer to the
+*       first character of next pathname is returned (intervening semicolons
+*       are skipped over). If the pathname is too long, as much as possible
+*       is copied to the user-specified buffer and nullptr is returned.
+*
+*       Note that the no check is made of the validity of the copied pathname.
+*
+*Exceptions:
+*
+*******************************************************************************/
+template <typename Character>
+_Success_(return != 0)
+static Character* __cdecl common_getpath(
+    _In_z_                          Character const*    const   delimited_paths,
+    _Out_writes_z_(result_count)    Character*          const   result,
+                                    size_t              const   result_count
+    ) throw()
+{
+    _VALIDATE_RETURN_NOEXC(result != nullptr, EINVAL, nullptr);
+
+    if (result_count > 0)
+    {
+        result[0] = '\0';
+    }
+
+    _VALIDATE_RETURN_NOEXC(result_count > 1,  EINVAL, nullptr);
+
+    Character const* source_it = delimited_paths;
+
+    // Skip past any leading semicolons:
+    while (*source_it == ';')
+    {
+        ++source_it;
+    }
+
+    Character const* const source_first = source_it;
+
+    Character*       result_it   = result;
+    Character* const result_last = result + result_count - 1; // Leave room for \0
+
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 Prefast is confused.
+    while (*source_it != '\0' && *source_it != ';')
+    {
+        if (*source_it == '"')
+        {
+            // We found a quote; copy all characters until we reach the matching
+            // end quote or the end of the string:
+            ++source_it; // Advance past opening quote
+
+            while (*source_it != '\0' && *source_it != '"')
+            {
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 26015 Prefast is confused.
+                *result_it++ = *source_it++;
+                if (result_it == result_last)
+                {
+                    *result_it = '\0';
+                    errno = ERANGE;
+                    return nullptr;
+                }
+            }
+
+            if (*source_it != '\0')
+            {
+                ++source_it; // Advance past closing quote
+            }
+        }
+        else
+        {
+            *result_it++ = *source_it++;
+            if (result_it == result_last)
+            {
+                *result_it = '\0';
+                errno = ERANGE;
+                return nullptr;
+            }
+        }
+    }
+
+    // If we copied something and stopped because we reached a semicolon, skip
+    // any semicolons before returning:
+    while (*source_it == ';')
+    {
+        ++source_it;
+    }
+
+    *result_it = '\0';
+    return source_it == source_first
+        ? nullptr
+        : const_cast<Character*>(source_it);
+}
+
+extern "C" char* __cdecl __acrt_getpath(
+    char const* const delimited_paths,
+    char*       const result,
+    size_t      const result_count
+    )
+{
+    return common_getpath(delimited_paths, result, result_count);
+}
+
+extern "C" wchar_t* __cdecl __acrt_wgetpath(
+    wchar_t const* const delimited_paths,
+    wchar_t*       const result,
+    size_t         const result_count
+    )
+{
+    return common_getpath(delimited_paths, result, result_count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/putenv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/putenv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c87bd55093ebca0506827f0fea5c0c323191455
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/putenv.cpp	
@@ -0,0 +1,243 @@
+//
+// putenv.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the putenv() family of functions, which add, replace, or remove an
+// environment variable from the current process environment.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+// These functions test to see if the other environment exists
+static bool other_environment_exists(wchar_t) throw() { return _environ_table.value() != nullptr; }
+static bool other_environment_exists(char)    throw() { return _wenviron_table.value() != nullptr; }
+
+
+
+// This function computes the required size of the buffer that will store a
+// "name=value" string in the other environment.
+template <typename Character>
+static size_t compute_required_transform_buffer_count(
+    Character const* const name,
+    Character const* const value
+    ) throw()
+{
+    // Compute the amount of space required for the transformation:
+    size_t const name_count_required = __crt_compute_required_transform_buffer_count(CP_ACP, name);
+    _VALIDATE_RETURN_NOEXC(name_count_required != 0, EILSEQ, false);
+
+    if (!value)
+        return name_count_required;
+
+    size_t const value_count_required = __crt_compute_required_transform_buffer_count(CP_ACP, value);
+    _VALIDATE_RETURN_NOEXC(value_count_required != 0, EILSEQ, false);
+
+    // Note that each count includes space a the null terminator.  Since we'll
+    // only be storing one terminator in the buffer, the space for the other
+    // terminator will be used to store the '=' between the name and the value.
+    return name_count_required + value_count_required;
+}
+
+
+
+// Constructs an environment string of the form "name=value" from a {name, value}
+// pair.  Returns a pointer to the resulting string.  The string is dynamically
+// allocated and must be freed by the caller (via the CRT free).
+template <typename Character>
+static Character* create_environment_string(
+    Character const* const name,
+    Character const* const value
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    if (value)
+    {
+        size_t const name_length  = traits::tcsnlen(name,  _MAX_ENV);
+        size_t const value_length = traits::tcsnlen(value, _MAX_ENV);
+
+        _VALIDATE_RETURN(name_length  < _MAX_ENV, EINVAL, nullptr);
+        _VALIDATE_RETURN(value_length < _MAX_ENV, EINVAL, nullptr);
+
+        // We add two to the length:  one for the '=' and one for the terminator
+        size_t const buffer_count = name_length + 1 + value_length + 1;
+
+        __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, buffer_count));
+        if (!buffer)
+            return nullptr;
+
+        traits::tcscpy_s(buffer.get(), buffer_count, name);
+        buffer.get()[name_length] = '=';
+        traits::tcscpy_s(buffer.get() + name_length + 1, value_length + 1, value);
+
+        return buffer.detach();
+    }
+    else
+    {
+        Character const* const equal_sign_it = traits::tcschr(name, '=');
+        if (equal_sign_it)
+        {
+            // Validate the length of both the name and the value:
+            _VALIDATE_RETURN(equal_sign_it - name < _MAX_ENV,                         EINVAL, nullptr);
+            _VALIDATE_RETURN(traits::tcsnlen(equal_sign_it + 1, _MAX_ENV) < _MAX_ENV, EINVAL, nullptr);
+        }
+
+        size_t const buffer_count = traits::tcslen(name) + 1;
+
+        __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, buffer_count));
+        if (!buffer)
+            return nullptr;
+
+        traits::tcscpy_s(buffer.get(), buffer_count, name);
+
+        return buffer.detach();
+    }
+}
+
+
+
+// Converts the {name, value} pair to the other kind of string (wchar_t => char,
+// char => wchar_t) and updates the other environment.
+template <typename Character>
+static bool __cdecl set_variable_in_other_environment(
+    Character const* const name,
+    Character const* const value
+    ) throw()
+{
+    typedef __crt_char_traits<Character>       traits;
+    typedef typename traits::other_char_type   other_char_type;
+    typedef __crt_char_traits<other_char_type> other_traits;
+
+    size_t const buffer_count = compute_required_transform_buffer_count(name, value);
+
+    __crt_unique_heap_ptr<other_char_type> buffer(_calloc_crt_t(other_char_type, buffer_count));
+    if (!buffer)
+        return false;
+
+    size_t const name_written_count = __crt_transform_string(CP_ACP, name, buffer.get(), buffer_count);
+    _VALIDATE_RETURN_NOEXC(name_written_count != 0, EILSEQ, false);
+
+    if (value)
+    {
+        // Overwrite the null terminator with an '=':
+        buffer.get()[name_written_count - 1] = '=';
+
+        size_t const value_written_count = __crt_transform_string(
+            CP_ACP,
+            value,
+            buffer.get() + name_written_count,
+            buffer_count - name_written_count);
+        _VALIDATE_RETURN_NOEXC(value_written_count != 0, EILSEQ, false);
+    }
+
+    return other_traits::set_variable_in_environment_nolock(buffer.detach(), 0) == 0;
+}
+
+
+
+// Adds, replaces, or removes a variable in the current environment.  For the
+// functions that take a {name, value} pair, the name is the name of the variable
+// and the value is the value it is to be given.  For the functions that just
+// take and option, the option is of the form "name=value".
+//
+// If the value is an empty string and the name names an existing environment
+// variable, that variable is removed from the environment.  If the value is
+// a nonempty string and the name names an existing environment variable, the
+// variable is updated to have the new value.  If the value is a nonempty string
+// and the name does not name an existing environment variable, a new variable
+// is added to the environment.
+//
+// If the required environment does not yet exist, it is created from the other
+// environment.  If both environments exist, the modifications are made to both
+// of them so that they are kept in sync.
+//
+// Returns 0 on success; -1 on failure.
+template <typename Character>
+static int __cdecl common_putenv_nolock(
+    Character const* const name,
+    Character const* const value
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    // Ensure that the environment is initialized:
+    if (!_environ_table.value() && !_wenviron_table.value())
+        return -1;
+
+    // At startup, we obtain the "native" flavor of environment strings from the
+    // operating system.  So, a "main" program has _environ set and a "wmain"
+    // program has _wenviron set.  Only when the user gets or puts the "other"
+    // flavor do we convert it.
+    _VALIDATE_RETURN(name != nullptr, EINVAL, -1);
+
+    __crt_unique_heap_ptr<Character> new_option(create_environment_string(name, value));
+    if (!new_option)
+        return -1;
+
+    if (traits::set_variable_in_environment_nolock(new_option.detach(), 1) != 0)
+        return -1;
+
+    // See if the "other" environment type exists; if it doesn't, we're done.
+    // Otherwise, put the new option into the other environment as well.
+    if (!other_environment_exists(Character()))
+        return 0;
+
+    if (!set_variable_in_other_environment(name, value))
+        return -1;
+
+    return 0;
+}
+
+
+
+template <typename Character>
+static int __cdecl common_putenv(
+    Character const* const name,
+    Character const* const value
+    ) throw()
+{
+    int status = 0;
+
+    __acrt_lock(__acrt_environment_lock);
+    __try
+    {
+        status = common_putenv_nolock(name, value);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_environment_lock);
+    }
+
+    return status;
+}
+
+
+
+extern "C" int __cdecl _putenv(char const* const option)
+{
+    return common_putenv(option, static_cast<char const*>(nullptr));
+}
+
+extern "C" int __cdecl _wputenv(wchar_t const* const option)
+{
+    return common_putenv(option, static_cast<wchar_t const*>(nullptr));
+}
+
+
+
+extern "C" errno_t __cdecl _putenv_s(char const* const name, char const* const value)
+{
+    _VALIDATE_RETURN_ERRCODE(value != nullptr, EINVAL);
+    return common_putenv(name, value) == 0 ? 0 : errno;
+}
+
+extern "C" errno_t __cdecl _wputenv_s(wchar_t const* const name, wchar_t const* const value)
+{
+    _VALIDATE_RETURN_ERRCODE(value != nullptr, EINVAL);
+    return common_putenv(name, value) == 0 ? 0 : errno;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/searchenv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/searchenv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7126497e31420eadd77c6e66353797583b9114a6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/searchenv.cpp	
@@ -0,0 +1,215 @@
+//
+// searchenv.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the searchenv() family of functions, which search for a file in the
+// paths contained in an environment variable (like %PATH%).
+//
+#include <direct.h>
+#include <corecrt_internal_traits.h>
+#include <io.h>
+#include <stdlib.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036 Prefast doesn't understand perfect forwarding so annotations are lost.
+#pragma warning(disable:__WARNING_MISSING_ZERO_TERMINATION2) // 6054 Prefast doesn't understand perfect forwarding so annotations are lost.
+
+// These functions search for a file in the paths in an environment variable.
+// The environment variable named 'environment_variable' is retrieved from the
+// environment.  It is expected to contain a semicolon-delimited sequence of
+// directories, similar to %PATH%.  The file name is concatenated onto the end
+// of each directory string in sequence and its existence is tested for.  When
+// a file is found, the search stops and the buffer is filled with the full path
+// to the file.  If the file is not found for whatever reason, a zero-length
+// string is placed in the buffer and an error code is returned.
+template <typename Character>
+static errno_t __cdecl common_searchenv_s(
+    _In_z_                       Character const* const file_name,
+    _In_z_                       Character const* const environment_variable,
+    _Out_writes_z_(result_count) Character*       const result_buffer,
+    _In_                         size_t           const result_count
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(result_buffer != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(result_count  >  0,       EINVAL);
+    if (!file_name)
+    {
+        result_buffer[0] = '\0';
+        _VALIDATE_RETURN_ERRCODE(file_name != nullptr, EINVAL);
+    }
+
+    // Special case:  If the file name is an empty string, we'll just return an
+    // empty result_buffer and set errno:
+    if (file_name[0] == '\0')
+    {
+        result_buffer[0] = '\0';
+        return errno = ENOENT;
+    }
+
+    errno_t saved_errno = errno;
+    int const access_result = traits::taccess_s(file_name, 0);
+    errno = saved_errno;
+
+    // If the file name exists, convert it to a fully qualified result_buffer name:
+    if (access_result == 0)
+    {
+        if (traits::tfullpath(result_buffer, file_name, result_count) == nullptr)
+        {
+            result_buffer[0] = '\0';
+            return errno; // fullpath will set errno
+        }
+
+        return 0;
+    }
+
+    Character* path_string = nullptr;
+    if (_ERRCHECK_EINVAL(traits::tdupenv_s_crt(&path_string, nullptr, environment_variable)) != 0 || path_string == nullptr)
+    {   
+        result_buffer[0] = '\0';
+        return errno = ENOENT; // The environment variable doesn't exist
+    }
+
+    __crt_unique_heap_ptr<Character> const path_string_cleanup(path_string);
+
+    size_t const file_name_length = traits::tcslen(file_name);
+    
+    size_t const local_path_count = _MAX_PATH + 4;
+    Character local_path_buffer[local_path_count];
+    
+    size_t     path_count  = local_path_count;
+    Character* path_buffer = local_path_buffer;
+    if (file_name_length >= result_count)
+    {
+        // The local buffer is not large enough; dynamically allocate a new
+        // buffer.  We add two to the size to account for a trailing slash
+        // that we may need to add and for the null terminator:
+        path_count  = traits::tcslen(path_string) + file_name_length + 2;
+        path_buffer = _calloc_crt_t(Character, path_count).detach(); // We'll retake ownership below
+        if (!path_buffer)
+        {
+            result_buffer[0] = '\0';
+            return errno = ENOMEM;
+        }
+    }
+
+    __crt_unique_heap_ptr<Character> path_buffer_cleanup(path_buffer == local_path_buffer
+        ? nullptr
+        : path_buffer);
+
+    saved_errno = errno;
+    while (path_string)
+    {
+        Character* const previous_path_string = path_string;
+        path_string = traits::tgetpath(path_string, path_buffer, path_count - file_name_length - 1);
+        if (!path_string && path_buffer == local_path_buffer && errno == ERANGE)
+        {
+            // If the getpath operation failed because the buffer was not large
+            // enough, try allocating a larger buffer:
+            size_t const required_count = traits::tcslen(previous_path_string) + file_name_length + 2;
+
+            path_buffer_cleanup = _calloc_crt_t(Character, required_count);
+            if (!path_buffer_cleanup)
+            {
+                result_buffer[0] = '\0';
+                return errno = ENOMEM;
+            }
+
+            path_count  = required_count;
+            path_buffer = path_buffer_cleanup.get();
+
+            path_string = traits::tgetpath(previous_path_string, path_buffer, path_count - file_name_length);
+        }
+
+        if (!path_string || path_buffer[0] == '\0')
+        {
+            result_buffer[0] = '\0';
+            return errno = ENOENT;
+        }
+
+        // The result_buffer now holds a non-empty path name from path_string
+        // and we know that the buffer is large enough to hold the concatenation
+        // of the path with the file name (if not, the call to getpath would
+        // have failed.  So, we concatenate the path and file names:
+        size_t path_length = traits::tcslen(path_buffer);
+        Character* path_it = path_buffer + path_length;
+        
+        // Add a trailing '\' if one is required:
+        Character const last_character = *(path_it - 1);
+        if (last_character != '/' && last_character != '\\' && last_character != ':')
+        {
+            *path_it++ = '\\';
+            ++path_length;
+        }
+
+        // The path_it now points to the character following the trailing '\',
+        // '/', or ':'; this is where we copy the file name:
+        _ERRCHECK(traits::tcscpy_s(path_it, path_count - path_length, file_name));
+
+        // If we can't access the file at this path, it isn't a match:
+        if (traits::taccess_s(path_buffer, 0) != 0)
+            continue;
+
+        // Otherwise, we can access the file, and we copy the full path into the
+        // caller-provided buffer:
+        if (path_length + file_name_length + 1 > result_count)
+        {
+            result_buffer[0] = '\0';
+            return errno = ERANGE;
+        }
+
+        errno = saved_errno;
+
+        _ERRCHECK(traits::tcscpy_s(result_buffer, result_count, path_buffer));
+        return 0;
+    }
+
+    // If we get here, we must have tried every path in the environment and not
+    // found the file name:
+    result_buffer[0] = '\0';
+    return errno = ENOENT;
+}
+
+
+
+extern "C" errno_t __cdecl _searchenv_s(
+    char const* const file_name,
+    char const* const environment_variable,
+    char*       const result_buffer,
+    size_t      const result_count
+    )
+{
+    return common_searchenv_s(file_name, environment_variable, result_buffer, result_count);
+}
+
+extern "C" errno_t __cdecl _wsearchenv_s(
+    wchar_t const* const file_name,
+    wchar_t const* const environment_variable,
+    wchar_t*       const result_buffer,
+    size_t         const result_count
+    )
+{
+    return common_searchenv_s(file_name, environment_variable, result_buffer, result_count);
+}
+
+
+
+extern "C" void __cdecl _searchenv(
+    char const* const file_name,
+    char const* const environment_variable,
+    char*       const result_buffer
+    )
+{
+    common_searchenv_s(file_name, environment_variable, result_buffer, _MAX_PATH);
+}
+
+extern "C" void __cdecl _wsearchenv(
+    wchar_t const* const file_name,
+    wchar_t const* const environment_variable,
+    wchar_t*       const result_buffer
+    )
+{
+    common_searchenv_s(file_name, environment_variable, result_buffer, _MAX_PATH);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/setenv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/setenv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..930f57831abe3f706c0c83186fe85c91e95c101a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/env/setenv.cpp	
@@ -0,0 +1,373 @@
+//
+// setenv.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Internal functions for setting or removing variables from an environment. The
+// logic for manipulating the environment data structures is split across this
+// file and environment_initialization.cpp.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <limits.h>
+#include <stdlib.h>
+
+
+
+static char**&    __cdecl get_environment(char)    throw() { return _environ_table.value(); }
+static wchar_t**& __cdecl get_environment(wchar_t) throw() { return _wenviron_table.value(); }
+
+static wchar_t**& __cdecl get_other_environment(char)    throw() { return _wenviron_table.value(); }
+static char**&    __cdecl get_other_environment(wchar_t) throw() { return _environ_table.value(); }
+
+static char**&    __cdecl get_initial_environment(char)    throw() { return __dcrt_initial_narrow_environment; }
+static wchar_t**& __cdecl get_initial_environment(wchar_t) throw() { return __dcrt_initial_wide_environment;   }
+
+
+
+// Makes a copy of the provided environment and returns the copy.  The caller is
+// responsible for freeing the returned array (using the CRT free).  Returns
+// nullptr on failure; terminates the process on allocation failure.
+template <typename Character>
+static Character** __cdecl copy_environment(Character** const old_environment) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    if (!old_environment)
+    {
+        return nullptr;
+    }
+
+    // Count the number of environment variables:
+    size_t entry_count = 0;
+    for (Character** it = old_environment; *it; ++it)
+    {
+        ++entry_count;
+    }
+
+    // We need one pointer for each string, plus one null pointer at the end:
+    __crt_unique_heap_ptr<Character*> new_environment(_calloc_crt_t(Character*, entry_count + 1));
+    if (!new_environment)
+    {
+        abort();
+    }
+
+    Character** old_it = old_environment;
+    Character** new_it = new_environment.get();
+    for (; *old_it; ++old_it, ++new_it)
+    {
+        size_t const required_count = traits::tcslen(*old_it) + 1;
+        *new_it = _calloc_crt_t(Character, required_count).detach();
+        if (!*new_it)
+        {
+            abort();
+        }
+
+        _ERRCHECK(traits::tcscpy_s(*new_it, required_count, *old_it));
+    }
+
+    return new_environment.detach();
+}
+
+
+
+// If the current environment is the initial environment, this function clones
+// the current environment so that it is not the initial environment.  This
+// should be called any time that we are about to modify the current environment
+// but we do not know whether the current environment is the initial environment.
+template <typename Character>
+static void __cdecl ensure_current_environment_is_not_initial_environment_nolock() throw()
+{
+    if (get_environment(Character()) == get_initial_environment(Character()))
+    {
+        get_environment(Character()) = copy_environment(get_environment(Character()));
+    }
+}
+
+
+
+// Finds an environment variable in the specified environment.  If a variable
+// with the given name is found, its index in the environment is returned.  If
+// no such environment is found, the total number of environment variables is
+// returned, multiplied by -1.  Note that a return value of 0 may indicate
+// either that the variable was found at index 0 or there are zero variables
+// in the environment.  Be sure to check for this case.
+template <typename Character>
+static ptrdiff_t __cdecl find_in_environment_nolock(
+    Character const* const name,
+    size_t           const length
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    Character** const environment = get_environment(Character());
+
+    Character** it = nullptr;
+    for (it = environment; *it; ++it)
+    {
+        // See if the first 'length' characters match:
+        if (traits::tcsnicoll(name, *it, length) != 0)
+        {
+            continue;
+        }
+
+        // Ensure that the next character of the environment is an '=' or '\0':
+        if ((*it)[length] != '=' && (*it)[length] != '\0')
+        {
+            continue;
+        }
+
+        // Otherwise, this entry matched; return its index in the environment:
+        return static_cast<ptrdiff_t>(it - environment);
+    }
+
+    // No entry matched; return the total number of strings, multiplied by -1:
+    return -static_cast<ptrdiff_t>(it - environment);
+}
+
+
+/***
+*int __dcrt_set_variable_in_narrow_environment(option) - add/replace/remove variable in environment
+*
+*Purpose:
+*       option should be of the form "option=value".  If a string with the
+*       given option part already exists, it is replaced with the given
+*       string; otherwise the given string is added to the environment.
+*       If the string is of the form "option=", then the string is
+*       removed from the environment, if it exists.  If the string has
+*       no equals sign, error is returned.
+*
+*Entry:
+*       TCHAR **poption - pointer to option string to set in the environment list.
+*           should be of the form "option=value".
+*           This function takes ownership of this pointer in the success case.
+*       int primary - Only the primary call to _crt[w]setenv needs to
+*           create new copies or set the OS environment.
+*           1 indicates that this is the primary call.
+*
+*Exit:
+*       returns 0 if OK, -1 if fails.
+*       If *poption is non-null on exit, we did not free it, and the caller should
+*       If *poption is null on exit, we did free it, and the caller should not.
+*
+*Exceptions:
+*
+*Warnings:
+*       This code will not work if variables are removed from the environment
+*       by deleting them from environ[].  Use _putenv("option=") to remove a
+*       variable.
+*
+*       The option argument will be taken ownership of by this code and may be freed!
+*
+*******************************************************************************/
+template <typename Character>
+static int __cdecl common_set_variable_in_environment_nolock(
+    Character* const option,
+    int        const is_top_level_call
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    // Check that the option string is valid first.  Find the '=' and verify
+    // that '=' is not the first character in the string:
+    _VALIDATE_RETURN_NOEXC(option != nullptr, EINVAL, -1);
+    __crt_unique_heap_ptr<Character> owned_option(option);
+
+    Character* const equal_sign = traits::tcschr(option, '=');
+    _VALIDATE_RETURN_NOEXC(equal_sign != nullptr && equal_sign != option, EINVAL, -1);
+
+    // Internal consistency check:  The environment string should never use
+    // buffers larger than _MAX_ENV.  See also the SetEnvironmentVariable SDK
+    // function.
+    _ASSERTE(equal_sign - option                       < _MAX_ENV);
+    _ASSERTE(traits::tcsnlen(equal_sign + 1, _MAX_ENV) < _MAX_ENV);
+
+    // If the character following '=' is the terminator, we are removing the
+    // environment variable.  Otherwise, we are adding or updating the variable:
+    bool const is_removal = *(equal_sign + 1) == '\0';
+
+    // At program startup, the initial environment (__dcrt_initial_narrow_environment), which is passed
+    // to main(), is backed by the same environment arrays as the global
+    // environment used by getenv, setenv, et al.  We cannot modify thie initial
+    // environment, so we make a copy of it the first time we need to make any
+    // modifications to the global environment:
+    ensure_current_environment_is_not_initial_environment_nolock<Character>();
+
+    // If the required environment does not exist, see if the other environment
+    // exists; if it does, convert it to create the required environment.  These
+    // functions will reenter this function once for each environment variable;
+    // we use the top-level call flag to stop recursion.
+    if (!get_environment(Character()))
+    {
+        if (is_top_level_call && get_other_environment(Character()))
+        {
+            _VALIDATE_RETURN_NOEXC(traits::get_or_create_environment_nolock() != nullptr, EINVAL, -1);
+
+            // The call to get_or_create_environment() may have initialized the
+            // current environment to the same environment that is the initial
+            // environment.  Re-check and make a new copy of the environment to
+            // modify if necessary.
+            ensure_current_environment_is_not_initial_environment_nolock<Character>();
+        }
+        else
+        {
+            // If the environment doesn't exist and the requested operation is a
+            // removal, there is nothing to do (there is nothing to remove):
+            if (is_removal)
+            {
+                return 0;
+            }
+
+            // Create a new environment for each environment that does not exist.
+            // Just start each off as an empty environment:
+            if (!_environ_table.value())
+            {
+                _environ_table.value() = _calloc_crt_t(char*, 1).detach();
+            }
+
+            if (!_environ_table.value())
+            {
+                return -1;
+            }
+
+            if (!_wenviron_table.value())
+            {
+                _wenviron_table.value() = _calloc_crt_t(wchar_t*, 1).detach();
+            }
+
+            if (!_wenviron_table.value())
+            {
+                return -1;
+            }
+        }
+    }
+
+    // At this point, either [1] only one environment exists, or [2] both of the
+    // environments exist and are in-sync.  The only way they can get out of sync
+    // is if there are conversion problems.  For example, if the user sets two
+    // Unicode environment variables, FOO1 and FOO2, and the conversion of these
+    // to multibyte yields FOO? and FOO?, then these environment blocks will
+    // differ.
+    Character** const environment = get_environment(Character());
+    if (!environment)
+    {
+        _ASSERTE(("CRT logic error in setenv", 0));
+        return -1;
+    }
+
+    // Try to find the option in the environment...
+    ptrdiff_t const option_index = find_in_environment_nolock(option, equal_sign - option);
+
+    // ... if the string is already in the environment, we free up the original
+    // string, then install the new string or shrink the environment:
+    if (option_index >= 0 && environment[0])
+    {
+        _free_crt(environment[option_index]);
+
+        // If this is a removal, shrink the environment:
+        if (is_removal)
+        {
+            // Shift all of the entries down by one element:
+            size_t i = static_cast<size_t>(option_index);
+            for (; environment[i]; ++i)
+            {
+                environment[i] = environment[i + 1];
+            }
+
+            // Shrink the environment memory block.  At this point, i is the
+            // number of elements remaining in the environment.  This realloc
+            // should never fail, since we are shrinking the block, but it is
+            // best to be careful.  If it does fail, it doesn't matter.
+            Character** new_environment = _recalloc_crt_t(Character*, environment, i).detach();
+            if (new_environment)
+            {
+                get_environment(Character()) = new_environment;
+            }
+        }
+        // If this is a replacement, replace the variable:
+        else
+        {
+            environment[option_index] = owned_option.detach();
+        }
+    }
+    // Otherwise, the string is not in the environment:
+    else
+    {
+        // If this is a removal, it is a no-op:  the variable does not exist.
+        if (is_removal)
+        {
+            return 0;
+        }
+        // Otherwise, we need to append the string to the environment table, and
+        // we must grow the table to do this:
+        else
+        {
+            size_t const environment_count = static_cast<size_t>(-option_index);
+            if (environment_count + 2 < environment_count)
+            {
+                return -1;
+            }
+
+            if (environment_count + 2 >= SIZE_MAX / sizeof(Character*))
+            {
+                return -1;
+            }
+
+            Character** const new_environment = _recalloc_crt_t(Character*, environment, environment_count + 2).detach();
+            if (!new_environment)
+            {
+                return -1;
+            }
+
+            new_environment[environment_count]     = owned_option.detach();
+            new_environment[environment_count + 1] = nullptr;
+
+            get_environment(Character()) = new_environment;
+        }
+    }
+
+    // Update the operating system environment.  Do not give an error if this
+    // fails since the failure will not affect the user code unless it is making
+    // direct calls to the operating system.  We only need to do this for one of
+    // the environments; the operating system synchronizes with the other
+    // environment automatically.
+    if (is_top_level_call)
+    {
+        size_t const count = traits::tcslen(option) + 2;
+        __crt_unique_heap_ptr<Character> const buffer(_calloc_crt_t(Character, count));
+        if (!buffer)
+        {
+            return 0;
+        }
+
+        Character* const name = buffer.get();
+        _ERRCHECK(traits::tcscpy_s(name, count, option));
+
+        Character* const value = name + (equal_sign - option) + 1;
+        *(value - 1) = '\0'; // Overwrite the '=' with a null terminator
+
+        if (traits::set_environment_variable(name, is_removal ? nullptr : value) == 0)
+        {
+            errno = EILSEQ;
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+extern "C" int __cdecl __dcrt_set_variable_in_narrow_environment_nolock(
+    char* const option,
+    int   const is_top_level_call
+    )
+{
+    return common_set_variable_in_environment_nolock(option, is_top_level_call);
+}
+
+extern "C" int __cdecl __dcrt_set_variable_in_wide_environment_nolock(
+    wchar_t* const option,
+    int      const is_top_level_call
+    )
+{
+    return common_set_variable_in_environment_nolock(option, is_top_level_call);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/cenvarg.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/cenvarg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0276886c37d60586d80c14578c063b838548c05a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/cenvarg.cpp	
@@ -0,0 +1,369 @@
+//
+// cenvarg.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the _cenvarg() and _capture_argv functions, which transform argument
+// vectors and environments for use by the _exec() and _spawn() functions.
+//
+#include <corecrt_internal.h>
+#include <errno.h>
+#include <corecrt_internal_traits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036
+
+
+// Converts a main()-style argv arguments vector into a command line.  On success,
+// returns a pointer to the newly constructed arguments block; the caller is
+// responsible for freeing the string.  On failure, returns null and sets errno.
+template <typename Character>
+static errno_t __cdecl construct_command_line(
+    Character const* const* const argv,
+    Character**             const command_line_result
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    *command_line_result = nullptr;
+
+    // Compute the number of bytes required to store the arguments in argv in a
+    // command line string (including spaces between arguments and a terminator):
+    size_t const command_line_count = [&]
+    {
+        size_t n = 0;
+        for (Character const* const* it = argv; *it; n += traits::tcslen(*it++) + 1) { }
+
+        // If there were no arguments, return 1 so that we can return an empty
+        // string:
+        return __max(n, 1);
+    }();
+
+    __crt_unique_heap_ptr<Character> command_line(_calloc_crt_t(Character, command_line_count));
+    if (!command_line)
+    {
+        __acrt_errno_map_os_error(ERROR_NOT_ENOUGH_MEMORY);
+        return errno = ENOMEM;
+    }
+
+    Character const* const* source_it = argv;
+    Character*              result_it = command_line.get();
+
+    // If there are no arguments, just return the empty string:
+    if (*source_it == '\0')
+    {
+        *command_line_result = command_line.detach();
+        return 0;
+    }
+
+    // Copy the arguments, separated by spaces:
+    while (*source_it != '\0')
+    {
+        _ERRCHECK(traits::tcscpy_s(result_it, command_line_count - (result_it - command_line.get()), *source_it));
+        result_it += traits::tcslen(*source_it);
+        *result_it++ = ' ';
+        ++source_it;
+    }
+
+    // Replace the last space with a terminator:
+    result_it[-1] = '\0';
+
+    *command_line_result = command_line.detach();
+    return 0;
+}
+
+
+
+// Converts a main()-style envp environment vector into an environment block in
+// the form required by the CreateProcess API.  On success, returns a pointer to
+// the newly constructed environment block; the caller is responsible for freeing
+// the block.  On failure, returns null and sets errno.
+template <typename Character>
+static errno_t __cdecl construct_environment_block(
+    _In_opt_z_ Character const* const*      const   envp,
+    _Outptr_result_maybenull_ Character**   const   environment_block_result
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    *environment_block_result = nullptr;
+
+    // If envp is null, we will use the current environment of this process as
+    // the environment for the new process.  No action is required in this case
+    // because simply passing a null environment pointer to CreateProcess will
+    // do the right thing.
+    if (envp == nullptr)
+        return 0;
+
+    // Get the value of the SystemRoot environment variable, if it is defined,
+    // and compute the number of characters required to store it in the
+    // envrionment block:
+    Character const system_root_name[] = { 'S', 'y', 's', 't', 'e', 'm', 'R', 'o', 'o', 't', '\0' };
+
+    __crt_unique_heap_ptr<Character> system_root_value;
+    if (_ERRCHECK_EINVAL(traits::tdupenv_s_crt(system_root_value.get_address_of(), nullptr, system_root_name)) != 0)
+        return errno;
+
+    size_t const system_root_value_count = system_root_value
+        ? traits::tcslen(system_root_value.get()) + 1
+        : 0;
+
+    size_t const system_root_count = _countof(system_root_name) + system_root_value_count;
+
+    // Compute the number of characters required to hold the environment
+    // strings provided by the user:
+    size_t const envp_count = [&]
+    {
+        size_t n = 2; // Account for double null terminator
+        for (auto it = envp; *it != nullptr; n += traits::tcslen(*it++) + 1) { }
+        return n;
+    }();
+
+    // Get the current environment from the OS so that we can get the current
+    // directory strings (those starting with '=') and append them to the user-
+    // provided environment.
+    __crt_unique_heap_ptr<Character> const os_environment(traits::get_environment_from_os());
+    if (!os_environment)
+        return EINVAL;
+
+    // Find the first shell environment variable:
+    Character* const first_cwd = [&]
+    {
+        Character* it = os_environment.get();
+        while (*it != '=')
+            it += traits::tcslen(it) + 1;
+        return it;
+    }();
+
+    // Find the end of the shell environment variables (assume they are contiguous):
+    Character* const last_cwd = [&]
+    {
+        Character* it = first_cwd;
+        while (it[0] == '=' && it[1] != '\0' && it[2] == ':' && it[3] == '=')
+            it += 4 + traits::tcslen(it + 4) + 1;
+        return it;
+    }();
+
+    size_t const cwd_count = last_cwd - first_cwd;
+
+
+    // Check to see if the SystemRoot is already defined in the environment:
+    bool const system_root_defined_in_environment = [&]
+    {
+        for (auto it = envp; *it != nullptr; ++it)
+        {
+            if (traits::tcsnicmp(*it, system_root_name, traits::tcslen(system_root_name)) == 0)
+                return true;
+        }
+
+        return false;
+    }();
+
+    // Allocate storage for the new environment:
+    size_t const environment_block_count = system_root_defined_in_environment
+        ? envp_count + cwd_count
+        : envp_count + cwd_count + system_root_count;
+    
+    __crt_unique_heap_ptr<Character> environment_block(_calloc_crt_t(Character, environment_block_count));
+    if (!environment_block)
+    {
+        __acrt_errno_map_os_error(ERROR_OUTOFMEMORY);
+        return errno = ENOMEM;
+    }
+
+    // Build the environment block by concatenating the environment strings with
+    // null characters between them, and with a double null terminator.
+    Character* result_it            = environment_block.get();
+    size_t     remaining_characters = environment_block_count;
+
+    // Copy the cwd strings into the new environment:
+    if (cwd_count != 0)
+    {
+        memcpy(result_it, first_cwd, cwd_count * sizeof(Character));
+        result_it            += cwd_count;
+        remaining_characters -= cwd_count;
+    }
+
+    // Copy the environment strings from envp into the new environment:
+    for (auto it = envp; *it != nullptr; ++it)
+    {
+        _ERRCHECK(traits::tcscpy_s(result_it, remaining_characters, *it));
+        
+        size_t const count_copied = traits::tcslen(*it) + 1;
+        result_it            += count_copied;
+        remaining_characters -= count_copied;
+    }
+
+    // Copy the SystemRoot into the new environment:
+    if (!system_root_defined_in_environment)
+    {
+        static Character const equal_sign[] = { '=', '\0' };
+
+        _ERRCHECK(traits::tcscpy_s(result_it, system_root_count, system_root_name));
+        _ERRCHECK(traits::tcscat_s(result_it, system_root_count, equal_sign));
+        if (system_root_value)
+        {
+            _ERRCHECK(traits::tcscat_s(result_it, system_root_count, system_root_value.get()));
+        }
+        result_it += system_root_count;
+    }
+
+    // Null-terminate the environment block and return it.  If the environment
+    // block is empty, it requires two null terminators:
+    if (result_it == environment_block.get())
+        *result_it++ = '\0';
+
+    *result_it = '\0';
+
+    *environment_block_result = environment_block.detach();
+    return 0;
+}
+
+
+
+// Converts a main()-style argv arguments vector and envp environment vector into
+// a command line and an environment block, for use in the _exec and _spawn
+// functions.  On success, returns 0 and sets the two result argumetns to point
+// to the newly created command line and environment block.  The caller is
+// responsible for freeing these blocks.  On failure, returns -1 and sets errno.
+template <typename Character>
+_Success_(return == 0)
+_Ret_range_(-1, 0)
+static int __cdecl common_pack_argv_and_envp(
+    _In_z_                    Character const* const* const argv,
+    _In_opt_z_                Character const* const* const envp,
+    _Outptr_result_maybenull_ Character**             const command_line_result,
+    _Outptr_result_maybenull_ Character**             const environment_block_result
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    __crt_unique_heap_ptr<Character> command_line;
+    if (construct_command_line(argv, command_line.get_address_of()) != 0)
+        return -1;
+    
+    __crt_unique_heap_ptr<Character> environment_block;
+    if (construct_environment_block(envp, environment_block.get_address_of()) != 0)
+        return -1;
+
+    *command_line_result      = command_line.detach();
+    *environment_block_result = environment_block.detach();
+    return 0;
+}
+
+extern "C" int __cdecl __acrt_pack_narrow_command_line_and_environment(
+    char const* const* const argv,
+    char const* const* const envp,
+    char**             const command_line_result,
+    char**             const environment_block_result
+    )
+{
+    return common_pack_argv_and_envp(argv, envp, command_line_result, environment_block_result);
+}
+
+extern "C" int __cdecl __acrt_pack_wide_command_line_and_environment(
+    wchar_t const* const* const argv,
+    wchar_t const* const* const envp,
+    wchar_t**             const command_line_result,
+    wchar_t**             const environment_block_result
+    )
+{
+    return common_pack_argv_and_envp(argv, envp, command_line_result, environment_block_result);
+}
+
+
+
+// Creates an argv array for the _exec and _spawn functions.  This function walks
+// the provided varargs list, copying the char* or wchar_t* pointers into an
+// array.  The caller_array is used first; if it is too small to fit all of the
+// arguments, an array is dynamically allocated.  A pointer to the argv array is
+// returned to the caller.  If the returned pointer is not 'caller_array', the
+// caller must free the array.  On failure, nullptr is returned and errno is set.
+template <typename Character>
+_Success_(return != 0)
+static Character** __cdecl common_capture_argv(
+    _In_ va_list*                                   const   arglist,
+    _In_z_ Character const*                         const   first_argument,
+    _When_(return == caller_array, _Post_z_)
+    _Out_writes_(caller_array_count) Character**    const   caller_array,
+    _In_ size_t                                     const   caller_array_count
+    ) throw()
+{
+    Character** argv       = caller_array;
+    size_t      argv_count = caller_array_count;
+
+    __crt_unique_heap_ptr<Character*> local_array;
+
+    size_t i = 0;
+    Character* next_argument = const_cast<Character*>(first_argument);
+    for (;;)
+    {
+        if (i >= argv_count)
+        {
+            _VALIDATE_RETURN_NOEXC(SIZE_MAX / 2 > argv_count, ENOMEM, nullptr);
+
+            // If we have run out of room in the caller-provided array, allocate
+            // an array on the heap and copy the contents of the caller-provided
+            // array:
+            if (argv == caller_array)
+            {
+                local_array = _calloc_crt_t(Character*, argv_count * 2);
+                _VALIDATE_RETURN_NOEXC(local_array.get() != nullptr, ENOMEM, nullptr);
+
+                _ERRCHECK(memcpy_s(local_array.get(), argv_count * 2, caller_array, caller_array_count));
+
+                argv = local_array.get();
+            }
+            // Otherwise, we have run out of room in a dynamically allocated
+            // array.  We need to reallocate:
+            else
+            {
+                __crt_unique_heap_ptr<Character*> new_array(_recalloc_crt_t(Character*, local_array.get(), argv_count * 2));
+                _VALIDATE_RETURN_NOEXC(new_array.get() != nullptr, ENOMEM, nullptr);
+
+                local_array.detach();
+                local_array.attach(new_array.detach());
+
+                argv = local_array.get();
+            }
+
+            argv_count *= 2;
+        }
+
+        argv[i++] = next_argument;
+        if (!next_argument)
+            break;
+
+#pragma warning(suppress:__WARNING_INCORRECT_ANNOTATION) // 26007 Possibly incorrect single element annotation on arglist
+        next_argument = va_arg(*arglist, Character*);
+    }
+
+    // At this point, we have succeeded; either local_array is null, or argv is
+    // local_array.  In either case, we detach so that we can transfer ownership
+    // to the caller:
+    local_array.detach();
+    return argv;
+}
+
+extern "C" char** __acrt_capture_narrow_argv(
+    va_list*    const arglist,
+    char const* const first_argument,
+    char**      const caller_array,
+    size_t      const caller_array_count
+    )
+{
+    return common_capture_argv(arglist, first_argument, caller_array, caller_array_count);
+}
+
+extern "C" wchar_t** __acrt_capture_wide_argv(
+    va_list*       const arglist,
+    wchar_t const* const first_argument,
+    wchar_t**      const caller_array,
+    size_t         const caller_array_count
+    )
+{
+    return common_capture_argv(arglist, first_argument, caller_array, caller_array_count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/getproc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/getproc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4be47420d2825021da58f92b76940d1cb6b06a9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/getproc.cpp	
@@ -0,0 +1,67 @@
+/***
+*getproc.c - Get the address of a procedure in a DLL.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _getdllprocadd() - gets a procedure address by name or
+*       ordinal
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+
+#define _CRT_ENABLE_OBSOLETE_LOADLIBRARY_FUNCTIONS
+
+#include <process.h>
+
+/***
+*int (*)() _getdllprocaddr(handle, name, ordinal) - Get the address of a
+*       DLL procedure specified by name or ordinal
+*
+*Purpose:
+*
+*Entry:
+*       int handle - a DLL handle from _loaddll
+*       char * name - Name of the procedure, or nullptr to get by ordinal
+*       int ordinal - Ordinal of the procedure, or -1 to get by name
+*
+*
+*Exit:
+*       returns a pointer to the procedure if found
+*       returns nullptr if not found
+*
+*Exceptions:
+*
+*******************************************************************************/
+typedef int (__cdecl* proc_address_type)();
+
+extern "C" 
+DECLSPEC_GUARD_SUPPRESS
+proc_address_type __cdecl _getdllprocaddr(
+    intptr_t const module_handle_value,
+    char*    const procedure_name,
+    intptr_t const ordinal
+    )
+{
+    HMODULE const module_handle = reinterpret_cast<HMODULE>(module_handle_value);
+    if (procedure_name == nullptr)
+    {
+        if (ordinal <= 65535)
+        {
+            char* const ordinal_as_string = reinterpret_cast<char*>(ordinal);
+            return reinterpret_cast<proc_address_type>(
+                GetProcAddress(module_handle, ordinal_as_string));
+        }
+    }
+    else
+    {
+        if (ordinal == static_cast<intptr_t>(-1))
+        {
+            return reinterpret_cast<proc_address_type>(
+                GetProcAddress(module_handle, procedure_name));
+        }
+    }
+
+    return nullptr;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/loaddll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/loaddll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8739f989442375919d574731547368151ff381e2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/loaddll.cpp	
@@ -0,0 +1,65 @@
+/***
+*loaddll.c - load or free a Dynamic Link Library
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _loaddll() and _unloaddll() - load and unload DLL
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#define _CRT_ENABLE_OBSOLETE_LOADLIBRARY_FUNCTIONS
+
+#include <process.h>
+
+/***
+*int _loaddll(filename) - Load a dll
+*
+*Purpose:
+*       Load a DLL into memory
+*
+*Entry:
+*       char *filename - file to load
+*
+*Exit:
+*       returns a unique DLL (module) handle if succeeds
+*       returns 0 if fails
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" intptr_t __cdecl _loaddll(char* szName)
+{
+    return reinterpret_cast<intptr_t>(__acrt_LoadLibraryExA(szName, nullptr, 0));
+}
+
+/***
+*int _unloaddll(handle) - Unload a dll
+*
+*Purpose:
+*       Unloads a DLL. The resources of the DLL will be freed if no other
+*       processes are using it.
+*
+*Entry:
+*       int handle - handle from _loaddll
+*
+*Exit:
+*       returns 0 if succeeds
+*       returns DOS error if fails
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _unloaddll(intptr_t hMod)
+{
+        if (!FreeLibrary(reinterpret_cast<HMODULE>(hMod))) {
+            return ((int)GetLastError());
+        }
+        return (0);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnl.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f25f274f86d20f7e03856d667189e90c35143498
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnl.cpp	
@@ -0,0 +1,143 @@
+//
+// spawnl.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the -l and -le flavors of the _exec() and _spawn() functions.  See
+// the comments in spawnv.cpp for details of the various flavors of these
+// functions.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <stddef.h>
+#include <process.h>
+#include <stdarg.h>
+
+
+
+template <typename Character>
+static intptr_t __cdecl common_spawnl(
+    bool             const pass_environment,
+    int              const mode,
+    Character const* const file_name,
+    Character const* const arguments,
+    va_list                varargs
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(file_name    != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(file_name[0] != '\0',    EINVAL, -1);
+    _VALIDATE_RETURN(arguments    != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments[0] != '\0',    EINVAL, -1);
+
+    Character* arguments_buffer[64];
+    Character** const captured_arguments = traits::capture_argv(
+        &varargs,
+        arguments,
+        &arguments_buffer[0],
+        64);
+
+    _VALIDATE_RETURN_NOEXC(captured_arguments != nullptr, ENOMEM, -1);
+
+    __crt_unique_heap_ptr<Character*> const captured_arguments_cleanup(
+        captured_arguments == arguments_buffer ? nullptr : captured_arguments);
+
+    Character const* const* const environment = pass_environment
+        ? va_arg(varargs, Character const* const*)
+        : nullptr;
+
+    return traits::tspawnve(mode, file_name, captured_arguments, environment);
+}
+
+
+
+extern "C" intptr_t __cdecl _execl(
+    char const* const file_name,
+    char const* const arguments,
+    ...
+    )
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(false, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t __cdecl _execle(
+    char const* const file_name,
+    char const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(true, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t __cdecl _spawnl(
+    int         const mode,
+    char const* const file_name,
+    char const* const arguments,
+    ...
+    )
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(false, mode, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t __cdecl _spawnle(
+    int         const mode,
+    char const* const file_name,
+    char const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(true, mode, file_name, arguments, varargs);
+}
+
+
+
+extern "C" intptr_t __cdecl _wexecl(
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...
+    )
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(false, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t __cdecl _wexecle(
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(true, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t __cdecl _wspawnl(
+    int            const mode,
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...
+    )
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(false, mode, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t __cdecl _wspawnle(
+    int            const mode,
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnl(true, mode, file_name, arguments, varargs);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnlp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnlp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b54ec66110cda4f22c94b090829ee2b09b4e078e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnlp.cpp	
@@ -0,0 +1,140 @@
+//
+// spawnlp.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the -lp and -lpe flavors of the _exec() and _spawn() functions.  See
+// the comments in spawnv.cpp for details of the various flavors of these
+// functions.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <stddef.h>
+#include <process.h>
+#include <stdarg.h>
+
+
+
+template <typename Character>
+static intptr_t __cdecl common_spawnlp(
+    bool             const pass_environment,
+    int              const mode,
+    Character const* const file_name,
+    Character const* const arguments,
+    va_list                varargs
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(file_name    != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(file_name[0] != '\0',    EINVAL, -1);
+    _VALIDATE_RETURN(arguments    != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments[0] != '\0',    EINVAL, -1);
+
+    Character* arguments_buffer[64];
+    Character** const captured_arguments = traits::capture_argv(
+        &varargs,
+        arguments,
+        &arguments_buffer[0],
+        64);
+
+    _VALIDATE_RETURN_NOEXC(captured_arguments != nullptr, ENOMEM, -1);
+
+    __crt_unique_heap_ptr<Character*> const captured_arguments_cleanup(
+        captured_arguments == arguments_buffer ? nullptr : captured_arguments);
+
+    Character const* const* const environment = pass_environment
+        ? va_arg(varargs, Character const* const*)
+        : nullptr;
+
+    return traits::tspawnvpe(mode, file_name, captured_arguments, environment);
+}
+
+
+
+extern "C" intptr_t _execlp(
+    char const* const file_name,
+    char const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(false, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t _execlpe(
+    char const* const file_name,
+    char const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(true, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t _spawnlp(
+    int         const mode,
+    char const* const file_name,
+    char const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(false, mode, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t _spawnlpe(
+    int         const mode,
+    char const* const file_name,
+    char const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(true, mode, file_name, arguments, varargs);
+}
+   
+
+
+extern "C" intptr_t _wexeclp(
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(false, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t _wexeclpe(
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(true, _P_OVERLAY, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t _wspawnlp(
+    int            const mode,
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(false, mode, file_name, arguments, varargs);
+}
+
+extern "C" intptr_t _wspawnlpe(
+    int            const mode,
+    wchar_t const* const file_name,
+    wchar_t const* const arguments,
+    ...)
+{
+    va_list varargs;
+    va_start(varargs, arguments);
+    return common_spawnlp(true, mode, file_name, arguments, varargs);
+}
+    
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a50f1e23bcfe139bb9312c4bbf9cea5af58c50a7
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnv.cpp	
@@ -0,0 +1,451 @@
+//
+// spawnv.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the -v and -ve flavors of the _exec() and _spawn() functions.
+//
+// There are many varieties of the _exec() and _spawn() functions.  A high level
+// summary of the behavioral differences is as follows:
+//
+// All of these functions execute a new process.  The _spawn() functions all take
+// a 'mode' parameter, which specifies the way in which the process is started.
+// The 'mode' must be one of the _P_-prefixed modes from <process.h>.  The _exec()
+// family of functions execute a new process, then call _exit() to terminate the
+// calling process.  Each _exit() function is equivalent to the corresponding
+// _spawn() function with the _P_OVERLAY mode.
+//
+// There are eight variants each of _exec() and _spawn(), suffixed with -l, -le,
+// -lp, -lpe, -v, -ve, -vp, and -vpe.
+//
+// If a function has 'e' in its suffix, it accepts an environment with which to
+// create the new process.  If a function does not have 'e' in its suffix, it
+// does not accept an environment and instead uses the environment of the calling
+// process.  A call to an 'e' function with a null environment argument has the
+// same effect as calling the non-'e'-suffixed equivalent.
+//
+// Each _exec() or _spawn() function has either an 'l' or 'v' suffix.  These have
+// equivalent functionality; they differ only in how they accept their arguments.
+// The 'l'-suffixed functions accept the command-line arguments and the environment
+// as varargs.  There must be at least one command line argument (conventionally
+// the name of the program to be executed).  If the function accepts an environment
+// (if it is 'e'-suffixed), then there must be a null pointer between the last
+// argument and the first environment variable.  The arguments are terminated by a
+// null pointer.
+//
+// The 'v'-suffixed functions accept a pair of pointers:  one to the argv vector
+// and one to the envp vector.  Each is an array of pointers terminated by a null
+// pointer, similar to how arguments and the environment are passed to main().
+//
+// Finally, if a function has a 'p' in its suffix, and if the provided executable
+// file name is just a file name (and does not contain any path component), the
+// %PATH% is searched for an executable with the given name.  If a function does
+// not have a 'p' suffix, then the environment is not searched; the executable
+// must be found simply by passing its name to CreateProcess.
+//
+// All functions return -1 and set errno on failure.  On success, the _exec()
+// functions do not return.  On success, the _spawn() functions return different
+// things, depending on the provided mode.  See the CreateProcess invocation
+// logic in this file for details.
+//
+// Note that the only supported modes are wait and overlay.
+//
+// These functions may set errno to one of the following values:
+// * E2BIG:    Failed in argument or environment processing because the argument
+//             list or environment is too large.
+// * EACCESS:  Locking or sharing violation on a file
+// * EMFILE:   Too many files open
+// * ENOENT:   Failed to find the program (no such file or directory)
+// * ENOEXEC:  Failed in a call to exec() due to a bad executable format
+// * ENOMEM:   Failed to allocate memory required for the spawn operation
+// * EINVAL:   Invalid mode argumnt or process state for spawn (note that most
+//             invalid arguments cause the invalid parameter handler to be
+//             invoked).
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_traits.h>
+#include <errno.h>
+#include <io.h>
+#include <mbstring.h>
+#include <process.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+// Accumulates the inheritable file handles into *data, in the structure expected
+// by the spawnee (see the lowio initialization code for the logic that decodes
+// this data structure).  On success, *data and *size have the handle data array
+// and the size of the handle data, and true is returned.  The caller must free
+// *data.  On failure, false is returned and errno is set.
+static bool accumulate_inheritable_handles(
+    BYTE**  const data,
+    size_t* const size,
+    bool    const include_std_handles
+    ) throw()
+{
+    return __acrt_lock_and_call(__acrt_lowio_index_lock, [&]() -> bool
+    {
+        *data = nullptr;
+        *size = 0;
+
+        // Count the number of handles to be inherited:
+        size_t handle_count = 0;
+        for (handle_count = _nhandle; handle_count != 0 && _osfile(handle_count - 1) != 0; --handle_count)
+        {
+        }
+
+        size_t const max_handle_count = (USHRT_MAX - sizeof(int)) / (sizeof(char) + sizeof(intptr_t));
+        _VALIDATE_RETURN_NOEXC(handle_count < max_handle_count, ENOMEM, false);
+
+        size_t const handle_data_header_size  = sizeof(int);
+        size_t const handle_data_element_size = sizeof(char) + sizeof(intptr_t);
+
+        unsigned short const handle_data_size = static_cast<unsigned short>(
+            handle_data_header_size +
+            handle_count * handle_data_element_size);
+
+        __crt_unique_heap_ptr<BYTE> handle_data(_calloc_crt_t(BYTE, handle_data_size));
+        _VALIDATE_RETURN_NOEXC(handle_data.get() != nullptr, ENOMEM, false);
+
+        // Set the handle count in the data:
+        *reinterpret_cast<int*>(handle_data.get()) = static_cast<int>(handle_count);
+
+        auto const first_flags  = reinterpret_cast<char*>(handle_data.get() + sizeof(int));
+        auto const first_handle = reinterpret_cast<intptr_t UNALIGNED*>(first_flags + (handle_count * sizeof(char)));
+
+        // Copy the handle data:
+        auto flags_it  = first_flags;
+        auto handle_it = first_handle;
+        for (size_t i = 0; i != handle_count; ++i, ++flags_it, ++handle_it)
+        {
+            __crt_lowio_handle_data* const pio = _pioinfo(i);
+            if ((pio->osfile & FNOINHERIT) == 0)
+            {
+                *flags_it  = pio->osfile;
+                *handle_it = pio->osfhnd;
+            }
+            else
+            {
+                *flags_it  = 0;
+                *handle_it = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+            }
+        }
+
+        // Exclude the first three handles (stdin, stdout, stderr) if asked:
+        if (!include_std_handles)
+        {
+            flags_it = first_flags;
+            handle_it = first_handle;
+            for (size_t i = 0; i != __min(handle_count, 3); ++i, ++flags_it, ++handle_it)
+            {
+                *flags_it = 0;
+                *handle_it = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+            }
+        }
+
+        *data = handle_data.detach();
+        *size = handle_data_size;
+        return true;
+    });
+}
+
+
+
+static bool __cdecl should_create_unicode_environment(char)    throw() { return false; }
+static bool __cdecl should_create_unicode_environment(wchar_t) throw() { return true;  }
+
+
+
+// Spawns a child process.  The mode must be one of the _P-modes from <process.h>.
+// The return value depends on the mode:
+// * _P_OVERLAY:  On success, calls _exit() and does not return. Returns -1 on failure.
+// * _P_WAIT:     Returns (termination_code << 8 + result_code)
+// * _P_DETACH:   Returns 0 on success; -1 on failure
+// * Others:      Returns a handle to the process. The caller must close the handle.
+template <typename Character>
+static intptr_t __cdecl execute_command(
+    int                     const mode,
+    Character const*        const file_name,
+    Character const* const* const arguments,
+    Character const* const* const environment
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(file_name != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments != nullptr, EINVAL, -1);
+
+    _VALIDATE_CLEAR_OSSERR_RETURN(mode >= 0 && mode <= _P_DETACH, EINVAL, -1);
+
+    __crt_unique_heap_ptr<Character> command_line;
+    __crt_unique_heap_ptr<Character> environment_block;
+    if (traits::pack_command_line_and_environment(
+            arguments,
+            environment,
+            command_line.get_address_of(),
+            environment_block.get_address_of()
+        ) == -1)
+    {
+        return -1;
+    }
+
+    __crt_unique_heap_ptr<BYTE> handle_data;
+    size_t                      handle_data_size;
+    if (!accumulate_inheritable_handles(handle_data.get_address_of(), &handle_data_size, mode != _P_DETACH))
+        return -1;
+
+    DWORD creation_flags = 0;
+    if (mode == _P_DETACH)
+        creation_flags |= DETACHED_PROCESS;
+
+    if (should_create_unicode_environment(Character()))
+        creation_flags |= CREATE_UNICODE_ENVIRONMENT;
+
+    _doserrno = 0;
+
+    STARTUPINFOW startup_info = { };
+    startup_info.cb          = sizeof(startup_info);
+    startup_info.cbReserved2 = static_cast<WORD>(handle_data_size);
+    startup_info.lpReserved2 = handle_data.get();
+
+    PROCESS_INFORMATION process_info;
+    BOOL const create_process_status = traits::create_process(
+        const_cast<Character*>(file_name),
+        command_line.get(),
+        nullptr,
+        nullptr,
+        TRUE,
+        creation_flags,
+        environment_block.get(),
+        nullptr,
+        &startup_info,
+        &process_info);
+
+    __crt_unique_handle process_handle(process_info.hProcess);
+    __crt_unique_handle thread_handle(process_info.hThread);
+
+    if (!create_process_status)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    if (mode == _P_OVERLAY)
+    {
+        // Destroy ourselves:
+        _exit(0);
+    }
+    else if (mode == _P_WAIT)
+    {
+        WaitForSingleObject(process_info.hProcess, static_cast<DWORD>(-1));
+
+        // Return the termination code and exit code.  Note that we return
+        // the full exit code.
+        DWORD exit_code;
+        if (0 != GetExitCodeProcess(process_info.hProcess, &exit_code))
+        {
+            return static_cast<int>(exit_code);
+        }
+        else
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            return -1;
+        }
+    }
+    else if (mode == _P_DETACH)
+    {
+        /* like totally detached asynchronous spawn, dude,
+            close process handle, return 0 for success */
+        return 0;
+    }
+    else
+    {
+        // Asynchronous spawn:  return process handle:
+        return reinterpret_cast<intptr_t>(process_handle.detach());
+    }
+}
+
+
+
+template <typename Character>
+static intptr_t __cdecl common_spawnv(
+    int                     const mode,
+    Character const*        const file_name,
+    Character const* const* const arguments,
+    Character const* const* const environment
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(file_name       != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(file_name[0]    != '\0',    EINVAL, -1);
+    _VALIDATE_RETURN(arguments       != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments[0]    != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments[0][0] != '\0',    EINVAL, -1);
+
+    Character const* const final_backslash = traits::tcsrchr(file_name, '\\');
+    Character const* const final_slash     = traits::tcsrchr(file_name, '/');
+
+    Character const* mutated_file_name = file_name;
+    Character const* end_of_directory  = final_backslash;
+    if (!final_slash)
+    {
+        if (!final_backslash)
+        {
+            Character const* const final_colon = traits::tcsrchr(file_name, ':');
+            if (final_colon)
+            {
+                end_of_directory = final_colon;
+            }
+            else
+            {
+                // The path is a file name only.  We force it to be a relative
+                // path name.
+                size_t const file_name_size = traits::tcslen(file_name) + 3;
+                __crt_unique_heap_ptr<Character> buffer(_calloc_crt_t(Character, file_name_size));
+                if (!buffer)
+                    return -1;
+
+                static Character const dot_slash[] = { '.', '\\', '\0' };
+                _ERRCHECK(traits::tcscpy_s(buffer.get(), file_name_size, dot_slash));
+                _ERRCHECK(traits::tcscat_s(buffer.get(), file_name_size, file_name));
+
+                mutated_file_name = buffer.detach();
+                end_of_directory  = mutated_file_name + 2; // Adjust for ".\"
+            }
+        }
+    }
+    else if (!final_backslash || final_slash > final_backslash)
+    {
+        end_of_directory = final_slash;
+    }
+
+    // If we allocated a file name above, make sure we clean it up:
+    __crt_unique_heap_ptr<Character const> const mutated_file_name_cleanup(file_name == mutated_file_name
+        ? nullptr
+        : mutated_file_name);
+
+    if (traits::tcsrchr(end_of_directory, '.'))
+    {
+        // If an extension was provided, just invoke the path:
+        if (traits::taccess_s(mutated_file_name, 0) == 0)
+        {
+            return execute_command(mode, mutated_file_name, arguments, environment);
+        }
+    }
+    else
+    {
+        // If no extension was provided, try known executable extensions:
+        size_t const buffer_size = traits::tcslen(mutated_file_name) + 5;
+        __crt_unique_heap_ptr<Character> const buffer(_calloc_crt_t(Character, buffer_size));
+        if (!buffer)
+            return -1;
+
+        _ERRCHECK(traits::tcscpy_s(buffer.get(), buffer_size, mutated_file_name));
+        Character* extension_buffer = buffer.get() + buffer_size - 5;
+
+        typedef Character const extension_type[5];
+        static extension_type const extensions[4] =
+        {
+            { '.', 'c', 'o', 'm', '\0' },
+            { '.', 'e', 'x', 'e', '\0' },
+            { '.', 'b', 'a', 't', '\0' },
+            { '.', 'c', 'm', 'd', '\0' }
+        };
+
+        errno_t const saved_errno = errno;
+
+        extension_type const* const first_extension = extensions;
+        extension_type const* const last_extension  = first_extension + _countof(extensions);
+        for (auto it = first_extension; it != last_extension; ++it)
+        {
+            _ERRCHECK(traits::tcscpy_s(extension_buffer, 5, *it));
+
+            if (traits::taccess_s(buffer.get(), 0) == 0)
+            {
+                errno = saved_errno;
+                return execute_command(mode, buffer.get(), arguments, environment);
+            }
+        }
+    }
+
+    return -1;
+}
+
+
+
+extern "C" intptr_t __cdecl _execv(
+    char const*        const file_name,
+    char const* const* const arguments
+    )
+{
+    return common_spawnv(_P_OVERLAY, file_name, arguments, static_cast<char const* const*>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _execve(
+    char const*        const file_name,
+    char const* const* const arguments,
+    char const* const* const environment
+    )
+{
+    return common_spawnv(_P_OVERLAY, file_name, arguments, environment);
+}
+
+extern "C" intptr_t __cdecl _spawnv(
+    int                const mode,
+    char const*        const file_name,
+    char const* const* const arguments
+    )
+{
+    return common_spawnv(mode, file_name, arguments, static_cast<char const* const*>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _spawnve(
+    int                const mode,
+    char const*        const file_name,
+    char const* const* const arguments,
+    char const* const* const environment
+    )
+{
+    return common_spawnv(mode, file_name, arguments, environment);
+}
+
+
+
+extern "C" intptr_t __cdecl _wexecv(
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments
+    )
+{
+    return common_spawnv(_P_OVERLAY, file_name, arguments, static_cast<wchar_t const* const*>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _wexecve(
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments,
+    wchar_t const* const* const environment
+    )
+{
+    return common_spawnv(_P_OVERLAY, file_name, arguments, environment);
+}
+
+extern "C" intptr_t __cdecl _wspawnv(
+    int                   const mode,
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments
+    )
+{
+    return common_spawnv(mode, file_name, arguments, static_cast<wchar_t const* const*>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _wspawnve(
+    int                   const mode,
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments,
+    wchar_t const* const* const environment
+    )
+{
+    return common_spawnv(mode, file_name, arguments, environment);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnvp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnvp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52a6b4785528be7fd69b65decb8f4da0bb46d4cc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/spawnvp.cpp	
@@ -0,0 +1,212 @@
+//
+// spawnvp.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the -vp and -vpe flavors of the _exec() and _spawn() functions.  See
+// the comments in spawnv.cpp for details of the various flavors of these
+// functions.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include <process.h>
+#include <mbstring.h>
+
+
+
+template <typename Character>
+static intptr_t __cdecl common_spawnvp(
+    int                     const mode,
+    Character const*        const file_name,
+    Character const* const* const arguments,
+    Character const* const* const environment
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(file_name       != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(file_name[0]    != '\0',    EINVAL, -1);
+    _VALIDATE_RETURN(arguments       != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments[0]    != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(arguments[0][0] != '\0',    EINVAL, -1);
+
+    __crt_errno_guard const guard_errno;
+
+    // Attempt to perform the spawn with the given file name.  If this succeeds
+    // and is a spawn operation (mode != _P_OVERLAY), then it returns a status
+    // code other than -1 and we can just return it.  If this succeds and is an
+    // exec operation (mode == _P_OVERLAY), then this call does not return.
+    intptr_t const initial_result = traits::tspawnve(mode, file_name, arguments, environment);
+    if (initial_result != -1)
+        return initial_result;
+
+    // If the spawn attempt failed, try to determine why.  ENOENT indicates that
+    // the spawn operation itself failed, and there's nothing we can do:
+    if (errno != ENOENT)
+        return -1;
+
+    // If the file name is an absolute or relative path, then we do not search
+    // the %PATH%, so there is nothing left to do:
+    if (traits::tcschr(file_name, '\\') != nullptr)
+        return -1;
+    
+    if (traits::tcschr(file_name, '/') != nullptr)
+        return -1;
+
+    if (file_name[1] == ':')
+        return -1;
+
+    // Otherwise, the file name string just names an executable.  Let's try
+    // appending it to each path in the %PATH% and see if we can find the
+    // file to execute:
+    Character const path_name[] = { 'P', 'A', 'T', 'H', '\0' };
+    __crt_unique_heap_ptr<Character> path_value;
+    if (_ERRCHECK_EINVAL(traits::tdupenv_s_crt(path_value.get_address_of(), nullptr, path_name)) != 0)
+        return -1;
+
+    if (!path_value)
+        return -1;
+
+    // This will be used to store alternative path names to the executable:
+    __crt_unique_heap_ptr<Character> const owned_file_buffer(_calloc_crt_t(Character, _MAX_PATH));
+    if (!owned_file_buffer)
+        return -1;
+
+    Character* file_buffer = owned_file_buffer.get();
+    Character* path_state  = path_value.get();
+    while ((path_state = traits::tgetpath(path_state, file_buffer, _MAX_PATH - 1)) != 0)
+    {
+        if (!*file_buffer)
+            break;
+
+        // Append a '\' if necessary:
+        Character* const last_character_it = file_buffer + traits::tcslen(file_buffer) - 1;
+        if (last_character_it != traits::tcsrchr(file_buffer, '\\') &&
+            last_character_it != traits::tcsrchr(file_buffer, '/'))
+        {
+            Character const backslash_string[] =  { '\\', '\0' };
+            _ERRCHECK(traits::tcscat_s(file_buffer, _MAX_PATH, backslash_string));
+        }
+
+        // Make sure that the buffer is sufficiently large to hold the file name
+        // concatenated onto the end of this %PATH% component.  If it is not, we
+        // return immediately (errno will still be set from the last call to
+        // _spawnve().
+        if (traits::tcslen(file_buffer) + traits::tcslen(file_name) >= _MAX_PATH)
+            break;
+
+        _ERRCHECK(traits::tcscat_s(file_buffer, _MAX_PATH, file_name));
+
+        // Try the spawn again with the newly constructed path.  Like before, if
+        // this succeeds and is a spawn operation, then a status is returned and
+        // we can return immediately.  If this succeeds and is an exec operation,
+        // the call does not return.
+        errno = 0;
+        intptr_t const result = traits::tspawnve(mode, file_buffer, arguments, environment);
+        if (result != -1)
+            return result;
+
+        // Two classes of failures are acceptable here:  either the operation
+        // failed because the spawn operation itself failed (e.g., if the file
+        // could not be found)...
+        if (errno == ENOENT || _doserrno == ERROR_NOT_READY)
+            continue;
+
+        // ...or the path is a UNC path...
+        bool const is_unc_path_with_slashes =
+            traits::tcschr(file_buffer,     '/') == file_buffer &&
+            traits::tcschr(file_buffer + 1, '/') == file_buffer + 1;
+
+        bool const is_unc_path_with_backslashes =
+            traits::tcschr(file_buffer,     '\\') == file_buffer &&
+            traits::tcschr(file_buffer + 1, '\\') == file_buffer + 1;
+
+        if (is_unc_path_with_slashes || is_unc_path_with_backslashes)
+            continue;
+
+        // ...otherwise, we report the error back to the caller:
+        break;
+    }
+
+    return -1;
+}
+
+
+
+extern "C" intptr_t __cdecl _execvp(
+    char const*        const file_name,
+    char const* const* const arguments
+    )
+{
+    return common_spawnvp(_P_OVERLAY, file_name, arguments, static_cast<char const* const* const>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _execvpe(
+    char const*        const file_name,
+    char const* const* const arguments,
+    char const* const* const environment
+    )
+{
+    return common_spawnvp(_P_OVERLAY, file_name, arguments, environment);
+}
+
+extern "C" intptr_t __cdecl _spawnvp(
+    int                const mode,
+    char const*        const file_name,
+    char const* const* const arguments
+    )
+{
+    return common_spawnvp(mode, file_name, arguments, static_cast<char const* const* const>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _spawnvpe(
+    int                const mode,
+    char const*        const file_name,
+    char const* const* const arguments,
+    char const* const* const environment
+    )
+{
+    return common_spawnvp(mode, file_name, arguments, environment);
+}
+
+
+
+extern "C" intptr_t __cdecl _wexecvp(
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments
+    )
+{
+    return common_spawnvp(_P_OVERLAY, file_name, arguments, static_cast<wchar_t const* const* const>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _wexecvpe(
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments,
+    wchar_t const* const* const environment
+    )
+{
+    return common_spawnvp(_P_OVERLAY, file_name, arguments, environment);
+}
+
+extern "C" intptr_t __cdecl _wspawnvp(
+    int                   const mode,
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments
+    )
+{
+    return common_spawnvp(mode, file_name, arguments, static_cast<wchar_t const* const* const>(nullptr));
+}
+
+extern "C" intptr_t __cdecl _wspawnvpe(
+    int                   const mode,
+    wchar_t const*        const file_name,
+    wchar_t const* const* const arguments,
+    wchar_t const* const* const environment
+    )
+{
+    return common_spawnvp(mode, file_name, arguments, environment);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/system.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/system.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac28526757beeab55dd0e6a7f6605060e16fe251
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/system.cpp	
@@ -0,0 +1,86 @@
+//
+// system.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the system() family of functions, which execute a command via the
+// shell.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <process.h>
+#include <io.h>
+#include <stdlib.h>
+#include <errno.h>
+
+
+
+// Executes a command via the shell.  If the command is null, attempts to execute
+// the command processor specified by the %COMSPEC% environment variable.  If 
+// that fails, attempts to execute cmd.exe.
+template <typename Character>
+static int __cdecl common_system(Character const* const command) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    static Character const comspec_name[] = { 'C', 'O', 'M', 'S', 'P', 'E', 'C', '\0' };
+    static Character const cmd_exe[]      = { 'c', 'm', 'd', '.', 'e', 'x', 'e', '\0' };
+    static Character const slash_c[]      = { '/', 'c', '\0' };
+
+    __crt_unique_heap_ptr<Character> comspec_value;
+    _ERRCHECK_EINVAL(traits::tdupenv_s_crt(comspec_value.get_address_of(), nullptr, comspec_name));
+
+    // If the command is null, return TRUE only if %COMSPEC% is set and the file
+    // to which it points exists.
+    if (!command)
+    {
+        if (!comspec_value)
+            return 0;
+
+        return traits::taccess_s(comspec_value.get(), 0) == 0;
+    }
+
+    _ASSERTE(command[0] != '\0');
+
+    Character const* arguments[4] =
+    {
+        comspec_value.get(),
+        slash_c,
+        command,
+        nullptr
+    };
+
+    if (comspec_value)
+    {
+        errno_t const saved_errno = errno;
+        errno = 0;
+
+        int const result = static_cast<int>(traits::tspawnve(_P_WAIT, arguments[0], arguments, nullptr));
+        if (result != -1)
+        {
+            errno = saved_errno;
+            return result;
+        }
+
+        if (errno != ENOENT && errno != EACCES)
+        {
+            return result;
+        }
+
+        // If the error wasn't one of those two errors, try again with cmd.exe...
+        errno = saved_errno;
+    }
+
+   arguments[0] = cmd_exe;
+   return static_cast<int>(traits::tspawnvpe(_P_WAIT, arguments[0], arguments, nullptr));
+}
+
+extern "C" int __cdecl system(char const* const command)
+{
+    return common_system(command);
+}
+
+extern "C" int __cdecl _wsystem(wchar_t const* const command)
+{
+    return common_system(command);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/wait.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/wait.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb8eab02848d8a83ecafa5028df90591d461afd5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/exec/wait.cpp	
@@ -0,0 +1,87 @@
+/***
+*wait.c - wait for child process to terminate
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _wait() - wait for child process to terminate
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <errno.h>
+#include <process.h>
+#include <stdlib.h>
+
+/***
+*int _cwait(stat_loc, process_id, action_code) - wait for specific child
+*       process
+*
+*Purpose:
+*       The function _cwait() suspends the calling-process until the specified
+*       child-process terminates.  If the specifed child-process terminated
+*       prior to the call to _cwait(), return is immediate.
+*
+*Entry:
+*       int *stat_loc - pointer to where status is stored or nullptr
+*       process_id - specific process id to be interrogated (0 means any)
+*       action_code - specific action to perform on process ID
+*                   either _WAIT_CHILD or _WAIT_GRANDCHILD
+*
+*Exit:
+*       process ID of terminated child or -1 on error
+*
+*       *stat_loc is updated to contain the following:
+*       Normal termination: lo-byte = 0, hi-byte = child exit code
+*       Abnormal termination: lo-byte = term status, hi-byte = 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" intptr_t __cdecl _cwait(
+    int*     const exit_code_result,
+    intptr_t const process_id,
+    int      const action_code
+    )
+{
+    DBG_UNREFERENCED_PARAMETER(action_code);
+    
+    if (exit_code_result)
+        *exit_code_result = static_cast<DWORD>(-1);
+
+    // Explicitly check for process ids -1 and -2.  In Windows NT, -1 is a handle
+    // to the current process and -2 is a handle to the current thread, and the
+    // OS will let you wait (forever) on either.
+    _VALIDATE_RETURN_NOEXC(process_id != -1 && process_id != -2, ECHILD, -1);
+
+    __crt_unique_handle process_handle(reinterpret_cast<HANDLE>(process_id));
+
+    // Wait for the child process and get its exit code:
+    DWORD exit_code;
+    if (WaitForSingleObject(process_handle.get(), static_cast<DWORD>(-1)) == 0 &&
+        GetExitCodeProcess(process_handle.get(), &exit_code))
+    {
+        if (exit_code_result)
+            *exit_code_result = exit_code;
+
+        return process_id;
+    }
+
+    // One of the API calls failed; map the error and return failure.
+    DWORD const os_error = GetLastError();
+    if (os_error == ERROR_INVALID_HANDLE)
+    {
+        errno = ECHILD;
+        _doserrno = os_error;
+    }
+    else
+    {
+        __acrt_errno_map_os_error(os_error);
+    }
+
+    if (exit_code_result)
+        *exit_code_result = static_cast<DWORD>(-1);
+
+    return -1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/access.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/access.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10b468a43c15eda72870dce39e06624551961159
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/access.cpp	
@@ -0,0 +1,34 @@
+//
+// access.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _access() and _access_s() functions, which test file accessibility.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+#include <corecrt_internal_win32_buffer.h>
+
+// See _waccess_s for information about this function's behavior.
+extern "C" errno_t __cdecl _access_s(char const* const path, int const access_mode)
+{
+    if (path == nullptr) {
+        return _waccess_s(nullptr, access_mode);
+    }
+
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _waccess_s(wide_path.data(), access_mode);
+}
+
+// The same as _access_s, but transforms all errors into a -1 return value.
+extern "C" int __cdecl _access(char const* const path, int const access_mode)
+{
+    return _access_s(path, access_mode) == 0 ? 0 : -1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/chmod.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/chmod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..05cb3a4c0b03a7aa582cd9a21a33c68b94f54131
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/chmod.cpp	
@@ -0,0 +1,31 @@
+//
+// chmod.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _chmod() function, which changes file attributes.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+#include <sys\stat.h>
+#include <corecrt_internal_win32_buffer.h>
+
+// Changes the mode of a file.  The only supported mode bit is _S_IWRITE, which
+// controls the user write (read-only) attribute of the file.  Returns zero if
+// successful; returns -1 and sets errno and _doserrno on failure.
+extern "C" int __cdecl _chmod(char const* const path, int const mode)
+{
+    if (path == nullptr) {
+        return _wchmod(nullptr, mode);
+    }
+
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _wchmod(wide_path.data(), mode);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/findfile.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/findfile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cfd746525e87fa3b03a4e8412d6122c937639132
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/findfile.cpp	
@@ -0,0 +1,395 @@
+/***
+*findfile.c - C find file functions
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines _findfirst(), _findnext(), and _findclose().
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <errno.h>
+#include <corecrt_internal_time.h>
+#include <io.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <corecrt_internal_win32_buffer.h>
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Utilities for working with the different file type and time data types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename CrtTime>
+static CrtTime __cdecl convert_system_time_to_time_t(SYSTEMTIME const& st) throw();
+
+template <>
+static __time32_t __cdecl convert_system_time_to_time_t(SYSTEMTIME const& st) throw()
+{
+    return __loctotime32_t(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, -1);
+}
+
+template <>
+static __time64_t __cdecl convert_system_time_to_time_t(SYSTEMTIME const& st) throw()
+{
+    return __loctotime64_t(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, -1);
+}
+
+
+
+template <typename CrtTime>
+static CrtTime __cdecl convert_file_time_to_time_t(FILETIME const& ft) throw()
+{
+    // A FILETIME of 0 becomes a time_t of -1:
+    if (ft.dwLowDateTime == 0 && ft.dwHighDateTime == 0)
+        return static_cast<CrtTime>(-1);
+
+    SYSTEMTIME st_utc;
+    if (!FileTimeToSystemTime(&ft, &st_utc))
+        return static_cast<CrtTime>(-1);
+
+    SYSTEMTIME st_local;
+    if (!SystemTimeToTzSpecificLocalTime(nullptr, &st_utc, &st_local))
+        return static_cast<CrtTime>(-1);
+
+    return convert_system_time_to_time_t<CrtTime>(st_local);
+}
+
+
+
+template <typename Integer>
+static Integer convert_file_size_to_integer(DWORD const high, DWORD const low) throw();
+
+template <>
+static __int64 convert_file_size_to_integer(DWORD const high, DWORD const low) throw()
+{
+    return static_cast<__int64>(high) * 0x100000000i64 + static_cast<__int64>(low);
+}
+
+template <>
+static unsigned long convert_file_size_to_integer(DWORD const high, DWORD const low) throw()
+{
+    UNREFERENCED_PARAMETER(high);
+    return low;
+}
+
+
+
+template <typename WideFileData, typename NarrowFileData>
+_Success_(return)
+static bool __cdecl copy_wide_to_narrow_find_data(WideFileData const& wfd, _Out_ NarrowFileData& fd, unsigned int const code_page) throw()
+{
+    __crt_internal_win32_buffer<char> name;
+
+    errno_t const cvt = __acrt_wcs_to_mbs_cp(wfd.name, name, code_page);
+
+    if (cvt != 0) {
+        return false;
+    }
+
+    _ERRCHECK(strcpy_s(fd.name, _countof(fd.name), name.data()));
+
+    fd.attrib       = wfd.attrib;
+    fd.time_create  = wfd.time_create;
+    fd.time_access  = wfd.time_access;
+    fd.time_write   = wfd.time_write;
+    fd.size         = wfd.size;
+
+    return true;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The _findfirst family of functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions find the first file matching the given wildcard pattern. If a
+// file is found, information about that file is stored in the pointed-to result
+// parameter.  The return value is a handle that identifies the group of files
+// that match the pattern.  If no file is found, or if an error occurs, errno is
+// set and -1 is returned.
+//
+// There are eight functions in this family, combining {wide name, narrow name}
+// x {32-bit file size, 64-bit file size} x {32-bit time_t, 64-bit time_t}.
+template <typename WideFileData>
+_Success_(return != -1)
+static intptr_t __cdecl common_find_first_wide(wchar_t const* const pattern, _Out_ WideFileData* const result) throw()
+{
+    _VALIDATE_RETURN(result  != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(pattern != nullptr, EINVAL, -1);
+
+    // Ensure the underlying WIN32_FIND_DATA's file name buffer is not larger
+    // than ours.
+    static_assert(sizeof(WideFileData().name) <= sizeof(WIN32_FIND_DATAW().cFileName), "");
+
+    WIN32_FIND_DATAW wfd;
+    HANDLE const hFile = FindFirstFileExW(pattern, FindExInfoStandard, &wfd, FindExSearchNameMatch, nullptr, 0);
+    if (hFile == INVALID_HANDLE_VALUE)
+    {
+        DWORD const os_error = GetLastError();
+        switch (os_error)
+        {
+        case ERROR_NO_MORE_FILES:
+        case ERROR_FILE_NOT_FOUND:
+        case ERROR_PATH_NOT_FOUND:
+            errno = ENOENT;
+            break;
+
+        case ERROR_NOT_ENOUGH_MEMORY:
+            errno = ENOMEM;
+            break;
+
+        default:
+            errno = EINVAL;
+            break;
+        }
+
+        return -1;
+    }
+
+    result->attrib = wfd.dwFileAttributes == FILE_ATTRIBUTE_NORMAL
+        ? 0
+        : wfd.dwFileAttributes;
+
+    typedef decltype(result->time_create) crt_time_type;
+    result->time_create = convert_file_time_to_time_t<crt_time_type>(wfd.ftCreationTime);
+    result->time_access = convert_file_time_to_time_t<crt_time_type>(wfd.ftLastAccessTime);
+    result->time_write  = convert_file_time_to_time_t<crt_time_type>(wfd.ftLastWriteTime);
+
+    typedef decltype(result->size) file_size_type;
+    result->size = convert_file_size_to_integer<file_size_type>(wfd.nFileSizeHigh, wfd.nFileSizeLow);
+
+    _ERRCHECK(wcscpy_s(result->name, _countof(result->name), wfd.cFileName));
+
+    return reinterpret_cast<intptr_t>(hFile);
+}
+
+template <typename WideFileData, typename NarrowFileData>
+_Success_(return != -1)
+static intptr_t __cdecl common_find_first_narrow(char const* const pattern, _Out_ NarrowFileData* const result, unsigned int const code_page) throw()
+{
+    _VALIDATE_RETURN(result != nullptr, EINVAL, -1);
+
+    __crt_internal_win32_buffer<wchar_t> wide_pattern;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(pattern, wide_pattern, code_page);
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    WideFileData wide_result;
+    intptr_t const handle = common_find_first_wide(wide_pattern.data(), &wide_result);
+    if (handle == -1)
+        return -1;
+
+    if (!copy_wide_to_narrow_find_data(wide_result, *result, code_page))
+        return -1;
+
+    return handle;
+}
+
+// Narrow name, 32-bit time_t, 32-bit size
+extern "C" intptr_t __cdecl _findfirst32(char const* const pattern, _finddata32_t* const result)
+{
+    return common_find_first_narrow<_wfinddata32_t>(pattern, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Narrow name, 32-bit time_t, 64-bit size
+extern "C" intptr_t __cdecl _findfirst32i64(char const* const pattern, _finddata32i64_t* const result)
+{
+    return common_find_first_narrow<_wfinddata32i64_t>(pattern, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Narrow name, 64-bit time_t, 32-bit size
+extern "C" intptr_t __cdecl _findfirst64i32(char const* const pattern, _finddata64i32_t* const result)
+{
+    return common_find_first_narrow<_wfinddata64i32_t>(pattern, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Narrow name, 64-bit time_t, 64-bit size
+extern "C" intptr_t __cdecl _findfirst64(char const* const pattern, __finddata64_t* const result)
+{
+    return common_find_first_narrow<_wfinddata64_t>(pattern, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Wide name, 32-bit time_t, 32-bit size
+extern "C" intptr_t __cdecl _wfindfirst32(wchar_t const* const pattern, _wfinddata32_t* const result)
+{
+    return common_find_first_wide(pattern, result);
+}
+
+// Wide name, 32-bit time_t, 64-bit size
+extern "C" intptr_t __cdecl _wfindfirst32i64(wchar_t const* const pattern, _wfinddata32i64_t* const result)
+{
+    return common_find_first_wide(pattern, result);
+}
+
+// Wide name, 64-bit time_t, 32-bit size
+extern "C" intptr_t __cdecl _wfindfirst64i32(wchar_t const* const pattern, _wfinddata64i32_t* const result)
+{
+    return common_find_first_wide(pattern, result);
+}
+
+// Wide name, 64-bit time_t, 64-bit size
+extern "C" intptr_t __cdecl _wfindfirst64(wchar_t const* const pattern, _wfinddata64_t* const result)
+{
+    return common_find_first_wide(pattern, result);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The _findnext family of functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions perform iteration over a set of files matching a wildcard
+// pattern.  The handle argument must be a handle returned by a previous call to
+// one of the _findfirst functions that completed successfully.  Each call to a
+// _findnext function advances the internal iterator and returns information
+// about the next file in the set.
+//
+// If iteration has not yet completed and a file is found, information about that
+// file is stored in the pointed-to result parameter.  The return value is a
+// handle that identifies the group of files that match the pattern.  If no file
+// is found, or if an error occurs, errno is set and -1 is returned.
+//
+// There are eight functions in this family, combining {wide name, narrow name}
+// x {32-bit file size, 64-bit file size} x {32-bit time_t, 64-bit time_t}.
+template <typename WideFileData>
+static int __cdecl common_find_next_wide(intptr_t const handle, WideFileData* const result) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(handle);
+
+    _VALIDATE_RETURN(os_handle != 0                   , EINVAL, -1);
+    _VALIDATE_RETURN(os_handle != INVALID_HANDLE_VALUE, EINVAL, -1);
+    _VALIDATE_RETURN(result != nullptr,                 EINVAL, -1);
+
+    WIN32_FIND_DATAW wfd;
+    if (!FindNextFileW(os_handle, &wfd))
+    {
+        DWORD const os_error = GetLastError();
+        switch (os_error)
+        {
+        case ERROR_NO_MORE_FILES:
+        case ERROR_FILE_NOT_FOUND:
+        case ERROR_PATH_NOT_FOUND:
+            errno = ENOENT;
+            break;
+
+        case ERROR_NOT_ENOUGH_MEMORY:
+            errno = ENOMEM;
+            break;
+
+        default:
+            errno = EINVAL;
+            break;
+        }
+
+        return -1;
+    }
+
+    result->attrib = wfd.dwFileAttributes == FILE_ATTRIBUTE_NORMAL
+        ? 0
+        : wfd.dwFileAttributes;
+
+    typedef decltype(result->time_create) crt_time_type;
+    result->time_create = convert_file_time_to_time_t<crt_time_type>(wfd.ftCreationTime);
+    result->time_access = convert_file_time_to_time_t<crt_time_type>(wfd.ftLastAccessTime);
+    result->time_write  = convert_file_time_to_time_t<crt_time_type>(wfd.ftLastWriteTime);
+
+    typedef decltype(result->size) file_size_type;
+    result->size = convert_file_size_to_integer<file_size_type>(wfd.nFileSizeHigh, wfd.nFileSizeLow);
+
+    _ERRCHECK(wcscpy_s(result->name, _countof(result->name), wfd.cFileName));
+
+    return 0;
+}
+
+template <typename WideFileData, typename NarrowFileData>
+static int __cdecl common_find_next_narrow(intptr_t const pattern, NarrowFileData* const result, unsigned int const code_page) throw()
+{
+    WideFileData wide_result;
+    int const return_value = common_find_next_wide(pattern, &wide_result);
+    if (return_value == -1)
+        return -1;
+
+    if (!copy_wide_to_narrow_find_data(wide_result, *result, code_page))
+        return -1;
+
+    return return_value;
+}
+
+// Narrow name, 32-bit time_t, 32-bit size
+extern "C" int __cdecl _findnext32(intptr_t const handle, _finddata32_t* const result)
+{
+    return common_find_next_narrow<_wfinddata32_t>(handle, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Narrow name, 32-bit time_t, 64-bit size
+extern "C" int __cdecl _findnext32i64(intptr_t const handle, _finddata32i64_t* const result)
+{
+    return common_find_next_narrow<_wfinddata32i64_t>(handle, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Narrow name, 64-bit time_t, 32-bit size
+extern "C" int __cdecl _findnext64i32(intptr_t const handle, _finddata64i32_t* const result)
+{
+    return common_find_next_narrow<_wfinddata64i32_t>(handle, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Narrow name, 64-bit time_t, 64-bit size
+extern "C" int __cdecl _findnext64(intptr_t const handle, __finddata64_t* const result)
+{
+    return common_find_next_narrow<_wfinddata64_t>(handle, result, __acrt_get_utf8_acp_compatibility_codepage());
+}
+
+// Wide name, 32-bit time_t, 32-bit size
+extern "C" int __cdecl _wfindnext32(intptr_t const handle, _wfinddata32_t* const result)
+{
+    return common_find_next_wide(handle, result);
+}
+
+// Wide name, 32-bit time_t, 64-bit size
+extern "C" int __cdecl _wfindnext32i64(intptr_t const handle, _wfinddata32i64_t* const result)
+{
+    return common_find_next_wide(handle, result);
+}
+
+// Wide name, 64-bit time_t, 32-bit size
+extern "C" int __cdecl _wfindnext64i32(intptr_t const handle, _wfinddata64i32_t* const result)
+{
+    return common_find_next_wide(handle, result);
+}
+
+// Wide name, 64-bit time_t, 64-bit size
+extern "C" int __cdecl _wfindnext64(intptr_t const handle, _wfinddata64_t* const result)
+{
+    return common_find_next_wide(handle, result);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The _findclose function
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This function releases resources associated with a _findfirst/_findnext
+// iteration.  It must be called exactly once for each handle returned by
+// _findfirst.  Returns 0 on success; -1 on failure.
+extern "C" int __cdecl _findclose(intptr_t const handle)
+{
+    if (!FindClose(reinterpret_cast<HANDLE>(handle)))
+    {
+        errno = EINVAL;
+        return -1;
+    }
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/fullpath.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/fullpath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22e11475a575d5608eb759f997c1d03946d64af9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/fullpath.cpp	
@@ -0,0 +1,153 @@
+/***
+*fullpath.c -
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose: contains the function _fullpath which makes an absolute path out
+*       of a relative path. i.e.  ..\pop\..\main.c => c:\src\main.c if the
+*       current directory is c:\src\src
+*
+*******************************************************************************/
+
+#include <stdio.h>
+#include <direct.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <corecrt_internal_traits.h>
+#include <windows.h>
+
+/***
+*_TCHAR *_fullpath( _TCHAR *buf, const _TCHAR *path, maxlen );
+*
+*Purpose:
+*
+*       _fullpath - combines the current directory with path to form
+*       an absolute path. i.e. _fullpath takes care of .\ and ..\
+*       in the path.
+*
+*       The result is placed in buf. If the length of the result
+*       is greater than maxlen nullptr is returned, otherwise
+*       the address of buf is returned.
+*
+*       If buf is nullptr then a buffer is malloc'ed and maxlen is
+*       ignored. If there are no errors then the address of this
+*       buffer is returned.
+*
+*       If path specifies a drive, the curent directory of this
+*       drive is combined with path. If the drive is not valid
+*       and _fullpath needs the current directory of this drive
+*       then nullptr is returned.  If the current directory of this
+*       non existant drive is not needed then a proper value is
+*       returned.
+*       For example:  path = "z:\\pop" does not need z:'s current
+*       directory but path = "z:pop" does.
+*
+*
+*
+*Entry:
+*       _TCHAR *buf  - pointer to a buffer maintained by the user;
+*       _TCHAR *path - path to "add" to the current directory
+*       int maxlen - length of the buffer pointed to by buf
+*
+*Exit:
+*       Returns pointer to the buffer containing the absolute path
+*       (same as buf if non-nullptr; otherwise, malloc is
+*       used to allocate a buffer)
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+template <typename Character>
+_Success_(return != 0)
+static Character* __cdecl common_fullpath(
+    _Out_writes_z_(max_count) Character* const user_buffer,
+    Character const* const path,
+    size_t           const max_count,
+    int              const block_use,
+    char const*      const file_name,
+    int              const line_number
+    ) throw()
+{
+    // These are referenced only in the Debug CRT build
+    UNREFERENCED_PARAMETER(block_use);
+    UNREFERENCED_PARAMETER(file_name);
+    UNREFERENCED_PARAMETER(line_number);
+
+    typedef __crt_char_traits<Character> traits;
+
+    // If the path is empty, we have no work to do:
+    if (path == nullptr || path[0] == '\0')
+    {
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036 Prefast does not understand perfect forwarding.
+        return traits::tgetcwd(user_buffer, static_cast<int>(__min(max_count, INT_MAX)));
+    }
+
+    if (user_buffer != nullptr) {
+        // Using user buffer. Fail if not enough space.
+        __crt_no_alloc_win32_buffer<Character> buffer(user_buffer, max_count);
+        if (!traits::get_full_path_name(path, buffer)) {
+            return user_buffer;
+        } else {
+            return nullptr;
+        }
+    } else {
+        // Always new memory suitable for debug mode and releasing to the user.
+        __crt_public_win32_buffer<Character> buffer(
+            __crt_win32_buffer_debug_info(block_use, file_name, line_number)
+            );
+        traits::get_full_path_name(path, buffer);
+        return buffer.detach();
+    }
+}
+
+
+
+extern "C" char* __cdecl _fullpath(
+    char*       const user_buffer,
+    char const* const path,
+    size_t      const max_count
+    )
+{
+    return common_fullpath(user_buffer, path, max_count, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" wchar_t* __cdecl _wfullpath(
+    wchar_t*       const user_buffer,
+    wchar_t const* const path,
+    size_t         const max_count
+    )
+{
+    return common_fullpath(user_buffer, path, max_count, _NORMAL_BLOCK, nullptr, 0);
+}
+
+#ifdef _DEBUG
+
+#undef _fullpath_dbg
+#undef _wfullpath_dbg
+
+extern "C" char* __cdecl _fullpath_dbg(
+    char*       const user_buffer,
+    char const* const path,
+    size_t      const max_count,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return common_fullpath(user_buffer, path, max_count, block_use, file_name, line_number);
+}
+
+extern "C" wchar_t* __cdecl _wfullpath_dbg(
+    wchar_t*       const user_buffer,
+    wchar_t const* const path,
+    size_t         const max_count,
+    int            const block_use,
+    char const*    const file_name,
+    int            const line_number
+    )
+{
+    return common_fullpath(user_buffer, path, max_count, block_use, file_name, line_number);
+}
+
+#endif // _DEBUG
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/makepath.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/makepath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..990c37eb1ea1c19c1f9148fd4551cc65252f7a55
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/makepath.cpp	
@@ -0,0 +1,205 @@
+//
+// makepath.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the makepath family of functions, which compose a path string.
+//
+#include <corecrt_internal_securecrt.h>
+#include <mbstring.h>
+#include <stdlib.h>
+
+
+
+static char const* previous_character(char const* const first, char const* const current) throw()
+{
+    return reinterpret_cast<char const*>(_mbsdec(
+        reinterpret_cast<unsigned char const*>(first),
+        reinterpret_cast<unsigned char const*>(current)));
+}
+
+static wchar_t const* previous_character(wchar_t const*, wchar_t const* const current) throw()
+{
+    return current - 1;
+}
+
+
+
+template <typename Character>
+static errno_t __cdecl cleanup_after_error(
+    _Out_writes_z_(count) Character* const buffer,
+    size_t                           const count) throw()
+{
+    // This is referenced only in the Debug CRT build
+    UNREFERENCED_PARAMETER(count);
+
+    _RESET_STRING(buffer, count);
+    _RETURN_BUFFER_TOO_SMALL(buffer, count);
+    return EINVAL; // This is unreachable
+}
+
+
+
+// These functions compose a path string from its component parts.  They
+// concatenate the drive, directory, file_name, and extension into the provided
+// result_buffer.  For the functions that do not have a buffer count parameter,
+// the buffer is assumed to be large enough to hold however many characters are
+// required.
+//
+// The drive may or may not contain a ':'.  The directory may or may not contain
+// a leading or trailing '/' or '\'.  The extension may or may not contain a
+// leading '.'.
+template <typename Character>
+static errno_t __cdecl common_makepath_s(
+    _Out_writes_z_(result_count) Character* const result_buffer,
+    _In_       size_t           const result_count,
+    _In_opt_z_ Character const* const drive,
+    _In_opt_z_ Character const* const directory,
+    _In_opt_z_ Character const* const file_name,
+    _In_opt_z_ Character const* const extension
+    ) throw()
+{
+    _VALIDATE_STRING(result_buffer, result_count);
+
+    Character*       result_it  = result_buffer;
+
+    // For the non-secure makepath functions, result_count is _CRT_UNBOUNDED_BUFFER_SIZE.
+    // In this case, we do not want to perform arithmetic with the result_count.  Instead,
+    // we set the result_end to nullptr:  result_it will never be a null pointer,
+    // and when we need to perform arithmetic with result_end we can check it for
+    // null first.
+    Character* const result_end = result_count != _CRT_UNBOUNDED_BUFFER_SIZE
+        ? result_buffer + result_count
+        : nullptr;
+
+    CRT_WARNING_DISABLE_PUSH(26015, "Silence prefast about overflow - covered by result_end for secure callers")
+
+    // Copy the drive:
+    if (drive && drive[0] != '\0')
+    {
+        if (result_end != nullptr && result_end - result_it < 2)
+            return cleanup_after_error(result_buffer, result_count);
+
+        *result_it++ = *drive;
+        *result_it++ = ':';
+    }
+
+    // Copy the directory:
+    if (directory && directory[0] != '\0')
+    {
+        Character const* source_it = directory;
+        while (*source_it != '\0')
+        {
+            if ((result_end != nullptr) && (result_it >= result_end))
+                return cleanup_after_error(result_buffer, result_count);
+
+            *result_it++ = *source_it++;
+        }
+
+        // Write a trailing backslash if there isn't one:
+        source_it = previous_character(directory, source_it);
+        if (*source_it != '/' && *source_it != '\\')
+        {
+            if ((result_end != nullptr) && (result_it >= result_end))
+                return cleanup_after_error(result_buffer, result_count);
+
+            *result_it++ = '\\';
+        }
+    }
+
+    // Copy the file name:
+    if (file_name)
+    {
+        Character const* source_it = file_name;
+        while (*source_it != '\0')
+        {
+            if ((result_end != nullptr) && (result_it >= result_end))
+                return cleanup_after_error(result_buffer, result_count);
+
+            *result_it++ = *source_it++;
+        }
+    }
+
+    // Copy the extension:
+    if (extension)
+    {
+        // Add a '.' if one is required:
+        if (extension[0] != '\0' && extension[0] != '.')
+        {
+            if ((result_end != nullptr) && (result_it >= result_end))
+                return cleanup_after_error(result_buffer, result_count);
+
+            *result_it++ = '.';
+        }
+
+        Character const* source_it = extension;
+        while (*source_it != '\0')
+        {
+            if ((result_end != nullptr) && (result_it >= result_end))
+                return cleanup_after_error(result_buffer, result_count);
+
+            *result_it++ = *source_it++;
+        }
+    }
+
+    // Copy the null terminator:
+    if ((result_end != nullptr) && (result_it >= result_end))
+        return cleanup_after_error(result_buffer, result_count);
+
+    *result_it++ = '\0';
+
+    CRT_WARNING_POP
+
+    _FILL_STRING(result_buffer, result_count, result_it - result_buffer);
+    return 0;
+}
+
+
+
+extern "C" void __cdecl _makepath(
+    char*       const result_buffer,
+    char const* const drive,
+    char const* const directory,
+    char const* const file_name,
+    char const* const extension
+    )
+{
+    _makepath_s(result_buffer, _CRT_UNBOUNDED_BUFFER_SIZE, drive, directory, file_name, extension);
+}
+
+extern "C" void __cdecl _wmakepath(
+    wchar_t*       const result_buffer,
+    wchar_t const* const drive,
+    wchar_t const* const directory,
+    wchar_t const* const file_name,
+    wchar_t const* const extension
+    )
+{
+    _wmakepath_s(result_buffer, _CRT_UNBOUNDED_BUFFER_SIZE, drive, directory, file_name, extension);
+}
+
+
+
+extern "C" errno_t __cdecl _makepath_s(
+    char*       const result_buffer,
+    size_t      const result_count,
+    char const* const drive,
+    char const* const directory,
+    char const* const file_name,
+    char const* const extension
+    )
+{
+    return common_makepath_s(result_buffer, result_count, drive, directory, file_name, extension);
+}
+
+extern "C" errno_t __cdecl _wmakepath_s(
+    wchar_t*       const result_buffer,
+    size_t         const result_count,
+    wchar_t const* const drive,
+    wchar_t const* const directory,
+    wchar_t const* const file_name,
+    wchar_t const* const extension
+    )
+{
+    return common_makepath_s(result_buffer, result_count, drive, directory, file_name, extension);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/mkdir.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/mkdir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bdee943ae4b04156438769aba8f4ed2c618d1528
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/mkdir.cpp	
@@ -0,0 +1,29 @@
+//
+// mkdir.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _mkdir() function, which creates a directory.
+//
+#include <corecrt_internal.h>
+#include <direct.h>
+#include <corecrt_internal_win32_buffer.h>
+
+// Creates a directory.  Returns 0 on success; returns -1 and sets errno and
+// _doserrno on failure.
+extern "C" int __cdecl _mkdir(char const* const path)
+{
+    if (path == nullptr) {
+        return _wmkdir(nullptr);
+    }
+
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _wmkdir(wide_path.data());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/rename.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/rename.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f015025d1de99de4790a73f26eef08005ced62c3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/rename.cpp	
@@ -0,0 +1,39 @@
+//
+// rename.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The rename() function, which renames a file.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+#include <corecrt_internal_win32_buffer.h>
+
+
+
+// See _wrename() for details about the behavior of this function.  (This
+// function simply converts the multibyte strings to wide strings and calls
+// _wrename().)
+extern "C" int __cdecl rename(char const* const old_name, char const* const new_name)
+{
+    unsigned int const code_page = __acrt_get_utf8_acp_compatibility_codepage();
+
+    __crt_internal_win32_buffer<wchar_t> wide_old_name;
+
+    errno_t cvt1 = __acrt_mbs_to_wcs_cp(old_name, wide_old_name, code_page);
+    if (cvt1 != 0)
+    {
+        errno = cvt1;
+        return -1;
+    }
+
+    __crt_internal_win32_buffer<wchar_t> wide_new_name;
+    errno_t cvt2 = __acrt_mbs_to_wcs_cp(new_name, wide_new_name, code_page);
+    if (cvt2 != 0)
+    {
+        errno = cvt2;
+        return -1;
+    }
+
+    return _wrename(wide_old_name.data(), wide_new_name.data());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/rmdir.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/rmdir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a1130f4a375cacb65da67723f610bc6210c45256
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/rmdir.cpp	
@@ -0,0 +1,31 @@
+//
+// rmdir.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _rmdir() function, which removes a directory.
+//
+#include <corecrt_internal.h>
+#include <direct.h>
+#include <corecrt_internal_win32_buffer.h>
+
+// Removes the directory specified by the path.  The directory must be empty, it
+// must not be the current working directory, and it must not be the root of any
+// drive.  Returns 0 on success; returns -1 and sets errno and _doserrno on
+// failure.
+extern "C" int __cdecl _rmdir(char const* const path)
+{
+    if (path == nullptr) {
+        return _wrmdir(nullptr);
+    }
+
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _wrmdir(wide_path.data());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/splitpath.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/splitpath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..345c4e99af12f48eca22180b361ea5073bcd32da
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/splitpath.cpp	
@@ -0,0 +1,352 @@
+/***
+*splitpath.c - break down path name into components
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       To provide support for accessing the individual components of an
+*       arbitrary path name
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <mbctype.h>
+#include <stdlib.h>
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_internal_traits.h>
+
+namespace
+{
+    template <typename Character>
+    struct component_buffers
+    {
+        _Null_terminated_ _Maybenull_
+        Character* _drive;
+        size_t     _drive_count;
+        _Null_terminated_ _Maybenull_
+        Character* _directory;
+        size_t     _directory_count;
+        _Null_terminated_ _Maybenull_
+        Character* _file_name;
+        size_t     _file_name_count;
+        _Null_terminated_ _Maybenull_
+        Character* _extension;
+        size_t     _extension_count;
+    };
+}
+
+template <typename Character, typename ResetPolicy>
+static void __cdecl reset_buffers(
+    component_buffers<Character>* const components,
+    ResetPolicy                   const reset_buffer
+    ) throw()
+{
+    reset_buffer(components->_drive,     components->_drive_count    );
+    reset_buffer(components->_directory, components->_directory_count);
+    reset_buffer(components->_file_name, components->_file_name_count);
+    reset_buffer(components->_extension, components->_extension_count);
+}
+
+// is_lead_byte helper 
+// these functions are only used to ensure that trailing bytes that might
+// look like slashes or periods aren't misdetected.
+// UTF-8/UTF-16 don't have that problem as trail bytes never look like \ or .
+static bool __cdecl needs_trail_byte(char const c) throw()
+{
+    // UTF-8 is OK here as the caller is really only concerned about trail
+    // bytes that look like . or \ and UTF-8 trail bytes never will.
+    return _ismbblead(c) != 0;
+}
+
+static bool __cdecl needs_trail_byte(wchar_t) throw()
+{
+    // UTF-16 is OK here as the caller is really only concerned about trail
+    // characters that look like . or \ and UTF-16 surrogate pairs never will.
+    return false;
+}
+
+template <typename Character, typename ResetPolicy, typename BufferCountTransformer>
+static errno_t __cdecl common_splitpath_internal(
+    Character const*              const path,
+    component_buffers<Character>* const components,
+    ResetPolicy                   const reset_buffer,
+    BufferCountTransformer        const transform_buffer_count
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    if (!path || !components)
+    {
+        reset_buffers(components, reset_buffer);
+        _VALIDATE_RETURN_ERRCODE(false, EINVAL);
+    }
+
+    if ((components->_drive     == nullptr) != (components->_drive_count     == 0) ||
+        (components->_directory == nullptr) != (components->_directory_count == 0) ||
+        (components->_file_name == nullptr) != (components->_file_name_count == 0) ||
+        (components->_extension == nullptr) != (components->_extension_count == 0))
+    {
+        reset_buffers(components, reset_buffer);
+        _VALIDATE_RETURN_ERRCODE(false, EINVAL);
+    }
+
+    Character const* path_it = path;
+
+    // Extract drive letter and ':', if any:
+    {
+        size_t skip = _MAX_DRIVE - 2;
+        Character const* p = path_it;
+        while (skip > 0 && *p != '\0')
+        {
+            --skip;
+            ++p;
+        }
+
+        if (*p == ':')
+        {
+            if (components->_drive)
+            {
+                if (components->_drive_count < _MAX_DRIVE)
+                {
+                    reset_buffers(components, reset_buffer);
+                    return errno = ERANGE;
+                }
+
+                traits::tcsncpy_s(components->_drive, transform_buffer_count(components->_drive_count), path_it, _MAX_DRIVE - 1);
+            }
+
+            path_it = p + 1;
+        }
+        else
+        {
+            reset_buffer(components->_drive, components->_drive_count);
+        }
+    }
+
+    // Extract the path string, if any.  The path iterator now points to the first
+    // character of the path, if there is one, or to the filename or extension if
+    // no path was specified.  Scan ahead for the last occurence, if any, of a '/'
+    //  or '\' path separator character.  If none is found, there is no path.  We
+    // will also note the last '.' character found, if any, to aid in handling the
+    // extension.
+    Character const* p          = path_it;
+    Character const* last_slash = nullptr;
+    Character const* last_dot   = nullptr;
+    for (; *p != '\0'; ++p)
+    {
+        // UTF-8 will never look like slashes or periods so this will be OK for UTF-8
+        if (needs_trail_byte(*p))
+        {
+            // For narrow character strings, skip any multibyte characters to avoid
+            // matching trail bytes that "look like" slashes or periods.  This ++p
+            // will skip the lead byte; the ++p in the for loop will skip the trail
+            // byte.
+            ++p;
+
+            // If we've reached the end of the string, there is no trail byte.
+            // (Technically, the string is malformed.)
+            if (*p == '\0')
+            {
+                break;
+            }
+        }
+        else if (*p == '/' || *p == '\\')
+        {
+            last_slash = p + 1; // Point one past for later copy
+        }
+        else if (*p == '.')
+        {
+            last_dot = p;
+        }
+    }
+
+    if (last_slash)
+    {
+        if (components->_directory)
+        {
+            size_t const length = static_cast<size_t>(last_slash - path_it);
+            if (components->_directory_count <= length)
+            {
+                reset_buffers(components, reset_buffer);
+                return errno = ERANGE;
+            }
+
+            traits::tcsncpy_s(components->_directory, transform_buffer_count(components->_directory_count), path_it, length);
+        }
+
+        path_it = last_slash;
+    }
+    else
+    {
+        reset_buffer(components->_directory, components->_directory_count);
+    }
+
+    // Extract the file name and extension, if any.  The path iterator now points
+    // to the first character of the file name, if any, or the extension if no
+    // file name was given.  The dot points to the '.' beginning the extension,
+    // if any.
+    if (last_dot && last_dot >= path_it)
+    {
+        // We found a dot; it separates the file name from the extension:
+        if (components->_file_name)
+        {
+            size_t const length = static_cast<size_t>(last_dot - path_it);
+            if (components->_file_name_count <= length)
+            {
+                reset_buffers(components, reset_buffer);
+                return errno = ERANGE;
+            }
+
+            traits::tcsncpy_s(components->_file_name, transform_buffer_count(components->_file_name_count), path_it, length);
+        }
+
+        if (components->_extension)
+        {
+            size_t const length = static_cast<size_t>(p - last_dot);
+            if (components->_extension_count <= length)
+            {
+                reset_buffers(components, reset_buffer);
+                return errno = ERANGE;
+            }
+
+            traits::tcsncpy_s(components->_extension, transform_buffer_count(components->_extension_count), last_dot, length);
+        }
+    }
+    else
+    {
+        // No extension found; reset the extension and treat the remaining text
+        // as the file name:
+        if (components->_file_name)
+        {
+            size_t const length = static_cast<size_t>(p - path_it);
+            if (components->_file_name_count <= length)
+            {
+                reset_buffers(components, reset_buffer);
+                return errno = ERANGE;
+            }
+
+            traits::tcsncpy_s(components->_file_name, transform_buffer_count(components->_file_name_count), path_it, length);
+        }
+
+        if (components->_extension)
+        {
+            reset_buffer(components->_extension, components->_extension_count);
+        }
+    }
+
+    return 0;
+}
+
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_splitpath_s(
+    Character const*              const path,
+    component_buffers<Character>* const components
+    ) throw()
+{
+    return common_splitpath_internal(path, components, [](_Out_writes_z_(buffer_count) Character* const buffer, size_t const buffer_count)
+    {
+        UNREFERENCED_PARAMETER(buffer);
+        UNREFERENCED_PARAMETER(buffer_count);
+        if (buffer)
+        {
+            _RESET_STRING(buffer, buffer_count);
+        }
+    },
+    [](size_t const n) { return n; });
+}
+
+
+extern "C" errno_t __cdecl _splitpath_s(
+    char const* const path,
+    char*       const drive,
+    size_t      const drive_count,
+    char*       const directory,
+    size_t      const directory_count,
+    char*       const file_name,
+    size_t      const file_name_count,
+    char*       const extension,
+    size_t      const extension_count
+    )
+{
+    component_buffers<char> components =
+    {
+        drive,     drive_count,
+        directory, directory_count,
+        file_name, file_name_count,
+        extension, extension_count
+    };
+
+    return common_splitpath_s(path, &components);
+}
+
+extern "C" errno_t __cdecl _wsplitpath_s(
+    wchar_t const* const path,
+    wchar_t*       const drive,
+    size_t         const drive_count,
+    wchar_t*       const directory,
+    size_t         const directory_count,
+    wchar_t*       const file_name,
+    size_t         const file_name_count,
+    wchar_t*       const extension,
+    size_t         const extension_count
+    )
+{
+    component_buffers<wchar_t> components =
+    {
+        drive,     drive_count,
+        directory, directory_count,
+        file_name, file_name_count,
+        extension, extension_count
+    };
+
+    return common_splitpath_s(path, &components);
+}
+
+template <typename Character>
+static void __cdecl common_splitpath(
+    _In_z_                   Character const* const path,
+    _Pre_maybenull_ _Post_z_ Character*       const drive,
+    _Pre_maybenull_ _Post_z_ Character*       const directory,
+    _Pre_maybenull_ _Post_z_ Character*       const file_name,
+    _Pre_maybenull_ _Post_z_ Character*       const extension
+    ) throw()
+{
+    component_buffers<Character> components =
+    {
+        drive,     drive     ? _MAX_DRIVE : 0,
+        directory, directory ? _MAX_DIR   : 0,
+        file_name, file_name ? _MAX_FNAME : 0,
+        extension, extension ? _MAX_EXT   : 0
+    };
+
+    common_splitpath_internal(path, &components, [](Character* const buffer, size_t const buffer_count)
+    {
+        if (buffer && buffer_count != 0)
+        {
+            buffer[0] = '\0';
+        }
+    },
+    [](size_t){ return static_cast<size_t>(-1); });
+}
+
+extern "C" void __cdecl _splitpath(
+    char const* const path,
+    char*       const drive,
+    char*       const directory,
+    char*       const file_name,
+    char*       const extension
+    )
+{
+    return common_splitpath(path, drive, directory, file_name, extension);
+}
+
+extern "C" void __cdecl _wsplitpath(
+    wchar_t const* const path,
+    wchar_t*       const drive,
+    wchar_t*       const directory,
+    wchar_t*       const file_name,
+    wchar_t*       const extension
+    )
+{
+    return common_splitpath(path, drive, directory, file_name, extension);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/stat.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/stat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11f4f86a6894dbc5bba2bea03e08dbd692c528bc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/stat.cpp	
@@ -0,0 +1,748 @@
+/***
+*stat64.c - get file status
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _stat64() - get file status
+*
+*******************************************************************************/
+
+#include <ctype.h>
+#include <direct.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <io.h>
+#include <share.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <corecrt_internal_time.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_win32_buffer.h>
+
+#include "faststat.h"
+
+#ifdef ENABLE_FAST_STAT
+
+#include <winnt.h>
+#include <winioctl.h>
+
+#ifndef MAXUSHORT
+#define MAXUSHORT           0xffff
+#endif
+
+#endif // ENABLE_FAST_STAT
+
+namespace
+{
+    struct file_handle_traits
+    {
+        typedef int type;
+
+        inline static bool close(_In_ type const fh) throw()
+        {
+            _close(fh);
+            return true;
+        }
+
+        inline static type get_invalid_value() throw()
+        {
+            return -1;
+        }
+    };
+
+    struct find_handle_traits
+    {
+        typedef HANDLE type;
+
+        static bool close(_In_ type const handle) throw()
+        {
+            return ::FindClose(handle) != FALSE;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return INVALID_HANDLE_VALUE;
+        }
+    };
+
+
+
+    typedef __crt_unique_handle_t<file_handle_traits> scoped_file_handle;
+    typedef __crt_unique_handle_t<find_handle_traits> unique_find_handle;
+}
+
+static bool __cdecl is_slash(wchar_t const c) throw()
+{
+    return c == L'\\' || c == L'/';
+}
+
+static bool __cdecl compute_size(BY_HANDLE_FILE_INFORMATION const& file_info, long& size) throw()
+{
+    size = 0;
+    _VALIDATE_RETURN_NOEXC(file_info.nFileSizeHigh == 0 && file_info.nFileSizeLow <= LONG_MAX, EOVERFLOW, false);
+
+    size = static_cast<long>(file_info.nFileSizeLow);
+    return true;
+}
+
+static bool __cdecl compute_size(BY_HANDLE_FILE_INFORMATION const& file_info, __int64& size) throw()
+{
+    size = 0;
+    _VALIDATE_RETURN_NOEXC(file_info.nFileSizeHigh <= LONG_MAX, EOVERFLOW, false);
+
+    size = static_cast<__int64>(
+        static_cast<unsigned __int64>(file_info.nFileSizeHigh) * 0x100000000i64 +
+        static_cast<unsigned __int64>(file_info.nFileSizeLow));
+    return true;
+}
+
+#ifdef ENABLE_FAST_STAT
+
+static bool __cdecl compute_size(LARGE_INTEGER const& file_size, long& size) throw()
+{
+    size = 0;
+    _VALIDATE_RETURN_NOEXC(file_size.HighPart == 0 && file_size.LowPart <= LONG_MAX, EOVERFLOW, false);
+
+    size = static_cast<long>(file_size.LowPart);
+    return true;
+}
+
+static bool __cdecl compute_size(LARGE_INTEGER const& file_size, __int64& size) throw()
+{
+    size = 0;
+    _VALIDATE_RETURN_NOEXC(file_size.HighPart <= LONG_MAX, EOVERFLOW, false);
+
+    size = static_cast<__int64>(
+        static_cast<unsigned __int64>(file_size.HighPart) * 0x100000000i64 +
+        static_cast<unsigned __int64>(file_size.LowPart));
+    return true;
+}
+
+#endif // ENABLE_FAST_STAT
+
+_Success_(return != 0)
+static wchar_t* __cdecl call_wfullpath(
+    _Out_writes_z_(buffer_size) wchar_t*        const   buffer,
+                                wchar_t const*  const   path,
+                                size_t          const   buffer_size,
+    _Inout_                     wchar_t**       const   buffer_result
+    ) throw()
+{
+    errno_t const saved_errno = errno;
+    errno = 0;
+
+    wchar_t* const result = _wfullpath(buffer, path, buffer_size);
+    if (result != nullptr)
+    {
+        errno = saved_errno;
+        return result;
+    }
+
+    if (errno != ERANGE)
+        return nullptr;
+
+    errno = saved_errno;
+
+    *buffer_result = _wfullpath(nullptr, path, 0);
+    return *buffer_result;
+}
+
+static bool __cdecl has_executable_extension(wchar_t const* const path) throw()
+{
+    if (!path)
+    {
+        return false;
+    }
+
+    wchar_t const* const last_dot = wcsrchr(path, L'.');
+    if (!last_dot)
+    {
+        return false;
+    }
+
+    if (_wcsicmp(last_dot, L".exe") != 0 &&
+        _wcsicmp(last_dot, L".cmd") != 0 &&
+        _wcsicmp(last_dot, L".bat") != 0 &&
+        _wcsicmp(last_dot, L".com") != 0)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+static bool __cdecl is_root_or_empty(wchar_t const* const path) throw()
+{
+    if (!path)
+    {
+        return false;
+    }
+
+    bool const has_drive_letter_and_colon = __ascii_iswalpha(path[0]) && path[1] == L':';
+    wchar_t const* const path_start = has_drive_letter_and_colon
+        ? path + 2
+        : path;
+
+    if (path_start[0] == L'\0')
+    {
+        return true;
+    }
+
+    if (is_slash(path_start[0]) && path_start[1] == L'\0')
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static unsigned short __cdecl convert_to_stat_mode(
+    int            const attributes,
+    wchar_t const* const path
+    ) throw()
+{
+    unsigned const os_mode = attributes & 0xff;
+
+    // check to see if this is a directory - note we must make a special
+    // check for the root, which DOS thinks is not a directory:
+    bool const is_directory = (os_mode & FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+    unsigned short stat_mode = is_directory || is_root_or_empty(path)
+        ? _S_IFDIR | _S_IEXEC
+        : _S_IFREG;
+
+    // If attribute byte does not have read-only bit, it is read-write:
+    stat_mode |= (os_mode & FILE_ATTRIBUTE_READONLY) != 0
+        ? _S_IREAD
+        : _S_IREAD | _S_IWRITE;
+
+    // See if file appears to be an executable by checking its extension:
+    if (has_executable_extension(path))
+        stat_mode |= _S_IEXEC;
+
+    // propagate user read/write/execute bits to group/other fields:
+    stat_mode |= (stat_mode & 0700) >> 3;
+    stat_mode |= (stat_mode & 0700) >> 6;
+
+    return stat_mode;
+}
+
+// Returns false if and only if the path is invalid.
+static bool __cdecl get_drive_number_from_path(wchar_t const* const path, int& drive_number) throw()
+{
+    drive_number = 0;
+
+    // If path has a drive letter and a colon, return the value of that drive,
+    // as expected from _getdrive(). A = 1, B = 2, etc.
+    // If the path is relative, then use _getdrive() to get the current drive.
+    if (__ascii_iswalpha(path[0]) && path[1] == L':')
+    {
+        // If the path is just a drive letter followed by a colon, it is not a
+        // valid input to the stat functions:
+        if (path[2] == L'\0')
+        {
+            __acrt_errno_map_os_error(ERROR_FILE_NOT_FOUND);
+            return false;
+        }
+
+        drive_number = __ascii_towlower(path[0]) - L'a' + 1;
+    }
+    else
+    {
+        drive_number = _getdrive();
+    }
+
+    return true;
+}
+
+static bool __cdecl is_root_unc_name(wchar_t const* const path) throw()
+{
+    // The shortest allowed string is of the form //x/y:
+    if (wcslen(path) < 5)
+        return 0;
+
+    // The string must begin with exactly two consecutive slashes:
+    if (!is_slash(path[0]) || !is_slash(path[1]) || is_slash(path[2]))
+        return 0;
+
+    // Find the slash between the server name and share name:
+    wchar_t const* p = path + 2; // Account for the two slashes
+    while (*++p)
+    {
+        if (is_slash(*p))
+            break;
+    }
+
+    // We reached the end before finding a slash, or the slash is at the end:
+    if (p[0] == L'\0' || p[1] == L'\0')
+        return 0;
+
+    // Is there a further slash?
+    while (*++p)
+    {
+        if (is_slash(*p))
+            break;
+    }
+
+    // Just the final slash (or no final slash):
+    if (p[0] == L'\0' || p[1] == L'\0')
+        return 1;
+
+    return 0;
+}
+
+static bool __cdecl is_usable_drive_or_unc_root(wchar_t const* const path) throw()
+{
+    if (wcspbrk(path, L"./\\") == nullptr)
+        return false;
+
+    wchar_t  full_path_buffer[_MAX_PATH];
+    __crt_unique_heap_ptr<wchar_t, __crt_public_free_policy> full_path_pointer;
+    wchar_t* const full_path = call_wfullpath(
+        full_path_buffer,
+        path,
+        _MAX_PATH,
+        full_path_pointer.get_address_of());
+
+    if (full_path == nullptr)
+        return false;
+
+    // Check to see if the path is a root of a directory ("C:\") or a UNC root
+    // directory ("\\server\share\"):
+    if (wcslen(full_path) != 3 && !is_root_unc_name(full_path))
+        return false;
+
+    if (GetDriveTypeW(path) <= 1)
+        return false;
+
+    return true;
+}
+
+template <typename TimeType>
+static TimeType __cdecl convert_filetime_to_time_t(
+    FILETIME const file_time,
+    TimeType const fallback_time
+    ) throw()
+{
+    using time_traits = __crt_time_time_t_traits<TimeType>;
+
+    if (file_time.dwLowDateTime == 0 && file_time.dwHighDateTime == 0)
+    {
+        return fallback_time;
+    }
+
+    SYSTEMTIME system_time;
+    SYSTEMTIME local_time;
+    if (!FileTimeToSystemTime(&file_time, &system_time) ||
+        !SystemTimeToTzSpecificLocalTime(nullptr, &system_time, &local_time))
+    {
+        // Ignore failures from these APIs, for consistency with the logic below
+        // that ignores failures in the conversion from SYSTEMTIME to time_t.
+        return -1;
+    }
+
+    // If the conversion to time_t fails, it will return -1.  We'll use this as
+    // the time_t value instead of failing the entire stat call, to allow callers
+    // to get information about files whose time information is not representable.
+    // (Callers use this API to test for file existence or to get file sizes.)
+    return time_traits::loctotime(
+        local_time.wYear,
+        local_time.wMonth,
+        local_time.wDay,
+        local_time.wHour,
+        local_time.wMinute,
+        local_time.wSecond,
+        -1);
+}
+
+#ifdef ENABLE_FAST_STAT
+
+template <typename TimeType>
+static TimeType __cdecl convert_filetime_to_time_t(
+    const LARGE_INTEGER& file_time_int,
+    const TimeType& fallback_time
+    ) throw()
+{
+    FILETIME file_time;
+    file_time.dwHighDateTime = file_time_int.HighPart;
+    file_time.dwLowDateTime = file_time_int.LowPart;
+    return convert_filetime_to_time_t(file_time, fallback_time);
+}
+
+#endif // ENABLE_FAST_STAT
+
+template <typename StatStruct>
+static bool __cdecl common_stat_handle_file_not_opened(
+    wchar_t const* const path,
+    StatStruct&          result
+    ) throw()
+{
+    using time_traits = __crt_time_time_t_traits<decltype(result.st_mtime)>;
+
+    if (!is_usable_drive_or_unc_root(path))
+    {
+        __acrt_errno_map_os_error(ERROR_FILE_NOT_FOUND);
+        return false;
+    }
+
+    // Root directories (such as C:\ or \\server\share\) are fabricated:
+    result.st_mode  = convert_to_stat_mode(FILE_ATTRIBUTE_DIRECTORY, path);
+    result.st_nlink = 1;
+
+    // Try to get the disk from the name; if there is none, get the current disk:
+    int drive_number{};
+    if (!get_drive_number_from_path(path, drive_number))
+    {
+        return false;
+    }
+
+    result.st_rdev = static_cast<_dev_t>(drive_number - 1);
+    result.st_dev  = static_cast<_dev_t>(drive_number - 1); // A=0, B=1, etc.
+
+    result.st_mtime = time_traits::loctotime(1980, 1, 1, 0, 0, 0, -1);
+    result.st_atime = result.st_mtime;
+    result.st_ctime = result.st_mtime;
+    return true;
+}
+
+template <typename StatStruct>
+static bool __cdecl common_stat_handle_file_opened(
+    wchar_t const* const path,
+    int            const fh,
+    HANDLE         const handle,
+    StatStruct&          result
+    ) throw()
+{
+    using time_type = decltype(result.st_mtime);
+
+    // Figure out what kind of file underlies the file handle:
+    int const file_type = GetFileType(handle) & ~FILE_TYPE_REMOTE;
+
+    if (file_type == FILE_TYPE_DISK)
+    {
+        // Okay, it's a disk file; we'll do the normal logic below.
+    }
+    else if (file_type == FILE_TYPE_CHAR || file_type == FILE_TYPE_PIPE)
+    {
+        // We treat pipes and devices similarly:  no further information is
+        // available from any API, so we set the fields as reasonably as
+        // possible and return.
+        result.st_mode = file_type == FILE_TYPE_CHAR
+            ? _S_IFCHR
+            : _S_IFIFO;
+
+        result.st_nlink = 1;
+
+        result.st_rdev = static_cast<unsigned>(fh);
+        result.st_dev  = static_cast<unsigned>(fh);
+
+        if (file_type != FILE_TYPE_CHAR)
+        {
+            unsigned long available;
+            if (PeekNamedPipe(handle, nullptr, 0, nullptr, &available, nullptr))
+            {
+                result.st_size = static_cast<_off_t>(available);
+            }
+        }
+
+        return true;
+    }
+    else if (file_type == FILE_TYPE_UNKNOWN)
+    {
+        errno = EBADF;
+        return false;
+    }
+    else
+    {
+        // Per the documentation we should not reach here, but we'll add
+        // this just to be safe:
+        __acrt_errno_map_os_error(GetLastError());
+        return false;
+    }
+
+    // At this point, we know we have a file on disk. Set the common fields:
+    result.st_nlink = 1;
+
+    if (path)
+    {
+        // Try to get the disk from the name; if there is none, get the current disk:
+        int drive_number{};
+        if (!get_drive_number_from_path(path, drive_number))
+        {
+            return false;
+        }
+
+        result.st_rdev = static_cast<_dev_t>(drive_number - 1);
+        result.st_dev  = static_cast<_dev_t>(drive_number - 1); // A=0, B=1, etc.
+    }
+
+    BY_HANDLE_FILE_INFORMATION file_info{};
+    if (!GetFileInformationByHandle(handle, &file_info))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return false;
+    }
+
+    result.st_mode  = convert_to_stat_mode(file_info.dwFileAttributes, path);
+
+    result.st_mtime = convert_filetime_to_time_t(file_info.ftLastWriteTime, static_cast<time_type>(0));
+    result.st_atime = convert_filetime_to_time_t(file_info.ftLastAccessTime, result.st_mtime);
+    result.st_ctime = convert_filetime_to_time_t(file_info.ftCreationTime, result.st_mtime);
+
+    if (!compute_size(file_info, result.st_size))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+#ifdef ENABLE_FAST_STAT
+
+template <typename StatStruct>
+static bool __cdecl common_stat_by_path(
+    wchar_t const* const path,
+    StatStruct&          result
+    ) throw()
+{
+    using time_type = decltype(result.st_mtime);
+
+    LARGE_INTEGER file_size;
+    LARGE_INTEGER creation_time;
+    LARGE_INTEGER last_access_time;
+    LARGE_INTEGER last_write_time;
+    unsigned long device_type;
+    unsigned long number_of_links;
+    unsigned long file_attributes;
+    bool status = false;
+
+    if ((path != nullptr) &&
+        GetFileInfoByName(path,
+                          device_type,
+                          number_of_links,
+                          file_attributes,
+                          creation_time.QuadPart,
+                          last_access_time.QuadPart,
+                          last_write_time.QuadPart,
+                          file_size.QuadPart))
+    {
+        do
+        {
+            // Verify that the device type is one of the supported set.
+            bool use_file_info;
+            switch (device_type)
+            {
+            case FILE_DEVICE_DISK:
+            case FILE_DEVICE_DISK_FILE_SYSTEM:
+            case FILE_DEVICE_VIRTUAL_DISK:
+                use_file_info = true;
+                break;
+
+            default:
+                use_file_info = false;
+                break;
+            }
+            if (!use_file_info)
+            {
+                break;
+            }
+
+            if (!compute_size(file_size, result.st_size))
+            {
+                break;
+            }
+
+            // Try to get the disk from the path.
+            int drive_number{};
+            if (!get_drive_number_from_path(path, drive_number))
+            {
+                break;
+            }
+
+            result.st_nlink = number_of_links > MAXUSHORT ? MAXUSHORT : (USHORT) number_of_links;
+            result.st_rdev = static_cast<_dev_t>(drive_number - 1);
+            result.st_dev  = static_cast<_dev_t>(drive_number - 1); // A=0, B=1, etc.
+            result.st_mode  = convert_to_stat_mode(file_attributes, path);
+            result.st_mtime = convert_filetime_to_time_t(last_write_time, static_cast<time_type>(0));
+            result.st_atime = convert_filetime_to_time_t(last_access_time, result.st_mtime);
+            result.st_ctime = convert_filetime_to_time_t(creation_time, result.st_mtime);
+
+            status = true;
+
+        } while (false);
+    }
+
+    return status;
+}
+
+#endif // ENABLE_FAST_STAT
+
+template <typename StatStruct>
+static int __cdecl common_stat(
+    wchar_t const* const path,
+    StatStruct*    const result
+    ) throw()
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(result != nullptr, EINVAL, -1);
+    *result = StatStruct{};
+
+    _VALIDATE_CLEAR_OSSERR_RETURN(path   != nullptr, EINVAL, -1);
+
+#ifdef ENABLE_FAST_STAT
+
+    // Try to do a fast stat by path; if that fails,
+    // fall back to the older (slower) implementation.
+    if (common_stat_by_path(path, *result))
+    {
+        return 0;
+    }
+
+#endif // ENABLE_FAST_STAT
+
+    __crt_unique_handle const file_handle(CreateFileW(
+        path,
+        FILE_READ_ATTRIBUTES,
+        FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nullptr,
+        OPEN_EXISTING,
+        FILE_FLAG_BACKUP_SEMANTICS,
+        nullptr));
+
+    if (file_handle)
+    {
+        if (!common_stat_handle_file_opened(path, -1, file_handle.get(), *result))
+        {
+            *result = StatStruct{};
+            return -1;
+        }
+    }
+    else
+    {
+        if (!common_stat_handle_file_not_opened(path, *result))
+        {
+            *result = StatStruct{};
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+
+template <typename StatStruct>
+static int __cdecl common_stat(
+    char const* const path,
+    StatStruct* const result
+    ) throw()
+{
+    if (path == nullptr) {
+        return common_stat(static_cast<wchar_t const*>(nullptr), result);
+    }
+
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return common_stat(wide_path.data(), result);
+}
+
+
+
+extern "C" int __cdecl _stat32(char const* const path, struct _stat32* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _stat32i64(char const* const path, struct _stat32i64* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _stat64(char const* const path, struct _stat64* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _stat64i32(char const* const path, struct _stat64i32* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _wstat32(wchar_t const* const path, struct _stat32* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _wstat32i64(wchar_t const* const path, struct _stat32i64* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _wstat64(wchar_t const* const path, struct _stat64* const result)
+{
+    return common_stat(path, result);
+}
+
+extern "C" int __cdecl _wstat64i32(wchar_t const* const path, struct _stat64i32* const result)
+{
+    return common_stat(path, result);
+}
+
+
+
+template <typename StatStruct>
+static int __cdecl common_fstat(int const fh, StatStruct* const result) throw()
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(result != nullptr, EINVAL, -1);
+    *result = StatStruct{};
+
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && fh < _nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            return -1;
+        }
+
+        if (!common_stat_handle_file_opened(nullptr, fh, reinterpret_cast<HANDLE>(_osfhnd(fh)), *result))
+        {
+            *result = StatStruct{};
+            return -1;
+        }
+
+        return 0;
+    });
+}
+
+extern "C" int __cdecl _fstat32(int const fh, struct _stat32* const result)
+{
+    return common_fstat(fh, result);
+}
+
+extern "C" int __cdecl _fstat32i64(int const fh, struct _stat32i64* const result)
+{
+    return common_fstat(fh, result);
+}
+
+extern "C" int __cdecl _fstat64(int const fh, struct _stat64* const result)
+{
+    return common_fstat(fh, result);
+}
+
+extern "C" int __cdecl _fstat64i32(int const fh, struct _stat64i32* const result)
+{
+    return common_fstat(fh, result);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/unlink.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/unlink.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..399d220fd71ad4f11983f570b6de391a55bd3327
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/unlink.cpp	
@@ -0,0 +1,35 @@
+//
+// unlink.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The remove() and unlink() functions, which remove (delete) files.
+//
+#include <corecrt_internal.h>
+#include <stdio.h>
+#include <corecrt_internal_win32_buffer.h>
+
+// Deletes the specified file.  Returns zero if successful; returns -1 and sets
+// errno and _doserrno on failure.
+extern "C" int __cdecl remove(char const* const path)
+{
+    if (path == nullptr)
+        return _wremove(nullptr);
+
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _wremove(wide_path.data());
+}
+
+
+
+extern "C" int __cdecl _unlink(char const* const path)
+{
+    return remove(path);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/waccess.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/waccess.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e32347347577668247c97e68fb9cc05d8a5008e2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/waccess.cpp	
@@ -0,0 +1,55 @@
+//
+// waccess.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _waccess() and _waccess_s() functions, which test file accessibility.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+
+
+
+// Tests whether the specified file can be accessed with the specified mode.  The
+// access_mode must be one of:  0 (exist only), 2 (write), 4 (read), 6 (read and
+// write).  Returns zero if the file can be accessed with the given mode; returns
+// an error code otherwise or if an error occurs.
+extern "C" errno_t __cdecl _waccess_s(wchar_t const* const path, int const access_mode)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(path != nullptr,           EINVAL);
+    _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE((access_mode & (~6)) == 0, EINVAL);
+
+    WIN32_FILE_ATTRIBUTE_DATA attributes;
+    if (!GetFileAttributesExW(path, GetFileExInfoStandard, &attributes))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return errno;
+    }
+
+    // All directories have both read and write access:
+    if (attributes.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+        return 0;
+
+    // If we require write access, make sure the read only flag is not set:
+    bool const file_is_read_only = (attributes.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0;
+    bool const mode_requires_write = (access_mode & 2) != 0;
+    
+    if (file_is_read_only && mode_requires_write)
+    {
+        _doserrno = ERROR_ACCESS_DENIED;
+        errno = EACCES;
+        return errno;
+    }
+
+    // Otherwise, the file is accessible:
+    return 0;
+
+}
+
+
+
+// The same as _waccess_s, but transforms all errors into a -1 return value.
+extern "C" int __cdecl _waccess(wchar_t const* const path, int const access_mode)
+{
+    return _waccess_s(path, access_mode) == 0 ? 0 : -1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wchmod.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wchmod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d57b5638020ee903c6665313d3ad205f48dff7d2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wchmod.cpp	
@@ -0,0 +1,45 @@
+//
+// wchmod.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _wchmod() function, which changes file attributes.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+#include <sys\stat.h>
+
+
+
+// Changes the mode of a file.  The only supported mode bit is _S_IWRITE, which
+// controls the user write (read-only) attribute of the file.  Returns zero if
+// successful; returns -1 and sets errno and _doserrno on failure.
+extern "C" int __cdecl _wchmod(wchar_t const* const path, int const mode)
+{
+    _VALIDATE_CLEAR_OSSERR_RETURN(path != nullptr, EINVAL, -1);
+
+    WIN32_FILE_ATTRIBUTE_DATA attributes;
+    if (!GetFileAttributesExW(path, GetFileExInfoStandard, &attributes))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    // Set or clear the read-only flag:
+    if (mode & _S_IWRITE)
+    {
+        attributes.dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
+    }
+    else
+    {
+        attributes.dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
+    }
+
+    if (!SetFileAttributesW(path, attributes.dwFileAttributes))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wmkdir.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wmkdir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26cc9fc13a3f30c33b53426c89ce727edc56e8b3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wmkdir.cpp	
@@ -0,0 +1,24 @@
+//
+// wmkdir.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _wmkdir() function, which creates a directory.
+//
+#include <corecrt_internal.h>
+#include <direct.h>
+
+
+
+// Creates a directory.  Returns 0 on success; returns -1 and sets errno and
+// _doserrno on failure.
+extern "C" int __cdecl _wmkdir(wchar_t const* const path)
+{
+    if (!CreateDirectoryW(path, nullptr))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wrename.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wrename.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..028ec1615667c671edadc61b78e05b766177b3f6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wrename.cpp	
@@ -0,0 +1,25 @@
+//
+// wrename.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _wrename() function, which renames a file.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+
+
+
+// Renames the file named 'old_name' to be named 'new_name'.  Returns zero if
+// successful; returns -1 and sets errno and _doserrno on failure.
+extern "C" int __cdecl _wrename(wchar_t const* const old_name, wchar_t const* const new_name)
+{
+    // The MOVEFILE_COPY_ALLOWED flag alloes moving to a different volume.
+    if (!MoveFileExW(old_name, new_name, MOVEFILE_COPY_ALLOWED))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wrmdir.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wrmdir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee7e2dfcde7ae2c1305acff4f1b0286dde82131a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wrmdir.cpp	
@@ -0,0 +1,26 @@
+//
+// wrmdir.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _wrmdir() function, which removes a directory.
+//
+#include <corecrt_internal.h>
+#include <direct.h>
+
+
+
+// Removes the directory specified by the path.  The directory must be empty, it
+// must not be the current working directory, and it must not be the root of any
+// drive.  Returns 0 on success; returns -1 and sets errno and _doserrno on
+// failure.
+extern "C" int __cdecl _wrmdir(wchar_t const* const path)
+{
+    if (!RemoveDirectoryW(path))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+    
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wunlink.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wunlink.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c12723e2476b710199a426f7d0831713a1b025e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/filesystem/wunlink.cpp	
@@ -0,0 +1,31 @@
+//
+// wunlink.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _wremove() and _wunlink() functions, which remove (delete) files.
+//
+#include <corecrt_internal.h>
+#include <stdio.h>
+
+
+
+// Deletes the specified file.  Returns zero if successful; returns -1 and sets
+// errno and _doserrno on failure.
+extern "C" int __cdecl _wremove(wchar_t const* const path)
+{
+    if (!DeleteFileW(path))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+extern "C" int __cdecl _wunlink(wchar_t const* const path)
+{
+    return _wremove(path);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/align.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/align.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d491d7722cead4d8b0dee38e92a7a113ab558fe
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/align.cpp	
@@ -0,0 +1,638 @@
+/***
+*align.c - Aligned allocation, reallocation or freeing of memory in the heap
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines the _aligned_malloc(),
+*                   _aligned_realloc(),
+*                   _aligned_recalloc(),
+*                   _aligned_offset_malloc(),
+*                   _aligned_offset_realloc(),
+*                   _aligned_offset_recalloc(),
+*                   _aligned_free(),
+*                   _aligned_msize() functions.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+
+
+#define IS_2_POW_N(X)   ((X) != 0 && ((X) & ((X) - 1)) == 0)
+#define PTR_SZ          sizeof(void *)
+
+/***
+*
+* |1|___6___|2|3|4|_________5__________|_6_|
+*
+* 1 -> Pointer to start of the block allocated by malloc.
+* 2 -> Value of 1.
+* 3 -> Gap used to get 1 aligned on sizeof(void *).
+* 4 -> Pointer to the start of data block.
+* 4+5 -> Data block.
+* 6 -> Wasted memory at rear of data block.
+* 6 -> Wasted memory.
+*
+*******************************************************************************/
+
+static void _aligned_free_base(
+    _Pre_maybenull_ _Post_invalid_ void* block
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size)
+static void* _aligned_malloc_base(
+    _In_ size_t size,
+    _In_ size_t alignment
+    );
+
+_Check_return_
+static size_t _aligned_msize_base(
+    _Pre_notnull_ void*  block,
+    _In_          size_t alignment,
+    _In_          size_t offset
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size)
+static void* _aligned_offset_malloc_base(
+    _In_ size_t size,
+    _In_ size_t alignment,
+    _In_ size_t offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size)
+static void* _aligned_offset_realloc_base(
+    _Pre_maybenull_ _Post_invalid_ void*  block,
+    _In_                           size_t size,
+    _In_                           size_t alignment,
+    _In_                           size_t offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size * count)
+static void* _aligned_offset_recalloc_base(
+    _Pre_maybenull_ _Post_invalid_ void*  block,
+    _In_                           size_t count,
+    _In_                           size_t size,
+    _In_                           size_t alignment,
+    _In_                           size_t offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size)
+static void* _aligned_realloc_base(
+    _Pre_maybenull_ _Post_invalid_ void*  block,
+    _In_                           size_t size,
+    _In_                           size_t alignment
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size * count)
+static void* _aligned_recalloc_base(
+    _Pre_maybenull_ _Post_invalid_ void*  block,
+    _In_                           size_t count,
+    _In_                           size_t size,
+    _In_                           size_t alignment
+    );
+
+/***
+* void *_aligned_malloc_base(size_t size, size_t alignment)
+*       - Get a block of aligned memory from the heap.
+*
+* Purpose:
+*       Allocate of block of aligned memory aligned on the alignment of at least
+*       size bytes from the heap and return a pointer to it.
+*
+* Entry:
+*       size_t size - size of block requested
+*       size_t alignment - alignment of memory (needs to be a power of 2)
+*
+* Exit:
+*       Success: Pointer to memory block
+*       Failure: Null, errno is set
+*
+* Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static __forceinline void* __cdecl _aligned_malloc_base(
+    size_t const size,
+    size_t const alignment
+    )
+{
+    return _aligned_offset_malloc_base(size, alignment, 0);
+}
+/***
+* void *_aligned_offset_malloc_base(size_t size, size_t alignment, int offset)
+*       - Get a block of memory from the heap.
+*
+* Purpose:
+*       Allocate a block of memory which is shifted by offset from alignment of
+*       at least size bytes from the heap and return a pointer to it.
+*
+* Entry:
+*       size_t size - size of block of memory
+*       size_t alignment - alignment of memory (needs to be a power of 2)
+*       size_t offset - offset of memory from the alignment
+*
+* Exit:
+*       Success: Pointer to memory block
+*       Failure: Null, errno is set
+*
+* Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+
+static __forceinline void* __cdecl _aligned_offset_malloc_base(
+    size_t size,
+    size_t align,
+    size_t offset
+    )
+{
+    uintptr_t ptr, retptr, gap;
+    size_t nonuser_size,block_size;
+
+    /* validation section */
+    _VALIDATE_RETURN(IS_2_POW_N(align), EINVAL, nullptr);
+    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
+
+    align = (align > PTR_SZ ? align : PTR_SZ) -1;
+
+    /* gap = number of bytes needed to round up offset to align with PTR_SZ*/
+    gap = (0 - offset)&(PTR_SZ -1);
+
+    nonuser_size = PTR_SZ +gap +align;
+    block_size = nonuser_size + size;
+    _VALIDATE_RETURN_NOEXC(size <= block_size, ENOMEM, nullptr)
+
+    if ( (ptr =(uintptr_t)malloc(block_size)) == (uintptr_t)nullptr)
+        return nullptr;
+
+    retptr =((ptr +nonuser_size+offset)&~align)- offset;
+    ((uintptr_t *)(retptr - gap))[-1] = ptr;
+
+    return (void *)retptr;
+}
+
+/***
+*
+* void *_aligned_realloc_base(void * memblock, size_t size, size_t alignment)
+*       - Reallocate a block of aligned memory from the heap.
+*
+* Purpose:
+*       Reallocates of block of aligned memory aligned on the alignment of at
+*       least size bytes from the heap and return a pointer to it. Size can be
+*       either greater or less than the original size of the block.
+*       The reallocation may result in moving the block as well as changing the
+*       size.
+*
+* Entry:
+*       void *memblock - pointer to block in the heap previously allocated by
+*               call to _aligned_malloc(), _aligned_offset_malloc(),
+*               _aligned_realloc() or _aligned_offset_realloc().
+*       size_t size - size of block requested
+*       size_t alignment - alignment of memory
+*
+* Exit:
+*       Success: Pointer to re-allocated memory block
+*       Failure: Null, errno is set
+*
+* Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static __forceinline void* __cdecl _aligned_realloc_base(
+    void*  const block,
+    size_t const size,
+    size_t const alignment
+    )
+{
+    return _aligned_offset_realloc_base(block, size, alignment, 0);
+}
+
+/***
+*
+* void *_aligned_recalloc_base(void * memblock, size_t count, size_t size, size_t alignment)
+*       - Reallocate a block of aligned memory from the heap.
+*
+* Purpose:
+*       Reallocates of block of aligned memory aligned on the alignment of at
+*       least size bytes from the heap and return a pointer to it. Size can be
+*       either greater or less than the original size of the block.
+*       The reallocation may result in moving the block as well as changing the
+*       size.
+*
+* Entry:
+*       void *memblock - pointer to block in the heap previously allocated by
+*               call to _aligned_malloc(), _aligned_offset_malloc(),
+*               _aligned_realloc() or _aligned_offset_realloc().
+*       size_t count - count of items
+*       size_t size - size of item
+*       size_t alignment - alignment of memory
+*
+* Exit:
+*       Success: Pointer to re-allocated memory block
+*       Failure: Null, errno is set
+*
+* Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static __forceinline void* __cdecl _aligned_recalloc_base(
+    void*  const block,
+    size_t const count,
+    size_t const size,
+    size_t const alignment
+    )
+{
+    return _aligned_offset_recalloc_base(block, count, size, alignment, 0);
+}
+
+/***
+*
+* void *_aligned_offset_realloc_base (void * memblock, size_t size,
+*                                     size_t alignment, int offset)
+*       - Reallocate a block of memory from the heap.
+*
+* Purpose:
+*       Reallocates a block of memory which is shifted by offset from
+*       alignment of at least size bytes from the heap and return a pointer
+*       to it. Size can be either greater or less than the original size of the
+*       block.
+*
+* Entry:
+*       void *memblock - pointer to block in the heap previously allocated by
+*               call to _aligned_malloc(), _aligned_offset_malloc(),
+*               _aligned_realloc() or _aligned_offset_realloc().
+*       size_t size - size of block of memory
+*       size_t alignment - alignment of memory
+*       size_t offset - offset of memory from the alignment
+*
+* Exit:
+*       Success: Pointer to re-allocated memory block
+*       Failure: Null, errno is set
+*
+* Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static __forceinline void* __cdecl _aligned_offset_realloc_base(
+    void*  block,
+    size_t size,
+    size_t align,
+    size_t offset
+    )
+{
+    uintptr_t ptr, retptr, gap, stptr, diff;
+    uintptr_t movsz, reqsz;
+    int bFree = 0;
+
+    /* special cases */
+    if (block == nullptr)
+    {
+        return _aligned_offset_malloc_base(size, align, offset);
+    }
+    if (size == 0)
+    {
+        _aligned_free_base(block);
+        return nullptr;
+    }
+
+    /* validation section */
+    _VALIDATE_RETURN(IS_2_POW_N(align), EINVAL, nullptr);
+    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
+
+    stptr = (uintptr_t)block;
+
+    /* ptr points to the pointer to starting of the memory block */
+    stptr = (stptr & ~(PTR_SZ -1)) - PTR_SZ;
+
+    /* ptr is the pointer to the start of memory block*/
+    stptr = *((uintptr_t *)stptr);
+
+    align = (align > PTR_SZ ? align : PTR_SZ) -1;
+    /* gap = number of bytes needed to round up offset to align with PTR_SZ*/
+    gap = (0 -offset)&(PTR_SZ -1);
+
+    diff = (uintptr_t)block - stptr;
+    /* Mov size is min of the size of data available and sizw requested.
+     */
+    #pragma warning(push)
+    #pragma warning(disable: 22018) // Silence prefast about overflow/underflow
+    movsz = _msize_base((void *)stptr) - ((uintptr_t)block - stptr);
+    #pragma warning(pop)
+
+    movsz = movsz > size ? size : movsz;
+    reqsz = PTR_SZ + gap + align + size;
+
+    _VALIDATE_RETURN_NOEXC(size <= reqsz, ENOMEM, nullptr);
+
+    /* First check if we can expand(reducing or expanding using expand) data
+     * safely, ie no data is lost. eg, reducing alignment and keeping size
+     * same might result in loss of data at the tail of data block while
+     * expanding.
+     *
+     * If no, use malloc to allocate the new data and move data.
+     *
+     * If yes, expand and then check if we need to move the data.
+     */
+    if ((stptr +align +PTR_SZ +gap)<(uintptr_t)block)
+    {
+        if ((ptr = (uintptr_t)malloc(reqsz)) == (uintptr_t) nullptr)
+            return nullptr;
+        bFree = 1;
+    }
+    else
+    {
+        /* we need to save errno, which can be modified by _expand */
+        errno_t save_errno = errno;
+        if ((ptr = (uintptr_t)_expand((void *)stptr, reqsz)) == (uintptr_t)nullptr)
+        {
+            errno = save_errno;
+            if ((ptr = (uintptr_t)malloc(reqsz)) == (uintptr_t) nullptr)
+                return nullptr;
+            bFree = 1;
+        }
+        else
+            stptr = ptr;
+    }
+
+
+    if ( ptr == ((uintptr_t)block - diff)
+         && !( ((size_t)block + gap +offset) & ~(align) ))
+    {
+        return block;
+    }
+
+    retptr =((ptr +PTR_SZ +gap +align +offset)&~align)- offset;
+    memmove((void *)retptr, (void *)(stptr + diff), movsz);
+    if ( bFree)
+        free ((void *)stptr);
+
+    ((uintptr_t *)(retptr - gap))[-1] = ptr;
+    return (void *)retptr;
+}
+
+
+/***
+*
+* size_t _aligned_msize_base(void *memblock, size_t align, size_t offset)
+*
+* Purpose:
+*       Computes the size of an aligned block.
+*
+* Entry:
+*       void * memblock - pointer to the aligned block of memory
+*
+* Exceptions:
+*       None. If memblock == nullptr 0 is returned.
+*
+*******************************************************************************/
+
+static __forceinline size_t __cdecl _aligned_msize_base(
+    void*  block,
+    size_t align,
+    size_t offset
+    )
+{
+    size_t header_size = 0; /* Size of the header block */
+    size_t footer_size = 0; /* Size of the footer block */
+    size_t total_size  = 0; /* total size of the allocated block */
+    size_t user_size   = 0; /* size of the user block*/
+    uintptr_t gap      = 0; /* keep the alignment of the data block */
+                             /* after the sizeof(void*) aligned pointer */
+                             /* to the beginning of the allocated block */
+    uintptr_t ptr      = 0; /* computes the beginning of the allocated block */
+
+    _VALIDATE_RETURN(block != nullptr, EINVAL, static_cast<size_t>(-1));
+
+    /* HEADER SIZE + FOOTER SIZE = GAP + ALIGN + SIZE OF A POINTER*/
+    /* HEADER SIZE + USER SIZE + FOOTER SIZE = TOTAL SIZE */
+
+    ptr = (uintptr_t)block;            /* ptr points to the start of the aligned memory block */
+    ptr = (ptr & ~(PTR_SZ - 1)) - PTR_SZ; /* ptr is one position behind memblock */
+                                          /* the value in ptr is the start of the real allocated block */
+    ptr = *((uintptr_t *)ptr);            /* after dereference ptr points to the beginning of the allocated block */
+
+    total_size = _msize_base((void*)ptr);
+    header_size = (uintptr_t) block - ptr;
+    gap = (0 - offset) & (PTR_SZ - 1);
+    /* Alignment cannot be less than sizeof(void*) */
+    align = (align > PTR_SZ ? align : PTR_SZ) -1;
+    footer_size = gap + align + PTR_SZ - header_size;
+    user_size = total_size - header_size - footer_size;
+
+    return user_size;
+}
+
+/***
+*
+* void *_aligned_offset_recalloc_base (void * memblock, size_t size, size_t count, size_t alignment, int offset)
+*       - Reallocate a block of memory from the heap.
+*
+* Purpose:
+*       Reallocates a block of memory which is shifted by offset from
+*       alignment of at least size bytes from the heap and return a pointer
+*       to it. Size can be either greater or less than the original size of the
+*       block.
+*
+* Entry:
+*       void *memblock - pointer to block in the heap previously allocated by
+*               call to _aligned_malloc(), _aligned_offset_malloc(),
+*               _aligned_realloc() or _aligned_offset_realloc().
+*       size_t count - count of items
+*       size_t size - size of items
+*       size_t alignment - alignment of memory
+*       size_t offset - offset of memory from the alignment
+*
+* Exit:
+*       Success: Pointer to re-allocated memory block
+*       Failure: Null, errno is set
+*
+* Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+static __forceinline void* __cdecl _aligned_offset_recalloc_base(
+    void*  block,
+    size_t count,
+    size_t size,
+    size_t align,
+    size_t offset
+    )
+{
+    size_t user_size  = 0;    /* wanted size, passed to aligned realoc */
+    size_t start_fill = 0;    /* location where aligned recalloc starts to fill with 0 */
+                              /* filling must start from the end of the previous user block */
+    void * retptr     = nullptr; /* result of aligned recalloc*/
+
+    /* ensure that (size * num) does not overflow */
+    if (count > 0)
+    {
+        _VALIDATE_RETURN_NOEXC((_HEAP_MAXREQ / count) >= size, ENOMEM, nullptr);
+    }
+
+    user_size = size * count;
+
+    if (block != nullptr)
+    {
+        start_fill = _aligned_msize_base(block, align, offset);
+    }
+
+    retptr = _aligned_offset_realloc_base(block, user_size, align, offset);
+
+    if (retptr != nullptr)
+    {
+        if (start_fill < user_size)
+        {
+            memset ((char*)retptr + start_fill, 0, user_size - start_fill);
+        }
+    }
+    return retptr;
+}
+
+/***
+*
+* void *_aligned_free_base(void *memblock)
+*       - Free the memory which was allocated using _aligned_malloc or
+*       _aligned_offset_memory
+*
+* Purpose:
+*       Frees the aligned memory block which was allocated using _aligned_malloc.
+*
+* Entry:
+*       void * memblock - pointer to the block of memory
+*
+* Exceptions:
+*       None. If memblock == nullptr we simply return without doing anything.
+*
+*******************************************************************************/
+
+static __forceinline void __cdecl _aligned_free_base(void* const block)
+{
+    uintptr_t ptr;
+
+    if (block == nullptr)
+        return;
+
+    ptr = (uintptr_t)block;
+
+    /* ptr points to the pointer to starting of the memory block */
+    ptr = (ptr & ~(PTR_SZ -1)) - PTR_SZ;
+
+    /* ptr is the pointer to the start of memory block*/
+    ptr = *((uintptr_t*)ptr);
+    free((void *)ptr);
+}
+
+// These functions are patchable and therefore must be marked noinline.
+// Their *_base implementations are marked __forceinline in order to
+// ensure each export is separated from each other and that there is
+// enough space in each export to host a patch.
+
+extern "C" __declspec(noinline) void __cdecl _aligned_free(void* const block)
+{
+    #ifdef _DEBUG
+    _aligned_free_dbg(block);
+    #else
+    _aligned_free_base(block);
+    #endif
+}
+
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _aligned_malloc(
+    size_t const size,
+    size_t const alignment
+    )
+{
+    #ifdef _DEBUG
+    return _aligned_offset_malloc_dbg(size, alignment, 0, nullptr, 0);
+    #else
+    return _aligned_malloc_base(size, alignment);
+    #endif
+}
+
+extern "C" __declspec(noinline) size_t __cdecl _aligned_msize(
+    void*  const block,
+    size_t const alignment,
+    size_t const offset)
+{
+    #ifdef _DEBUG
+    return _aligned_msize_dbg(block, alignment, offset);
+    #else
+    return _aligned_msize_base(block, alignment, offset);
+    #endif
+}
+
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _aligned_offset_malloc(
+    size_t const size,
+    size_t const alignment,
+    size_t const offset
+    )
+{
+    #ifdef _DEBUG
+    return _aligned_offset_malloc_dbg(size, alignment, offset, nullptr, 0);
+    #else
+    return _aligned_offset_malloc_base(size, alignment, offset);
+    #endif
+}
+
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _aligned_offset_realloc(
+    void*  const block,
+    size_t const size,
+    size_t const alignment,
+    size_t const offset
+    )
+{
+    #ifdef _DEBUG
+    return _aligned_offset_realloc_dbg(block, size, alignment, offset, nullptr, 0);
+    #else
+    return _aligned_offset_realloc_base(block, size, alignment, offset);
+    #endif
+}
+
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _aligned_offset_recalloc(
+    void*  const block,
+    size_t const count,
+    size_t const size,
+    size_t const alignment,
+    size_t const offset
+    )
+{
+    #ifdef _DEBUG
+    return _aligned_offset_recalloc_dbg(block, count, size, alignment, offset, nullptr, 0);
+    #else
+    return _aligned_offset_recalloc_base(block, count, size, alignment, offset);
+    #endif
+}
+
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _aligned_realloc(
+    void*  const block,
+    size_t const size,
+    size_t const alignment
+    )
+{
+    #ifdef _DEBUG
+    return _aligned_offset_realloc_dbg(block, size, alignment, 0, nullptr, 0);
+    #else
+    return _aligned_realloc_base(block, size, alignment);
+    #endif
+}
+
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _aligned_recalloc(
+    void*  const block,
+    size_t const count,
+    size_t const size,
+    size_t const alignment
+    )
+{
+    #ifdef _DEBUG
+    return _aligned_offset_recalloc_dbg(block, count, size, alignment, 0, nullptr, 0);
+    #else
+    return _aligned_recalloc_base(block, count, size, alignment);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/calloc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/calloc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..530ebd77f0e9e78baad0ce17ca8993f110404f42
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/calloc.cpp	
@@ -0,0 +1,30 @@
+//
+// calloc.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of calloc().  Note that _calloc_base is defined in its own
+// source file to resolve various issues when linking.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+// Allocates a block of memory of size 'count * size' in the heap.  The newly
+// allocated block is zero-initialized.  If allocation fails, nullptr is
+// returned.
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _calloc_dbg and _calloc_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to calloc
+// with either other function or vice versa.
+extern "C" _CRT_HYBRIDPATCHABLE __declspec(noinline) _CRTRESTRICT void* __cdecl calloc(
+    size_t const count,
+    size_t const size
+    )
+{
+    #ifdef _DEBUG
+    return _calloc_dbg(count, size, _NORMAL_BLOCK, nullptr, 0);
+    #else
+    return _calloc_base(count, size);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/calloc_base.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/calloc_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d8bbb3000c0c0229e8df2ec20234191bcb40172
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/calloc_base.cpp	
@@ -0,0 +1,53 @@
+//
+// calloc_base.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _calloc_base().  This is defined in a different source file
+// from the calloc() function to allow calloc() to be replaced by the user.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <new.h>
+
+// This function implements the logic of calloc().
+//
+// This function must be marked noinline, otherwise calloc and
+// _calloc_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because calloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _calloc_base(
+    size_t const count,
+    size_t const size
+    )
+{
+    // Ensure that (count * size) does not overflow
+    _VALIDATE_RETURN_NOEXC(count == 0 || (_HEAP_MAXREQ / count) >= size, ENOMEM, nullptr);
+
+    // Ensure that we allocate a nonzero block size:
+    size_t const requested_block_size = count * size;
+    size_t const actual_block_size = requested_block_size == 0
+        ? 1
+        : requested_block_size;
+
+    for (;;)
+    {
+        void* const block = HeapAlloc(__acrt_heap, HEAP_ZERO_MEMORY, actual_block_size);
+
+        // If allocation succeeded, return the pointer to the new block:
+        if (block)
+        {
+            return block;
+        }
+
+        // Otherwise, see if we need to call the new handler, and if so call it.
+        // If the new handler fails, just return nullptr:
+        if (_query_new_mode() == 0 || !_callnewh(actual_block_size))
+        {
+            errno = ENOMEM;
+            return nullptr;
+        }
+
+        // The new handler was successful; try to allocate aagain...
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/debug_heap.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/debug_heap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c8bc77d186364873f27e76b7fcea9d1db63cdcc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/debug_heap.cpp	
@@ -0,0 +1,1979 @@
+//
+// debug_heap.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// The implementation of the CRT Debug Heap.
+//
+#ifndef _DEBUG
+    #error This file is supported only in debug builds
+    #define _DEBUG // For design-time support, when editing/viewing CRT sources
+#endif
+
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <minmax.h>
+#include <new.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Constant Data
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#define _ALLOCATION_FILE_LINENUM "\nMemory allocated at %hs(%d).\n"
+
+#if _FREE_BLOCK != 0 || _NORMAL_BLOCK != 1 || _CRT_BLOCK != 2 || _IGNORE_BLOCK != 3 || _CLIENT_BLOCK != 4
+    #error Block numbers have changed!
+#endif
+
+static char const* const block_use_names[_MAX_BLOCKS]
+{
+    "Free",
+    "Normal",
+    "CRT",
+    "Ignore",
+    "Client",
+};
+
+// The following values are non-zero, constant, odd, large, and atypical.
+// * Non-zero values help find bugs that assume zero-filled data
+// * Constant values are good so that memory filling is deterministic (to help
+//   make bugs reproducible).  Of course, it is bad if the constant filling of
+//   weird values masks a bug.
+// * Mathematically odd numbers are good for finding bugs assuming a cleared
+//   lower bit (e.g. properly aligned pointers to types other than char are not
+//   odd).
+// * Large byte values are less typical and are useful for finding bad addresses.
+// * Atypical values (i.e., not too often) are good because they typically cause
+//   early detection in code.
+// * For the case of the no-man's land and free blocks, if you store to any of
+//   these locations, the memory integrity checker will detect it.
+//
+// The align_land_fill was changed from 0xBD to 0xED to ensure that four bytes of
+// that value (0xEDEDEDED) would form an inaccessible address outside of the lower
+// 3GB of a 32-bit process address space.
+static unsigned char const no_mans_land_fill{0xFD}; // Fill unaligned no-man's land
+static unsigned char const align_land_fill  {0xED}; // Fill aligned no-man's land
+static unsigned char const dead_land_fill   {0xDD}; // Fill free objects with this
+static unsigned char const clean_land_fill  {0xCD}; // Fill new objects with this
+
+// The size of the no-man's land used in unaligned and aligned allocations:
+static size_t const no_mans_land_size = 4;
+static size_t const align_gap_size    = sizeof(void *);
+
+// For _IGNORE_BLOCK blocks, we use these request and line numbers as sentinels.
+static long const request_number_for_ignore_blocks{0};
+static int  const line_number_for_ignore_blocks   {static_cast<int>(0xFEDCBABC)};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// For diagnostic purpose, blocks are allocated in the debug heap with extra
+// information and stored in a doubly-linked list.  This makes all blocks
+// registered with how big they are, when they were allocated, and what they are
+// used for.
+struct _CrtMemBlockHeader
+{
+    _CrtMemBlockHeader* _block_header_next;
+    _CrtMemBlockHeader* _block_header_prev;
+    char const*         _file_name;
+    int                 _line_number;
+
+    int                 _block_use;
+    size_t              _data_size;
+
+    long                _request_number;
+    unsigned char       _gap[no_mans_land_size];
+
+    // Followed by:
+    // unsigned char    _data[_data_size];
+    // unsigned char    _another_gap[no_mans_land_size];
+};
+
+static_assert(
+    sizeof(_CrtMemBlockHeader) % MEMORY_ALLOCATION_ALIGNMENT == 0,
+    "Incorrect debug heap block alignment");
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Global Mutable State (Synchronized by the AppCRT Heap Lock)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These are pointers to the first and last nodes in the debug heap's doubly
+// linked list of allocation nodes.
+static _CrtMemBlockHeader* __acrt_first_block{nullptr};
+static _CrtMemBlockHeader* __acrt_last_block {nullptr};
+
+// These are the statistics for the current state of the debug heap, storing the
+// total number of bytes allocated over the life of the process, the total number
+// of bytes currently allocated (but not freed), and the maximum number of bytes
+// that were ever allocated at once.
+static size_t __acrt_total_allocations  {0};
+static size_t __acrt_current_allocations{0};
+static size_t __acrt_max_allocations    {0};
+
+// These states control the frequency with which _CrtCheckMemory.  The units are
+// "calls to allocation functions."
+static unsigned __acrt_check_frequency{0};
+static unsigned __acrt_check_counter  {0};
+
+// This is the current request number, which is incremented each time a new
+// allocation request is made.
+static long __acrt_current_request_number{1};
+
+
+
+// These three globals had external linkage in older versions of the CRT and may
+// be referenced by name in client code.  The first stores the current debug
+// heap options (flags).  The second stores the next allocation number on which
+// to break.  The third stores the pointer to the dump client to be used when
+// dumping heap objects.
+#undef _crtDbgFlag
+#undef _crtBreakAlloc
+
+extern "C" int              _crtDbgFlag{_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_DEFAULT_DF};
+extern "C" long             _crtBreakAlloc{-1};
+extern "C" _CRT_DUMP_CLIENT _pfnDumpClient{nullptr};
+
+extern "C" int* __p__crtDbgFlag()
+{
+    return &_crtDbgFlag;
+}
+
+extern "C" long* __p__crtBreakAlloc()
+{
+    return &_crtBreakAlloc;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal Utilities
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+static unsigned char* __cdecl block_from_header(_CrtMemBlockHeader* const header) throw()
+{
+    return reinterpret_cast<unsigned char*>(header + 1);
+}
+
+static _CrtMemBlockHeader* __cdecl header_from_block(void const* const block) throw()
+{
+    return static_cast<_CrtMemBlockHeader*>(const_cast<void*>(block)) - 1;
+}
+
+static bool __cdecl is_block_type_valid(int const block_use) throw()
+{
+    return _BLOCK_TYPE(block_use) == _CLIENT_BLOCK
+        || _BLOCK_TYPE(block_use) == _CRT_BLOCK
+        || block_use              == _NORMAL_BLOCK
+        || block_use              == _IGNORE_BLOCK;
+}
+
+// Tests the array of size bytes starting at first.  Returns true if all of the
+// bytes in the array have the given value; returns false otherwise.
+static bool __cdecl check_bytes(
+    unsigned char const* const first,
+    unsigned char        const value,
+    size_t               const size
+    ) throw()
+{
+    unsigned char const* const last{first + size};
+    for (unsigned char const* it{first}; it != last; ++it)
+    {
+        if (*it != value)
+            return false;
+    }
+
+    return true;
+}
+
+// Tests whether the size bytes of memory starting at address p can be read from.
+// The functionality is similar to that of the Windows API IsBadReadPtr(), which
+// is now deprecated.
+static bool __cdecl is_bad_read_pointer(void const* const p, size_t const size) throw()
+{
+    SYSTEM_INFO system_info{};
+    GetSystemInfo(&system_info);
+    DWORD const page_size{system_info.dwPageSize};
+
+    // If the structure has zero length, then do not probe the structure for
+    // read accessibility or alignment.
+    if (size == 0)
+        return false;
+
+    // A null pointer can never be read from:
+    if (!p)
+        return true;
+
+    char const* start_address{static_cast<char const*>(p)};
+    char const* end_address  {start_address + size - 1   };
+    if (end_address < start_address)
+        return true;
+
+    __try
+    {
+        *(volatile char*)start_address;
+
+        long const mask{~(static_cast<long>(page_size) - 1)};
+
+        start_address = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(start_address) & mask);
+        end_address   = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(end_address)   & mask);
+        while (start_address != end_address)
+        {
+            start_address = start_address + page_size;
+            *reinterpret_cast<const volatile char*>(start_address);
+        }
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static bool __cdecl is_block_an_aligned_allocation(void const* const block) throw()
+{
+    unsigned char const* const possible_alignment_gap{reinterpret_cast<unsigned char const*>(
+        reinterpret_cast<uintptr_t>(block) & (~sizeof(uintptr_t) - 1)) - align_gap_size};
+
+    return check_bytes(possible_alignment_gap, align_land_fill, align_gap_size);
+}
+
+// The debug heap can be configured to validate the consistency of the heap at
+// regular intervals.  If this behavior is configured, this function controls
+// that validation.
+static bool heap_validation_pending{false};
+
+static void __cdecl validate_heap_if_required_nolock() throw()
+{
+    if (__acrt_check_frequency == 0)
+    {
+        return;
+    }
+
+    if (__acrt_check_counter != __acrt_check_frequency - 1)
+    {
+        ++__acrt_check_counter;
+        return;
+    }
+
+    if (heap_validation_pending)
+    {
+        return;
+    }
+
+    heap_validation_pending = true;
+    __try
+    {
+        _ASSERTE(_CrtCheckMemory());
+    }
+    __finally
+    {
+        heap_validation_pending = false;
+    }
+
+    __acrt_check_counter = 0;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal Debug Heap APIs
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Attempts to allocate a block of size bytes from the debug heap.  Returns null
+// on failure.
+static void* __cdecl heap_alloc_dbg_internal(
+    size_t      const size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    ) throw()
+{
+    void* block{nullptr};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        validate_heap_if_required_nolock();
+
+        long const request_number{__acrt_current_request_number};
+
+        // Handle break-on-request and forced failure:
+        if (_crtBreakAlloc != -1 && request_number == _crtBreakAlloc)
+        {
+            _CrtDbgBreak();
+        }
+
+        if (_pfnAllocHook && !_pfnAllocHook(
+            _HOOK_ALLOC,
+            nullptr,
+            size,
+            block_use,
+            request_number,
+            reinterpret_cast<unsigned char const*>(file_name),
+            line_number))
+        {
+            if (file_name)
+                _RPTN(_CRT_WARN, "Client hook allocation failure at file %hs line %d.\n", file_name, line_number);
+            else
+                _RPT0(_CRT_WARN, "Client hook allocation failure.\n");
+
+            __leave;
+        }
+
+#pragma warning(suppress:__WARNING_UNUSED_ASSIGNMENT) // 28931
+        bool const ignore_block{_BLOCK_TYPE(block_use) != _CRT_BLOCK && !(_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF)};
+
+        // Diagnostic memory allocation from this point on...
+        if (size > static_cast<size_t>(_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)))
+        {
+            errno_t* const global_errno{_errno()};
+            if (global_errno)
+                *global_errno = ENOMEM;
+
+            __leave;
+        }
+
+        if (!is_block_type_valid(block_use))
+        {
+            _RPT0(_CRT_ERROR, "Error: memory allocation: bad memory block type.\n");
+        }
+
+        size_t const block_size{sizeof(_CrtMemBlockHeader) + size + no_mans_land_size};
+
+        _CrtMemBlockHeader* const header{static_cast<_CrtMemBlockHeader*>(HeapAlloc(__acrt_heap, 0, block_size))};
+        if (!header)
+        {
+            errno_t* const global_errno{_errno()};
+            if (global_errno)
+                *global_errno = ENOMEM;
+
+            __leave;
+        }
+
+        // Commit the allocation by linking the block into the global list:
+        ++__acrt_current_request_number;
+
+        if (ignore_block)
+        {
+            header->_block_header_next = nullptr;
+            header->_block_header_prev = nullptr;
+            header->_file_name         = nullptr;
+            header->_line_number       = line_number_for_ignore_blocks;
+            header->_data_size         = size;
+            header->_block_use         = _IGNORE_BLOCK;
+            header->_request_number    = request_number_for_ignore_blocks;
+        }
+        else
+        {
+            // Keep track of total amount of memory allocated:
+            if (SIZE_MAX - __acrt_total_allocations > size)
+            {
+                __acrt_total_allocations += size;
+            }
+            else
+            {
+                __acrt_total_allocations = SIZE_MAX;
+            }
+
+            __acrt_current_allocations += size;
+
+            if (__acrt_current_allocations > __acrt_max_allocations)
+                __acrt_max_allocations = __acrt_current_allocations;
+
+            if (__acrt_first_block)
+            {
+                __acrt_first_block->_block_header_prev = header;
+            }
+            else
+            {
+                __acrt_last_block = header;
+            }
+
+            header->_block_header_next = __acrt_first_block;
+            header->_block_header_prev = nullptr;
+            header->_file_name         = file_name;
+            header->_line_number       = line_number;
+            header->_data_size         = size;
+            header->_block_use         = block_use;
+            header->_request_number    = request_number;
+
+            __acrt_first_block = header;
+        }
+
+        // Fill the gap before and after the data block:
+        memset(header->_gap,                     no_mans_land_fill, no_mans_land_size);
+        memset(block_from_header(header) + size, no_mans_land_fill, no_mans_land_size);
+
+        // Fill the data block with a silly (but non-zero) value:
+        memset(block_from_header(header), clean_land_fill, size);
+
+        block = block_from_header(header);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return block;
+}
+
+
+
+// Allocates a block of size bytes from the debug heap, using the new handler if
+// it is configured for use with malloc.
+static void* __cdecl heap_alloc_dbg(
+    size_t      const size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    ) throw()
+{
+    bool const should_call_new_handler{_query_new_mode() != 0};
+    for (;;)
+    {
+        void* const block{heap_alloc_dbg_internal(size, block_use, file_name, line_number)};
+        if (block)
+            return block;
+
+        if (!should_call_new_handler || !_callnewh(size))
+        {
+            errno_t* const global_errno{_errno()};
+            if (global_errno)
+                *global_errno = ENOMEM;
+
+            return nullptr;
+        }
+
+        // The new handler was successful -- try to allocate again
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Public Debug Heap Allocation APIs
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// These are the allocation functions that allocate, manipulate, and free blocks
+// from the debug heap.  They are equivalent to the main allocation functions,
+// which deal with blocks from the process heap.  Most of the debug allocation
+// functions accept a block use, file name, and/or line number which are used to
+// track where allocations originated.
+//
+// Documentation comments for these functions describe only the material
+// differences between them and the corresponding main allocation functions.
+
+// This function must be marked noinline, otherwise malloc and
+// _malloc_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because malloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _malloc_dbg(
+    size_t      const size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return heap_alloc_dbg(size, block_use, file_name, line_number);
+}
+
+
+// This function must be marked noinline, otherwise calloc and
+// _calloc_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because calloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _calloc_dbg(
+    size_t      const count,
+    size_t      const element_size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    _VALIDATE_RETURN_NOEXC(count == 0 || (_HEAP_MAXREQ / count) >= element_size, ENOMEM, nullptr);
+
+    size_t const allocation_size{element_size * count};
+
+    // Note that we zero exactly allocation_size bytes.  The _calloc_base
+    // function for the main heap may zero more bytes if a larger block is
+    // allocated.
+    void* const block{heap_alloc_dbg(allocation_size, block_use, file_name, line_number)};
+    if (block)
+        memset(block, 0, allocation_size);
+
+    return block;
+}
+
+
+
+// Common debug realloc implementation shared by _realloc_dbg, _recalloc_dbg,
+// and _expand_dbg.  If reallocation_is_allowed is true, the expand behavior
+// is used; otherwise the realloc behavior is used.
+static void * __cdecl realloc_dbg_nolock(
+    void*       const block,
+    size_t*     const new_size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number,
+    bool        const reallocation_is_allowed
+    ) throw()
+{
+    // realloc(nullptr, size) is equivalent to malloc(size):
+    if (!block)
+    {
+        return _malloc_dbg(*new_size, block_use, file_name, line_number);
+    }
+
+    // realloc(block, 0) is equivalent to free(block):
+    if (reallocation_is_allowed && *new_size == 0)
+    {
+        _free_dbg(block, block_use);
+        return nullptr;
+    }
+
+    validate_heap_if_required_nolock();
+
+    // Handle break-on-request and forced failure:
+    long const request_number{__acrt_current_request_number};
+    if (_crtBreakAlloc != -1 && request_number == _crtBreakAlloc)
+    {
+        _CrtDbgBreak();
+    }
+
+    if (_pfnAllocHook && !_pfnAllocHook(
+        _HOOK_REALLOC,
+        block,
+        *new_size,
+        block_use,
+        request_number,
+        reinterpret_cast<unsigned char const*>(file_name),
+        line_number))
+    {
+        if (file_name)
+            _RPTN(_CRT_WARN, "Client hook re-allocation failure at file %hs line %d.\n", file_name, line_number);
+        else
+            _RPT0(_CRT_WARN, "Client hook re-allocation failure.\n");
+
+        return nullptr;
+    }
+
+    // Ensure the block type matches what is expected and isn't an aligned allocation:
+    if (block_use != _NORMAL_BLOCK && _BLOCK_TYPE(block_use) != _CLIENT_BLOCK && _BLOCK_TYPE(block_use) != _CRT_BLOCK)
+    {
+        if (file_name)
+        {
+            _RPTN(_CRT_ERROR,
+                "Error: memory allocation: bad memory block type.\n" _ALLOCATION_FILE_LINENUM,
+                file_name, line_number);
+        }
+        else
+        {
+            _RPT0(_CRT_ERROR, "Error: memory allocation: bad memory block type.\n");
+        }
+    }
+    else if (is_block_an_aligned_allocation(block))
+    {
+        // We don't know (yet) where (file, linenum) block was allocated
+        _RPTN(_CRT_ERROR, "The Block at 0x%p was allocated by aligned routines, use _aligned_realloc()", block);
+        errno = EINVAL;
+
+        return nullptr;
+    }
+
+    // If this assertion fails, a bad pointer has been passed in.  It may be
+    // totally bogus, or it may have been allocated from another heap.  The
+    // pointer must have been allocated from the debug heap.
+    _ASSERTE(_CrtIsValidHeapPointer(block));
+
+    _CrtMemBlockHeader* const old_head{header_from_block(block)};
+
+    bool const is_ignore_block{old_head->_block_use == _IGNORE_BLOCK};
+    if (is_ignore_block)
+    {
+        _ASSERTE(old_head->_line_number == line_number_for_ignore_blocks && old_head->_request_number == request_number_for_ignore_blocks);
+    }
+    else if (__acrt_total_allocations < old_head->_data_size)
+    {
+        _RPTN(_CRT_ERROR, "Error: possible heap corruption at or near 0x%p", block);
+        errno = EINVAL;
+        return nullptr;
+    }
+
+    // Ensure the new requested size is not too large:
+    if (*new_size > static_cast<size_t>(_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)))
+    {
+        errno = ENOMEM;
+        return nullptr;
+    }
+
+    // Note that all header values will remain valid and the minimum of the old
+    // size and the new size of data will remain valid.
+    size_t const new_internal_size{sizeof(_CrtMemBlockHeader) + *new_size + no_mans_land_size};
+
+    _CrtMemBlockHeader* new_head{nullptr};
+    if (reallocation_is_allowed)
+    {
+        new_head = static_cast<_CrtMemBlockHeader*>(_realloc_base(old_head, new_internal_size));
+        if (!new_head)
+            return nullptr;
+    }
+    else
+    {
+        new_head = static_cast<_CrtMemBlockHeader*>(_expand_base(old_head, new_internal_size));
+        if (!new_head)
+            return nullptr;
+
+        // On Win64, the heap does not try to resize the block if it is shrinking
+        // because of the use of the low-fragmentation heap.  It just returns the
+        // original block.  We make sure that our own header tracks that properly:
+        #ifdef _WIN64
+        *new_size = static_cast<size_t>(HeapSize(__acrt_heap, 0, new_head)
+            - sizeof(_CrtMemBlockHeader)
+            - no_mans_land_size);
+        #endif
+    }
+
+    _Analysis_assume_(new_head->_data_size == old_head->_data_size);
+
+    // Account for the current allocation and track the total amount of memory
+    // that is currently allocated:
+    ++__acrt_current_request_number;
+    if (!is_ignore_block)
+    {
+        if (__acrt_total_allocations < SIZE_MAX)
+        {
+            __acrt_total_allocations -= new_head->_data_size;
+            __acrt_total_allocations += SIZE_MAX - __acrt_total_allocations > *new_size
+                ? *new_size
+                : SIZE_MAX;
+        }
+
+        __acrt_current_allocations -= new_head->_data_size;
+        __acrt_current_allocations += *new_size;
+
+        if (__acrt_current_allocations > __acrt_max_allocations)
+            __acrt_max_allocations = __acrt_current_allocations;
+    }
+
+    unsigned char* const new_block{block_from_header(new_head)};
+
+    // If the block grew, fill the "extension" with the land fill value:
+    if (*new_size > new_head->_data_size)
+    {
+        memset(new_block + new_head->_data_size, clean_land_fill, *new_size - new_head->_data_size);
+    }
+
+    // Fill in the gap after the client block:
+    memset(new_block + *new_size, no_mans_land_fill, no_mans_land_size);
+
+    if (!is_ignore_block)
+    {
+        new_head->_file_name      = file_name;
+        new_head->_line_number    = line_number;
+        new_head->_request_number = request_number;
+    }
+
+    new_head->_data_size = *new_size;
+
+    _ASSERTE(reallocation_is_allowed || (!reallocation_is_allowed && new_head == old_head));
+
+    // If the block did not move or is ignored, we are done:
+    if (new_head == old_head || is_ignore_block)
+        return new_block;
+
+    // Swap out the old block from the linked list and link in the new block:
+    if (new_head->_block_header_next)
+    {
+        new_head->_block_header_next->_block_header_prev = new_head->_block_header_prev;
+    }
+    else
+    {
+        _ASSERTE(__acrt_last_block == old_head);
+        __acrt_last_block = new_head->_block_header_prev;
+    }
+
+    if (new_head->_block_header_prev)
+    {
+        new_head->_block_header_prev->_block_header_next = new_head->_block_header_next;
+    }
+    else
+    {
+        _ASSERTE(__acrt_first_block == old_head);
+        __acrt_first_block = new_head->_block_header_next;
+    }
+
+    if (__acrt_first_block)
+    {
+        __acrt_first_block->_block_header_prev = new_head;
+    }
+    else
+    {
+        __acrt_last_block = new_head;
+    }
+
+    new_head->_block_header_next = __acrt_first_block;
+    new_head->_block_header_prev = nullptr;
+    __acrt_first_block = new_head;
+
+    return new_block;
+}
+
+
+// This function must be marked noinline, otherwise realloc and
+// _realloc_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because realloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _realloc_dbg(
+    void*       const block,
+    size_t      const requested_size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    void* new_block{nullptr};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        size_t new_size{requested_size};
+        new_block = realloc_dbg_nolock(block, &new_size, block_use, file_name, line_number, true);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return new_block;
+}
+
+
+// This function must be marked noinline, otherwise recalloc and
+// _recalloc_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because recalloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _recalloc_dbg(
+    void*       const block,
+    size_t      const count,
+    size_t      const element_size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    _VALIDATE_RETURN_NOEXC(count == 0 || (_HEAP_MAXREQ / count) >= element_size, ENOMEM, nullptr);
+
+    size_t const old_allocation_size{block ? _msize_dbg(block, block_use) : 0};
+    size_t const new_allocation_size{element_size * count     };
+
+    void* const new_block{_realloc_dbg(block, new_allocation_size, block_use, file_name, line_number)};
+    if (!new_block)
+        return nullptr;
+
+    // Zero the "expansion," if the block was expanded:
+    if (old_allocation_size < new_allocation_size)
+    {
+        memset(
+            static_cast<unsigned char*>(new_block) + old_allocation_size,
+            0,
+            new_allocation_size - old_allocation_size);
+    }
+
+    return new_block;
+}
+
+
+// This function must be marked noinline, otherwise _expand and
+// _expand_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because _expand
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _expand_dbg(
+    void*       const block,
+    size_t      const requested_size,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    _VALIDATE_RETURN(block != nullptr, EINVAL, nullptr);
+
+    if (requested_size > static_cast<size_t>(_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)))
+    {
+        errno = ENOMEM;
+        return nullptr;
+    }
+
+    void* new_block{nullptr};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        size_t new_size{requested_size};
+        new_block = realloc_dbg_nolock(block, &new_size, block_use, file_name, line_number, false);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return new_block;
+}
+
+
+
+static void __cdecl free_dbg_nolock(
+    void* const block,
+    int   const block_use
+    ) throw()
+{
+    validate_heap_if_required_nolock();
+
+    if (block == nullptr)
+        return;
+
+    #if _UCRT_HEAP_MISMATCH_DETECTION && (defined _M_IX86 || defined _M_AMD64)
+
+    if (!_CrtIsValidHeapPointer(block))
+    {
+        HANDLE const msvcrt_heap_handle = __acrt_get_msvcrt_heap_handle();
+        if (msvcrt_heap_handle)
+        {
+            if (HeapValidate(msvcrt_heap_handle, 0, block))
+            {
+                _RPT1(_CRT_WARN, "CRTHEAP: ucrt: Attempt to free a pointer (0x%p) that belongs to MSVCRT's private heap, not the process heap.\n", block);
+
+                #if _UCRT_HEAP_MISMATCH_BREAK
+                _CrtDbgBreak();
+                #endif // _UCRT_HEAP_MISMATCH_BREAK
+
+                #if _UCRT_HEAP_MISMATCH_RECOVERY
+                if (HeapFree(msvcrt_heap_handle, 0, block))
+                {
+                    _RPT1(_CRT_WARN, "CRTHEAP: ucrt: Successfully free'd 0x%p\n", block);
+                    return;
+                }
+                else
+                {
+                    _RPT1(_CRT_ERROR, "CRTHEAP: ucrt: Unable to free 0x%p\n", block);
+                    _CrtDbgBreak(); // Force break.
+                }
+                #endif // _UCRT_HEAP_MISMATCH_RECOVERY
+            }
+        }
+    }
+
+    #endif // _UCRT_HEAP_MISMATCH_DETECTION && (defined _M_IX86 || defined _M_AMD64)
+
+    // Check to ensure that the block was not allocated by _aligned routines
+    if (block_use == _NORMAL_BLOCK && is_block_an_aligned_allocation(block))
+    {
+        // We don't know (yet) where (file, linenum) block was allocated
+        _RPTN(_CRT_ERROR, "The Block at 0x%p was allocated by aligned routines, use _aligned_free()", block);
+        errno = EINVAL;
+        return;
+    }
+
+    // Forced failure handling
+    if (_pfnAllocHook && !_pfnAllocHook(_HOOK_FREE, block, 0, block_use, 0, nullptr, 0))
+    {
+        _RPT0(_CRT_WARN, "Client hook free failure.\n");
+        return;
+    }
+
+    // If this assertion fails, a bad pointer has been passed in.  It may be
+    // totally bogus, or it may have been allocated from another heap.  The
+    // pointer must have been allocated from the CRT heap.
+    _ASSERTE(_CrtIsValidHeapPointer(block));
+
+    // Get a pointer to memory block header:
+    _CrtMemBlockHeader* const header = header_from_block(block);
+    _ASSERTE(is_block_type_valid(header->_block_use));
+
+    // If we didn't already check entire heap, at least check this object by
+    // verifying that its no-man's land areas have not been trashed:
+    if (!(_crtDbgFlag & _CRTDBG_CHECK_ALWAYS_DF))
+    {
+        if (!check_bytes(header->_gap, no_mans_land_fill, no_mans_land_size))
+        {
+            if (header->_file_name)
+            {
+                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
+                    "CRT detected that the application wrote to memory before start of heap buffer.\n"
+                    _ALLOCATION_FILE_LINENUM,
+                    block_use_names[_BLOCK_TYPE(header->_block_use)],
+                    header->_request_number,
+                    block_from_header(header),
+                    header->_file_name,
+                    header->_line_number);
+            }
+            else
+            {
+                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
+                    "CRT detected that the application wrote to memory before start of heap buffer.\n",
+                    block_use_names[_BLOCK_TYPE(header->_block_use)],
+                    header->_request_number,
+                    block_from_header(header));
+            }
+        }
+
+        if (!check_bytes(block_from_header(header) + header->_data_size, no_mans_land_fill, no_mans_land_size))
+        {
+            if (header->_file_name)
+            {
+                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
+                    "CRT detected that the application wrote to memory after end of heap buffer.\n"
+                    _ALLOCATION_FILE_LINENUM,
+                    block_use_names[_BLOCK_TYPE(header->_block_use)],
+                    header->_request_number,
+                    block_from_header(header),
+                    header->_file_name,
+                    header->_line_number);
+            }
+            else
+            {
+                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
+                    "CRT detected that the application wrote to memory after end of heap buffer.\n",
+                    block_use_names[_BLOCK_TYPE(header->_block_use)],
+                    header->_request_number,
+                    block_from_header(header));
+            }
+        }
+    }
+
+    // If this block was ignored when it was allocated, we can just free it:
+    if (header->_block_use == _IGNORE_BLOCK)
+    {
+        _ASSERTE(header->_line_number == line_number_for_ignore_blocks && header->_request_number == request_number_for_ignore_blocks);
+        memset(header, dead_land_fill, sizeof(_CrtMemBlockHeader) + header->_data_size + no_mans_land_size);
+        _free_base(header);
+        return;
+    }
+
+    // Ensure that we were called with the right block use.  CRT blocks can be
+    // freed as NORMAL blocks.
+    _ASSERTE(header->_block_use == block_use || header->_block_use == _CRT_BLOCK && block_use == _NORMAL_BLOCK);
+
+    __acrt_current_allocations -= header->_data_size;
+
+    // Optionally reclaim memory:
+    if ((_crtDbgFlag & _CRTDBG_DELAY_FREE_MEM_DF) == 0)
+    {
+        // Unlink this allocation from the global linked list:
+        if (header->_block_header_next)
+        {
+            header->_block_header_next->_block_header_prev = header->_block_header_prev;
+        }
+        else
+        {
+            _ASSERTE(__acrt_last_block == header);
+            __acrt_last_block = header->_block_header_prev;
+        }
+
+        if (header->_block_header_prev)
+        {
+            header->_block_header_prev->_block_header_next = header->_block_header_next;
+        }
+        else
+        {
+            _ASSERTE(__acrt_first_block == header);
+            __acrt_first_block = header->_block_header_next;
+        }
+
+        memset(header, dead_land_fill, sizeof(_CrtMemBlockHeader) + header->_data_size + no_mans_land_size);
+        _free_base(header);
+    }
+    else
+    {
+        header->_block_use = _FREE_BLOCK;
+
+        // Keep memory around as dead space:
+        memset(block_from_header(header), dead_land_fill, header->_data_size);
+    }
+}
+
+
+// This function must be marked noinline, otherwise free and
+// _free_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because free
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void __cdecl _free_dbg(void* const block, int const block_use)
+{
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        // If a block use was provided, use it; if the block use was not known,
+        // use the block use stored in the header.  (For example, the block use
+        // is not known when this function is called by operator delete because
+        // the heap lock must be acquired to access the block header.)
+        int const actual_use{block_use == _UNKNOWN_BLOCK && block != nullptr
+            ? header_from_block(block)->_block_use
+            : block_use};
+
+        free_dbg_nolock(block, actual_use);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+}
+
+
+// This function must be marked noinline, otherwise _msize and
+// _msize_dbg will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because _msize
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) size_t __cdecl _msize_dbg(void* const block, int const block_use)
+{
+    UNREFERENCED_PARAMETER(block_use);
+
+    _VALIDATE_RETURN(block != nullptr, EINVAL, static_cast<size_t>(-1));
+
+    size_t size{0};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        validate_heap_if_required_nolock();
+
+        // If this assert fails, a bad pointer has been passed in.  It may be
+        // totally bogus, or it may have been allocated from another heap.  The
+        // pointer must have been allocated from the CRT heap.
+        _ASSERTE(_CrtIsValidHeapPointer(block));
+
+        _CrtMemBlockHeader* const header{header_from_block(block)};
+
+        _ASSERTE(is_block_type_valid(header->_block_use));
+
+        size = header->_data_size;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return size;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Public Debug Heap Control and Status APIs
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Configures the CRT to break on allocation operation number new_break_alloc.
+// Returns the previous break allocation value.
+extern "C" long __cdecl _CrtSetBreakAlloc(long const new_break_alloc)
+{
+    long const old_break_alloc{_crtBreakAlloc};
+    _crtBreakAlloc = new_break_alloc;
+    return old_break_alloc;
+}
+
+
+
+// Changes the block use for a block allocated on the debug heap.
+extern "C" void __cdecl _CrtSetDbgBlockType(
+    void* const block,
+    int   const block_use
+    )
+{
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        if (!_CrtIsValidHeapPointer(block))
+            __leave;
+
+        _CrtMemBlockHeader* const header{header_from_block(block)};
+
+        _ASSERTE(is_block_type_valid(header->_block_use));
+
+        header->_block_use = block_use;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+}
+
+
+
+// These get and set the allocation hook function, which is called for debug
+// heap allocation operations.
+extern "C" _CRT_ALLOC_HOOK __cdecl _CrtGetAllocHook()
+{
+    return _pfnAllocHook;
+}
+
+extern "C" _CRT_ALLOC_HOOK __cdecl _CrtSetAllocHook(_CRT_ALLOC_HOOK const new_hook)
+{
+    _CRT_ALLOC_HOOK const old_hook{_pfnAllocHook};
+    _pfnAllocHook = new_hook;
+    return old_hook;
+}
+
+
+
+// Checks the integrity of the debug heap.  Returns TRUE if the debug heap (and
+// the underlying Windows heap) appears valid; returns FALSE and asserts if the
+// heap appears corrupted or otherwise invalid.
+static bool __cdecl check_block(_CrtMemBlockHeader* const header) throw()
+{
+    bool this_block_okay{true};
+    char const* block_use{nullptr};
+
+    if (is_block_type_valid(header->_block_use))
+    {
+        block_use = block_use_names[_BLOCK_TYPE(header->_block_use)];
+    }
+    else
+    {
+        block_use = "DAMAGED";
+    }
+
+    // Check the no-man's-land gaps:
+    if (!check_bytes(header->_gap, no_mans_land_fill, no_mans_land_size))
+    {
+        if (header->_file_name)
+        {
+            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
+                "CRT detected that the application wrote to memory before start of heap buffer.\n"
+                _ALLOCATION_FILE_LINENUM,
+                block_use,
+                header->_request_number,
+                block_from_header(header),
+                header->_file_name,
+                header->_line_number);
+        }
+        else
+        {
+            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
+                "CRT detected that the application wrote to memory before start of heap buffer.\n",
+                block_use, header->_request_number, block_from_header(header));
+        }
+
+        this_block_okay = false;
+    }
+
+    if (!check_bytes(block_from_header(header) + header->_data_size, no_mans_land_fill, no_mans_land_size))
+    {
+        if (header->_file_name)
+        {
+            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
+                "CRT detected that the application wrote to memory after end of heap buffer.\n"
+                _ALLOCATION_FILE_LINENUM,
+                block_use,
+                header->_request_number,
+                block_from_header(header),
+                header->_file_name,
+                header->_line_number);
+        }
+        else
+        {
+            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
+                "CRT detected that the application wrote to memory after end of heap buffer.\n",
+                block_use, header->_request_number, block_from_header(header));
+        }
+
+        this_block_okay = false;
+    }
+
+    // Free blocks should remain undisturbed:
+    if (header->_block_use == _FREE_BLOCK && !check_bytes(block_from_header(header), dead_land_fill, header->_data_size))
+    {
+        if (header->_file_name)
+        {
+            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: on top of Free block at 0x%p.\n"
+                "CRT detected that the application wrote to a heap buffer that was freed.\n"
+                _ALLOCATION_FILE_LINENUM,
+                block_from_header(header),
+                header->_file_name,
+                header->_line_number);
+        }
+        else
+        {
+            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: on top of Free block at 0x%p.\n"
+                "CRT detected that the application wrote to a heap buffer that was freed.\n",
+                block_from_header(header));
+        }
+
+        this_block_okay = false;
+    }
+
+    if (!this_block_okay)
+    {
+        // Report statistics about the broken object:
+        if (header->_file_name)
+        {
+            _RPTN(_CRT_WARN,
+                "%hs located at 0x%p is %Iu bytes long.\n"
+                _ALLOCATION_FILE_LINENUM,
+                block_use,
+                block_from_header(header),
+                header->_data_size,
+                header->_file_name,
+                header->_line_number);
+        }
+        else
+        {
+            _RPTN(_CRT_WARN, "%hs located at 0x%p is %Iu bytes long.\n",
+                block_use, block_from_header(header), header->_data_size);
+        }
+    }
+
+    return this_block_okay;
+}
+
+extern "C" int __cdecl _CrtCheckMemory()
+{
+    if ((_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF) == 0)
+    {
+        return TRUE;
+    }
+
+    bool all_okay{true};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        // First walk our allocated heap blocks and verify consistency of our
+        // internal data structures.  We do this first because we can give
+        // better diagnostics to client code than the underlying Windows heap
+        // can (we have source file names and line numbers and other metadata).
+        // We use Floyd's cycle finding algorithm to detect cycles in the block
+        // list.
+        _CrtMemBlockHeader* trail_it{__acrt_first_block};
+        _CrtMemBlockHeader* lead_it {__acrt_first_block == nullptr ? nullptr : __acrt_first_block->_block_header_next};
+        while (trail_it != nullptr)
+        {
+            all_okay &= check_block(trail_it);
+
+            if (trail_it == lead_it)
+            {
+                _RPTN(_CRT_WARN,
+                    "Cycle in block list detected while processing block located at 0x%p.\n",
+                    trail_it);
+                all_okay = false;
+                break;
+            }
+
+            trail_it = trail_it->_block_header_next;
+
+            // Advance the lead iterator twice as fast as the trail iterator:
+            if (lead_it != nullptr)
+            {
+                lead_it = lead_it->_block_header_next == nullptr
+                    ? nullptr
+                    : lead_it->_block_header_next->_block_header_next;
+            }
+        }
+
+        // Then check the underlying Windows heap:
+        if (!HeapValidate(__acrt_heap, 0, nullptr))
+        {
+            _RPT0(_CRT_WARN, "Heap validation failed.\n");
+            all_okay = false;
+            __leave;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return all_okay ? TRUE : FALSE;
+}
+
+
+
+// Configures the debug heap behavior flags.  Note that only the flags listed at
+// the top of the function definition are valid; any other flags will cause the
+// invalid parameter handler to be invoked.  Returns the previous flag state.
+extern "C" int __cdecl _CrtSetDbgFlag(int const new_bits)
+{
+    int const valid_flags{
+        _CRTDBG_ALLOC_MEM_DF      |
+        _CRTDBG_DELAY_FREE_MEM_DF |
+        _CRTDBG_CHECK_ALWAYS_DF   |
+        _CRTDBG_CHECK_CRT_DF      |
+        _CRTDBG_LEAK_CHECK_DF};
+
+    bool const new_bits_have_only_valid_flags = (new_bits & 0xffff & ~valid_flags) == 0;
+    _VALIDATE_RETURN(new_bits == _CRTDBG_REPORT_FLAG || new_bits_have_only_valid_flags, EINVAL, _crtDbgFlag);
+
+    int old_bits{0};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        old_bits = _crtDbgFlag;
+
+        if (new_bits == _CRTDBG_REPORT_FLAG)
+            __leave;
+
+        if (new_bits & _CRTDBG_CHECK_ALWAYS_DF)
+            __acrt_check_frequency = 1;
+        else
+            __acrt_check_frequency = (new_bits >> 16) & 0x0ffff;
+
+        __acrt_check_counter = 0;
+        _crtDbgFlag = new_bits;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return old_bits;
+}
+
+
+
+// Calls a caller-provided function for each client object in the heap.
+extern "C" void __cdecl _CrtDoForAllClientObjects(
+    _CrtDoForAllClientObjectsCallback const callback,
+    void*                             const context
+    )
+{
+    _VALIDATE_RETURN_VOID(callback != nullptr, EINVAL);
+
+    if ((_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF) == 0)
+        return;
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        for (_CrtMemBlockHeader* header{__acrt_first_block}; header != nullptr; header = header->_block_header_next)
+        {
+            if (_BLOCK_TYPE(header->_block_use) == _CLIENT_BLOCK)
+                callback(block_from_header(header), context);
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+}
+
+
+
+// This function is provided for backwards compatibility only.  It just tests
+// whether the provided pointer is null.
+extern "C" int __cdecl _CrtIsValidPointer(
+    void const*  const p,
+    unsigned int const size_in_bytes,
+    int          const read_write
+    )
+{
+    UNREFERENCED_PARAMETER(size_in_bytes);
+    UNREFERENCED_PARAMETER(read_write);
+
+    return p != nullptr;
+}
+
+
+
+// This function is provided for backwards compatibility only.  It returns TRUE
+// if the given block points to an allocation from the OS heap that underlies
+// this CRT debug heap.  Back when the CRT used its own OS heap (prior to Dev10),
+// this function would thus also tell you whether the block was allocated by this
+// debug heap.  Now, it just tells you whether the block was allocated by some
+// debug heap.
+extern "C" int __cdecl _CrtIsValidHeapPointer(void const* const block)
+{
+    if (!block)
+        return FALSE;
+
+    return HeapValidate(__acrt_heap, 0, header_from_block(block));
+}
+
+
+
+// Verifies that the provided memory block is a block allocated by this debug
+// heap.  Returns TRUE if it is; FALSE otherwise.  If the request_number,
+// file_name, and line_number arguments are non-null, and if the block was
+// allocated by this debug heap, this function fills in those argments with the
+// actual values for the block.
+extern "C" int __cdecl _CrtIsMemoryBlock(
+    void const* const block,
+    unsigned    const size,
+    long*       const request_number,
+    char**      const file_name,
+    int*        const line_number
+    )
+{
+    if (request_number)
+        *request_number = 0;
+
+    if (file_name)
+        *file_name = nullptr;
+
+    if (line_number)
+        *line_number = 0;
+
+    if (!block)
+        return FALSE;
+
+    int result{FALSE};
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        _CrtMemBlockHeader* const header{header_from_block(block)};
+        if (!is_block_type_valid(header->_block_use))
+            __leave;
+
+        if (!_CrtIsValidPointer(block, size, TRUE))
+            __leave;
+
+        if (header->_data_size != size)
+            __leave;
+
+        if (header->_request_number > __acrt_current_request_number)
+            __leave;
+
+        // The block is valid
+        if (request_number)
+            *request_number = header->_request_number;
+
+        if (file_name)
+            *file_name = const_cast<char*>(header->_file_name);
+
+        if (line_number)
+            *line_number = header->_line_number;
+
+        result = TRUE;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return result;
+}
+
+
+
+// Tests whether the block was allocated by this heap and, if it was, returns
+// its block use.  Returns -1 if this block was not allocated by this heap.
+extern "C" int _CrtReportBlockType(void const* const block)
+{
+    if (!_CrtIsValidHeapPointer(block))
+        return -1;
+
+    return header_from_block(block)->_block_use;
+}
+
+
+
+// These get and set the active dump client, which is used when dumping the state
+// of the debug heap.
+extern "C" _CRT_DUMP_CLIENT __cdecl _CrtGetDumpClient()
+{
+    return _pfnDumpClient;
+}
+
+extern "C" _CRT_DUMP_CLIENT __cdecl _CrtSetDumpClient(_CRT_DUMP_CLIENT const new_client)
+{
+    _CRT_DUMP_CLIENT const old_client{_pfnDumpClient};
+    _pfnDumpClient = new_client;
+    return old_client;
+}
+
+
+
+// Creates a checkpoint for the current state of the debug heap.  Fills in the
+// object pointed to by state; state must be non-null.
+extern "C" void __cdecl _CrtMemCheckpoint(_CrtMemState* const state)
+{
+    _VALIDATE_RETURN_VOID(state != nullptr, EINVAL);
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        state->pBlockHeader = __acrt_first_block;
+
+        for (unsigned use{0}; use < _MAX_BLOCKS; ++use)
+        {
+            state->lCounts[use] = 0;
+            state->lSizes [use] = 0;
+        }
+
+        for (_CrtMemBlockHeader* header{__acrt_first_block}; header != nullptr; header = header->_block_header_next)
+        {
+            if (_BLOCK_TYPE(header->_block_use) >= 0 && _BLOCK_TYPE(header->_block_use) < _MAX_BLOCKS)
+            {
+                ++state->lCounts[_BLOCK_TYPE(header->_block_use)];
+                state->lSizes[_BLOCK_TYPE(header->_block_use)] += header->_data_size;
+            }
+            else if (header->_file_name)
+            {
+                _RPTN(_CRT_WARN, "Bad memory block found at 0x%p.\n" _ALLOCATION_FILE_LINENUM,
+                    header,
+                    header->_file_name,
+                    header->_line_number);
+            }
+            else
+            {
+                _RPTN(_CRT_WARN, "Bad memory block found at 0x%p.\n", header);
+            }
+        }
+
+        state->lHighWaterCount = __acrt_max_allocations;
+        state->lTotalCount     = __acrt_total_allocations;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+}
+
+
+
+// Computes the difference between two memory states.  The difference between
+// the old_state and new_state is stored in the object pointed to by state.
+// Returns TRUE if there is a difference; FALSE otherwise.  All three state
+// pointers must be valid and non-null.
+extern "C" int __cdecl _CrtMemDifference(
+    _CrtMemState*       const state,
+    _CrtMemState const* const old_state,
+    _CrtMemState const* const new_state
+    )
+{
+    _VALIDATE_RETURN(state     != nullptr, EINVAL, FALSE);
+    _VALIDATE_RETURN(old_state != nullptr, EINVAL, FALSE);
+    _VALIDATE_RETURN(new_state != nullptr, EINVAL, FALSE);
+
+    bool significant_difference_found{false};
+    for (int use{0}; use < _MAX_BLOCKS; ++use)
+    {
+        state->lSizes[use]  = new_state->lSizes[use]  - old_state->lSizes[use];
+        state->lCounts[use] = new_state->lCounts[use] - old_state->lCounts[use];
+
+        if (state->lSizes[use] == 0 && state->lCounts[use] == 0)
+            continue;
+
+        if (use == _FREE_BLOCK)
+            continue;
+
+        if (use == _CRT_BLOCK && (_crtDbgFlag & _CRTDBG_CHECK_CRT_DF) == 0)
+            continue;
+
+        significant_difference_found = true;
+    }
+
+    state->lHighWaterCount = new_state->lHighWaterCount - old_state->lHighWaterCount;
+    state->lTotalCount     = new_state->lTotalCount     - old_state->lTotalCount;
+    state->pBlockHeader    = nullptr;
+
+    return significant_difference_found ? 1 : 0;
+}
+
+
+
+// Prints metadata for a block of memory.
+static void __cdecl print_block_data(
+    _locale_t           const locale,
+    _CrtMemBlockHeader* const header
+    ) throw()
+{
+    _LocaleUpdate locale_update{locale};
+
+    static size_t const max_print = 16;
+
+    char print_buffer[max_print     + 1];
+    char value_buffer[max_print * 3 + 1];
+
+    size_t i{0};
+    for (; i < min(header->_data_size, max_print); ++i)
+    {
+        unsigned char const c{block_from_header(header)[i]};
+
+        print_buffer[i] = _isprint_l(c, locale_update.GetLocaleT()) ? c : ' ';
+        _ERRCHECK_SPRINTF(sprintf_s(value_buffer + i * 3, _countof(value_buffer) - (i * 3), "%.2X ", c));
+    }
+
+    print_buffer[i] = '\0';
+    _RPTN(_CRT_WARN, " Data: <%s> %s\n", print_buffer, value_buffer);
+}
+
+// Prints metadata for all blocks allocated since the provided state was taken.
+static void __cdecl dump_all_object_since_nolock(_CrtMemState const* const state) throw()
+{
+    _LocaleUpdate locale_update{nullptr};
+    _locale_t     locale{locale_update.GetLocaleT()};
+
+    _RPT0(_CRT_WARN, "Dumping objects ->\n");
+
+    _CrtMemBlockHeader* const stop_block{state ? state->pBlockHeader : nullptr};
+
+    for (_CrtMemBlockHeader* header{__acrt_first_block}; header != nullptr && header != stop_block; header = header->_block_header_next)
+    {
+        if (_BLOCK_TYPE(header->_block_use) == _IGNORE_BLOCK)
+            continue;
+
+        if (_BLOCK_TYPE(header->_block_use) == _FREE_BLOCK)
+            continue;
+
+        if (_BLOCK_TYPE(header->_block_use) == _CRT_BLOCK && (_crtDbgFlag & _CRTDBG_CHECK_CRT_DF) == 0)
+            continue;
+
+        if (header->_file_name != nullptr)
+        {
+            if (!_CrtIsValidPointer(header->_file_name, 1, FALSE) || is_bad_read_pointer(header->_file_name, 1))
+            {
+                _RPTN(_CRT_WARN, "#File Error#(%d) : ", header->_line_number);
+            }
+            else
+            {
+                _RPTN(_CRT_WARN, "%hs(%d) : ", header->_file_name, header->_line_number);
+            }
+        }
+
+        _RPTN(_CRT_WARN, "{%ld} ", header->_request_number);
+
+        if (_BLOCK_TYPE(header->_block_use) == _CLIENT_BLOCK)
+        {
+            _RPTN(_CRT_WARN, "client block at 0x%p, subtype %x, %Iu bytes long.\n",
+                block_from_header(header),
+                _BLOCK_SUBTYPE(header->_block_use),
+                header->_data_size);
+
+            if (_pfnDumpClient && !is_bad_read_pointer(block_from_header(header), header->_data_size))
+            {
+                _pfnDumpClient(block_from_header(header), header->_data_size);
+            }
+            else
+            {
+                print_block_data(locale, header);
+            }
+        }
+        else if (header->_block_use == _NORMAL_BLOCK)
+        {
+            _RPTN(_CRT_WARN, "normal block at 0x%p, %Iu bytes long.\n",
+                block_from_header(header),
+                header->_data_size);
+
+            print_block_data(locale, header);
+        }
+        else if (_BLOCK_TYPE(header->_block_use) == _CRT_BLOCK)
+        {
+            _RPTN(_CRT_WARN, "crt block at 0x%p, subtype %x, %Iu bytes long.\n",
+                block_from_header(header),
+                _BLOCK_SUBTYPE(header->_block_use),
+                header->_data_size);
+
+            print_block_data(locale, header);
+        }
+    }
+}
+
+// Prints metadata for all blocks allocated since the provided state was taken.
+extern "C" void __cdecl _CrtMemDumpAllObjectsSince(_CrtMemState const* const state)
+{
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        dump_all_object_since_nolock(state);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    _RPT0(_CRT_WARN, "Object dump complete.\n");
+}
+
+
+
+// Dumps all currently active allocations in this heap.  Returns TRUE if there
+// are memory leaks; false otherwise.  It is assumed that all client allocations
+// remaining in the heap are memory leaks.
+extern "C" int __cdecl _CrtDumpMemoryLeaks()
+{
+    _CrtMemState state;
+    _CrtMemCheckpoint(&state);
+
+    if (state.lCounts[_CLIENT_BLOCK] != 0 ||
+        state.lCounts[_NORMAL_BLOCK] != 0 ||
+        (_crtDbgFlag & _CRTDBG_CHECK_CRT_DF && state.lCounts[_CRT_BLOCK] != 0))
+    {
+        _RPT0(_CRT_WARN, "Detected memory leaks!\n");
+
+        _CrtMemDumpAllObjectsSince(nullptr);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+
+// Prints some brief information about the provided state of the heap.
+extern "C" void __cdecl _CrtMemDumpStatistics(_CrtMemState const* const state)
+{
+    _VALIDATE_RETURN_VOID(state != nullptr, EINVAL);
+
+    for (unsigned use{0}; use < _MAX_BLOCKS; ++use)
+    {
+        _RPTN(_CRT_WARN, "%Id bytes in %Id %hs Blocks.\n",
+            state->lSizes[use],
+            state->lCounts[use],
+            block_use_names[use]);
+    }
+
+    _RPTN(_CRT_WARN, "Largest number used: %Id bytes.\n", state->lHighWaterCount);
+    _RPTN(_CRT_WARN, "Total allocations: %Id bytes.\n",   state->lTotalCount);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Aligned Allocation
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions are equivalent to the normal aligned allocation functions in
+// alignment.cpp, but these functions (suffixed with _dbg instead of _base) utilize
+// the debug heap and accept the file name and line number as arguments.  Consult
+// alignment.cpp for more information on the behavior of these functions.
+struct _AlignMemBlockHdr
+{
+    void*         _head;
+    unsigned char _gap[align_gap_size];
+};
+
+
+
+#define IS_2_POW_N(X)   ((X) != 0 && ((X) & ((X) - 1)) == 0)
+
+
+
+extern "C" void* __cdecl _aligned_malloc_dbg(
+    size_t      const size,
+    size_t      const alignment,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return _aligned_offset_malloc_dbg(size, alignment, 0, file_name, line_number);
+}
+
+extern "C" void* __cdecl _aligned_offset_malloc_dbg(
+    size_t      const size,
+    size_t            alignment,
+    size_t      const offset,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    _VALIDATE_RETURN(IS_2_POW_N(alignment),        EINVAL, nullptr);
+    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
+
+    alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) - 1;
+
+    uintptr_t const t_ptr = (0 -offset) & (sizeof(uintptr_t) -1);
+
+    size_t const nonuser_size = t_ptr + alignment + sizeof(_AlignMemBlockHdr); // Cannot overflow
+    size_t const block_size = size + nonuser_size;
+    _VALIDATE_RETURN_NOEXC(size <= block_size, ENOMEM, nullptr);
+
+    uintptr_t const ptr = reinterpret_cast<uintptr_t>(_malloc_dbg(block_size, _NORMAL_BLOCK, file_name, line_number));
+    if (ptr == reinterpret_cast<uintptr_t>(nullptr))
+        return nullptr;
+
+    uintptr_t const r_ptr = ((ptr +nonuser_size +offset)&~alignment)-offset;
+    _AlignMemBlockHdr* const header_from_block = reinterpret_cast<_AlignMemBlockHdr*>(r_ptr - t_ptr) - 1;
+    memset(header_from_block->_gap, align_land_fill, align_gap_size);
+    header_from_block->_head = reinterpret_cast<void*>(ptr);
+    return reinterpret_cast<void*>(r_ptr);
+}
+
+extern "C" void* __cdecl _aligned_realloc_dbg(
+    void*       const block,
+    size_t      const size,
+    size_t      const alignment,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return _aligned_offset_realloc_dbg(block, size, alignment, 0, file_name, line_number);
+}
+
+extern "C" void* __cdecl _aligned_recalloc_dbg(
+    void*       const block,
+    size_t      const count,
+    size_t      const size,
+    size_t      const alignment,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return _aligned_offset_recalloc_dbg(block, count, size, alignment, 0, file_name, line_number);
+}
+
+extern "C" void* __cdecl _aligned_offset_realloc_dbg(
+    void * block,
+    size_t size,
+    size_t alignment,
+    size_t offset,
+    const char * file_name,
+    int line_number
+    )
+{
+    uintptr_t ptr, r_ptr, t_ptr, mov_sz;
+    _AlignMemBlockHdr *header_from_block, *s_header_from_block;
+    size_t nonuser_size, block_size;
+
+    if (block == nullptr)
+    {
+        return _aligned_offset_malloc_dbg(size, alignment, offset, file_name, line_number);
+    }
+    if (size == 0)
+    {
+        _aligned_free_dbg(block);
+        return nullptr;
+    }
+
+    s_header_from_block = (_AlignMemBlockHdr *)((uintptr_t)block & ~(sizeof(uintptr_t) -1)) -1;
+
+    if (check_bytes((unsigned char *)block -no_mans_land_size, no_mans_land_fill, no_mans_land_size))
+    {
+        // We don't know where (file, linenum) block was allocated
+        _RPTN(_CRT_ERROR, "The block at 0x%p was not allocated by _aligned routines, use realloc()", block);
+        errno = EINVAL;
+        return nullptr;
+    }
+
+    if(!check_bytes(s_header_from_block->_gap, align_land_fill, align_gap_size))
+    {
+        // We don't know where (file, linenum) block was allocated
+        _RPTN(_CRT_ERROR, "Damage before 0x%p which was allocated by aligned routine\n", block);
+    }
+
+    /* validation section */
+    _VALIDATE_RETURN(IS_2_POW_N(alignment),        EINVAL, nullptr);
+    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
+
+    mov_sz = _msize_dbg(s_header_from_block->_head, _NORMAL_BLOCK) - ((uintptr_t)block - (uintptr_t)s_header_from_block->_head);
+
+    alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) -1;
+
+    t_ptr = (0 -offset) & (sizeof(uintptr_t) - 1);
+
+    nonuser_size = t_ptr + alignment + sizeof(_AlignMemBlockHdr); // Cannot overflow
+    block_size = size + nonuser_size;
+    _VALIDATE_RETURN_NOEXC(size <= block_size, ENOMEM, nullptr);
+
+    if ((ptr = (uintptr_t)_malloc_dbg(block_size, _NORMAL_BLOCK, file_name, line_number)) == (uintptr_t)nullptr)
+        return nullptr;
+
+    r_ptr = ((ptr + nonuser_size + offset) & ~alignment) - offset;
+    header_from_block = (_AlignMemBlockHdr*)(r_ptr - t_ptr) - 1;
+    memset(header_from_block->_gap, align_land_fill, align_gap_size);
+    header_from_block->_head = reinterpret_cast<void*>(ptr);
+
+    memcpy(reinterpret_cast<void*>(r_ptr), block, mov_sz > size ? size : mov_sz);
+    _free_dbg(s_header_from_block->_head, _NORMAL_BLOCK);
+
+    return (void *) r_ptr;
+}
+
+extern "C" size_t __cdecl _aligned_msize_dbg(
+    void*  const block,
+    size_t       alignment,
+    size_t const offset
+    )
+{
+    size_t header_size = 0; // Size of the header block
+    size_t footer_size = 0; // Size of the footer block
+    size_t total_size  = 0; // total size of the allocated block
+    size_t user_size   = 0; // size of the user block
+    uintptr_t gap      = 0; // keep the alignment of the data block
+                            // after the sizeof(void*) aligned pointer
+                            // to the beginning of the allocated block
+
+    // HEADER SIZE + FOOTER SIZE = GAP + ALIGN + SIZE OF A POINTER
+    // HEADER SIZE + USER SIZE + FOOTER SIZE = TOTAL SIZE
+    _VALIDATE_RETURN (block != nullptr, EINVAL, static_cast<size_t>(-1));
+
+    _AlignMemBlockHdr* header_from_block = nullptr; // points to the beginning of the allocated block
+    header_from_block = (_AlignMemBlockHdr*)((uintptr_t)block & ~(sizeof(uintptr_t) - 1)) - 1;
+    total_size = _msize_dbg(header_from_block->_head, _NORMAL_BLOCK);
+    header_size = (uintptr_t)block - (uintptr_t)header_from_block->_head;
+    gap = (0 - offset) & (sizeof(uintptr_t) - 1);
+    // The alignment cannot be smaller than the sizeof(uintptr_t)
+    alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) - 1;
+    footer_size = gap + alignment + sizeof(_AlignMemBlockHdr) - header_size;
+    user_size = total_size - header_size - footer_size;
+    return user_size;
+}
+
+extern "C" void* __cdecl _aligned_offset_recalloc_dbg(
+    void*       const block,
+    size_t      const count,
+    size_t      const element_size,
+    size_t      const alignment,
+    size_t      const offset,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    _VALIDATE_RETURN_NOEXC(count == 0 || _HEAP_MAXREQ / count >= element_size, ENOMEM, nullptr);
+
+    size_t const old_allocation_size{block ? _aligned_msize_dbg(block, alignment, offset) : 0};
+    size_t const new_allocation_size{element_size * count};
+
+    void* const new_block{_aligned_offset_realloc_dbg(block, new_allocation_size, alignment, offset, file_name, line_number)};
+    if (!new_block)
+        return nullptr;
+
+    if (old_allocation_size < new_allocation_size)
+        memset(static_cast<unsigned char*>(new_block) + old_allocation_size, 0, new_allocation_size - old_allocation_size);
+
+    return new_block;
+}
+
+extern "C" void __cdecl _aligned_free_dbg(void* const block)
+{
+    if (!block)
+        return;
+
+    _AlignMemBlockHdr* const header{reinterpret_cast<_AlignMemBlockHdr*>(
+        reinterpret_cast<uintptr_t>(block) & ~(sizeof(uintptr_t) - 1)
+    ) -1};
+
+    if (check_bytes(static_cast<unsigned char*>(block) - no_mans_land_size, no_mans_land_fill, no_mans_land_size))
+    {
+        // We don't know where (file, linenum) block was allocated
+        _RPTN(_CRT_ERROR, "The block at 0x%p was not allocated by _aligned routines, use free()", block);
+        return;
+    }
+
+    if (!check_bytes(header->_gap, align_land_fill, align_gap_size))
+    {
+        // We don't know where (file, linenum) block was allocated
+        _RPTN(_CRT_ERROR, "Damage before 0x%p which was allocated by aligned routine\n", block);
+    }
+
+    _free_dbg(header->_head, _NORMAL_BLOCK);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/debug_heap_hook.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/debug_heap_hook.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d1f80f8ed20135fc47b29bf3f7300339ed440b1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/debug_heap_hook.cpp	
@@ -0,0 +1,40 @@
+//
+// debug_heap_hook.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of the default debug heap allocation hook.  This is in its own
+// object so that it may be replaced by a client hook at link time when the
+// static CRT is used.
+//
+#ifndef _DEBUG
+    #error This file is supported only in debug builds
+#endif
+
+#include <corecrt_internal.h>
+
+
+
+// A default heap allocation hook that permits all allocations
+extern "C" int __cdecl _CrtDefaultAllocHook(
+    int                  const allocation_type,
+    void*                const data,
+    size_t               const size,
+    int                  const block_use,
+    long                 const request,
+    unsigned char const* const file_name,
+    int                  const line_number
+    )
+{
+    UNREFERENCED_PARAMETER(allocation_type);
+    UNREFERENCED_PARAMETER(data);
+    UNREFERENCED_PARAMETER(size);
+    UNREFERENCED_PARAMETER(block_use);
+    UNREFERENCED_PARAMETER(request);
+    UNREFERENCED_PARAMETER(file_name);
+    UNREFERENCED_PARAMETER(line_number);
+
+    return 1; // Allow all heap operations
+}
+
+extern "C" _CRT_ALLOC_HOOK _pfnAllocHook = _CrtDefaultAllocHook;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/expand.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/expand.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b7cc1be9e217ddef44a6077173e112f8ac68cd8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/expand.cpp	
@@ -0,0 +1,100 @@
+//
+// expand.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _expand().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+
+
+// Enclaves have a different heap implementation.
+
+#ifdef _UCRT_ENCLAVE_BUILD
+
+// Tests whether the allocation contraction is possible
+__inline static bool is_contraction_possible(size_t const) throw()
+{
+    return FALSE;
+}
+
+#else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */
+
+// Tests whether the allocation contraction is possible
+__inline static bool is_contraction_possible(size_t const old_size) throw()
+{
+    // Check if object allocated on low fragmentation heap.
+    //The LFH can only allocate blocks up to 16KB in size.
+    if (old_size <= 0x4000)
+    {
+        LONG heap_type = -1;
+        if (!HeapQueryInformation(
+            __acrt_heap,
+            HeapCompatibilityInformation,
+            &heap_type,
+            sizeof(heap_type),
+            nullptr))
+        {
+            return FALSE;
+        }
+        return heap_type != 2;
+    }
+    // Contraction possible for objects not on the LFH
+    return TRUE;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+
+// This function implements the logic of expand().  It is called directly by the
+// _expand() function in the Release CRT, and called by the debug heap in the
+// Debug CRT.
+//
+// This function must be marked noinline, otherwise _expand and
+// _expand_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because _expand
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _expand_base(void* const block, size_t const size)
+{
+    // Validation section
+    _VALIDATE_RETURN      (block != nullptr,     EINVAL, nullptr);
+    _VALIDATE_RETURN_NOEXC(size <= _HEAP_MAXREQ, ENOMEM, nullptr);
+
+    size_t const old_size = static_cast<size_t>(HeapSize(__acrt_heap, 0, block));
+    size_t const new_size = size == 0 ? 1 : size;
+
+    void* new_block = HeapReAlloc(__acrt_heap, HEAP_REALLOC_IN_PLACE_ONLY, block, new_size);
+    if (new_block != nullptr)
+        return new_block;
+
+    // If a failure to contract was caused by platform limitations, just
+    // return the original block.
+    if (new_size <= old_size && !is_contraction_possible(old_size))
+        return block;
+
+    errno = __acrt_errno_from_os_error(GetLastError());
+    return nullptr;
+}
+
+// Expands or contracts a block of memory in the heap.
+//
+// This function resizes a block of memory in the heap to 'size' bytes.  The
+// new size may be either greater (expansion) or less (contraction) than the
+// original size of the block.  This function never moves the block.  In the
+// case of expansion, if the block cannot be expanded to 'size', it is expanded
+// as much as possible.
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _expand_dbg and _expand_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to _expand
+// with either other function or vice versa.
+extern "C" _CRT_HYBRIDPATCHABLE __declspec(noinline) void* __cdecl _expand(void* const block, size_t const size)
+{
+    #ifdef _DEBUG
+    return _expand_dbg(block, size, _NORMAL_BLOCK, nullptr, 0);
+    #else
+    return _expand_base(block, size);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/free.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/free.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b4f34533b81ad9ce278e8482435c5d2b5b2a0ae
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/free.cpp	
@@ -0,0 +1,39 @@
+//
+// free.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of free().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+// Frees a block in the heap.  The 'block' pointer must either be a null pointer
+// or must point to a valid block in the heap.
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _free_dbg and _free_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to free
+// with either other function or vice versa.
+extern "C" _CRT_HYBRIDPATCHABLE __declspec(noinline) void __cdecl free(void* const block)
+{
+    // Arm64 and Arm64EC functions have a minimum size of 12, which is enough to detour.
+    // CHPE is not publicly available for 3rd party use, and CHPE binaries have FFS for
+    // applications to patch.  Hence, we don't need the dummy volatile variable write
+    // and read for the said architectures, which generate heavy stlr/ldar instuctions
+    // that do nothing but slow things down.
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC) && !defined(_M_HYBRID_X86_ARM64) && !defined(_MT)
+    // Some libraries that hook memory allocation routines (such as libtcmalloc)
+    // look for an appropriate place inside free to place a patch to its version
+    // of free. Without these extra instructions padding the call to _free_base,
+    // some libraries may choose to insert this patch in _free_base instead.
+    volatile int extra_instructions_for_patching_libraries = 0;
+    (void) extra_instructions_for_patching_libraries;
+#endif
+
+    #ifdef _DEBUG
+    _free_dbg(block, _NORMAL_BLOCK);
+    #else
+    _free_base(block);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/free_base.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/free_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a6280cbf30a4575e154671c8d6036b5b9a07f70e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/free_base.cpp	
@@ -0,0 +1,110 @@
+//
+// free_base.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _free_base().  This is defined in a different source file
+// from the free() function to allow free() to be replaced by the user.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+#if _UCRT_HEAP_MISMATCH_ANY && (defined _M_IX86 || defined _M_AMD64)
+
+    // Gets a handle to MSVCRT's private heap, if msvcrt is loaded for the
+    // current process.  Otherwise returns nullptr.
+    extern "C" HANDLE __cdecl __acrt_get_msvcrt_heap_handle()
+    {
+        static HANDLE global_msvcrt_heap_handle_cache = reinterpret_cast<HANDLE>(1);
+
+        HANDLE const cached_msvcrt_heap_handle = __crt_interlocked_read_pointer(&global_msvcrt_heap_handle_cache);
+        if (cached_msvcrt_heap_handle != reinterpret_cast<HANDLE>(1))
+        {
+            return cached_msvcrt_heap_handle;
+        }
+
+        HMODULE const msvcrt_module_handle = GetModuleHandleW(L"msvcrt.dll");
+        if (!msvcrt_module_handle)
+        {
+            // If msvcrt is not loaded, its heap does not exist:
+            __crt_interlocked_exchange_pointer(&global_msvcrt_heap_handle_cache, nullptr);
+            return nullptr;
+        }
+
+        typedef intptr_t (__cdecl* fp_get_heap_handle)();
+
+        // Get the exported function _get_heap_handle() from MSVCRT
+        fp_get_heap_handle const get_msvcrt_heap_handle =
+            reinterpret_cast<fp_get_heap_handle>(GetProcAddress(
+                msvcrt_module_handle,
+                "_get_heap_handle"));
+
+        if (!get_msvcrt_heap_handle)
+        {
+            __crt_interlocked_exchange_pointer(&global_msvcrt_heap_handle_cache, nullptr);
+            return nullptr;
+        }
+
+        HANDLE const new_msvcrt_heap_handle = reinterpret_cast<HANDLE>(get_msvcrt_heap_handle());
+        __crt_interlocked_exchange_pointer(&global_msvcrt_heap_handle_cache, new_msvcrt_heap_handle);
+        return new_msvcrt_heap_handle;
+    }
+
+#endif // _UCRT_HEAP_MISMATCH_ANY && (defined _M_IX86 || defined _M_AMD64)
+
+#if _UCRT_HEAP_MISMATCH_RECOVERY && (defined _M_IX86 || defined _M_AMD64)
+
+    static __forceinline HANDLE __cdecl select_heap(void* const block)
+    {
+        HANDLE const msvcrt_heap_handle = __acrt_get_msvcrt_heap_handle();
+        if (!msvcrt_heap_handle)
+        {
+            return __acrt_heap;
+        }
+
+        if (HeapValidate(__acrt_heap, 0, block))
+        {
+            return __acrt_heap;
+        }
+
+        if (HeapValidate(msvcrt_heap_handle, 0, block))
+        {
+            return msvcrt_heap_handle;
+        }
+
+        return __acrt_heap;
+    }
+
+#else // ^^^ Heap Mismatch Recovery ^^^ // vvv No Heap Mismatch Recovery vvv //
+
+    static __forceinline HANDLE __cdecl select_heap(void* const block)
+    {
+        UNREFERENCED_PARAMETER(block);
+
+        return __acrt_heap;
+    }
+
+#endif
+
+
+// This function implements the logic of free().  It is called directly by the
+// free() function in the Release CRT, and it is called by the debug heap in the
+// Debug CRT.
+//
+// This function must be marked noinline, otherwise free and
+// _free_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because free
+// needs to support users patching in custom implementations.
+extern "C" void __declspec(noinline) __cdecl _free_base(void* const block)
+{
+    if (block == nullptr)
+    {
+        return;
+    }
+
+    if (!HeapFree(select_heap(block), 0, block))
+    {
+        errno = __acrt_errno_from_os_error(GetLastError());
+    }
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heap_handle.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heap_handle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c53974341a37da12c073700b401de02ae81ded88
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heap_handle.cpp	
@@ -0,0 +1,52 @@
+//
+// heap_handle.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global CRT heap handle and initialization/termination functions.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+
+
+// The CRT heap handle.  This global variable is modified only during CRT
+// startup and CRT shutdown.
+extern "C" HANDLE __acrt_heap = nullptr;
+
+
+
+// Initializes the heap.  This function must be called during CRT startup, and
+// must be called before any user code that might use the heap is executed.
+extern "C" bool __cdecl __acrt_initialize_heap()
+{
+    __acrt_heap = GetProcessHeap();
+    if (__acrt_heap == nullptr)
+        return false;
+
+    return true;
+}
+
+// Uninitializes the heap.  This function should be called during CRT shutdown,
+// after any user code that might use the heap has stopped running.
+extern "C" bool __cdecl __acrt_uninitialize_heap(bool const /* terminating */)
+{
+    __acrt_heap = nullptr;
+    return true;
+}
+
+// Gets the HANDLE of the CRT heap.  Because the CRT always uses the process
+// heap, this function always returns the same thing as GetProcessHeap().
+extern "C" intptr_t __cdecl _get_heap_handle()
+{
+    _ASSERTE(__acrt_heap != nullptr);
+    return reinterpret_cast<intptr_t>(__acrt_heap);
+}
+
+// Internal CRT function to get the HANDLE of the CRT heap, that returns a
+// HANDLE instead of an intptr_t.
+extern "C" HANDLE __acrt_getheap()
+{
+    _ASSERTE(__acrt_heap != nullptr);
+    return __acrt_heap;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapchk.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapchk.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d4c8866f20468a32bfb27d81bef4eaa15d9f55a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapchk.cpp	
@@ -0,0 +1,21 @@
+//
+// heapchk.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _heapchk().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+// Performs a consistency check on the heap.  The return value is one of the
+// following:
+//  * _HEAPOK       The validation of the heap completed successfully
+//  * _HEAPBADNODE  Some node in the heap is malformed and the heap is corrupt
+extern "C" int __cdecl _heapchk()
+{
+    if (!HeapValidate(__acrt_heap, 0, nullptr))
+        return _HEAPBADNODE;
+
+    return _HEAPOK;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapmin.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapmin.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec77d2914603f90e49b32d18ec5ebb6ed34059f0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapmin.cpp	
@@ -0,0 +1,19 @@
+//
+// heapmin.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _heapmin().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+// Minimizes the heap, freeing as much memory as possible back to the OS.
+// Returns 0 on success, -1 on failure.
+extern "C" int __cdecl _heapmin()
+{
+    if (!HeapCompact(__acrt_heap, 0))
+        return -1;
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapwalk.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapwalk.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e9e8fea28c8738ffbf6150689fe37a5e9052444
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/heapwalk.cpp	
@@ -0,0 +1,90 @@
+//
+// heapwalk.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _heapwalk().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+
+
+// Calls HeapWalk and guards against access violations in case a bad pointer is
+// passed to the CRT _heapwalk function (or in case the heap is corrupt).
+static int __cdecl try_walk(PROCESS_HEAP_ENTRY* const win32_entry) throw()
+{
+    __try
+    {
+        if (HeapWalk(__acrt_heap, win32_entry))
+            return _HEAPOK;
+
+        if (GetLastError() == ERROR_NO_MORE_ITEMS)
+            return _HEAPEND;
+
+        return _HEAPBADNODE;
+    }
+    __except(GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
+    {
+        return _HEAPBADNODE;
+    }
+}
+
+// Walks the heap, returning information on one entry at a time.  If there are
+// multiple threads in the process that are allocating using the process heap,
+// the caller must lock the heap for the duration of the heap walk, by calling
+// the Windows API HeapLock.  See the documentation of HeapWalk for more
+// information.
+//
+// The return value is one of the following:
+//  * _HEAPOK       The call completed successfully and returned a node
+//  * _HEAPBADPTR   The provided 'entry' pointer is invalid
+//  * _HEAPBADBEGIN The initial node cannot be found in the heap
+//  * _HEAPBADNODE  A node was malformed or the heap is corrupt
+//  * _HEAPEND      The end of the heap was successfully reached
+extern "C" int __cdecl _heapwalk(_HEAPINFO* const entry)
+{
+    // Validation section
+    _VALIDATE_RETURN(entry != nullptr, EINVAL, _HEAPBADPTR);
+
+    PROCESS_HEAP_ENTRY win32_entry = { 0 };
+    win32_entry.wFlags = 0;
+    win32_entry.iRegionIndex = 0;
+    win32_entry.lpData = entry->_pentry;
+
+    // If _pentry is nullptr, then we're just starting the heap walk:
+    if (win32_entry.lpData == nullptr)
+    {
+        if (!HeapWalk(__acrt_heap, &win32_entry))
+            return _HEAPBADBEGIN;
+    }
+    else
+    {
+        if (entry->_useflag == _USEDENTRY)
+        {
+            if (!HeapValidate(__acrt_heap, 0, entry->_pentry))
+                return _HEAPBADNODE;
+
+            win32_entry.wFlags = PROCESS_HEAP_ENTRY_BUSY;
+        }
+
+        int const status = try_walk(&win32_entry);
+        if (status != _HEAPOK)
+            return status;
+    }
+
+    for (;;)
+    {
+        if (win32_entry.wFlags & PROCESS_HEAP_ENTRY_BUSY)
+        {
+            entry->_pentry = static_cast<int*>(win32_entry.lpData);
+            entry->_size = win32_entry.cbData;
+            entry->_useflag = _USEDENTRY;
+            return _HEAPOK;
+        }
+
+        int const status = try_walk(&win32_entry);
+        if (status != _HEAPOK)
+            return status;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/malloc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/malloc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7add8a68b4bd7e31e50ed345d71f8af00893293
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/malloc.cpp	
@@ -0,0 +1,27 @@
+//
+// malloc.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of malloc().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+
+
+// Allocates a block of memory of size 'size' bytes in the heap.  If allocation
+// fails, nullptr is returned.
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _malloc_dbg and _malloc_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to malloc
+// with either other function or vice versa.
+extern "C" _CRT_HYBRIDPATCHABLE __declspec(noinline) _CRTRESTRICT void* __cdecl malloc(size_t const size)
+{
+    #ifdef _DEBUG
+    return _malloc_dbg(size, _NORMAL_BLOCK, nullptr, 0);
+    #else
+    return _malloc_base(size);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/malloc_base.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/malloc_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2f771a747a2a4f1efad9070b90ec99a0562edbf6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/malloc_base.cpp	
@@ -0,0 +1,47 @@
+//
+// malloc_base.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _malloc_base().  This is defined in a different source file
+// from the malloc() function to allow malloc() to be replaced by the user.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <new.h>
+
+
+
+// This function implements the logic of malloc().  It is called directly by the
+// malloc() function in the Release CRT and is called by the debug heap in the
+// Debug CRT.
+//
+// This function must be marked noinline, otherwise malloc and
+// _malloc_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because malloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _malloc_base(size_t const size)
+{
+    // Ensure that the requested size is not too large:
+    _VALIDATE_RETURN_NOEXC(_HEAP_MAXREQ >= size, ENOMEM, nullptr);
+
+    // Ensure we request an allocation of at least one byte:
+    size_t const actual_size = size == 0 ? 1 : size;
+
+    for (;;)
+    {
+        void* const block = HeapAlloc(__acrt_heap, 0, actual_size);
+        if (block)
+            return block;
+
+        // Otherwise, see if we need to call the new handler, and if so call it.
+        // If the new handler fails, just return nullptr:
+        if (_query_new_mode() == 0 || !_callnewh(actual_size))
+        {
+            errno = ENOMEM;
+            return nullptr;
+        }
+
+        // The new handler was successful; try to allocate again...
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/msize.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/msize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73fc67433613dcb4b26efd0eda62a0db800ac0c6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/msize.cpp	
@@ -0,0 +1,42 @@
+//
+// msize.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of msize().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+
+
+// This function implements the logic of _msize().  It is called only in the
+// Release CRT.  The Debug CRT has its own implementation of this function.
+//
+// This function must be marked noinline, otherwise _msize and
+// _msize_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because _msize
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) size_t __cdecl _msize_base(void* const block) noexcept
+{
+    // Validation section
+    _VALIDATE_RETURN(block != nullptr, EINVAL, static_cast<size_t>(-1));
+
+    return static_cast<size_t>(HeapSize(__acrt_heap, 0, block));
+}
+
+// Calculates the size of the specified block in the heap.  'block' must be a
+// pointer to a valid block of heap-allocated memory (it must not be nullptr).
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _msize_dbg and _msize_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to _msize
+// with either other function or vice versa.
+extern "C" _CRT_HYBRIDPATCHABLE __declspec(noinline) size_t __cdecl _msize(void* const block)
+{
+    #ifdef _DEBUG
+    return _msize_dbg(block, _NORMAL_BLOCK);
+    #else
+    return _msize_base(block);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/new_handler.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/new_handler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f12e5de032d0b90f43f0ecdcb9a501da9992e454
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/new_handler.cpp	
@@ -0,0 +1,83 @@
+//
+// new_handler.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of the new handler and related functions..
+//
+#include <corecrt_internal.h>
+#include <new.h>
+
+// The global new handler.  This pointer should only be accessed via the
+// functions defined in this source file.
+static __crt_state_management::dual_state_global<_PNH> __acrt_new_handler;
+
+
+
+// Initializes the new handler to the encoded nullptr value.
+extern "C" void __cdecl __acrt_initialize_new_handler(void* const encoded_null)
+{
+    __acrt_new_handler.initialize(reinterpret_cast<_PNH>(encoded_null));
+}
+
+// Sets the new handler to the new new handler and returns the old handler.
+_PNH __cdecl _set_new_handler(_PNH new_handler)
+{
+    _PNH result = nullptr;
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        result = __crt_fast_decode_pointer(__acrt_new_handler.value());
+        __acrt_new_handler.value() = __crt_fast_encode_pointer(new_handler);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return result;
+}
+
+// Sets the new handler to nullptr and returns the old handler.  The argument
+// must be zero.  This overload is used to enable a caller to pass nullptr.
+_PNH __cdecl _set_new_handler(int const new_handler)
+{
+    // This is referenced only in the Debug CRT build
+    UNREFERENCED_PARAMETER(new_handler);
+
+    _ASSERTE(new_handler == 0);
+
+    return _set_new_handler(__crt_fast_encode_pointer(nullptr));
+}
+
+// Gets the current new handler.
+_PNH __cdecl _query_new_handler()
+{
+    _PNH result = nullptr;
+
+    __acrt_lock(__acrt_heap_lock);
+    __try
+    {
+        result = __crt_fast_decode_pointer(__acrt_new_handler.value());
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_heap_lock);
+    }
+
+    return result;
+}
+
+// Calls the currently registered new handler with the provided size.  If the
+// new handler succeeds, this function returns 1.  This function returns 0 on
+// failure.  The new handler may throw std::bad_alloc.
+extern "C" int __cdecl _callnewh(size_t const size)
+{
+    _PNH const pnh = _query_new_handler();
+
+    if (pnh == nullptr || (*pnh)(size) == 0)
+        return 0;
+
+    return 1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/new_mode.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/new_mode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1ef7115e378f4b7456ad98830524c24d1b09b414
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/new_mode.cpp	
@@ -0,0 +1,31 @@
+//
+// new_mode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of _set_new_mode and _query_new_mode, which provide access to the
+// _newmode global flag.
+//
+#include <corecrt_internal.h>
+#include <new.h>
+
+
+
+static __crt_state_management::dual_state_global<long> __acrt_global_new_mode;
+
+
+
+// Sets the _newmode flag to the new value 'mode' and return the old mode.
+extern "C" int __cdecl _set_new_mode(int const mode)
+{
+    // The only valid values of _newmode are 0 and 1:
+    _VALIDATE_RETURN(mode == 0 || mode == 1, EINVAL, -1);
+
+    return static_cast<int>(_InterlockedExchange(&__acrt_global_new_mode.value(), mode));
+}
+
+// Gets the current value of the _newmode flag.
+extern "C" int __cdecl _query_new_mode()
+{
+    return static_cast<int>(__crt_interlocked_read(&__acrt_global_new_mode.value()));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/realloc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/realloc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..31ef47b24b0ecb399f4ed7af46e16b20e4e1272f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/realloc.cpp	
@@ -0,0 +1,41 @@
+//
+// realloc.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of realloc().
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+// Reallocates a block of memory in the heap.
+//
+// This function reallocates the block pointed to by 'block' such that it is
+// 'size' bytes in size.  The new size may be either greater or less than the
+// original size of the block.  The reallocation may result in the block being
+// moved to a new location in memory.  If the block is moved, the contents of
+// the original block are copied.
+//
+// Standard behavior notes:
+// [1] realloc(nullptr, new_size) is equivalent to malloc(new_size)
+// [2] realloc(p, 0) is equivalent to free(p), and nullptr is returned
+// [3] If reallocation fails, the original block is left unchanged
+//
+// If 'block' is non-null, it must point to a valid block of memory allocated in
+// the heap.
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _realloc_dbg and _realloc_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to realloc
+// with either other function or vice versa.
+extern "C" _CRT_HYBRIDPATCHABLE __declspec(noinline) _CRTRESTRICT void* __cdecl realloc(
+    void*  const block,
+    size_t const size
+    )
+{
+    #ifdef _DEBUG
+    return _realloc_dbg(block, size, _NORMAL_BLOCK, nullptr, 0);
+    #else
+    return _realloc_base(block, size);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/realloc_base.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/realloc_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39901fd2ab71d32e196cd132bbe89093dec0af21
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/realloc_base.cpp	
@@ -0,0 +1,59 @@
+//
+// realloc_base.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _realloc_base().  This is defined in a different source
+// file from the realloc() function to allow realloc() to be replaced by the
+// user.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <new.h>
+
+
+
+// This function implements the logic of realloc().  It is called directly by
+// the realloc() and _recalloc() functions in the Release CRT and is called by
+// the debug heap in the Debug CRT.
+//
+// This function must be marked noinline, otherwise realloc and
+// _realloc_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because realloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _realloc_base(
+    void*  const block,
+    size_t const size
+    )
+{
+    // If the block is a nullptr, just call malloc:
+    if (block == nullptr)
+        return _malloc_base(size);
+
+    // If the new size is 0, just call free and return nullptr:
+    if (size == 0)
+    {
+        _free_base(block);
+        return nullptr;
+    }
+
+    // Ensure that the requested size is not too large:
+    _VALIDATE_RETURN_NOEXC(_HEAP_MAXREQ >= size, ENOMEM, nullptr);
+
+    for (;;)
+    {
+        void* const new_block = HeapReAlloc(__acrt_heap, 0, block, size);
+        if (new_block)
+            return new_block;
+
+        // Otherwise, see if we need to call the new handler, and if so call it.
+        // If the new handler fails, just return nullptr:
+        if (_query_new_mode() == 0 || !_callnewh(size))
+        {
+            errno = ENOMEM;
+            return nullptr;
+        }
+
+        // The new handler was successful; try to allocate again...
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/recalloc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/recalloc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..790969d2dc4e26c309c8868026c7214b31e6a092
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/heap/recalloc.cpp	
@@ -0,0 +1,70 @@
+//
+// recalloc.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Implementation of _recalloc()
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <string.h>
+
+
+
+// This function provides the logic for the _recalloc() function.  It is called
+// only in the Release CRT (in the Debug CRT, the debug heap has its own
+// implementation of _recalloc()).
+//
+// This function must be marked noinline, otherwise recalloc and
+// _recalloc_base will have identical COMDATs, and the linker will fold
+// them when calling one from the CRT. This is necessary because recalloc
+// needs to support users patching in custom implementations.
+extern "C" __declspec(noinline) void* __cdecl _recalloc_base(
+    void*  const block,
+    size_t const count,
+    size_t const size
+    )
+{
+    // Ensure that (count * size) does not overflow
+    _VALIDATE_RETURN_NOEXC(count == 0 || (_HEAP_MAXREQ / count) >= size, ENOMEM, nullptr);
+
+    size_t const old_block_size = block != nullptr ? _msize_base(block) : 0;
+    size_t const new_block_size = count * size;
+
+    void* const new_block = _realloc_base(block, new_block_size);
+
+    // If the reallocation succeeded and the new block is larger, zero-fill the
+    // new bytes:
+    if (new_block != nullptr && old_block_size < new_block_size)
+    {
+        memset(static_cast<char*>(new_block) + old_block_size, 0, new_block_size - old_block_size);
+    }
+
+    return new_block;
+}
+
+// Reallocates a block of memory in the heap.
+//
+// This function reallocates the block pointed to by 'block' such that it is
+// 'count * size' bytes in size.  The new size may be either greater or less
+// than the original size of the block.  If the new size is greater than the
+// original size, the new bytes are zero-filled.  This function shares its
+// implementation with the realloc() function; consult the comments of that
+// function for more information about the implementation.
+//
+// This function supports patching and therefore must be marked noinline.
+// Both _recalloc_dbg and _recalloc_base must also be marked noinline
+// to prevent identical COMDAT folding from substituting calls to _recalloc
+// with either other function or vice versa.
+extern "C" __declspec(noinline) _CRTRESTRICT void* __cdecl _recalloc(
+    void*  const block,
+    size_t const count,
+    size_t const size
+    )
+{
+    #ifdef _DEBUG
+    return _recalloc_dbg(block, count, size, _NORMAL_BLOCK, nullptr, 0);
+    #else
+    return _recalloc_base(block, count, size);
+    #endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal.h
new file mode 100644
index 0000000000000000000000000000000000000000..d941f891f69ec49d2295d79013738ba7280f0baa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal.h	
@@ -0,0 +1,2145 @@
+//
+// corecrt_internal.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CoreCRT Internals
+//
+#pragma once
+
+#include <corecrt.h>
+#include <corecrt_startup.h>
+#include <corecrt_terminate.h>
+#include <corecrt_wctype.h>
+#include <corecrt_internal_ffs.h>
+#include <crtdbg.h>
+#include <ctype.h>
+#include <errno.h>
+#include <excpt.h>
+#include <internal_shared.h>
+#include <limits.h>
+#include <malloc.h>
+#include <process.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <vcruntime_startup.h>
+#include <windows.h>
+#include <appmodel.h>
+
+#ifdef __cplusplus
+    #include <roapi.h>
+#endif
+
+_CRT_BEGIN_C_HEADER
+
+#if defined(_DLL) && !defined(_DEBUG)
+#define _UCRT_DLL 1
+#else
+#define _UCRT_DLL 0
+#endif
+
+#define _DEFINE_SET_FUNCTION(function_name, type, variable_name) \
+    __inline void function_name(type value)                      \
+    {                                                            \
+        __pragma(warning(push))                                  \
+        __pragma(warning(disable:4996))                          \
+        variable_name = value;                                   \
+        __pragma(warning(pop))                                   \
+    }
+
+
+
+#if defined _M_IX86
+    #define _CRT_LINKER_SYMBOL_PREFIX "_"
+#elif defined _M_X64 || defined _M_ARM || defined _M_ARM64
+    #define _CRT_LINKER_SYMBOL_PREFIX ""
+#else
+    #error Unsupported architecture
+#endif
+
+#define _CRT_LINKER_FORCE_INCLUDE(name) \
+    __pragma(comment(linker,            \
+        "/include:"                     \
+        _CRT_LINKER_SYMBOL_PREFIX #name \
+        ))
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// CRT SAL Annotations
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This macro can be used to annotate a buffer when it has the option that
+// _CRT_UNBOUNDED_BUFFER_SIZE may be passed as its size in order to invoke unsafe behavior.
+// void example(
+//    _Maybe_unsafe_(_Out_writes_z_, buffer_count) char * const buffer,
+//    _In_                                         size_t const buffer_size
+// )
+#define _CRT_UNBOUNDED_BUFFER_SIZE (static_cast<size_t>(-1))
+#define _Maybe_unsafe_(buffer_annotation, expr)                                                    \
+        _When_((expr < _CRT_UNBOUNDED_BUFFER_SIZE), buffer_annotation(expr))                       \
+        _When_((expr >= _CRT_UNBOUNDED_BUFFER_SIZE), buffer_annotation(_Inexpressible_("unsafe")))
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Forward declarations of __crt_state_management types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+extern "C++"
+{
+    namespace __crt_state_management
+    {
+        template <typename T>
+        class dual_state_global;
+    }
+}
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Dual-state globals (that shouldn't be exported directly)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+    extern __crt_state_management::dual_state_global<int>               _fmode;
+    extern __crt_state_management::dual_state_global<unsigned char*>    _mbctype;
+    extern __crt_state_management::dual_state_global<unsigned char*>    _mbcasemap;
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Dynamic Initialization Support
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#define _CORECRT_GENERATE_FORWARDER(prefix, callconv, name, callee_name)                     \
+    __pragma(warning(push))                                                                  \
+    __pragma(warning(disable: 4100)) /* unreferenced formal parameter */                     \
+    template <typename... Params>                                                            \
+    prefix auto callconv name(Params&&... args) throw() -> decltype(callee_name(args...))    \
+    {                                                                                        \
+        _BEGIN_SECURE_CRT_DEPRECATION_DISABLE                                                \
+        return callee_name(args...);                                                         \
+        _END_SECURE_CRT_DEPRECATION_DISABLE                                                  \
+    }                                                                                        \
+    __pragma(warning(pop))
+
+extern size_t const _sys_first_posix_error;
+extern size_t const _sys_last_posix_error;
+extern char const* const _sys_posix_errlist[];
+
+_Ret_z_
+__inline char const* _get_sys_err_msg(size_t const m)
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    if (m > _sys_last_posix_error || ((size_t)_sys_nerr < m && m < _sys_first_posix_error))
+        return _sys_errlist[_sys_nerr];
+    if (m <= (size_t)_sys_nerr)
+        return _sys_errlist[m];
+    else
+        return _sys_posix_errlist[m - _sys_first_posix_error];
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
+
+#ifdef __cplusplus
+    // The maximum number of characters (including null terminator) of a system
+    // error message.  Note:  This value must correspond to the number of characters
+    // in the longest message in the error list.
+    size_t const max_system_error_message_count = 38;
+
+    // The number of characters in the per-thread strerror buffer.  This has room
+    // for a 94 character user-provided prefix, a ": " delimiter, and one of the
+    // system error messages.
+    size_t const strerror_buffer_count = (94 + max_system_error_message_count + 2);
+#endif
+
+
+
+_Success_(return != 0)
+char* __cdecl __acrt_getpath(
+    _In_z_                       char const* delimited_paths,
+    _Out_writes_z_(buffer_count) char*       buffer,
+    _In_                         size_t      buffer_count
+    );
+
+_Success_(return != 0)
+wchar_t* __cdecl __acrt_wgetpath(
+    _In_z_                       wchar_t const* delimited_paths,
+    _Out_writes_z_(buffer_count) wchar_t*       buffer,
+    _In_                         size_t         buffer_count
+    );
+
+_Success_(return == 0)
+errno_t __acrt_expand_narrow_argv_wildcards(
+    _In_z_               char**  argv,
+    _Out_ _Deref_post_z_ char*** result
+    );
+
+_Success_(return == 0)
+errno_t __acrt_expand_wide_argv_wildcards(
+    _In_                 wchar_t**  argv,
+    _Out_ _Deref_post_z_ wchar_t*** result
+    );
+
+_Success_(return == 0)
+_Ret_range_(-1, 0)
+int __cdecl __acrt_pack_narrow_command_line_and_environment(
+    _In_z_                    char const* const* argv,
+    _In_opt_z_                char const* const* envp,
+    _Outptr_result_maybenull_ char**             command_line_result,
+    _Outptr_result_maybenull_ char**             environment_block_result
+    );
+
+_Success_(return == 0)
+_Ret_range_(-1, 0)
+int __cdecl __acrt_pack_wide_command_line_and_environment(
+    _In_z_                    wchar_t const* const* argv,
+    _In_opt_z_                wchar_t const* const* envp,
+    _Outptr_result_maybenull_ wchar_t**             command_line_result,
+    _Outptr_result_maybenull_ wchar_t**             environment_block_result
+    );
+
+_Ret_z_
+_Success_(return != 0)
+char** __acrt_capture_narrow_argv(
+    _In_                             va_list*    arglist,
+    _In_z_                           char const* first_argument,
+    _When_(return == caller_array, _Post_z_)
+    _Out_writes_(caller_array_count) char**      caller_array,
+    _In_                             size_t      caller_array_count
+    );
+
+_Ret_z_
+_Success_(return != 0)
+wchar_t** __acrt_capture_wide_argv(
+    _In_                             va_list*       arglist,
+    _In_z_                           wchar_t const* first_argument,
+    _When_(return == caller_array, _Post_z_)
+    _Out_writes_(caller_array_count) wchar_t**      caller_array,
+    _In_                             size_t         caller_array_count
+    );
+
+void __cdecl __acrt_call_reportfault(
+    int   nDbgHookCode,
+    DWORD dwExceptionCode,
+    DWORD dwExceptionFlags
+    );
+
+
+
+#ifndef _M_CEE_PURE
+    _DEFINE_SET_FUNCTION(_set_pgmptr,  _In_z_ char*,    _pgmptr)
+    _DEFINE_SET_FUNCTION(_set_wpgmptr, _In_z_ wchar_t*, _wpgmptr)
+#endif
+
+
+
+extern _CRT_ALLOC_HOOK _pfnAllocHook;
+
+BOOL __cdecl __acrt_CreateProcessA(
+    _In_opt_    LPCSTR                lpApplicationName,
+    _Inout_opt_ LPSTR                 lpCommandLine,
+    _In_opt_    LPSECURITY_ATTRIBUTES lpProcessAttributes,
+    _In_opt_    LPSECURITY_ATTRIBUTES lpThreadAttributes,
+    _In_        BOOL                  bInheritHandles,
+    _In_        DWORD                 dwCreationFlags,
+    _In_opt_    LPVOID                lpEnvironment,
+    _In_opt_    LPCSTR                lpCurrentDirectory,
+    _In_        LPSTARTUPINFOW        lpStartupInfo,
+    _Out_       LPPROCESS_INFORMATION lpProcessInformation
+    );
+
+_Success_(return > 0)
+DWORD __cdecl __acrt_GetTempPath2A(
+    DWORD nBufferLength,
+    _Out_writes_to_(nBufferLength, return + 1) PSTR lpBuffer
+    );
+
+DWORD __cdecl __acrt_GetModuleFileNameA(
+    _In_opt_                HMODULE hModule,
+    _When_(return < nSize, _Out_writes_to_(nSize, return + 1))
+    _When_(return == nSize, _Out_writes_all_(nSize) _Null_terminated_) char * lpFilename,
+    _In_range_(1, MAX_PATH) DWORD   nSize
+    );
+
+HMODULE __cdecl __acrt_LoadLibraryExA(
+    _In_       LPCSTR lpFileName,
+    _Reserved_ HANDLE  hFile,
+    _In_       DWORD   dwFlags
+    );
+
+BOOL __cdecl __acrt_SetEnvironmentVariableA(
+    _In_     LPCSTR lpName,
+    _In_opt_ LPCSTR lpValue
+    );
+
+BOOL __cdecl __acrt_SetCurrentDirectoryA(
+    _In_ LPCSTR lpPathName
+    );
+
+
+// Adding some defines which are used in dbgrpt.c
+#define DBGRPT_MAX_MSG 4096
+#define DBGRPT_TOOLONGMSG "_CrtDbgReport: String too long or IO Error"
+#define DBGRPT_INVALIDMSG "_CrtDbgReport: String too long or Invalid characters in String"
+
+#ifdef __cplusplus
+extern "C++"
+{
+    template <typename Character>
+    struct __crt_report_hook_node
+    {
+        using hook_type = int(__CRTDECL*)(int, Character*, int*);
+
+        __crt_report_hook_node* prev;
+        __crt_report_hook_node* next;
+        unsigned                refcount;
+        hook_type               hook;
+    };
+}
+#endif
+
+_Success_(return != 0)
+unsigned char* __cdecl __acrt_allocate_buffer_for_argv(
+    _In_ size_t argument_count,
+    _In_ size_t character_count,
+    _In_ size_t character_size
+    );
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// CoreCRT Shared Initialization Support
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+typedef bool (__cdecl* __acrt_initialize_pft  )(void);
+typedef bool (__cdecl* __acrt_uninitialize_pft)(bool);
+
+typedef struct __acrt_initializer
+{
+    __acrt_initialize_pft   _initialize;
+    __acrt_uninitialize_pft _uninitialize;
+} __acrt_initializer;
+
+bool __cdecl __acrt_execute_initializers(
+    _In_reads_(last - first) _In_ __acrt_initializer const* first,
+    _In_reads_(0) __acrt_initializer const* last
+    );
+
+bool __cdecl __acrt_execute_uninitializers(
+    _In_reads_(last - first) __acrt_initializer const* first,
+    _In_reads_(0) __acrt_initializer const* last
+    );
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// CoreCRT Fatal Runtime Error Reporting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+void __cdecl __acrt_report_runtime_error(_In_z_ wchar_t const* message);
+
+int __cdecl __acrt_show_narrow_message_box(
+    _In_opt_z_ char const* text,
+    _In_opt_z_ char const* caption,
+    _In_       unsigned    type
+    );
+
+int __cdecl __acrt_show_wide_message_box(
+    _In_opt_z_ wchar_t const* text,
+    _In_opt_z_ wchar_t const* caption,
+    _In_       unsigned       type
+    );
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Initialization
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+bool __cdecl __acrt_initialize_winapi_thunks(void);
+bool __cdecl __acrt_uninitialize_winapi_thunks(_In_ bool terminating);
+
+bool __cdecl __acrt_initialize_locks(void);
+bool __cdecl __acrt_uninitialize_locks(_In_ bool terminating);
+
+bool __cdecl __acrt_initialize_heap(void);
+bool __cdecl __acrt_uninitialize_heap(_In_ bool terminating);
+
+bool __cdecl __acrt_initialize_ptd(void);
+bool __cdecl __acrt_uninitialize_ptd(_In_ bool terminating);
+
+bool __cdecl __acrt_initialize_lowio(void);
+bool __cdecl __acrt_uninitialize_lowio(_In_ bool terminating);
+
+bool __cdecl __acrt_initialize_command_line(void);
+bool __cdecl __acrt_uninitialize_command_line(_In_ bool terminating);
+
+void __cdecl __acrt_initialize_invalid_parameter_handler(_In_opt_ void* encoded_null);
+void __cdecl __acrt_initialize_new_handler(_In_opt_ void* encoded_null);
+void __cdecl __acrt_initialize_signal_handlers(_In_opt_ void* encoded_null);
+void __cdecl __acrt_initialize_thread_local_exit_callback(_In_opt_ void * encoded_null);
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Locale
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The offset to where ctype will point.  Look in initctype.cpp for how it is
+// being used.  It was introduced so that pctype can work with unsigned char
+// types and EOF.  It is used only in initctype and setlocale.
+#define _COFFSET 127
+
+// Maximum lengths for the language name, country name, and full locale name.
+#define MAX_LANG_LEN 64
+#define MAX_CTRY_LEN 64
+#define MAX_LC_LEN   (MAX_LANG_LEN + MAX_CTRY_LEN + 3)
+
+#define MAX_CP_LEN   16  // Maximum code page name length
+#define CATNAMES_LEN 57  // "LC_COLLATE=;LC_CTYPE=;..." length
+
+#define LC_INT_TYPE  0
+#define LC_STR_TYPE  1
+#define LC_WSTR_TYPE 2
+
+#define _WSETLOCALE_AVOID_SYNC_LOCALE_BIT   0x10
+#define _PER_THREAD_LOCALE_BIT              0x2
+#define _GLOBAL_LOCALE_BIT                  0x1
+
+
+
+typedef struct __crt_locale_string_table
+{
+    wchar_t* szName;
+    wchar_t  chAbbrev[4];
+} __crt_locale_string_table;
+
+typedef struct __crt_locale_strings
+{
+    wchar_t szLanguage  [MAX_LANG_LEN];
+    wchar_t szCountry   [MAX_CTRY_LEN];
+    wchar_t szCodePage  [MAX_CP_LEN];
+    wchar_t szLocaleName[LOCALE_NAME_MAX_LENGTH];
+} __crt_locale_strings;
+
+typedef struct __crt_lc_time_data
+{
+    char*    wday_abbr [ 7];
+    char*    wday      [ 7];
+    char*    month_abbr[12];
+    char*    month     [12];
+    char*    ampm      [ 2];
+    char*    ww_sdatefmt;
+    char*    ww_ldatefmt;
+    char*    ww_timefmt;
+    int      ww_caltype;
+    long     refcount;
+    wchar_t* _W_wday_abbr [ 7];
+    wchar_t* _W_wday      [ 7];
+    wchar_t* _W_month_abbr[12];
+    wchar_t* _W_month     [12];
+    wchar_t* _W_ampm      [ 2];
+    wchar_t* _W_ww_sdatefmt;
+    wchar_t* _W_ww_ldatefmt;
+    wchar_t* _W_ww_timefmt;
+    wchar_t* _W_ww_locale_name;
+} __crt_lc_time_data;
+
+typedef struct __crt_ctype_compatibility_data
+{
+    unsigned long id;
+    int           is_clike;
+} __crt_ctype_compatibility_data;
+
+typedef struct __crt_qualified_locale_data
+{
+    // Static data for qualified locale code
+    wchar_t const* pchLanguage;
+    wchar_t const* pchCountry;
+    int            iLocState;
+    int            iPrimaryLen;
+    BOOL           bAbbrevLanguage;
+    BOOL           bAbbrevCountry;
+    UINT           _cachecp;
+    wchar_t        _cachein [MAX_LC_LEN];
+    wchar_t        _cacheout[MAX_LC_LEN];
+
+    // Static data for LC_CTYPE
+    __crt_ctype_compatibility_data _Loc_c[5];
+    wchar_t                        _cacheLocaleName[LOCALE_NAME_MAX_LENGTH];
+} __crt_qualified_locale_data;
+
+typedef struct __crt_qualified_locale_data_downlevel
+{
+    // Static data for the downlevel qualified locale code
+    int iLcidState;
+    LCID lcidLanguage;
+    LCID lcidCountry;
+} __crt_qualified_locale_data_downlevel;
+
+typedef struct __crt_multibyte_data
+{
+    long           refcount;
+    int            mbcodepage;
+    int            ismbcodepage;
+    unsigned short mbulinfo[6];
+    unsigned char  mbctype[257];
+    unsigned char  mbcasemap[256];
+    wchar_t const* mblocalename;
+} __crt_multibyte_data;
+
+typedef struct __crt_locale_refcount
+{
+    char*    locale;
+    wchar_t* wlocale;
+    long*    refcount;
+    long*    wrefcount;
+} __crt_locale_refcount;
+
+typedef struct __crt_locale_data
+{
+    __crt_locale_data_public  _public;
+    long                      refcount;
+    unsigned int              lc_collate_cp;
+    unsigned int              lc_time_cp;
+    int                       lc_clike;
+    __crt_locale_refcount     lc_category[6];
+    long*                     lconv_intl_refcount;
+    long*                     lconv_num_refcount;
+    long*                     lconv_mon_refcount;
+    struct lconv*             lconv;
+    long*                     ctype1_refcount;
+    unsigned short*           ctype1;
+    unsigned char const*      pclmap;
+    unsigned char const*      pcumap;
+    __crt_lc_time_data const* lc_time_curr;
+    wchar_t*                  locale_name[6];
+} __crt_locale_data;
+
+// Unusual: < 0 => string length
+//           else scan up to specified size or string length, whichever comes first
+// The name is based on _In_NLS_string_.
+#define _In_CRT_NLS_string_(size) _When_((size) < 0,  _In_z_)                               \
+                                  _When_((size) >= _String_length_(_Curr_), _Pre_z_)        \
+                                  _When_((size) < _String_length_(_Curr_), _In_reads_(size))
+
+// Wrappers for locale-related Windows API functionality
+int __cdecl __acrt_CompareStringA(
+    _In_opt_               _locale_t _Plocinfo,
+    _In_                   LPCWSTR   _LocaleName,
+    _In_                   DWORD     _DwCmpFlags,
+    _In_CRT_NLS_string_(_CchCount1) PCCH _LpString1,
+    _In_                   int       _CchCount1,
+    _In_CRT_NLS_string_(_CchCount2) PCCH _LpString2,
+    _In_                   int       _CchCount2,
+    _In_                   int       _CodePage
+    );
+
+int __cdecl __acrt_CompareStringW(
+    _In_                   LPCWSTR  _LocaleName,
+    _In_                   DWORD    _DwCmpFlags,
+    _In_CRT_NLS_string_(_CchCount1) PCWCH _LpString1,
+    _In_                   int      _CchCount1,
+    _In_CRT_NLS_string_(_CchCount2) PCWCH _LpString2,
+    _In_                   int      _CchCount2
+    );
+
+int __cdecl __acrt_GetLocaleInfoA(
+    _In_opt_ _locale_t _Locale,
+    _In_     int       _LCType,
+    _In_     LPCWSTR   _LocaleName,
+    _In_     LCTYPE    _FieldType,
+    _Out_    void*     _Address
+    );
+
+_Success_(return)
+BOOL __cdecl __acrt_GetStringTypeA(
+    _In_opt_            _locale_t _Plocinfo,
+    _In_                DWORD     _DWInfoType,
+    _In_NLS_string_(_CchSrc) PCCH _LpSrcStr,
+    _In_                int       _CchSrc,
+    _Out_               LPWORD    _LpCharType,
+    _In_                int       _CodePage,
+    _In_                BOOL      _BError
+    );
+
+_Success_(return)
+BOOL __cdecl __acrt_GetStringTypeW(
+    _In_                DWORD       _DWInfoType,
+    _In_NLS_string_(_CchSrc) PCWCH  _LpSrcStr,
+    _In_                int         _CchSrc,
+    _Out_               LPWORD      _LpCharType
+);
+
+_Success_(return != 0)
+int __cdecl __acrt_LCMapStringA(
+    _In_opt_                   _locale_t _Plocinfo,
+    _In_                       LPCWSTR   _LocaleName,
+    _In_                       DWORD     _DwMapFlag,
+    _In_CRT_NLS_string_(_CchSrc) PCCH    _LpSrcStr,
+    _In_                       int       _CchSrc,
+    _Out_writes_opt_(_CchDest) PCH       _LpDestStr,
+    _In_                       int       _CchDest,
+    _In_                       int       _CodePage,
+    _In_                       BOOL      _BError
+    );
+
+_Success_(return != 0)
+int __cdecl __acrt_LCMapStringW(
+    _In_                       LPCWSTR _LocaleName,
+    _In_                       DWORD   _DWMapFlag,
+    _In_CRT_NLS_string_(_CchSrc) PCWCH _LpSrcStr,
+    _In_                       int     _CchSrc,
+    _Out_writes_opt_(_CchDest) PWCH    _LpDestStr,
+    _In_                       int     _CchDest
+    );
+
+_Success_(return != 0)
+int __cdecl __acrt_MultiByteToWideChar(
+    _In_                           UINT    _CodePage,
+    _In_                           DWORD   _DWFlags,
+    _In_                           LPCSTR  _LpMultiByteStr,
+    _In_                           int     _CbMultiByte,
+    _Out_writes_opt_(_CchWideChar) LPWSTR  _LpWideCharStr,
+    _In_                           int     _CchWideChar
+    );
+
+_Success_(return != 0)
+int __cdecl __acrt_WideCharToMultiByte(
+    _In_                           UINT    _CodePage,
+    _In_                           DWORD   _DWFlags,
+    _In_                           LPCWSTR _LpWideCharStr,
+    _In_                           int     _CchWideChar,
+    _Out_writes_opt_(_CbMultiByte) LPSTR   _LpMultiByteStr,
+    _In_                           int     _CbMultiByte,
+    _In_opt_                       LPCSTR  _LpDefaultChar,
+    _Out_opt_                      LPBOOL  _LpUsedDefaultChar
+    );
+
+// Case-insensitive ASCII comparisons
+_Check_return_
+int __cdecl __ascii_memicmp(
+    _In_reads_bytes_(count) void const * lhs,
+    _In_reads_bytes_(count) void const * rhs,
+    _In_                    size_t       count
+    );
+
+_Check_return_
+int __cdecl __ascii_stricmp(
+    _In_z_ char const * lhs,
+    _In_z_ char const * rhs
+    );
+
+_Check_return_
+int __cdecl __ascii_strnicmp(
+    _In_reads_or_z_(count) char const * lhs,
+    _In_reads_or_z_(count) char const * rhs,
+    _In_                   size_t       count
+    );
+
+_Check_return_
+int __cdecl __ascii_wcsicmp(
+    _In_z_ const wchar_t * lhs,
+    _In_z_ const wchar_t * rhs
+    );
+
+_Check_return_
+int __cdecl __ascii_wcsnicmp(
+    _In_reads_or_z_(count) const wchar_t * lhs,
+    _In_reads_or_z_(count) const wchar_t * rhs,
+    _In_                  size_t          count
+    );
+
+
+// Locale reference counting
+void __cdecl __acrt_add_locale_ref    (__crt_locale_data*);
+void __cdecl __acrt_release_locale_ref(__crt_locale_data*);
+void __cdecl __acrt_free_locale       (__crt_locale_data*);
+
+long __cdecl __acrt_locale_add_lc_time_reference(
+    _In_opt_ __crt_lc_time_data const* lc_time
+    );
+
+long __cdecl __acrt_locale_release_lc_time_reference(
+    _In_opt_ __crt_lc_time_data const* lc_time
+    );
+
+void __cdecl __acrt_locale_free_lc_time_if_unreferenced(
+    _In_opt_ __crt_lc_time_data const* lc_time
+    );
+
+// Initialization and cleanup functions for locale categories
+_Success_(return == 0)
+int __cdecl __acrt_locale_initialize_ctype(
+    _Inout_ __crt_locale_data* locale_data
+    );
+
+_Success_(return == 0)
+int __cdecl __acrt_locale_initialize_monetary(
+    _Inout_ __crt_locale_data* locale_data
+    );
+
+_Success_(return == 0)
+int __cdecl __acrt_locale_initialize_numeric(
+    _Inout_ __crt_locale_data* locale_data
+    );
+
+_Success_(return == 0)
+int __cdecl __acrt_locale_initialize_time(
+    _Inout_ __crt_locale_data* locale_data
+    );
+
+void __cdecl __acrt_locale_free_monetary(
+    _Inout_ struct lconv* lconv
+    );
+
+void __cdecl __acrt_locale_free_numeric(
+    _Inout_ struct lconv* lconv
+    );
+
+void __cdecl __acrt_locale_free_time(
+    _Inout_opt_ __crt_lc_time_data* lc_time_data
+    );
+
+
+
+// Locale synchronization
+__crt_locale_data*    __cdecl __acrt_update_thread_locale_data   (void);
+__crt_multibyte_data* __cdecl __acrt_update_thread_multibyte_data(void);
+
+
+
+_Success_(return != 0)
+_Ret_z_
+_Check_return_
+wchar_t* __cdecl __acrt_copy_locale_name(
+    _In_z_ wchar_t const* locale_name
+    );
+
+_Success_(return != 0)
+BOOL __cdecl __acrt_get_qualified_locale(
+    _In_      __crt_locale_strings const* input_strings,
+    _Out_opt_ UINT*                       code_page,
+    _Out_opt_ __crt_locale_strings*       result_strings
+    );
+
+_Success_(return != 0)
+BOOL __cdecl __acrt_get_qualified_locale_downlevel(
+    _In_      __crt_locale_strings const* input_strings,
+    _Out_opt_ UINT*                       code_page,
+    _Out_opt_ __crt_locale_strings*       result_strings
+    );
+
+
+// Global variable that is nonzero if the locale has been changed on any thread.
+// Do not touch this global variable; call __acrt_locale_changed instead.
+extern long __acrt_locale_changed_data;
+
+#ifdef __cplusplus
+
+    // Returns true if the locale has been changed on any thread.
+    __inline bool __cdecl __acrt_locale_changed()
+    {
+        // No need for __crt_interlocked_read, since __acrt_locale_changed_data
+        // is a 4 byte natural aligned memory, guaranteed to be atomic
+        // accessed on all platforms.
+        return __acrt_locale_changed_data != FALSE;
+    }
+
+#endif
+
+void __cdecl __acrt_set_locale_changed(void);
+
+
+// Non-NLS language and country/region string tables:
+extern __crt_locale_string_table const __acrt_rg_language[];
+extern size_t                    const __acrt_rg_language_count;
+
+extern __crt_locale_string_table const __acrt_rg_country[];
+extern size_t                    const __acrt_rg_country_count;
+
+// The lconv and LC TIME structures for the C locale:
+extern struct lconv             __acrt_lconv_c;
+extern __crt_lc_time_data const __lc_time_c;
+
+// The initial and current locale states:
+extern __crt_multibyte_data  __acrt_initial_multibyte_data;
+extern __crt_locale_data     __acrt_initial_locale_data;
+extern __crt_locale_pointers __acrt_initial_locale_pointers;
+
+#ifdef __cplusplus
+
+    extern __crt_state_management::dual_state_global<
+        __crt_locale_data*
+    > __acrt_current_locale_data;
+
+    extern __crt_state_management::dual_state_global<
+        __crt_multibyte_data*
+    > __acrt_current_multibyte_data;
+
+#endif
+
+
+// The current lconv structure:
+extern struct lconv* __acrt_lconv;
+
+// Character tables:
+extern unsigned short const __newctype[];
+extern unsigned char  const __newclmap[];
+extern unsigned char  const __newcumap[];
+
+// The name of the C locale, as a wide string ("C")
+extern wchar_t __acrt_wide_c_locale_string[];
+
+
+
+// The global locale status, to support the threadlocale.obj link option
+extern int __globallocalestatus;
+
+
+
+bool __cdecl __acrt_initialize_multibyte(void);
+
+
+
+__inline int __CRTDECL __acrt_isleadbyte_l_noupdate(
+    _In_ int       const c,
+    _In_ _locale_t const locale
+    )
+{
+    return __acrt_locale_get_ctype_array_value(locale->locinfo->_public._locale_pctype, c, _LEADBYTE);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Math
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+void __cdecl __acrt_initialize_user_matherr(void* encoded_null);
+bool __cdecl __acrt_has_user_matherr(void);
+int  __cdecl __acrt_invoke_user_matherr(struct _exception*);
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Threading
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+typedef struct __acrt_thread_parameter
+{
+    // The thread procedure and context argument
+    void*   _procedure;
+    void*   _context;
+
+    // The handle for the newly created thread.  This is initialized only from
+    // _beginthread (not _beginthreadex).  When a thread created via _beginthread
+    // exits, it frees this handle.
+    HANDLE _thread_handle;
+
+    // The handle for the module in which the user's thread procedure is defined.
+    // This may be null if the handle could not be obtained.  This handle enables
+    // us to bump the reference count of the user's module, to ensure that the
+    // module will not be unloaded while the thread is executing.  When the thread
+    // exits, it frees this handle.
+    HMODULE _module_handle;
+
+    // This flag is true if RoInitialized was called on the thread to initialize
+    // it into the MTA.
+    bool    _initialized_apartment;
+} __acrt_thread_parameter;
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Per-Thread Data
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+typedef struct __acrt_ptd
+{
+    // These three data members support signal handling and runtime errors
+    struct __crt_signal_action_t* _pxcptacttab;     // Pointer to the exception-action table
+    EXCEPTION_POINTERS*           _tpxcptinfoptrs;  // Pointer to the exception info pointers
+    int                           _tfpecode;        // Last floating point exception code
+
+    terminate_handler  _terminate;  // terminate() routine
+
+    int                  _terrno;          // errno value
+    unsigned long        _tdoserrno;       // _doserrno value
+
+    unsigned int         _rand_state;      // Previous value of rand()
+
+    // Per-thread strtok(), wcstok(), and mbstok() data:
+    char*                _strtok_token;
+    unsigned char*       _mbstok_token;
+    wchar_t*             _wcstok_token;
+
+    // Per-thread tmpnam() data:
+    char*                _tmpnam_narrow_buffer;
+    wchar_t*             _tmpnam_wide_buffer;
+
+    // Per-thread time library data:
+    char*                _asctime_buffer;  // Pointer to asctime() buffer
+    wchar_t*             _wasctime_buffer; // Pointer to _wasctime() buffer
+    struct tm*           _gmtime_buffer;   // Pointer to gmtime() structure
+
+    char*                _cvtbuf;          // Pointer to the buffer used by ecvt() and fcvt().
+
+    // Per-thread error message data:
+    char*      _strerror_buffer;            // Pointer to strerror()  / _strerror()  buffer
+    wchar_t*   _wcserror_buffer;            // Pointer to _wcserror() / __wcserror() buffer
+
+    // Locale data:
+    __crt_multibyte_data*                  _multibyte_info;
+    __crt_locale_data*                     _locale_info;
+    __crt_qualified_locale_data            _setloc_data;
+    __crt_qualified_locale_data_downlevel* _setloc_downlevel_data;
+    int                                    _own_locale;   // See _configthreadlocale() and __acrt_should_sync_with_global_locale()
+
+    // The buffer used by _putch(), and the flag indicating whether the buffer
+    // is currently in use or not.
+    unsigned char  _putch_buffer[MB_LEN_MAX];
+    unsigned short _putch_buffer_used;
+
+    // The thread-local invalid parameter handler
+    _invalid_parameter_handler _thread_local_iph;
+
+    // If this thread was started by the CRT (_beginthread or _beginthreadex),
+    // then this points to the context with which the thread was created.  If
+    // this thread was not started by the CRT, this pointer is null.
+    __acrt_thread_parameter* _beginthread_context;
+
+} __acrt_ptd;
+
+__acrt_ptd* __cdecl __acrt_getptd(void);
+__acrt_ptd* __cdecl __acrt_getptd_head(void);
+__acrt_ptd* __cdecl __acrt_getptd_noexit(void);
+__acrt_ptd* __cdecl __acrt_getptd_noexit2(void);
+void        __cdecl __acrt_freeptd(void);
+
+
+
+void __cdecl __acrt_errno_map_os_error (unsigned long);
+int  __cdecl __acrt_errno_from_os_error(unsigned long);
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Multi-Threading and Synchronization
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+typedef enum __acrt_lock_id
+{
+    __acrt_heap_lock,
+    __acrt_debug_lock,
+    __acrt_exit_lock,
+    __acrt_signal_lock,
+    __acrt_locale_lock,
+    __acrt_multibyte_cp_lock,
+    __acrt_time_lock,
+    __acrt_lowio_index_lock,
+    __acrt_stdio_index_lock,
+    __acrt_conio_lock,
+    __acrt_popen_lock,
+    __acrt_environment_lock,
+    __acrt_tempnam_lock,
+    __acrt_os_exit_lock,
+    __acrt_function_pointer_table_lock,
+    __acrt_lock_count
+} __acrt_lock_id;
+
+#define _CORECRT_SPINCOUNT 4000
+
+void __cdecl __acrt_lock(_In_ __acrt_lock_id lock);
+void __cdecl __acrt_unlock(_In_ __acrt_lock_id lock);
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// CoreCRT SEH Encapsulation
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+extern "C++"
+{
+    template <typename Action>
+    auto __acrt_lock_and_call(__acrt_lock_id const lock_id, Action&& action) throw()
+        -> decltype(action())
+    {
+        return __crt_seh_guarded_call<decltype(action())>()(
+            [lock_id]() { __acrt_lock(lock_id); },
+            action,
+            [lock_id]() { __acrt_unlock(lock_id); });
+    }
+}
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Heap Internals and Debug Heap Internals
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern HANDLE __acrt_heap;
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size)
+void* __cdecl _expand_base(
+    _Pre_notnull_ void*  block,
+    _In_          size_t size
+    );
+
+// For detection of heap mismatch between MSVCRT and UCRT
+#define _UCRT_HEAP_MISMATCH_DETECTION   0
+#define _UCRT_HEAP_MISMATCH_RECOVERY    0
+#define _UCRT_HEAP_MISMATCH_BREAK       0
+
+#define _UCRT_HEAP_MISMATCH_ANY (_UCRT_HEAP_MISMATCH_DETECTION || _UCRT_HEAP_MISMATCH_RECOVERY || _UCRT_HEAP_MISMATCH_BREAK)
+
+#if _UCRT_HEAP_MISMATCH_ANY && (defined _M_IX86 || defined _M_AMD64)
+    HANDLE __cdecl __acrt_get_msvcrt_heap_handle(void);
+#endif
+
+
+// CRT Allocation macros:
+#ifndef _DEBUG
+    #define _expand_crt    _expand
+
+    #define _strdup_crt    _strdup
+
+    #define _dupenv_s_crt  _dupenv_s
+    #define _wdupenv_s_crt _wdupenv_s
+
+#else
+    #define _expand_crt(p, s)      _expand_dbg(p, s, _CRT_BLOCK)
+
+    #define _strdup_crt(s)         _strdup_dbg(s, _CRT_BLOCK, __FILE__, __LINE__)
+
+    #define _dupenv_s_crt(...)     _dupenv_s_dbg(__VA_ARGS__, _CRT_BLOCK, __FILE__, __LINE__)
+    #define _wdupenv_s_crt(...)    _wdupenv_s_dbg(__VA_ARGS__, _CRT_BLOCK, __FILE__, __LINE__)
+
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// CoreCRT Scoped HANDLE Wrappers
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These classes are similar to the WRL HandleT and its traits.  We cannot use
+// HandleT because it has a virtual function, InternalClose().  (Every object
+// that uses a HandleT instantiation also has the RTTI data for that HandleT
+// instantiation. This RTTI data causes the object to depend on type_info, which
+// causes an indirect dependency on operator delete.  This breaks static linking
+// of the CRT, when operator delete is replaced in a user-provided object.
+#ifdef __cplusplus
+extern "C++"
+{
+    struct __crt_handle_traits
+    {
+        typedef HANDLE type;
+
+        static bool close(_In_ type handle) throw()
+        {
+            return ::CloseHandle(handle) != FALSE;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return INVALID_HANDLE_VALUE;
+        }
+    };
+
+    struct __crt_hmodule_traits
+    {
+        typedef HMODULE type;
+
+        static bool close(_In_ type handle) throw()
+        {
+            return ::FreeLibrary(handle) != FALSE;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return nullptr;
+        }
+    };
+
+    struct __crt_findfile_traits
+    {
+        typedef HANDLE type;
+
+        static bool close(_In_ type handle) throw()
+        {
+            return ::FindClose(handle) != FALSE;
+        }
+
+        static type get_invalid_value() throw()
+        {
+            return INVALID_HANDLE_VALUE;
+        }
+    };
+
+
+
+    template <typename Traits>
+    class __crt_unique_handle_t
+    {
+    public:
+
+        typedef Traits                traits_type;
+        typedef typename Traits::type handle_type;
+
+        explicit __crt_unique_handle_t(handle_type const h = traits_type::get_invalid_value()) throw()
+            : _handle(h)
+        {
+        }
+
+        __crt_unique_handle_t(_Inout_ __crt_unique_handle_t&& h) throw()
+            : _handle(h._handle)
+        {
+            h._handle = traits_type::get_invalid_value();
+        }
+
+        ~__crt_unique_handle_t() throw()
+        {
+            close();
+        }
+
+        __crt_unique_handle_t& operator=(_Inout_ __crt_unique_handle_t&& h) throw()
+        {
+            close();
+            _handle = h._handle;
+            h._handle = traits_type::get_invalid_value();
+            return *this;
+        }
+
+        void attach(handle_type h) throw()
+        {
+            if (h != _handle)
+            {
+                close();
+                _handle = h;
+            }
+        }
+
+        handle_type detach() throw()
+        {
+            handle_type h = _handle;
+            _handle = traits_type::get_invalid_value();
+            return h;
+        }
+
+        handle_type get() const throw()
+        {
+            return _handle;
+        }
+
+        void close() throw()
+        {
+            if (_handle == traits_type::get_invalid_value())
+                return;
+
+            traits_type::close(_handle);
+            _handle = traits_type::get_invalid_value();
+        }
+
+        bool is_valid() const throw()
+        {
+            return _handle != traits_type::get_invalid_value();
+        }
+
+        operator bool() const throw()
+        {
+            return is_valid();
+        }
+
+        handle_type* get_address_of() throw()
+        {
+            return &_handle;
+        }
+
+        handle_type* release_and_get_address_of() throw()
+        {
+            close();
+            return &_handle;
+        }
+
+    private:
+
+        __crt_unique_handle_t(__crt_unique_handle_t const&) throw();
+        __crt_unique_handle_t& operator=(__crt_unique_handle_t const&) throw();
+
+        handle_type _handle;
+    };
+
+    typedef __crt_unique_handle_t<__crt_handle_traits>   __crt_unique_handle;
+    typedef __crt_unique_handle_t<__crt_hmodule_traits>  __crt_unique_hmodule;
+    typedef __crt_unique_handle_t<__crt_findfile_traits> __crt_findfile_handle;
+
+} // extern "C++"
+#endif // __cplusplus
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Windows API Thunks
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+BOOL WINAPI __acrt_AreFileApisANSI(void);
+
+int WINAPI __acrt_CompareStringEx(
+    _In_opt_                       LPCWSTR          locale_name,
+    _In_                           DWORD            flags,
+    _In_NLS_string_(string1_count) LPCWCH           string1,
+    _In_                           int              string1_count,
+    _In_NLS_string_(string2_count) LPCWCH           string2,
+    _In_                           int              string2_count,
+    _Reserved_                     LPNLSVERSIONINFO version,
+    _Reserved_                     LPVOID           reserved,
+    _Reserved_                     LPARAM           param
+    );
+
+BOOL WINAPI __acrt_EnumSystemLocalesEx(
+    _In_     LOCALE_ENUMPROCEX enum_proc,
+    _In_     DWORD             flags,
+    _In_     LPARAM            param,
+    _In_opt_ LPVOID            reserved
+    );
+
+DWORD WINAPI __acrt_FlsAlloc(
+    _In_opt_ PFLS_CALLBACK_FUNCTION lpCallback
+    );
+
+BOOL WINAPI __acrt_FlsFree(
+    _In_ DWORD dwFlsIndex
+    );
+
+PVOID WINAPI __acrt_FlsGetValue(
+    _In_ DWORD dwFlsIndex
+    );
+
+BOOL WINAPI __acrt_FlsSetValue(
+    _In_     DWORD dwFlsIndex,
+    _In_opt_ PVOID lpFlsData
+    );
+
+PVOID WINAPI __acrt_FlsGetValue2(
+    _In_ DWORD dwFlsIndex
+    );
+
+BOOL WINAPI __acrt_IsThreadAFiber();
+
+int WINAPI __acrt_GetDateFormatEx(
+    _In_opt_                       LPCWSTR           locale_name,
+    _In_                           DWORD             flags,
+    _In_opt_                       SYSTEMTIME CONST* date,
+    _In_opt_                       LPCWSTR           format,
+    _Out_writes_opt_(buffer_count) LPWSTR            buffer,
+    _In_opt_                       int               buffer_count,
+    _In_opt_                       LPCWSTR           calendar
+    );
+
+int WINAPI __acrt_GetTempPath2W(
+    _In_ DWORD nBufferLength,
+    _Out_writes_to_opt_(BufferLength, return +1) LPWSTR lpBuffer
+    );
+
+BOOL WINAPI __acrt_GetFileInformationByName(
+    _In_ LPCWSTR FileName,
+    _In_ DWORD FileInformationClass,                // FILE_INFO_BY_NAME_CLASS
+    _Out_writes_bytes_(FileInfoBufferSize) PVOID FileInfoBuffer,
+    _In_ ULONG FileInfoBufferSize
+    );
+
+DWORD64 WINAPI __acrt_GetEnabledXStateFeatures(void);
+
+int WINAPI __acrt_GetLocaleInfoEx(
+    _In_opt_                       LPCWSTR locale_name,
+    _In_                           LCTYPE  lc_type,
+    _Out_writes_opt_(data_count)   LPWSTR  data,
+    _In_                           int     data_count
+    );
+
+VOID WINAPI __acrt_GetSystemTimePreciseAsFileTime(
+    _Out_ LPFILETIME system_time
+    );
+
+int WINAPI __acrt_GetTimeFormatEx(
+    _In_opt_                         LPCWSTR           locale_name,
+    _In_                             DWORD             flags,
+    _In_opt_                         SYSTEMTIME CONST* time,
+    _In_opt_                         LPCWSTR           format,
+    _Out_writes_opt_(buffer_count)   LPWSTR            buffer,
+    _In_opt_                         int               buffer_count
+    );
+
+int WINAPI __acrt_GetUserDefaultLocaleName(
+    _Out_writes_(locale_name_count) LPWSTR  locale_name,
+    _In_                            int     locale_name_count
+    );
+
+_Must_inspect_result_
+BOOL WINAPI __acrt_GetXStateFeaturesMask(
+    _In_  PCONTEXT context,
+    _Out_ PDWORD64 feature_mask
+    );
+
+BOOL WINAPI __acrt_InitializeCriticalSectionEx(
+    _Out_ LPCRITICAL_SECTION critical_section,
+    _In_  DWORD              spin_count,
+    _In_  DWORD              flags
+    );
+
+BOOL WINAPI __acrt_IsValidLocaleName(
+    _In_ LPCWSTR locale_name
+    );
+
+int WINAPI __acrt_LCMapStringEx(
+    _In_opt_                            LPCWSTR          locale_name,
+    _In_                                DWORD            flags,
+    _In_CRT_NLS_string_(source_count)   LPCWSTR          source,
+    _In_                                int              source_count,
+    _Out_writes_opt_(destination_count) LPWSTR           destination,
+    _In_                                int              destination_count,
+    _In_opt_                            LPNLSVERSIONINFO version,
+    _In_opt_                            LPVOID           reserved,
+    _In_opt_                            LPARAM           sort_handle
+    );
+
+int WINAPI __acrt_LCIDToLocaleName(
+    _In_                         LCID   locale,
+    _Out_writes_opt_(name_count) LPWSTR name,
+    _In_                         int    name_count,
+    _In_                         DWORD  flags
+    );
+
+DWORD WINAPI __acrt_LocaleNameToLCID(
+    _In_ LPCWSTR name,
+    _In_ DWORD   flags
+    );
+
+_Success_(return != NULL)
+PVOID WINAPI __acrt_LocateXStateFeature(
+    _In_      PCONTEXT content,
+    _In_      DWORD    feature_id,
+    _Out_opt_ PDWORD   length
+    );
+
+int WINAPI __acrt_MessageBoxA(
+    _In_opt_ HWND   hwnd,
+    _In_opt_ LPCSTR text,
+    _In_opt_ LPCSTR caption,
+    _In_     UINT   type
+    );
+
+int WINAPI __acrt_MessageBoxW(
+    _In_opt_ HWND    hwnd,
+    _In_opt_ LPCWSTR text,
+    _In_opt_ LPCWSTR caption,
+    _In_     UINT    type
+    );
+
+void WINAPI __acrt_OutputDebugStringA(
+    _In_opt_ LPCSTR text
+    );
+
+#ifdef __cplusplus
+    HRESULT WINAPI __acrt_RoInitialize(
+        _In_ RO_INIT_TYPE init_type
+        );
+#endif
+
+void WINAPI __acrt_RoUninitialize(void);
+
+_Success_(return != 0)
+BOOLEAN WINAPI __acrt_RtlGenRandom(
+    _Out_writes_bytes_(buffer_count) PVOID buffer,
+    _In_                             ULONG buffer_count
+    );
+
+LONG WINAPI __acrt_AppPolicyGetProcessTerminationMethodInternal(_Out_ AppPolicyProcessTerminationMethod* policy);
+LONG WINAPI __acrt_AppPolicyGetThreadInitializationTypeInternal(_Out_ AppPolicyThreadInitializationType* policy);
+LONG WINAPI __acrt_AppPolicyGetShowDeveloperDiagnosticInternal(_Out_ AppPolicyShowDeveloperDiagnostic* policy);
+LONG WINAPI __acrt_AppPolicyGetWindowingModelInternal(_Out_ AppPolicyWindowingModel* policy);
+
+BOOL WINAPI __acrt_SetThreadStackGuarantee(
+    _Inout_ PULONG stack_size_in_bytes
+    );
+
+
+bool __cdecl __acrt_can_show_message_box(void);
+bool __cdecl __acrt_can_use_vista_locale_apis(void);
+void __cdecl __acrt_eagerly_load_locale_apis(void);
+bool __cdecl __acrt_can_use_xstate_apis(void);
+HWND __cdecl __acrt_get_parent_window(void);
+bool __cdecl __acrt_is_interactive(void);
+
+bool __cdecl __acrt_app_verifier_enabled(void);
+bool __cdecl __acrt_is_secure_process(void);
+
+bool __cdecl __acrt_tls2_supported(void);
+
+LCID __cdecl __acrt_DownlevelLocaleNameToLCID(
+    _In_opt_ LPCWSTR localeName
+    );
+
+_Success_(return != 0)
+int __cdecl __acrt_DownlevelLCIDToLocaleName(
+    _In_      LCID   lcid,
+    _Out_writes_opt_z_(cchLocaleName) LPWSTR outLocaleName,
+    _In_      int    cchLocaleName
+    );
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// AppCRT Signal Handling and Exception Filter
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Pointer to a signal handler
+typedef void (__cdecl* __crt_signal_handler_t)(int);
+
+// Exception-action table used by the C runtime to identify and dispose of
+// exceptions corresponding to C runtime errors or C signals.
+struct __crt_signal_action_t
+{
+    // Exception code or number; defined by the host OS.
+    unsigned long _exception_number;
+
+    // Signal code or number; defined by the CRT.
+    int _signal_number;
+
+    // Exception action code. Either a special code or the address of
+    // a handler function. Always determines how the exception filter
+    // should dispose of the exception.
+    __crt_signal_handler_t _action;
+};
+
+extern struct __crt_signal_action_t const __acrt_exception_action_table[];
+
+// Number of entries in the exception-action table
+extern size_t const __acrt_signal_action_table_count;
+
+// Size of exception-action table (in bytes)
+extern size_t const __acrt_signal_action_table_size;
+
+// Index of the first floating point exception entry
+extern size_t const __acrt_signal_action_first_fpe_index;
+
+// Number of FPE entries
+extern size_t const __acrt_signal_action_fpe_count;
+
+__crt_signal_handler_t __cdecl __acrt_get_sigabrt_handler(void);
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// DesktopCRT Environment
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+    extern __crt_state_management::dual_state_global<char**>    _environ_table;
+    extern __crt_state_management::dual_state_global<wchar_t**> _wenviron_table;
+#endif
+
+extern wchar_t** __dcrt_initial_wide_environment;
+extern char**    __dcrt_initial_narrow_environment;
+
+_Ret_opt_z_
+char*    __cdecl __dcrt_get_narrow_environment_from_os(void) _CRT_NOEXCEPT;
+
+_Ret_opt_z_
+wchar_t* __cdecl __dcrt_get_wide_environment_from_os(void) _CRT_NOEXCEPT;
+
+_Deref_ret_opt_z_
+char**    __cdecl __dcrt_get_or_create_narrow_environment_nolock(void);
+
+_Deref_ret_opt_z_
+wchar_t** __cdecl __dcrt_get_or_create_wide_environment_nolock(void);
+
+void __cdecl __dcrt_uninitialize_environments_nolock(void);
+
+
+int __cdecl __dcrt_set_variable_in_narrow_environment_nolock(
+    _In_ _Post_invalid_ char* option,
+    _In_                int   is_top_level_call
+    );
+
+int __cdecl __dcrt_set_variable_in_wide_environment_nolock(
+    _In_ _Post_invalid_ wchar_t* option,
+    _In_                int      is_top_level_call
+    );
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal fast locale functions with no extra checks
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Only use these when the input char is validated to be an unsigned char and not EOF.
+// Ensure locale has already been updated.
+_Check_return_ __forceinline unsigned char __cdecl _toupper_fast_internal(
+    _In_ unsigned char const c,
+    _In_ _locale_t const     locale
+    )
+{
+    return locale->locinfo->pcumap[c];
+}
+
+_Check_return_ __forceinline unsigned char __cdecl _tolower_fast_internal(
+    _In_ unsigned char const c,
+    _In_ _locale_t const     locale
+    )
+{
+    return locale->locinfo->pclmap[c];
+}
+
+extern const unsigned short _wctype[];
+
+_Check_return_ __forceinline wint_t _towupper_fast_internal(
+    _In_ unsigned char const c,
+    _In_ _locale_t const     locale
+    )
+{
+    // Check for iswlower required because upper map assumes using narrow ctype categories.
+    // towupper uses a locale-sensitive transformation, but only if the wide character
+    // is considered lowercase in UTF-16.
+    // _wctype starts at EOF. Add one to map to characters.
+    if (_wctype[c + 1] & _LOWER)
+    {
+        return _toupper_fast_internal(c, locale);
+    }
+    return c;
+}
+
+_Check_return_ inline wint_t _towupper_internal(
+    _In_ unsigned short const c,
+    _In_ _locale_t const      locale
+    )
+{
+    if (c < 256)
+    {
+        return _towupper_fast_internal((unsigned char) c, locale);
+    }
+
+    return _towupper_l(c, locale);
+}
+
+_Check_return_ __forceinline wint_t _towlower_fast_internal(
+    _In_ unsigned char const c,
+    _In_ _locale_t const     locale
+    )
+{
+    // Check for iswupper required because lower map assumes using narrow ctype categories.
+    // towlower uses a locale-sensitive transformation, but only if the wide character
+    // is considered uppercase in UTF-16.
+    // _wctype starts at EOF. Add one to map to characters.
+    if (_wctype[c + 1] & _UPPER)
+    {
+        return _tolower_fast_internal(c, locale);
+    }
+
+    return c;
+}
+
+_Check_return_ inline wint_t _towlower_internal(
+    _In_ unsigned short const c,
+    _In_ _locale_t const      locale
+    )
+{
+    if (c < 256)
+    {
+        return _towlower_fast_internal((unsigned char) c, locale);
+    }
+
+    return _towlower_l(c, locale);
+}
+
+_Check_return_ __forceinline unsigned short __cdecl _ctype_fast_check_internal(
+    _In_ unsigned char const c,
+    _In_ int const           _Mask,
+    _In_ _locale_t const     locale
+    )
+{
+    return locale->locinfo->_public._locale_pctype[c] & _Mask;
+}
+
+_Check_return_ __forceinline unsigned short __cdecl _isdigit_fast_internal(
+    _In_ unsigned char const c,
+    _In_ _locale_t const     locale
+    )
+{
+    return _ctype_fast_check_internal(c, _DIGIT, locale);
+}
+
+// isleadbyte has a macro that casts the first argument to unsigned char
+// Instead of using _isleadbyte_l (which requires the caller to cast to unsigned char),
+// use _isleadbyte_fast_internal to prevent any unintentional casting errors that may occur.
+// As long as the locale is already updated via _LocaleUpdate or retrieved from __crt_cached_ptd_host,
+// this function is safe to use.
+#define _isleadbyte_l(_C, _L) use_isleadbyte_fast_internal_instead_to_prevent_casting_errors()
+
+_Check_return_ __forceinline unsigned short __cdecl _isleadbyte_fast_internal(
+    _In_ unsigned char const c,
+    _In_ _locale_t const     locale
+    )
+{
+    return _ctype_fast_check_internal(c, _LEADBYTE, locale);
+}
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Invalid Parameter Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Invoke Watson if _ExpressionError is not 0; otherwise simply return
+// _ExpressionError.
+_CRT_SECURITYCRITICAL_ATTRIBUTE
+__forceinline void _invoke_watson_if_error(
+    _In_       errno_t        expression_error,
+    _In_opt_z_ wchar_t const* expression,
+    _In_opt_z_ wchar_t const* function_name,
+    _In_opt_z_ wchar_t const* file_name,
+    _In_       unsigned int   line_number,
+    _In_       uintptr_t      reserved
+    )
+{
+    if (expression_error == 0)
+    {
+        return;
+    }
+
+    _invoke_watson(expression, function_name, file_name, line_number, reserved);
+}
+
+// Invoke Watson if _ExpressionError is not 0 and equal to _ErrorValue1 or
+// _ErrorValue2; otherwise simply return _EspressionError.
+__forceinline errno_t _invoke_watson_if_oneof(
+    _In_       errno_t        expression_error,
+    _In_       errno_t        error_value1,
+    _In_       errno_t        error_value2,
+    _In_opt_z_ wchar_t const* expression,
+    _In_opt_z_ wchar_t const* function_name,
+    _In_opt_z_ wchar_t const* file_name,
+    _In_       unsigned int   line_number,
+    _In_       uintptr_t      reserved
+    )
+{
+    if (expression_error == 0 || (expression_error != error_value1 && expression_error != error_value2))
+    {
+        return expression_error;
+    }
+
+    _invoke_watson(expression, function_name, file_name, line_number, reserved);
+}
+
+#ifdef _DEBUG
+    #define _INVOKE_WATSON_IF_ERROR(expr) _invoke_watson_if_error((expr), _CRT_WIDE(#expr), __FUNCTIONW__, __FILEW__, __LINE__, 0)
+    #define _INVOKE_WATSON_IF_ONEOF(expr, errvalue1, errvalue2) _invoke_watson_if_oneof(expr, (errvalue1), (errvalue2), _CRT_WIDE(#expr), __FUNCTIONW__, __FILEW__, __LINE__, 0)
+#else
+    #define _INVOKE_WATSON_IF_ERROR(expr) _invoke_watson_if_error(expr, NULL, NULL, NULL, 0, 0)
+    #define _INVOKE_WATSON_IF_ONEOF(expr, errvalue1, errvalue2) _invoke_watson_if_oneof((expr), (errvalue1), (errvalue2), NULL, NULL, NULL, 0, 0)
+#endif
+
+#define _ERRCHECK(e)               _INVOKE_WATSON_IF_ERROR(e)
+#define _ERRCHECK_EINVAL(e)        _INVOKE_WATSON_IF_ONEOF(e, EINVAL, EINVAL)
+#define _ERRCHECK_EINVAL_ERANGE(e) _INVOKE_WATSON_IF_ONEOF(e, EINVAL, ERANGE)
+
+#define _ERRCHECK_SPRINTF(_PrintfCall)      \
+    {                                       \
+        errno_t _SaveErrno = errno;         \
+        errno = 0;                          \
+        if ((_PrintfCall) < 0)              \
+        {                                   \
+            _ERRCHECK_EINVAL_ERANGE(errno); \
+        }                                   \
+        errno = _SaveErrno;                 \
+    }
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// SecureCRT
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// We completely fill the buffer only in debug (see _SECURECRT__FILL_STRING and
+// _SECURECRT__FILL_BYTE macros).
+#ifndef _SECURECRT_FILL_BUFFER
+    #ifdef _DEBUG
+        #define _SECURECRT_FILL_BUFFER 1
+    #else
+        #define _SECURECRT_FILL_BUFFER 0
+    #endif
+#endif
+
+#ifndef _SECURECRT_FILL_BUFFER_THRESHOLD
+// _SECURECRT_FILL_BUFFER_THRESHOLD must be a constant for Prefast due to the
+// double evaluation. Making it something unique like 42 would pollute Prefast's warnings.
+    #if defined _PREFAST_ || !defined _DEBUG
+        #define _SECURECRT_FILL_BUFFER_THRESHOLD ((size_t)0)
+    #else
+        #define _SECURECRT_FILL_BUFFER_THRESHOLD (_CrtGetDebugFillThreshold())
+    #endif
+#endif
+
+// TODO make this a template so that _CrtGetDebugFillThreshold is not called multiple times.
+#if _SECURECRT_FILL_BUFFER
+    #define _SECURECRT__FILL_STRING(_String, _Count, _Offset)                       \
+        if ((_Count) != ((size_t)-1) &&                                             \
+            (_Count) != INT_MAX &&                                                  \
+            ((size_t)(_Offset)) < (_Count))                                         \
+        {                                                                           \
+            size_t max_buffer_count = _SECURECRT_FILL_BUFFER_THRESHOLD;             \
+            memset(                                                                 \
+                (_String) + (_Offset),                                              \
+                _SECURECRT_FILL_BUFFER_PATTERN,                                     \
+                (max_buffer_count < ((size_t)((_Count) - (_Offset)))                \
+                    ? max_buffer_count                                              \
+                    : ((_Count) - (_Offset))) * sizeof(*(_String)));                \
+        }
+#else
+    #define _SECURECRT__FILL_STRING(_String, _Count, _Offset)
+#endif
+
+#if _SECURECRT_FILL_BUFFER
+    #define _SECURECRT__FILL_BYTE(_Position)                \
+        if (_SECURECRT_FILL_BUFFER_THRESHOLD > 0)           \
+        {                                                   \
+            (_Position) = _SECURECRT_FILL_BUFFER_PATTERN;   \
+        }
+#else
+    #define _SECURECRT__FILL_BYTE(_Position)
+#endif
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Precondition Validation Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// We use _VALIDATE_STREAM_ANSI_RETURN to ensure that ANSI file operations (e.g.
+// fprintf) aren't called on files opened as UNICODE. We do this check only if
+// it's an actual FILE pointer & not a string.
+#define _VALIDATE_STREAM_ANSI_RETURN(stream, errorcode, retexpr)               \
+    {                                                                          \
+        __crt_stdio_stream const _Stream(stream);                              \
+        int fn;                                                                \
+        _VALIDATE_RETURN((                                                     \
+            (_Stream.is_string_backed()) ||                                    \
+            (fn = _fileno(_Stream.public_stream()),                            \
+                ((_textmode_safe(fn) == __crt_lowio_text_mode::ansi) &&        \
+                !_tm_unicode_safe(fn)))),                                      \
+            errorcode, retexpr)                                                \
+    }
+
+#define _CHECK_FH_RETURN( handle, errorcode, retexpr )                         \
+    {                                                                          \
+        if(handle == _NO_CONSOLE_FILENO)                                       \
+        {                                                                      \
+            errno = errorcode;                                                 \
+            return ( retexpr );                                                \
+        }                                                                      \
+    }
+
+#define _CHECK_FH_CLEAR_OSSERR_RETURN( handle, errorcode, retexpr )            \
+    {                                                                          \
+        if(handle == _NO_CONSOLE_FILENO)                                       \
+        {                                                                      \
+            _doserrno = 0L;                                                    \
+            errno = errorcode;                                                 \
+            return ( retexpr );                                                \
+        }                                                                      \
+    }
+
+#define _CHECK_FH_CLEAR_OSSERR_RETURN_ERRCODE( handle, retexpr )               \
+    {                                                                          \
+        if(handle == _NO_CONSOLE_FILENO)                                       \
+        {                                                                      \
+            _doserrno = 0L;                                                    \
+            return ( retexpr );                                                \
+        }                                                                      \
+    }
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Redirect-to-Locale Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+    #define _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE extern "C"
+#else
+    #define _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE
+#endif
+
+#define _REDIRECT_TO_L_VERSION_1(_ReturnType, _FunctionName, _Type1)                          \
+    _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE                                                      \
+    _ReturnType __cdecl _FunctionName(_Type1 _Arg1)                                           \
+    {                                                                                         \
+        return _FunctionName##_l(_Arg1, NULL);                                                \
+    }
+
+#define _REDIRECT_TO_L_VERSION_2(_ReturnType, _FunctionName, _Type1, _Type2)                  \
+    _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE                                                      \
+    _ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2)                             \
+    {                                                                                         \
+        return _FunctionName##_l(_Arg1, _Arg2, NULL);                                         \
+    }
+
+#define _REDIRECT_TO_L_VERSION_3(_ReturnType, _FunctionName, _Type1, _Type2, _Type3)          \
+    _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE                                                      \
+    _ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2, _Type3 _Arg3)               \
+    {                                                                                         \
+        return _FunctionName##_l(_Arg1, _Arg2, _Arg3, NULL);                                  \
+    }
+
+#define _REDIRECT_TO_L_VERSION_4(_ReturnType, _FunctionName, _Type1, _Type2, _Type3, _Type4)  \
+    _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE                                                      \
+    _ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2, _Type3 _Arg3, _Type4 _Arg4) \
+    {                                                                                         \
+        return _FunctionName##_l(_Arg1, _Arg2, _Arg3, _Arg4, NULL);                           \
+    }
+
+
+
+#ifdef __cplusplus
+extern "C++"
+{
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // Forward declare PTD propagation host
+    //
+    // To use the PTD propagation utilities, include corecrt_internal_ptd_propagation.h.
+    // That header also opts into removing old validation macros that would use errno,
+    // so the __crt_cached_ptd_host is declared here so that headers don't need to be fully converted.
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+    class __crt_cached_ptd_host;
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // Internals with PTD propagation
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+    extern "C" void __cdecl __acrt_errno_map_os_error_ptd(unsigned long, __crt_cached_ptd_host&);
+
+    extern "C" void __cdecl _invalid_parameter_internal(
+        _In_opt_z_ wchar_t const*,
+        _In_opt_z_ wchar_t const*,
+        _In_opt_z_ wchar_t const*,
+        _In_       unsigned int,
+        _In_       uintptr_t,
+        _Inout_    __crt_cached_ptd_host&
+        );
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // Locale Update
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    extern "C" void __acrt_update_locale_info(
+        _In_     __acrt_ptd*        const ptd,
+        _Inout_ __crt_locale_data** const data
+        );
+
+    extern "C" void __acrt_update_multibyte_info(
+        _In_    __acrt_ptd*            const ptd,
+        _Inout_ __crt_multibyte_data** const data
+        );
+
+    // Querying the global state index queries TLS.
+    // If the global state index is known, use the explicit functions to avoid a GetFlsValue call.
+    extern "C" void __acrt_update_locale_info_explicit(
+        _In_     __acrt_ptd*        const ptd,
+        _Inout_ __crt_locale_data** const data,
+        _In_    size_t              const current_global_state_index
+        );
+
+    extern "C" void __acrt_update_multibyte_info_explicit(
+        _In_    __acrt_ptd*            const ptd,
+        _Inout_ __crt_multibyte_data** const data,
+        _In_    size_t                 const current_global_state_index
+        );
+
+    extern "C" __inline bool __acrt_should_sync_with_global_locale(
+        _In_ __acrt_ptd* const ptd
+        )
+    {
+        // Check whether per-thread locales are enabled either:
+        //  * On the thread (_ptd->_own_locale & _PER_THREAD_LOCALE_BIT is set)
+        //  * Globally (__globallocalestatus & _GLOBAL_LOCALE_BIT is set)
+
+        // If neither are enabled then we want to check the global locale setting
+        // and synchronize it to our per-thread-data.
+
+        // _own_locale
+        // bits: 000000000000000000000000 000W 00P1
+        // P is set after _configthreadlocale(_ENABLE_PER_THREAD_LOCALE).
+        // W is set in _wsetlocale to prevent resynchronization during _wsetlocale.
+        // Note that this means when _wsetlocale is ask whether it should to synchronize,
+        // it should not use __acrt_should_sync_with_global_locale.
+
+        // __globallocalestatus
+        // bits: 111111111111111111111111 1111 1N1G
+        // G is set if threadlocale.obj was linked to (via _configthreadlocale(-1)).
+        // N is whether new locales use the global locale and is unrelated to locale ptd sync.
+
+        // if _ENABLE_PER_THREAD_LOCALE is not set and threadlocale.obj is not linked to
+        return (ptd->_own_locale & __globallocalestatus) == 0;
+    }
+
+    // The per-thread locale is sometimes temporarily protected from resynchronization from
+    // the global locale to ensure calling the public API surface without locale information
+    // will not cause the locale to be reloaded half way through a call.
+
+    // This is only to protect us from ourselves - a future change can correct the need for these calls.
+    // Allows different 'bit_value' so that _wsetlocale can also use this.
+    extern "C" __inline void __acrt_disable_global_locale_sync(
+        _In_ __acrt_ptd* const ptd,
+        _In_ int         const bit_value = _PER_THREAD_LOCALE_BIT
+        )
+    {
+        ptd->_own_locale |= bit_value;
+    }
+
+    extern "C" __inline void __acrt_enable_global_locale_sync(
+        _In_ __acrt_ptd* const ptd,
+        _In_ int         const bit_value = _PER_THREAD_LOCALE_BIT
+        )
+    {
+        ptd->_own_locale &= ~bit_value;
+    }
+
+    class _LocaleUpdate
+    {   // Retained for old code paths - updating/locking/unlocking locale
+        // in every function is costly.
+        // Prefer using __crt_cached_ptd_host&.
+    public:
+
+        explicit _LocaleUpdate(_locale_t const locale) throw()
+            : _updated(false)
+        {
+            if (locale)
+            {
+                _locale_pointers = *locale;
+            }
+            else if (!__acrt_locale_changed())
+            {
+                _locale_pointers = __acrt_initial_locale_pointers;
+            }
+            else
+            {
+                _ptd = __acrt_getptd();
+                _locale_pointers.locinfo = _ptd->_locale_info;
+                _locale_pointers.mbcinfo = _ptd->_multibyte_info;
+
+                __acrt_update_locale_info   (_ptd, &_locale_pointers.locinfo);
+                __acrt_update_multibyte_info(_ptd, &_locale_pointers.mbcinfo);
+
+                if ((_ptd->_own_locale & _PER_THREAD_LOCALE_BIT) == 0)
+                {
+                    // Skip re-synchronization with the global locale to prevent the
+                    // locale from changing half-way through the call.
+                    __acrt_disable_global_locale_sync(_ptd);
+                    _updated = true;
+                }
+            }
+        }
+
+        ~_LocaleUpdate() throw()
+        {
+            if (_updated)
+            {
+                __acrt_enable_global_locale_sync(_ptd);
+            }
+        }
+
+        _locale_t GetLocaleT() throw()
+        {
+            return &_locale_pointers;
+        }
+
+    private:
+
+        __acrt_ptd*           _ptd;
+        // Using the locale data from the PTD ensures their lifetime
+        // will last through the end of the call - no need to increment/decrement reference count.
+        __crt_locale_pointers _locale_pointers;
+        bool                  _updated;
+
+    };
+
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // errno Cache
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // Some operations in this file may need to set or query errno many times.  Each
+    // use of errno requires us to get the PTD from FLS.  To avoid having to do this
+    // many times, we cache the pointer to errno.  This class encapsulates that
+    // caching and also defers the initial acquisition of &errno until the first
+    // time that errno is actually needed (when we aren't calling functions that may
+    // set errno, there's no need to acquire errno at all).
+    class __crt_deferred_errno_cache
+    {   // Retained for old code paths - querying errno is a performance issue.
+        // Prefer using __crt_cached_ptd_host&.
+    public:
+
+        __crt_deferred_errno_cache() throw()
+            : _cached_errno{}
+        {
+        }
+
+        errno_t& get() throw()
+        {
+            if (!_cached_errno)
+            {
+                _cached_errno = &errno;
+            }
+
+            return *_cached_errno;
+        }
+
+    private:
+
+        errno_t* _cached_errno;
+    };
+
+
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // errno and LastError Reset
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #ifndef _M_CEE
+
+    struct __crt_errno_guard
+    {   // Retained for old code paths - querying errno is a performance issue.
+        // Prefer using __crt_cached_ptd_host& (via ->get_errno().create_guard()).
+    public:
+
+        __crt_errno_guard(errno_t* const errno_address = &errno) throw()
+            : _errno_address(errno_address), _stored_errno(*errno_address)
+        {
+            *errno_address = 0;
+        }
+
+        ~__crt_errno_guard() throw()
+        {
+            if (*_errno_address == 0 && _stored_errno != 0)
+                *_errno_address = _stored_errno;
+        }
+
+    private:
+
+        __crt_errno_guard(__crt_errno_guard const&) throw(); // not implemented
+        void operator=(__crt_errno_guard const&) throw();    // not implemented
+
+        errno_t* _errno_address;
+        errno_t  _stored_errno;
+    };
+
+    extern bool __acrt_use_tls2_apis;
+
+    // Resets the operating system last error (GetLastError) to its original
+    // value on scope exit.
+    class __crt_scoped_get_last_error_reset
+    {
+    public:
+
+        __crt_scoped_get_last_error_reset() throw()
+        {
+            _old_last_error = GetLastError();
+        }
+
+        ~__crt_scoped_get_last_error_reset() throw()
+        {
+            SetLastError(_old_last_error);
+        }
+
+    private:
+        __crt_scoped_get_last_error_reset(__crt_scoped_get_last_error_reset const&);
+        __crt_scoped_get_last_error_reset& operator=(__crt_scoped_get_last_error_reset const&);
+
+        DWORD _old_last_error;
+    };
+    #endif // _M_CEE
+} // extern "C++"
+#endif // __cplusplus
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Windows policy APIs
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Specifies method used to end a process
+typedef enum
+{
+    process_end_policy_terminate_process,
+    process_end_policy_exit_process
+} process_end_policy;
+
+process_end_policy __cdecl __acrt_get_process_end_policy(void);
+
+// Specifies whether RoInitialize() should be called when creating a thread
+typedef enum
+{
+    begin_thread_init_policy_unknown,
+    begin_thread_init_policy_none,
+    begin_thread_init_policy_ro_initialize
+} begin_thread_init_policy;
+
+begin_thread_init_policy __cdecl __acrt_get_begin_thread_init_policy(void);
+
+// Specifies whether the Assert dialog should be shown
+typedef enum
+{
+    developer_information_policy_unknown,
+    developer_information_policy_none,
+    developer_information_policy_ui
+} developer_information_policy;
+
+developer_information_policy __cdecl __acrt_get_developer_information_policy(void);
+
+// Specifies what type of Windowing support is available
+typedef enum
+{
+    windowing_model_policy_unknown,
+    windowing_model_policy_hwnd,
+    windowing_model_policy_corewindow,
+    windowing_model_policy_legacyphone,
+    windowing_model_policy_none
+} windowing_model_policy;
+
+windowing_model_policy __cdecl __acrt_get_windowing_model_policy(void);
+
+
+_CRT_END_C_HEADER
+
+#include <corecrt_internal_state_isolation.h>
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_big_integer.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_big_integer.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e58e6ff02cf6fde7e4d71915027f92c1aa173c1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_big_integer.h	
@@ -0,0 +1,942 @@
+//
+// corecrt_internal_big_integer.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// A lightweight high precision integer type for use by the binary floating
+// point <=> decimal string conversion functions.
+//
+#include <corecrt_internal.h>
+#include <float.h>
+#include <stdint.h>
+
+// CRT_REFACTOR TODO We should be building the whole CRT /O2 /GL.  For the moment,
+// just ensure that everything using big_integer is optimized for maximum speed.
+#ifndef _DEBUG
+    #if !defined(_BEGIN_PRAGMA_OPTIMIZE_DISABLE)
+    #define _BEGIN_PRAGMA_OPTIMIZE_DISABLE(flags, bug, reason) \
+        __pragma(optimize(flags, off))
+    #define _BEGIN_PRAGMA_OPTIMIZE_ENABLE(flags, bug, reason) \
+        __pragma(optimize(flags, on))
+    #define _END_PRAGMA_OPTIMIZE() \
+        __pragma(optimize("", on))
+    #endif
+    _BEGIN_PRAGMA_OPTIMIZE_ENABLE("gt", MSFT:4499494, "Optimize for maximum speed")
+#endif
+
+namespace __crt_strtox {
+
+// A lightweight, sufficiently functional high-precision integer type for use in
+// the binary floating point <=> decimal string conversions.  We define only the
+// operations (and in some cases parts of operations) that are actually used.
+//
+// We require sufficient precision to represent the reciprocal of the smallest
+// representable value (the smallest denormal, 2^-1074).  During parsing, we may
+// also consider up to 768 decimal digits.  For this, we require an additional
+// log2(10^768) bits of precision.  Finally, we require 54 bits of space for
+// pre-division numerator shifting, because double explicitly stores 52 bits,
+// implicitly stores 1 bit, and we need 1 more bit for rounding.
+//
+// PERFORMANCE NOTE:  We intentionally do not initialize the _data array when a
+// big_integer object is constructed.  Profiling showed that zero initialization
+// caused a substantial performance hit.  Initialization of the _data array is
+// not necessary:  all operations on the big_integer type are carefully written
+// to only access elements at indices [0, _used], and all operations correctly
+// update _used as the utilized size increases.
+struct big_integer
+{
+    __forceinline big_integer() throw()
+        : _used(0)
+    {
+        #ifdef _DEBUG
+        memset(_data, 0xcc, sizeof(_data));
+        #endif
+    }
+
+    __forceinline big_integer(big_integer const& other) throw()
+        : _used(other._used)
+    {
+        memcpy_s(_data, sizeof(_data), other._data, other._used * sizeof(uint32_t));
+    }
+
+    __forceinline big_integer& operator=(big_integer const& other) throw()
+    {
+        _used = other._used;
+        memcpy_s(_data, sizeof(_data), other._data, other._used * sizeof(uint32_t));
+        return *this;
+    }
+
+    enum : uint32_t
+    {
+        maximum_bits  =
+            1074 + // 1074 bits required to represent 2^1074
+            2552 + // ceil(log2(10^768))
+            54,    // shift space
+            
+        element_bits  = sizeof(uint32_t) * CHAR_BIT,
+
+        element_count = (maximum_bits + element_bits - 1) / element_bits
+    };
+
+    uint32_t _used;                // The number of elements currently in use
+    uint32_t _data[element_count]; // The number, stored in little endian form
+};
+
+__forceinline bool __cdecl operator==(big_integer const& lhs, big_integer const& rhs) throw()
+{
+    if (lhs._used != rhs._used)
+        return false;
+
+    for (uint32_t i = 0; i != lhs._used; ++i)
+    {
+        if (lhs._data[i] != rhs._data[i])
+            return false;
+    }
+
+    return true;
+}
+
+__forceinline bool __cdecl operator!=(big_integer const& lhs, big_integer const& rhs) throw()
+{
+    return !(rhs == lhs);
+}
+
+__forceinline bool __cdecl operator<(big_integer const& lhs, big_integer const& rhs) throw()
+{
+    if (lhs._used > rhs._used)
+        return false;
+
+    if (lhs._used < rhs._used)
+        return true;
+
+    uint32_t i = lhs._used - 1;
+    for (; i != static_cast<uint32_t>(-1) && lhs._data[i] == rhs._data[i]; --i)
+    {
+        // No-op
+    }
+
+    if (i == static_cast<uint32_t>(-1))
+        return false;
+
+    if (lhs._data[i] <= rhs._data[i])
+        return true;
+
+    return false;
+}
+
+__forceinline bool __cdecl operator>=(big_integer const& lhs, big_integer const& rhs) throw()
+{
+    return !(lhs < rhs);
+}
+
+__forceinline big_integer __cdecl make_big_integer(uint64_t const value) throw()
+{
+    big_integer x{};
+    x._data[0] = value & 0xffffffff;
+    x._data[1] = value >> 32;
+    x._used    = x._data[1] == 0 ? 1 : 2;
+    return x;
+}
+
+__forceinline big_integer __cdecl make_big_integer_power_of_two(uint32_t const power) throw()
+{
+    uint32_t const one = 1;
+
+    big_integer x{};
+
+    uint32_t const element_index = power / big_integer::element_bits;
+    uint32_t const bit_index     = power % big_integer::element_bits;
+
+    memset(x._data, 0, element_index * sizeof(uint32_t));
+    x._data[element_index] = (one << bit_index);
+    x._used = element_index + 1;
+
+    return x;
+}
+
+__forceinline bool __cdecl is_zero(big_integer const& value) throw()
+{
+    return value._used == 0;
+}
+
+__forceinline uint32_t __cdecl bit_scan_reverse(uint32_t const value) throw()
+{
+    unsigned long index = 0;
+    if (_BitScanReverse(&index, value))
+        return index + 1;
+    return 0;
+}
+
+__forceinline uint32_t __cdecl bit_scan_reverse(uint64_t const value) throw()
+{
+#if defined(_M_X64) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    unsigned long index = 0;
+    if (_BitScanReverse64(&index, value))
+        return index + 1;
+    return 0;
+#else
+    if (value > UINT32_MAX)
+    {
+        return bit_scan_reverse(reinterpret_cast<uint32_t const*>(&value)[1]) + 32;
+    }
+    else
+    {
+        return bit_scan_reverse(reinterpret_cast<uint32_t const*>(&value)[0]);
+    }
+#endif
+}
+
+__forceinline uint32_t __cdecl bit_scan_reverse(big_integer const& x) throw()
+{
+    if (x._used == 0)
+    {
+        return 0;
+    }
+
+    return (x._used - 1) * big_integer::element_bits + bit_scan_reverse(x._data[x._used - 1]);
+}
+
+// Shifts the high precision integer x by n bits to the left.  Returns true if
+// the left shift was successful; false if it overflowed.  When overflow occurs,
+// the high precision integer is reset to zero.
+__forceinline bool __cdecl shift_left(big_integer& x, uint32_t const n) throw()
+{
+    uint32_t const unit_shift = n / big_integer::element_bits;
+    uint32_t const bit_shift  = n % big_integer::element_bits;
+
+    uint64_t const one = 1;
+
+    uint32_t const msb_bits = bit_shift;
+    uint32_t const lsb_bits = big_integer::element_bits - msb_bits;
+
+    uint32_t const lsb_mask = static_cast<uint32_t>((one << lsb_bits) - one);
+    uint32_t const msb_mask = ~lsb_mask;
+
+    bool const bit_shifts_into_next_unit = bit_shift > (big_integer::element_bits - bit_scan_reverse(x._data[x._used - 1]));
+
+    bool const unit_shift_will_overflow = x._used + unit_shift > big_integer::element_count;
+
+    if (unit_shift_will_overflow)
+    {
+        x = big_integer{};
+        return false;
+    }
+
+    uint32_t const new_used =
+        x._used + unit_shift + static_cast<uint32_t>(bit_shifts_into_next_unit);
+
+    if (new_used > big_integer::element_count)
+    {
+        x = big_integer{};
+        return false;
+    }
+
+    for (uint32_t destination_index = new_used - 1; destination_index != unit_shift - 1; --destination_index)
+    {
+        uint32_t const upper_source_index = destination_index - unit_shift;
+        uint32_t const lower_source_index = destination_index - unit_shift - 1;
+
+        uint32_t const upper_source = upper_source_index < x._used ? x._data[upper_source_index] : 0;
+        uint32_t const lower_source = lower_source_index < x._used ? x._data[lower_source_index] : 0;
+
+        uint32_t const shifted_upper_source = (upper_source & lsb_mask) << msb_bits;
+        uint32_t const shifted_lower_source = (lower_source & msb_mask) >> lsb_bits;
+
+        uint32_t const combined_shifted_source = shifted_upper_source | shifted_lower_source;
+
+        x._data[destination_index] = combined_shifted_source;
+    }
+
+    for (uint32_t destination_index = 0; destination_index != unit_shift; ++destination_index)
+    {
+        x._data[destination_index] = 0;
+    }
+
+    x._used = new_used;
+
+    return true;
+}
+
+// Adds a 32-bit value to the high-precision integer x.  Returns true if the
+// addition was successful; false if it overflowed.  When overflow occurs, the
+// high precision integer is reset to zero.
+__forceinline bool __cdecl add(big_integer& x, uint32_t const value) throw()
+{
+    if (value == 0)
+    {
+        return true;
+    }
+
+    uint32_t carry = value;
+    for (uint32_t i = 0; i != x._used; ++i)
+    {
+        uint64_t const result = static_cast<uint64_t>(x._data[i]) + carry;
+        x._data[i]            = static_cast<uint32_t>(result);
+        carry                 = static_cast<uint32_t>(result >> 32);
+    }
+
+    if (carry != 0)
+    {
+        if (x._used < big_integer::element_count)
+        {
+            x._data[x._used] = carry;
+            ++x._used;
+        }
+        else
+        {
+            x = big_integer{};
+            return false;
+        }
+    }
+
+    return true;
+}
+
+__forceinline uint32_t __cdecl add_carry(
+    uint32_t&      u1,
+    uint32_t const u2,
+    uint32_t const u_carry
+    ) throw()
+{
+    uint64_t const uu = static_cast<uint64_t>(u1) + u2 + u_carry;
+    u1   = static_cast<uint32_t>(uu);
+    return static_cast<uint32_t>(uu >> 32);
+}
+
+__forceinline uint32_t __cdecl add_multiply_carry(
+    uint32_t&      u_add,
+    uint32_t const u_mul_1,
+    uint32_t const u_mul_2,
+    uint32_t const u_carry
+    ) throw()
+{
+    uint64_t const uu_res = static_cast<uint64_t>(u_mul_1) * u_mul_2 + u_add + u_carry;
+    u_add = static_cast<uint32_t>(uu_res);
+    return  reinterpret_cast<unsigned const*>(&uu_res)[1];
+}
+
+__forceinline uint32_t __cdecl multiply_core(
+    _Inout_updates_all_(multiplicand_count) uint32_t*   const multiplicand,
+                                            uint32_t    const multiplicand_count,
+                                            uint32_t    const multiplier
+    ) throw()
+{
+    uint32_t carry = 0;
+    for (uint32_t i = 0; i != multiplicand_count; ++i)
+    {
+        uint64_t const result = static_cast<uint64_t>(multiplicand[i]) * multiplier + carry;
+        multiplicand[i]       = static_cast<uint32_t>(result);
+        carry                 = static_cast<uint32_t>(result >> 32);
+    }
+
+    return carry;
+}
+
+
+// Multiplies the high precision multiplicand by a 32-bit multiplier.  Returns
+// true if the multiplication was successful; false if it overflowed.  When
+// overflow occurs, the multiplicand is reset to zero.
+__forceinline bool __cdecl multiply(big_integer& multiplicand, uint32_t const multiplier) throw()
+{
+    if (multiplier == 0)
+    {
+        multiplicand = big_integer{};
+        return true;
+    }
+
+    if (multiplier == 1)
+    {
+        return true;
+    }
+
+    if (multiplicand._used == 0)
+    {
+        return true;
+    }
+
+    uint32_t const carry = multiply_core(multiplicand._data, multiplicand._used, multiplier);
+    if (carry != 0)
+    {
+        if (multiplicand._used < big_integer::element_count)
+        {
+            multiplicand._data[multiplicand._used] = carry;
+            ++multiplicand._used;
+        }
+        else
+        {
+            multiplicand = big_integer{};
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// This high precision integer division implementation was translated from the
+// implementation of System.Numerics.BigIntegerBuilder.Mul in the .NET Framework
+// sources.  It multiplies the multiplicand by the multiplier and returns true
+// if the multiplication was successful; false if it overflowed.  When overflow
+// occurs, the multiplicand is reset to zero.
+__forceinline bool __cdecl multiply(big_integer& multiplicand, big_integer const& multiplier) throw()
+{
+    if (multiplier._used <= 1)
+    {
+        return multiply(multiplicand, multiplier._data[0]);
+    }
+
+    if (multiplicand._used <= 1)
+    {
+        uint32_t const small_multiplier = multiplicand._data[0];
+        multiplicand = multiplier;
+        return multiply(multiplicand, small_multiplier);
+    }
+
+    // We prefer more iterations on the inner loop and fewer on the outer:
+    bool const multiplier_is_shorter = multiplier._used < multiplicand._used;
+    uint32_t const* const rgu1 = multiplier_is_shorter ? multiplier._data : multiplicand._data;
+    uint32_t const* const rgu2 = multiplier_is_shorter ? multiplicand._data : multiplier._data;
+
+    uint32_t const cu1 = multiplier_is_shorter ? multiplier._used : multiplicand._used;
+    uint32_t const cu2 = multiplier_is_shorter ? multiplicand._used : multiplier._used;
+
+    big_integer result{};
+    for (uint32_t iu1 = 0; iu1 != cu1; ++iu1)
+    {
+        uint32_t const u_cur = rgu1[iu1];
+        if (u_cur == 0)
+        {
+            if (iu1 == result._used)
+            {
+                result._data[iu1] = 0;
+                result._used = iu1 + 1;
+            }
+
+            continue;
+        }
+
+        uint32_t u_carry = 0;
+        uint32_t iu_res = iu1;
+        for (uint32_t iu2 = 0; iu2 != cu2 && iu_res != big_integer::element_count; ++iu2, ++iu_res)
+        {
+            if (iu_res == result._used)
+            {
+                result._data[iu_res] = 0;
+                result._used = iu_res + 1;
+            }
+
+            u_carry = add_multiply_carry(result._data[iu_res], u_cur, rgu2[iu2], u_carry);
+        }
+
+        while (u_carry != 0 && iu_res != big_integer::element_count)
+        {
+            if (iu_res == result._used)
+            {
+                result._data[iu_res] = 0;
+                result._used = iu_res + 1;
+            }
+
+            u_carry = add_carry(result._data[iu_res++], 0, u_carry);
+        }
+
+        if (iu_res == big_integer::element_count)
+        {
+            multiplicand = big_integer{};
+            return false;
+        }
+    }
+
+    // Store the result in the multiplicand and compute the actual number of
+    // elements used:
+    multiplicand = result;
+    return true;
+}
+
+// Multiplies the high precision integer x by 10^power.  Returns true if the
+// multiplication was successful; false if it overflowed.  When overflow occurs,
+// the high precision integer is reset to zero.
+__forceinline bool __cdecl multiply_by_power_of_ten(big_integer& x, uint32_t const power) throw()
+{
+    // To improve performance, we use a table of precomputed powers of ten, from
+    // 10^10 through 10^380, in increments of ten.  In its unpacked form, as an
+    // array of big_integer objects, this table consists mostly of zero elements.
+    // Thus, we store the table in a packed form, trimming leading and trailing
+    // zero elements.  We provide an index that is used to unpack powers from the
+    // table, using the function that appears after this function in this file.
+    //
+    // The minimum value representable with double precision is 5E-324.  With
+    // this table we can thus compute most multiplications with a single multiply.
+    static uint32_t const large_power_data[] = 
+    {
+        0x540be400, 0x00000002, 0x63100000, 0x6bc75e2d, 0x00000005, 0x40000000, 0x4674edea, 0x9f2c9cd0, 
+        0x0000000c, 0xb9f56100, 0x5ca4bfab, 0x6329f1c3, 0x0000001d, 0xb5640000, 0xc40534fd, 0x926687d2, 
+        0x6c3b15f9, 0x00000044, 0x10000000, 0x946590d9, 0xd762422c, 0x9a224501, 0x4f272617, 0x0000009f, 
+        0x07950240, 0x245689c1, 0xc5faa71c, 0x73c86d67, 0xebad6ddc, 0x00000172, 0xcec10000, 0x63a22764, 
+        0xefa418ca, 0xcdd17b25, 0x6bdfef70, 0x9dea3e1f, 0x0000035f, 0xe4000000, 0xcdc3fe6e, 0x66bc0c6a, 
+        0x2e391f32, 0x5a450203, 0x71d2f825, 0xc3c24a56, 0x000007da, 0xa82e8f10, 0xaab24308, 0x8e211a7c, 
+        0xf38ace40, 0x84c4ce0b, 0x7ceb0b27, 0xad2594c3, 0x00001249, 0xdd1a4000, 0xcc9f54da, 0xdc5961bf, 
+        0xc75cabab, 0xf505440c, 0xd1bc1667, 0xfbb7af52, 0x608f8d29, 0x00002a94, 0x21000000, 0x17bb8a0c, 
+        0x56af8ea4, 0x06479fa9, 0x5d4bb236, 0x80dc5fe0, 0xf0feaa0a, 0xa88ed940, 0x6b1a80d0, 0x00006323, 
+        0x324c3864, 0x8357c796, 0xe44a42d5, 0xd9a92261, 0xbd3c103d, 0x91e5f372, 0xc0591574, 0xec1da60d, 
+        0x102ad96c, 0x0000e6d3, 0x1e851000, 0x6e4f615b, 0x187b2a69, 0x0450e21c, 0x2fdd342b, 0x635027ee, 
+        0xa6c97199, 0x8e4ae916, 0x17082e28, 0x1a496e6f, 0x0002196e, 0x32400000, 0x04ad4026, 0xf91e7250, 
+        0x2994d1d5, 0x665bcdbb, 0xa23b2e96, 0x65fa7ddb, 0x77de53ac, 0xb020a29b, 0xc6bff953, 0x4b9425ab, 
+        0x0004e34d, 0xfbc32d81, 0x5222d0f4, 0xb70f2850, 0x5713f2f3, 0xdc421413, 0xd6395d7d, 0xf8591999, 
+        0x0092381c, 0x86b314d6, 0x7aa577b9, 0x12b7fe61, 0x000b616a, 0x1d11e400, 0x56c3678d, 0x3a941f20, 
+        0x9b09368b, 0xbd706908, 0x207665be, 0x9b26c4eb, 0x1567e89d, 0x9d15096e, 0x7132f22b, 0xbe485113, 
+        0x45e5a2ce, 0x001a7f52, 0xbb100000, 0x02f79478, 0x8c1b74c0, 0xb0f05d00, 0xa9dbc675, 0xe2d9b914, 
+        0x650f72df, 0x77284b4c, 0x6df6e016, 0x514391c2, 0x2795c9cf, 0xd6e2ab55, 0x9ca8e627, 0x003db1a6, 
+        0x40000000, 0xf4ecd04a, 0x7f2388f0, 0x580a6dc5, 0x43bf046f, 0xf82d5dc3, 0xee110848, 0xfaa0591c, 
+        0xcdf4f028, 0x192ea53f, 0xbcd671a0, 0x7d694487, 0x10f96e01, 0x791a569d, 0x008fa475, 0xb9b2e100, 
+        0x8288753c, 0xcd3f1693, 0x89b43a6b, 0x089e87de, 0x684d4546, 0xfddba60c, 0xdf249391, 0x3068ec13, 
+        0x99b44427, 0xb68141ee, 0x5802cac3, 0xd96851f1, 0x7d7625a2, 0x014e718d, 0xfb640000, 0xf25a83e6, 
+        0x9457ad0f, 0x0080b511, 0x2029b566, 0xd7c5d2cf, 0xa53f6d7d, 0xcdb74d1c, 0xda9d70de, 0xb716413d, 
+        0x71d0ca4e, 0xd7e41398, 0x4f403a90, 0xf9ab3fe2, 0x264d776f, 0x030aafe6, 0x10000000, 0x09ab5531, 
+        0xa60c58d2, 0x566126cb, 0x6a1c8387, 0x7587f4c1, 0x2c44e876, 0x41a047cf, 0xc908059e, 0xa0ba063e, 
+        0xe7cfc8e8, 0xe1fac055, 0xef0144b2, 0x24207eb0, 0xd1722573, 0xe4b8f981, 0x071505ae, 0x7a3b6240, 
+        0xcea45d4f, 0x4fe24133, 0x210f6d6d, 0xe55633f2, 0x25c11356, 0x28ebd797, 0xd396eb84, 0x1e493b77, 
+        0x471f2dae, 0x96ad3820, 0x8afaced1, 0x4edecddb, 0x5568c086, 0xb2695da1, 0x24123c89, 0x107d4571, 
+        0x1c410000, 0x6e174a27, 0xec62ae57, 0xef2289aa, 0xb6a2fbdd, 0x17e1efe4, 0x3366bdf2, 0x37b48880, 
+        0xbfb82c3e, 0x19acde91, 0xd4f46408, 0x35ff6a4e, 0x67566a0e, 0x40dbb914, 0x782a3bca, 0x6b329b68, 
+        0xf5afc5d9, 0x266469bc, 0xe4000000, 0xfb805ff4, 0xed55d1af, 0x9b4a20a8, 0xab9757f8, 0x01aefe0a, 
+        0x4a2ca67b, 0x1ebf9569, 0xc7c41c29, 0xd8d5d2aa, 0xd136c776, 0x93da550c, 0x9ac79d90, 0x254bcba8, 
+        0x0df07618, 0xf7a88809, 0x3a1f1074, 0xe54811fc, 0x59638ead, 0x97cbe710, 0x26d769e8, 0xb4e4723e, 
+        0x5b90aa86, 0x9c333922, 0x4b7a0775, 0x2d47e991, 0x9a6ef977, 0x160b40e7, 0x0c92f8c4, 0xf25ff010, 
+        0x25c36c11, 0xc9f98b42, 0x730b919d, 0x05ff7caf, 0xb0432d85, 0x2d2b7569, 0xa657842c, 0xd01fef10, 
+        0xc77a4000, 0xe8b862e5, 0x10d8886a, 0xc8cd98e5, 0x108955c5, 0xd059b655, 0x58fbbed4, 0x03b88231, 
+        0x034c4519, 0x194dc939, 0x1fc500ac, 0x794cc0e2, 0x3bc980a1, 0xe9b12dd1, 0x5e6d22f8, 0x7b38899a, 
+        0xce7919d8, 0x78c67672, 0x79e5b99f, 0xe494034e, 0x00000001, 0xa1000000, 0x6c5cd4e9, 0x9be47d6f, 
+        0xf93bd9e7, 0x77626fa1, 0xc68b3451, 0xde2b59e8, 0xcf3cde58, 0x2246ff58, 0xa8577c15, 0x26e77559, 
+        0x17776753, 0xebe6b763, 0xe3fd0a5f, 0x33e83969, 0xa805a035, 0xf631b987, 0x211f0f43, 0xd85a43db, 
+        0xab1bf596, 0x683f19a2, 0x00000004, 0xbe7dfe64, 0x4bc9042f, 0xe1f5edb0, 0x8fa14eda, 0xe409db73, 
+        0x674fee9c, 0xa9159f0d, 0xf6b5b5d6, 0x7338960e, 0xeb49c291, 0x5f2b97cc, 0x0f383f95, 0x2091b3f6, 
+        0xd1783714, 0xc1d142df, 0x153e22de, 0x8aafdf57, 0x77f5e55f, 0xa3e7ca8b, 0x032f525b, 0x42e74f3d, 
+        0x0000000a, 0xf4dd1000, 0x5d450952, 0xaeb442e1, 0xa3b3342e, 0x3fcda36f, 0xb4287a6e, 0x4bc177f7, 
+        0x67d2c8d0, 0xaea8f8e0, 0xadc93b67, 0x6cc856b3, 0x959d9d0b, 0x5b48c100, 0x4abe8a3d, 0x52d936f4, 
+        0x71dbe84d, 0xf91c21c5, 0x4a458109, 0xd7aad86a, 0x08e14c7c, 0x759ba59c, 0xe43c8800, 0x00000017, 
+        0x92400000, 0x04f110d4, 0x186472be, 0x8736c10c, 0x1478abfb, 0xfc51af29, 0x25eb9739, 0x4c2b3015, 
+        0xa1030e0b, 0x28fe3c3b, 0x7788fcba, 0xb89e4358, 0x733de4a4, 0x7c46f2c2, 0x8f746298, 0xdb19210f, 
+        0x2ea3b6ae, 0xaa5014b2, 0xea39ab8d, 0x97963442, 0x01dfdfa9, 0xd2f3d3fe, 0xa0790280, 0x00000037, 
+        0x509c9b01, 0xc7dcadf1, 0x383dad2c, 0x73c64d37, 0xea6d67d0, 0x519ba806, 0xc403f2f8, 0xa052e1a2, 
+        0xd710233a, 0x448573a9, 0xcf12d9ba, 0x70871803, 0x52dc3a9b, 0xe5b252e8, 0x0717fb4e, 0xbe4da62f, 
+        0x0aabd7e1, 0x8c62ed4f, 0xceb9ec7b, 0xd4664021, 0xa1158300, 0xcce375e6, 0x842f29f2, 0x00000081, 
+        0x7717e400, 0xd3f5fb64, 0xa0763d71, 0x7d142fe9, 0x33f44c66, 0xf3b8f12e, 0x130f0d8e, 0x734c9469, 
+        0x60260fa8, 0x3c011340, 0xcc71880a, 0x37a52d21, 0x8adac9ef, 0x42bb31b4, 0xd6f94c41, 0xc88b056c, 
+        0xe20501b8, 0x5297ed7c, 0x62c361c4, 0x87dad8aa, 0xb833eade, 0x94f06861, 0x13cc9abd, 0x8dc1d56a, 
+        0x0000012d, 0x13100000, 0xc67a36e8, 0xf416299e, 0xf3493f0a, 0x77a5a6cf, 0xa4be23a3, 0xcca25b82, 
+        0x3510722f, 0xbe9d447f, 0xa8c213b8, 0xc94c324e, 0xbc9e33ad, 0x76acfeba, 0x2e4c2132, 0x3e13cd32, 
+        0x70fe91b4, 0xbb5cd936, 0x42149785, 0x46cc1afd, 0xe638ddf8, 0x690787d2, 0x1a02d117, 0x3eb5f1fe, 
+        0xc3b9abae, 0x1c08ee6f, 0x000002be, 0x40000000, 0x8140c2aa, 0x2cf877d9, 0x71e1d73d, 0xd5e72f98, 
+        0x72516309, 0xafa819dd, 0xd62a5a46, 0x2a02dcce, 0xce46ddfe, 0x2713248d, 0xb723d2ad, 0xc404bb19, 
+        0xb706cc2b, 0x47b1ebca, 0x9d094bdc, 0xc5dc02ca, 0x31e6518e, 0x8ec35680, 0x342f58a8, 0x8b041e42, 
+        0xfebfe514, 0x05fffc13, 0x6763790f, 0x66d536fd, 0xb9e15076, 0x00000662, 0x67b06100, 0xd2010a1a, 
+        0xd005e1c0, 0xdb12733b, 0xa39f2e3f, 0x61b29de2, 0x2a63dce2, 0x942604bc, 0x6170d59b, 0xc2e32596, 
+        0x140b75b9, 0x1f1d2c21, 0xb8136a60, 0x89d23ba2, 0x60f17d73, 0xc6cad7df, 0x0669df2b, 0x24b88737, 
+        0x669306ed, 0x19496eeb, 0x938ddb6f, 0x5e748275, 0xc56e9a36, 0x3690b731, 0xc82842c5, 0x24ae798e, 
+        0x00000ede, 0x41640000, 0xd5889ac1, 0xd9432c99, 0xa280e71a, 0x6bf63d2e, 0x8249793d, 0x79e7a943, 
+        0x22fde64a, 0xe0d6709a, 0x05cacfef, 0xbd8da4d7, 0xe364006c, 0xa54edcb3, 0xa1a8086e, 0x748f459e, 
+        0xfc8e54c8, 0xcc74c657, 0x42b8c3d4, 0x57d9636e, 0x35b55bcc, 0x6c13fee9, 0x1ac45161, 0xb595badb, 
+        0xa1f14e9d, 0xdcf9e750, 0x07637f71, 0xde2f9f2b, 0x0000229d, 0x10000000, 0x3c5ebd89, 0xe3773756, 
+        0x3dcba338, 0x81d29e4f, 0xa4f79e2c, 0xc3f9c774, 0x6a1ce797, 0xac5fe438, 0x07f38b9c, 0xd588ecfa, 
+        0x3e5ac1ac, 0x85afccce, 0x9d1f3f70, 0xe82d6dd3, 0x177d180c, 0x5e69946f, 0x648e2ce1, 0x95a13948, 
+        0x340fe011, 0xb4173c58, 0x2748f694, 0x7c2657bd, 0x758bda2e, 0x3b8090a0, 0x2ddbb613, 0x6dcf4890, 
+        0x24e4047e, 0x00005099, 
+    };
+
+    struct unpack_index
+    {
+        uint16_t _offset; // The offset of this power's initial byte in the array
+        uint8_t  _zeroes; // The number of omitted leading zero elements
+        uint8_t  _size;   // The number of elements present for this power
+    };
+
+    static unpack_index const large_power_indices[] = 
+    {
+        {    0,  0,  2 }, {    2,  0,  3 }, {    5,  0,  4 }, {    9,  1,  4 }, 
+        {   13,  1,  5 }, {   18,  1,  6 }, {   24,  2,  6 }, {   30,  2,  7 }, 
+        {   37,  2,  8 }, {   45,  3,  8 }, {   53,  3,  9 }, {   62,  3, 10 }, 
+        {   72,  4, 10 }, {   82,  4, 11 }, {   93,  4, 12 }, {  105,  5, 12 }, 
+        {  117,  5, 13 }, {  130,  5, 14 }, {  144,  5, 15 }, {  159,  6, 15 }, 
+        {  174,  6, 16 }, {  190,  6, 17 }, {  207,  7, 17 }, {  224,  7, 18 }, 
+        {  242,  7, 19 }, {  261,  8, 19 }, {  280,  8, 21 }, {  301,  8, 22 }, 
+        {  323,  9, 22 }, {  345,  9, 23 }, {  368,  9, 24 }, {  392, 10, 24 }, 
+        {  416, 10, 25 }, {  441, 10, 26 }, {  467, 10, 27 }, {  494, 11, 27 }, 
+        {  521, 11, 28 }, {  549, 11, 29 },
+    };
+
+    uint32_t large_power = power / 10;
+    while (large_power  != 0)
+    {
+        uint32_t const current_power = large_power > _countof(large_power_indices)
+            ? _countof(large_power_indices)
+            : large_power;
+
+        unpack_index const& index = large_power_indices[current_power - 1];
+        big_integer multiplier{};
+        multiplier._used = index._size + index._zeroes;
+
+        uint32_t const* const source = large_power_data + index._offset;
+        
+        memset(multiplier._data, 0, index._zeroes * sizeof(uint32_t));
+        memcpy(multiplier._data + index._zeroes, source, index._size * sizeof(uint32_t));
+
+        if (!multiply(x, multiplier))
+        {
+            x = big_integer{};
+            return false;
+        }
+
+        large_power -= current_power;
+    }
+
+    static uint32_t const small_powers_of_ten[9] =
+    {
+          10,
+         100,
+        1000,
+        1000 *   10,
+        1000 *  100,
+        1000 * 1000,
+        1000 * 1000 *   10,
+        1000 * 1000 *  100,
+        1000 * 1000 * 1000
+    };
+
+    uint32_t const small_power = power % 10;
+    if (small_power != 0)
+    {
+        if (!multiply(x, small_powers_of_ten[small_power - 1]))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// The following non-compiled functions are the generators for the big powers of
+// ten table found in multiply_by_power_of_ten().  This code is provided for
+// future use if the table needs to be amended.  Do not remove this code.
+/*
+uint32_t count_leading_zeroes(big_integer const& x)
+{
+    for (uint32_t i = 0; i != x._used; ++i)
+    {
+        if (x._data[i] != 0)
+            return i;
+    }
+
+    return 0;
+}
+
+void generate_table()
+{
+    std::vector<uint32_t>     elements;
+    std::vector<unpack_index> indices;
+
+    for (uint32_t i = 10; i != 390; i += 10)
+    {
+        big_integer x = make_big_integer(1);
+        for (uint32_t j = 0; j != i; ++j)
+        {
+            multiply(x, 10);
+        }
+
+        unpack_index index{};
+        index._offset = elements.size();
+        index._zeroes = count_leading_zeroes(x);
+        index._size   = x._used - index._zeroes;
+
+        for (uint32_t j = index._zeroes; j != x._used; ++j)
+        {
+            elements.push_back(x._data[j]);
+        }
+        indices.push_back(index);
+    }
+
+    printf("static uint32_t const large_power_data[] = \n{");
+    for (uint32_t i = 0; i != elements.size(); ++i)
+    {
+        printf("%s0x%08x, ", i % 8 == 0 ? "\n    " : "", elements[i]);
+    }
+    printf("\n};\n");
+    
+    printf("static unpack_index const large_power_indices[] = \n{\n");
+    for (uint32_t i = 0; i != indices.size(); ++i)
+    {
+        printf("%s{ %4u, %2u, %2u }, ",
+            i % 4 == 0 ? "\n    " : "",
+            indices[i]._offset,
+            indices[i]._zeroes,
+            indices[i]._size);
+    }
+    printf("};\n");
+}
+*/
+
+// Computes the number of zeroes higher than the most significant set bit in 'u'
+__forceinline uint32_t __cdecl count_sequential_high_zeroes(uint32_t const u) throw()
+{
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    return _CountLeadingZeros(u);
+#else
+    unsigned long result;
+    return _BitScanReverse(&result, u) ? 31 - result : 32;
+#endif
+}
+
+// PERFORMANCE NOTE:  On x86, for multiplication of a 64-bit unsigned integer by
+// a 32-bit unsigned integer, the compiler will generate a call to _allmul.  For
+// division-heavy conversions, the inline assembly version presented here gives a
+// 10% overall performance improvement (not 10% faster division--10% faster total).
+// This function [1] uses only two 32-bit multiplies instead of the three required
+// for general 64-bit x 64-bit multiplication, and [2] is inlineable, allowing the
+// compile to elide the extreme overhead of calling the _allmul function.
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    __forceinline uint64_t __cdecl multiply_64_32(
+        uint64_t const multiplicand,
+        uint32_t const multiplier
+        ) throw()
+    {
+        __asm
+        {
+            mov eax, dword ptr [multiplicand + 4]
+            mul multiplier
+
+            mov ecx, eax
+
+            mov eax, dword ptr [multiplicand]
+            mul multiplier
+
+            add edx, ecx
+        }
+    }
+#else
+    __forceinline uint64_t __cdecl multiply_64_32(
+        uint64_t const multiplicand,
+        uint32_t const multiplier
+        ) throw()
+    {
+        return multiplicand * multiplier;
+    }
+#endif
+
+// This high precision integer division implementation was translated from the
+// implementation of System.Numerics.BigIntegerBuilder.ModDivCore in the .NET
+// Framework sources.  It computes both quotient and remainder:  the remainder
+// is stored in the numerator argument, and the least significant 32 bits of the
+// quotient are returned from the function.
+inline uint64_t __cdecl divide(
+    big_integer      & numerator,
+    big_integer const& denominator
+    ) throw()
+{
+    // If the numerator is zero, then both the quotient and remainder are zero:
+    if (numerator._used == 0)
+    {
+        return 0;
+    }
+
+    // If the denominator is zero, then uh oh. We can't divide by zero:
+    if (denominator._used == 0)
+    {
+        _ASSERTE(("Division by zero", false));
+        return 0;
+    }
+
+    uint32_t max_numerator_element_index   = numerator._used   - 1;
+    uint32_t max_denominator_element_index = denominator._used - 1;
+
+    // The numerator and denominator are both nonzero.  If the denominator is
+    // only one element wide, we can take the fast route:
+    if (max_denominator_element_index == 0)
+    {
+        uint32_t const small_denominator = denominator._data[0];
+
+        if (small_denominator == 1)
+        {
+            uint32_t const quotient = numerator._data[0];
+            numerator = big_integer{};
+            return quotient;
+        }
+
+        if (max_numerator_element_index == 0)
+        {
+            uint32_t const small_numerator = numerator._data[0];
+
+            numerator = big_integer{};
+            numerator._data[0] = small_numerator % small_denominator;
+            numerator._used = numerator._data[0] > 0 ? 1 : 0;
+            return small_numerator / small_denominator;
+        }
+
+        // We count down in the next loop, so the last assignment to quotient
+        // will be the correct one.
+        uint64_t quotient = 0;
+
+        uint64_t uu = 0;
+        for (uint32_t iv = max_numerator_element_index; iv != static_cast<uint32_t>(-1); --iv)
+        {
+            uu = (uu << 32) | numerator._data[iv];
+            quotient = (quotient << 32) + static_cast<uint32_t>(uu / small_denominator);
+            uu %= small_denominator;
+        }
+
+        numerator = big_integer{};
+        numerator._data[1] = static_cast<uint32_t>(uu >> 32);
+        numerator._data[0] = static_cast<uint32_t>(uu      );
+        numerator._used = numerator._data[1] > 0 ? 2 : 1;
+        return quotient;
+    }
+
+    if (max_denominator_element_index > max_numerator_element_index)
+    {
+        return 0;
+    }
+
+    uint32_t cu_den  = max_denominator_element_index + 1;
+    int32_t  cu_diff = max_numerator_element_index - max_denominator_element_index;
+
+    // Determine whether the result will have cu_diff or cu_diff + 1 digits:
+    int32_t cu_quo = cu_diff;
+    for (int32_t iu = max_numerator_element_index; ; --iu)
+    {
+        if (iu < cu_diff)
+        {
+            ++cu_quo;
+            break;
+        }
+
+        if (denominator._data[iu - cu_diff] != numerator._data[iu])
+        {
+            if (denominator._data[iu - cu_diff] < numerator._data[iu])
+            {
+                ++cu_quo;
+            }
+
+            break;
+        }
+    }
+
+    if (cu_quo == 0)
+    {
+        return 0;
+    }
+
+    // Get the uint to use for the trial divisions.  We normalize so the
+    // high bit is set:
+    uint32_t u_den      = denominator._data[cu_den - 1];
+    uint32_t u_den_next = denominator._data[cu_den - 2];
+
+    uint32_t cbit_shift_left  = count_sequential_high_zeroes(u_den);
+    uint32_t cbit_shift_right = 32 - cbit_shift_left;
+    if (cbit_shift_left > 0)
+    {
+        u_den        = (u_den << cbit_shift_left) | (u_den_next >> cbit_shift_right);
+        u_den_next <<= cbit_shift_left;
+
+        if (cu_den > 2)
+        {
+            u_den_next |= denominator._data[cu_den - 3] >> cbit_shift_right;
+        }
+    }
+
+    uint64_t quotient{};
+    for (int32_t iu = cu_quo; --iu >= 0; )
+    {
+        // Get the high (normalized) bits of the numerator:
+        uint32_t u_num_hi = (iu + cu_den <= max_numerator_element_index)
+            ? numerator._data[iu + cu_den]
+            : 0;
+
+        uint64_t uu_num = numerator._data[iu + cu_den - 1];
+        reinterpret_cast<uint32_t*>(&uu_num)[1] = u_num_hi;
+
+        uint32_t u_num_next = numerator._data[iu + cu_den - 2];
+        if (cbit_shift_left > 0)
+        {
+            uu_num = (uu_num << cbit_shift_left) | (u_num_next >> cbit_shift_right);
+            u_num_next <<= cbit_shift_left;
+
+            if (iu + cu_den >= 3)
+            {
+                u_num_next |= numerator._data[iu + cu_den - 3] >> cbit_shift_right;
+            }
+        }
+
+        // Divide to get the quotient digit:
+        uint64_t uu_quo = uu_num / u_den;
+        uint64_t uu_rem = static_cast<uint32_t>(uu_num % u_den);
+
+        if (uu_quo > UINT32_MAX)
+        {
+            uu_rem += u_den * (uu_quo - UINT32_MAX);
+            uu_quo  = UINT32_MAX;
+        }
+
+        while (uu_rem <= UINT32_MAX && uu_quo * u_den_next > ((uu_rem << 32) | u_num_next))
+        {
+            --uu_quo;
+            uu_rem += u_den;
+        }
+
+        // Multiply and subtract.  Note that uu_quo may be one too large.  If
+        // we have a borrow at the end, we'll add the denominator back on and 
+        // decrement uu_quo.
+        if (uu_quo > 0)
+        {
+            uint64_t uu_borrow = 0;
+
+            for (uint32_t iu2 = 0; iu2 < cu_den; ++iu2)
+            {
+                uu_borrow += multiply_64_32(uu_quo, denominator._data[iu2]);
+
+                uint32_t const u_sub = static_cast<uint32_t>(uu_borrow);
+                uu_borrow >>= 32;
+                if (numerator._data[iu + iu2] < u_sub)
+                {
+                    ++uu_borrow;
+                }
+
+                numerator._data[iu + iu2] -= u_sub;
+            }
+
+            if (u_num_hi < uu_borrow)
+            {
+                // Add, tracking carry:
+                uint32_t u_carry = 0;
+                for (uint32_t iu2 = 0; iu2 < cu_den; ++iu2)
+                {
+                    uint64_t const sum =
+                        static_cast<uint64_t>(numerator._data[iu + iu2]) +
+                        static_cast<uint64_t>(denominator._data[iu2])    +
+                        u_carry;
+
+                    numerator._data[iu + iu2] = static_cast<uint32_t>(sum);
+                    u_carry = sum >> 32;
+                }
+
+                --uu_quo;
+            }
+
+            max_numerator_element_index = iu + cu_den - 1;
+        }
+
+        quotient = (quotient << 32) + static_cast<uint32_t>(uu_quo);
+    }
+
+    // Trim the remainder:
+    for (uint32_t i = max_numerator_element_index + 1; i < numerator._used; ++i)
+    {
+        numerator._data[i] = 0;
+    }
+
+    numerator._used = max_numerator_element_index + 1;
+    while (numerator._used != 0 && numerator._data[numerator._used - 1] == 0)
+    {
+        --numerator._used;
+    }
+
+    return quotient;
+}
+
+} // namespace __crt_strtox
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_fltintrn.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_fltintrn.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f4215bcb2d16f58c0dbe3144d08e154a97d26f1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_fltintrn.h	
@@ -0,0 +1,220 @@
+//
+// corecrt_internal_fltintrn.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Floating point conversion routines for internal use.  This is a C++ header.
+//
+#pragma once
+
+#include <corecrt_internal.h>
+#include <float.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename FloatingType>
+struct __acrt_floating_type_traits;
+
+template <>
+struct __acrt_floating_type_traits<float>
+{
+    enum : int32_t
+    {
+        mantissa_bits            = FLT_MANT_DIG,
+        exponent_bits            = sizeof(float) * CHAR_BIT - FLT_MANT_DIG,
+
+        maximum_binary_exponent  = FLT_MAX_EXP - 1,
+        minimum_binary_exponent  = FLT_MIN_EXP - 1,
+
+        exponent_bias            = 127
+    };
+
+    enum : uint32_t
+    {
+        exponent_mask             = (1u << (exponent_bits    )) - 1,
+        normal_mantissa_mask      = (1u << (mantissa_bits    )) - 1,
+        denormal_mantissa_mask    = (1u << (mantissa_bits - 1)) - 1,
+
+        special_nan_mantissa_mask = (1u << (mantissa_bits - 2))
+    };
+
+    struct components_type
+    {
+        uint32_t _mantissa : mantissa_bits - 1;
+        uint32_t _exponent : exponent_bits;
+        uint32_t _sign     : 1;
+    };
+
+    static_assert(sizeof(components_type) == sizeof(float), "unexpected components size");
+};
+
+template <>
+struct __acrt_floating_type_traits<double>
+{
+    enum : int32_t
+    {
+        mantissa_bits            = DBL_MANT_DIG,
+        exponent_bits            = sizeof(double) * CHAR_BIT - DBL_MANT_DIG,
+
+        maximum_binary_exponent  = DBL_MAX_EXP - 1,
+        minimum_binary_exponent  = DBL_MIN_EXP - 1,
+
+        exponent_bias            = 1023
+    };
+
+    enum : uint64_t
+    {
+        exponent_mask             = (1ui64 << (exponent_bits    )) - 1,
+        normal_mantissa_mask      = (1ui64 << (mantissa_bits    )) - 1,
+        denormal_mantissa_mask    = (1ui64 << (mantissa_bits - 1)) - 1,
+
+        special_nan_mantissa_mask = (1ui64 << (mantissa_bits - 2))
+    };
+
+    struct components_type
+    {
+        uint64_t _mantissa : mantissa_bits - 1;
+        uint64_t _exponent : exponent_bits;
+        uint64_t _sign     : 1;
+    };
+
+    static_assert(sizeof(components_type) == sizeof(double), "unexpected components size");
+};
+
+enum class __acrt_fp_class : uint32_t
+{
+    finite,
+    infinity,
+    quiet_nan,
+    signaling_nan,
+    indeterminate,
+};
+
+enum class __acrt_has_trailing_digits
+{
+    trailing,
+    no_trailing
+};
+
+// Precision is the number of digits after the decimal point, but
+// this has different implications for how many digits need to be
+// generated based upon how the number will be formatted.
+enum class __acrt_precision_style
+{
+    fixed,      // 123.456 %f style requires '3' precision to generate 6 digits to format "123.456".
+    scientific  // 123.456 %e style requires '5' precision to generate 6 digits to format "1.23456e+02".
+};
+
+// This rounding mode is used to know if we are using functions like gcvt vs printf
+enum class __acrt_rounding_mode
+{
+    legacy,
+    standard
+};
+
+inline __acrt_fp_class __cdecl __acrt_fp_classify(double const& value) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    components_type const& components = reinterpret_cast<components_type const&>(value);
+
+    bool const value_is_nan_or_infinity = components._exponent == (1u << floating_traits::exponent_bits) - 1;
+    if (!value_is_nan_or_infinity)
+    {
+        return __acrt_fp_class::finite;
+    }
+    else if (components._mantissa == 0)
+    {
+        return __acrt_fp_class::infinity;
+    }
+    else if (components._sign == 1 && components._mantissa == floating_traits::special_nan_mantissa_mask)
+    {
+        return __acrt_fp_class::indeterminate;
+    }
+    else if (components._mantissa & floating_traits::special_nan_mantissa_mask) // Quiet NAN
+    {
+        return __acrt_fp_class::quiet_nan;
+    }
+    else // Signaling NAN
+    {
+        return __acrt_fp_class::signaling_nan;
+    }
+}
+
+inline bool __cdecl __acrt_fp_is_negative(double const& value) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<double>;
+    using components_type = floating_traits::components_type;
+
+    components_type const& components = reinterpret_cast<components_type const&>(value);
+
+    return components._sign == 1;
+}
+
+struct _strflt
+{
+    int   sign;     // Zero if positive otherwise negative
+    int   decpt;    // Exponent of floating point number
+    char* mantissa; // Pointer to mantissa in string form
+};
+
+typedef _strflt* STRFLT;
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Floating Point Conversion Routines
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+_CRT_BEGIN_C_HEADER
+
+// Result buffer count for __acrt_fp_format has a minimum value that depends on the precision requested.
+// This requirement originates and propagates from the fp_format_e_internal function (in convert\cvt.cpp)
+// This macro can be used to annotate result_buffer_count in the below functions
+#define _In_fits_precision_(precision_arg)                                        \
+        _When_(precision_arg <= 0, _Pre_satisfies_(_Curr_ > 9))                   \
+        _When_(precision_arg >  0, _Pre_satisfies_(_Curr_ > 9 + precision_arg))
+
+_Success_(return == 0)
+errno_t __cdecl __acrt_fp_format(
+    _In_                                                   double const*          value,
+    _Maybe_unsafe_(_Inout_updates_z_, result_buffer_count) char*                  result_buffer,
+    _In_fits_precision_(precision)                         size_t                 result_buffer_count,
+    _Out_writes_(scratch_buffer_count)                     char*                  scratch_buffer,
+    _In_                                                   size_t                 scratch_buffer_count,
+    _In_                                                   int                    format,
+    _In_                                                   int                    precision,
+    _In_                                                   uint64_t               options,
+    _In_                                                   __acrt_rounding_mode   rounding_mode,
+    _Inout_                                                __crt_cached_ptd_host& ptd
+    );
+
+errno_t __cdecl __acrt_fp_strflt_to_string(
+    _Out_writes_z_(buffer_count) char*  buffer,
+    _When_((digits >  0), _In_ _Pre_satisfies_(buffer_count > digits + 1))
+    _When_((digits <= 0), _In_ _Pre_satisfies_(buffer_count > 1))
+    _In_                         size_t buffer_count,
+    _In_                         int    digits,
+    _Inout_                      STRFLT value,
+    _In_                         __acrt_has_trailing_digits trailing_digits,
+    _In_                         __acrt_rounding_mode rounding_mode,
+    _Inout_                      __crt_cached_ptd_host& ptd
+    );
+
+__acrt_has_trailing_digits __cdecl __acrt_fltout(
+    _In_                         _CRT_DOUBLE            value,
+    _In_                         unsigned               precision,
+    _In_                         __acrt_precision_style precision_style,
+    _Out_                        STRFLT                 result,
+    _Out_writes_z_(buffer_count) char*                  buffer,
+    _In_                         size_t                 buffer_count
+    );
+
+_CRT_END_C_HEADER
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_lowio.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_lowio.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6263afd08f9c238d7494acb1021f9041cc89bc0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_lowio.h	
@@ -0,0 +1,328 @@
+//
+// corecrt_internal_lowio.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines internal utilities for working with the lowio
+// library.  This header may only be included in C++ translation units.
+//
+#pragma once
+
+#include <fcntl.h>
+#include <io.h>
+#include <corecrt_internal_traits.h>
+#include <share.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#define LF 10           /* line feed */
+#define CR 13           /* carriage return */
+#define CTRLZ 26        /* ctrl-z means eof for text */
+
+// Real default size for stdio buffers
+#define _INTERNAL_BUFSIZ    4096
+#define _SMALL_BUFSIZ       512
+
+/* Most significant Bit */
+#define _msbit(c) ((c) & 0x80)
+
+/* Independent byte has most significant bit set to 0 */
+#define  _utf8_is_independent(c)    (_msbit(c) == 0)
+
+/* Get no of trailing bytes from the lookup table */
+//    1 for pattern 110xxxxx - 1 trailbyte
+//    2 for pattern 1110xxxx - 2 trailbytes
+//    3 for pattern 11110xxx - 3 trailbytes
+//    0 for everything else, including invalid patterns.
+// We return 0 for invalid patterns because we rely on MultiByteToWideChar to
+// do the validations.
+
+extern char _lookuptrailbytes[256];
+__inline char _utf8_no_of_trailbytes(const unsigned char c)
+{
+    return _lookuptrailbytes[c];
+}
+// It may be faster to just look up the bytes than to use the lookup table.
+//__inline char _utf8_no_of_trailbytes(const unsigned char c)
+//{
+//    // ASCII range is a single character
+//    if ((c & 0x80) == 0) return 0;
+//    // Trail bytes 10xxxxxx aren't lead bytes
+//    if ((c & 0x40) == 0) return 0;
+//    // 110xxxxx is a 2 byte sequence (1 trail byte)
+//    if ((c & 0x20) == 0) return 1;
+//    // 1110xxxx is a 3 byte sequence (2 trail bytes)
+//    if ((c & 0x10) == 0) return 2;
+//    // 11110xxx is a 4 byte sequence (3 trail bytes)
+//    if ((c & 0x08) == 0) return 3;
+//    // Anything with 5 or more lead bits is illegal
+//    return 0;
+//}
+
+/* Any leadbyte will have the patterns 11000xxx 11100xxx or 11110xxx */
+#define  _utf8_is_leadbyte(c)       (_utf8_no_of_trailbytes(static_cast<const unsigned char>(c)) != 0)
+
+enum class __crt_lowio_text_mode : char
+{
+    ansi    = 0, // Regular text
+    utf8    = 1, // UTF-8 encoded
+    utf16le = 2, // UTF-16LE encoded
+};
+
+// osfile flag values
+enum : unsigned char
+{
+    FOPEN      = 0x01, // file handle open
+    FEOFLAG    = 0x02, // end of file has been encountered
+    FCRLF      = 0x04, // CR-LF across read buffer (in text mode)
+    FPIPE      = 0x08, // file handle refers to a pipe
+    FNOINHERIT = 0x10, // file handle opened _O_NOINHERIT
+    FAPPEND    = 0x20, // file handle opened O_APPEND
+    FDEV       = 0x40, // file handle refers to device
+    FTEXT      = 0x80, // file handle is in text mode
+};
+
+typedef char __crt_lowio_pipe_lookahead[3];
+
+/*
+ * Control structure for lowio file handles
+ */
+struct __crt_lowio_handle_data
+{
+    CRITICAL_SECTION           lock;
+    intptr_t                   osfhnd;          // underlying OS file HANDLE
+    __int64                    startpos;        // File position that matches buffer start
+    unsigned char              osfile;          // Attributes of file (e.g., open in text mode?)
+    __crt_lowio_text_mode      textmode;
+    __crt_lowio_pipe_lookahead _pipe_lookahead;
+
+    uint8_t unicode          : 1; // Was the file opened as unicode?
+    uint8_t utf8translations : 1; // Buffer contains translations other than CRLF
+    uint8_t dbcsBufferUsed   : 1; // Is the dbcsBuffer in use?
+    char    mbBuffer[MB_LEN_MAX]; // Buffer for the lead byte of DBCS when converting from DBCS to Unicode
+                                  // Or for the first up to 3 bytes of a UTF-8 character
+};
+
+// The log-base-2 of the number of elements in each array of lowio file objects
+#define IOINFO_L2E          6
+
+// The number of elements in each array of lowio file objects
+#define IOINFO_ARRAY_ELTS   (1 << IOINFO_L2E)
+
+// The hard maximum number of arrays of lowio file objects that may be allocated
+#define IOINFO_ARRAYS       128
+
+// The maximum number of lowio file objects that may be allocated at any one time
+#define _NHANDLE_           (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS)
+
+
+
+#define STDIO_HANDLES_COUNT       3
+/*
+ * Access macros for getting at an __crt_lowio_handle_data struct and its fields from a
+ * file handle
+ */
+#define _pioinfo(i)          (__pioinfo[(i) >> IOINFO_L2E] + ((i) & (IOINFO_ARRAY_ELTS - 1)))
+#define _osfhnd(i)           (_pioinfo(i)->osfhnd)
+#define _osfile(i)           (_pioinfo(i)->osfile)
+#define _pipe_lookahead(i)   (_pioinfo(i)->_pipe_lookahead)
+#define _textmode(i)         (_pioinfo(i)->textmode)
+#define _tm_unicode(i)       (_pioinfo(i)->unicode)
+#define _startpos(i)         (_pioinfo(i)->startpos)
+#define _utf8translations(i) (_pioinfo(i)->utf8translations)
+#define _mbBuffer(i)         (_pioinfo(i)->mbBuffer)
+#define _dbcsBuffer(i)       (_pioinfo(i)->mbBuffer[0])
+#define _dbcsBufferUsed(i)   (_pioinfo(i)->dbcsBufferUsed)
+
+/*
+ * Safer versions of the above macros. Currently, only _osfile_safe is
+ * used.
+ */
+#define _pioinfo_safe(i)    ((((i) != -1) && ((i) != -2)) ? _pioinfo(i) : &__badioinfo)
+#define _osfile_safe(i)     (_pioinfo_safe(i)->osfile)
+#define _textmode_safe(i)   (_pioinfo_safe(i)->textmode)
+#define _tm_unicode_safe(i) (_pioinfo_safe(i)->unicode)
+
+typedef __crt_lowio_handle_data* __crt_lowio_handle_data_array[IOINFO_ARRAYS];
+
+// Special, static lowio file object used only for more graceful handling
+// of a C file handle value of -1 (results from common errors at the stdio
+// level).
+extern __crt_lowio_handle_data __badioinfo;
+
+// The umask value
+extern int _umaskval;
+
+// Global array of pointers to the arrays of lowio file objects.
+extern __crt_lowio_handle_data_array __pioinfo;
+
+// The number of handles for which file objects have been allocated.  This
+// number is such that for any fh in [0, _nhandle), _pioinfo(fh) is well-
+// formed.
+extern int _nhandle;
+
+
+
+int __cdecl _alloc_osfhnd(void);
+int __cdecl _free_osfhnd(int);
+int __cdecl __acrt_lowio_set_os_handle(int, intptr_t);
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal lowio functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+_Success_(return == 0)
+errno_t __cdecl _sopen_nolock(
+    _Out_  int*        _UnlockFlag,
+    _Out_  int*        _FileHandle,
+    _In_z_ char const* _FileName,
+    _In_   int         _OpenFlag,
+    _In_   int         _ShareFlag,
+    _In_   int         _PermissionFlag,
+    _In_   int         _SecureFlag
+    );
+
+_Success_(return == 0)
+errno_t __cdecl _wsopen_nolock(
+    _Out_  int*           _UnlockFlag,
+    _Out_  int*           _FileHandle,
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _OpenFlag,
+    _In_   int            _ShareFlag,
+    _In_   int            _PermissionFlag,
+    _In_   int            _SecureFlag
+    );
+
+
+_Check_return_
+__crt_lowio_handle_data* __cdecl __acrt_lowio_create_handle_array();
+
+void __cdecl __acrt_lowio_destroy_handle_array(
+    _Pre_maybenull_ _Post_invalid_ _In_reads_opt_(IOINFO_ARRAY_ELTS) __crt_lowio_handle_data* _Array
+    );
+
+_Check_return_opt_
+errno_t __cdecl __acrt_lowio_ensure_fh_exists(
+    _In_ int _FileHandle
+    );
+
+void __cdecl __acrt_lowio_lock_fh  (_In_ int _FileHandle);
+void __cdecl __acrt_lowio_unlock_fh(_In_ int _FileHandle);
+
+extern "C++"
+{
+    template <typename Action>
+    auto __acrt_lowio_lock_fh_and_call(int const fh, Action&& action) throw()
+        -> decltype(action())
+    {
+        return __crt_seh_guarded_call<decltype(action())>()(
+            [fh]() { __acrt_lowio_lock_fh(fh); },
+            action,
+            [fh]() { __acrt_lowio_unlock_fh(fh); });
+    }
+}
+
+// console_invalid_handle indicates that CONOUT$ or CONIN$ could not be created
+// console_uninitialized_handle indicates that the handle has not yet been initialized
+const HANDLE _console_invalid_handle = reinterpret_cast<HANDLE>(-1);
+const HANDLE _console_uninitialized_handle = reinterpret_cast<HANDLE>(-2);
+
+BOOL __cdecl __dcrt_lowio_ensure_console_input_initialized(void);
+
+BOOL __cdecl __dcrt_read_console_input(
+    _Out_ PINPUT_RECORD lpBuffer,
+    _In_  DWORD         nLength,
+    _Out_ LPDWORD       lpNumberOfEventsRead
+    );
+
+BOOL __cdecl __dcrt_read_console(
+    _Out_ LPVOID  lpBuffer,
+    _In_  DWORD   nNumberOfCharsToRead,
+    _Out_ LPDWORD lpNumberOfCharsRead
+    );
+
+BOOL __cdecl __dcrt_get_number_of_console_input_events(
+    _Out_ LPDWORD lpcNumberOfEvents
+    );
+
+BOOL __cdecl __dcrt_peek_console_input_a(
+    _Out_ PINPUT_RECORD lpBuffer,
+    _In_  DWORD         nLength,
+    _Out_ LPDWORD       lpNumberOfEventsRead
+    );
+
+BOOL __cdecl __dcrt_get_input_console_mode(
+    _Out_ LPDWORD lpMode
+    );
+
+BOOL __cdecl __dcrt_set_input_console_mode(
+    _In_ DWORD dwMode
+    );
+
+BOOL __cdecl __dcrt_lowio_ensure_console_output_initialized(void);
+
+BOOL __cdecl __dcrt_write_console(
+    _In_  void const * lpBuffer,
+    _In_  DWORD        nNumberOfCharsToWrite,
+    _Out_ LPDWORD      lpNumberOfCharsWritten
+    );
+
+_Check_return_ int __cdecl _chsize_nolock(_In_ int _FileHandle,_In_ __int64 _Size);
+_Check_return_opt_ int __cdecl _close_nolock(_In_ int _FileHandle);
+_Check_return_opt_ long __cdecl _lseek_nolock(_In_ int _FileHandle, _In_ long _Offset, _In_ int _Origin);
+_Check_return_ int __cdecl _setmode_nolock(_In_ int _FileHandle, _In_ int _Mode);
+_Check_return_ _Success_(return >= 0 && return <= _MaxCharCount) int __cdecl _read_nolock(_In_ int _FileHandle, _Out_writes_bytes_(_MaxCharCount) void * _DstBuf, _In_ unsigned int _MaxCharCount);
+_Check_return_ int __cdecl _write_nolock(_In_ int _FileHandle, _In_reads_bytes_(_MaxCharCount) const void * _Buf, _In_ unsigned int _MaxCharCount, __crt_cached_ptd_host& _Ptd);
+_Check_return_opt_ __int64 __cdecl _lseeki64_nolock(_In_ int _FileHandle, _In_ __int64 _Offset, _In_ int _Origin);
+
+// Temporary until non-PTD propagating versions can be replaced:
+_Check_return_ int __cdecl _chsize_nolock_internal(_In_ int _FileHandle, _In_ __int64 _Size, _Inout_ __crt_cached_ptd_host& _Ptd);
+_Check_return_opt_ __int64 __cdecl _lseeki64_nolock_internal(_In_ int _FileHandle, _In_ __int64 _Offset, _In_ int _Origin, _Inout_ __crt_cached_ptd_host& _Ptd);
+_Check_return_opt_ int __cdecl _close_nolock_internal(_In_ int _FileHandle, _Inout_ __crt_cached_ptd_host& _Ptd);
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal stdio functions with PTD propagation
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+_Check_return_opt_
+int __cdecl _close_internal(
+    _In_    int                    _FileHandle,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+_Check_return_opt_
+long __cdecl _lseek_internal(
+    _In_    int                    _FileHandle,
+    _In_    long                   _Offset,
+    _In_    int                    _Origin,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+_Check_return_opt_
+__int64 __cdecl _lseeki64_internal(
+    _In_    int                    _FileHandle,
+    _In_    __int64                _Offset,
+    _In_    int                    _Origin,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+int __cdecl _write_internal(
+    _In_                            int                    _FileHandle,
+    _In_reads_bytes_(_MaxCharCount) void const*            _Buf,
+    _In_                            unsigned int           _MaxCharCount,
+    _Inout_                         __crt_cached_ptd_host& _Ptd
+    );
+
+// fileno for stdout, stdin & stderr when there is no console
+#define _NO_CONSOLE_FILENO ((intptr_t)-2)
+
+
+_CRT_END_C_HEADER
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_mbstring.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_mbstring.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e08828b87ff41654a902693fd8c5a8a0026c08e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_mbstring.h	
@@ -0,0 +1,153 @@
+//
+// corecrt_internal_mbstring.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This internal header defines internal utilities for working with the multibyte
+// character and string library.
+//
+#pragma once
+
+#include <corecrt_internal.h>
+#include <mbctype.h>
+#include <mbstring.h>
+#include <uchar.h>
+
+_CRT_BEGIN_C_HEADER
+
+
+
+ // Multibyte full-width-latin upper/lower info
+#define NUM_ULINFO 6
+
+/* internal use macros since tolower/toupper are locale-dependent */
+#define _mbbisupper(_c) ((_mbctype.value()[(_c) + 1] & _SBUP) == _SBUP)
+#define _mbbislower(_c) ((_mbctype.value()[(_c) + 1] & _SBLOW) == _SBLOW)
+
+#define _mbbtolower(_c) (_mbbisupper(_c) ? _mbcasemap.value()[_c] : _c)
+#define _mbbtoupper(_c) (_mbbislower(_c) ? _mbcasemap.value()[_c] : _c)
+
+#define _ismbbtruelead_l(_lb,_ch,p)   (!(_lb) && _ismbblead_l((_ch), p))
+#define _mbbisupper_l(_c, p)      ((p->mbcinfo->mbctype[(_c) + 1] & _SBUP) == _SBUP)
+#define _mbbislower_l(_c, p)      ((p->mbcinfo->mbctype[(_c) + 1] & _SBLOW) == _SBLOW)
+#define _mbbtolower_l(_c, p)      (_mbbisupper_l(_c, p) ? p->mbcinfo->mbcasemap[_c] : _c)
+#define _mbbtoupper_l(_c, p)      (_mbbislower_l(_c, p) ? p->mbcinfo->mbcasemap[_c] : _c)
+
+/* define full-width-latin upper/lower ranges */
+
+#define _MBUPPERLOW1_MT(p)  p->mbcinfo->mbulinfo[0]
+#define _MBUPPERHIGH1_MT(p) p->mbcinfo->mbulinfo[1]
+#define _MBCASEDIFF1_MT(p)  p->mbcinfo->mbulinfo[2]
+
+#define _MBUPPERLOW2_MT(p)  p->mbcinfo->mbulinfo[3]
+#define _MBUPPERHIGH2_MT(p) p->mbcinfo->mbulinfo[4]
+#define _MBCASEDIFF2_MT(p)  p->mbcinfo->mbulinfo[5]
+
+// Kanji-specific ranges
+#define _MBHIRALOW      0x829f  // Hiragana
+#define _MBHIRAHIGH     0x82f1
+
+#define _MBKATALOW      0x8340  // Katakana
+#define _MBKATAHIGH     0x8396
+#define _MBKATAEXCEPT   0x837f  // Exception
+
+#define _MBKIGOULOW     0x8141  // Kanji punctuation
+#define _MBKIGOUHIGH    0x81ac
+#define _MBKIGOUEXCEPT  0x817f  // Exception
+
+// Macros used in the implementation of the classification functions.
+// These accesses of _locale_pctype are internal and guarded by bounds checks when used.
+#define _ismbbalnum_l(_c, pt)  ((((pt)->locinfo->_public._locale_pctype)[_c] & \
+                                (_ALPHA|_DIGIT)) || \
+                                (((pt)->mbcinfo->mbctype+1)[_c] & _MS))
+#define _ismbbalpha_l(_c, pt)  ((((pt)->locinfo->_public._locale_pctype)[_c] & \
+                            (_ALPHA)) || \
+                            (((pt)->mbcinfo->mbctype+1)[_c] & _MS))
+#define _ismbbgraph_l(_c, pt)  ((((pt)->locinfo->_public._locale_pctype)[_c] & \
+                            (_PUNCT|_ALPHA|_DIGIT)) || \
+                            (((pt)->mbcinfo->mbctype+1)[_c] & (_MS|_MP)))
+#define _ismbbprint_l(_c, pt)  ((((pt)->locinfo->_public._locale_pctype)[_c] & \
+                            (_BLANK|_PUNCT|_ALPHA|_DIGIT)) || \
+                            (((pt)->mbcinfo->mbctype + 1)[_c] & (_MS|_MP)))
+#define _ismbbpunct_l(_c, pt)  ((((pt)->locinfo->_public._locale_pctype)[_c] & _PUNCT) || \
+                                (((pt)->mbcinfo->mbctype+1)[_c] & _MP))
+#define _ismbbblank_l(_c, pt)  (((_c) == '\t') ? _BLANK : (((pt)->locinfo->_public._locale_pctype)[_c] & _BLANK) || \
+                               (((pt)->mbcinfo->mbctype+1)[_c] & _MP))
+// Note that these are intended for double byte character sets (DBCS) and so UTF-8 doesn't consider either to be true for any bytes
+// (for UTF-8 we never set _M1 or _M2 in this array)
+#define _ismbblead_l(_c, p)   ((p->mbcinfo->mbctype + 1)[_c] & _M1)
+#define _ismbbtrail_l(_c, p)  ((p->mbcinfo->mbctype + 1)[_c] & _M2)
+
+
+
+#ifdef __cplusplus
+extern "C" inline int __cdecl __dcrt_multibyte_check_type(
+    unsigned int   const c,
+    _locale_t      const locale,
+    unsigned short const category_bits,
+    bool           const expected
+    )
+{
+    // Return false if we are not in a supported multibyte codepage:
+    if (!locale->mbcinfo->ismbcodepage)
+        return FALSE;
+
+    int const code_page = locale->mbcinfo->mbcodepage;
+
+    char const bytes[] = { static_cast<char>((c >> 8) & 0xff), static_cast<char>(c & 0xff) };
+
+    // The 'c' "character" could be two one-byte multibyte characters, so we
+    // need room in the type array to handle this.  If 'c' is two one-byte
+    // multibyte characters, the second element in the type array will be
+    // nonzero.
+    unsigned short ctypes[2] = { };
+
+    if (__acrt_GetStringTypeA(locale, CT_CTYPE1, bytes, _countof(bytes), ctypes, code_page, TRUE) == 0)
+        return FALSE;
+
+    // Ensure 'c' is a single multibyte character:
+    if (ctypes[1] != 0)
+        return FALSE;
+
+    // Test the category:
+    return static_cast<bool>((ctypes[0] & category_bits) != 0) == expected ? TRUE : FALSE;
+}
+#endif
+
+_Check_return_wat_
+extern "C" errno_t __cdecl _wctomb_internal(
+    _Out_opt_                        int*                  _SizeConverted,
+    _Out_writes_opt_z_(_SizeInBytes) char*                 _MbCh,
+    _In_                             size_t                _SizeInBytes,
+    _In_                             wchar_t               _WCh,
+    _Inout_                         __crt_cached_ptd_host& _Ptd
+    );
+
+_Success_(return != -1)
+extern "C" int __cdecl _mbtowc_internal(
+    _Pre_notnull_ _Post_z_               wchar_t*               _DstCh,
+    _In_reads_or_z_opt_(_SrcSizeInBytes) char const*            _SrcCh,
+    _In_                                 size_t                 _SrcSizeInBytes,
+    _Inout_                              __crt_cached_ptd_host& _Ptd
+    );
+
+_CRT_END_C_HEADER
+
+namespace __crt_mbstring
+{
+    int __cdecl __mblen_utf8(const char* s);
+    size_t __cdecl __c16rtomb_utf8(char* s, char16_t c16, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+    size_t __cdecl __c32rtomb_utf8(char* s, char32_t c32, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+    size_t __cdecl __mbrtoc16_utf8(char16_t* pc32, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+    size_t __cdecl __mbrtoc32_utf8(char32_t* pc32, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+
+    size_t __cdecl __mbrtowc_utf8(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+    size_t __cdecl __mbsrtowcs_utf8(wchar_t* dst, const char** src, size_t len, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+    size_t __cdecl __wcsrtombs_utf8(char* dst, const wchar_t** src, size_t len, mbstate_t* ps, __crt_cached_ptd_host& ptd);
+
+    constexpr size_t INVALID = static_cast<size_t>(-1);
+    constexpr size_t INCOMPLETE = static_cast<size_t>(-2);
+
+    size_t return_illegal_sequence(mbstate_t* ps, __crt_cached_ptd_host& ptd);
+    size_t reset_and_return(size_t retval, mbstate_t* ps);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_ptd_propagation.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_ptd_propagation.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cf213e0aeb8d8a86e5921740de1bf982c65b6af
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_ptd_propagation.h	
@@ -0,0 +1,569 @@
+//
+// corecrt_internal_ptd_propagation.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Consistently querying for per-thread data puts a significant overhead
+// on runtime of the UCRT. Instead of re-querying the PTD every time it is
+// needed, the goal going forward is to propagate the PTD, locale, global state index,
+// and errno information between function calls via an argument.
+// This header contains support for PTD propagation, disables common
+// macros that invoke errno, and provides internal-only functions that
+// propagate the per-thread data.
+
+#pragma once
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+_CRT_BEGIN_C_HEADER
+
+// To grab the PTD, we also must query the global state index. Both of the FlsGetValue calls must be protected
+// from modifying the Win32 error state, so must be guarded by GetLastError()/SetLastError().
+// This function is provided so that if we already know the global state index and already
+// have a Win32 error guard object, we can avoid doing it again for getting the PTD.
+__acrt_ptd* __cdecl __acrt_getptd_noexit_explicit(__crt_scoped_get_last_error_reset const&, size_t global_state_index);
+
+#ifdef __cplusplus
+extern "C++"
+{
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // PTD Data Host
+    //
+    // Upon public function entry, one of these objects should be instantiated in order
+    // to host all the per-thread data for the rest of the function call. If any per-thread
+    // data is required, it will be requested once for the full runtime of the function.
+    // Additionally, changes to errno and doserrno will be recorded here instead, so that
+    // the actual errno value will only be updated once, and will never be queried.
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+    class __crt_cached_ptd_host
+    {   // The goal of this class is to minimize the number of calls to FlsGetValue()/SetLastError().
+
+        // Each call into the UCRT can use this class to lazily get and update:
+        // * The __acrt_ptd:
+        //    * errno / doserrno
+        //    * locale / multibyte info
+        // * The global state index
+        // while calling GetFlsValue the minimum number of times.
+        //
+        // -- PTD and Global State Index --
+        // Upon the first request of the PTD, both of these are updated at once. The global state index
+        // is required for getting the correct PTD, and both need to be guarded with
+        // a __crt_scoped_get_last_error_reset to prevent affecting the Win32 error.
+        // If the global state index is requested prior to the PTD, only the global state index is updated.
+
+        // -- Locale and Multibyte Info --
+        // If given a valid _locale_t during construction, it is used for the locale data.
+        // If the locale has not yet been set by a call to setlocale(), the initial locale
+        // data for the C locale is used instead.
+        // Otherwise, we wait until get_locale() is first called before querying the PTD
+        // and locking the locale from any other changes until the destructor is called
+        // (i.e. when the UCRT function call is completed).
+
+        // -- errno and _doserrno --
+        // This can be accessed directly via get_raw_ptd()->_terrno / _tdoserrno, but
+        // checking errno results between internal function calls
+        // (for example, printf can call wctomb and then check errno)
+        // is a significant source of overhead.
+        // Instead, both errno and doserrno changes are recorded locally in this class
+        // and the values in the PTD are only updated once this class is destroyed and the
+        // UCRT function call is complete.
+        // This means that if you must check errno after calling another function, if errno
+        // is not set then no PTD access was required. Using this instead of accessing errno
+        // directly removed all PTD access in many printf scenarios.
+
+        // Do not pass this directly, use __crt_cached_ptd_host&.
+        // When the PTD is queried by a child function, the parent will also not need to re-query.
+    public:
+        enum class locale_status : unsigned char
+        {
+            uninitialized,
+            updated_on_construction,
+            updated_via_ptd
+        };
+
+        explicit __crt_cached_ptd_host(_locale_t const locale = nullptr) throw()
+            : _ptd(nullptr), _current_global_state_index_valid(false), _locale_status(locale_status::uninitialized)
+        {
+            if (locale)
+            {
+                _locale_pointers = *locale;
+                _locale_status   = locale_status::updated_on_construction;
+            }
+            else if (!__acrt_locale_changed())
+            {
+                _locale_pointers = __acrt_initial_locale_pointers;
+                _locale_status   = locale_status::updated_on_construction;
+            }
+        }
+
+        ~__crt_cached_ptd_host() throw()
+        {
+            if (_locale_status == locale_status::updated_via_ptd)
+            {
+                // We only locked the PTD from locale propagation if we are using
+                // the locale data from the PTD.
+                __acrt_enable_global_locale_sync(_ptd); // The PTD must be valid if locale was updated via the PTD.
+            }
+
+            if (_current_errno.valid())
+            {
+                get_raw_ptd()->_terrno = _current_errno.unsafe_value();
+            }
+
+            if (_current_doserrno.valid())
+            {
+                get_raw_ptd()->_tdoserrno = _current_doserrno.unsafe_value();
+            }
+        }
+
+        __crt_cached_ptd_host(__crt_cached_ptd_host const&) = delete;
+        __crt_cached_ptd_host& operator=(__crt_cached_ptd_host const&) = delete;
+
+        _locale_t get_locale() throw()
+        {
+            update_locale();
+            return &_locale_pointers;
+        }
+
+        size_t get_current_global_state_index() throw()
+        {
+            return check_synchronize_global_state_index();
+        }
+
+        __acrt_ptd * get_raw_ptd() throw()
+        {
+            return check_synchronize_per_thread_data();
+        }
+
+        __acrt_ptd * get_raw_ptd_noexit() throw()
+        {
+            return try_synchronize_per_thread_data();
+        }
+
+        template <typename T>
+        struct cached
+        {
+        public:
+            cached() throw()
+                : _valid(false)
+            {}
+
+            bool valid() const throw()
+            {
+                return _valid;
+            }
+
+            T set(T new_value) throw()
+            {
+                _valid = true;
+                _value = new_value;
+                return new_value;
+            }
+
+            T value_or(T const alternative) const throw()
+            {
+                if (_valid)
+                {
+                    return _value;
+                }
+                return alternative;
+            }
+
+            bool check(T const value) const throw()
+            {
+                return _valid && _value == value;
+            }
+
+            class guard
+            {
+            public:
+                explicit guard(cached& parent) throw()
+                : _parent(parent), _copy(parent), _enabled(true)
+                {
+                }
+
+                ~guard() throw()
+                {
+                    if (_enabled)
+                    {
+                        _parent = _copy;
+                    }
+                }
+
+                guard(guard const&) = delete;
+                guard& operator=(guard const&) = delete;
+
+                void disable() throw()
+                {
+                    _enabled = false;
+                }
+
+                void enable() throw()
+                {
+                    _enabled = true;
+                }
+
+            private:
+                cached& _parent;
+                cached  _copy;
+                bool    _enabled;
+            };
+
+            guard create_guard() throw()
+            {
+                return guard(*this);
+            }
+
+            T unsafe_value() throw()
+            {
+                // Must check status beforehand.
+                return _value;
+            }
+
+        private:
+            cached(cached const&) = default;
+            cached(cached&&)      = default;
+
+            cached& operator=(cached const&) = default;
+            cached& operator=(cached&&)      = default;
+
+            T    _value;
+            bool _valid;
+        };
+
+        auto& get_errno() throw()
+        {
+            return _current_errno;
+        }
+
+        auto& get_doserrno() throw()
+        {
+            return _current_doserrno;
+        }
+
+    private:
+        __forceinline void update_locale() throw()
+        {   // Avoid costs for function call if locale doesn't need to be updated.
+            if (_locale_status == locale_status::uninitialized)
+            {
+                update_locale_slow();
+            }
+        }
+
+        void update_locale_slow() throw()
+        {
+            __acrt_ptd * const ptd_ptr = get_raw_ptd();
+
+            _locale_pointers.locinfo = ptd_ptr->_locale_info;
+            _locale_pointers.mbcinfo = ptd_ptr->_multibyte_info;
+
+            // _get_raw_ptd() will update _current_global_state_index
+            __acrt_update_locale_info_explicit(
+                ptd_ptr, &_locale_pointers.locinfo, _current_global_state_index
+                );
+
+            __acrt_update_multibyte_info_explicit(
+                ptd_ptr, &_locale_pointers.mbcinfo, _current_global_state_index
+                );
+
+            if ((ptd_ptr->_own_locale & _PER_THREAD_LOCALE_BIT) == 0)
+            {
+                // Skip re-synchronization with the global locale to prevent the
+                // locale from changing half-way through the call.
+                __acrt_disable_global_locale_sync(ptd_ptr);
+                _locale_status = locale_status::updated_via_ptd;
+            }
+        }
+
+        __forceinline __acrt_ptd * check_synchronize_per_thread_data() throw()
+        {
+            if (_ptd == nullptr)
+            {
+                if (force_synchronize_per_thread_data() == nullptr)
+                {
+                    abort();
+                }
+            }
+            return _ptd;
+        }
+
+        __forceinline __acrt_ptd * try_synchronize_per_thread_data() throw()
+        {
+            if (_ptd == nullptr)
+            {
+                return force_synchronize_per_thread_data();
+            }
+
+            return _ptd;
+        }
+
+        __acrt_ptd * force_synchronize_per_thread_data() throw()
+        {   // This function should be called at most once per UCRT function call.
+            // Update all per-thread variables to minimize number of GetLastError() calls.
+            __crt_scoped_get_last_error_reset const last_error_reset;
+
+            return _ptd = __acrt_getptd_noexit_explicit(
+                last_error_reset,
+                check_synchronize_global_state_index(last_error_reset)
+                );
+        }
+
+        size_t check_synchronize_global_state_index() throw()
+        {
+            if (!_current_global_state_index_valid)
+            {
+                __crt_scoped_get_last_error_reset const last_error_reset;
+                return force_synchronize_global_state_index(last_error_reset);
+            }
+
+            return _current_global_state_index;
+        }
+
+        size_t check_synchronize_global_state_index(__crt_scoped_get_last_error_reset const& last_error_reset) throw()
+        {
+            if (!_current_global_state_index_valid)
+            {
+                return force_synchronize_global_state_index(last_error_reset);
+            }
+
+            return _current_global_state_index;
+        }
+
+        size_t force_synchronize_global_state_index(__crt_scoped_get_last_error_reset const& last_error_reset) throw()
+        {
+            _current_global_state_index       = __crt_state_management::get_current_state_index(last_error_reset);
+            _current_global_state_index_valid = true;
+
+            return _current_global_state_index;
+        }
+
+        __acrt_ptd *                   _ptd;
+
+        size_t                         _current_global_state_index;
+        bool                           _current_global_state_index_valid;
+
+        __crt_locale_pointers          _locale_pointers;
+        locale_status                  _locale_status;
+
+        cached<errno_t>       _current_errno;
+        cached<unsigned long> _current_doserrno;
+    };
+
+
+    namespace __crt_state_management
+    {
+        // If we have already grabbed the PTD, then we also grabbed the current global state index
+        // and can use the global state index cached inside the __crt_cached_ptd_host.
+
+        template <typename T>
+        T& dual_state_global<T>::value(__crt_cached_ptd_host& ptd) throw()
+        {
+            return _value[ptd.get_current_global_state_index()];
+        }
+
+        template <typename T>
+        T const& dual_state_global<T>::value(__crt_cached_ptd_host& ptd) const throw()
+        {
+            return _value[ptd.get_current_global_state_index()];
+        }
+    }
+} // extern "C++"
+#endif // __cplusplus
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Validation Macros / Errno update functions
+//
+// All the UCRT _VALIDATE_* macros will set errno directly on error.
+// These new validation macros use __crt_cached_ptd_host& instead to prevent overhead.
+//
+// If this header is included, then the old validation/errno macros are #undef-ed to
+// to prevent accidental calling of errno.
+//
+// _ALLOW_OLD_VALIDATE_MACROS is provided as an escape hatch for files that need to include
+// this header, but still have code paths that require the old validate macros.
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+#ifndef _ALLOW_OLD_VALIDATE_MACROS
+    // Use this to allow the validate macros without PTD propagation in a source file.
+    #undef _INVALID_PARAMETER
+
+    #undef _VALIDATE_CLEAR_OSSERR_RETURN
+    #undef _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE
+    #undef _VALIDATE_RETURN
+    #undef _VALIDATE_RETURN_ERRCODE
+    #undef _VALIDATE_RETURN_ERRCODE_NOEXC
+    #undef _VALIDATE_RETURN_NOERRNO
+    #undef _VALIDATE_RETURN_NOEXC
+    #undef _VALIDATE_RETURN_VOID
+
+    #undef _ERRCHECK_SPRINTF
+    #undef _VALIDATE_STREAM_ANSI_RETURN
+    #undef _CHECK_FH_RETURN
+    #undef _CHECK_FH_CLEAR_OSSERR_RETURN
+    #undef _CHECK_FH_CLEAR_OSSERR_RETURN_ERRCODE
+    #undef _VALIDATE_CLEAR_OSSERR_RETURN
+
+    #undef errno
+    #undef _doserrno
+
+#endif // _ALLOW_OLD_VALIDATE_MACROS
+
+// Validate macros whose counterparts are from internal_shared.h
+
+#ifdef _DEBUG
+    #define _UCRT_INVALID_PARAMETER(ptd, expr) _invalid_parameter_internal(expr, __FUNCTIONW__, __FILEW__, __LINE__, 0, ptd)
+#else // _DEBUG
+    #define _UCRT_INVALID_PARAMETER(ptd, expr) _invalid_parameter_internal(nullptr, nullptr, nullptr, 0, 0, ptd)
+#endif // _DEBUG
+
+#define _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, expr, errorcode, retexpr)      \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            (ptd).get_doserrno().set(0L);                                     \
+            (ptd).get_errno().set((errorcode));                               \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, expr, errorcode)       \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            (ptd).get_doserrno().set(0L);                                     \
+            (ptd).get_errno().set((errorcode));                               \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return (errorcode);                                                \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_RETURN(ptd, expr, errorcode, retexpr)                   \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            (ptd).get_errno().set((errorcode));                               \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_RETURN_ERRCODE(ptd, expr, errorcode)                    \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            (ptd).get_errno().set((errorcode));                               \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return (errorcode);                                                \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_RETURN_ERRCODE_NOEXC(ptd, expr, errorcode)              \
+    {                                                                          \
+        if (!(expr))                                                           \
+        {                                                                      \
+            return (ptd).get_errno().set((errorcode));                        \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_RETURN_NOERRNO(ptd, expr, retexpr)                      \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_RETURN_NOEXC(ptd, expr, errorcode, retexpr)             \
+    {                                                                          \
+        if (!(expr))                                                           \
+        {                                                                      \
+            (ptd).get_errno().set((errorcode));                               \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_RETURN_VOID(ptd, expr, errorcode)                       \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            (ptd).get_errno().set((errorcode));                               \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return;                                                            \
+        }                                                                      \
+    }
+
+// Validate macros whose counterparts are from corecrt_internal.h
+
+#define _UCRT_VALIDATE_STREAM_ANSI_RETURN(ptd, stream, errorcode, retexpr)     \
+    {                                                                          \
+        __crt_stdio_stream const _Stream((stream));                            \
+        int fn;                                                                \
+        _UCRT_VALIDATE_RETURN((ptd), (                                         \
+            (_Stream.is_string_backed()) ||                                    \
+            (fn = _fileno(_Stream.public_stream()),                            \
+                ((_textmode_safe(fn) == __crt_lowio_text_mode::ansi) &&        \
+                !_tm_unicode_safe(fn)))),                                      \
+            (errorcode), (retexpr))                                            \
+    }
+
+#define _UCRT_CHECK_FH_RETURN(ptd, handle, errorcode, retexpr)                 \
+    {                                                                          \
+        if ((handle) == _NO_CONSOLE_FILENO)                                    \
+        {                                                                      \
+            (ptd).get_errno().set((errorcode));                               \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, handle, errorcode, retexpr)    \
+    {                                                                          \
+        if ((handle) == _NO_CONSOLE_FILENO)                                    \
+        {                                                                      \
+            (ptd).get_doserrno().set(0L);                                     \
+            (ptd).get_errno().set((errorcode));                               \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN_ERRCODE(ptd, handle, retexpr)       \
+    {                                                                          \
+        if ((handle) == _NO_CONSOLE_FILENO)                                    \
+        {                                                                      \
+            (ptd).get_doserrno().set(0L);                                     \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, expr, errorcode, retexpr)      \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            (ptd).get_doserrno().set(0L);                                     \
+            (ptd).get_errno().set((errorcode));                               \
+            _UCRT_INVALID_PARAMETER((ptd), _CRT_WIDE(#expr));                  \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+_CRT_END_C_HEADER
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_securecrt.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_securecrt.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e6665420b6c3c4bc9c189a6770ff12ed0661671
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_securecrt.h	
@@ -0,0 +1,130 @@
+/***
+*corecrt_internal_securecrt.h - contains declarations of internal routines and variables for securecrt
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Declares routines and variables used internally in the SecureCRT implementation.
+*       In this include file we define the macros needed to implement the secure functions
+*       inlined in the *.inl files like tcscpy_s.inl, etc.
+*
+*       [Internal]
+*
+****/
+
+#pragma once
+
+#ifndef _INC_INTERNAL_SECURECRT
+#define _INC_INTERNAL_SECURECRT
+
+#include <corecrt_internal.h>
+#include <errno.h>
+
+/* string resetting */
+#define _FILL_STRING _SECURECRT__FILL_STRING
+
+#define _FILL_BYTE _SECURECRT__FILL_BYTE
+
+#define _RESET_STRING(_String, _Size) \
+    *(_String) = 0; \
+    _FILL_STRING((_String), (_Size), 1);
+
+/* validations */
+#define _VALIDATE_STRING_ERROR(_String, _Size, _Ret) \
+    _VALIDATE_RETURN((_String) != NULL && (_Size) > 0, EINVAL, (_Ret))
+
+#define _VALIDATE_STRING(_String, _Size) \
+    _VALIDATE_STRING_ERROR((_String), (_Size), EINVAL)
+
+#define _VALIDATE_POINTER_ERROR_RETURN(_Pointer, _ErrorCode, _Ret) \
+    _VALIDATE_RETURN((_Pointer) != NULL, (_ErrorCode), (_Ret))
+
+#define _VALIDATE_POINTER_ERROR(_Pointer, _Ret) \
+    _VALIDATE_POINTER_ERROR_RETURN((_Pointer), EINVAL, (_Ret))
+
+#define _VALIDATE_POINTER(_Pointer) \
+    _VALIDATE_POINTER_ERROR((_Pointer), EINVAL)
+
+#define _VALIDATE_CONDITION_ERROR_RETURN(_Condition, _ErrorCode, _Ret) \
+    _VALIDATE_RETURN((_Condition), (_ErrorCode), (_Ret))
+
+#define _VALIDATE_CONDITION_ERROR(_Condition, _Ret) \
+    _VALIDATE_CONDITION_ERROR_RETURN((_Condition), EINVAL, (_Ret))
+
+#define _VALIDATE_POINTER_RESET_STRING_ERROR(_Pointer, _String, _Size, _Ret) \
+    if ((_Pointer) == NULL) \
+    { \
+        _RESET_STRING((_String), (_Size)); \
+        _VALIDATE_POINTER_ERROR_RETURN((_Pointer), EINVAL, (_Ret)) \
+    }
+
+#define _VALIDATE_POINTER_RESET_STRING(_Pointer, _String, _Size) \
+    _VALIDATE_POINTER_RESET_STRING_ERROR((_Pointer), (_String), (_Size), EINVAL)
+
+#define _RETURN_BUFFER_TOO_SMALL_ERROR(_String, _Size, _Ret) \
+    _VALIDATE_RETURN((L"Buffer is too small" && 0), ERANGE, _Ret)
+
+#define _RETURN_BUFFER_TOO_SMALL(_String, _Size) \
+    _RETURN_BUFFER_TOO_SMALL_ERROR((_String), (_Size), ERANGE)
+
+#define _RETURN_DEST_NOT_NULL_TERMINATED(_String, _Size) \
+    _VALIDATE_RETURN((L"String is not null terminated" && 0), EINVAL, EINVAL)
+
+#define _RETURN_EINVAL \
+    _VALIDATE_RETURN((L"Invalid parameter", 0), EINVAL, EINVAL)
+
+#define _RETURN_ERROR(_Msg, _Ret) \
+    _VALIDATE_RETURN(((_Msg), 0), EINVAL, _Ret)
+
+/* returns without calling _invalid_parameter */
+#define _RETURN_NO_ERROR \
+    return 0
+
+/* Note that _RETURN_TRUNCATE does not set errno */
+#define _RETURN_TRUNCATE \
+    return STRUNCATE
+
+#define _SET_MBCS_ERROR \
+    (errno = EILSEQ)
+
+#define _RETURN_MBCS_ERROR \
+    return _SET_MBCS_ERROR
+
+/* locale dependent */
+#define _LOCALE_ARG \
+    _LocInfo
+
+#define _LOCALE_ARG_DECL \
+    _locale_t _LOCALE_ARG
+
+#define _LOCALE_UPDATE \
+    _LocaleUpdate _LocUpdate(_LOCALE_ARG)
+
+#define _ISMBBLEAD(_Character) \
+    _ismbblead_l((_Character), _LocUpdate.GetLocaleT())
+
+#define _ISMBBLEADPREFIX(_Result, _StringStart, _BytePtr)               \
+    {                                                                   \
+        unsigned char *_Tmp_VAR, *_StringStart_VAR, *_BytePtr_VAR;      \
+                                                                        \
+        _StringStart_VAR = (_StringStart);                              \
+        _BytePtr_VAR = (_BytePtr);                                      \
+        _Tmp_VAR = _BytePtr_VAR;                                        \
+        while ((_Tmp_VAR >= _StringStart_VAR) && _ISMBBLEAD(*_Tmp_VAR)) \
+        {                                                               \
+            _Tmp_VAR--;                                                 \
+        }                                                               \
+        (_Result) = ((_BytePtr_VAR - _Tmp_VAR) & 1) != 0;               \
+    }
+
+#define _LOCALE_SHORTCUT_TEST \
+    _LocUpdate.GetLocaleT()->mbcinfo->ismbcodepage == 0
+
+/* misc */
+#define _ASSIGN_IF_NOT_NULL(_Pointer, _Value) \
+    if ((_Pointer) != NULL) \
+    { \
+        *(_Pointer) = (_Value); \
+    }
+
+#endif  /* _INC_INTERNAL_SECURECRT */
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_simd.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_simd.h
new file mode 100644
index 0000000000000000000000000000000000000000..f78a118aed45119c1d4ad8bdad76a53c7bd84e3a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_simd.h	
@@ -0,0 +1,157 @@
+//
+// corecrt_internal_simd.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines internal SIMD utilities.  This header may only
+// be included in C++ translation units.
+//
+#pragma once
+
+#include <intrin.h>
+#include <isa_availability.h>
+#include <stdint.h>
+
+#if (defined _M_IX86 || defined _M_X64) && !defined(_M_HYBRID_X86_ARM64) && !defined(_M_ARM64EC)
+    #define _CRT_SIMD_SUPPORT_AVAILABLE
+#endif
+
+#if defined _CRT_SIMD_SUPPORT_AVAILABLE
+
+    extern "C" int __isa_available;
+
+    enum class __crt_simd_isa
+    {
+        sse2,
+        avx2
+    };
+
+    template <__crt_simd_isa Isa>
+    struct __crt_simd_cleanup_guard;
+
+    template <__crt_simd_isa Isa>
+    struct __crt_simd_pack_traits;
+
+    template <__crt_simd_isa Isa, typename Element>
+    struct __crt_simd_traits;
+
+
+
+    template <__crt_simd_isa Isa, typename Element>
+    struct __crt_simd_element_traits
+        : __crt_simd_pack_traits<Isa>
+    {
+        using element_type = Element;
+
+        enum : size_t
+        {
+            element_size      = sizeof(element_type),
+            elements_per_pack = pack_size / element_size
+        };
+    };
+
+
+
+    template <>
+    struct __crt_simd_cleanup_guard<__crt_simd_isa::sse2>
+    {
+        // No cleanup required for SSE2 usage, however we still need to define
+        // the no-op destructor in order to avoid unreferened local variable
+        // warnings when this cleanup guard is used.
+        ~__crt_simd_cleanup_guard() throw()
+        {
+        }
+    };
+
+    template <>
+    struct __crt_simd_pack_traits<__crt_simd_isa::sse2>
+    {
+        using pack_type = __m128i;
+
+        enum : size_t { pack_size = sizeof(pack_type) };
+
+        static __forceinline pack_type get_zero_pack() throw()
+        {
+            return _mm_setzero_si128();
+        }
+
+        static __forceinline int compute_byte_mask(pack_type const x) throw()
+        {
+            return _mm_movemask_epi8(x);
+        }
+    };
+
+    template <>
+    struct __crt_simd_traits<__crt_simd_isa::sse2, uint8_t>
+        : __crt_simd_element_traits<__crt_simd_isa::sse2, uint8_t>
+    {
+        static __forceinline pack_type compare_equals(pack_type const x, pack_type const y) throw()
+        {
+            return _mm_cmpeq_epi8(x, y);
+        }
+    };
+
+    template <>
+    struct __crt_simd_traits<__crt_simd_isa::sse2, uint16_t>
+        : __crt_simd_element_traits<__crt_simd_isa::sse2, uint16_t>
+    {
+        static __forceinline pack_type compare_equals(pack_type const x, pack_type const y) throw()
+        {
+            return _mm_cmpeq_epi16(x, y);
+        }
+    };
+
+
+
+    template <>
+    struct __crt_simd_cleanup_guard<__crt_simd_isa::avx2>
+    {
+        ~__crt_simd_cleanup_guard()
+        {
+            // After executing AVX2 instructions, we must zero the upper halves
+            // of the YMM registers before returning.  See the Intel article
+            // "Intel AVX State Transitions: Migrating SSE Code to AVX" for
+            // further details.
+            _mm256_zeroupper();
+        }
+    };
+
+    template <>
+    struct __crt_simd_pack_traits<__crt_simd_isa::avx2>
+    {
+        using pack_type = __m256i;
+
+        enum : size_t { pack_size = sizeof(pack_type) };
+
+        static __forceinline pack_type get_zero_pack() throw()
+        {
+            return _mm256_setzero_si256();
+        }
+
+        static __forceinline int compute_byte_mask(pack_type const x) throw()
+        {
+            return _mm256_movemask_epi8(x);
+        }
+    };
+
+    template <>
+    struct __crt_simd_traits<__crt_simd_isa::avx2, uint8_t>
+        : __crt_simd_element_traits<__crt_simd_isa::avx2, uint8_t>
+    {
+        static __forceinline pack_type compare_equals(pack_type const x, pack_type const y) throw()
+        {
+            return _mm256_cmpeq_epi8(x, y);
+        }
+    };
+
+    template <>
+    struct __crt_simd_traits<__crt_simd_isa::avx2, uint16_t>
+        : __crt_simd_element_traits<__crt_simd_isa::avx2, uint16_t>
+    {
+        static __forceinline pack_type compare_equals(pack_type const x, pack_type const y) throw()
+        {
+            return _mm256_cmpeq_epi16(x, y);
+        }
+    };
+
+#endif // _CRT_SIMD_SUPPORT_AVAILABLE
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec4dca04443c5fcce0ee3e0c54522c9c2d03fa58
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio.h	
@@ -0,0 +1,864 @@
+//
+// corecrt_internal_stdio.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines internal utilities for working with the stdio
+// library.
+//
+#pragma once
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_traits.h>
+#include <io.h>
+#include <mbstring.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#pragma pack(push, _CRT_PACKING)
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Stream State Flags
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+enum : long
+{
+    // Mode bits:  These bits control the stream mode.  A stream may be in one
+    // of three modes:  read mode, write mode, or update (read/write) mode.  At
+    // least one of these bits will be set for any open stream.
+    //
+    // If the stream is open in read mode or write mode, then only the _IOREAD
+    // or _IOWRITE bit will be set.
+    //
+    // If the stream is open in update (read/write) mode, then the _IOUPDATE bit
+    // will be set.  Further state must also be tracked for update mode streams.
+    // Read and write operations cannot be mixed willy-nilly:  in most cases, a
+    // flush or reposition must take place in order to transition between reading
+    // and writing.  So, for update mode streams, if the next operation must be
+    // a read, the _IOREAD bit is set, and if the next operation must be a write,
+    // the _IOWRITE bit is set.
+    _IOREAD           = 0x0001,
+    _IOWRITE          = 0x0002,
+    _IOUPDATE         = 0x0004,
+
+    // Stream state bits:  These bits track the state of the stream.  The _IOEOF
+    // and _IOERROR flags track the end-of-file and error states, respectively,
+    // which are reported by feof() and ferror().  The _IOCTRLZ flag is when the
+    // last read ended because a Ctrl+Z was read; it corresponds to the lowio
+    // FEOFLAG state.
+    _IOEOF            = 0x0008,
+    _IOERROR          = 0x0010,
+    _IOCTRLZ          = 0x0020,
+
+    // Buffering state bits:  These track the buffering mode of the stream:
+    //
+    // (*) CRT:      The buffer was allocated by the CRT via the usual mechanism
+    //               (typically via __acrt_stdio_allocate_buffer_nolock, and of
+    //               size _INTERNAL_BUFSIZ).
+    //
+    // (*) USER:     The buffer was allocated by the user and was configured via
+    //               the setvbuf() function.
+    //
+    // (*) SETVBUF:  The buffer was set via the setvbuf() function.  This flag
+    //               may be combined with either the CRT or USER flag, depending
+    //               on who owns the buffer (based on how setvbuf() was called).
+    //
+    // (*) STBUF:    The buffer was set via a call to the
+    //               __acrt_stdio_begin_temporary_buffering_nolock() function,
+    //               which provides a temporary buffer for console I/O operations
+    //               to improve the performance of bulk read or write operations.
+    //
+    // (*) NONE:     Buffering is disabled, either because it was explicitly
+    //               disabled or because the CRT attempted to allocate a buffer
+    //               but allocation failed.  When this flag is set, the internal
+    //               two-byte character buffer is used.
+    //
+    // Note that these flags are related to, but distinct from, the public stdio
+    // buffering flags that are used with setvbuf (_IOFBF, _IOLBF, and _IONBF).
+    // Specifically, note that those flags are never or'ed into the flags for a
+    // stream.
+    _IOBUFFER_CRT     = 0x0040,
+    _IOBUFFER_USER    = 0x0080,
+    _IOBUFFER_SETVBUF = 0x0100,
+    _IOBUFFER_STBUF   = 0x0200,
+    _IOBUFFER_NONE    = 0x0400,
+
+    // Commit-on-flush state bit:  When this flag is set, every flush operation
+    // on the stream also commits the file to disk.
+    _IOCOMMIT         = 0x0800,
+
+    // String state bit:  When this flag is set, it indicates that the stream is
+    // backed by a string, not a file.  String-backed streams are not exposed to
+    // user code; they are created internally to support formatted I/O to string
+    // buffers (e.g. the sprintf and sscanf families of functions).  If a stream
+    // is backed by a string, its lock is not initialized and no synchronization
+    // is required.
+    _IOSTRING         = 0x1000,
+
+    // Allocation state bit:  When this flag is set it indicates that the stream
+    // is currently allocated and in-use.  If this flag is not set, it indicates
+    // that the stream is free and available for use.
+    _IOALLOCATED      = 0x2000,
+};
+
+
+
+#ifndef _M_CEE
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal stdio functions with PTD propagation
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+_Check_return_opt_
+extern "C" int __cdecl _putch_nolock_internal(
+    _In_    int                    _Ch,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+_Check_return_opt_
+extern "C" wint_t __cdecl _putwch_nolock_internal(
+    _In_    wchar_t                _Ch,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+_Check_return_opt_
+extern "C" wint_t __cdecl _fputwc_nolock_internal(
+    _In_    wchar_t                _Character,
+    _Inout_ FILE*                  _Stream,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+_Success_(return != EOF)
+_Check_return_opt_
+extern "C" int __cdecl _fputc_nolock_internal(
+    _In_    int                    _Character,
+    _Inout_ FILE*                  _Stream,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+_Check_return_opt_
+extern "C" size_t __cdecl _fwrite_nolock_internal(
+    _In_reads_bytes_(_ElementSize * _ElementCount) void const*            _Buffer,
+    _In_                                           size_t                 _ElementSize,
+    _In_                                           size_t                 _ElementCount,
+    _Inout_                                        FILE*                  _Stream,
+    _Inout_                                        __crt_cached_ptd_host& _Ptd
+    );
+
+_Check_return_
+extern "C" __int64 __cdecl _ftelli64_nolock_internal(
+    _Inout_ FILE*                  _Stream,
+    _Inout_ __crt_cached_ptd_host& _Ptd
+    );
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal Stream Types (__crt_stdio_stream and friends)
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+struct __crt_stdio_stream_data
+{
+    union
+    {
+        FILE  _public_file;
+        char* _ptr;
+    };
+
+    char*            _base;
+    int              _cnt;
+    long             _flags;
+    long             _file;
+    int              _charbuf;
+    int              _bufsiz;
+    char*            _tmpfname;
+    CRITICAL_SECTION _lock;
+};
+
+// Ensure that __crt_stdio_stream_data* and FILE* pointers are freely convertible:
+static_assert(
+    offsetof(__crt_stdio_stream_data, _public_file) == 0,
+    "FILE member of __crt_stdio_stream_data is not at offset zero."
+    );
+
+static_assert(
+    sizeof(FILE) == sizeof(void*),
+    "FILE structure has unexpected size."
+    );
+
+
+class __crt_stdio_stream
+{
+public:
+
+    __crt_stdio_stream() throw()
+        : _stream(nullptr)
+    {
+    }
+
+    explicit __crt_stdio_stream(FILE* const stream) throw()
+        : _stream(reinterpret_cast<__crt_stdio_stream_data*>(stream))
+    {
+    }
+
+    explicit __crt_stdio_stream(__crt_stdio_stream_data* const stream) throw()
+        : _stream(stream)
+    {
+    }
+
+    bool  valid()         const throw() { return _stream != nullptr;     }
+    FILE* public_stream() const throw() { return &_stream->_public_file; }
+
+
+
+    // Tests whether this stream is allocated.  Returns true if the stream is
+    // currently in use; returns false if the stream is free for allocation.
+    bool is_in_use() const throw()
+    {
+        return (get_flags() & _IOALLOCATED) != 0;
+    }
+
+    // Attempts to allocate this stream for use.  Returns true if this stream was
+    // free and has been allocated for the caller.  Returns false if the stream
+    // was in-use and could not be allocated for the caller.  If it returns true,
+    // the caller gains ownership of the stream and is responsible for deallocating
+    // it.
+    bool try_allocate() throw()
+    {
+        return (_InterlockedOr(&_stream->_flags, _IOALLOCATED) & _IOALLOCATED) == 0;
+    }
+
+    // Deallocates the stream, freeing it for use by another client.  It is
+    // assumed that the caller owns the stream before calling this function.
+    void deallocate() throw()
+    {
+        // Note:  We clear all flags intentionally, so that the stream object
+        // is "clean" the next time it is allocated.
+        _InterlockedExchange(&_stream->_flags, 0);
+    }
+
+
+
+    void lock()   const throw() { _lock_file  (public_stream()); }
+    void unlock() const throw() { _unlock_file(public_stream()); }
+
+    bool has_any_of(long const flags) const throw() { return (get_flags() & flags) != 0;     }
+    bool has_all_of(long const flags) const throw() { return (get_flags() & flags) == flags; }
+
+    bool set_flags  (long const flags) const throw() { return (_InterlockedOr(&_stream->_flags,   flags) & flags) != 0; }
+    bool unset_flags(long const flags) const throw() { return (_InterlockedAnd(&_stream->_flags, ~flags) & flags) != 0; }
+
+    bool eof()    const throw() { return has_any_of(_IOEOF);   }
+    bool error()  const throw() { return has_any_of(_IOERROR); }
+    bool ctrl_z() const throw() { return has_any_of(_IOCTRLZ); }
+
+    bool has_crt_buffer()       const throw() { return has_any_of(_IOBUFFER_CRT);                                   }
+    bool has_user_buffer()      const throw() { return has_any_of(_IOBUFFER_USER);                                  }
+    bool has_temporary_buffer() const throw() { return has_any_of(_IOBUFFER_STBUF);                                 }
+    bool has_setvbuf_buffer()   const throw() { return has_any_of(_IOBUFFER_SETVBUF);                               }
+    bool has_big_buffer()       const throw() { return has_any_of(_IOBUFFER_CRT | _IOBUFFER_USER);                  }
+    bool has_any_buffer()       const throw() { return has_any_of(_IOBUFFER_CRT | _IOBUFFER_USER | _IOBUFFER_NONE); }
+
+
+
+    int lowio_handle() const throw() { return __crt_interlocked_read(&_stream->_file); }
+
+    bool is_string_backed() const throw() { return (get_flags() & _IOSTRING) != 0; }
+
+    __crt_stdio_stream_data* operator->() const throw() { return _stream; }
+
+    long get_flags() const throw()
+    {
+        return __crt_interlocked_read(&_stream->_flags);
+    }
+
+private:
+
+    __crt_stdio_stream_data* _stream;
+};
+
+// These cannot have C linkage because they use __crt_stdio_stream, which has
+// a destructor.
+__crt_stdio_stream __cdecl __acrt_stdio_allocate_stream() throw();
+void __cdecl __acrt_stdio_free_stream(__crt_stdio_stream _Stream) throw();
+
+
+
+template <typename Action>
+auto __acrt_lock_stream_and_call(FILE* const stream, Action&& action) throw()
+    -> decltype(action())
+{
+    return __crt_seh_guarded_call<decltype(action())>()(
+        [stream]() { _lock_file(stream); },
+        action,
+        [stream]() { _unlock_file(stream); });
+}
+
+
+
+/*
+ * Number of entries supported in the array pointed to by __piob[]. That is,
+ * the number of stdio-level files which may be open simultaneously. This
+ * is normally set to _NSTREAM_ by the stdio initialization code.
+ */
+extern "C" extern int _nstream;
+
+/*
+ * Pointer to the array of pointers to FILE structures that are used
+ * to manage stdio-level files.
+ */
+extern "C" extern __crt_stdio_stream_data** __piob;
+
+// __acrt_stdio_is_initialized cannot be with the rest of
+// stdio initialization logic since referencing those symbols
+// pulls in the stdio initializers.
+inline bool __acrt_stdio_is_initialized() {
+    return __piob != 0;
+}
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Deprecated stdio functionality
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" {
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    _Success_(return != 0) char*, __RETURN_POLICY_SAME, _ACRTIMP, gets,
+    _Pre_notnull_ _Post_z_ _Out_writes_z_(((size_t)-1)), char, _Buffer
+    )
+
+// string[0] must contain the maximum length of the string.  The number of
+// characters written is stored in string[1].  The return value is a pointer to
+// string[2] on success; nullptr on failure.
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(
+    _Success_(return != 0) char*, _DCRTIMP, _cgets,
+    _At_(_Buffer, _Pre_notnull_ _In_reads_(1))
+    _At_(_Buffer + 1, _Pre_notnull_ _Out_writes_(1))
+    _At_(_Buffer + 2, _Pre_notnull_ _Post_z_ _Out_writes_to_(_Buffer[0], _Buffer[1])),
+    char, _Buffer
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    _Success_(return != 0)
+    wchar_t*, __RETURN_POLICY_SAME, _ACRTIMP, _getws,
+    _Pre_notnull_ _Post_z_, wchar_t, _Buffer
+    )
+
+// string[0] must contain the maximum length of the string.  The number of
+// characters written is stored in string[1].  The return value is a pointer to
+// string[2] on success; nullptr on failure.
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(
+    _Post_satisfies_(return == 0 || return == _Buffer + 2)
+    _Success_(return != 0) wchar_t*, _DCRTIMP, _cgetws,
+    _At_(_Buffer, _In_reads_(1))
+    _At_(_Buffer + 1, _Out_writes_(1))
+    _At_(_Buffer + 2, _Post_z_ _Out_writes_to_(_Buffer[0], _Buffer[1])),
+    wchar_t, _Buffer
+    )
+
+} // extern "C"
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Internal stdio functionality
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" {
+
+
+_Check_return_
+FILE* __cdecl _openfile(
+    _In_z_ char const* file_name,
+    _In_z_ char const* mode,
+    _In_   int         share_flag,
+    _Out_  FILE*       stream
+    );
+
+_Check_return_
+FILE* __cdecl _wopenfile(
+    _In_z_ wchar_t const* file_name,
+    _In_z_ wchar_t const* mode,
+    _In_   int            share_flag,
+    _Out_  FILE*          stream
+    );
+
+_Check_return_
+int __cdecl __acrt_stdio_refill_and_read_narrow_nolock(
+    _Inout_ FILE* stream
+    );
+
+_Check_return_
+int __cdecl __acrt_stdio_refill_and_read_wide_nolock(
+    _Inout_ FILE* stream
+    );
+
+_Check_return_opt_
+int __cdecl __acrt_stdio_flush_and_write_narrow_nolock(
+    _In_    int                    c,
+    _Inout_ FILE*                  stream,
+    _Inout_ __crt_cached_ptd_host& ptd
+    );
+
+_Check_return_opt_
+int __cdecl __acrt_stdio_flush_and_write_wide_nolock(
+    _In_    int                    c,
+    _Inout_ FILE*                  stream,
+    _Inout_ __crt_cached_ptd_host& ptd
+    );
+
+void __cdecl __acrt_stdio_allocate_buffer_nolock(
+    _Out_ FILE* stream
+    );
+
+void __cdecl __acrt_stdio_free_buffer_nolock(
+    _Inout_ FILE* stream
+    );
+
+bool __cdecl __acrt_stdio_begin_temporary_buffering_nolock(
+    _Inout_ FILE* stream
+    );
+
+bool __cdecl __acrt_should_use_temporary_buffer(
+    _In_ FILE* stream
+);
+
+void __cdecl __acrt_stdio_end_temporary_buffering_nolock(
+    _In_    bool                 flag,
+    _Inout_ FILE*                  stream,
+    _Inout_ __crt_cached_ptd_host& ptd
+    );
+
+int  __cdecl __acrt_stdio_flush_nolock(
+    _Inout_ FILE*                  stream,
+    _Inout_ __crt_cached_ptd_host& ptd
+    );
+
+void __cdecl __acrt_stdio_free_tmpfile_name_buffers_nolock();
+
+#ifndef CRTDLL
+    extern int _cflush;
+#endif
+
+extern unsigned int _tempoff;
+extern unsigned int _old_pfxlen;
+
+} // extern "C"
+
+
+
+class __acrt_stdio_temporary_buffering_guard
+{
+public:
+
+    explicit __acrt_stdio_temporary_buffering_guard(FILE* const stream, __crt_cached_ptd_host& ptd) throw()
+        : _stream(stream), _ptd(ptd)
+    {
+        _flag = __acrt_stdio_begin_temporary_buffering_nolock(stream);
+    }
+
+    __acrt_stdio_temporary_buffering_guard(__acrt_stdio_temporary_buffering_guard const&) throw() = delete;
+    void operator=(__acrt_stdio_temporary_buffering_guard const&) throw() = delete;
+
+    ~__acrt_stdio_temporary_buffering_guard() throw()
+    {
+        __acrt_stdio_end_temporary_buffering_nolock(_flag, _stream, _ptd);
+    }
+
+private:
+    FILE*                  _stream;
+    __crt_cached_ptd_host& _ptd;
+    bool                   _flag;
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Character Traits
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename Character>
+struct __acrt_stdio_char_traits;
+
+template <>
+struct __acrt_stdio_char_traits<char> : __crt_char_traits<char>
+{
+    static int_type const eof = EOF;
+
+    static bool validate_stream_is_ansi_if_required(FILE* const stream) throw()
+    {
+        _VALIDATE_STREAM_ANSI_RETURN(stream, EINVAL, false);
+        return true;
+    }
+};
+
+template <>
+struct __acrt_stdio_char_traits<wchar_t> : __crt_char_traits<wchar_t>
+{
+    static int_type const eof = WEOF;
+
+    static bool validate_stream_is_ansi_if_required(FILE* const stream) throw()
+    {
+        UNREFERENCED_PARAMETER(stream);
+
+        return true; // This validation is only for ANSI functions.
+    }
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// fopen mode string parser
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Represents a {lowio, stdio} mode pair.  This is the result of parsing a
+// stdio mode string using the parser, defined below.
+struct __acrt_stdio_stream_mode
+{
+    int  _lowio_mode;
+    int  _stdio_mode;
+    bool _success;
+};
+
+
+
+// This function and the following functions support __acrt_stdio_parse_mode.
+// They handle individual parts of the parsing.
+inline bool __acrt_stdio_parse_mode_plus(__acrt_stdio_stream_mode& result, bool& seen_plus) throw()
+{
+    if (seen_plus) {
+        return false;
+    }
+
+    seen_plus = true;
+
+    if (result._lowio_mode & _O_RDWR) {
+        return false;
+    }
+
+    result._lowio_mode |= _O_RDWR;
+    result._lowio_mode &= ~(_O_RDONLY | _O_WRONLY);
+    result._stdio_mode |= _IOUPDATE;
+    result._stdio_mode &= ~(_IOREAD | _IOWRITE);
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_b(__acrt_stdio_stream_mode& result) throw()
+{
+    if (result._lowio_mode & (_O_TEXT | _O_BINARY)) {
+        return false;
+    }
+
+    result._lowio_mode |= _O_BINARY;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_t(__acrt_stdio_stream_mode& result) throw()
+{
+    if (result._lowio_mode & (_O_TEXT | _O_BINARY)) {
+        return false;
+    }
+
+    result._lowio_mode |= _O_TEXT;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_c(__acrt_stdio_stream_mode& result, bool& seen_commit_mode) throw()
+{
+    if (seen_commit_mode) {
+        return false;
+    }
+
+    seen_commit_mode = true;
+    result._stdio_mode |= _IOCOMMIT;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_n(__acrt_stdio_stream_mode& result, bool& seen_commit_mode) throw()
+{
+    if (seen_commit_mode) {
+        return false;
+    }
+
+    seen_commit_mode = true;
+    result._stdio_mode &= ~_IOCOMMIT;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_S(__acrt_stdio_stream_mode& result, bool& seen_scan_mode) throw()
+{
+    if (seen_scan_mode) {
+        return false;
+    }
+
+    seen_scan_mode = true;
+    result._lowio_mode |= _O_SEQUENTIAL;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_R(__acrt_stdio_stream_mode& result, bool& seen_scan_mode) throw()
+{
+    if (seen_scan_mode) {
+        return false;
+    }
+
+    seen_scan_mode = true;
+    result._lowio_mode |= _O_RANDOM;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_T(__acrt_stdio_stream_mode& result) throw()
+{
+    if (result._lowio_mode & _O_SHORT_LIVED) {
+        return false;
+    }
+
+    result._lowio_mode |= _O_SHORT_LIVED;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_D(__acrt_stdio_stream_mode& result) throw()
+{
+    if (result._lowio_mode & _O_TEMPORARY) {
+        return false;
+    }
+
+    result._lowio_mode |= _O_TEMPORARY;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_N(__acrt_stdio_stream_mode& result) throw()
+{
+    result._lowio_mode |= _O_NOINHERIT;
+    return true;
+}
+
+inline bool __acrt_stdio_parse_mode_x(__acrt_stdio_stream_mode& result) throw()
+{
+    if (!(result._lowio_mode & _O_TRUNC)) {
+        // 'x' only permitted with 'w'
+        return false;
+    }
+
+    result._lowio_mode |= _O_EXCL;
+    return true;
+}
+
+
+
+// Parses a stdio mode string, returning the corresponding pair of lowio and
+// stdio flags.  On success, sets the success flag in the result to true; on
+// failure, sets that flag to false.  All failures are logic errors.
+template <typename Character>
+__acrt_stdio_stream_mode __cdecl __acrt_stdio_parse_mode(
+    Character const* const mode
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    // Note that we value initialize the result, so the success flag is false
+    // by default.  This ensures that any premature return will return failure.
+    __acrt_stdio_stream_mode result = __acrt_stdio_stream_mode();
+    result._stdio_mode = _commode;
+
+    // Advance past any leading spaces:
+    Character const* it = mode;
+    while (*it == ' ')
+        ++it;
+
+    // Read the first character.  It must be one of 'r', 'w' , or 'a':
+    switch (*it)
+    {
+    case 'r':
+        result._lowio_mode = _O_RDONLY;
+        result._stdio_mode = _IOREAD;
+        break;
+
+    case 'w':
+        result._lowio_mode = _O_WRONLY | _O_CREAT | _O_TRUNC;
+        result._stdio_mode = _IOWRITE;
+        break;
+
+    case 'a':
+        result._lowio_mode = _O_WRONLY | _O_CREAT | _O_APPEND;
+        result._stdio_mode = _IOWRITE;
+        break;
+
+    default:
+        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
+    }
+
+    // Advance past the first character:
+    ++it;
+
+    // There can be up to seven more optional mode characters:
+    // [1] A single '+' character
+    // [2] One of 't' or 'b' (indicating text or binary, respectively)
+    // [3] One of 'c' or 'n' (enable or disable auto-commit to disk on flush)
+    // [4] One of 'S' or 'R' (optimize for sequential or random access)
+    // [5] 'T' (indicating the file is short-lived)
+    // [6] 'D' (indicating the file is temporary)
+    // [7] 'N' (indicating the file should not be inherited by child processes)
+    // [8] 'x' (indicating the file must be created and it is an error if it already exists)
+    bool seen_commit_mode   = false;
+    bool seen_plus          = false;
+    bool seen_scan_mode     = false;
+    bool seen_encoding_flag = false;
+    for (bool continue_loop = true; continue_loop && *it != '\0'; it += (continue_loop ? 1 : 0))
+    {
+        switch (*it)
+        {
+        case '+': continue_loop = __acrt_stdio_parse_mode_plus(result, seen_plus);        break;
+        case 'b': continue_loop = __acrt_stdio_parse_mode_b   (result);                   break;
+        case 't': continue_loop = __acrt_stdio_parse_mode_t   (result);                   break;
+        case 'c': continue_loop = __acrt_stdio_parse_mode_c   (result, seen_commit_mode); break;
+        case 'n': continue_loop = __acrt_stdio_parse_mode_n   (result, seen_commit_mode); break;
+        case 'S': continue_loop = __acrt_stdio_parse_mode_S   (result, seen_scan_mode  ); break;
+        case 'R': continue_loop = __acrt_stdio_parse_mode_R   (result, seen_scan_mode  ); break;
+        case 'T': continue_loop = __acrt_stdio_parse_mode_T   (result);                   break;
+        case 'D': continue_loop = __acrt_stdio_parse_mode_D   (result);                   break;
+        case 'N': continue_loop = __acrt_stdio_parse_mode_N   (result);                   break;
+        case 'x': continue_loop = __acrt_stdio_parse_mode_x   (result);                   break;
+
+        // If we encounter any spaces, skip them:
+        case ' ':
+            break;
+
+        // If we encounter a comma, it begins the encoding specification; we
+        // break out of the loop immediately and parse the encoding flag next:
+        case ',':
+            seen_encoding_flag = true;
+            continue_loop = false;
+            break;
+
+        default:
+            _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
+        }
+    }
+
+    // Advance past the comma that terminated the loop:
+    if (seen_encoding_flag)
+        ++it;
+
+    while (*it == ' ')
+        ++it;
+
+    // If we did not encounter the encoding introducer (a comma), make sure we
+    // actually reached the end of the mode string.  We are done:
+    if (!seen_encoding_flag)
+    {
+        _VALIDATE_RETURN(*it == '\0', EINVAL, result);
+        result._success = true;
+        return result;
+    }
+
+    // Otherwise, we saw the beginning of an encoding; parse it:
+    static Character const ccs[]              = { 'c', 'c', 's' };
+    static Character const utf8_encoding[]    = { 'U', 'T', 'F', '-', '8' };
+    static Character const utf16_encoding[]   = { 'U', 'T', 'F', '-', '1', '6', 'L', 'E' };
+    static Character const unicode_encoding[] = { 'U', 'N', 'I', 'C', 'O', 'D', 'E' };
+
+    // Make sure it begins with "ccs" (all lowercase)...
+    if (stdio_traits::tcsncmp(it, ccs, _countof(ccs)) != 0)
+        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
+
+    it += _countof(ccs); // Advance past the "ccs"
+
+    while (*it == ' ')
+        ++it;
+
+    if (*it != '=')
+        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
+
+    ++it; // Advance past the "="
+
+    while (*it == ' ')
+        ++it;
+
+    if (stdio_traits::tcsnicmp(it, utf8_encoding, _countof(utf8_encoding)) == 0)
+    {
+        it += _countof(utf8_encoding);
+        result._lowio_mode |= _O_U8TEXT;
+    }
+    else if (stdio_traits::tcsnicmp(it, utf16_encoding, _countof(utf16_encoding)) == 0)
+    {
+        it += _countof(utf16_encoding);
+        result._lowio_mode |= _O_U16TEXT;
+    }
+    else if (stdio_traits::tcsnicmp(it, unicode_encoding, _countof(unicode_encoding)) == 0)
+    {
+        it += _countof(unicode_encoding);
+        result._lowio_mode |= _O_WTEXT;
+    }
+    else
+    {
+        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
+    }
+
+    // Finally, skip any trailing spaces...
+    while (*it == ' ')
+        ++it;
+
+    // ...and ensure there are no characters left:
+    _VALIDATE_RETURN(*it == '\0', EINVAL, result);
+
+    result._success = true;
+    return result;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// __acrt_common_path_requires_backslash()
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+inline bool __cdecl __crt_stdio_path_requires_backslash(char const* const first) throw()
+{
+    char const* const last = first + strlen(first);
+    if (first == last)
+        return false;
+
+    if (*(last - 1) == '\\')
+    {
+        return reinterpret_cast<unsigned char const*>(last - 1)
+            != _mbsrchr(reinterpret_cast<unsigned char const*>(first), '\\');
+    }
+
+    if (*(last - 1) == '/')
+        return false;
+
+    return true;
+}
+
+inline bool __cdecl __crt_stdio_path_requires_backslash(wchar_t const* const first) throw()
+{
+    wchar_t const* const last = first + wcslen(first);
+    if (first == last)
+        return false;
+
+    if (*(last - 1) == L'\\')
+        return false;
+
+    if (*(last - 1) == L'/')
+        return false;
+
+    return true;
+}
+
+// Reset the file buffer to be empty and ready for reuse
+inline void __cdecl __acrt_stdio_reset_buffer(__crt_stdio_stream const stream) throw()
+{
+    stream->_ptr = stream->_base;
+    stream->_cnt = 0;
+}
+
+#endif // !_M_CEE
+
+#pragma pack(pop)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio_input.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio_input.h
new file mode 100644
index 0000000000000000000000000000000000000000..55df8f7607fa0476471005fd0e1decbc866bf16a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio_input.h	
@@ -0,0 +1,1613 @@
+//
+// corecrt_internal_stdio_input.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file defines the core implementation of the formatted output functions,
+// including scanf and its many variants (sscanf, fscanf, etc.).
+//
+#include <conio.h>
+#include <ctype.h>
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_strtox.h>
+#include <locale.h>
+#include <stdarg.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Input Adapters
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The actual read operations are different depending on whether the source is a
+// stream or the console.  We handle these differences via input adapters.  The
+// stream and console I/O functions pass an adapter to the core input function,
+// and that function calls various read members of the adapter to perform read
+// operations.
+namespace __crt_stdio_input {
+
+template <typename Character>
+class console_input_adapter
+{
+public:
+
+    using traits             = __acrt_stdio_char_traits<Character>;
+    using char_type          = Character;
+    using int_type           = typename traits::int_type;
+
+    console_input_adapter() throw()
+        : _characters_read{0}
+    {
+    }
+
+    bool validate() const throw()
+    {
+        return true;
+    }
+
+    int_type get() throw()
+    {
+        int_type const c{traits::gettche_nolock()};
+        if (c != traits::eof)
+            ++_characters_read;
+
+        return c;
+    }
+
+    void unget(int_type const c) throw()
+    {
+        if (c == traits::eof)
+            return;
+
+        --_characters_read;
+        traits::ungettch_nolock(c);
+    }
+
+    size_t characters_read() const throw()
+    {
+        return _characters_read;
+    }
+
+private:
+
+    size_t _characters_read;
+};
+
+template <typename Character>
+class stream_input_adapter
+{
+public:
+
+    using traits             = __acrt_stdio_char_traits<Character>;
+    using char_type          = Character;
+    using int_type           = typename traits::int_type;
+
+    stream_input_adapter(FILE* const public_stream) throw()
+        : _stream         {public_stream},
+          _characters_read{0            }
+    {
+    }
+
+    bool validate() const throw()
+    {
+        _VALIDATE_RETURN(_stream.valid(), EINVAL, false);
+
+        return traits::validate_stream_is_ansi_if_required(_stream.public_stream());
+    }
+
+    int_type get() throw()
+    {
+        int_type const c{traits::getc_nolock(_stream.public_stream())};
+        if (c != traits::eof)
+            ++_characters_read;
+
+        return c;
+    }
+
+    void unget(int_type const c) throw()
+    {
+        if (c == traits::eof)
+            return;
+
+        --_characters_read;
+        traits::ungettc_nolock(c, _stream.public_stream());
+    }
+
+    size_t characters_read() const throw()
+    {
+         return _characters_read;
+    }
+
+private:
+
+    __crt_stdio_stream _stream;
+    size_t             _characters_read;
+};
+
+template <typename Character>
+class string_input_adapter
+{
+public:
+
+    using traits             = __acrt_stdio_char_traits<Character>;
+    using char_type          = Character;
+    using unsigned_char_type = typename traits::unsigned_char_type;
+    using int_type           = typename traits::int_type;
+
+    string_input_adapter(
+        char_type const* const string,
+        size_t           const length
+        ) throw()
+        : _first{string}, _last{string + length}, _it{string}
+    {
+    }
+
+    bool validate() throw()
+    {
+        _VALIDATE_RETURN(_it != nullptr, EINVAL, false);
+        _VALIDATE_RETURN(_it <= _last,   EINVAL, false);
+        return true;
+    }
+
+    int_type get() throw()
+    {
+        if (_it == _last)
+            return traits::eof;
+
+        // If we are processing narrow characters, the character value may be
+        // negative.  In this case, its value will have been sign extended in
+        // the conversion to int_type.  Mask the sign extension bits for
+        // compatibility with the other input adapters:
+        return static_cast<unsigned_char_type>(*_it++);
+    }
+
+    void unget(int_type const c) throw()
+    {
+        if (_it == _first)
+            return;
+
+        if (_it == _last && c == traits::eof)
+            return;
+
+        --_it;
+    }
+
+    size_t characters_read() const throw()
+    {
+        return static_cast<size_t>(_it - _first);
+    }
+
+private:
+
+    char_type const* _first;
+    char_type const* _last;
+    char_type const* _it;
+};
+
+
+
+// Eats whitespace characters from an input adapter.  When it returns, the next
+// call to get() on the input adapter will be either a non-whitespace character
+// or will be EOF.
+template <template <typename> class InputAdapter, typename Character>
+typename __acrt_stdio_char_traits<Character>::int_type __cdecl skip_whitespace(
+    InputAdapter<Character>&       adapter,
+    _locale_t                const locale
+    )
+{
+    using traits             = __acrt_stdio_char_traits<Character>;
+    using char_type          = Character;
+    using unsigned_char_type = typename traits::unsigned_char_type;
+    using int_type           = typename traits::int_type;
+
+    int_type c;
+
+    do
+    {
+        c = adapter.get();
+
+        if (c == traits::eof)
+            break;
+    }
+    while (__crt_strtox::is_space(static_cast<char_type>(c), locale));
+
+    return c;
+}
+
+} // namespace __crt_stdio_input
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Scanset Buffer
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+namespace __crt_stdio_input {
+
+
+
+// The scanset buffer provides storage for a scanset (a set of characters to be
+// matched).  We need a bitfield with one bit per character, so for char we can
+// use a member buffer but for wchar_t we need to dynamically allocate a buffer
+// on first use to avoid excessive stack usage.
+template <size_t CharacterSize>
+class scanset_storage;
+
+template <>
+class scanset_storage<sizeof(char)>
+{
+public:
+
+    scanset_storage()
+        : _buffer{}
+    {
+    }
+
+    unsigned char* data() const throw() { return _buffer;     }
+    size_t         size() const throw() { return buffer_size; }
+
+private:
+
+    enum : size_t { buffer_size = (static_cast<size_t>(UCHAR_MAX) + 1) / CHAR_BIT };
+
+    mutable unsigned char _buffer[buffer_size];
+};
+
+template <>
+class scanset_storage<sizeof(wchar_t)>
+{
+public:
+
+    unsigned char* data() const throw()
+    {
+        if (!_buffer)
+            _buffer = _calloc_crt_t(unsigned char, buffer_size);
+
+        return _buffer.get();
+    }
+
+    size_t size() const throw()
+    {
+        return buffer_size;
+    }
+
+private:
+
+    enum : size_t { buffer_size = (static_cast<size_t>(WCHAR_MAX) + 1) / CHAR_BIT };
+
+    mutable __crt_unique_heap_ptr<unsigned char> _buffer;
+};
+
+template <typename UnsignedCharacter>
+class scanset_buffer
+{
+public:
+
+    bool is_usable() throw()
+    {
+        return _storage.data() != nullptr;
+    }
+
+    void set(UnsignedCharacter const c) throw()
+    {
+        _storage.data()[c / CHAR_BIT] |= 1 << (c % CHAR_BIT);
+    }
+
+    bool test(UnsignedCharacter const c) const throw()
+    {
+        return (_storage.data()[c / CHAR_BIT] & 1 << (c % CHAR_BIT)) != 0;
+    }
+
+    void reset() throw()
+    {
+        unsigned char* const first{_storage.data()};
+        if (!first)
+            return;
+
+        ::memset(first, 0, _storage.size());
+    }
+
+    void invert() throw()
+    {
+        unsigned char* const first{_storage.data()        };
+        unsigned char* const last {first + _storage.size()};
+
+        for (unsigned char* it{first}; it != last; ++it)
+        {
+            *it ^= static_cast<unsigned char>(-1);
+        }
+    }
+
+private:
+
+    scanset_storage<sizeof(UnsignedCharacter)> _storage;
+};
+
+} // namespace __crt_stdio_input
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Format String Parser
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+namespace __crt_stdio_input {
+
+enum class format_directive_kind
+{
+    unknown_error,
+    end_of_string,
+    whitespace,
+    literal_character,
+    conversion_specifier
+};
+
+enum class length_modifier
+{
+    none,
+    hh,
+    h,
+    l,
+    ll,
+    j,
+    z,
+    t,
+    L,
+    I32,
+    I64,
+    T,
+    enumerator_count
+};
+
+inline size_t __cdecl to_integer_length(length_modifier const length) throw()
+{
+    switch (length)
+    {
+    case length_modifier::none: return sizeof(int      );
+    case length_modifier::hh:   return sizeof(char     );
+    case length_modifier::h:    return sizeof(short    );
+    case length_modifier::l:    return sizeof(long     );
+    case length_modifier::ll:   return sizeof(long long);
+    case length_modifier::j:    return sizeof(intmax_t );
+    case length_modifier::z:    return sizeof(size_t   );
+    case length_modifier::t:    return sizeof(ptrdiff_t);
+    case length_modifier::I32:  return sizeof(int32_t  );
+    case length_modifier::I64:  return sizeof(int64_t  );
+
+    default:
+        _ASSERTE(("Unexpected length specifier", false));
+        return 0;
+    }
+}
+
+inline size_t __cdecl to_floating_point_length(length_modifier const length) throw()
+{
+    switch (length)
+    {
+    case length_modifier::none: return sizeof(float      );
+    case length_modifier::l:    return sizeof(double     );
+    case length_modifier::L:    return sizeof(long double);
+
+    default:
+        _ASSERTE(("Unexpected length specifier", false));
+        return 0;
+    }
+}
+
+enum class conversion_mode
+{
+    character,
+    string,
+
+    signed_unknown,
+    signed_decimal,
+    unsigned_octal,
+    unsigned_decimal,
+    unsigned_hexadecimal,
+
+    floating_point,
+
+    scanset,
+
+    report_character_count,
+
+    enumerator_count
+};
+
+inline bool __cdecl is_length_valid(conversion_mode const mode, length_modifier const length) throw()
+{
+    static unsigned char const constraints
+        [static_cast<size_t>(conversion_mode::enumerator_count)]
+        [static_cast<size_t>(length_modifier::enumerator_count)]
+    {
+                                     /* none hh   h    l    ll   j    z    t    L    I32  I64  T */
+        /* character              */ {  1  , 0  , 1  , 1  , 1  , 0  , 0  , 0  , 1  , 0  , 0  , 1  },
+        /* string                 */ {  1  , 0  , 1  , 1  , 1  , 0  , 0  , 0  , 1  , 0  , 0  , 1  },
+        /* signed decimal         */ {  1  , 1  , 1  , 1  , 1  , 1  , 1  , 1  , 0  , 1  , 1  , 0  },
+        /* signed unknown         */ {  1  , 1  , 1  , 1  , 1  , 1  , 1  , 1  , 0  , 1  , 1  , 0  },
+        /* unsigned octal         */ {  1  , 1  , 1  , 1  , 1  , 1  , 1  , 1  , 0  , 1  , 1  , 0  },
+        /* unsigned decimal       */ {  1  , 1  , 1  , 1  , 1  , 1  , 1  , 1  , 0  , 1  , 1  , 0  },
+        /* unsigned hexadecimal   */ {  1  , 1  , 1  , 1  , 1  , 1  , 1  , 1  , 0  , 1  , 1  , 0  },
+        /* floating point         */ {  1  , 0  , 0  , 1  , 0  , 0  , 0  , 0  , 1  , 0  , 0  , 0  },
+        /* scanset                */ {  1  , 0  , 0  , 1  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 1  },
+        /* report character count */ {  1  , 1  , 1  , 1  , 1  , 1  , 1  , 1  , 0  , 1  , 1  , 0  }
+    };
+
+    return constraints[static_cast<size_t>(mode)][static_cast<size_t>(length)] != 0;
+}
+
+template <size_t N> struct uintn_t_impl;
+template <> struct uintn_t_impl<4> { typedef uint32_t type; };
+template <> struct uintn_t_impl<8> { typedef uint64_t type; };
+
+template <size_t N>
+using uintn_t = typename uintn_t_impl<N>::type;
+
+template <typename Character>
+class format_string_parser
+{
+public:
+
+    using traits             = __acrt_stdio_char_traits<Character>;
+    using char_type          = Character;
+    using unsigned_char_type = typename traits::unsigned_char_type;
+    using int_type           = typename traits::int_type;
+
+    format_string_parser(
+        _In_   uint64_t                  const options,
+        _In_z_ unsigned_char_type const* const format_it
+        ) throw()
+        : _options   {options  },
+          _format_it {format_it},
+          _error_code{0        }
+    {
+        reset_token_state();
+    }
+
+    bool validate() const throw()
+    {
+        _VALIDATE_RETURN(_format_it != nullptr, EINVAL, false);
+        return true;
+    }
+
+    bool advance() throw()
+    {
+        if (_error_code != 0)
+        {
+            return false;
+        }
+
+        reset_token_state();
+
+        if (*_format_it == '\0')
+        {
+            _kind = format_directive_kind::end_of_string;
+            return false;
+        }
+
+        if (traits::istspace(*_format_it))
+        {
+            _kind = format_directive_kind::whitespace;
+
+            while (traits::istspace(*_format_it))
+                ++_format_it;
+
+            return true;
+        }
+
+        if (_format_it[0] != '%' || _format_it[1] == '%')
+        {
+            _kind = format_directive_kind::literal_character;
+            _literal_character_lead = *_format_it;
+            _format_it += _format_it[0] != '%' ? 1 : 2;
+
+            return scan_optional_literal_character_trail_bytes_tchar(char_type());
+        }
+
+        _kind = format_directive_kind::conversion_specifier;
+        ++_format_it; // Advance past the %
+
+        scan_optional_assignment_suppressor();
+
+        if (!scan_optional_field_width())
+        {
+            return false;
+        }
+
+        scan_optional_length_modifier();
+        scan_optional_wide_modifier();
+
+        if (!scan_conversion_specifier())
+        {
+            return false;
+        }
+
+        if (!is_length_valid(_mode, _length))
+        {
+            reset_token_state_for_error(EINVAL);
+            return false;
+        }
+
+        return true;
+    }
+
+    errno_t error_code() const throw()
+    {
+        return _error_code;
+    }
+
+    format_directive_kind kind() const throw()
+    {
+        return _kind;
+    }
+
+    unsigned_char_type literal_character_lead() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::literal_character);
+        return _literal_character_lead;
+    }
+
+    unsigned_char_type literal_character_trail() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::literal_character);
+        return _literal_character_trail;
+    }
+
+    bool suppress_assignment() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::conversion_specifier);
+        return _suppress_assignment;
+    }
+
+    uint64_t width() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::conversion_specifier);
+        return _width;
+    }
+
+    size_t length() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::conversion_specifier);
+        switch (_mode)
+        {
+        case conversion_mode::character:
+        case conversion_mode::string:
+        case conversion_mode::scanset:
+            return _is_wide ? sizeof(wchar_t) : sizeof(char);
+
+        case conversion_mode::signed_unknown:
+        case conversion_mode::signed_decimal:
+        case conversion_mode::unsigned_octal:
+        case conversion_mode::unsigned_decimal:
+        case conversion_mode::unsigned_hexadecimal:
+        case conversion_mode::report_character_count:
+            return to_integer_length(_length);
+
+        case conversion_mode::floating_point:
+            return to_floating_point_length(_length);
+        }
+
+        return 0; // Unreachable
+    }
+
+    conversion_mode mode() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::conversion_specifier);
+        return _mode;
+    }
+
+    scanset_buffer<unsigned_char_type> const& scanset() const throw()
+    {
+        _ASSERTE(_kind == format_directive_kind::conversion_specifier && _mode == conversion_mode::scanset);
+        return _scanset;
+    }
+
+private:
+
+    bool scan_optional_literal_character_trail_bytes_tchar(char) throw()
+    {
+        if (isleadbyte(_literal_character_lead) == 0)
+        {
+            return true;
+        }
+
+        // If we need a trail byte and we're at the end of the format string,
+        // the format string is malformed:
+        if (*_format_it == '\0')
+        {
+            reset_token_state_for_error(EILSEQ);
+            return false;
+        }
+
+        _literal_character_trail = *_format_it;
+        ++_format_it;
+        return true;
+    }
+
+    bool scan_optional_literal_character_trail_bytes_tchar(wchar_t) throw()
+    {
+        return true; // There are no trail bytes for wide character strings
+    }
+
+    void scan_optional_assignment_suppressor() throw()
+    {
+        if (*_format_it != '*')
+            return;
+
+        _suppress_assignment = true;
+        ++_format_it;
+        return;
+    }
+
+    bool scan_optional_field_width() throw()
+    {
+        if (__crt_strtox::parse_digit(static_cast<char_type>(*_format_it)) > 9)
+            return true;
+
+        unsigned_char_type* width_end{};
+        uint64_t const width{traits::tcstoull(
+            reinterpret_cast<char_type const*>(_format_it),
+            reinterpret_cast<char_type**>(&width_end),
+            10)};
+
+        if (width == 0 || width_end == _format_it)
+        {
+            reset_token_state_for_error(EINVAL);
+            return false;
+        }
+
+        _width     = width;
+        _format_it = width_end;
+        return true;
+    }
+
+    void scan_optional_length_modifier() throw()
+    {
+        switch (*_format_it)
+        {
+        case 'h':
+        {
+            if (_format_it[1] == 'h')
+            {
+                _format_it += 2; // Advance past "hh"
+                _length = length_modifier::hh;
+            }
+            else
+            {
+                _format_it += 1; // Advance past "h"
+                _length = length_modifier::h;
+            }
+
+            return;
+        }
+
+        case 'I':
+        {
+            // The I32, I64, and I length modifiers are Microsoft extensions.
+
+            if (_format_it[1] == '3' && _format_it[2] == '2')
+            {
+                _format_it += 3; // Advance past "I32"
+                _length = length_modifier::I32;
+                return;
+            }
+
+            if (_format_it[1] == '6' && _format_it[2] == '4')
+            {
+                _format_it += 3; // Advance past "I64"
+                _length = length_modifier::I64;
+                return;
+            }
+
+            // Some disambiguation is required for the standalone I length
+            // modifier.  If the I is followed by a d, i, o, x, or X character,
+            // then we treat it as I32 on 32-bit platforms and I64 on 64-bit
+            // platforms.  Otherwise, we do not treat it as a length modifier
+            // and instead treat it as a conversion specifier (equivalent to the
+            // lowercase i).
+            if (_format_it[1] == 'd' ||
+                _format_it[1] == 'i' ||
+                _format_it[1] == 'o' ||
+                _format_it[1] == 'u' ||
+                _format_it[1] == 'x' ||
+                _format_it[1] == 'X')
+            {
+                ++_format_it; // Advance past "I"
+                _length = sizeof(void*) == 4
+                    ? length_modifier::I32
+                    : length_modifier::I64;
+                return;
+            }
+
+            return;
+        }
+
+        case 'l':
+        {
+            if (_format_it[1] == 'l')
+            {
+                _format_it += 2; // Advance past "ll"
+                _length = length_modifier::ll;
+            }
+            else
+            {
+                _format_it += 1; // Advance past "l"
+                _length = length_modifier::l;
+            }
+
+            return;
+        }
+
+        case 'L':
+        {
+            ++_format_it; // Advance past "L"
+            _length = length_modifier::L;
+            return;
+        }
+
+        case 'j':
+        {
+            ++_format_it; // Advance past "j"
+            _length = length_modifier::j;
+            return;
+        }
+
+        case 't':
+        {
+            ++_format_it; // Advance past "t"
+            _length = length_modifier::t;
+            return;
+        }
+
+        case 'z':
+        {
+            ++_format_it; // Advance past "z"
+            _length = length_modifier::z;
+            return;
+        }
+
+        case 'T':
+        {
+            ++_format_it; // Advance past "T"
+            _length = length_modifier::T;
+            return;
+        }
+        }
+    }
+
+    void scan_optional_wide_modifier() throw()
+    {
+        if (*_format_it == 'w')
+        {
+            ++_format_it; // Advance past "w"
+            _is_wide = true;
+            return;
+        }
+
+        if (should_default_to_wide(*_format_it))
+        {
+            _is_wide = true;
+            return;
+        }
+    }
+
+    bool should_default_to_wide(unsigned char const c) throw()
+    {
+        return c == 'C' || c == 'S';
+    }
+
+    bool should_default_to_wide(wchar_t const c) throw()
+    {
+        if (c == 'C' || c == 'S')
+            return false;
+
+        if (_length == length_modifier::T)
+            return true;
+
+        return (_options & _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS) != 0;
+    }
+
+    void set_wide_for_c_s_or_scanset() throw()
+    {
+        if (_length == length_modifier::h)
+            _is_wide = false;
+
+        if (_length == length_modifier::l  ||
+            _length == length_modifier::ll ||
+            _length == length_modifier::L)
+            _is_wide = true;
+    }
+
+    bool scan_conversion_specifier() throw()
+    {
+        switch (*_format_it)
+        {
+        case 'C':
+        case 'c':
+        {
+            // If no width was specified, use a default width of one character:
+            if (_width == 0)
+                _width = 1;
+
+            set_wide_for_c_s_or_scanset();
+
+            _mode = conversion_mode::character;
+            ++_format_it;
+            return true;
+        }
+
+        case 'S':
+        case 's':
+        {
+            set_wide_for_c_s_or_scanset();
+
+            _mode = conversion_mode::string;
+            ++_format_it;
+            return true;
+        }
+
+        case 'i':
+        case 'I':
+        {
+            _mode = conversion_mode::signed_unknown;
+            ++_format_it;
+            return true;
+        }
+
+        case 'd':
+        {
+            _mode = conversion_mode::signed_decimal;
+            ++_format_it;
+            return true;
+        }
+
+        case 'u':
+        {
+            _mode = conversion_mode::unsigned_decimal;
+            ++_format_it;
+            return true;
+        }
+
+        case 'X':
+        case 'x':
+        {
+            _mode = conversion_mode::unsigned_hexadecimal;
+            ++_format_it;
+            return true;
+        }
+
+        case 'p':
+        {
+            _length = sizeof(void*) == 4
+                ? length_modifier::I32
+                : length_modifier::I64;
+            _mode = conversion_mode::unsigned_hexadecimal;
+            ++_format_it;
+            return true;
+        }
+
+        case 'o':
+        {
+            _mode = conversion_mode::unsigned_octal;
+            ++_format_it;
+            return true;
+        }
+
+        case 'A':
+        case 'a':
+        case 'E':
+        case 'e':
+        case 'F':
+        case 'f':
+        case 'G':
+        case 'g':
+        {
+            _mode = conversion_mode::floating_point;
+            ++_format_it;
+            return true;
+        }
+
+        case '[':
+        {
+            set_wide_for_c_s_or_scanset();
+
+            _mode = conversion_mode::scanset;
+            ++_format_it;
+            return scan_scanset_range();
+        }
+
+        case 'n':
+        {
+            _mode = conversion_mode::report_character_count;
+            ++_format_it;
+            return true;
+        }
+
+        default:
+        {
+            reset_token_state_for_error(EINVAL);
+            return false;
+        }
+        }
+    }
+
+    bool scan_scanset_range() throw()
+    {
+        if (!_scanset.is_usable())
+        {
+            reset_token_state_for_error(ENOMEM);
+            return false;
+        }
+
+        _scanset.reset();
+
+        bool const is_reject_set{*_format_it == '^'};
+        if (is_reject_set)
+        {
+            ++_format_it;
+        }
+
+        if (*_format_it == ']')
+        {
+            ++_format_it;
+            _scanset.set(static_cast<unsigned_char_type>(']'));
+        }
+
+        unsigned_char_type const* const first{_format_it};
+        unsigned_char_type const* last_range_end = nullptr;
+        for (; *_format_it != ']' && *_format_it != '\0'; ++_format_it)
+        {
+            // If the current character is not a hyphen, if its the end of a range,
+            // or if it's the first or last character in the scanset, treat it as a
+            // literal character and just add it to the table:
+            if (*_format_it != '-' || _format_it - 1 == last_range_end || _format_it == first || _format_it[1] == ']')
+            {
+                _scanset.set(*_format_it);
+            }
+            // Otherwise, we're pointing to a hyphen that falls between two other
+            // characters, so this is a range to be matched (e.g. [a-z]).  Toggle
+            // the bits for each character in the range:
+            else
+            {
+                unsigned_char_type lower_bound{_format_it[-1]};
+                unsigned_char_type upper_bound{_format_it[ 1]};
+                last_range_end = _format_it + 1;
+
+                // We support ranges in both directions ([a-z] and [z-a]).  We
+                // can handle both simultaneously by transforming [z-a] into [a-z]:
+                if (lower_bound > upper_bound)
+                {
+                    unsigned_char_type const c{lower_bound};
+                    lower_bound = upper_bound;
+                    upper_bound = c;
+                }
+
+                // Convert [lower_bound, upper_bound] into [lower_bound, upper_bound):
+                ++upper_bound;
+
+                for (unsigned_char_type c{lower_bound}; c != upper_bound; ++c)
+                {
+                    _scanset.set(c);
+                }
+            }
+        }
+
+        if (*_format_it == '\0')
+        {
+            reset_token_state_for_error(EINVAL);
+            return false;
+        }
+
+        if (is_reject_set)
+        {
+            _scanset.invert();
+        }
+
+        ++_format_it; // Advance past ']'
+        return true;
+    }
+
+    void reset_token_state() throw()
+    {
+        // Note that we never reset the error code; in theory, we should never
+        // be trying to use the parser at all once an error is encountered.
+        _kind                    = format_directive_kind::unknown_error;
+        _literal_character_lead  = '\0';
+        _literal_character_trail = '\0';
+        _suppress_assignment     = false;
+        _width                   = 0;
+        _length                  = length_modifier::none;
+        _is_wide                 = false;
+        _mode                    = conversion_mode();
+    }
+
+    void reset_token_state_for_error(errno_t const error_code) throw()
+    {
+        reset_token_state();
+        _error_code = error_code;
+    }
+
+    uint64_t                           _options;
+    unsigned_char_type const*          _format_it;
+    errno_t                            _error_code;
+
+    format_directive_kind              _kind;
+
+    unsigned_char_type                 _literal_character_lead;
+    unsigned_char_type                 _literal_character_trail;
+
+    bool                               _suppress_assignment;
+    uint64_t                           _width;
+    length_modifier                    _length;
+    bool                               _is_wide;
+    conversion_mode                    _mode;
+    scanset_buffer<unsigned_char_type> _scanset;
+};
+
+} // namespace __crt_stdio_input
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Input Processor
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The input processor constructs a format string parser, iterates over the
+// format string, and performs the appropriate action for each directive.
+namespace __crt_stdio_input {
+
+template <typename Character, typename InputAdapter>
+class input_processor
+{
+public:
+
+    using traits             = __acrt_stdio_char_traits<Character>;
+    using char_type          = Character;
+    using unsigned_char_type = typename traits::unsigned_char_type;
+    using int_type           = typename traits::int_type;
+
+    input_processor(
+        InputAdapter     const& input_adapter,
+        uint64_t         const  options,
+        char_type const* const  format,
+        _locale_t        const  locale,
+        va_list          const  arglist
+        ) throw()
+        : _options                        {options                                                     },
+          _input_adapter                  {input_adapter                                               },
+          _format_parser                  {options, reinterpret_cast<unsigned_char_type const*>(format)},
+          _locale                         {locale                                                      },
+          _valist                         {arglist                                                     },
+          _receiving_arguments_assigned   {0                                                           }
+    {
+    }
+
+    int process() throw()
+    {
+        if (!_input_adapter.validate())
+            return EOF;
+
+        if (!_format_parser.validate())
+            return EOF;
+
+        while (_format_parser.advance())
+        {
+            if (!process_state())
+                break;
+        }
+
+        // Return value is number of receiving arguments assigned,
+        // or EOF if read failure occurs before the first receiving argument was assigned.
+        int result{static_cast<int>(_receiving_arguments_assigned)};
+
+        // If we haven't reached the 'end_of_string' parse, then a read error occurred.
+        if (_receiving_arguments_assigned == 0 && _format_parser.kind() != format_directive_kind::end_of_string)
+        {
+            int_type const c{_input_adapter.get()};
+            if (c == traits::eof)
+                result = EOF;
+
+            _input_adapter.unget(c);
+        }
+
+        if (secure_buffers())
+        {
+            _VALIDATE_RETURN(_format_parser.error_code() == 0, _format_parser.error_code(), result);
+        }
+
+        return result;
+    }
+
+private:
+
+    bool process_state() throw()
+    {
+        switch (_format_parser.kind())
+        {
+        case format_directive_kind::whitespace:
+        {
+            return process_whitespace();
+        }
+
+        case format_directive_kind::literal_character:
+        {
+            return process_literal_character();
+        }
+
+        case format_directive_kind::conversion_specifier:
+        {
+            bool const result{process_conversion_specifier()};
+            // %n and suppressed conversion specifiers are not considered receiving arguments
+            if (result
+                && _format_parser.mode() != conversion_mode::report_character_count
+                && !_format_parser.suppress_assignment())
+            {
+                ++_receiving_arguments_assigned;
+            }
+
+            return result;
+        }
+        }
+
+        return false;
+    }
+
+    bool process_whitespace() throw()
+    {
+        _input_adapter.unget(skip_whitespace(_input_adapter, _locale));
+        return true;
+    }
+
+    bool process_literal_character() throw()
+    {
+        int_type const c{_input_adapter.get()};
+        if (c == traits::eof)
+        {
+            return false;
+        }
+
+        if (c != _format_parser.literal_character_lead())
+        {
+            _input_adapter.unget(c);
+            return false;
+        }
+
+        return process_literal_character_tchar(static_cast<char_type>(c));
+    }
+
+    bool process_literal_character_tchar(char const initial_character) throw()
+    {
+        if (isleadbyte(static_cast<unsigned char>(initial_character)) == 0)
+        {
+            return true;
+        }
+
+        int_type const c{_input_adapter.get()};
+        if (c != _format_parser.literal_character_trail())
+        {
+            _input_adapter.unget(c);
+            _input_adapter.unget(initial_character);
+            return false;
+        }
+
+        return true;
+    }
+
+    bool process_literal_character_tchar(wchar_t) throw()
+    {
+        return true; // No-op for Unicode
+    }
+
+    bool process_conversion_specifier() throw()
+    {
+        switch (_format_parser.mode())
+        {
+        case conversion_mode::character:              return process_string_specifier(conversion_mode::character);
+        case conversion_mode::string:                 return process_string_specifier(conversion_mode::string);
+        case conversion_mode::scanset:                return process_string_specifier(conversion_mode::scanset);
+
+        case conversion_mode::signed_unknown:         return process_integer_specifier( 0,  true);
+        case conversion_mode::signed_decimal:         return process_integer_specifier(10,  true);
+        case conversion_mode::unsigned_octal:         return process_integer_specifier( 8, false);
+        case conversion_mode::unsigned_decimal:       return process_integer_specifier(10, false);
+        case conversion_mode::unsigned_hexadecimal:   return process_integer_specifier(16, false);
+
+        case conversion_mode::floating_point:         return process_floating_point_specifier();
+
+        case conversion_mode::report_character_count: return process_character_count_specifier();
+        }
+
+        return false;
+    }
+
+    bool process_string_specifier(conversion_mode const mode) throw()
+    {
+        if (mode == conversion_mode::string)
+        {
+            process_whitespace();
+        }
+
+        switch (_format_parser.length())
+        {
+        case sizeof(char):    return process_string_specifier_tchar(mode, char());
+        case sizeof(wchar_t): return process_string_specifier_tchar(mode, wchar_t());
+        default:              return false;
+        }
+    }
+
+    template <typename BufferCharacter>
+    bool process_string_specifier_tchar(conversion_mode const mode, BufferCharacter) throw()
+    {
+        BufferCharacter _UNALIGNED* buffer{nullptr};
+        if (!_format_parser.suppress_assignment())
+        {
+            buffer = va_arg(_valist, BufferCharacter _UNALIGNED*);
+            _VALIDATE_RETURN(buffer != nullptr, EINVAL, false);
+        }
+
+        size_t const buffer_count{buffer != nullptr && secure_buffers()
+            ? va_arg(_valist, unsigned)
+            : _CRT_UNBOUNDED_BUFFER_SIZE
+        };
+
+        if (buffer_count == 0)
+        {
+            if (_options & _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY)
+            {
+                // For legacy compatibility:  in the old implementation, we failed
+                // to unget the last character read if the buffer had a size of zero
+                _input_adapter.get();
+
+                // Additionally, we wrote a terminator to the buffer, even though
+                // the caller said the buffer had zero elements
+                buffer[0] = '\0';
+            }
+
+            errno = ENOMEM;
+            return false;
+        }
+
+        uint64_t const width{_format_parser.width()};
+
+        BufferCharacter _UNALIGNED* buffer_pointer  {buffer      };
+        size_t                      buffer_remaining{buffer_count};
+
+        if (mode != conversion_mode::character && buffer_remaining != _CRT_UNBOUNDED_BUFFER_SIZE)
+        {
+            --buffer_remaining; // Leave room for terminator when scanning strings
+        }
+
+        uint64_t width_consumed{0};
+        for (; width == 0 || width_consumed != width; ++width_consumed)
+        {
+            int_type c{_input_adapter.get()};
+
+            if (!is_character_allowed_in_string(mode, c))
+            {
+                _input_adapter.unget(c);
+                break;
+            }
+
+            if (_format_parser.suppress_assignment())
+            {
+                continue;
+            }
+
+            if (buffer_remaining == 0)
+            {
+                reset_buffer(buffer, buffer_count);
+                errno = ENOMEM;
+                return false;
+            }
+
+            if (!write_character(buffer, buffer_count, buffer_pointer, buffer_remaining, static_cast<char_type>(c)))
+            {
+                break;
+            }
+        }
+
+        if (width_consumed == 0)
+        {
+            return false;
+        }
+
+        // The %c conversion specifier "matches a sequence of characters of exactly
+        // the number specified by the field width."  The legacy behavior was to
+        // match a sequence of up to that many characters.  If legacy mode was not
+        // requested, fail if we did not match the requested number of characters:
+        if (mode == conversion_mode::character &&
+            width_consumed != width &&
+            (_options & _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
+        {
+            return false;
+        }
+
+        if (_format_parser.suppress_assignment())
+        {
+            return true;
+        }
+
+        if (mode != conversion_mode::character)
+        {
+            *buffer_pointer = '\0';
+            fill_buffer(buffer, buffer_count, buffer_remaining);
+        }
+
+        return true;
+    }
+
+    // There are four overloads of write_character to handle writing both narrow
+    // and wide characters into either a narrow or a wide buffer.
+    bool write_character(
+        char*  const buffer,
+        size_t const buffer_count,
+        char*&       buffer_pointer,
+        size_t&      buffer_remaining,
+        char   const c
+        ) throw()
+    {
+        UNREFERENCED_PARAMETER(buffer);
+        UNREFERENCED_PARAMETER(buffer_count);
+
+        *buffer_pointer++ = c;
+        --buffer_remaining;
+        return true;
+    }
+
+    bool write_character(
+        char*   const buffer,
+        size_t  const buffer_count,
+        char*&        buffer_pointer,
+        size_t&       buffer_remaining,
+        wchar_t const c
+        ) throw()
+    {
+        if (buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE)
+        {
+            int narrow_count{0};
+            if (_ERRCHECK_EINVAL_ERANGE(wctomb_s(&narrow_count, buffer_pointer, MB_LEN_MAX, c)) == 0)
+            {
+                buffer_pointer   += narrow_count;
+                buffer_remaining -= narrow_count;
+            }
+        }
+        else
+        {
+            int narrow_count{0};
+            if (wctomb_s(&narrow_count, buffer_pointer, buffer_remaining, c) == ERANGE)
+            {
+                reset_buffer(buffer, buffer_count);
+                return false;
+            }
+
+            if (narrow_count > 0)
+            {
+                buffer_pointer   += narrow_count;
+                buffer_remaining -= narrow_count;
+            }
+        }
+
+        return true;
+    }
+
+    bool write_character(
+        wchar_t _UNALIGNED* const buffer,
+        size_t              const buffer_count,
+        wchar_t _UNALIGNED*&      buffer_pointer,
+        size_t&                   buffer_remaining,
+        char                const c
+        ) throw()
+    {
+        UNREFERENCED_PARAMETER(buffer);
+        UNREFERENCED_PARAMETER(buffer_count);
+
+        char narrow_temp[2]{c, '\0'};
+        if (isleadbyte(static_cast<unsigned char>(c)))
+        {
+            narrow_temp[1] = static_cast<char>(_input_adapter.get());
+        }
+
+        wchar_t wide_temp{'?'};
+
+        _mbtowc_l(&wide_temp, narrow_temp, _locale->locinfo->_public._locale_mb_cur_max, _locale);
+
+        *buffer_pointer++ = c;
+        --buffer_remaining;
+        return true;
+    }
+
+    bool write_character(
+        wchar_t _UNALIGNED* const buffer,
+        size_t              const buffer_count,
+        wchar_t _UNALIGNED*&      buffer_pointer,
+        size_t&                   buffer_remaining,
+        wchar_t             const c
+        ) throw()
+    {
+        UNREFERENCED_PARAMETER(buffer);
+        UNREFERENCED_PARAMETER(buffer_count);
+
+        *buffer_pointer++ = c;
+        --buffer_remaining;
+        return true;
+    }
+
+    template <typename BufferCharacter>
+    static void fill_buffer(
+        BufferCharacter _UNALIGNED* const buffer,
+        size_t                      const buffer_count,
+        size_t                      const buffer_remaining
+        ) throw()
+    {
+        UNREFERENCED_PARAMETER(buffer);
+        UNREFERENCED_PARAMETER(buffer_remaining);
+
+        if (buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE)
+            return;
+
+        _FILL_STRING(buffer, buffer_count, buffer_count - buffer_remaining);
+    }
+
+    template <typename BufferCharacter>
+    static void reset_buffer(
+        BufferCharacter _UNALIGNED* const buffer,
+        size_t                      const buffer_count
+        ) throw()
+    {
+        UNREFERENCED_PARAMETER(buffer);
+
+        if (buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE)
+            return;
+
+        _RESET_STRING(buffer, buffer_count);
+    }
+
+    bool is_character_allowed_in_string(conversion_mode const mode, int_type const c) const throw()
+    {
+        if (c == traits::eof)
+            return false;
+
+        switch (mode)
+        {
+        case conversion_mode::character:
+        {
+            return true;
+        }
+
+        case conversion_mode::string:
+        {
+            if (c >= '\t' && c <= '\r')
+                return false;
+
+            if (c == ' ')
+                return false;
+
+            return true;
+        }
+
+        case conversion_mode::scanset:
+        {
+            if (!_format_parser.scanset().test(static_cast<unsigned_char_type>(c)))
+                return false;
+
+            return true;
+        }
+        }
+
+        return false;
+    }
+
+    bool process_integer_specifier(unsigned base, bool const is_signed) throw()
+    {
+        process_whitespace();
+
+        bool succeeded{false};
+        uint64_t const number{__crt_strtox::parse_integer<uint64_t>(
+            _locale,
+            __crt_strtox::make_input_adapter_character_source(&_input_adapter, _format_parser.width(), &succeeded),
+            base,
+            is_signed)};
+
+        if (!succeeded)
+            return false;
+
+        if (_format_parser.suppress_assignment())
+            return true;
+
+        return write_integer(number);
+    }
+
+    template <typename FloatingType>
+    bool process_floating_point_specifier_t() throw()
+    {
+        bool succeeded{false};
+        FloatingType value{};
+        SLD_STATUS const status{__crt_strtox::parse_floating_point(
+            _locale,
+            __crt_strtox::make_input_adapter_character_source(&_input_adapter, _format_parser.width(), &succeeded),
+            &value)};
+
+        if (!succeeded || status == SLD_NODIGITS)
+            return false;
+
+        if (_format_parser.suppress_assignment())
+            return true;
+
+        return write_floating_point(value);
+    }
+
+    bool process_floating_point_specifier() throw()
+    {
+        process_whitespace();
+
+        switch (_format_parser.length())
+        {
+        case sizeof(float):  return process_floating_point_specifier_t<float >();
+        case sizeof(double): return process_floating_point_specifier_t<double>();
+        default:             return false;
+        }
+    }
+
+    bool process_character_count_specifier() throw()
+    {
+        if (_format_parser.suppress_assignment())
+            return true;
+
+        return write_integer(_input_adapter.characters_read());
+    }
+
+    bool write_integer(uint64_t const value) throw()
+    {
+        void* const result_pointer{va_arg(_valist, void*)};
+        _VALIDATE_RETURN(result_pointer != nullptr, EINVAL, false);
+
+        switch (_format_parser.length())
+        {
+        case sizeof(uint8_t ): *static_cast<uint8_t *>(result_pointer) = static_cast<uint8_t >(value); return true;
+        case sizeof(uint16_t): *static_cast<uint16_t*>(result_pointer) = static_cast<uint16_t>(value); return true;
+        case sizeof(uint32_t): *static_cast<uint32_t*>(result_pointer) = static_cast<uint32_t>(value); return true;
+        case sizeof(uint64_t): *static_cast<uint64_t*>(result_pointer) = static_cast<uint64_t>(value); return true;
+        default:
+            _ASSERTE(("Unexpected length specifier", false));
+            return false;
+        }
+    }
+
+    template <typename FloatingType>
+    bool write_floating_point(FloatingType const& value) throw()
+    {
+        using integer_type = uintn_t<sizeof(FloatingType)>;
+
+        void* const result_pointer{va_arg(_valist, void*)};
+        _VALIDATE_RETURN(result_pointer != nullptr, EINVAL, false);
+
+        _ASSERTE(sizeof(FloatingType) == _format_parser.length());
+
+        // We write through the pointer as if it were an integer pointer, to
+        // avoid floating point instructions that cause information loss for
+        // special NaNs (signaling NaNs, indeterminates):
+        *static_cast<integer_type*>(result_pointer) = reinterpret_cast<integer_type const&>(value);
+        return true;
+    }
+
+private:
+
+    bool secure_buffers() const throw()
+    {
+        return (_options & _CRT_INTERNAL_SCANF_SECURECRT) != 0;
+    }
+
+    uint64_t                        _options;
+    InputAdapter                    _input_adapter;
+    format_string_parser<char_type> _format_parser;
+    _locale_t                       _locale;
+    va_list                         _valist;
+    size_t                          _receiving_arguments_assigned;
+};
+
+} // namespace __crt_stdio_input
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio_output.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio_output.h
new file mode 100644
index 0000000000000000000000000000000000000000..7afd328424f50dee398b8fbf0a8b2e72096345ea
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_stdio_output.h	
@@ -0,0 +1,2877 @@
+//
+// corecrt_internal_stdio_output.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file defines the core implementation of the formatted output functions,
+// including printf and its many variants (sprintf, fprintf, etc.).
+//
+#include <conio.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_strtox.h>
+#include <ctype.h>
+#include <locale.h>
+#include <stdarg.h>
+
+#include <corecrt_internal_ptd_propagation.h>
+
+namespace __crt_stdio_output {
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Argument Handling
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These provide a very basic encapsulation over a va_list.  The 'read' function
+// reads the next argument of type T from the varargs list and updates the
+// va_list, just like va_arg does.  The 'peek' function returns the next argument
+// of type T, but does not modify the va_list.
+template <typename T>
+T read_va_arg(va_list& arglist) throw()
+{
+    return va_arg(arglist, T);
+}
+
+template <typename T>
+T peek_va_arg(va_list arglist) throw()
+{
+    return va_arg(arglist, T);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Output Adapters
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The actual write operations are different depending on whether the target is
+// a stream or the console.  We handle these differences via output adapters.
+// The stream and console I/O functions pass an adapter to the core output
+// function, and that function calls the various write members of the adapter to
+// perform the write operations.
+template <typename Character, typename Derived>
+class output_adapter_common
+{
+public:
+    void write_character(Character const c, int* const count_written, __crt_cached_ptd_host& ptd) const throw()
+    {
+        if (static_cast<Derived const*>(this)->write_character_without_count_update(c, ptd))
+        {
+            ++*count_written;
+        }
+        else
+        {
+            *count_written = -1;
+        }
+    }
+
+protected:
+    void write_string_impl(
+        Character const*   const string,
+        int                const length,
+        int*               const count_written,
+        __crt_cached_ptd_host&   ptd
+        ) const throw()
+    {
+        auto const reset_errno = ptd.get_errno().create_guard();
+
+        Character const* const string_last{string + length};
+        for (Character const* it{string}; it != string_last; ++it)
+        {
+            if (static_cast<Derived const*>(this)->write_character_without_count_update(*it, ptd))
+            {
+                ++*count_written;
+            }
+            else
+            {
+                // Non-standard extension: EILSEQ errors are recoverable.
+                // Standard behavior when we've encountered an 'illegal sequence' error
+                // (i.e. EILSEQ) is to set 'errno' to EILSEQ and return -1.
+                // Instead, we write '?' and continue writing the string.
+                if (!ptd.get_errno().check(EILSEQ))
+                {
+                    // *printf returns the number of characters written
+                    // set count written to -1 to indicate an error occurred
+                    *count_written = -1;
+                    break;
+                }
+
+                write_character('?', count_written, ptd);
+            }
+        }
+    }
+};
+
+template <typename Character>
+class console_output_adapter
+    : public output_adapter_common<Character, console_output_adapter<Character>>
+{
+public:
+    typedef __acrt_stdio_char_traits<Character> char_traits;
+
+    bool validate(__crt_cached_ptd_host&) const throw()
+    {
+        return true;
+    }
+
+    bool write_character_without_count_update(Character const c, __crt_cached_ptd_host& ptd) const throw()
+    {
+        return char_traits::puttch_nolock_internal(c, ptd) != char_traits::eof;
+    }
+
+    void write_string(
+        Character const*   const string,
+        int                const length,
+        int*               const count_written,
+        __crt_cached_ptd_host&   ptd
+        ) const throw()
+    {
+        write_string_impl(string, length, count_written, ptd);
+    }
+};
+
+
+
+template <typename Character>
+class stream_output_adapter
+    : public output_adapter_common<Character, stream_output_adapter<Character>>
+{
+public:
+    typedef __acrt_stdio_char_traits<Character> char_traits;
+
+    stream_output_adapter(FILE* const public_stream) throw()
+        : _stream{public_stream}
+    {
+    }
+
+    bool validate(__crt_cached_ptd_host& ptd) const throw()
+    {
+        _UCRT_VALIDATE_RETURN(ptd, _stream.valid(), EINVAL, false);
+
+        return char_traits::validate_stream_is_ansi_if_required(_stream.public_stream());
+    }
+
+    bool write_character_without_count_update(Character const c, __crt_cached_ptd_host& ptd) const throw()
+    {
+        if (_stream.is_string_backed() && _stream->_base == nullptr)
+        {
+            return true;
+        }
+
+        return char_traits::puttc_nolock_internal(c, _stream.public_stream(), ptd) != char_traits::eof;
+    }
+
+    void write_string(
+        Character const*   const string,
+        int                const length,
+        int*               const count_written,
+        __crt_cached_ptd_host&   ptd
+        ) const throw()
+    {
+        if (_stream.is_string_backed() && _stream->_base == nullptr)
+        {
+            *count_written += length;
+            return;
+        }
+
+        write_string_impl(string, length, count_written, ptd);
+    }
+
+private:
+
+    __crt_stdio_stream _stream;
+};
+
+
+
+template <typename Character>
+struct string_output_adapter_context
+{
+    Character* _buffer;
+    size_t     _buffer_count;
+    size_t     _buffer_used;
+    bool       _continue_count;
+};
+
+template <typename Character>
+class string_output_adapter
+{
+public:
+
+    typedef __acrt_stdio_char_traits<Character>      char_traits;
+    typedef string_output_adapter_context<Character> context_type;
+
+    string_output_adapter(context_type* const context) throw()
+        : _context(context)
+    {
+    }
+
+    bool validate(__crt_cached_ptd_host& ptd) const throw()
+    {
+        _UCRT_VALIDATE_RETURN(ptd, _context != nullptr, EINVAL, false);
+        return true;
+    }
+
+    __forceinline bool write_character(Character const c, int* const count_written, __crt_cached_ptd_host&) const throw()
+    {
+        if (_context->_buffer_used == _context->_buffer_count)
+        {
+            if (_context->_continue_count)
+            {
+                ++*count_written;
+            }
+            else
+            {
+                *count_written = -1;
+            }
+
+            return _context->_continue_count;
+        }
+
+        ++*count_written;
+        ++_context->_buffer_used;
+        *_context->_buffer++ = c;
+        return true;
+    }
+
+    void write_string(
+        Character const*   const string,
+        int                const length,
+        int*               const count_written,
+        __crt_cached_ptd_host&   ptd
+        ) const throw()
+    {
+        // This function does not perform any operations that might reset errno,
+        // so we don't need to use __crt_errno_guard as we do in other output
+        // adapters.
+        UNREFERENCED_PARAMETER(ptd);
+
+        if (length == 0)
+        {
+            return;
+        }
+
+        if (_context->_buffer_used == _context->_buffer_count)
+        {
+            if (_context->_continue_count)
+            {
+                *count_written += length;
+            }
+            else
+            {
+                *count_written = -1;
+            }
+
+            return;
+        }
+
+        size_t const space_available  = _context->_buffer_count - _context->_buffer_used;
+        size_t const elements_to_copy = __min(space_available, static_cast<size_t>(length));
+
+        // Performance note:  This is hot code.  Profiling has shown the extra
+        // validation done by memcpy_s to be quite expensive.  The validation is
+        // unnecessary, so we call memcpy directly here:
+        memcpy(
+            _context->_buffer,
+            string,
+            elements_to_copy * sizeof(Character));
+
+        _context->_buffer      += elements_to_copy;
+        _context->_buffer_used += elements_to_copy;
+
+        if (_context->_continue_count)
+        {
+            *count_written += length;
+        }
+        else if (elements_to_copy != static_cast<size_t>(length))
+        {
+            *count_written = -1;
+        }
+        else
+        {
+            *count_written += static_cast<int>(elements_to_copy);
+        }
+    }
+
+private:
+
+    context_type* _context;
+};
+
+
+
+template <typename OutputAdapter, typename Character>
+__forceinline void write_multiple_characters(
+    OutputAdapter      const& adapter,
+    Character          const  c,
+    int                const  count,
+    int*               const  count_written,
+    __crt_cached_ptd_host&    ptd
+    ) throw()
+{
+    for (int i{0}; i < count; ++i)
+    {
+        adapter.write_character(c, count_written, ptd);
+        if (*count_written == -1)
+            break;
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Formatting Buffer
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This type encapsulates the buffer to be used when formatting numbers.  It
+// contains as a data member a large, statically-sized buffer, which is used
+// at first.  If a larger buffer is required a new, larger buffer is dynamically
+// allocated.
+class formatting_buffer
+{
+public:
+
+    enum
+    {
+        member_buffer_size = 1024,
+    };
+
+    static_assert(member_buffer_size >= (_CVTBUFSIZE + 6) * 2, "Buffer is too small");
+
+    formatting_buffer() throw()
+        : _dynamic_buffer_size{0}
+    {
+    }
+
+    template <typename T>
+    bool ensure_buffer_is_big_enough(size_t const count, __crt_cached_ptd_host& ptd) throw()
+    {
+        constexpr size_t max_count = SIZE_MAX / sizeof(T) / 2; // avoid runtime division
+        _UCRT_VALIDATE_RETURN_NOEXC(ptd, max_count >= count, ENOMEM, false);
+
+        size_t const required_size{count * sizeof(T) * 2};
+
+        // Once we allocate a dynamic buffer, we no longer use the member buffer
+        if (!_dynamic_buffer && required_size <= member_buffer_size) {
+            return true;
+        }
+
+        if (required_size <= _dynamic_buffer_size) {
+            return true;
+        }
+
+        __crt_unique_heap_ptr<char> new_buffer{_malloc_crt_t(char, required_size)};
+        if (!new_buffer) {
+            return false;
+        }
+
+        _dynamic_buffer      = static_cast<__crt_unique_heap_ptr<char>&&>(new_buffer);
+        _dynamic_buffer_size = required_size;
+        return true;
+    }
+
+    template <typename T>
+    T* data() throw()
+    {
+        if (!_dynamic_buffer)
+            return reinterpret_cast<T*>(_member_buffer);
+
+        return reinterpret_cast<T*>(_dynamic_buffer.get());
+    }
+
+    template <typename T>
+    T* scratch_data() throw()
+    {
+        if (!_dynamic_buffer)
+            return reinterpret_cast<T*>(_member_buffer) + count<T>();
+
+        return reinterpret_cast<T*>(_dynamic_buffer.get()) + count<T>();
+    }
+
+    template <typename T>
+    size_t count() const throw()
+    {
+        if (!_dynamic_buffer)
+            return member_buffer_size / sizeof(T) / 2;
+
+        return _dynamic_buffer_size / sizeof(T) / 2;
+    }
+
+    template <typename T>
+    size_t scratch_count() const throw()
+    {
+        return count<T>();
+    }
+
+private:
+
+    char _member_buffer[member_buffer_size];
+
+    size_t                      _dynamic_buffer_size;
+    __crt_unique_heap_ptr<char> _dynamic_buffer;
+};
+
+
+
+// This function forces a decimal point in floating point output.  It is called
+// if '#' flag is given and precision is 0, so we know the number has no '.' in
+// its current representation.  We insert the '.' and move everything back one
+// position until '\0' is seen.  This function updates the buffer in place.
+inline void __cdecl force_decimal_point(_Inout_z_ char* buffer, _locale_t const locale) throw()
+{
+    if (_tolower_fast_internal(static_cast<unsigned char>(*buffer), locale) != 'e')
+    {
+        do
+        {
+            ++buffer;
+        }
+        while (_isdigit_fast_internal(static_cast<unsigned char>(*buffer), locale));
+    }
+
+    // Check if the buffer is in hexadecimal format (cfr %a or %A and fp_format_a):
+    if (_tolower_fast_internal(*buffer, locale) == 'x')
+    {
+        // The buffer is in the form: [-]0xhP+d, and buffer points to the 'x':
+        // we want to put the decimal point after the h digit: [-]0xh.P+d
+        buffer += 2; // REVIEW This can skip terminal nul?
+    }
+
+    char holdchar = *buffer;
+
+    *buffer++ = *locale->locinfo->lconv->decimal_point;
+
+    do
+    {
+        char const nextchar = *buffer;
+        *buffer  = holdchar;
+        holdchar = nextchar;
+    }
+    while (*buffer++);
+}
+
+
+
+// This function removes trailing zeroes (after the '.') from a floating point
+// number.  This function is called only when formatting in the %g mode when
+// there is no '#' flag and precision is nonzero.  This function updates the
+// buffer in-place.
+//
+// This function changes the contents of the buffer from:
+//     [-] digit [digit...] [ . [digits...] [0...] ] [(exponent part)]
+// to:
+//     [-] digit [digit...] [ . digit [digits...] ] [(exponent part)]
+// or:
+//     [-] digit [digit...] [(exponent part)]
+inline void __cdecl crop_zeroes(_Inout_z_ char* buffer, _locale_t const locale) throw()
+{
+    char const decimal_point = *locale->locinfo->lconv->decimal_point;
+
+    while (*buffer && *buffer != decimal_point)
+        ++buffer;
+
+    if (*buffer++)
+    {
+        while (*buffer && *buffer != 'e' && *buffer != 'E')
+            ++buffer;
+
+        char* stop = buffer--;
+
+        while (*buffer == '0')
+            --buffer;
+
+        if (*buffer == decimal_point)
+            --buffer;
+
+        while((*++buffer = *stop++) != '\0') { }
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// States and the State Transition Tables
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These tables hold the state transition data for the format processor.  The
+// lower nibble of each byte is the character class of the character.  The upper
+// nibble of each byte gives the next state to enter.
+
+// The states of the format parsing state machine.  These are encoded into the
+// transition tables and are referenced throughout the format processor.
+enum class state : unsigned char
+{
+    normal,    // Normal state; outputting literal chars
+    percent,   // Just read '%'
+    flag,      // Just read flag character
+    width,     // Just read width specifier
+    dot,       // Just read '.'
+    precision, // Just read precision specifier
+    size,      // Just read size specifier
+    type,      // Just read type specifier
+    invalid    // Invalid format
+};
+
+// Manifest constants to represent the different types of characters that may
+// be encountered in the format string.  These are not referenced anywhere in
+// the source anymore, but their values are encoded into the state table, so
+// we have retained the definition for reference.
+enum class character_type : unsigned char
+{
+    other,   // character with no special meaning
+    percent, // '%'
+    dot,     // '.'
+    star,    // '*'
+    zero,    // '0'
+    digit,   // '1'..'9'
+    flag,    // ' ', '+', '-', '#'
+    size,    // 'h', 'l', 'L', 'N', 'F', 'w'
+    type     // type specifying character
+};
+
+struct state_transition_pair
+{
+    state          next_state;
+    character_type current_class;
+};
+
+template <typename T, size_t Size>
+class spectre_mitigated_lookup_table
+{
+public:
+
+    static size_t const mask = Size - 1;
+    static_assert((Size & mask) == 0, "Size must be a power of two.");
+
+    // Instead of using an lfence mitigation, we can fill the table to a power of two,
+    // then bitwise-and all values used to index into the array.
+    __declspec(spectre(nomitigation)) T const& operator[](size_t const index) const
+    {
+        return m_array[index & mask];
+    }
+
+    T m_array[Size];
+};
+
+using printf_state_transition_table = spectre_mitigated_lookup_table<state_transition_pair, 128>;
+
+// Note, the state transition and character type are unrelated data - they just occupy the same table.
+// This table skips the 'invalid' state.
+extern __declspec(selectany) printf_state_transition_table const standard_lookup_table_spectre
+{
+    /* prev state -> cur char ->    new state                   character type */
+    /* normal     -> other    -> */ state::normal,    /* ' ' */ character_type::flag,
+    /* percent    -> other    -> */ state::normal,    /* '!' */ character_type::other,
+    /* flag       -> other    -> */ state::normal,    /* '"' */ character_type::other,
+    /* width      -> other    -> */ state::normal,    /* '#' */ character_type::flag,
+    /* dot        -> other    -> */ state::normal,    /* '$' */ character_type::other,
+    /* precision  -> other    -> */ state::normal,    /* '%' */ character_type::percent,
+    /* size       -> other    -> */ state::normal,    /* '&' */ character_type::other,
+    /* type       -> other    -> */ state::normal,    /* ''' */ character_type::other,
+    /* normal     -> percent  -> */ state::percent,   /* '(' */ character_type::other,
+    /* percent    -> percent  -> */ state::normal,    /* ')' */ character_type::other,
+    /* flag       -> percent  -> */ state::normal,    /* '*' */ character_type::star,
+    /* width      -> percent  -> */ state::normal,    /* '+' */ character_type::flag,
+    /* dot        -> percent  -> */ state::normal,    /* ',' */ character_type::other,
+    /* precision  -> percent  -> */ state::normal,    /* '-' */ character_type::flag,
+    /* size       -> percent  -> */ state::normal,    /* '.' */ character_type::dot,
+    /* type       -> percent  -> */ state::percent,   /* '/' */ character_type::other,
+    /* normal     -> dot      -> */ state::normal,    /* '0' */ character_type::zero,
+    /* percent    -> dot      -> */ state::dot,       /* '1' */ character_type::digit,
+    /* flag       -> dot      -> */ state::dot,       /* '2' */ character_type::digit,
+    /* width      -> dot      -> */ state::dot,       /* '3' */ character_type::digit,
+    /* dot        -> dot      -> */ state::normal,    /* '4' */ character_type::digit,
+    /* precision  -> dot      -> */ state::normal,    /* '5' */ character_type::digit,
+    /* size       -> dot      -> */ state::normal,    /* '6' */ character_type::digit,
+    /* type       -> dot      -> */ state::normal,    /* '7' */ character_type::digit,
+    /* normal     -> star     -> */ state::normal,    /* '8' */ character_type::digit,
+    /* percent    -> star     -> */ state::width,     /* '9' */ character_type::digit,
+    /* flag       -> star     -> */ state::width,     /* ':' */ character_type::other,
+    /* width      -> star     -> */ state::normal,    /* ';' */ character_type::other,
+    /* dot        -> star     -> */ state::precision, /* '<' */ character_type::other,
+    /* precision  -> star     -> */ state::normal,    /* '=' */ character_type::other,
+    /* size       -> star     -> */ state::normal,    /* '>' */ character_type::other,
+    /* type       -> star     -> */ state::normal,    /* '?' */ character_type::other,
+    /* normal     -> zero     -> */ state::normal,    /* '@' */ character_type::other,
+    /* percent    -> zero     -> */ state::flag,      /* 'A' */ character_type::type,
+    /* flag       -> zero     -> */ state::flag,      /* 'B' */ character_type::other,
+    /* width      -> zero     -> */ state::width,     /* 'C' */ character_type::type,
+    /* dot        -> zero     -> */ state::precision, /* 'D' */ character_type::other,
+    /* precision  -> zero     -> */ state::precision, /* 'E' */ character_type::type,
+    /* size       -> zero     -> */ state::normal,    /* 'F' */ character_type::size,
+    /* type       -> zero     -> */ state::normal,    /* 'G' */ character_type::type,
+    /* normal     -> digit    -> */ state::normal,    /* 'H' */ character_type::other,
+    /* percent    -> digit    -> */ state::width,     /* 'I' */ character_type::size,
+    /* flag       -> digit    -> */ state::width,     /* 'J' */ character_type::other,
+    /* width      -> digit    -> */ state::width,     /* 'K' */ character_type::other,
+    /* dot        -> digit    -> */ state::precision, /* 'L' */ character_type::size,
+    /* precision  -> digit    -> */ state::precision, /* 'M' */ character_type::other,
+    /* size       -> digit    -> */ state::normal,    /* 'N' */ character_type::size,
+    /* type       -> digit    -> */ state::normal,    /* 'O' */ character_type::other,
+    /* normal     -> flag     -> */ state::normal,    /* 'P' */ character_type::other,
+    /* percent    -> flag     -> */ state::flag,      /* 'Q' */ character_type::other,
+    /* flag       -> flag     -> */ state::flag,      /* 'R' */ character_type::other,
+    /* width      -> flag     -> */ state::normal,    /* 'S' */ character_type::type,
+    /* dot        -> flag     -> */ state::normal,    /* 'T' */ character_type::size,
+    /* precision  -> flag     -> */ state::normal,    /* 'U' */ character_type::other,
+    /* size       -> flag     -> */ state::normal,    /* 'V' */ character_type::other,
+    /* type       -> flag     -> */ state::normal,    /* 'W' */ character_type::other,
+    /* normal     -> size     -> */ state::normal,    /* 'X' */ character_type::type,
+    /* percent    -> size     -> */ state::size,      /* 'Y' */ character_type::other,
+    /* flag       -> size     -> */ state::size,      /* 'Z' */ character_type::type,
+    /* width      -> size     -> */ state::size,      /* '[' */ character_type::other,
+    /* dot        -> size     -> */ state::size,      /* '\' */ character_type::other,
+    /* precision  -> size     -> */ state::size,      /* ']' */ character_type::other,
+    /* size       -> size     -> */ state::size,      /* '^' */ character_type::other,
+    /* type       -> size     -> */ state::normal,    /* '_' */ character_type::other,
+    /* normal     -> type     -> */ state::normal,    /* '`' */ character_type::other,
+    /* percent    -> type     -> */ state::type,      /* 'a' */ character_type::type,
+    /* flag       -> type     -> */ state::type,      /* 'b' */ character_type::other,
+    /* width      -> type     -> */ state::type,      /* 'c' */ character_type::type,
+    /* dot        -> type     -> */ state::type,      /* 'd' */ character_type::type,
+    /* precision  -> type     -> */ state::type,      /* 'e' */ character_type::type,
+    /* size       -> type     -> */ state::type,      /* 'f' */ character_type::type,
+    /* type       -> type     -> */ state::normal,    /* 'g' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'h' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'i' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'j' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'k' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'l' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'm' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'n' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'o' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'p' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'q' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'r' */ character_type::other,
+    /* unused                    */ state::normal,    /* 's' */ character_type::type,
+    /* unused                    */ state::normal,    /* 't' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'u' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'v' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'w' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'x' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'y' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'z' */ character_type::size
+};
+
+// Note, the state transition and character type are unrelated data - they just occupy the same table.
+extern __declspec(selectany) printf_state_transition_table const format_validation_lookup_table_spectre
+{
+    /* prev state -> cur char ->    new state                   character type */
+    /* normal     -> other    -> */ state::normal,    /* ' ' */ character_type::flag,
+    /* percent    -> other    -> */ state::invalid,   /* '!' */ character_type::other,
+    /* flag       -> other    -> */ state::invalid,   /* '"' */ character_type::other,
+    /* width      -> other    -> */ state::invalid,   /* '#' */ character_type::flag,
+    /* dot        -> other    -> */ state::invalid,   /* '$' */ character_type::other,
+    /* precision  -> other    -> */ state::invalid,   /* '%' */ character_type::percent,
+    /* size       -> other    -> */ state::invalid,   /* '&' */ character_type::other,
+    /* type       -> other    -> */ state::normal,    /* ''' */ character_type::other,
+    /* invalid    -> other    -> */ state::normal,    /* '(' */ character_type::other,
+    /* normal     -> percent  -> */ state::percent,   /* ')' */ character_type::other,
+    /* percent    -> percent  -> */ state::normal,    /* '*' */ character_type::star,
+    /* flag       -> percent  -> */ state::invalid,   /* '+' */ character_type::flag,
+    /* width      -> percent  -> */ state::invalid,   /* ',' */ character_type::other,
+    /* dot        -> percent  -> */ state::invalid,   /* '-' */ character_type::flag,
+    /* precision  -> percent  -> */ state::invalid,   /* '.' */ character_type::dot,
+    /* size       -> percent  -> */ state::invalid,   /* '/' */ character_type::other,
+    /* type       -> percent  -> */ state::percent,   /* '0' */ character_type::zero,
+    /* invalid    -> percent  -> */ state::normal,    /* '1' */ character_type::digit,
+    /* normal     -> dot      -> */ state::normal,    /* '2' */ character_type::digit,
+    /* percent    -> dot      -> */ state::dot,       /* '3' */ character_type::digit,
+    /* flag       -> dot      -> */ state::dot,       /* '4' */ character_type::digit,
+    /* width      -> dot      -> */ state::dot,       /* '5' */ character_type::digit,
+    /* dot        -> dot      -> */ state::invalid,   /* '6' */ character_type::digit,
+    /* precision  -> dot      -> */ state::invalid,   /* '7' */ character_type::digit,
+    /* size       -> dot      -> */ state::invalid,   /* '8' */ character_type::digit,
+    /* type       -> dot      -> */ state::normal,    /* '9' */ character_type::digit,
+    /* invalid    -> dot      -> */ state::normal,    /* ':' */ character_type::other,
+    /* normal     -> star     -> */ state::normal,    /* ';' */ character_type::other,
+    /* percent    -> star     -> */ state::width,     /* '<' */ character_type::other,
+    /* flag       -> star     -> */ state::width,     /* '=' */ character_type::other,
+    /* width      -> star     -> */ state::invalid,   /* '>' */ character_type::other,
+    /* dot        -> star     -> */ state::precision, /* '?' */ character_type::other,
+    /* precision  -> star     -> */ state::invalid,   /* '@' */ character_type::other,
+    /* size       -> star     -> */ state::invalid,   /* 'A' */ character_type::type,
+    /* type       -> star     -> */ state::normal,    /* 'B' */ character_type::other,
+    /* invalid    -> star     -> */ state::normal,    /* 'C' */ character_type::type,
+    /* normal     -> zero     -> */ state::normal,    /* 'D' */ character_type::other,
+    /* percent    -> zero     -> */ state::flag,      /* 'E' */ character_type::type,
+    /* flag       -> zero     -> */ state::flag,      /* 'F' */ character_type::size,
+    /* width      -> zero     -> */ state::width,     /* 'G' */ character_type::type,
+    /* dot        -> zero     -> */ state::precision, /* 'H' */ character_type::other,
+    /* precision  -> zero     -> */ state::precision, /* 'I' */ character_type::size,
+    /* size       -> zero     -> */ state::invalid,   /* 'J' */ character_type::other,
+    /* type       -> zero     -> */ state::normal,    /* 'K' */ character_type::other,
+    /* invalid    -> zero     -> */ state::normal,    /* 'L' */ character_type::size,
+    /* normal     -> digit    -> */ state::normal,    /* 'M' */ character_type::other,
+    /* percent    -> digit    -> */ state::width,     /* 'N' */ character_type::size,
+    /* flag       -> digit    -> */ state::width,     /* 'O' */ character_type::other,
+    /* width      -> digit    -> */ state::width,     /* 'P' */ character_type::other,
+    /* dot        -> digit    -> */ state::precision, /* 'Q' */ character_type::other,
+    /* precision  -> digit    -> */ state::precision, /* 'R' */ character_type::other,
+    /* size       -> digit    -> */ state::invalid,   /* 'S' */ character_type::type,
+    /* type       -> digit    -> */ state::normal,    /* 'T' */ character_type::size,
+    /* invalid    -> digit    -> */ state::normal,    /* 'U' */ character_type::other,
+    /* normal     -> flag     -> */ state::normal,    /* 'V' */ character_type::other,
+    /* percent    -> flag     -> */ state::flag,      /* 'W' */ character_type::other,
+    /* flag       -> flag     -> */ state::flag,      /* 'X' */ character_type::type,
+    /* width      -> flag     -> */ state::invalid,   /* 'Y' */ character_type::other,
+    /* dot        -> flag     -> */ state::invalid,   /* 'Z' */ character_type::type,
+    /* precision  -> flag     -> */ state::invalid,   /* '[' */ character_type::other,
+    /* size       -> flag     -> */ state::invalid,   /* '\' */ character_type::other,
+    /* type       -> flag     -> */ state::normal,    /* ']' */ character_type::other,
+    /* invalid    -> flag     -> */ state::normal,    /* '^' */ character_type::other,
+    /* normal     -> size     -> */ state::normal,    /* '_' */ character_type::other,
+    /* percent    -> size     -> */ state::size,      /* '`' */ character_type::other,
+    /* flag       -> size     -> */ state::size,      /* 'a' */ character_type::type,
+    /* width      -> size     -> */ state::size,      /* 'b' */ character_type::other,
+    /* dot        -> size     -> */ state::size,      /* 'c' */ character_type::type,
+    /* precision  -> size     -> */ state::size,      /* 'd' */ character_type::type,
+    /* size       -> size     -> */ state::size,      /* 'e' */ character_type::type,
+    /* type       -> size     -> */ state::normal,    /* 'f' */ character_type::type,
+    /* invalid    -> size     -> */ state::normal,    /* 'g' */ character_type::type,
+    /* normal     -> type     -> */ state::normal,    /* 'h' */ character_type::size,
+    /* percent    -> type     -> */ state::type,      /* 'i' */ character_type::type,
+    /* flag       -> type     -> */ state::type,      /* 'j' */ character_type::size,
+    /* width      -> type     -> */ state::type,      /* 'k' */ character_type::other,
+    /* dot        -> type     -> */ state::type,      /* 'l' */ character_type::size,
+    /* precision  -> type     -> */ state::type,      /* 'm' */ character_type::other,
+    /* size       -> type     -> */ state::type,      /* 'n' */ character_type::other,
+    /* type       -> type     -> */ state::normal,    /* 'o' */ character_type::type,
+    /* invalid    -> type     -> */ state::normal,    /* 'p' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'q' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'r' */ character_type::other,
+    /* unused                    */ state::normal,    /* 's' */ character_type::type,
+    /* unused                    */ state::normal,    /* 't' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'u' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'v' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'w' */ character_type::size,
+    /* unused                    */ state::normal,    /* 'x' */ character_type::type,
+    /* unused                    */ state::normal,    /* 'y' */ character_type::other,
+    /* unused                    */ state::normal,    /* 'z' */ character_type::size
+};
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Flags
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+enum FLAG : unsigned
+{
+    FL_SIGN       = 0x01, // Put plus or minus in front
+    FL_SIGNSP     = 0x02, // Put space or minus in front
+    FL_LEFT       = 0x04, // Left justify
+    FL_LEADZERO   = 0x08, // Pad with leading zeros
+    FL_SIGNED     = 0x10, // Signed data given
+    FL_ALTERNATE  = 0x20, // Alternate form requested
+    FL_NEGATIVE   = 0x40, // Value is negative
+    FL_FORCEOCTAL = 0x80, // Force leading '0' for octals
+};
+
+enum class length_modifier
+{
+    none,
+    hh,
+    h,
+    l,
+    ll,
+    j,
+    z,
+    t,
+    L,
+    I,
+    I32,
+    I64,
+    w,
+    T,
+    enumerator_count
+};
+
+inline size_t __cdecl to_integer_size(length_modifier const length) throw()
+{
+    switch (length)
+    {
+    case length_modifier::none: return sizeof(int      );
+    case length_modifier::hh:   return sizeof(char     );
+    case length_modifier::h:    return sizeof(short    );
+    case length_modifier::l:    return sizeof(long     );
+    case length_modifier::ll:   return sizeof(long long);
+    case length_modifier::j:    return sizeof(intmax_t );
+    case length_modifier::z:    return sizeof(size_t   );
+    case length_modifier::t:    return sizeof(ptrdiff_t);
+    case length_modifier::I:    return sizeof(void*    );
+    case length_modifier::I32:  return sizeof(int32_t  );
+    case length_modifier::I64:  return sizeof(int64_t  );
+    default:                    return 0;
+    }
+}
+
+template <typename Character>
+bool __cdecl is_wide_character_specifier(
+    uint64_t        const options,
+    Character       const format_type,
+    length_modifier const length
+    ) throw()
+{
+    UNREFERENCED_PARAMETER(options);
+
+    // If a length specifier was used, use that width:
+    switch (length)
+    {
+    case length_modifier::l: return true;
+    case length_modifier::w: return true;
+    case length_modifier::h: return false;
+    }
+
+    if (length == length_modifier::T)
+    {
+        return sizeof(Character) == sizeof(wchar_t);
+    }
+
+    bool const is_naturally_wide{
+        sizeof(Character) == sizeof(wchar_t) &&
+        (options & _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS) != 0
+    };
+
+    bool const is_natural_width{
+        format_type == 'c' ||
+        format_type == 's'
+    };
+
+    return is_naturally_wide == is_natural_width;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Core Base Classes
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The format processor consists of a set of base classes that form a single
+// inheritance hierarchy that looks like so:
+//
+//  * common_data
+//    * output_adapter_data
+//      * standard_base                   [1]
+//        * format_validation_base        [2]
+//          * positional_parameter_base   [3]
+//
+// There is a single class template, output_processor, which may be instantiated
+// to derive from any of the three bottom-most classes in the aforementioned
+// base class hierarchy (these are marked with the numbers 1-3). When it derives
+// from standard_base, it provides the standard formatted output functionality
+// as defined in the C Standard Library specification.  When it derives from the
+// format_validation_base, it provides that same functionality, but also checks
+// the format string for validity, and invokes the invalid parameter handler if
+// the format string is determined to be invalid.  Finally, if it derives from
+// the positional_parameter_base, it supports positional parameters.
+//
+// These three derivable bases allow us to implement the three forms of public
+// functions using a common implementation:  the standard, unsuffixed functions,
+// the format validating _s-suffixed functions, and the _p-suffixed functions
+// that permit positional parameter usage.
+//
+// There are no virtual functions used here:  each of the three functionality
+// bases "overrides" base class functionality by hiding it.  We must therefore
+// be cautious to ensure that functions are called in such a way that the right
+// implementation is called.
+template <typename Character>
+class common_data
+{
+protected:
+    common_data(__crt_cached_ptd_host& ptd)
+        : _options           {0            },
+          _ptd               {ptd          },
+          _format_it         {nullptr      },
+          _valist_it         {nullptr      },
+          _characters_written{0            },
+          _state             {state::normal},
+          _flags             {0            },
+          _field_width       {0            },
+          _precision         {0            },
+          _suppress_output   {false        },
+          _format_char       {'\0'         },
+          _string_length     {0            },
+          _string_is_wide    {false        }
+    {
+    }
+
+    uint64_t                        _options;
+
+    // We cache a reference to the PTD and updated locale information
+    // to avoid having to query thread-local storage for every character
+    // write that we perform.
+    __crt_cached_ptd_host&          _ptd;
+
+    // These two iterators control the formatting operation.  The format iterator
+    // iterates over the format string, and the va_list argument pointer iterates
+    // over the varargs arguments.
+    Character const*                _format_it;
+    va_list                         _valist_it;
+
+    // This stores the number of characters that have been written so far.  It is
+    // initialized to zero and is incremented as characters are written.  If an
+    // I/O error occurs, it is set to -1 to indicate the I/O failure.
+    int                             _characters_written;
+
+    // These represent the state for the current format specifier.  The suppress
+    // output flag is set when output should be suppressed for the current format
+    // specifier (note that this is distinct from the global suppression that we
+    // use during the first pass of positional parameter handling).
+    state                           _state;
+    unsigned                        _flags;
+    int                             _field_width;
+    int                             _precision;
+    length_modifier                 _length;
+    bool                            _suppress_output;
+
+    // This is the character from the format string that was used to compute the
+    // current state.  We need to store this separately because we advance the
+    // format string iterator at various points during processing.
+    Character                       _format_char;
+
+    // These pointers are used in various places to point to strings that either
+    // [1] are being formatted into, or [2] contain formatted data that is ready
+    // to be printed.  At any given time, we may have either a narrow string or
+    // a wide string, but never both.  The string length is the length of which-
+    // -ever string is currently present.  The wide flag is set if the wide string
+    // is currently in use.
+    union
+    {
+        char*                       _narrow_string;
+        wchar_t*                    _wide_string;
+    };
+
+    char*&    tchar_string(char   ) throw() { return _narrow_string; }
+    wchar_t*& tchar_string(wchar_t) throw() { return _wide_string;   }
+
+    Character*& tchar_string() throw() { return tchar_string(Character()); }
+
+    int                             _string_length;
+    bool                            _string_is_wide;
+
+    // The formatting buffer.  This buffer is used to store the result of various
+    // formatting operations--notably, numbers get formatted into strings in this
+    // buffer.
+    formatting_buffer               _buffer;
+};
+
+// This data base is split out from the common data base only so that we can
+// more easily value-initialize all of the members of the common data base.
+template <typename Character, typename OutputAdapter>
+class output_adapter_data
+    : protected common_data<Character>
+{
+protected:
+    output_adapter_data(
+        OutputAdapter      const& output_adapter,
+        uint64_t           const  options,
+        Character const*   const  format,
+        __crt_cached_ptd_host&    ptd,
+        va_list            const  arglist
+        ) throw()
+        : common_data{ptd},
+          _output_adapter(output_adapter)
+    {
+        // We initialize several base class data members here, so that we can
+        // value initialize the entire base class before we get to this point.
+        _options   = options;
+        _format_it = format;
+        _valist_it = arglist;
+    }
+
+    OutputAdapter _output_adapter;
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// standard_base
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This is the base class with which the format processor is instantiated to
+// provide "standard" printf formatting.
+template <typename Character, typename OutputAdapter>
+class standard_base
+    : protected output_adapter_data<Character, OutputAdapter>
+{
+protected:
+    template <typename... Ts>
+    standard_base(Ts&&... arguments) throw()
+        : output_adapter_data<Character, OutputAdapter>{arguments...     },
+          _current_pass      {pass::not_started}
+    {
+    }
+
+    bool advance_to_next_pass() throw()
+    {
+        _current_pass = static_cast<pass>(static_cast<unsigned>(_current_pass) + 1);
+        return _current_pass != pass::finished;
+    }
+
+    __forceinline bool validate_and_update_state_at_end_of_format_string() const throw()
+    {
+        // No validation is performed in the standard output implementation:
+        return true;
+    }
+
+    bool should_format() throw()
+    {
+        return true;
+    }
+
+    template <typename RequestedParameterType, typename ActualParameterType>
+    bool extract_argument_from_va_list(ActualParameterType& result) throw()
+    {
+        result = static_cast<ActualParameterType>(read_va_arg<RequestedParameterType>(_valist_it));
+
+        return true;
+    }
+
+    bool update_field_width() throw()
+    {
+        _field_width = read_va_arg<int>(_valist_it);
+        return true;
+    }
+
+    bool update_precision() throw()
+    {
+        _precision = read_va_arg<int>(_valist_it);
+        return true;
+    }
+
+    bool validate_state_for_type_case_a() const throw()
+    {
+        return true;
+    }
+
+    bool should_skip_normal_state_processing() throw()
+    {
+        return false;
+    }
+
+    bool validate_and_update_state_at_beginning_of_format_character() throw()
+    {
+        return true;
+    }
+
+    bool should_skip_type_state_output() const throw()
+    {
+        return false;
+    }
+
+    static unsigned state_count() throw()
+    {
+        return static_cast<unsigned>(state::type) + 1;
+    }
+
+    static printf_state_transition_table const& state_transition_table() throw()
+    {
+        return standard_lookup_table_spectre;
+    }
+
+private:
+
+    // In the standard format string processing, there is only one state, in
+    // which we both evaluate the format specifiers and format the parameters.
+    enum class pass : unsigned
+    {
+        not_started,
+        output,
+        finished
+    };
+
+    pass _current_pass;
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// format_validation_base
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This is the base class with which the format processor is instantiated to
+// provide "standard" printf formatting with additional validation of the format
+// string.
+template <typename Character, typename OutputAdapter>
+class format_validation_base
+    : protected standard_base<Character, OutputAdapter>
+{
+protected:
+    template <typename... Ts>
+    format_validation_base(Ts&&... arguments) throw()
+        : standard_base<Character, OutputAdapter>{arguments...}
+    {
+    }
+
+    __forceinline bool validate_and_update_state_at_end_of_format_string() throw()
+    {
+        // When we reach the end of the format string, we ensure that the format
+        // string is not incomplete.  I.e., when we are finished, the lsat thing
+        // that we should have encountered is a regular character to be written
+        // or a type specifier.  Otherwise, the format string was incomplete.
+        _UCRT_VALIDATE_RETURN(_ptd, _state == state::normal || _state == state::type, EINVAL, false);
+
+        return true;
+    }
+
+    static unsigned state_count() throw()
+    {
+        return static_cast<unsigned>(state::invalid) + 1;
+    }
+
+    static printf_state_transition_table const& state_transition_table() throw()
+    {
+        return format_validation_lookup_table_spectre;
+    }
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// positional_parameter_base
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This is the base class with which the format processor is instantiated to
+// provide support for the formatted output functions that permit positional
+// parameter references in the format string.  Note that when this base is used,
+// it also pulls in the format validation functionality.
+template <typename Character, typename OutputAdapter>
+class positional_parameter_base
+    : protected format_validation_base<Character, OutputAdapter>
+{
+protected:
+
+    typedef positional_parameter_base    self_type;
+    typedef format_validation_base       base_type;
+    typedef __crt_char_traits<Character> char_traits;
+
+    template <typename... Ts>
+    positional_parameter_base(Ts&&... arguments) throw()
+        : format_validation_base<Character, OutputAdapter>{arguments...     },
+          _current_pass         {pass::not_started},
+          _format_mode          {mode::unknown    },
+          _format               {_format_it       },
+          _type_index           {-1               },
+          _maximum_index        {-1               }
+    {
+        // Note that we do not zero-initialize the parameter data table until
+        // the first positional parameter is encountered in the format string.
+    }
+
+    bool advance_to_next_pass() throw()
+    {
+        _current_pass = static_cast<pass>(static_cast<unsigned>(_current_pass) + 1);
+        if (_current_pass == pass::finished)
+            return false;
+
+        // If we are in the output pass but the format string is a non-positional,
+        // ordinary format string, then we do not need a second pass:
+        if (_current_pass == pass::output && _format_mode == mode::nonpositional)
+            return false;
+
+        // All characters before the first format specifier are output in the
+        // first pass.  We reset the format mode to 'unknown' to ensure that
+        // they are not output again during the second pass.
+        _format_mode = mode::unknown;
+
+        _maximum_index = -1;
+        _type_index    = -1;
+
+        _field_width = 0;
+        _precision   = 0;
+        _format_it   = _format;
+
+        return true;
+    }
+
+    bool validate_and_update_state_at_end_of_format_string() throw()
+    {
+        if (!base_type::validate_and_update_state_at_end_of_format_string())
+            return false;
+
+        if (_format_mode != mode::positional || _current_pass != pass::position_scan)
+            return true;
+
+        // At the end of the first pass, we have the types filled into the
+        // arg_type member for each positional parameter.  We now need to get
+        // the argument pointer for each positional parameter and store it
+        // into the arg_ptr member.
+        parameter_data* const first{_parameters};
+        parameter_data* const last {_parameters + _maximum_index + 1};
+        for (parameter_data* it{first}; it != last; ++it)
+        {
+            it->_valist_it = _valist_it;
+
+            switch (it->_actual_type)
+            {
+            case parameter_type::int32:   read_va_arg<int        >(_valist_it); break;
+            case parameter_type::int64:   read_va_arg<__int64    >(_valist_it); break;
+            case parameter_type::pointer: read_va_arg<void*      >(_valist_it); break;
+            case parameter_type::real64:  read_va_arg<_CRT_DOUBLE>(_valist_it); break;
+
+            default:
+                // We should never reach this point:
+                _UCRT_VALIDATE_RETURN(_ptd, ("Missing position in the format string", 0), EINVAL, false);
+                break;
+            }
+        }
+
+        return true;
+    }
+
+    bool should_format() throw()
+    {
+        return _current_pass != pass::position_scan || _format_mode == mode::nonpositional;
+    }
+
+    template <typename RequestedParameterType, typename ActualParameterType>
+    bool extract_argument_from_va_list(ActualParameterType& result) throw()
+    {
+        if (_format_mode == mode::nonpositional)
+        {
+            return base_type::extract_argument_from_va_list<RequestedParameterType>(result);
+        }
+
+        _UCRT_VALIDATE_RETURN(_ptd, _type_index >= 0 && _type_index < _ARGMAX, EINVAL, false);
+
+        if (_current_pass == pass::position_scan)
+        {
+            return validate_and_store_parameter_data(
+                _parameters[_type_index],
+                get_parameter_type(RequestedParameterType()),
+                _format_char,
+                _length
+            );
+        }
+        else
+        {
+            result = static_cast<ActualParameterType>(peek_va_arg<RequestedParameterType>(_parameters[_type_index]._valist_it));
+            return true;
+        }
+    }
+
+    bool update_field_width() throw()
+    {
+        if (_format_mode == mode::nonpositional)
+        {
+            return base_type::update_field_width();
+        }
+
+        Character* end_pointer{nullptr};
+        int const width_index{_tcstol_internal(_ptd, _format_it, &end_pointer, 10) - 1};
+        _format_it = end_pointer + 1;
+
+        if (_current_pass == pass::position_scan)
+        {
+            _UCRT_VALIDATE_RETURN(_ptd, width_index >= 0 && *end_pointer == '$' && width_index < _ARGMAX, EINVAL, false);
+
+            _maximum_index = width_index > _maximum_index
+                ? width_index
+                : _maximum_index;
+
+            return validate_and_store_parameter_data(
+                _parameters[width_index],
+                parameter_type::int32,
+                _format_char,
+                _length
+            );
+        }
+        else
+        {
+            _field_width = peek_va_arg<int>(_parameters[width_index]._valist_it);
+        }
+
+        return true;
+    }
+
+    bool update_precision() throw()
+    {
+        if (_format_mode == mode::nonpositional)
+        {
+            return base_type::update_precision();
+        }
+
+        Character* end_pointer{nullptr};
+        int const precision_index{_tcstol_internal(_ptd, _format_it, &end_pointer, 10) - 1};
+        _format_it = end_pointer + 1;
+
+        if (_current_pass == pass::position_scan)
+        {
+            _UCRT_VALIDATE_RETURN(_ptd, precision_index >= 0 && *end_pointer == '$' && precision_index < _ARGMAX, EINVAL, false);
+
+            _maximum_index = precision_index > _maximum_index
+                ? precision_index
+                : _maximum_index;
+
+            return validate_and_store_parameter_data(
+                _parameters[precision_index],
+                parameter_type::int32,
+                _format_char,
+                _length
+            );
+        }
+        else
+        {
+            _precision = peek_va_arg<int>(_parameters[precision_index]._valist_it);
+        }
+
+        return true;
+    }
+
+    bool validate_state_for_type_case_a() throw()
+    {
+        if (_format_mode == mode::positional && _current_pass == pass::position_scan)
+        {
+            _UCRT_VALIDATE_RETURN(_ptd, _type_index >= 0 && _type_index < _ARGMAX, EINVAL, false);
+            return validate_and_store_parameter_data(
+                _parameters[_type_index],
+                parameter_type::real64,
+                _format_char,
+                _length
+            );
+        }
+
+        return true;
+    }
+
+    bool should_skip_normal_state_processing() throw()
+    {
+        if (_current_pass == pass::position_scan && _format_mode == mode::positional)
+            return true;
+
+        if (_current_pass == pass::output && _format_mode == mode::unknown)
+            return true;
+
+        // We do not output during the first pass if we have already come across
+        // a positional format specifier.  All characters before the first format
+        // specifier are output in the first pass.  We need to check the format
+        // type during the second pass to ensure that they are not output a second
+        // time.
+        return false;
+    }
+
+    bool validate_and_update_state_at_beginning_of_format_character() throw()
+    {
+        // We're looking for a format specifier, so we'll have just seen a '%'
+        // and the next character is not a '%':
+        if (_state != state::percent || *_format_it == '%')
+            return true;
+
+        // When we encounter the first format specifier, we determine whether
+        // the format string is a positional format string or a standard format
+        // string.
+        if (_format_mode == mode::unknown)
+        {
+            Character* end_pointer{nullptr};
+
+            // Only digits are permitted between the % and the $ in the positional format specifier.
+            if (*_format_it < '0' || *_format_it > '9')
+            {
+                _format_mode = mode::nonpositional;
+            }
+            else if (_tcstol_internal(_ptd, _format_it, &end_pointer, 10) > 0 && *end_pointer == '$')
+            {
+                if (_current_pass == pass::position_scan)
+                {
+                    memset(_parameters, 0, sizeof(_parameters));
+                }
+
+                _format_mode = mode::positional;
+            }
+            else
+            {
+                _format_mode = mode::nonpositional;
+            }
+        }
+
+        if (_format_mode != mode::positional)
+        {
+            return true;
+        }
+
+        Character* end_pointer{nullptr};
+        _type_index = _tcstol_internal(_ptd, _format_it, &end_pointer, 10) - 1;
+        _format_it = end_pointer + 1;
+
+        if (_current_pass != pass::position_scan)
+            return true;
+
+        // We do not re-perform the type validations during the second pass...
+        _UCRT_VALIDATE_RETURN(_ptd, _type_index >= 0 && *end_pointer == '$' && _type_index < _ARGMAX, EINVAL, false);
+
+        _maximum_index = _type_index > _maximum_index
+            ? _type_index
+            : _maximum_index;
+
+        return true;
+    }
+
+    bool should_skip_type_state_output() const throw()
+    {
+        return _format_mode == mode::positional && _current_pass == pass::position_scan;
+    }
+
+private:
+
+    // Positional parameter processing occurs in two passes.  In the first pass,
+    // we scan the format string to accumulate type information for the
+    // positional parameters.  If the format string is a standard format string
+    // (that does not use positional parameters), then this pass also does the
+    // output.  Otherwise, if the format string uses positional parameters,
+    // the actual output operation takes place in the second pass, after we've
+    // aggregated all of the information about the positional parameters.
+    enum class pass : unsigned
+    {
+        not_started,
+        position_scan,
+        output,
+        finished
+    };
+
+    // These represent the two modes of formatting.  The processor starts off in
+    // the unknown mode and can transition to either nonpositional (indicating
+    // standard format string processing) or positional mode.
+    enum class mode : unsigned
+    {
+        unknown,
+        nonpositional,
+        positional
+    };
+
+    // These represent the different types of parameters that may be present in
+    // the argument list (remember that integral types narrower than int and
+    // real types narrower than double are promoted for the varargs call).
+    enum class parameter_type : unsigned
+    {
+        unused,
+        int32,
+        int64,
+        pointer,
+        real64
+    };
+
+    // This represents a parameter in the varargs list, along with information
+    // we have about the parameter from the format string.  We store an array
+    // of these structures internally, and the structures are updated in several
+    // steps.  They start off uninitialized, with the "unused" actual type.  If
+    // the format string uses positional parameters, then the actual type, format
+    // type, and flags are updated during the positional scan of the format
+    // string.  At the end of that scan, we iterate over the parameters and the
+    // varargs array to fill in the argptr for each of the positional parameters.
+    struct parameter_data
+    {
+        parameter_type  _actual_type;
+        Character       _format_type;
+
+        va_list         _valist_it;
+        length_modifier _length;
+    };
+
+    // These provide transformations from the source parameter types to their
+    // underlying representation enumerators (from the parameter_type enum).
+    template <typename T>
+    static parameter_type __cdecl get_parameter_type(T*              ) throw() { return parameter_type::pointer; }
+    static parameter_type __cdecl get_parameter_type(short           ) throw() { return parameter_type::int32;   }
+    static parameter_type __cdecl get_parameter_type(unsigned short  ) throw() { return parameter_type::int32;   }
+    static parameter_type __cdecl get_parameter_type(wchar_t         ) throw() { return parameter_type::int32;   }
+    static parameter_type __cdecl get_parameter_type(int             ) throw() { return parameter_type::int32;   }
+    static parameter_type __cdecl get_parameter_type(unsigned int    ) throw() { return parameter_type::int32;   }
+    static parameter_type __cdecl get_parameter_type(__int64         ) throw() { return parameter_type::int64;   }
+    static parameter_type __cdecl get_parameter_type(unsigned __int64) throw() { return parameter_type::int64;   }
+    static parameter_type __cdecl get_parameter_type(_CRT_DOUBLE     ) throw() { return parameter_type::real64;  }
+
+    // With positional parameters, a given parameter may be used multiple times
+    // in a format string.  All appearances of a given parameter must be
+    // consistent (they must match in type and width).  The first time a given
+    // parameter appears, it is accepted as-is.  Each subsequent time that it
+    // reappears, this function is called to ensure that the reappearance is
+    // consistent with the previously processed appearance.
+    //
+    // Returns true if the reappearance is consistent (and valid).  Returns false
+    // otherwise.  This function does not invoke invalid parameter handling.
+    bool is_positional_parameter_reappearance_consistent(
+        parameter_data  const& parameter,
+        parameter_type  const  actual_type,
+        Character       const  format_type,
+        length_modifier const  length
+        ) throw()
+    {
+        // Pointer format specifiers are exclusive; a parameter that previously
+        // appeared as a pointer may not reappear as a non-pointer, and vice-
+        // versa.
+        bool const old_is_pointer{is_pointer_specifier(parameter._format_type)};
+        bool const new_is_pointer{is_pointer_specifier(format_type)};
+        if (old_is_pointer || new_is_pointer)
+        {
+            return old_is_pointer == new_is_pointer;
+        }
+
+        // String format specifiers are exclusive, just like pointer specifiers.
+        // We must also ensure that the two appearances match in string type:
+        // either both must be wide or both must be narrow.
+        bool const old_is_string{is_string_specifier(parameter._format_type)};
+        bool const new_is_string{is_string_specifier(format_type)};
+
+        bool const old_is_character{is_character_specifier(parameter._format_type)};
+        bool const new_is_character{is_character_specifier(format_type)};
+        if (old_is_string || new_is_string || old_is_character || new_is_character)
+        {
+            if (old_is_string != new_is_string || old_is_character != new_is_character)
+                return false;
+
+            bool const old_is_wide{is_wide_character_specifier(_options, parameter._format_type, parameter._length)};
+            bool const new_is_wide{is_wide_character_specifier(_options, format_type, length)};
+            if (old_is_wide != new_is_wide)
+                return false;
+
+            return true;
+        }
+
+        // Numeric specifiers are exclusive:  either both appearances must be
+        // numeric specifiers or neither appearance may be a numeric specifier.
+        // Additionally, if both appearances are numeric specifiers, they must
+        // both have the same width.
+        bool const old_is_integral{is_integral_specifier(parameter._format_type)};
+        bool const new_is_integral{is_integral_specifier(format_type)};
+        if (old_is_integral || new_is_integral)
+        {
+            if (old_is_integral != new_is_integral)
+                return false;
+
+            if ((parameter._length == length_modifier::I) != (length == length_modifier::I))
+                return false;
+
+            return to_integer_size(parameter._length) == to_integer_size(length);
+        }
+
+        return parameter._actual_type == actual_type;
+    }
+
+    bool validate_and_store_parameter_data(
+        parameter_data       & parameter,
+        parameter_type  const  actual_type,
+        Character       const  format_type,
+        length_modifier const  length
+        ) throw()
+    {
+        if (parameter._actual_type == parameter_type::unused)
+        {
+            parameter._actual_type = actual_type;
+            parameter._format_type = format_type;
+            parameter._length      = length;
+        }
+        else
+        {
+            _UCRT_VALIDATE_RETURN(_ptd, is_positional_parameter_reappearance_consistent(
+                parameter, actual_type, format_type, length
+            ), EINVAL, false);
+        }
+
+        return true;
+    }
+
+    template <typename Character>
+    static bool __cdecl is_pointer_specifier(Character const specifier) throw()
+    {
+        return specifier == 'p';
+    }
+
+    template <typename Character>
+    static bool __cdecl is_string_specifier(Character const specifier) throw()
+    {
+        return specifier == 's' || specifier == 'S';
+    }
+
+    template <typename Character>
+    static bool __cdecl is_character_specifier(Character const specifier) throw()
+    {
+        return specifier == 'c' || specifier == 'C';
+    }
+
+    template <typename Character>
+    static bool __cdecl is_integral_specifier(Character const specifier) throw()
+    {
+        return specifier == 'd' || specifier == 'i' || specifier == 'o'
+            || specifier == 'u' || specifier == 'x' || specifier == 'X'
+            || specifier == '*';
+    }
+
+    pass _current_pass;
+    mode _format_mode;
+
+    // The original format pointer, which allows us to reset the format iterator
+    // between the two passes used in positional parameter processing.
+    Character const* _format;
+
+    // The array of positional parameters used in the format string.
+    parameter_data _parameters[_ARGMAX];
+
+    // These are indices into the _parameters array.  They hold the maximum
+    // positional parameter index that has been seen so far and the index of the
+    // current format specifier.  Until a positional parameter is encountered in
+    // the format string, these have the value -1.
+    int _maximum_index;
+    int _type_index;
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// output_processor
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This is the main output processor class, which performs the format string
+// processing and formats the varargs arguments appropriately.  It delegates to
+// the provided ProcessorBase for certain parts of the functionality.  It is
+// expected that the ProcessorBase argument is one of the base class types
+// defined above.
+template <typename Character, typename OutputAdapter, typename ProcessorBase>
+class output_processor
+    : private ProcessorBase
+{
+public:
+
+    typedef __acrt_stdio_char_traits<Character> char_traits;
+
+    output_processor(
+        OutputAdapter      const& output_adapter,
+        uint64_t           const  options,
+        Character const*   const  format,
+        __crt_cached_ptd_host&    ptd,
+        va_list            const  arglist
+        ) throw()
+        : ProcessorBase{output_adapter, options, format, ptd, arglist}
+    {
+    }
+
+    // After construction, this function is called to evaluate the formatted
+    // output operation.  This function must be called exactly once, immediately
+    // after constructing the object.
+    int process() throw()
+    {
+        if (!_output_adapter.validate(_ptd))
+        {
+            return -1;
+        }
+
+        _UCRT_VALIDATE_RETURN(_ptd, _format_it != nullptr, EINVAL, -1);
+
+        while (advance_to_next_pass())
+        {
+            // At the start of each pass, we have no buffered string and we are
+            // in the normal state:
+            _string_length = 0;
+            _state         = state::normal;
+
+            // Iterate over the format string until we reach the end, encounter
+            // an I/O error, or fail due to some other error:
+            while ((_format_char = *_format_it++) != '\0' && _characters_written >= 0)
+            {
+                _state = find_next_state(_format_char, _state);
+
+                if (!validate_and_update_state_at_beginning_of_format_character())
+                {
+                    return -1;
+                }
+
+                if (_state >= state::invalid)
+                {
+                    _UCRT_VALIDATE_RETURN(_ptd, ("Incorrect format specifier", 0), EINVAL, -1);
+                }
+
+                bool result = false;
+
+                switch (_state)
+                {
+                case state::normal:    result = state_case_normal   (); break;
+                case state::percent:   result = state_case_percent  (); break;
+                case state::flag:      result = state_case_flag     (); break;
+                case state::width:     result = state_case_width    (); break;
+                case state::dot:       result = state_case_dot      (); break;
+                case state::precision: result = state_case_precision(); break;
+                case state::size:      result = state_case_size     (); break;
+                case state::type:      result = state_case_type     (); break;
+                }
+
+                // If the state-specific operation failed, return immediately.
+                // The individual state cases are responsible for invoking the
+                // invalid parameter handler if the failure is due to an invalid
+                // parameter.
+                if (!result)
+                    return -1;
+            }
+
+            if (!validate_and_update_state_at_end_of_format_string())
+                return -1;
+        }
+
+        return _characters_written;
+    }
+
+private:
+
+    // The normal state is entered when a character that is not part of a format
+    // specifier is encountered in the format string.  We simply write the
+    // character.  There are four parts to the normal state:  the state_case_normal
+    // function is called when the state is entered.  It tests whether the actual
+    // output operation should take place.  The state_case_normal_common function
+    // performs the actual output operation and is called from elsewhere in this
+    // class.
+    __forceinline bool state_case_normal() throw()
+    {
+        if (should_skip_normal_state_processing())
+            return true;
+
+        _UCRT_VALIDATE_RETURN(_ptd, state_case_normal_common(), EINVAL, false);
+
+        return true;
+    }
+
+    __forceinline bool state_case_normal_common() throw()
+    {
+        if (!state_case_normal_tchar(Character()))
+            return false;
+
+        _output_adapter.write_character(_format_char, &_characters_written, _ptd);
+        return true;
+    }
+
+    __forceinline bool state_case_normal_tchar(char) throw()
+    {
+        _string_is_wide = false;
+
+        if (__acrt_isleadbyte_l_noupdate(_format_char, _ptd.get_locale()))
+        {
+            _output_adapter.write_character(_format_char, &_characters_written, _ptd);
+            _format_char = *_format_it++;
+
+            // Ensure that we do not fall off the end of the format string:
+            _UCRT_VALIDATE_RETURN(_ptd, _format_char != '\0', EINVAL, false);
+        }
+
+        return true;
+    }
+
+    __forceinline bool state_case_normal_tchar(wchar_t) throw()
+    {
+        _string_is_wide = true;
+        return true;
+    }
+
+    // We enter the percent state when we read a '%' from the format string.  The
+    // percent sign begins a format specifier, so we reset our internal state for
+    // the new format specifier.
+    __forceinline bool state_case_percent() throw()
+    {
+        _field_width     =  0;
+        _suppress_output =  false;
+        _flags           =  0;
+        _precision       = -1;
+        _length          =  length_modifier::none;
+        _string_is_wide  =  false;
+
+        return true;
+    }
+
+    // We enter the flag state when we are reading a format specifier and we
+    // encounter one of the optional flags.  We update our state to account for
+    // the flag.
+    __forceinline bool state_case_flag() throw()
+    {
+        // Set the flag based on which flag character:
+        switch (_format_char)
+        {
+        case '-': set_flag(FL_LEFT     ); break; // '-' => left justify
+        case '+': set_flag(FL_SIGN     ); break; // '+' => force sign indicator
+        case ' ': set_flag(FL_SIGNSP   ); break; // ' ' => force sign or space
+        case '#': set_flag(FL_ALTERNATE); break; // '#' => alternate form
+        case '0': set_flag(FL_LEADZERO ); break; // '0' => pad with leading zeros
+        }
+
+        return true;
+    }
+
+    // Parses an integer from the format string.  It is expected in this function
+    // that it is called _after_ the format string iterator has been advanced to
+    // the next character, so it starts parsing from _format_it - 1 (i.e., from
+    // the character currently being processed, a copy of which is stored in
+    // the _format_char data member).
+    bool parse_int_from_format_string(int* const result) throw()
+    {
+        auto const reset_errno = _ptd.get_errno().create_guard();
+
+        Character* end{};
+        *result = static_cast<int>(_tcstol_internal(_ptd,
+            _format_it - 1,
+            &end,
+            10));
+
+        if (_ptd.get_errno().check(ERANGE))
+        {
+            return false;
+        }
+
+        if (end < _format_it)
+        {
+            return false;
+        }
+
+        _format_it = end;
+        return true;
+    }
+
+    // We enter the width state when we are reading a format specifier and we
+    // encounter either an asterisk (indicating the width should be read from
+    // the varargs) or a digit (indicating that we are in the process of reading
+    // the width from the format string.
+    __forceinline bool state_case_width() throw()
+    {
+        if (_format_char != '*')
+        {
+            return parse_int_from_format_string(&_field_width);
+        }
+
+        // If the format character is an asterisk, we read the width from the
+        // varargs.  If we read a negative value, we treat it as the '-' flag
+        // followed by a positive width (per the C Standard Library spec).
+        if (!update_field_width())
+            return false;
+
+        if (!should_format())
+            return true;
+
+        if (_field_width < 0)
+        {
+            set_flag(FL_LEFT);
+            _field_width = -_field_width;
+        }
+
+        return true;
+    }
+
+    // We enter the dot state when we read a '.' from the format string.  This
+    // '.' introduces the precision part of the format specifier.
+    __forceinline bool state_case_dot() throw()
+    {
+        // Reset the precision to zero.  If the dot is not followed by a number,
+        // it means a precision of zero, not the default precision (per the C
+        // Standard Library specification).  (Note:  We represent the default
+        // precision with -1.)
+        _precision = 0;
+
+        return true;
+    }
+
+    // We enter the precision state after we read a ',' from the format string.
+    // At this point, we read the precision, in a manner similar to how we read
+    // the width.
+    __forceinline bool state_case_precision() throw()
+    {
+        if (_format_char != '*')
+        {
+            return parse_int_from_format_string(&_precision);
+        }
+
+        // If the format character is an asterisk, we read the width from the
+        // varargs.  If we read a negative value, we treat it as indicating the
+        // default precision.
+        if (!update_precision())
+            return false;
+
+        if (!should_format())
+            return true;
+
+        if (_precision < 0)
+            _precision = -1;
+
+        return true;
+    }
+
+    // We enter the size state when we have read one of the size characters from
+    // the format string.
+    bool state_case_size() throw()
+    {
+        if (_format_char == 'F')
+        {
+            // We hand the 'F' character as a length modifier because the length
+            // modifier occurs before the type specifier.  If we find an 'F' and
+            // we are in the legacy compatibility mode that supports the 'F' length
+            // modifier, we just ignore it (it has no meaning).  Otherwise we are
+            // not in compatibility mode so we switch out to the type case to handle
+            // the 'F' as a %F format specifier:
+            if ((_options & _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
+            {
+                _state = state::type;
+                return state_case_type();
+            }
+
+            return true;
+        }
+
+        if (_format_char == 'N')
+        {
+            // If we find an 'N' and we are in the legacy compatibility mode that
+            // supports the 'N' length modifier, we just ignore it (it has no
+            // meaning).  Otherwise, we are not in compatibility mode, so we
+            // invoke the invalid parameter handler and return failure.
+            if ((_options & _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
+            {
+                _state = state::invalid;
+#pragma warning(suppress: __WARNING_IGNOREDBYCOMMA) // 6319 comma operator
+                _UCRT_VALIDATE_RETURN(_ptd, ("N length modifier not specifier", false), EINVAL, false);
+                return false;
+            }
+
+            return true;
+        }
+
+        _UCRT_VALIDATE_RETURN(_ptd, _length == length_modifier::none, EINVAL, false);
+
+        // We just read a size specifier; set the flags based on it:
+        switch (_format_char)
+        {
+        case 'h':
+        {
+            if (*_format_it == 'h')
+            {
+                ++_format_it;
+                _length = length_modifier::hh;
+            }
+            else
+            {
+                _length = length_modifier::h;
+            }
+
+            return true;
+        }
+
+        case 'I':
+        {
+            // The I32, I64, and I length modifiers are Microsoft extensions.
+
+            if (*_format_it == '3' && *(_format_it + 1) == '2')
+            {
+                _format_it += 2;
+                _length = length_modifier::I32;
+            }
+            else if (*_format_it == '6' && *(_format_it + 1) == '4')
+            {
+                _format_it += 2;
+                _length = length_modifier::I64;
+            }
+            else if (*_format_it == 'd' ||
+                     *_format_it == 'i' ||
+                     *_format_it == 'o' ||
+                     *_format_it == 'u' ||
+                     *_format_it == 'x' ||
+                     *_format_it == 'X')
+            {
+                // If we support positional parameters, then %I without a following
+                // 32 or 64 is platform-dependent:
+                _length = length_modifier::I;
+            }
+
+            return true;
+        }
+
+        case 'l':
+        {
+            if (*_format_it == 'l')
+            {
+                ++_format_it;
+                _length = length_modifier::ll;
+            }
+            else
+            {
+                _length = length_modifier::l;
+            }
+
+            return true;
+        }
+
+        case 'L':
+        {
+            _length = length_modifier::L;
+            return true;
+        }
+
+        case 'j':
+        {
+            _length = length_modifier::j;
+            return true;
+        }
+
+        case 't':
+        {
+            _length = length_modifier::t;
+            return true;
+        }
+
+        case 'z':
+        {
+            _length = length_modifier::z;
+            return true;
+        }
+
+        case 'w':
+        {
+            _length = length_modifier::w;
+            return true;
+        }
+
+        case 'T':
+        {
+            _length = length_modifier::T;
+            return true;
+        }
+        }
+
+        return true;
+    }
+
+    // We enter the type case when we read the type part of the format specifier.
+    // At this point, we have read the entire format specifier and we can extract
+    // the value to be formatted from the varargs, format it, then output it.
+    // This state is broken up into subfunctions, one per type category.
+    bool state_case_type() throw()
+    {
+        // Each of the subfunctions is responsible for [1] extracting the next
+        // argument from the varargs, [2] formatting that argument into the
+        // internal buffer, and [3] updating the string state variables with
+        // the correct data for the format operation (either _narrow_string or
+        // _wide_string must be set correctly, the _string_length must be set
+        // correctly, and _string_is_wide must be true if the wide string
+        // should be used.
+        bool result{false};
+        switch (_format_char)
+        {
+        // Individual character output:
+        case 'C':
+        case 'c': result = type_case_c(); break;
+
+        // String output:
+        case 'Z': result = type_case_Z(); break;
+        case 'S':
+        case 's': result = type_case_s(); break;
+
+        // Floating-point output:
+        case 'A':
+        case 'E':
+        case 'F':
+        case 'G':
+        case 'a':
+        case 'e':
+        case 'f':
+        case 'g': result = type_case_a(); break;
+
+        // Integer and pointer output:
+        case 'd':
+        case 'i': result = type_case_d(); break;
+        case 'u': result = type_case_u(); break;
+        case 'o': result = type_case_o(); break;
+        case 'X': result = type_case_X(); break;
+        case 'x': result = type_case_x(); break;
+        case 'p': result = type_case_p(); break;
+
+        // State reporting (no output):
+        case 'n': result = type_case_n(); break;
+        }
+
+        // If the case-specific logic failed, return immediately.  The case-
+        // specific function is responsible for invoking the invalid parameter
+        // handler if it needs to do so.
+        if (!result)
+            return false;
+
+        // Check to see whether the output operation should be skipped (we skip
+        // the output part e.g. during the positional scan pass when positional
+        // formatting is used).
+        if (should_skip_type_state_output())
+            return true;
+
+        // At this point, we've completed the bulk of the formatting operation
+        // and the string is ready to be printed.  We now justify the string,
+        // pre-pend any required prefix and leading zeroes, then print it.  Well,
+        // unless output is suppressed, that is... :-)
+        if (_suppress_output)
+            return true;
+
+        // Compute the prefix, if one is required...
+        Character  prefix[3]{};
+        size_t     prefix_length{0};
+
+        if (has_flag(FL_SIGNED))
+        {
+            if (has_flag(FL_NEGATIVE))
+            {
+                prefix[prefix_length++] = '-';
+            }
+            else if (has_flag(FL_SIGN))
+            {
+                prefix[prefix_length++] = '+';
+            }
+            else if (has_flag(FL_SIGNSP))
+            {
+                prefix[prefix_length++] = ' ';
+            }
+        }
+
+        bool const print_integer_0x{(_format_char == 'x' || _format_char == 'X') && has_flag(FL_ALTERNATE)};
+        bool const print_floating_point_0x{_format_char == 'a' || _format_char == 'A'};
+
+        if (print_integer_0x || print_floating_point_0x)
+        {
+            prefix[prefix_length++] = '0';
+            prefix[prefix_length++] = adjust_hexit('x' - 'a' + '9' + 1, _format_char == 'X' || _format_char == 'A');
+        }
+
+        // Compute the amount of padding required to get to the desired field
+        // width, then output the left padding, prefix, leading zeroes, the
+        // string, and right padding, in that order.
+        int const padding = static_cast<int>(_field_width - _string_length - prefix_length);
+
+        if (!has_flag(FL_LEFT | FL_LEADZERO))
+        {
+            // Left-pad with spaces
+            write_multiple_characters(_output_adapter, ' ', padding, &_characters_written, _ptd);
+        }
+
+        // Write the prefix
+        _output_adapter.write_string(prefix, static_cast<int>(prefix_length), &_characters_written, _ptd);
+
+        if (has_flag(FL_LEADZERO) && !has_flag(FL_LEFT))
+        {
+            // Write leading zeroes
+            write_multiple_characters(_output_adapter, '0', padding, &_characters_written, _ptd);
+        }
+
+        // Write the string
+        write_stored_string_tchar(Character());
+
+        if (_characters_written >= 0 && has_flag(FL_LEFT))
+        {
+            // Right-pad with spaces
+            write_multiple_characters(_output_adapter, ' ', padding, &_characters_written, _ptd);
+        }
+
+        return true;
+    }
+
+    // Individual character output:  The 'C' and 'c' format specifiers output an
+    // individual wide or narrow character, respectively.  They both delegate to
+    // the type_case_c_tchar() overloads, which handle the output appropriately
+    // for the character type of the output adapter.
+    bool type_case_c() throw()
+    {
+        return type_case_c_tchar(Character());
+    }
+
+    bool type_case_c_tchar(char) throw()
+    {
+        // If the character is a wide character, we translate it to multibyte
+        // to be output, storing the multibyte string in the internal buffer:
+        if (is_wide_character_specifier(_options, _format_char, _length))
+        {
+            wchar_t wide_character{};
+            if (!extract_argument_from_va_list<wchar_t>(wide_character))
+            {
+                return false;
+            }
+
+            if (!should_format())
+            {
+                return true;
+            }
+
+            // Convert to multibyte.  If the conversion fails, we suppress the
+            // output operation but we do not fail the entire operation:
+            errno_t const status{_wctomb_internal(&_string_length, _buffer.data<char>(), _buffer.count<char>(), wide_character, _ptd)};
+            if (status != 0)
+            {
+                _suppress_output = true;
+            }
+        }
+        // If the character is a narrow character, we can just write it directly
+        // to the output, as-is.
+        else
+        {
+            if (!extract_argument_from_va_list<unsigned short>(_buffer.data<char>()[0]))
+            {
+                return false;
+            }
+
+            if (!should_format())
+            {
+                return true;
+            }
+
+            _string_length = 1;
+        }
+
+        _narrow_string = _buffer.data<char>();
+        return true;
+    }
+
+    bool type_case_c_tchar(wchar_t) throw()
+    {
+        // If the output adapter accepts wide characters, then we must transform
+        // the character into a wide character to be output.
+        _string_is_wide = true;
+
+        wchar_t wide_character{};
+        if (!extract_argument_from_va_list<wchar_t>(wide_character))
+            return false;
+
+        if (!should_format())
+            return true;
+
+        if (!is_wide_character_specifier(_options, _format_char, _length))
+        {
+            // If the character is actually a multibyte character, then we must
+            // transform it into the equivalent wide character.  If the translation
+            // is unsuccessful, we ignore this character but do not fail the entire
+            // output operation.
+            char const local_buffer[2]{ static_cast<char>(wide_character & 0x00ff), '\0' };
+            int const mbc_length{_mbtowc_internal(
+                _buffer.data<wchar_t>(),
+                local_buffer,
+                _ptd.get_locale()->locinfo->_public._locale_mb_cur_max,
+                _ptd
+                )};
+            if (mbc_length < 0)
+            {
+                _suppress_output = true;
+            }
+        }
+        else
+        {
+            _buffer.data<wchar_t>()[0] = wide_character;
+        }
+
+        _wide_string   = _buffer.data<wchar_t>();
+        _string_length = 1;
+        return true;
+    }
+
+    // String Output:  The Z, S, and s format specifiers output a string.  The Z
+    // format specifier is an extension, used to print a Windows SDK ANSI_STRING
+    // or UNICODE_STRING counted string.  The S and s format specifiers output a
+    // wide or narrow C string, respectively.  If a null pointer is passed, we
+    // replace it with a special sentinel string, with the contents "(null)".
+    bool type_case_Z() throw()
+    {
+        // This matches the representation of the Windows SDK types ANSI_STRING
+        // and UNICODE_STRING, which represent a counted string.
+        struct ansi_string
+        {
+            unsigned short _length;
+            unsigned short _maximum_length;
+            char*          _buffer;
+        };
+
+        ansi_string* string{};
+        if (!extract_argument_from_va_list<ansi_string*>(string))
+            return false;
+
+        if (!should_format())
+            return true;
+
+        if (!string || string->_buffer == nullptr)
+        {
+            _narrow_string  = narrow_null_string();
+            _string_length  = static_cast<int>(strlen(_narrow_string));
+            _string_is_wide = false;
+        }
+        else if (is_wide_character_specifier(_options, _format_char, _length))
+        {
+            _wide_string    = reinterpret_cast<wchar_t*>(string->_buffer);
+            _string_length  = string->_length / static_cast<int>(sizeof(wchar_t));
+            _string_is_wide = true;
+        }
+        else
+        {
+            _narrow_string  = string->_buffer;
+            _string_length  = string->_length;
+            _string_is_wide = false;
+        }
+
+        return true;
+    }
+
+    bool type_case_s() throw()
+    {
+        // If this format specifier has the default precision, then the entire
+        // string is output.  If a precision is given, then we output the minimum
+        // of the length of the C string and the given precision.  Note that the
+        // string needs not be null-terminated if a precision is given, so we
+        // cannot call strlen to compute the length of the string.
+        if (!extract_argument_from_va_list<char*>(_narrow_string))
+            return false;
+
+        if (!should_format())
+            return true;
+
+        int const maximum_length{(_precision == -1) ? INT_MAX : _precision};
+
+        if (is_wide_character_specifier(_options, _format_char, _length))
+        {
+            if (!_wide_string)
+                _wide_string = wide_null_string();
+
+            _string_is_wide = true;
+            _string_length  = static_cast<int>(wcsnlen(_wide_string, maximum_length));
+        }
+        else
+        {
+            if (!_narrow_string)
+                _narrow_string = narrow_null_string();
+
+            _string_length = type_case_s_compute_narrow_string_length(maximum_length, Character());
+        }
+
+        return true;
+    }
+
+    // We have two different implementations of the 's' type case, to handle
+    // narrow and wide strings, since computation of the length is subtly
+    // different depending on whether we are outputting narrow or wide
+    // characters.  These functions just update the string state appropriately
+    // for the string that has just been read from the varargs.
+    int type_case_s_compute_narrow_string_length(int const maximum_length, char) throw()
+    {
+        return static_cast<int>(strnlen(_narrow_string, maximum_length));
+    }
+
+    int type_case_s_compute_narrow_string_length(int const maximum_length, wchar_t) throw()
+    {
+        _locale_t locale = _ptd.get_locale();
+
+        if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
+        {
+            int string_length{0};
+
+            for (char const* p{_narrow_string}; string_length < maximum_length && *p; ++string_length)
+            {
+                int const len = __crt_mbstring::__mblen_utf8(p);
+
+                if (len >= 1 && len <= 4) {
+                    p += len;
+                } else {
+                    ++p; // on illegal sequence, treat as ascii. We will return EILSEQ during write
+                }
+
+                if (len == 4)
+                {
+                    ++string_length; // utf-16 surrogate pair
+                }
+            }
+
+            return string_length;
+        }
+
+        int string_length{0};
+
+        for (char const* p{_narrow_string}; string_length < maximum_length && *p; ++string_length)
+        {
+            if (__acrt_isleadbyte_l_noupdate(static_cast<unsigned char>(*p), locale))
+            {
+                ++p;
+            }
+
+            ++p;
+        }
+
+        return string_length;
+    }
+
+    // Floating-point output:  The A case handles the A, E, F, and G format specifiers.
+    // The a case handles the a, e, f, and g format specifiers.  A capital format
+    // specifier causes us to output capital hexits, whereas a lowercase format
+    // specifier causes us to output lowercase hexits.
+    bool type_case_a() throw()
+    {
+        // The double type is signed:
+        set_flag(FL_SIGNED);
+
+        if (!validate_state_for_type_case_a())
+            return false;
+
+        if (!should_format())
+            return true;
+
+        // First, we need to compute the actual precision to use, limited by
+        // both the maximum precision and the size of the buffer that we can
+        // allocate.
+        if (_precision < 0)
+        {
+            // The default precision depends on the format specifier used.  For
+            // %e, %f, and %g, C specifies that the default precision is 6.  For
+            // %a, C specifies that "if the precision is missing and FLT_RADIX
+            // is a power of 2, then the precision is sufficient for an exact
+            // representation of the value" (C11 7.21.6.1/8).
+            //
+            // The 64-bit double has 53 bits of precision.  When printing in
+            // hexadecimal form, we print one bit of precision to the left of the
+            // radix point and the remaining 52 bits of precision to the right.
+            // Thus, the default precision is 13 (13 * 4 == 52).
+            if (_format_char == 'a' || _format_char == 'A')
+            {
+                _precision = 13;
+            }
+            else
+            {
+                _precision = 6;
+            }
+        }
+        else if (_precision == 0 && (_format_char == 'g' || _format_char == 'G'))
+        {
+            _precision = 1; // Per C Standard Library specification.
+        }
+
+        if (!_buffer.ensure_buffer_is_big_enough<char>(_CVTBUFSIZE + _precision, _ptd))
+        {
+            // If we fail to enlarge the buffer, cap precision so that the
+            // statically-sized buffer may be used for the formatting:
+            _precision = static_cast<int>(_buffer.count<char>() - _CVTBUFSIZE);
+        }
+
+        _narrow_string = _buffer.data<char>();
+
+        // Note that we separately handle the FORMAT_POSSCAN_PASS above.
+        _CRT_DOUBLE tmp{};
+        if (!extract_argument_from_va_list<_CRT_DOUBLE>(tmp))
+        {
+            return false;
+        }
+
+        // Format the number into the buffer:
+        __acrt_fp_format(
+            &tmp.x,
+            _buffer.data<char>(),
+            _buffer.count<char>(),
+            _buffer.scratch_data<char>(),
+            _buffer.scratch_count<char>(),
+            static_cast<char>(_format_char),
+            _precision,
+            _options,
+            __acrt_rounding_mode::standard,
+            _ptd);
+
+        // If the precision is zero but the '#' flag is part of the specifier,
+        // we force a decimal point:
+        if (has_flag(FL_ALTERNATE) && _precision == 0)
+        {
+            force_decimal_point(_narrow_string, _ptd.get_locale());
+        }
+
+        // The 'g' format specifier indicates that zeroes should be cropped
+        // unless the '#' flag is part of the specifier.
+        if ((_format_char == 'g' || _format_char == 'G') && !has_flag(FL_ALTERNATE))
+        {
+            crop_zeroes(_narrow_string, _ptd.get_locale());
+        }
+
+        // If the result was negative, we save the '-' for later and advance past
+        // the negative sign (we handle the '-' separately, in code shared with
+        // the integer formatting, to correctly handle flags).
+        if (*_narrow_string == '-')
+        {
+            set_flag(FL_NEGATIVE);
+            ++_narrow_string;
+        }
+
+        // If the result was a special infinity or a nan string, suppress output
+        // of the "0x" prefix by treating the special string as just a string:
+        if (*_narrow_string == 'i' || *_narrow_string == 'I' ||
+            *_narrow_string == 'n' || *_narrow_string == 'N')
+        {
+            unset_flag(FL_LEADZERO); // padded with spaces, not zeros.
+            _format_char = 's';
+        }
+
+        _string_length = static_cast<int>(strlen(_narrow_string));
+
+        return true;
+    }
+
+    // Integer output:  These functions handle the formatting of integer values.
+    // There are a number of format specifiers that handle integer formatting;
+    // we handle them separately, but they all end up calling the common function
+    // type_case_integer(), defined last.
+    bool type_case_d() throw()
+    {
+        set_flag(FL_SIGNED);
+
+        return type_case_integer<10>();
+    }
+
+    bool type_case_u() throw()
+    {
+        return type_case_integer<10>();
+    }
+
+    bool type_case_o() throw()
+    {
+        // If the alternate flag is set, we force a leading 0:
+        if (has_flag(FL_ALTERNATE))
+            set_flag(FL_FORCEOCTAL);
+
+        return type_case_integer<8>();
+    }
+
+    bool type_case_X() throw()
+    {
+        return type_case_integer<16>(true);
+    }
+
+    bool type_case_x() throw()
+    {
+        return type_case_integer<16>();
+    }
+
+    // The 'p' format specifier writes a pointer, which is simply treated as a
+    // hexadecimal integer with lowercase hexits.
+    bool type_case_p() throw()
+    {
+        // We force the precision to be 2 * sizeof(void*), which is the number
+        // of hexits required to represent the pointer, so that it is zero-
+        // padded.
+        _precision = 2 * sizeof(void*);
+
+        // Ensure that we read a 32-bit integer on 32-bit architectures, and
+        // a 64-bit integer on 64-bit platforms:
+        _length = sizeof(void*) == 4
+            ? length_modifier::I32
+            : length_modifier::I64;
+
+        return type_case_integer<16>(true);
+    }
+
+    // This is the first half of the common integer formatting routine.  It
+    // extracts the integer of the specified type from the varargs and does
+    // pre-processing common to all integer processing.
+    template <unsigned Radix>
+    bool type_case_integer(bool const capital_hexits = false) throw()
+    {
+        size_t const integer_size = to_integer_size(_length);
+
+        // First, extract the argument of the required type from the varargs:
+        __int64 original_number  {};
+        bool    extraction_result{};
+        switch (integer_size)
+        {
+        case sizeof(int8_t):
+            extraction_result = has_flag(FL_SIGNED)
+                ? extract_argument_from_va_list<int8_t >(original_number)
+                : extract_argument_from_va_list<uint8_t>(original_number);
+            break;
+        case sizeof(int16_t):
+            extraction_result = has_flag(FL_SIGNED)
+                ? extract_argument_from_va_list<int16_t >(original_number)
+                : extract_argument_from_va_list<uint16_t>(original_number);
+            break;
+        case sizeof(int32_t):
+            extraction_result = has_flag(FL_SIGNED)
+                ? extract_argument_from_va_list<int32_t >(original_number)
+                : extract_argument_from_va_list<uint32_t>(original_number);
+            break;
+        case sizeof(int64_t):
+            extraction_result = has_flag(FL_SIGNED)
+                ? extract_argument_from_va_list<int64_t >(original_number)
+                : extract_argument_from_va_list<uint64_t>(original_number);
+            break;
+        default:
+            _UCRT_VALIDATE_RETURN(_ptd, ("Invalid integer length modifier", 0), EINVAL, false);
+            break;
+        }
+
+        if (!extraction_result)
+            return false;
+
+        // If we're not formatting, then we're done; we just needed to read the
+        // argument from the varargs.
+        if (!should_format())
+            return true;
+
+        // Check the sign of the number.  If it is negative, convert it to
+        // positive for formatting.  We'll handle the minus sign later (after
+        // we return from this function).
+        unsigned __int64 number{};
+
+        if (has_flag(FL_SIGNED) && original_number < 0)
+        {
+            number = static_cast<unsigned __int64>(-original_number);
+            set_flag(FL_NEGATIVE);
+        }
+        else
+        {
+            number = static_cast<unsigned __int64>(original_number);
+        }
+
+        // Check the precision to see if the default precision was specified.  If
+        // a non-default precision was specified, we turn off the zero flag, per
+        // the C Standard Library specification.
+        if (_precision < 0)
+        {
+            _precision = 1; // Default precision
+        }
+        else
+        {
+            unset_flag(FL_LEADZERO);
+            _buffer.ensure_buffer_is_big_enough<Character>(_precision, _ptd);
+        }
+
+        // If the number is zero, we do not want to print the hex prefix ("0x"),
+        // even if it was requested:
+        if (number == 0)
+        {
+            unset_flag(FL_ALTERNATE);
+        }
+
+        _string_is_wide = sizeof(Character) == sizeof(wchar_t);
+
+        if (integer_size == sizeof(int64_t))
+        {
+            type_case_integer_parse_into_buffer<uint64_t, Radix>(number, capital_hexits);
+        }
+        else
+        {
+            type_case_integer_parse_into_buffer<uint32_t, Radix>(static_cast<uint32_t>(number), capital_hexits);
+        }
+
+        // If the FORCEOCTAL flag is set, then we output a leading zero, unless
+        // the formatted string already has a leading zero:
+        if (has_flag(FL_FORCEOCTAL) && (_string_length == 0 || tchar_string()[0] != '0'))
+        {
+            *--tchar_string() = '0';
+            ++_string_length;
+        }
+
+        return true;
+    }
+
+    // This is the second half of the common integer formatting routine.  It
+    // handles the actual formatting of the number.  This logic has been split
+    // out from the first part so that we only use 64-bit arithmetic when
+    // absolutely required (on x86, 64-bit division is Slow-with-a-capital-S).
+    template <typename UnsignedInteger, unsigned Radix>
+    void type_case_integer_parse_into_buffer(
+        UnsignedInteger       number,
+        bool            const capital_hexits
+        ) throw()
+    {
+        // Format the number into the formatting buffer.  Note that we format the
+        // buffer at the end of the formatting buffer, which allows us to perform
+        // the formatting from least to greatest magnitude, which maps well to
+        // the math.
+        Character* const last_digit{_buffer.data<Character>() + _buffer.count<Character>() - 1};
+
+        Character*& string_pointer = tchar_string();
+
+        string_pointer = last_digit;
+        while (_precision > 0 || number != 0)
+        {
+            --_precision;
+
+            Character digit{static_cast<Character>(number % Radix + '0')};
+            number /= Radix;
+
+            // If the digit is greater than 9, we need to convert it to the
+            // corresponding letter hexit in the required case:
+            if (digit > '9')
+            {
+                digit = adjust_hexit(digit, capital_hexits);
+            }
+
+            *string_pointer-- = static_cast<char>(digit);
+        }
+
+        _string_length = static_cast<int>(last_digit - string_pointer);
+        ++string_pointer;
+    }
+
+    // The 'n' type specifier is special:  We read a short* or int* from the
+    // varargs and write the number of characters that we've written so far to
+    // the pointed-to integer.
+    bool type_case_n() throw()
+    {
+        void* p{nullptr};
+        if (!extract_argument_from_va_list<void*>(p))
+            return false;
+
+        if (!should_format())
+            return true;
+
+        if (!_get_printf_count_output())
+        {
+            _UCRT_VALIDATE_RETURN(_ptd, ("'n' format specifier disabled", 0), EINVAL, false);
+            return false; // Unreachable
+        }
+
+        switch (to_integer_size(_length))
+        {
+        case sizeof(int8_t):  *static_cast<int8_t *>(p) = static_cast<int8_t >(_characters_written);   break;
+        case sizeof(int16_t): *static_cast<int16_t*>(p) = static_cast<int16_t>(_characters_written);   break;
+        case sizeof(int32_t): *static_cast<int32_t*>(p) = static_cast<int32_t>(_characters_written);   break;
+        case sizeof(int64_t): *static_cast<int64_t*>(p) = static_cast<int64_t>(_characters_written);   break;
+        default:              _UCRT_VALIDATE_RETURN(_ptd, ("Invalid integer length modifier", 0), EINVAL, false); break;
+        }
+
+        // This format specifier never corresponds to an output operation:
+        _suppress_output = true;
+        return true;
+    }
+
+    // After we have completed the formatting of the string to be output, we
+    // perform the output operation, which is handled by these two functions.
+    __forceinline bool write_stored_string_tchar(char) throw()
+    {
+        if (!_string_is_wide || _string_length <= 0)
+        {
+            _output_adapter.write_string(_narrow_string, _string_length, &_characters_written, _ptd);
+        }
+        else if (_ptd.get_locale()->locinfo->_public._locale_lc_codepage == CP_UTF8)
+        {   // Use resumable character translator to handle UTF-16 surrogate pairs.
+            wchar_t const* p{_wide_string};
+            mbstate_t state{};
+
+            for (int i = 0; i != _string_length; ++i)
+            {
+                char local_buffer[MB_LEN_MAX + 1];
+                size_t const mbc_length = __crt_mbstring::__c16rtomb_utf8(local_buffer, static_cast<char16_t>(*p++), &state, _ptd);
+                if (mbc_length == __crt_mbstring::INVALID)
+                {
+                    _characters_written = -1;
+                    return true;
+                }
+
+                _output_adapter.write_string(local_buffer, static_cast<int>(mbc_length), &_characters_written, _ptd);
+            }
+        }
+        else
+        {
+            wchar_t const* p{_wide_string};
+            for (int i{0}; i != _string_length; ++i)
+            {
+                char local_buffer[MB_LEN_MAX + 1];
+
+                int mbc_length{0};
+                errno_t const status{_wctomb_internal(&mbc_length, local_buffer, _countof(local_buffer), *p++, _ptd)};
+                if (status != 0 || mbc_length == 0)
+                {
+                    _characters_written = -1;
+                    return true;
+                }
+
+                _output_adapter.write_string(local_buffer, mbc_length, &_characters_written, _ptd);
+            }
+        }
+
+        return true;
+    }
+
+
+    __forceinline bool write_stored_string_tchar(wchar_t) throw()
+    {
+        if (_string_is_wide || _string_length <= 0)
+        {
+            _output_adapter.write_string(_wide_string, _string_length, &_characters_written, _ptd);
+        }
+        else if (_ptd.get_locale()->locinfo->_public._locale_lc_codepage == CP_UTF8)
+        {
+            char const* p{_narrow_string};
+            mbstate_t state{};
+            for (int i = 0; i != _string_length; ++i)
+            {
+                wchar_t local_buffer[2]{}; // Two wchar_ts to support UTF-16 surrogate pairs
+                size_t const mbc_length = __crt_mbstring::__mbsrtowcs_utf8(local_buffer, &p, 2, &state, _ptd);
+                // Unlike other per-character functions used nearby, __mbsrtowcs_utf8 will advance the string pointer.
+                if (mbc_length == __crt_mbstring::INVALID)
+                {
+                    _characters_written = -1;
+                    return true;
+                }
+
+                _output_adapter.write_character(local_buffer[0], &_characters_written, _ptd);
+
+                if (mbc_length == 2)
+                {
+                    _output_adapter.write_character(local_buffer[1], &_characters_written, _ptd);
+                    ++i;
+                }
+            }
+        }
+        else
+        {
+            _locale_t locale_ptr = _ptd.get_locale();
+
+            char const* p{_narrow_string};
+            for (int i{0}; i != _string_length; ++i)
+            {
+                wchar_t wide_character{};
+                int mbc_length{_mbtowc_internal(&wide_character, p, locale_ptr->locinfo->_public._locale_mb_cur_max, _ptd)};
+
+                if (mbc_length <= 0)
+                {
+                    _characters_written = -1;
+                    return true;
+                }
+
+                _output_adapter.write_character(wide_character, &_characters_written, _ptd);
+                p += mbc_length;
+            }
+        }
+
+        return true;
+    }
+
+    // These functions are utilities for working with the flags, and performing
+    // state transitions.
+    bool has_flag  (unsigned const f) const throw() { return (_flags & f) != 0; }
+    void set_flag  (unsigned const f)       throw() { _flags |= f;              }
+    void unset_flag(unsigned const f)       throw() { _flags &= ~f;             }
+
+    state find_next_state(Character const c, state const previous_state) const throw()
+    {
+        auto const& lookup_table = state_transition_table();
+
+        unsigned const current_class = static_cast<unsigned>((c < ' ' || c > 'z')
+            ? character_type::other
+            : static_cast<character_type>(lookup_table[c - ' '].current_class));
+
+        auto const index = current_class * state_count() + static_cast<unsigned>(previous_state);
+        return static_cast<state>(lookup_table[index].next_state);
+    }
+
+    // Adjusts an out-of-range hexit character to be a lowercase or capital
+    // letter.  This function is called when formatting a number as hexadecimal
+    // and a hexit is above 9.  The normal formatting will not correctly handle
+    // this case.  Here, we adjust it by the required offset to yield a letter,
+    // in the range [A, F], as either a lowercase or capital letter.
+    static char __cdecl adjust_hexit(int const value, bool const capitalize) throw()
+    {
+        int const base  {capitalize ? 'A' : 'a'};
+        int const offset{base - '9' - 1        };
+
+        return static_cast<char>(offset + value);
+    }
+
+    // When a null pointer is passed, we print this string as a placeholder.
+    static char   * __cdecl narrow_null_string() throw() { return  "(null)"; }
+    static wchar_t* __cdecl wide_null_string  () throw() { return L"(null)"; }
+};
+
+
+
+} // namespace __crt_stdio_output
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_string_templates.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_string_templates.h
new file mode 100644
index 0000000000000000000000000000000000000000..2262b05e3bc2f6fb4fab2aca3a4d3732730bef99
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_string_templates.h	
@@ -0,0 +1,299 @@
+//
+// corecrt_internal_string_templates.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines template implementations of several secure
+// string functions that have identical implementations for both narrow and
+// wide character strings.
+//
+#pragma once
+
+#include <corecrt_internal_securecrt.h>
+
+
+
+// _strcat_s() and _wcscat_s()
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tcscat_s(
+    _Inout_updates_z_(size_in_elements) Character* const destination,
+    size_t                                         const size_in_elements,
+    _In_z_  Character const*                       const source
+    ) throw()
+{
+    _VALIDATE_STRING(destination, size_in_elements);
+    _VALIDATE_POINTER_RESET_STRING(source, destination, size_in_elements);
+
+    Character* destination_it = destination;
+    size_t available = size_in_elements;
+    while (available > 0 && *destination_it != 0)
+    {
+        ++destination_it;
+        --available;
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_DEST_NOT_NULL_TERMINATED(destination, size_in_elements);
+    }
+
+    Character const* source_it = source;
+    while ((*destination_it++ = *source_it++) != 0 && --available > 0)
+    {
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_BUFFER_TOO_SMALL(destination, size_in_elements);
+    }
+    _FILL_STRING(destination, size_in_elements, size_in_elements - available + 1);
+    _RETURN_NO_ERROR;
+}
+
+
+
+// _strcpy_s() and _wcscpy_s()
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tcscpy_s(
+    _Out_writes_z_(size_in_elements) Character* const destination,
+    _In_                                 size_t const size_in_elements,
+    _In_z_                     Character const* const source
+    ) throw()
+{
+    _VALIDATE_STRING(destination, size_in_elements);
+    _VALIDATE_POINTER_RESET_STRING(source, destination, size_in_elements);
+
+    Character*       destination_it = destination;
+    Character const* source_it      = source;
+
+    size_t available = size_in_elements;
+    while ((*destination_it++ = *source_it++) != 0 && --available > 0)
+    {
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_BUFFER_TOO_SMALL(destination, size_in_elements);
+    }
+    _FILL_STRING(destination, size_in_elements, size_in_elements - available + 1);
+    _RETURN_NO_ERROR;
+}
+
+
+
+// _strncat_s() and _wcsncat_s()
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tcsncat_s(
+    _Inout_updates_z_(size_in_elements) Character* const destination,
+    _In_                                    size_t const size_in_elements,
+    _In_reads_or_z_(count)        Character const* const source,
+    _In_                                    size_t const count
+    ) throw()
+{
+    if (count == 0 && destination == nullptr && size_in_elements == 0)
+    {
+        // This case is allowed; nothing to do:
+        _RETURN_NO_ERROR;
+    }
+
+    _VALIDATE_STRING(destination, size_in_elements);
+    if (count != 0)
+    {
+        _VALIDATE_POINTER_RESET_STRING(source, destination, size_in_elements);
+    }
+
+    Character* destination_it = destination;
+
+    size_t available = size_in_elements;
+    size_t remaining = count;
+    while (available > 0 && *destination_it != 0)
+    {
+        ++destination_it;
+        --available;
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_DEST_NOT_NULL_TERMINATED(destination, size_in_elements);
+    }
+
+    Character const* source_it = source;
+    if (count == _TRUNCATE)
+    {
+        while ((*destination_it++ = *source_it++) != 0 && --available > 0)
+        {
+        }
+    }
+    else
+    {
+        while (remaining > 0 && (*destination_it++ = *source_it++) != 0 && --available > 0)
+        {
+            remaining--;
+        }
+
+        if (remaining == 0)
+        {
+            *destination_it = 0;
+        }
+    }
+
+    if (available == 0)
+    {
+        if (count == _TRUNCATE)
+        {
+            destination[size_in_elements - 1] = 0;
+            _RETURN_TRUNCATE;
+        }
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_BUFFER_TOO_SMALL(destination, size_in_elements);
+    }
+    _FILL_STRING(destination, size_in_elements, size_in_elements - available + 1);
+    _RETURN_NO_ERROR;
+}
+
+
+
+// _strncpy_s() and _wcsncpy_s()
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tcsncpy_s(
+    _Out_writes_z_(size_in_elements) Character* const destination,
+    _In_                                 size_t const size_in_elements,
+    _In_reads_or_z_(count)     Character const* const source,
+    _In_                                 size_t const count
+    ) throw()
+{
+    if (count == 0 && destination == nullptr && size_in_elements == 0)
+    {
+        // this case is allowed; nothing to do:
+        _RETURN_NO_ERROR;
+    }
+
+    _VALIDATE_STRING(destination, size_in_elements);
+    if (count == 0)
+    {
+        // Notice that the source string pointer can be nullptr in this case:
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_NO_ERROR;
+    }
+    _VALIDATE_POINTER_RESET_STRING(source, destination, size_in_elements);
+
+    Character*       destination_it = destination;
+    Character const* source_it      = source;
+
+    size_t available = size_in_elements;
+    size_t remaining = count;
+    if (count == _TRUNCATE)
+    {
+        while ((*destination_it++ = *source_it++) != 0 && --available > 0)
+        {
+        }
+    }
+    else
+    {
+        while ((*destination_it++ = *source_it++) != 0 && --available > 0 && --remaining > 0)
+        {
+        }
+        if (remaining == 0)
+        {
+            *destination_it = 0;
+        }
+    }
+
+    if (available == 0)
+    {
+        if (count == _TRUNCATE)
+        {
+            destination[size_in_elements - 1] = 0;
+            _RETURN_TRUNCATE;
+        }
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_BUFFER_TOO_SMALL(destination, size_in_elements);
+    }
+    _FILL_STRING(destination, size_in_elements, size_in_elements - available + 1);
+    _RETURN_NO_ERROR;
+}
+
+
+
+// _strnset_s() and _wcsnset_s()
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tcsnset_s(
+    _Inout_updates_z_(size_in_elements) Character* const destination,
+    _In_                                    size_t const size_in_elements,
+    _In_                                 Character const value,
+    _In_                                    size_t const count
+    ) throw()
+{
+    if (count == 0 && destination == nullptr && size_in_elements == 0)
+    {
+        // This case is allowed; nothing to do:
+        _RETURN_NO_ERROR;
+    }
+    _VALIDATE_STRING(destination, size_in_elements);
+
+    Character* destination_it = destination;
+
+    size_t available = size_in_elements;
+    size_t remaining = count;
+    while (*destination_it != 0 && remaining > 0 && --available > 0)
+    {
+        *destination_it++ = value;
+        --remaining;
+    }
+
+    if (remaining == 0)
+    {
+        // Ensure the string is null-terminated:
+        while (*destination_it != 0 && --available > 0)
+        {
+            ++destination_it;
+        }
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_DEST_NOT_NULL_TERMINATED(destination, size_in_elements);
+    }
+    _FILL_STRING(destination, size_in_elements, size_in_elements - available + 1);
+    _RETURN_NO_ERROR;
+}
+
+
+
+// _strset_s() and _wcsset_s()
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tcsset_s(
+    _Inout_updates_z_(size_in_elements) Character* const destination,
+    _In_                                    size_t const size_in_elements,
+    _In_                                 Character const value
+    ) throw()
+{
+    _VALIDATE_STRING(destination, size_in_elements);
+
+    Character* destination_it = destination;
+
+    size_t available = size_in_elements;
+    while (*destination_it != 0 && --available > 0)
+    {
+        *destination_it++ = value;
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(destination, size_in_elements);
+        _RETURN_DEST_NOT_NULL_TERMINATED(destination, size_in_elements);
+    }
+    _FILL_STRING(destination, size_in_elements, size_in_elements - available + 1);
+    _RETURN_NO_ERROR;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_strtox.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_strtox.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f8c9e69a0f9a4913b32d7c07ed186d15ed21340
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_strtox.h	
@@ -0,0 +1,2047 @@
+//
+// corecrt_internal_strtox.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file defines the core implementations of the numeric parsers that parse
+// integer or floating point numbers stored as strings.  These general parsers
+// operate on abstract character sources, which allow the functions to be used
+// to parse both random access and nonseekable ranges of characters (to support
+// both strtod-style functions and fscanf-style functions).
+//
+#pragma once
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_big_integer.h>
+#include <corecrt_internal_fltintrn.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <corecrt_internal_stdio.h>
+#include <ctype.h>
+#include <fenv.h>
+#include <locale.h>
+#include <stdint.h>
+
+// This header is temporarily mixed PTD-propagation and direct errno usage.
+#pragma push_macro("_VALIDATE_RETURN_VOID")
+#pragma push_macro("_VALIDATE_RETURN")
+#pragma push_macro("_INVALID_PARAMETER")
+#undef _VALIDATE_RETURN_VOID
+#undef _VALIDATE_RETURN
+#undef _INVALID_PARAMETER
+
+#ifdef _DEBUG
+    #define _INVALID_PARAMETER(expr) _invalid_parameter(expr, __FUNCTIONW__, __FILEW__, __LINE__, 0)
+#else
+    #define _INVALID_PARAMETER(expr) _invalid_parameter_noinfo()
+#endif
+
+#define _VALIDATE_RETURN(expr, errorcode, retexpr)                             \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            *_errno() = (errorcode);                                           \
+            _INVALID_PARAMETER(_CRT_WIDE(#expr));                              \
+            return (retexpr);                                                  \
+        }                                                                      \
+    }
+
+#define _VALIDATE_RETURN_VOID(expr, errorcode)                                 \
+    {                                                                          \
+        int _Expr_val = !!(expr);                                              \
+        _ASSERT_EXPR((_Expr_val), _CRT_WIDE(#expr));                           \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            *_errno() = (errorcode);                                           \
+            _INVALID_PARAMETER(_CRT_WIDE(#expr));                              \
+            return;                                                            \
+        }                                                                      \
+    }
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// String-to-Integer Conversion
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+namespace __crt_strtox {
+
+template <typename T> struct is_signed;
+template <> struct is_signed<long              > { enum { value = true  }; };
+template <> struct is_signed<long long         > { enum { value = true  }; };
+template <> struct is_signed<unsigned long     > { enum { value = false }; };
+template <> struct is_signed<unsigned long long> { enum { value = false }; };
+
+template <typename T> struct make_signed;
+template <> struct make_signed<long              > { using type = long;      };
+template <> struct make_signed<long long         > { using type = long long; };
+template <> struct make_signed<unsigned long     > { using type = long;      };
+template <> struct make_signed<unsigned long long> { using type = long long; };
+
+template <typename T> struct make_unsigned;
+template <> struct make_unsigned<long              > { using type = unsigned long;      };
+template <> struct make_unsigned<long long         > { using type = unsigned long long; };
+template <> struct make_unsigned<unsigned long     > { using type = unsigned long;      };
+template <> struct make_unsigned<unsigned long long> { using type = unsigned long long; };
+
+// Converts a wide character to its corresponding digit.  Returns -1 on failure.
+__forceinline int __cdecl wide_character_to_digit(wchar_t const c) throw()
+{
+    #define DIGIT_RANGE_TEST(zero) \
+        if (c < zero)              \
+            return -1;             \
+                                   \
+        if (c < zero + 10)         \
+            return c - zero;
+
+    DIGIT_RANGE_TEST(0x0030)        // 0030;DIGIT ZERO
+    if (c < 0xFF10)                 // FF10;FULLWIDTH DIGIT ZERO
+    {
+        DIGIT_RANGE_TEST(0x0660)    // 0660;ARABIC-INDIC DIGIT ZERO
+        DIGIT_RANGE_TEST(0x06F0)    // 06F0;EXTENDED ARABIC-INDIC DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0966)    // 0966;DEVANAGARI DIGIT ZERO
+        DIGIT_RANGE_TEST(0x09E6)    // 09E6;BENGALI DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0A66)    // 0A66;GURMUKHI DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0AE6)    // 0AE6;GUJARATI DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0B66)    // 0B66;ORIYA DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0C66)    // 0C66;TELUGU DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0CE6)    // 0CE6;KANNADA DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0D66)    // 0D66;MALAYALAM DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0E50)    // 0E50;THAI DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0ED0)    // 0ED0;LAO DIGIT ZERO
+        DIGIT_RANGE_TEST(0x0F20)    // 0F20;TIBETAN DIGIT ZERO
+        DIGIT_RANGE_TEST(0x1040)    // 1040;MYANMAR DIGIT ZERO
+        DIGIT_RANGE_TEST(0x17E0)    // 17E0;KHMER DIGIT ZERO
+        DIGIT_RANGE_TEST(0x1810)    // 1810;MONGOLIAN DIGIT ZERO
+
+        return -1;
+    }
+
+    #undef DIGIT_RANGE_TEST
+
+    if (c < 0xFF10 + 10)            // FF10;FULLWIDTH DIGIT ZERO
+        return c - 0xFF10;
+
+    return -1;
+}
+
+__forceinline unsigned __cdecl parse_digit(char const c) throw()
+{
+    if (c >= '0' && c <= '9')
+    {
+        return static_cast<unsigned>(c - '0');
+    }
+
+    if (c >= 'a' && c <= 'z')
+    {
+        return static_cast<unsigned>(c - 'a' + 10);
+    }
+
+    if (c >= 'A' && c <= 'Z')
+    {
+        return static_cast<unsigned>(c - 'A' + 10);
+    }
+
+    return static_cast<unsigned>(-1);
+}
+
+__forceinline unsigned __cdecl parse_digit(wchar_t const c) throw()
+{
+    int const value = wide_character_to_digit(c);
+    if (value != -1)
+        return static_cast<unsigned>(value);
+
+    if (__ascii_iswalpha(c))
+        return static_cast<unsigned>(__ascii_towupper(c) - 'A' + 10);
+
+    return static_cast<unsigned>(-1);
+}
+
+// The digit and nondigit categories include 0-9, a-z, A-Z, and _.  They are not
+// locale-dependent, so we do not call isalnum (which uses the current locale to
+// test for alphabetic characters).
+__forceinline bool __cdecl is_digit_or_nondigit(int const c) throw()
+{
+    if (c >= '0' && c <= '9')
+        return true;
+
+    if (c >= 'a' && c <= 'z')
+        return true;
+
+    if (c >= 'A' && c <= 'Z')
+        return true;
+
+    if (c == '_')
+        return true;
+
+    return false;
+}
+
+__forceinline bool __cdecl is_space(char const c, _locale_t const locale) throw()
+{
+    return _isspace_l(static_cast<int>(static_cast<unsigned char>(c)), locale) != 0;
+}
+
+__forceinline bool __cdecl is_space(wchar_t const c, _locale_t) throw()
+{
+    return iswspace(c) != 0;
+}
+
+inline long minimum_signed_value(unsigned long)    throw() { return LONG_MIN; }
+inline long maximum_signed_value(unsigned long)    throw() { return LONG_MAX; }
+
+inline __int64 minimum_signed_value(unsigned __int64) throw() { return _I64_MIN; }
+inline __int64 maximum_signed_value(unsigned __int64) throw() { return _I64_MAX; }
+
+enum : unsigned
+{
+    FL_SIGNED     = 0x01,
+    FL_NEGATIVE   = 0x02,
+    FL_OVERFLOW   = 0x04,
+    FL_READ_DIGIT = 0x08
+};
+
+template <typename UnsignedInteger>
+bool is_overflow_condition(unsigned const flags, UnsignedInteger const number) throw()
+{
+    if (flags & FL_OVERFLOW)
+        return true;
+
+    if (flags & FL_SIGNED)
+    {
+        if ((flags & FL_NEGATIVE) != 0 && number > static_cast<UnsignedInteger>(-minimum_signed_value(UnsignedInteger())))
+            return true;
+
+        if ((flags & FL_NEGATIVE) == 0 && number > static_cast<UnsignedInteger>(maximum_signed_value(UnsignedInteger())))
+            return true;
+    }
+
+    return false;
+}
+
+template <typename UnsignedInteger, typename CharacterSource, bool TrimWhitespace = true>
+UnsignedInteger __cdecl parse_integer(
+    __crt_cached_ptd_host&   ptd,
+    CharacterSource          source,
+    int                      base,
+    bool               const is_result_signed
+    ) throw()
+{
+    static_assert(!__crt_strtox::is_signed<UnsignedInteger>::value, "UnsignedInteger must be unsigned");
+
+    using char_type = typename CharacterSource::char_type;
+
+    if (!source.validate())
+        return 0;
+
+    _UCRT_VALIDATE_RETURN(ptd, base == 0 || (2 <= base && base <= 36), EINVAL, 0);
+    UnsignedInteger number{0}; // number is the accumulator
+
+    auto const initial_state = source.save_state();
+
+
+    char_type c{source.get()};
+
+    if constexpr (TrimWhitespace)
+    {
+        const _locale_t loc = ptd.get_locale();
+        while (is_space(c, loc))
+        {
+            c = source.get();
+        }
+    }
+
+    unsigned flags{is_result_signed ? FL_SIGNED : 0};
+
+    // Optional sign (+ or -):
+    if (c == '-')
+    {
+        flags |= FL_NEGATIVE;
+    }
+
+    if (c == '-' || c == '+')
+    {
+        c = source.get();
+    }
+
+    // If the base is zero, we try to detect the base from the string prefix:
+    if (base == 0 || base == 16)
+    {
+        if (parse_digit(c) != 0)
+        {
+            if (base == 0)
+            {
+                base = 10;
+            }
+        }
+        else
+        {
+            char_type const next_c = source.get();
+            if (next_c == 'x' || next_c == 'X')
+            {
+                if (base == 0)
+                {
+                    base = 16;
+                }
+                c = source.get();
+            }
+            else
+            {
+                if (base == 0)
+                {
+                    base = 8;
+                }
+                source.unget(next_c);
+            }
+        }
+    }
+
+    UnsignedInteger const max_pre_multiply_value = static_cast<UnsignedInteger>(-1) / base;
+
+    for (;;)
+    {
+        unsigned const digit{parse_digit(c)};
+        if (digit >= static_cast<unsigned>(base))
+        {
+            // This also handles the case where the digit could not
+            // be parsed and parse_digit returns -1.
+            break;
+        }
+
+        flags |= FL_READ_DIGIT;
+
+        UnsignedInteger const number_after_multiply = number * base;
+        UnsignedInteger const number_after_add = number_after_multiply + digit;
+
+        // Avoid branching when setting overflow flag.
+        flags |= FL_OVERFLOW * ((number > max_pre_multiply_value) | (number_after_add < number_after_multiply));
+
+        number = number_after_add;
+
+        c = source.get();
+    }
+
+    source.unget(c); // Return the pointer to the character that ended the scan
+
+    // If we failed to read any digits, there's no number to be read:
+    if ((flags & FL_READ_DIGIT) == 0)
+    {
+        source.restore_state(initial_state);
+        return 0;
+    }
+
+    if (is_overflow_condition(flags, number))
+    {
+        ptd.get_errno().set(ERANGE);
+
+        if ((flags & FL_SIGNED) == 0)
+        {
+            number = static_cast<UnsignedInteger>(-1);
+        }
+        else if (flags & FL_NEGATIVE)
+        {
+            return minimum_signed_value(UnsignedInteger());
+        }
+        else
+        {
+            return maximum_signed_value(UnsignedInteger());
+        }
+    }
+    else if (flags & FL_NEGATIVE)
+    {
+        number = static_cast<UnsignedInteger>(-static_cast<typename make_signed<UnsignedInteger>::type>(number));
+    }
+
+    return number;
+}
+
+template <typename UnsignedInteger, typename CharacterSource>
+UnsignedInteger __cdecl parse_integer(
+    _locale_t       const locale,
+    CharacterSource       source,
+    int                   base,
+    bool            const is_result_signed
+    ) throw()
+{
+    __crt_cached_ptd_host ptd{locale};
+    return parse_integer<UnsignedInteger>(ptd, static_cast<CharacterSource&&>(source), base, is_result_signed);
+}
+
+} // namespace __crt_strtox
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// String-to-Floating-Point Conversion
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+typedef enum
+{
+    SLD_OK,
+
+    SLD_NODIGITS,
+
+    SLD_UNDERFLOW,
+    SLD_OVERFLOW
+} SLD_STATUS;
+
+namespace __crt_strtox {
+
+// This is the internal result type of an attempt to parse a floating point value
+// from a string.  The SLD_STATUS type (above) is the type returned to callers of
+// the top-level parse_floating_point.
+enum class floating_point_parse_result
+{
+    decimal_digits,
+    hexadecimal_digits,
+
+    zero,
+    infinity,
+    qnan,
+    snan,
+    indeterminate,
+
+    no_digits,
+    underflow,
+    overflow
+};
+
+enum
+{
+    maximum_temporary_decimal_exponent =  5200,
+    minimum_temporary_decimal_exponent = -5200
+};
+
+// This type is used to hold a partially-parsed string representation of a
+// floating point number.  The number is stored in the following form:
+//
+//     [sign] 0._mantissa * B^_exponent
+//
+// The _mantissa buffer stores the mantissa digits in big endian, binary coded
+// decimal form.  The _mantissa_count stores the number of digits present in the
+// _mantissa buffer.  The base B is not stored; it must be tracked separately.
+// Note that the base of the mantissa digits may not be the same as B (e.g., for
+// hexadecimal floating point hexadecimal, the mantissa digits are in base 16
+// but the exponent is a base 2 exponent).
+//
+// We consider up to 768 decimal digits during conversion.  In most cases, we
+// require nowhere near this many bits of precision to compute the correctly
+// rounded binary floating point value for the input string.  768 bits gives us
+// room to handle the exact decimal representation of the smallest denormal
+// value, 2^-1074 (752 decimal digits after trimming zeroes) with a bit of slack
+// space.
+//
+// NOTE:  The mantissa buffer count here must be kept in sync with the precision
+// of the big_integer type, defined in <corecrt_internal_big_integer.h>.  See that file
+// for details.
+struct floating_point_string
+{
+    int32_t  _exponent;
+    uint32_t _mantissa_count;
+    uint8_t  _mantissa[768];
+    bool     _is_negative;
+};
+
+// This type wraps a float or double.  It serves as a crude form of type erasure
+// to allow us to avoid instantiating most of the parsing logic twice (once for
+// float and once for double).
+class floating_point_value
+{
+public:
+
+    template <typename T>
+    using traits = __acrt_floating_type_traits<T>;
+
+    explicit floating_point_value(double* const value) throw()
+        : _value(value), _is_double(true)
+    {
+        _ASSERTE(value != nullptr);
+    }
+
+    explicit floating_point_value(float* const value) throw()
+        : _value(value), _is_double(false)
+    {
+        _ASSERTE(value != nullptr);
+    }
+
+    bool is_double() const throw()
+    {
+        return _is_double;
+    }
+
+    double& as_double() const throw()
+    {
+        _ASSERT_AND_INVOKE_WATSON(_is_double);
+        return *static_cast<double*>(_value);
+    }
+
+    float& as_float() const throw()
+    {
+        _ASSERT_AND_INVOKE_WATSON(!_is_double);
+        return *static_cast<float*>(_value);
+    }
+
+    int32_t mantissa_bits          () const throw() { return _is_double ? traits<double>::mantissa_bits           : traits<float>::mantissa_bits;           }
+    int32_t exponent_bits          () const throw() { return _is_double ? traits<double>::exponent_bits           : traits<float>::exponent_bits;           }
+    int32_t maximum_binary_exponent() const throw() { return _is_double ? traits<double>::maximum_binary_exponent : traits<float>::maximum_binary_exponent; }
+    int32_t minimum_binary_exponent() const throw() { return _is_double ? traits<double>::minimum_binary_exponent : traits<float>::minimum_binary_exponent; }
+    int32_t exponent_bias          () const throw() { return _is_double ? traits<double>::exponent_bias           : traits<float>::exponent_bias;           }
+
+    uint64_t exponent_mask            () const throw() { return _is_double ? traits<double>::exponent_mask             : traits<float>::exponent_mask;             }
+    uint64_t normal_mantissa_mask     () const throw() { return _is_double ? traits<double>::normal_mantissa_mask      : traits<float>::normal_mantissa_mask;      }
+    uint64_t denormal_mantissa_mask   () const throw() { return _is_double ? traits<double>::denormal_mantissa_mask    : traits<float>::denormal_mantissa_mask;    }
+    uint64_t special_nan_mantissa_mask() const throw() { return _is_double ? traits<double>::special_nan_mantissa_mask : traits<float>::special_nan_mantissa_mask; }
+
+private:
+
+    void*  _value;
+    bool   _is_double;
+};
+
+// Stores a positive or negative zero into the result object
+template <typename FloatingType>
+void __cdecl assemble_floating_point_zero(bool const is_negative, FloatingType& result) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    components_type& result_components = reinterpret_cast<components_type&>(result);
+    result_components._sign     = is_negative ? 1 : 0;
+    result_components._exponent = 0;
+    result_components._mantissa = 0;
+}
+
+inline void __cdecl assemble_floating_point_zero(bool const is_negative, floating_point_value const& result) throw()
+{
+    if (result.is_double())
+    {
+        assemble_floating_point_zero(is_negative, result.as_double());
+    }
+    else
+    {
+        assemble_floating_point_zero(is_negative, result.as_float());
+    }
+}
+
+// Stores a positive or negative infinity into the result object
+template <typename FloatingType>
+void __cdecl assemble_floating_point_infinity(bool const is_negative, FloatingType& result) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    components_type& result_components = reinterpret_cast<components_type&>(result);
+    result_components._sign     = is_negative ? 1 : 0;
+    result_components._exponent = floating_traits::exponent_mask;
+    result_components._mantissa = 0;
+}
+
+inline void __cdecl assemble_floating_point_infinity(bool const is_negative, floating_point_value const& result) throw()
+{
+    if (result.is_double())
+    {
+        assemble_floating_point_infinity(is_negative, result.as_double());
+    }
+    else
+    {
+        assemble_floating_point_infinity(is_negative, result.as_float());
+    }
+}
+
+// Stores a positive or negative quiet NaN into the result object
+template <typename FloatingType>
+void __cdecl assemble_floating_point_qnan(bool const is_negative, FloatingType& result) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    components_type& result_components = reinterpret_cast<components_type&>(result);
+    result_components._sign     = is_negative ? 1 : 0;
+    result_components._exponent = floating_traits::exponent_mask;
+    result_components._mantissa = floating_traits::denormal_mantissa_mask;
+}
+
+inline void __cdecl assemble_floating_point_qnan(bool const is_negative, floating_point_value const& result) throw()
+{
+    if (result.is_double())
+    {
+        assemble_floating_point_qnan(is_negative, result.as_double());
+    }
+    else
+    {
+        assemble_floating_point_qnan(is_negative, result.as_float());
+    }
+}
+
+// Stores a positive or negative signaling NaN into the result object
+template <typename FloatingType>
+void __cdecl assemble_floating_point_snan(bool const is_negative, FloatingType& result) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    components_type& result_components = reinterpret_cast<components_type&>(result);
+    result_components._sign     = is_negative ? 1 : 0;
+    result_components._exponent = floating_traits::exponent_mask;
+    result_components._mantissa = 1;
+}
+
+inline void __cdecl assemble_floating_point_snan(bool const is_negative, floating_point_value const& result) throw()
+{
+    if (result.is_double())
+    {
+        assemble_floating_point_snan(is_negative, result.as_double());
+    }
+    else
+    {
+        assemble_floating_point_snan(is_negative, result.as_float());
+    }
+}
+
+// Stores an indeterminate into the result object (the indeterminate is "negative")
+template <typename FloatingType>
+void __cdecl assemble_floating_point_ind(FloatingType& result) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    components_type& result_components = reinterpret_cast<components_type&>(result);
+    result_components._sign     = 1;
+    result_components._exponent = floating_traits::exponent_mask;
+    result_components._mantissa = floating_traits::special_nan_mantissa_mask;
+}
+
+inline void __cdecl assemble_floating_point_ind(floating_point_value const& result) throw()
+{
+    if (result.is_double())
+    {
+        assemble_floating_point_ind(result.as_double());
+    }
+    else
+    {
+        assemble_floating_point_ind(result.as_float());
+    }
+}
+
+// Determines whether a mantissa should be rounded up in the current rounding
+// mode given [1] the value of the least significant bit of the mantissa, [2]
+// the value of the next bit after the least significant bit (the "round" bit)
+// and [3] whether any trailing bits after the round bit are set.
+//
+// The mantissa is treated as an unsigned integer magnitude; the sign is used
+// only to compute the correct rounding direction for directional rounding modes.
+//
+// For this function, "round up" is defined as "increase the magnitude" of the
+// mantissa.  (Note that this means that if we need to round a negative value to
+// the next largest representable value, we return false, because the next
+// largest representable value has a smaller magnitude.)
+__forceinline bool __cdecl should_round_up(
+    bool const is_negative,
+    bool const lsb_bit,
+    bool const round_bit,
+    bool const has_tail_bits
+    ) throw()
+{
+    // If there are no insignificant set bits, the value is exactly representable
+    // and should not be rounded in any rounding mode:
+    bool const is_exactly_representable = !round_bit && !has_tail_bits;
+    if (is_exactly_representable)
+    {
+        return false;
+    }
+
+    // If there are insignificant set bits, we need to round according to the
+    // current rounding mode.  For FE_TONEAREST, we need to handle two cases:
+    // we round up if either [1] the value is slightly greater than the midpoint
+    // between two exactly representable values or [2] the value is exactly the
+    // midpoint between two exactly representable values and the greater of the
+    // two is even (this is "round-to-even").
+    switch (fegetround())
+    {
+    case FE_TONEAREST:  return round_bit && (has_tail_bits || lsb_bit);
+    case FE_UPWARD:     return !is_negative;
+    case FE_DOWNWARD:   return is_negative;
+    case FE_TOWARDZERO: return false;
+    }
+
+    _ASSERTE(("unexpected rounding mode", false));
+    return false;
+}
+
+// Computes value / 2^shift, then rounds the result according to the current
+// rounding mode.  By the time we call this function, we will already have
+// discarded most digits.  The caller must pass true for has_zero_tail if
+// all discarded bits were zeroes.
+__forceinline uint64_t __cdecl right_shift_with_rounding(
+    bool     const is_negative,
+    uint64_t const value,
+    uint32_t const shift,
+    bool     const has_zero_tail
+    ) throw()
+{
+    // If we'd need to shift further than it is possible to shift, the answer
+    // is always zero:
+    if (shift >= sizeof(uint64_t) * CHAR_BIT)
+    {
+        return 0;
+    }
+
+    uint64_t const extra_bits_mask = (1ui64 << (shift - 1)) - 1;
+    uint64_t const round_bit_mask  = (1ui64 << (shift - 1));
+    uint64_t const lsb_bit_mask    =  1ui64 <<  shift;
+
+    bool const lsb_bit   = (value & lsb_bit_mask)   != 0;
+    bool const round_bit = (value & round_bit_mask) != 0;
+    bool const tail_bits = !has_zero_tail || (value & extra_bits_mask) != 0;
+
+    return (value >> shift) + should_round_up(is_negative, lsb_bit, round_bit, tail_bits);
+}
+
+// Converts the floating point value [sign] 0.mantissa * 2^exponent into the
+// correct form for FloatingType and stores the result into the result object.
+// The caller must ensure that the mantissa and exponent are correctly computed
+// such that either [1] the most significant bit of the mantissa is in the
+// correct position for the FloatingType, or [2] the exponent has been correctly
+// adjusted to account for the shift of the mantissa that will be required.
+//
+// This function correctly handles range errors and stores a zero or infinity in
+// the result object on underflow and overflow errors, respectively.  This
+// function correctly forms denormal numbers when required.
+//
+// If the provided mantissa has more bits of precision than can be stored in the
+// result object, the mantissa is rounded to the available precision.  Thus, if
+// possible, the caller should provide a mantissa with at least one more bit of
+// precision than is required, to ensure that the mantissa is correctly rounded.
+// (The caller should not round the mantissa before calling this function.)
+template <typename FloatingType>
+SLD_STATUS __cdecl assemble_floating_point_value_t(
+    bool         const  is_negative,
+    int32_t      const  exponent,
+    uint64_t     const  mantissa,
+    FloatingType      & result
+    ) throw()
+{
+    using floating_traits = __acrt_floating_type_traits<FloatingType>;
+    using components_type = typename floating_traits::components_type;
+
+    components_type& result_components = reinterpret_cast<components_type&>(result);
+    result_components._sign     = is_negative;
+    result_components._exponent = exponent + floating_traits::exponent_bias;
+    result_components._mantissa = mantissa;
+    return SLD_OK;
+}
+
+inline SLD_STATUS __cdecl assemble_floating_point_value(
+    uint64_t             const  initial_mantissa,
+    int32_t              const  initial_exponent,
+    bool                 const  is_negative,
+    bool                 const  has_zero_tail,
+    floating_point_value const& result
+    ) throw()
+{
+    // Assume that the number is representable as a normal value.  Compute the
+    // number of bits by which we must adjust the mantissa to shift it into the
+    // correct position, and compute the resulting base two exponent for the
+    // normalized mantissa:
+    uint32_t const initial_mantissa_bits = bit_scan_reverse(initial_mantissa);
+    int32_t  const normal_mantissa_shift = static_cast<int32_t>(result.mantissa_bits() - initial_mantissa_bits);
+    int32_t  const normal_exponent       = initial_exponent - normal_mantissa_shift;
+
+    uint64_t mantissa = initial_mantissa;
+    int32_t  exponent = normal_exponent;
+
+    if (normal_exponent > result.maximum_binary_exponent())
+    {
+        // The exponent is too large to be represented by the floating point
+        // type; report the overflow condition:
+        assemble_floating_point_infinity(is_negative, result);
+        return SLD_OVERFLOW;
+    }
+    else if (normal_exponent < result.minimum_binary_exponent())
+    {
+        // The exponent is too small to be represented by the floating point
+        // type as a normal value, but it may be representable as a denormal
+        // value.  Compute the number of bits by which we need to shift the
+        // mantissa in order to form a denormal number.  (The subtraction of
+        // an extra 1 is to account for the hidden bit of the mantissa that
+        // is not available for use when representing a denormal.)
+        int32_t const denormal_mantissa_shift =
+            normal_mantissa_shift +
+            normal_exponent +
+            result.exponent_bias() -
+            1;
+
+        // Denormal values have an exponent of zero, so the debiased exponent is
+        // the negation of the exponent bias:
+        exponent = -result.exponent_bias();
+
+        if (denormal_mantissa_shift < 0)
+        {
+            // Use two steps for right shifts:  for a shift of N bits, we first
+            // shift by N-1 bits, then shift the last bit and use its value to
+            // round the mantissa.
+            mantissa = right_shift_with_rounding(is_negative, mantissa, -denormal_mantissa_shift, has_zero_tail);
+
+            // If the mantissa is now zero, we have underflowed:
+            if (mantissa == 0)
+            {
+                assemble_floating_point_zero(is_negative, result);
+                return SLD_UNDERFLOW;
+            }
+
+            // When we round the mantissa, the result may be so large that the
+            // number becomes a normal value.  For example, consider the single
+            // precision case where the mantissa is 0x01ffffff and a right shift
+            // of 2 is required to shift the value into position. We perform the
+            // shift in two steps:  we shift by one bit, then we shift again and
+            // round using the dropped bit.  The initial shift yields 0x00ffffff.
+            // The rounding shift then yields 0x007fffff and because the least
+            // significant bit was 1, we add 1 to this number to round it.  The
+            // final result is 0x00800000.
+            //
+            // 0x00800000 is 24 bits, which is more than the 23 bits available
+            // in the mantissa.  Thus, we have rounded our denormal number into
+            // a normal number.
+            //
+            // We detect this case here and re-adjust the mantissa and exponent
+            // appropriately, to form a normal number:
+            if (mantissa > result.denormal_mantissa_mask())
+            {
+                // We add one to the denormal_mantissa_shift to account for the
+                // hidden mantissa bit (we subtracted one to account for this bit
+                // when we computed the denormal_mantissa_shift above).
+                exponent =
+                    initial_exponent -
+                    (denormal_mantissa_shift + 1) -
+                    normal_mantissa_shift;
+            }
+        }
+        else
+        {
+            mantissa <<= denormal_mantissa_shift;
+        }
+    }
+    else
+    {
+        if (normal_mantissa_shift < 0)
+        {
+            // Use two steps for right shifts:  for a shift of N bits, we first
+            // shift by N-1 bits, then shift the last bit and use its value to
+            // round the mantissa.
+            mantissa = right_shift_with_rounding(is_negative, mantissa, -normal_mantissa_shift, has_zero_tail);
+
+            // When we round the mantissa, it may produce a result that is too
+            // large.  In this case, we divide the mantissa by two and increment
+            // the exponent (this does not change the value).
+            if (mantissa > result.normal_mantissa_mask())
+            {
+                mantissa >>= 1;
+                ++exponent;
+
+                // The increment of the exponent may have generated a value too
+                // large to be represented.  In this case, report the overflow:
+                if (exponent > result.maximum_binary_exponent())
+                {
+                    assemble_floating_point_infinity(is_negative, result);
+                    return SLD_OVERFLOW;
+                }
+            }
+        }
+        else if (normal_mantissa_shift > 0)
+        {
+            mantissa <<= normal_mantissa_shift;
+        }
+    }
+
+    // Unset the hidden bit in the mantissa and assemble the floating point value
+    // from the computed components:
+    mantissa &= result.denormal_mantissa_mask();
+
+    return result.is_double()
+        ? assemble_floating_point_value_t(is_negative, exponent, mantissa, result.as_double())
+        : assemble_floating_point_value_t(is_negative, exponent, mantissa, result.as_float());
+}
+
+// This function is part of the fast track for integer floating point strings.
+// It takes an integer and a sign and converts the value into its FloatingType
+// representation, storing the result in the result object.  If the value is not
+// representable, +/-infinity is stored and overflow is reported (since this
+// function only deals with integers, underflow is impossible).
+inline SLD_STATUS __cdecl assemble_floating_point_value_from_big_integer(
+    big_integer          const& integer_value,
+    uint32_t             const  integer_bits_of_precision,
+    bool                 const  is_negative,
+    bool                 const  has_nonzero_fractional_part,
+    floating_point_value const& result
+    ) throw()
+{
+    int32_t const base_exponent = result.mantissa_bits() - 1;
+
+    // Very fast case:  If we have fewer than 64 bits of precision, we can just
+    // take the two low order elements from the big_integer:
+    if (integer_bits_of_precision <= 64)
+    {
+        int32_t const exponent = base_exponent;
+
+        uint32_t const mantissa_low  = integer_value._used > 0 ? integer_value._data[0] : 0;
+        uint32_t const mantissa_high = integer_value._used > 1 ? integer_value._data[1] : 0;
+        uint64_t const mantissa =
+            mantissa_low +
+            (static_cast<uint64_t>(mantissa_high) << 32);
+
+        return assemble_floating_point_value(mantissa, exponent, is_negative, !has_nonzero_fractional_part, result);
+    }
+
+    uint32_t const top_element_bits  = integer_bits_of_precision % 32;
+    uint32_t const top_element_index = integer_bits_of_precision / 32;
+
+    uint32_t const middle_element_index = top_element_index - 1;
+    uint32_t const bottom_element_index = top_element_index - 2;
+
+    // Pretty fast case:  If the top 64 bits occupy only two elements, we can
+    // just combine those two elements:
+    if (top_element_bits == 0)
+    {
+        int32_t const exponent = base_exponent + bottom_element_index * 32;
+
+        uint64_t const mantissa =
+            integer_value._data[bottom_element_index] +
+            (static_cast<uint64_t>(integer_value._data[middle_element_index]) << 32);
+
+        bool has_zero_tail = !has_nonzero_fractional_part;
+        for (uint32_t i = 0; i != bottom_element_index; ++i)
+        {
+            has_zero_tail &= integer_value._data[i] == 0;
+        }
+
+        return assemble_floating_point_value(mantissa, exponent, is_negative, has_zero_tail, result);
+    }
+
+    // Not quite so fast case:  The top 64 bits span three elements in the big
+    // integer.  Assemble the three pieces:
+    uint32_t const top_element_mask  = (1u << top_element_bits) - 1;
+    uint32_t const top_element_shift = 64 - top_element_bits; // Left
+
+    uint32_t const middle_element_shift = top_element_shift - 32; // Left
+
+    uint32_t const bottom_element_bits  = 32 - top_element_bits;
+    uint32_t const bottom_element_mask  = ~top_element_mask;
+    uint32_t const bottom_element_shift = 32 - bottom_element_bits; // Right
+
+    int32_t const exponent = base_exponent + bottom_element_index * 32 + top_element_bits;
+
+    uint64_t const mantissa =
+        (static_cast<uint64_t>(integer_value._data[top_element_index] & top_element_mask)       << top_element_shift)    +
+        (static_cast<uint64_t>(integer_value._data[middle_element_index])                       << middle_element_shift) +
+        (static_cast<uint64_t>(integer_value._data[bottom_element_index] & bottom_element_mask) >> bottom_element_shift);
+
+    bool has_zero_tail =
+        !has_nonzero_fractional_part &&
+        (integer_value._data[bottom_element_index] & top_element_mask) == 0;
+
+    for (uint32_t i = 0; i != bottom_element_index; ++i)
+    {
+        has_zero_tail &= integer_value._data[i] == 0;
+    }
+
+    return assemble_floating_point_value(mantissa, exponent, is_negative, has_zero_tail, result);
+}
+
+// Accumulates the decimal digits in [first_digit, last_digit) into the result
+// high precision integer.  This function assumes that no overflow will occur.
+__forceinline void __cdecl accumulate_decimal_digits_into_big_integer(
+    uint8_t const* const first_digit,
+    uint8_t const* const last_digit,
+    big_integer&         result
+    ) throw()
+{
+    // We accumulate nine digit chunks, transforming the base ten string into
+    // base one billion on the fly, allowing us to reduce the number of high
+    // precision multiplication and addition operations by 8/9.
+    uint32_t accumulator{};
+    uint32_t accumulator_count{};
+    for (uint8_t const* it = first_digit; it != last_digit; ++it)
+    {
+        if (accumulator_count == 9)
+        {
+            multiply(result, 1000 * 1000 * 1000);
+            add(result, accumulator);
+
+            accumulator       = 0;
+            accumulator_count = 0;
+        }
+
+        accumulator *= 10;
+        accumulator += *it;
+        ++accumulator_count;
+    }
+
+    if (accumulator_count != 0)
+    {
+        multiply_by_power_of_ten(result, accumulator_count);
+        add(result, accumulator);
+    }
+}
+
+// The core floating point string parser for decimal strings.  After a subject
+// string is parsed and converted into a floating_point_string object, if the
+// subject string was determined to be a decimal string, the object is passed to
+// this function.  This function converts the decimal real value to floating
+// point.
+inline SLD_STATUS __cdecl convert_decimal_string_to_floating_type_common(
+    floating_point_string const& data,
+    floating_point_value  const& result
+    ) throw()
+{
+    // To generate an N bit mantissa we require N + 1 bits of precision.  The
+    // extra bit is used to correctly round the mantissa (if there are fewer bits
+    // than this available, then that's totally okay; in that case we use what we
+    // have and we don't need to round).
+    uint32_t const required_bits_of_precision = result.mantissa_bits() + 1;
+
+    // The input is of the form 0.mantissa x 10^exponent, where 'mantissa' are
+    // the decimal digits of the mantissa and 'exponent' is the decimal exponent.
+    // We decompose the mantissa into two parts: an integer part and a fractional
+    // part.  If the exponent is positive, then the integer part consists of the
+    // first 'exponent' digits, or all present digits if there are fewer digits.
+    // If the exponent is zero or negative, then the integer part is empty.  In
+    // either case, the remaining digits form the fractional part of the mantissa.
+    uint32_t       const positive_exponent      = static_cast<uint32_t>(__max(0, data._exponent));
+    uint32_t       const integer_digits_present = __min(positive_exponent, data._mantissa_count);
+    uint32_t       const integer_digits_missing = positive_exponent - integer_digits_present;
+    uint8_t const* const integer_first          = data._mantissa;
+    uint8_t const* const integer_last           = data._mantissa + integer_digits_present;
+
+    uint8_t const* const fractional_first          = integer_last;
+    uint8_t const* const fractional_last           = data._mantissa + data._mantissa_count;
+    uint32_t       const fractional_digits_present = static_cast<uint32_t>(fractional_last - fractional_first);
+
+    // First, we accumulate the integer part of the mantissa into a big_integer:
+    big_integer integer_value{};
+    accumulate_decimal_digits_into_big_integer(integer_first, integer_last, integer_value);
+
+    if (integer_digits_missing > 0)
+    {
+        if (!multiply_by_power_of_ten(integer_value, integer_digits_missing))
+        {
+            assemble_floating_point_infinity(data._is_negative, result);
+            return SLD_OVERFLOW;
+        }
+    }
+
+    // At this point, the integer_value contains the value of the integer part
+    // of the mantissa.  If either [1] this number has more than the required
+    // number of bits of precision or [2] the mantissa has no fractional part,
+    // then we can assemble the result immediately:
+    uint32_t const integer_bits_of_precision = bit_scan_reverse(integer_value);
+    if (integer_bits_of_precision >= required_bits_of_precision ||
+        fractional_digits_present == 0)
+    {
+        return assemble_floating_point_value_from_big_integer(
+            integer_value,
+            integer_bits_of_precision,
+            data._is_negative,
+            fractional_digits_present != 0,
+            result);
+    }
+
+    // Otherwise, we did not get enough bits of precision from the integer part,
+    // and the mantissa has a fractional part.  We parse the fractional part of
+    // the mantsisa to obtain more bits of precision.  To do this, we convert
+    // the fractional part into an actual fraction N/M, where the numerator N is
+    // computed from the digits of the fractional part, and the denominator M is
+    // computed as the power of 10 such that N/M is equal to the value of the
+    // fractional part of the mantissa.
+    big_integer fractional_numerator{};
+    accumulate_decimal_digits_into_big_integer(fractional_first, fractional_last, fractional_numerator);
+
+    uint32_t const fractional_denominator_exponent = data._exponent < 0
+        ? fractional_digits_present + static_cast<uint32_t>(-data._exponent)
+        : fractional_digits_present;
+
+    big_integer fractional_denominator = make_big_integer(1);
+    if (!multiply_by_power_of_ten(fractional_denominator, fractional_denominator_exponent))
+    {
+        // If there were any digits in the integer part, it is impossible to
+        // underflow (because the exponent cannot possibly be small enough),
+        // so if we underflow here it is a true underflow and we return zero.
+        assemble_floating_point_zero(data._is_negative, result);
+        return SLD_UNDERFLOW;
+    }
+
+    // Because we are using only the fractional part of the mantissa here, the
+    // numerator is guaranteed to be smaller than the denominator.  We normalize
+    // the fraction such that the most significant bit of the numerator is in
+    // the same position as the most significant bit in the denominator.  This
+    // ensures that when we later shift the numerator N bits to the left, we
+    // will produce N bits of precision.
+    uint32_t const fractional_numerator_bits   = bit_scan_reverse(fractional_numerator);
+    uint32_t const fractional_denominator_bits = bit_scan_reverse(fractional_denominator);
+
+    uint32_t const fractional_shift = fractional_denominator_bits > fractional_numerator_bits
+        ? fractional_denominator_bits - fractional_numerator_bits
+        : 0;
+
+    if (fractional_shift > 0)
+    {
+        shift_left(fractional_numerator, fractional_shift);
+    }
+
+    uint32_t const required_fractional_bits_of_precision =
+        required_bits_of_precision -
+        integer_bits_of_precision;
+
+    uint32_t remaining_bits_of_precision_required = required_fractional_bits_of_precision;
+    if (integer_bits_of_precision > 0)
+    {
+        // If the fractional part of the mantissa provides no bits of precision
+        // and cannot affect rounding, we can just take whatever bits we got from
+        // the integer part of the mantissa.  This is the case for numbers like
+        // 5.0000000000000000000001, where the significant digits of the fractional
+        // part start so far to the right that they do not affect the floating
+        // point representation.
+        //
+        // If the fractional shift is exactly equal to the number of bits of
+        // precision that we require, then no fractional bits will be part of the
+        // result, but the result may affect rounding.  This is e.g. the case for
+        // large, odd integers with a fractional part greater than or equal to .5.
+        // Thus, we need to do the division to correctl round the result.
+        if (fractional_shift > remaining_bits_of_precision_required)
+        {
+            return assemble_floating_point_value_from_big_integer(
+                integer_value,
+                integer_bits_of_precision,
+                data._is_negative,
+                fractional_digits_present != 0,
+                result);
+        }
+
+        remaining_bits_of_precision_required -= fractional_shift;
+    }
+
+    // If there was no integer part of the mantissa, we will need to compute the
+    // exponent from the fractional part.  The fractional exponent is the power
+    // of two by which we must multiply the fractional part to move it into the
+    // range [1.0, 2.0).  This will either be the same as the shift we computed
+    // earlier, or one greater than that shift:
+    uint32_t const fractional_exponent = fractional_numerator < fractional_denominator
+        ? fractional_shift + 1
+        : fractional_shift;
+
+    shift_left(fractional_numerator, remaining_bits_of_precision_required);
+    uint64_t fractional_mantissa = divide(fractional_numerator, fractional_denominator);
+
+    bool has_zero_tail = fractional_numerator._used == 0;
+
+    // We may have produced more bits of precision than were required.  Check,
+    // and remove any "extra" bits:
+    uint32_t const fractional_mantissa_bits = bit_scan_reverse(fractional_mantissa);
+    if (fractional_mantissa_bits > required_fractional_bits_of_precision)
+    {
+        uint32_t const shift = fractional_mantissa_bits - required_fractional_bits_of_precision;
+        has_zero_tail         = has_zero_tail && (fractional_mantissa & ((1ui64 << shift) - 1)) == 0;
+        fractional_mantissa >>= shift;
+    }
+
+    // Compose the mantissa from the integer and fractional parts:
+    uint32_t const integer_mantissa_low  = integer_value._used > 0 ? integer_value._data[0] : 0;
+    uint32_t const integer_mantissa_high = integer_value._used > 1 ? integer_value._data[1] : 0;
+    uint64_t const integer_mantissa =
+        integer_mantissa_low +
+        (static_cast<uint64_t>(integer_mantissa_high) << 32);
+
+    uint64_t const complete_mantissa =
+        (integer_mantissa << required_fractional_bits_of_precision) +
+        fractional_mantissa;
+
+    // Compute the final exponent:
+    // * If the mantissa had an integer part, then the exponent is one less than
+    //   the number of bits we obtained from the integer part.  (It's one less
+    //   because we are converting to the form 1.11111, with one 1 to the left
+    //   of the decimal point.)
+    // * If the mantissa had no integer part, then the exponent is the fractional
+    //   exponent that we computed.
+    // Then, in both cases, we subtract an additional one from the exponent, to
+    // account for the fact that we've generated an extra bit of precision, for
+    // use in rounding.
+    int32_t const final_exponent = integer_bits_of_precision > 0
+        ? integer_bits_of_precision                          - 2
+        : -static_cast<int32_t>(fractional_exponent)         - 1;
+
+    return assemble_floating_point_value(complete_mantissa, final_exponent, data._is_negative, has_zero_tail, result);
+}
+
+template <typename FloatingType>
+SLD_STATUS __cdecl convert_decimal_string_to_floating_type(
+    floating_point_string const& data,
+    FloatingType               & result
+    ) throw()
+{
+    return convert_decimal_string_to_floating_type_common(data, floating_point_value(&result));
+}
+
+inline SLD_STATUS __cdecl convert_hexadecimal_string_to_floating_type_common(
+    floating_point_string const& data,
+    floating_point_value  const& result
+    ) throw()
+{
+    uint64_t mantissa = 0;
+    int32_t  exponent = data._exponent + result.mantissa_bits() - 1;
+
+    // Accumulate bits into the mantissa buffer
+    uint8_t const* const mantissa_last = data._mantissa + data._mantissa_count;
+    uint8_t const*       mantissa_it   = data._mantissa;
+    while (mantissa_it != mantissa_last && mantissa <= result.normal_mantissa_mask())
+    {
+        mantissa *= 16;
+        mantissa += *mantissa_it++;
+        exponent -=  4; // The exponent is in binary; log2(16) == 4
+    }
+
+    bool has_zero_tail = true;
+    while (mantissa_it != mantissa_last && has_zero_tail)
+    {
+        has_zero_tail = has_zero_tail && *mantissa_it++ == 0;
+    }
+
+    return assemble_floating_point_value(mantissa, exponent, data._is_negative, has_zero_tail, result);
+}
+
+template <typename FloatingType>
+SLD_STATUS __cdecl convert_hexadecimal_string_to_floating_type(
+    floating_point_string const& data,
+    FloatingType               & result
+    ) throw()
+{
+    return convert_hexadecimal_string_to_floating_type_common(data, floating_point_value(&result));
+}
+
+// The high precision conversion algorithm defined above supports only float and
+// double.  It does not support the 10- and 12-byte extended precision types.
+// These types are supported only for legacy reasons, so we use the old, low-
+// precision algorithm for these types, and do so by overloading the main
+// conversion and assembly functions for _LDBL12.
+void __cdecl assemble_floating_point_zero    (bool is_negative, _LDBL12& result) throw();
+void __cdecl assemble_floating_point_infinity(bool is_negative, _LDBL12& result) throw();
+void __cdecl assemble_floating_point_qnan    (bool is_negative, _LDBL12& result) throw();
+void __cdecl assemble_floating_point_snan    (bool is_negative, _LDBL12& result) throw();
+void __cdecl assemble_floating_point_ind     (_LDBL12& result) throw();
+
+SLD_STATUS __cdecl convert_decimal_string_to_floating_type(
+    floating_point_string const& data,
+    _LDBL12                    & result
+    ) throw();
+
+SLD_STATUS __cdecl convert_hexadecimal_string_to_floating_type(
+    floating_point_string const& data,
+    _LDBL12                    & result
+    ) throw();
+
+template <typename Character, typename CharacterSource>
+bool __cdecl parse_next_characters_from_source(
+    Character const* const uppercase,
+    Character const* const lowercase,
+    size_t           const count,
+    Character&             c,
+    CharacterSource&       source
+    ) throw()
+{
+    for (size_t i = 0; i != count; ++i)
+    {
+        if (c != uppercase[i] && c != lowercase[i])
+        {
+            return false;
+        }
+
+        c = source.get();
+    }
+
+    return true;
+}
+
+template <typename Character, typename CharacterSource>
+bool __cdecl parse_floating_point_possible_nan_is_snan(
+    Character&       c,
+    CharacterSource& source
+    ) throw()
+{
+    static Character const uppercase[] = { 'S', 'N', 'A', 'N', ')' };
+    static Character const lowercase[] = { 's', 'n', 'a', 'n', ')' };
+    return parse_next_characters_from_source(uppercase, lowercase, _countof(uppercase), c, source);
+}
+
+template <typename Character, typename CharacterSource>
+bool __cdecl parse_floating_point_possible_nan_is_ind(
+    Character&       c,
+    CharacterSource& source
+    ) throw()
+{
+    static Character const uppercase[] = { 'I', 'N', 'D', ')' };
+    static Character const lowercase[] = { 'i', 'n', 'd', ')' };
+    return parse_next_characters_from_source(uppercase, lowercase, _countof(uppercase), c, source);
+}
+
+template <typename Character, typename CharacterSource, typename StoredState>
+floating_point_parse_result __cdecl parse_floating_point_possible_infinity(
+    Character&            c,
+    CharacterSource&      source,
+    StoredState           stored_state
+    ) throw()
+{
+    using char_type = typename CharacterSource::char_type;
+
+    auto restore_state = [&]()
+    {
+        source.unget(c);
+        c = '\0';
+        return source.restore_state(stored_state);
+    };
+
+    static char_type const inf_uppercase[] = { 'I', 'N', 'F' };
+    static char_type const inf_lowercase[] = { 'i', 'n', 'f' };
+    if (!parse_next_characters_from_source(inf_uppercase, inf_lowercase, _countof(inf_uppercase), c, source))
+    {
+        return restore_state(), floating_point_parse_result::no_digits;
+    }
+
+    source.unget(c);
+    stored_state = source.save_state();
+    c = source.get();
+
+    static char_type const inity_uppercase[] = { 'I', 'N', 'I', 'T', 'Y' };
+    static char_type const inity_lowercase[] = { 'i', 'n', 'i', 't', 'y' };
+    if (!parse_next_characters_from_source(inity_uppercase, inity_lowercase, _countof(inity_uppercase), c, source))
+    {
+        return restore_state()
+            ? floating_point_parse_result::infinity
+            : floating_point_parse_result::no_digits;
+    }
+
+    source.unget(c);
+    return floating_point_parse_result::infinity;
+}
+
+template <typename Character, typename CharacterSource, typename StoredState>
+floating_point_parse_result __cdecl parse_floating_point_possible_nan(
+    Character&       c,
+    CharacterSource& source,
+    StoredState      stored_state
+    ) throw()
+{
+    using char_type = CharacterSource::char_type;
+
+    auto restore_state = [&]()
+    {
+        source.unget(c);
+        c = '\0';
+        return source.restore_state(stored_state);
+    };
+
+    static char_type const uppercase[] = { 'N', 'A', 'N' };
+    static char_type const lowercase[] = { 'n', 'a', 'n' };
+    if (!parse_next_characters_from_source(uppercase, lowercase, _countof(uppercase), c, source))
+    {
+        return restore_state(), floating_point_parse_result::no_digits;
+    }
+
+    source.unget(c);
+    stored_state = source.save_state();
+    c = source.get();
+
+    if (c != '(')
+    {
+        return restore_state()
+            ? floating_point_parse_result::qnan
+            : floating_point_parse_result::no_digits;
+    }
+
+    c = source.get(); // Advance past the left parenthesis
+
+    // After we've parsed a left parenthesis, test to see whether the parenthesized
+    // string represents a signaling NaN "(SNAN)" or an indeterminate "(IND)".  If
+    // so, we return the corresponding kind of NaN:
+    if (parse_floating_point_possible_nan_is_snan(c, source))
+    {
+        source.unget(c);
+        return floating_point_parse_result::snan;
+    }
+
+    if (parse_floating_point_possible_nan_is_ind(c, source))
+    {
+        source.unget(c);
+        return floating_point_parse_result::indeterminate;
+    }
+
+    // Otherwise, we didn't match one of the two special parenthesized strings.
+    // Keep eating chracters until we come across the right parenthesis or the
+    // end of the character sequence:
+    while (c != ')' && c != '\0')
+    {
+        if (!is_digit_or_nondigit(c))
+        {
+            return restore_state()
+                ? floating_point_parse_result::qnan
+                : floating_point_parse_result::no_digits;
+        }
+
+        c = source.get();
+    }
+
+    if (c != ')')
+    {
+        return restore_state()
+            ? floating_point_parse_result::qnan
+            : floating_point_parse_result::no_digits;
+    }
+
+    return floating_point_parse_result::qnan;
+}
+
+template <typename CharacterSource>
+floating_point_parse_result __cdecl parse_floating_point_from_source(
+    _locale_t             const  locale,
+    CharacterSource            & source,
+    floating_point_string      & fp_string
+    ) throw()
+{
+    using char_type = typename CharacterSource::char_type;
+
+    if (!source.validate())
+    {
+        return floating_point_parse_result::no_digits;
+    }
+
+    auto stored_state = source.save_state();
+    char_type c{source.get()};
+
+    auto restore_state = [&]()
+    {
+        source.unget(c);
+        c = '\0';
+        return source.restore_state(stored_state);
+    };
+
+    // Skip past any leading whitespace:
+    while (is_space(c, locale))
+    {
+        c = source.get();
+    }
+
+    // Check for the optional plus or minus sign:
+    fp_string._is_negative = c == '-';
+    if (c == '-' || c == '+')
+    {
+        c = source.get();
+    }
+
+    // Handle special cases "INF" and "INFINITY" (these are the only accepted
+    // character sequences that start with 'I'):
+    if (c == 'I' || c == 'i')
+    {
+        return parse_floating_point_possible_infinity(c, source, stored_state);
+    }
+
+    // Handle special cases "NAN" and "NAN(...)" (these are the only accepted
+    // character sequences that start with 'N'):
+    if (c == 'N' || c == 'n')
+    {
+        return parse_floating_point_possible_nan(c, source, stored_state);
+    }
+
+    // Check for optional "0x" or "0X" hexadecimal base prefix:
+    bool is_hexadecimal{false};
+    if (c == '0')
+    {
+        auto const next_stored_state = source.save_state();
+
+        char_type const next_c{source.get()};
+        if (next_c == 'x' || next_c == 'X')
+        {
+            is_hexadecimal = true;
+            c = source.get();
+
+            // If we match the hexadecimal base prefix we update the state to
+            // reflect that we consumed the leading zero to handle the case
+            // where a valid mantissa does not follow the base prefix.  In this
+            // case, the "0x" string is treated as a decimal zero subject ("0")
+            // followed by a final string starting with the "x".
+            stored_state = next_stored_state;
+        }
+        else
+        {
+            source.unget(next_c);
+        }
+    }
+
+    uint8_t*       mantissa_first{fp_string._mantissa};
+    uint8_t* const mantissa_last {fp_string._mantissa + _countof(fp_string._mantissa)};
+    uint8_t*       mantissa_it   {fp_string._mantissa};
+
+    // The exponent adjustment holds the number of digits in the mantissa buffer
+    // that appeared before the radix point.  It is positive for number strings
+    // with an integer component and negative for number strings without.
+    int exponent_adjustment{0};
+
+    // Track whether we've seen any digits, so we know whether we've successfully
+    // parsed something:
+    bool found_digits{false};
+
+    // Skip past any leading zeroes in the mantissa:
+    while (c == '0')
+    {
+        found_digits = true;
+        c = source.get();
+    }
+
+    // Scan the integer part of the mantissa:
+    for (; ; c = source.get())
+    {
+        unsigned const max_digit_value{is_hexadecimal ? 0xfu : 9u};
+
+        unsigned const digit_value{parse_digit(c)};
+        if (digit_value > max_digit_value)
+        {
+            break;
+        }
+
+        found_digits = true;
+        if (mantissa_it != mantissa_last)
+        {
+            *mantissa_it++ = static_cast<uint8_t>(digit_value);
+        }
+
+        ++exponent_adjustment;
+    }
+
+    // If a radix point is present, scan the fractional part of the mantissa:
+    char const radix_point{*locale->locinfo->lconv->decimal_point};
+    if (c == radix_point)
+    {
+        c = source.get();
+
+        // If we haven't yet scanned any nonzero digits, continue skipping over
+        // zeroes, updating the exponent adjustment to account for the zeroes
+        // we are skipping:
+        if (mantissa_it == mantissa_first)
+        {
+            while (c == '0')
+            {
+                found_digits = true;
+                --exponent_adjustment;
+                c = source.get();
+            }
+        }
+
+        for (; ; c = source.get())
+        {
+            unsigned const max_digit_value{is_hexadecimal ? 0xfu : 9u};
+
+            unsigned const digit_value{parse_digit(c)};
+            if (digit_value > max_digit_value)
+                break;
+
+            found_digits = true;
+            if (mantissa_it != mantissa_last)
+            {
+                *mantissa_it++ = static_cast<uint8_t>(digit_value);
+            }
+        }
+    }
+
+    if (!found_digits)
+    {
+        // We failed to parse any digits, so attempt to restore back to the last
+        // good terminal state.  This may fail if we are reading from a stream,
+        // we read a hexadecimal base prefix ("0x"), but we did not find any digits
+        // following the base prefix.
+        if (!restore_state())
+        {
+            return floating_point_parse_result::no_digits;
+        }
+
+        // If a hexadecimal base prefix was present ("0x"), then the string is a
+        // valid input:  the "0" is the subject sequence and the "x" is the first
+        // character of the final string.  Otherwise, the string is not a valid
+        // input.
+        if (is_hexadecimal)
+        {
+            return floating_point_parse_result::zero;
+        }
+        else
+        {
+            return floating_point_parse_result::no_digits;
+        }
+    }
+
+    source.unget(c);
+    stored_state = source.save_state();
+    c = source.get();
+
+    // Check for the optional 'e' or 'p' exponent introducer:
+    bool has_exponent{false};
+    switch (c)
+    {
+    case 'e':
+    case 'E':
+        has_exponent = !is_hexadecimal;
+        break;
+
+    case 'p':
+    case 'P':
+        has_exponent = is_hexadecimal;
+        break;
+    }
+
+    // If there was an exponent introducer, scan the exponent:
+    int exponent{0};
+    if (has_exponent)
+    {
+        c = source.get(); // Skip past exponent introducer character
+
+        // Check for the optional plus or minus sign:
+        bool const exponent_is_negative{c == '-'};
+        if (c == '+' || c == '-')
+        {
+            c = source.get();
+        }
+
+        bool has_exponent_digits{false};
+
+        while (c == '0')
+        {
+            has_exponent_digits = true;
+            c = source.get();
+        }
+
+        for (; ; c = source.get())
+        {
+            unsigned const digit_value{parse_digit(c)};
+            if (digit_value >= 10)
+            {
+                break;
+            }
+
+            has_exponent_digits = true;
+            exponent = exponent * 10 + digit_value;
+            if (exponent > maximum_temporary_decimal_exponent)
+            {
+                exponent = maximum_temporary_decimal_exponent + 1;
+                break;
+            }
+        }
+
+        // If the exponent is too large, skip over the remaining exponent digits
+        // so we can correctly update the end pointer:
+        while (parse_digit(c) < 10)
+        {
+            c = source.get();
+        }
+
+        if (exponent_is_negative)
+        {
+            exponent = -exponent;
+        }
+
+        // If no exponent digits were present, attempt to restore the last good
+        // terminal state.
+        if (!has_exponent_digits)
+        {
+            if (restore_state())
+            {
+                // The call to restore_state will have ungotten the exponent
+                // introducer.  Re-get this character, to restore us to the
+                // state we had before we entered the exponent parsing block.
+                c = source.get();
+            }
+            else
+            {
+                return floating_point_parse_result::no_digits;
+            }
+        }
+    }
+
+    // Unget the last character that we read that terminated input.  After this
+    // point, we must not use the source, c, or stored_state.
+    source.unget(c);
+
+    // Remove trailing zeroes from mantissa:
+    while (mantissa_it != mantissa_first && *(mantissa_it - 1) == 0)
+    {
+        --mantissa_it;
+    }
+
+    // If the mantissa buffer is empty, the mantissa was composed of all zeroes
+    // (so the mantissa is 0).  All such strings have the value zero, regardless
+    // what the exponent is (because 0 x b^n == 0 for all b and n).  We can return
+    // now.  Note that we defer this check until after we scan the exponent, so
+    // that we can correctly update end_ptr to point past the end of the exponent.
+    if (mantissa_it == mantissa_first)
+    {
+        return floating_point_parse_result::zero;
+    }
+
+    // Before we adjust the exponent, handle the case where we detected a wildly
+    // out of range exponent during parsing and clamped the value:
+    if (exponent > maximum_temporary_decimal_exponent)
+    {
+        return floating_point_parse_result::overflow;
+    }
+
+    if (exponent < minimum_temporary_decimal_exponent)
+    {
+        return floating_point_parse_result::underflow;
+    }
+
+    // In hexadecimal floating constants, the exponent is a base 2 exponent.  The
+    // exponent adjustment computed during parsing has the same base as the
+    // mantissa (so, 16 for hexadecimal floating constants).  We therefore need to
+    // scale the base 16 multiplier to base 2 by multiplying by log2(16):
+    int const exponent_adjustment_multiplier{is_hexadecimal ? 4 : 1};
+
+    exponent += exponent_adjustment * exponent_adjustment_multiplier;
+
+    // Verify that after adjustment the exponent isn't wildly out of range (if
+    // it is, it isn't representable in any supported floating point format).
+    if (exponent > maximum_temporary_decimal_exponent)
+    {
+        return floating_point_parse_result::overflow;
+    }
+
+    if (exponent < minimum_temporary_decimal_exponent)
+    {
+        return floating_point_parse_result::underflow;
+    }
+
+    fp_string._exponent       = exponent;
+    fp_string._mantissa_count = static_cast<uint32_t>(mantissa_it - mantissa_first);
+
+    return is_hexadecimal
+        ? floating_point_parse_result::hexadecimal_digits
+        : floating_point_parse_result::decimal_digits;
+}
+
+template <typename FloatingType>
+SLD_STATUS __cdecl parse_floating_point_write_result(
+    floating_point_parse_result const  parse_result,
+    floating_point_string       const& fp_string,
+    FloatingType*               const  result
+    ) throw()
+{
+    switch (parse_result)
+    {
+    case floating_point_parse_result::decimal_digits:     return convert_decimal_string_to_floating_type    (fp_string, *result);
+    case floating_point_parse_result::hexadecimal_digits: return convert_hexadecimal_string_to_floating_type(fp_string, *result);
+
+    case floating_point_parse_result::zero:          assemble_floating_point_zero    (fp_string._is_negative, *result); return SLD_OK;
+    case floating_point_parse_result::infinity:      assemble_floating_point_infinity(fp_string._is_negative, *result); return SLD_OK;
+    case floating_point_parse_result::qnan:          assemble_floating_point_qnan    (fp_string._is_negative, *result); return SLD_OK;
+    case floating_point_parse_result::snan:          assemble_floating_point_snan    (fp_string._is_negative, *result); return SLD_OK;
+    case floating_point_parse_result::indeterminate: assemble_floating_point_ind     (                        *result); return SLD_OK;
+
+    case floating_point_parse_result::no_digits:     assemble_floating_point_zero    (false,                  *result); return SLD_NODIGITS;
+    case floating_point_parse_result::underflow:     assemble_floating_point_zero    (fp_string._is_negative, *result); return SLD_UNDERFLOW;
+    case floating_point_parse_result::overflow:      assemble_floating_point_infinity(fp_string._is_negative, *result); return SLD_OVERFLOW;
+
+    default:
+        // Unreachable
+        _ASSERTE(false);
+        return SLD_NODIGITS;
+    }
+}
+
+template <typename CharacterSource, typename FloatingType>
+DECLSPEC_NOINITALL
+SLD_STATUS __cdecl parse_floating_point(
+    _locale_t       const locale,
+    CharacterSource       source,
+    FloatingType*   const result
+    ) throw()
+{
+    using char_type = typename CharacterSource::char_type;
+
+    _VALIDATE_RETURN(result != nullptr, EINVAL, SLD_NODIGITS);
+    _VALIDATE_RETURN(locale != nullptr, EINVAL, SLD_NODIGITS);
+
+    // PERFORMANCE NOTE:  fp_string is intentionally left uninitialized.  Zero-
+    // initialization is quite expensive and is unnecessary.  The benefit of not
+    // zero-initializing is greatest for short inputs.
+    floating_point_string fp_string;
+
+    floating_point_parse_result const parse_result = parse_floating_point_from_source(locale, source, fp_string);
+
+    return parse_floating_point_write_result(parse_result, fp_string, result);
+}
+
+} // namespace __crt_strtox
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Character Sources
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+namespace __crt_strtox {
+
+template <typename Character>
+class c_string_character_source
+{
+public:
+
+    typedef Character char_type;
+
+    c_string_character_source(
+        Character const*  const string,
+        Character const** const end
+        ) throw()
+        : _p{string}, _end{end}
+    {
+        if (end)
+        {
+            *end = string;
+        }
+    }
+
+    c_string_character_source(c_string_character_source&& other) throw()
+        : _p{other._p}, _end{other._end}
+    {
+        other._p   = nullptr;
+        other._end = nullptr;
+    }
+
+    c_string_character_source& operator=(c_string_character_source&& other) throw()
+    {
+        _p   = other._p;
+        _end = other._end;
+
+        other._p   = nullptr;
+        other._end = nullptr;
+        return *this;
+    }
+
+    ~c_string_character_source()
+    {
+        if (_end)
+        {
+            *_end = _p;
+        }
+    }
+
+    bool validate() const throw()
+    {
+        _VALIDATE_RETURN(_p != nullptr, EINVAL, false);
+        return true;
+    }
+
+    Character get() throw()
+    {
+        return *_p++;
+    }
+
+    void unget(Character const c) throw()
+    {
+        --_p;
+        _VALIDATE_RETURN_VOID(c == '\0' || *_p == c, EINVAL);
+    }
+
+    Character const* save_state() const throw()
+    {
+        return _p;
+    }
+
+    bool restore_state(Character const* const state) throw()
+    {
+        _p = state;
+        return true;
+    }
+
+private:
+
+    c_string_character_source(c_string_character_source const&) = delete;
+    c_string_character_source& operator=(c_string_character_source const&) = delete;
+
+    Character const*  _p;
+    Character const** _end;
+};
+
+template <typename Character, typename EndPointer>
+c_string_character_source<Character> __cdecl make_c_string_character_source(
+    Character const* const string,
+    EndPointer       const end
+    ) throw()
+{
+    return c_string_character_source<Character>(string, const_cast<Character const**>(end));
+}
+
+template <typename Integer, typename Character, typename EndPointer>
+__forceinline Integer __cdecl parse_integer_from_string(
+    Character const* const string,
+    EndPointer       const end,
+    int              const base,
+    _locale_t        const locale
+    ) throw()
+{
+    __crt_cached_ptd_host ptd{locale};
+
+    return static_cast<Integer>(parse_integer<typename make_unsigned<Integer>::type>(
+        ptd,
+        make_c_string_character_source(string, end),
+        base,
+        is_signed<Integer>::value));
+}
+
+template <typename InputAdapter>
+class input_adapter_character_source
+{
+public:
+
+    typedef typename InputAdapter::char_type    char_type;
+    typedef __acrt_stdio_char_traits<char_type> traits;
+
+    input_adapter_character_source(
+        InputAdapter* const input_adapter,
+        uint64_t      const width,
+        bool*         const succeeded
+        ) throw()
+        : _input_adapter{input_adapter},
+          _max_get_count{width        },
+          _get_count    {0            },
+          _succeeded    {succeeded    }
+    {
+        if (succeeded)
+            *succeeded = true;
+    }
+
+    input_adapter_character_source(input_adapter_character_source&& other) throw()
+        : _input_adapter{other._input_adapter},
+          _max_get_count{other._max_get_count},
+          _get_count    {other._get_count    },
+          _succeeded    {other._succeeded    }
+    {
+        other._input_adapter = nullptr;
+        other._succeeded     = nullptr;
+    }
+
+    input_adapter_character_source& operator=(input_adapter_character_source&& other) throw()
+    {
+        _input_adapter = other._input_adapter;
+        _max_get_count = other._max_get_count;
+        _get_count     = other._get_count;
+        _succeeded     = other._succeeded;
+
+        other._input_adapter = nullptr;
+        other._succeeded     = nullptr;
+        return *this;
+    }
+
+    ~input_adapter_character_source()
+    {
+        // If no characters were consumed, report as a failure.  This occurs if
+        // a matching failure occurs on the first character (if it occurs on a
+        // subsequent character, then the attempt to restore state will have
+        // failed and will set the failure flag).
+        if (_succeeded != nullptr && _get_count == 0)
+        {
+            *_succeeded = false;
+        }
+    }
+
+    bool validate() const throw()
+    {
+        _VALIDATE_RETURN(_input_adapter != nullptr, EINVAL, false);
+        _VALIDATE_RETURN(_succeeded     != nullptr, EINVAL, false);
+        return true;
+    }
+
+    char_type get() throw()
+    {
+        ++_get_count;
+
+        if (_max_get_count != 0 && _get_count > _max_get_count)
+            return '\0';
+
+        auto c = _input_adapter->get();
+        if (c == traits::eof)
+            return '\0';
+
+        return static_cast<char_type>(c);
+    }
+
+    void unget(char_type const c) throw()
+    {
+        --_get_count;
+
+        if (_max_get_count != 0 && _get_count > _max_get_count)
+            return;
+
+        if (c == '\0' || c == traits::eof)
+            return;
+
+        _input_adapter->unget(c);
+    }
+
+    uint64_t save_state() const throw()
+    {
+        return _get_count;
+    }
+
+    bool restore_state(uint64_t const get_count) throw()
+    {
+        if (get_count != _get_count)
+        {
+            *_succeeded = false;
+            return false;
+        }
+
+        return true;
+    }
+
+private:
+
+    input_adapter_character_source(input_adapter_character_source const&) = delete;
+    input_adapter_character_source& operator=(input_adapter_character_source const&) = delete;
+
+    InputAdapter* _input_adapter;
+    uint64_t      _max_get_count;
+    uint64_t      _get_count;
+    bool*         _succeeded;
+};
+
+template <typename InputAdapter>
+input_adapter_character_source<InputAdapter> __cdecl make_input_adapter_character_source(
+    InputAdapter* const input_adapter,
+    uint64_t      const width,
+    bool*         const succeeded
+    ) throw()
+{
+    return input_adapter_character_source<InputAdapter>{input_adapter, width, succeeded};
+}
+
+} // namespace __crt_strtox
+
+// Internal-only variations of the above functions
+
+// Note this is different from a usual tcstol call in that whitespace is not
+// trimmed in order to avoid acquiring the global locale for code paths that
+// do not require that functionality.
+template <typename Character, typename EndPointer, bool TrimWhitespace = false>
+__forceinline long __cdecl _tcstol_internal(
+    __crt_cached_ptd_host&   ptd,
+    Character const*   const string,
+    EndPointer         const end,
+    int                const base
+    ) throw()
+{
+    return static_cast<long>(__crt_strtox::parse_integer<unsigned long, __crt_strtox::c_string_character_source<Character>, TrimWhitespace>(
+        ptd,
+        __crt_strtox::make_c_string_character_source(string, end),
+        base,
+        true // long is signed
+        ));
+}
+
+#pragma pop_macro("_INVALID_PARAMETER")
+#pragma pop_macro("_VALIDATE_RETURN")
+#pragma pop_macro("_VALIDATE_RETURN_VOID")
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_time.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_time.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae59e31be025d9a3b6a832d92a41e3911ce73a53
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_time.h	
@@ -0,0 +1,216 @@
+//
+// corecrt_internal_time.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines internal utilities for working with the time
+// library.
+//
+#pragma once
+
+#include <corecrt.h>
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <io.h>
+#include <sys/utime.h>
+#include <time.h>
+
+#pragma pack(push, _CRT_PACKING)
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Constants
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Number of 100 nanosecond units from 1/1/1601 to 1/1/1970
+#define _EPOCH_BIAS 116444736000000000i64
+
+#define _DAY_SEC       (24 * 60 * 60)    // Seconds in a day
+#define _YEAR_SEC      (365 * _DAY_SEC)  // Seconds in a year
+#define _FOUR_YEAR_SEC (1461 * _DAY_SEC) // Seconds in a four-year interval
+#define _BASE_YEAR     70                // The epoch year (1970)
+#define _BASE_DOW      4                 // The day of week of 01-Jan-70 (Thursday)
+
+// Maximum local time adjustment (GMT + 14 Hours, DST -0 Hours)
+#define _MAX_LOCAL_TIME (14 * 60 * 60)
+
+// Minimum local time adjustment (GMT - 11 Hours, DST - 1 Hours)
+#define _MIN_LOCAL_TIME (-12 * 60 * 60)
+
+#define _TZ_STRINGS_SIZE 64
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Global Data
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C"
+{
+    extern char const __dnames[];
+    extern char const __mnames[];
+
+    extern int const _days[];
+    extern int const _lpdays[];
+}
+
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Integer Traits
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename TimeType>
+struct __crt_time_time_t_traits;
+
+template <>
+struct __crt_time_time_t_traits<__time32_t> : __crt_integer_traits<__time32_t>
+{
+    typedef _timespec32 timespec_type;
+
+    enum : long
+    {
+        // Number of seconds from 00:00:00, 01/01/1970 UTC to 23:59:59, 01/18/2038 UTC
+        max_time_t = 0x7fffd27f,
+    };
+
+    enum : unsigned long
+    {
+        // The maximum representable year
+        max_year = 138,  // 2038 is the maximum year
+    };
+};
+
+template <>
+struct __crt_time_time_t_traits<__time64_t> : __crt_integer_traits<__time64_t>
+{
+    typedef _timespec64 timespec_type;
+
+    enum : long long
+    {
+        // Number of seconds from 00:00:00, 01/01/1970 UTC to 07:59:59, 01/19/3001 UTC
+        // Note that the end of the epoch was intended to be 23:59:59, 01/18/3001 UTC,
+        // but this was mistakenly computed from a PST value (thus the 8 hour delta).
+        max_time_t = 0x793582affLL,
+    };
+
+    enum : unsigned long long
+    {
+        // The maximum representable year
+        max_year = 1101, // 3001 is the maximum year
+    };
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Combined Traits
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename TimeType, typename Character>
+struct __crt_time_traits
+    : __crt_char_traits<Character>,
+      __crt_time_time_t_traits<TimeType>
+{
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Utilities
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Union to facilitate converting from FILETIME to unsigned __int64
+union __crt_filetime_union
+{
+    unsigned __int64 _scalar;
+    FILETIME         _filetime;
+};
+
+
+
+extern "C"
+{
+    int  __cdecl _isindst(_In_ tm* _Time);
+    void __cdecl __tzset();
+    tm*  __cdecl __getgmtimebuf();
+
+    __time32_t __cdecl __loctotime32_t(int, int, int, int, int, int, int);
+    __time64_t __cdecl __loctotime64_t(int, int, int, int, int, int, int);
+}
+
+
+
+// Tests if the given year is a leap year.  The year is not the absolute year;
+// it is the number of years since 1900.
+template <typename TimeType>
+bool __cdecl __crt_time_is_leap_year(TimeType const yr) throw()
+{
+    if (yr % 4 == 0 && yr % 100 != 0)
+        return true;
+
+    if ((yr + 1900) % 400 == 0)
+        return true;
+
+    return false;
+}
+
+// Computes the number of leap years that have elapsed betwwen 1970 up to, but
+// not including, the specified year.  The year is not the absolute year; it is
+// the number of years since 1900.
+template <typename TimeType>
+TimeType __cdecl __crt_time_elapsed_leap_years(TimeType const yr) throw()
+{
+    static TimeType const leap_years_between_1900_and_1970 = 17;
+
+    TimeType const elapsed_leap_years = ((yr - 1) / 4) - ((yr - 1) / 100) + ((yr + 299) / 400);
+
+    return elapsed_leap_years - leap_years_between_1900_and_1970;
+}
+
+// Tests if the given date is valid (i.e., if such a day actually existed).
+inline bool __cdecl __crt_time_is_day_valid(int const yr, int const mo, int const dy) throw()
+{
+    if (dy <= 0)
+        return false;
+
+    int const days_in_month = _days[mo + 1] - _days[mo];
+    if (dy <= days_in_month)
+        return true;
+
+    // Special case for February:
+    if (__crt_time_is_leap_year(yr) && mo == 1 && dy <= 29)
+        return true;
+
+    return false;
+}
+
+inline int __crt_get_2digit_year(int const year) throw()
+{
+    return (1900 + year) % 100;
+}
+
+inline int __crt_get_century(int const year) throw()
+{
+    return (1900 + year) / 100;
+}
+
+extern "C" _Success_(return > 0) size_t __cdecl _Wcsftime_l(
+    _Out_writes_z_(max_size) wchar_t*       string,
+    _In_                     size_t         max_size,
+    _In_z_                   wchar_t const* format,
+    _In_                     tm const*      timeptr,
+    _In_opt_                 void*          lc_time_arg,
+    _In_opt_                 _locale_t      locale
+    );
+
+_Check_return_ _Deref_ret_z_
+extern "C" wchar_t** __cdecl __wide_tzname();
+
+#pragma pack(pop)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_traits.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..d43ba91ce899684e90f6bd2394cf017a9652f1c3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_traits.h	
@@ -0,0 +1,276 @@
+//
+// corecrt_internal_traits.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines template-based utilities for implementing sets
+// of functions that are largely similar but which operate on different kinds of
+// strings (narrow or wide) or different kinds of integers (32-bit or 64-bit).
+// It is similar in some respects to the macro-based <tchar.h>.
+//
+#pragma once
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_win32_buffer.h>
+#include <stdio.h>
+#include <string.h>
+
+#pragma pack(push, _CRT_PACKING)
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Character Traits
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename Character>
+struct __crt_char_traits;
+
+#define _CORECRT_APPLY_TO_MAPPINGS(_APPLY)                                                                                                       \
+    _APPLY(capture_argv,                       __acrt_capture_narrow_argv,                       __acrt_capture_wide_argv                      ) \
+    _APPLY(create_process,                     __acrt_CreateProcessA,                            CreateProcessW                                ) \
+    _APPLY(find_first_file_ex,                 __acrt_FindFirstFileExA,                          FindFirstFileExW                              ) \
+    _APPLY(find_next_file,                     __acrt_FindNextFileA,                             FindNextFileW                                 ) \
+    _APPLY(free_environment_strings,           FreeEnvironmentStringsA,                          FreeEnvironmentStringsW                       ) \
+    _APPLY(ftprintf,                           fprintf,                                          fwprintf                                      ) \
+    _APPLY(get_current_directory,              __acrt_get_current_directory_narrow_acp_or_utf8,  __acrt_get_current_directory_wide             ) \
+    _APPLY(get_environment_from_os,            __dcrt_get_narrow_environment_from_os,            __dcrt_get_wide_environment_from_os           ) \
+    _APPLY(get_full_path_name,                 __acrt_get_full_path_name_narrow_acp_or_utf8,     __acrt_get_full_path_name_wide                ) \
+    _APPLY(get_module_file_name,               __acrt_GetModuleFileNameA,                        GetModuleFileNameW                            ) \
+    _APPLY(get_or_create_environment_nolock,   __dcrt_get_or_create_narrow_environment_nolock,   __dcrt_get_or_create_wide_environment_nolock  ) \
+    _APPLY(get_temp_path,                      __acrt_GetTempPath2A,                             __acrt_GetTempPath2W                           ) \
+    _APPLY(getc_nolock,                        _getc_nolock,                                     _getwc_nolock                                 ) \
+    _APPLY(gettche_nolock,                     _getche_nolock,                                   _getwche_nolock                               ) \
+    _APPLY(initialize_environment_nolock,      _initialize_narrow_environment,                   _initialize_wide_environment                  ) \
+    _APPLY(istspace,                           isspace,                                          iswspace                                      ) \
+    _APPLY(itot_s,                             _itoa_s,                                          _itow_s                                       ) \
+    _APPLY(message_box,                        __acrt_MessageBoxA,                               __acrt_MessageBoxW                            ) \
+    _APPLY(open_file,                          _openfile,                                        _wopenfile                                    ) \
+    _APPLY(output_debug_string,                __acrt_OutputDebugStringA,                        OutputDebugStringW                            ) \
+    _APPLY(pack_command_line_and_environment,  __acrt_pack_narrow_command_line_and_environment,  __acrt_pack_wide_command_line_and_environment ) \
+    _APPLY(puttc_nolock_internal,              _fputc_nolock_internal,                           _fputwc_nolock_internal                       ) \
+    _APPLY(puttch_nolock_internal,             _putch_nolock_internal,                           _putwch_nolock_internal                       ) \
+    _APPLY(set_current_directory,              __acrt_SetCurrentDirectoryA,                      SetCurrentDirectoryW                          ) \
+    _APPLY(set_environment_variable,           __acrt_SetEnvironmentVariableA,                   SetEnvironmentVariableW                       ) \
+    _APPLY(set_program_name,                   _set_pgmptr,                                      _set_wpgmptr                                  ) \
+    _APPLY(set_variable_in_environment_nolock, __dcrt_set_variable_in_narrow_environment_nolock, __dcrt_set_variable_in_wide_environment_nolock) \
+    _APPLY(show_message_box,                   __acrt_show_narrow_message_box,                   __acrt_show_wide_message_box                  ) \
+    _APPLY(sntprintf_s,                        _snprintf_s,                                      _snwprintf_s                                  ) \
+    _APPLY(taccess_s,                          _access_s,                                        _waccess_s                                    ) \
+    _APPLY(tasctime,                           asctime,                                          _wasctime                                     ) \
+    _APPLY(tasctime_s,                         asctime_s,                                        _wasctime_s                                   ) \
+    _APPLY(tcscat_s,                           strcat_s,                                         wcscat_s                                      ) \
+    _APPLY(tcschr,                             strchr,                                           wcschr                                        ) \
+    _APPLY(tcscmp,                             strcmp,                                           wcscmp                                        ) \
+    _APPLY(tcscpy_s,                           strcpy_s,                                         wcscpy_s                                      ) \
+    _APPLY(tcserror_s,                         strerror_s,                                       _wcserror_s                                   ) \
+    _APPLY(tcsicmp,                            _stricmp,                                         _wcsicmp                                      ) \
+    _APPLY(tcslen,                             strlen,                                           wcslen                                        ) \
+    _APPLY(tcsnlen_s,                          strnlen_s,                                        wcsnlen_s                                     ) \
+    _APPLY(tcsncat_s,                          strncat_s,                                        wcsncat_s                                     ) \
+    _APPLY(tcsncmp,                            strncmp,                                          wcsncmp                                       ) \
+    _APPLY(tcsncpy_s,                          strncpy_s,                                        wcsncpy_s                                     ) \
+    _APPLY(tcsnicmp,                           _strnicmp,                                        _wcsnicmp                                     ) \
+    _APPLY(tcsnicoll,                          _strnicoll,                                       _wcsnicoll                                    ) \
+    _APPLY(tcsnlen,                            strnlen,                                          wcsnlen                                       ) \
+    _APPLY(tcspbrk,                            strpbrk,                                          wcspbrk                                       ) \
+    _APPLY(tcsrchr,                            strrchr,                                          wcsrchr                                       ) \
+    _APPLY(tcstoull,                           strtoull,                                         wcstoull                                      ) \
+    _APPLY(tdupenv_s_crt,                      _dupenv_s_crt,                                    _wdupenv_s_crt                                ) \
+    _APPLY(texecve,                            _execve,                                          _wexecve                                      ) \
+    _APPLY(tfdopen,                            _fdopen,                                          _wfdopen                                      ) \
+    _APPLY(tfullpath,                          _fullpath,                                        _wfullpath                                    ) \
+    _APPLY(tgetcwd,                            _getcwd,                                          _wgetcwd                                      ) \
+    _APPLY(tgetpath,                           __acrt_getpath,                                   __acrt_wgetpath                               ) \
+    _APPLY(tmktemp_s,                          _mktemp_s,                                        _wmktemp_s                                    ) \
+    _APPLY(tsopen_nolock,                      _sopen_nolock,                                    _wsopen_nolock                                ) \
+    _APPLY(tsopen_s,                           _sopen_s,                                         _wsopen_s                                     ) \
+    _APPLY(tspawnve,                           _spawnve,                                         _wspawnve                                     ) \
+    _APPLY(tspawnvpe,                          _spawnvpe,                                        _wspawnvpe                                    ) \
+    _APPLY(ulltot_s,                           _ui64toa_s,                                       _ui64tow_s                                    ) \
+    _APPLY(ultot_s,                            _ultoa_s,                                         _ultow_s                                      ) \
+    _APPLY(ungettc_nolock,                     _ungetc_nolock,                                   _ungetwc_nolock                               ) \
+    _APPLY(ungettch_nolock,                    _ungetch_nolock,                                  _ungetwch_nolock                              )
+
+template <>
+struct __crt_char_traits<char>
+{
+    typedef char           char_type;
+    typedef unsigned char  unsigned_char_type;
+    typedef wchar_t        other_char_type;
+    typedef int            int_type;
+    typedef STARTUPINFOA   startup_info_type;
+    typedef WIN32_FIND_DATAA win32_find_data_type;
+
+    #define _APPLY(name, narrow_name, wide_name) _CORECRT_GENERATE_FORWARDER(static, __cdecl, name, narrow_name)
+    _CORECRT_APPLY_TO_MAPPINGS(_APPLY)
+    #undef _APPLY
+};
+
+template <>
+struct __crt_char_traits<wchar_t>
+{
+    typedef wchar_t        char_type;
+    typedef wchar_t        unsigned_char_type;
+    typedef char           other_char_type;
+    typedef wint_t         int_type;
+    typedef STARTUPINFOW   startup_info_type;
+    typedef WIN32_FIND_DATAW win32_find_data_type;
+
+    #define _APPLY(name, narrow_name, wide_name) _CORECRT_GENERATE_FORWARDER(static, __cdecl, name, wide_name)
+    _CORECRT_APPLY_TO_MAPPINGS(_APPLY)
+    #undef _APPLY
+};
+
+#undef _CORECRT_APPLY_TO_MAPPINGS
+
+
+
+#define _GENERATE_TCHAR_STRING_FUNCTIONS(name, string)                                                        \
+    static char    const* __cdecl _CRT_CONCATENATE(get_, name)(char)    throw() { return string; }            \
+    static wchar_t const* __cdecl _CRT_CONCATENATE(get_, name)(wchar_t) throw() { return _CRT_WIDE(string); } \
+    static size_t const _CRT_CONCATENATE(name, _length) = _countof(string) - 1;                               \
+    static size_t const _CRT_CONCATENATE(name, _count ) = _countof(string);
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Integer Traits
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename Integer>
+struct __crt_integer_traits;
+
+#define _CORECRT_APPLY_TO_MAPPINGS(_APPLY)                  \
+    _APPLY(ftell_nolock, _ftell_nolock,   _ftelli64_nolock) \
+    _APPLY(lseek,        _lseek,          _lseeki64       ) \
+    _APPLY(lseek_nolock, _lseek_nolock,   _lseeki64_nolock) \
+    _APPLY(futime,       _futime32,       _futime64       ) \
+    _APPLY(gmtime_s,     _gmtime32_s,     _gmtime64_s     ) \
+    _APPLY(localtime_s,  _localtime32_s,  _localtime64_s  ) \
+    _APPLY(loctotime,    __loctotime32_t, __loctotime64_t ) \
+    _APPLY(time,         _time32,         _time64         )
+
+template <>
+struct __crt_integer_traits<long>
+{
+    #define _APPLY(name, name_32, name_64) _CORECRT_GENERATE_FORWARDER(static, __cdecl, name, name_32)
+    _CORECRT_APPLY_TO_MAPPINGS(_APPLY)
+    #undef _APPLY
+};
+
+template <>
+struct __crt_integer_traits<long long>
+{
+    #define _APPLY(name, name_32, name_64) _CORECRT_GENERATE_FORWARDER(static, __cdecl, name, name_64)
+    _CORECRT_APPLY_TO_MAPPINGS(_APPLY)
+    #undef _APPLY
+};
+
+#undef _CORECRT_APPLY_TO_MAPPINGS
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// char <=> wchar_t conversion utilities
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Complete list of internal conversion functions (only some defined here):
+// * __acrt_WideCharToMultiByte / __acrt_MultiByteToWideChar
+//     * Provides option compatibility to ensure we don't get ERROR_INVALID_FLAGS due to code page changes.
+//     * Other functions in this list use this to be implemented.
+// * wcstombs / mbstowcs
+//     * Public conversion functions, also used internally.
+//     * Should try to use _l variants when possible to avoid overhead of grabbing per-thread data.
+// * __acrt_mbs_to_wcs / __acrt_wcs_to_mbs
+//     * Should be used by default - uses wcstombs / mbstowcs.
+//     * Provides automatic space allocation with __crt_win32_buffer.
+// * __acrt_mbs_to_wcs_cp / __acrt_wcs_to_mbs_cp
+//     * Should be used by default, using code page instead of _locale_t.
+//     * Less optimizations - can't detect "C" locale for quick conversion.
+//     * Provides automatic space allocation with __crt_win32_buffer.
+//     * Uses __acrt_WideChartoMultiByte / __acrt_MultiByteToWideChar.
+// * __crt_compute_required_transform_buffer_count / __crt_transform_string
+//     * Used by environment initialization.
+//     * Only one (narrow or wide) environment may be available from the OS,
+//       the other needs to be cloned into the other.
+//
+// Places where we don't use current global locale, user-supplied locale, or ACP/UTF-8 adapter:
+// CP_ACP - __acrt_GetTempPath2A (via tmpnam)
+//     * Documented to do so on MSDN.
+//     * Required by API design - static buffer returned to user
+//     * Therefore, characters cannot be modified according to locale.
+// CP_ACP - Environment Initialization
+//     * This is done at startup and does not change based off of locale, so using the ACP is correct.
+// GetConsoleOutputCP() - write_double_translated_ansi_nolock (via _write)
+// GetConsoleCP() - _getch
+// CP_UTF8 - write_text_utf8_nolock (via _write)
+//
+// The following functions previous to UTF-8 awareness used the ACP for char conversions.
+// To avoid backwards compatibility issues, they will still use the ACP, except when the currently
+// set locale is CP_UTF8.
+// * _access
+// * _chdir
+// * _chmod
+// * _exec*
+// * _findfile*
+// * _fullpath
+// * _loaddll
+// * _mkdir
+// * _popen
+// * _remove
+// * _rename
+// * _rmdir
+// * _sopen
+// * _spawn*
+// * _stat*
+// * _unlink
+// * Wildcard parsing in argv with setargv.obj
+// * Calls to get the current module name for debug pop-up windows and assert messages (via __acrt_GetModuleFileNameA)
+// * Setting _tzname when value provided via TZ environment variable.
+//
+
+inline size_t __crt_compute_required_transform_buffer_count(
+            unsigned    const code_page,
+    _In_z_  char const* const string
+    )
+{
+    return static_cast<size_t>(__acrt_MultiByteToWideChar(code_page, 0, string, -1, nullptr, 0));
+}
+
+inline size_t __crt_compute_required_transform_buffer_count(
+            unsigned        const code_page,
+    _In_z_  wchar_t const*  const string
+    )
+{
+    return static_cast<size_t>(__acrt_WideCharToMultiByte(code_page, 0, string, -1, nullptr, 0, nullptr, nullptr));
+}
+
+_Success_(return > 0 && return <= buffer_count)
+inline size_t __crt_transform_string(
+                                    unsigned    const   code_page,
+    _In_z_                          char const* const   string,
+    _Out_writes_z_(buffer_count)    wchar_t*    const   buffer,
+    size_t      const buffer_count
+    )
+{
+    int const int_count = static_cast<int>(buffer_count);
+    return static_cast<size_t>(__acrt_MultiByteToWideChar(code_page, 0, string, -1, buffer, int_count));
+}
+
+_Success_(return > 0 && return <= buffer_count)
+inline size_t __crt_transform_string(
+                                    unsigned        const   code_page,
+    _In_z_                          wchar_t const*  const   string,
+    _Out_writes_z_(buffer_count)    char*           const   buffer,
+    size_t                                          const   buffer_count
+    )
+{
+    int const int_count = static_cast<int>(buffer_count);
+    return static_cast<size_t>(__acrt_WideCharToMultiByte(code_page, 0, string, -1, buffer, int_count, nullptr, nullptr));
+}
+
+#pragma pack(pop)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_win32_buffer.h b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_win32_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..f40552419840b4202134a2f4d690f5a19c82e1cc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/corecrt_internal_win32_buffer.h	
@@ -0,0 +1,799 @@
+//
+// corecrt_internal_win32_buffer.h
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This internal header defines template-based utilities for handling call-twice
+// Win32 APIs, where you first call the Win32 API with null or a fixed sized buffer,
+// and if there is not enough space, allocate a dynamically sized buffer.
+#pragma once
+#include <corecrt_internal.h>
+
+#pragma pack(push, _CRT_PACKING)
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// __crt_win32_buffer_debug_info
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// This is a class that can be used to describe the block_use, file_name, line_number
+// debug data that is sometimes shuffled around between function calls.
+
+class __crt_win32_buffer_debug_info
+{
+#ifndef _DEBUG
+public:
+    __crt_win32_buffer_debug_info(int, char const *, int)
+    {
+    }
+#else /* ^^^^ Release ^^^^ / vvvv Debug vvvv */
+public:
+    __crt_win32_buffer_debug_info(
+        int const          initial_block_use,
+        char const * const initial_file_name,
+        int const          initial_line_number
+        )
+        : _block_use(initial_block_use),
+          _file_name(initial_file_name),
+          _line_number(initial_line_number)
+    {
+    }
+
+    int block_use() const
+    {
+        return _block_use;
+    }
+
+    char const * file_name() const
+    {
+        return _file_name;
+    }
+
+    int line_number() const
+    {
+        return _line_number;
+    }
+
+private:
+    int          _block_use;
+    char const * _file_name;
+    int          _line_number;
+#endif /* _DEBUG */
+};
+
+class __crt_win32_buffer_empty_debug_info
+{
+};
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// __crt_win32_buffer resize policies
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These classes are used to describe the different resize policies that a
+// __crt_win32_buffer can have.
+
+struct __crt_win32_buffer_internal_dynamic_resizing
+{
+    using debug_info_type = __crt_win32_buffer_empty_debug_info;
+
+    _Check_return_
+    static errno_t allocate(void ** const address, size_t const size, debug_info_type const&)
+    {
+        void * const ret = _malloc_crt(size);
+        *address = ret;
+        if (ret == nullptr) {
+            return ENOMEM;
+        }
+        return 0;
+    }
+
+    static void deallocate(void * const ptr, debug_info_type const&)
+    {
+        _free_crt(ptr);
+    }
+};
+
+struct __crt_win32_buffer_public_dynamic_resizing
+{
+    using debug_info_type = __crt_win32_buffer_debug_info;
+
+    _Check_return_
+    static errno_t allocate(void ** const address, size_t const size, debug_info_type const& debug_info)
+    {
+        UNREFERENCED_PARAMETER(debug_info); // only used in debug mode
+        void * const ret = _malloc_dbg(
+            size,
+            debug_info.block_use(),
+            debug_info.file_name(),
+            debug_info.line_number()
+            );
+        *address = ret;
+        if (ret == nullptr) {
+            return ENOMEM;
+        }
+        return 0;
+    }
+
+    static void deallocate(void * const ptr, debug_info_type const& debug_info)
+    {
+        UNREFERENCED_PARAMETER(debug_info); // only used in debug mode
+        _free_dbg(ptr, debug_info.block_use());
+    }
+};
+
+struct __crt_win32_buffer_no_resizing
+{
+    using debug_info_type = __crt_win32_buffer_empty_debug_info;
+
+    _Check_return_
+    static errno_t allocate(void ** const, size_t const, debug_info_type const&)
+    {
+        errno = ERANGE; // buffer not large enough
+        return ERANGE;
+    }
+
+    static void deallocate(void * const, debug_info_type const&)
+    {
+    }
+};
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// __crt_win32_buffer, __crt_internal_win32_buffer
+// __crt_public_win32_buffer, __crt_no_alloc_win32_buffer
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Class and typedefs for buffers that support calling a win32 function and automatically
+// resizing if needed.
+
+template <typename Character, typename ResizePolicy>
+class __crt_win32_buffer : private ResizePolicy::debug_info_type
+{   // Buffer type to enable Win32 call-twice-if-not-enough-space APIs.
+    // Using this type allows us to use a local buffer if possible and allocate if needed.
+public:
+    using char_type = Character;
+    using debug_info_type = typename ResizePolicy::debug_info_type;
+
+    __crt_win32_buffer()
+        : debug_info_type(),
+          _initial_string(nullptr),
+          _initial_capacity(0),
+          _string(nullptr),
+          _capacity(0),
+          _size(0),
+          _is_dynamic(false)
+
+    {
+    }
+
+    explicit __crt_win32_buffer(debug_info_type const& debug_info)
+        : debug_info_type(debug_info),
+          _initial_string(nullptr),
+          _initial_capacity(0),
+          _string(nullptr),
+          _capacity(0),
+          _size(0),
+          _is_dynamic(false)
+
+    {
+    }
+
+    template <size_t N>
+    __crt_win32_buffer(Character (&buffer)[N])
+        : debug_info_type(),
+          _initial_string(buffer),
+          _initial_capacity(N),
+          _string(buffer),
+          _capacity(N),
+          _size(0),
+          _is_dynamic(false)
+    {
+    }
+
+    template <size_t N>
+    __crt_win32_buffer(Character (&buffer)[N], debug_info_type const& debug_info)
+        : debug_info_type(debug_info),
+          _initial_string(buffer),
+          _initial_capacity(N),
+          _string(buffer),
+          _capacity(N),
+          _size(0),
+          _is_dynamic(false)
+    {
+    }
+
+    __crt_win32_buffer(
+        Character * const buffer,
+        size_t const buffer_capacity
+        )
+        : debug_info_type(),
+          _initial_string(buffer),
+          _initial_capacity(buffer_capacity),
+          _string(buffer),
+          _capacity(buffer_capacity),
+          _size(0),
+          _is_dynamic(false)
+    {
+    }
+
+    __crt_win32_buffer(
+        Character * const buffer,
+        size_t const buffer_capacity,
+        debug_info_type const& debug_info
+        )
+        : debug_info_type(debug_info),
+          _initial_string(buffer),
+          _initial_capacity(buffer_capacity),
+          _string(buffer),
+          _capacity(buffer_capacity),
+          _size(0),
+          _is_dynamic(false)
+    {
+    }
+
+    ~__crt_win32_buffer()
+    {
+        _deallocate();
+    }
+
+    __crt_win32_buffer(__crt_win32_buffer const&) = delete;
+    __crt_win32_buffer& operator=(__crt_win32_buffer const&) = delete;
+
+    __crt_win32_buffer(__crt_win32_buffer&&) = delete;
+    __crt_win32_buffer& operator=(__crt_win32_buffer&&) = delete;
+
+    char_type * data()
+    {
+        return _string;
+    }
+
+    char_type const * data() const
+    {
+        return _string;
+    }
+
+    size_t size() const
+    {
+        return _size;
+    }
+
+    void size(size_t new_size)
+    {
+        _size = new_size;
+    }
+
+    size_t capacity() const
+    {
+        return _capacity;
+    }
+
+    void reset()
+    {
+        _deallocate();
+        _reset_no_dealloc();
+    }
+
+    char_type * detach()
+    {
+        if (_string == nullptr || _size == 0) {
+            return nullptr;
+        }
+
+        char_type * return_val{};
+
+        if (!_is_dynamic && _size > 0) {
+            // This pointer needs to live longer than the stack buffer
+            // Allocate + Copy
+            ResizePolicy::allocate(
+                reinterpret_cast<void **>(&return_val),
+                _size * sizeof(Character),
+                debug_info()
+                );
+            memcpy_s(return_val, _size, _string, _capacity);
+        } else {
+            return_val = _string;
+        }
+
+        _reset_no_dealloc();
+        return return_val;
+    }
+
+    template <typename Win32Function>
+    errno_t call_win32_function(Win32Function const& win32_function)
+    {   // Suitable for more Win32 calls, where a size is returned
+        // if there is not enough space.
+
+        size_t const required_size = win32_function(_string, static_cast<DWORD>(_capacity));
+        if (required_size == 0) {
+            __acrt_errno_map_os_error(GetLastError());
+            return errno;
+        }
+
+        if (required_size <= _capacity) {
+            // Had enough space, data was written, save size and return
+            _size = required_size;
+            return 0;
+        }
+
+        size_t const required_size_plus_null_terminator = required_size + 1;
+
+        errno_t const alloc_err = allocate(required_size_plus_null_terminator);
+        if (alloc_err)
+        {
+            return alloc_err;
+        }
+
+        // Upon success, return value is number of characters written, minus the null terminator.
+        size_t const required_size2 = win32_function(_string, static_cast<DWORD>(_capacity));
+        if (required_size2 == 0) {
+            __acrt_errno_map_os_error(GetLastError());
+            return errno;
+        }
+
+        // Capacity should be large enough at this point.
+        _size = required_size2;
+        return 0;
+    }
+
+    debug_info_type const& debug_info() const
+    {
+        return static_cast<debug_info_type const&>(*this);
+    }
+
+    errno_t allocate(size_t requested_size)
+    {
+        _deallocate();
+
+        errno_t err = ResizePolicy::allocate(
+            reinterpret_cast<void **>(&_string),
+            requested_size * sizeof(Character),
+            debug_info()
+            );
+
+        if (err) {
+            _is_dynamic = false;
+            _capacity = 0;
+            return err;
+        }
+
+        _is_dynamic = true;
+        _capacity = requested_size;
+        return 0;
+    }
+
+    void set_to_nullptr()
+    {
+        _deallocate();
+
+        _string = nullptr;
+        _capacity = 0;
+        _size = 0;
+    }
+
+private:
+    void _reset_no_dealloc()
+    {
+        _string = _initial_string;
+        _capacity = _initial_capacity;
+        _size = 0;
+    }
+
+    void _deallocate()
+    {
+        if (_is_dynamic) {
+            ResizePolicy::deallocate(_string, debug_info());
+            _is_dynamic = false;
+        }
+    }
+
+    char_type * const _initial_string;
+    size_t            _initial_capacity;
+    char_type *       _string;
+    size_t            _capacity;
+    size_t            _size;
+    bool              _is_dynamic;
+};
+
+template <typename Character>
+using __crt_internal_win32_buffer = __crt_win32_buffer<Character, __crt_win32_buffer_internal_dynamic_resizing>;
+
+template <typename Character>
+using __crt_public_win32_buffer = __crt_win32_buffer<Character, __crt_win32_buffer_public_dynamic_resizing>;
+
+template <typename Character>
+using __crt_no_alloc_win32_buffer = __crt_win32_buffer<Character, __crt_win32_buffer_no_resizing>;
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// UTF-8 or ACP Helper
+//
+// Some POSIX functions have historically used the ACP for doing narrow->wide
+// conversions. In order to support UTF-8 with these functions, they've been
+// modified so that they use CP_UTF8 when current locale is UTF-8, but the ACP
+// otherwise in order to preserve backwards compatibility.
+//
+// These POSIX functions can call __acrt_get_utf8_acp_compatibility_codepage to grab
+// the code page they should use for their conversions.
+//
+// The Win32 ANSI "*A" APIs also use this to preserve their behavior as using the ACP, unless
+// the current locale is set to UTF-8.
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+inline unsigned int __acrt_get_utf8_acp_compatibility_codepage()
+{
+    _LocaleUpdate locale_update(nullptr);
+    unsigned int const current_code_page = locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
+
+    if (current_code_page == CP_UTF8) {
+        return CP_UTF8;
+    }
+
+    bool const use_oem_code_page = !__acrt_AreFileApisANSI();
+
+    if (use_oem_code_page) {
+        return CP_OEMCP;
+    }
+
+    return CP_ACP;
+}
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Win32 APIs using __crt_win32_buffer
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// See complete list of internal conversion functions in corecrt_internal_traits.h
+
+template <typename FromChar, typename ToChar, typename CvtFunction, typename ResizePolicy>
+errno_t __acrt_convert_wcs_mbs(
+    FromChar const * const                    null_terminated_input_string,
+    __crt_win32_buffer<ToChar, ResizePolicy>& win32_buffer,
+    CvtFunction const&                        cvt_func,
+    _locale_t                                 locale
+    )
+{
+    // Common code path for conversions using mbstowcs and wcstombs.
+    if (null_terminated_input_string == nullptr) {
+        win32_buffer.set_to_nullptr();
+        return 0;
+    }
+
+    // No empty string special case - mbstowcs/wcstombs handles them.
+    size_t const required_size = cvt_func(nullptr, null_terminated_input_string, 0, locale);
+
+    if (required_size == static_cast<size_t>(-1)) {
+        return errno;
+    }
+
+    size_t const required_size_plus_null_terminator = required_size + 1;
+
+    if (required_size_plus_null_terminator > win32_buffer.capacity()) {
+        errno_t const alloc_err = win32_buffer.allocate(required_size_plus_null_terminator);
+        if (alloc_err != 0) {
+            return alloc_err;
+        }
+    }
+
+    size_t const chars_converted = cvt_func(win32_buffer.data(), null_terminated_input_string, win32_buffer.capacity(), locale);
+    if (chars_converted == static_cast<size_t>(-1) || chars_converted == win32_buffer.capacity()) {
+        // check for error or if output is not null terminated
+        return errno;
+    }
+
+    win32_buffer.size(chars_converted);
+    return 0;
+}
+
+template <typename FromChar, typename ToChar, typename CvtFunction, typename ResizePolicy>
+errno_t __acrt_convert_wcs_mbs_cp(
+    FromChar const * const                    null_terminated_input_string,
+    __crt_win32_buffer<ToChar, ResizePolicy>& win32_buffer,
+    CvtFunction const&                        cvt_func,
+    unsigned int const                        code_page
+    )
+{
+    // Common code path for conversions using MultiByteToWideChar and WideCharToMultiByte with null terminated inputs.
+    if (null_terminated_input_string == nullptr) {
+        win32_buffer.set_to_nullptr();
+        return 0;
+    }
+
+    // Special Case: Empty strings are not valid input to MultiByteToWideChar/WideCharToMultiByte
+    if (null_terminated_input_string[0] == '\0') {
+        if (win32_buffer.capacity() == 0) {
+            errno_t alloc_err = win32_buffer.allocate(1);
+            if (alloc_err != 0) {
+                return alloc_err;
+            }
+        }
+
+        win32_buffer.data()[0] = '\0';
+        win32_buffer.size(0);
+        return 0;
+    }
+
+    size_t const required_size_plus_null_terminator = cvt_func(
+        code_page,
+        null_terminated_input_string,
+        nullptr,
+        0
+        );
+
+    if (required_size_plus_null_terminator == 0) {
+        __acrt_errno_map_os_error(::GetLastError());
+        return errno;
+    }
+
+    if (required_size_plus_null_terminator > win32_buffer.capacity()) {
+        errno_t alloc_err = win32_buffer.allocate(required_size_plus_null_terminator);
+        if (alloc_err != 0) {
+            return alloc_err;
+        }
+    }
+
+    size_t const chars_converted_plus_null_terminator = cvt_func(
+        code_page,
+        null_terminated_input_string,
+        win32_buffer.data(),
+        win32_buffer.capacity()
+        );
+
+    if (chars_converted_plus_null_terminator == 0) {
+        __acrt_errno_map_os_error(::GetLastError());
+        return errno;
+    }
+
+    win32_buffer.size(chars_converted_plus_null_terminator - 1); // size does not include the null terminator
+    return 0;
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_wcs_to_mbs(
+    wchar_t const * const                   null_terminated_input_string,
+    __crt_win32_buffer<char, ResizePolicy>& win32_buffer,
+    _locale_t                               locale = nullptr
+    )
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        return __acrt_convert_wcs_mbs(
+            null_terminated_input_string,
+            win32_buffer,
+            _wcstombs_l,
+            locale
+            );
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_wcs_to_mbs_cp(
+    wchar_t const * const                   null_terminated_input_string,
+    __crt_win32_buffer<char, ResizePolicy>& win32_buffer,
+    unsigned int const                      code_page
+    )
+{
+    auto const wcs_to_mbs = [](
+        unsigned int const    code_page,
+        wchar_t const * const null_terminated_input_string,
+        char * const          buffer,
+        size_t const          buffer_size)
+    {
+        // Return value includes null terminator.
+        return __acrt_WideCharToMultiByte(
+            code_page,
+            0,
+            null_terminated_input_string,
+            -1,
+            buffer,
+            static_cast<int>(buffer_size),
+            nullptr,
+            nullptr
+            );
+    };
+
+    return __acrt_convert_wcs_mbs_cp(
+        null_terminated_input_string,
+        win32_buffer,
+        wcs_to_mbs,
+        code_page
+        );
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_mbs_to_wcs(
+    char const * const                         null_terminated_input_string,
+    __crt_win32_buffer<wchar_t, ResizePolicy>& win32_buffer,
+    _locale_t                                  locale = nullptr
+    )
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        return __acrt_convert_wcs_mbs(
+            null_terminated_input_string,
+            win32_buffer,
+            _mbstowcs_l,
+            locale
+            );
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_mbs_to_wcs_cp(
+    char const * const                         null_terminated_input_string,
+    __crt_win32_buffer<wchar_t, ResizePolicy>& win32_buffer,
+    unsigned int const                         code_page
+    )
+{
+    auto const mbs_to_wcs = [](
+        unsigned int const code_page,
+        char const * const null_terminated_input_string,
+        wchar_t * const    buffer,
+        size_t const       buffer_size)
+    {
+        // Return value includes null terminator.
+        return __acrt_MultiByteToWideChar(
+            code_page,
+            MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
+            null_terminated_input_string,
+            -1,
+            buffer,
+            static_cast<int>(buffer_size)
+            );
+    };
+
+    return __acrt_convert_wcs_mbs_cp(
+        null_terminated_input_string,
+        win32_buffer,
+        mbs_to_wcs,
+        code_page
+        );
+}
+
+// Array overloads are useful for __try contexts where objects with unwind semantics cannot be used.
+template <size_t N>
+size_t __acrt_wcs_to_mbs_array(
+    wchar_t const * const null_terminated_input_string,
+    char                  (&buffer)[N],
+    _locale_t             locale = nullptr
+    )
+{
+    __crt_no_alloc_win32_buffer<char> win32_buffer(buffer);
+    if (__acrt_wcs_to_mbs(null_terminated_input_string, win32_buffer, locale) != 0) {
+        return 0;
+    }
+
+    return win32_buffer.size();
+}
+
+template <size_t N>
+size_t __acrt_wcs_to_mbs_cp_array(
+    wchar_t const * const null_terminated_input_string,
+    char                  (&buffer)[N],
+    unsigned int const    code_page
+    )
+{
+    __crt_no_alloc_win32_buffer<char> win32_buffer(buffer);
+    if (__acrt_wcs_to_mbs_cp(null_terminated_input_string, win32_buffer, code_page) != 0) {
+        return 0;
+    }
+
+    return win32_buffer.size();
+}
+
+template <size_t N>
+size_t __acrt_mbs_to_wcs_array(
+    char const * const null_terminated_input_string,
+    wchar_t            (&buffer)[N],
+    _locale_t          locale = nullptr
+    )
+{
+    __crt_no_alloc_win32_buffer<wchar_t> win32_buffer(buffer);
+    if (__acrt_mbs_to_wcs(null_terminated_input_string, win32_buffer, locale) != 0) {
+        return 0;
+    }
+
+    return win32_buffer.size();
+}
+
+template <size_t N>
+size_t __acrt_mbs_to_wcs_cp_array(
+    char const * const null_terminated_input_string,
+    wchar_t            (&buffer)[N],
+    unsigned int const code_page
+    )
+{
+    __crt_no_alloc_win32_buffer<wchar_t> win32_buffer(buffer);
+    if (__acrt_wcs_to_mbs_cp(null_terminated_input_string, win32_buffer, code_page) != 0) {
+        return 0;
+    }
+
+    return win32_buffer.size();
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_get_current_directory_wide(
+     __crt_win32_buffer<wchar_t, ResizePolicy>& win32_buffer
+    )
+{
+    return win32_buffer.call_win32_function([](wchar_t * buffer, DWORD buffer_length)
+    {
+        return ::GetCurrentDirectoryW(buffer_length, buffer);
+    });
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_get_current_directory_narrow_acp_or_utf8(
+    __crt_win32_buffer<char, ResizePolicy>& win32_buffer
+    )
+{
+    wchar_t default_buffer_space[_MAX_PATH];
+    __crt_internal_win32_buffer<wchar_t> wide_buffer(default_buffer_space);
+
+    errno_t const err = __acrt_get_current_directory_wide(wide_buffer);
+
+    if (err != 0) {
+        return err;
+    }
+
+    return __acrt_wcs_to_mbs_cp(
+        wide_buffer.data(),
+        win32_buffer,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_get_full_path_name_wide(
+    wchar_t const * const                      lpFileName,
+    __crt_win32_buffer<wchar_t, ResizePolicy>& win32_buffer
+    )
+{
+    return win32_buffer.call_win32_function([lpFileName](wchar_t * buffer, DWORD buffer_length)
+    {
+        return ::GetFullPathNameW(
+            lpFileName,
+            buffer_length,
+            buffer,
+            nullptr
+        );
+    });
+}
+
+template <typename ResizePolicy>
+errno_t __acrt_get_full_path_name_narrow_acp_or_utf8(
+    char const * const                      lpFileName,
+    __crt_win32_buffer<char, ResizePolicy>& win32_buffer
+    )
+{
+    wchar_t default_buffer_space[_MAX_PATH];
+    __crt_internal_win32_buffer<wchar_t> wide_buffer(default_buffer_space);
+
+    wchar_t default_file_name_space[_MAX_PATH];
+    __crt_internal_win32_buffer<wchar_t> wide_file_name(default_file_name_space);
+
+    unsigned int const code_page = __acrt_get_utf8_acp_compatibility_codepage();
+
+    errno_t const cvt_err = __acrt_mbs_to_wcs_cp(
+        lpFileName,
+        wide_file_name,
+        code_page
+        );
+
+    if (cvt_err != 0)
+    {
+        return cvt_err;
+    }
+
+    errno_t const err = __acrt_get_full_path_name_wide(wide_file_name.data(), wide_buffer);
+
+    if (err != 0)
+    {
+        return err;
+    }
+
+    return __acrt_wcs_to_mbs_cp(
+        wide_buffer.data(),
+        win32_buffer,
+        code_page
+        );
+}
+
+#pragma pack(pop)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/i386/cruntime.inc b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/i386/cruntime.inc
new file mode 100644
index 0000000000000000000000000000000000000000..bfb96fbda387c8b5735949d4f4d6df907a5a3181
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/inc/i386/cruntime.inc	
@@ -0,0 +1,323 @@
+;***
+;cruntime.inc - multi-model assembly macros for interfacing to HLLs
+;
+;       Copyright (c) Microsoft Corporation.  All rights reserved.
+;
+;Purpose:
+;       This file defines the current memory model being used.
+;
+;*******************************************************************************
+
+;==============================================================================
+;
+;Use the following defines to control processor/segment model
+;
+;   default is -DI86 -Dmem_S
+;
+;==============================================================================
+;
+;The following variables are defined by this file:
+;   cpu                         86, 286, or 386
+;   mmodel                      english name of the memory model, i.e. "Medium"
+;   ISIZE, LSIZE, NSIZE         size of ints, longs, shorts
+;   FLTSIZE, DBLSIZE, LDBLSIZE  size of float, double, long double
+;
+;The following macros allow easy writing of combined 16/32 bit code:
+;
+; 16/32 bit registers:
+;   rax, rbx, rcx, rdx,         expand to native registers (rax = eax or ax)
+;   rsi, rdi, rsp, rbp
+;   CBI                         convert byte to int (al to rax)
+; Numeric type instructions:
+;   IWORD, LWORD, SWORD         data type of int, long, short
+;   DFLOAT, DDOUBLE, DLDOUBLE   define float, double, long double
+;
+;The following utility macros are provided:
+;   codeseg                     define/declare code segment
+;   error <msg>                 stop assembly with message
+;   display <msg>               display a message, unless QUIET defined
+;   _if cond <instruction>      assemble instruction only if cond is TRUE
+;   _ife cond <instruction>     assemble instruction only if cond is FALSE
+;   _ifd symbol <instruction>   assemble instruction only if symbol defined
+;   _ifnd symbol <instruction>  assemble instruction only if symbol not defined
+;
+;   lab  LabelName              assembles to "LabelName:" If DEBUG is defined
+;                               LabelName is made public
+;
+;   JS* (ex. JSE,JSZ,JSB ...)   assemble to "je short","jz short","jb short"
+;
+;   Cmacro look alikes
+;   static* Name, InitialValue, Repeat   defines a static variable of type *
+;   global* Name, InitialValue, Repeat   defines a global variable of type *
+;   label*  Name, {PUBLIC,PASCAL,C}      defines a label of type *
+;
+;==============================================================================
+
+; error <msg>   -    Output message and generate error
+
+error   MACRO   msg
+if2                     ;; only on pass 2 can we generate errors
+        %out    **********************************************************
+        %out    *** E r r o r  --  msg
+        %out    **********************************************************
+        .err
+endif
+        ENDM
+
+; display msg   -    Output message unless QUIET defined
+
+display MACRO   msg
+ifndef QUIET            ;; only when quiet flag not set
+if1                     ;; and on pass 1, then display message
+        %out msg
+endif
+endif
+        ENDM
+
+; One line conditionals:
+;   here we create the capability of writing code lines like
+;
+; _if sizeD   <push ds>   as opposed to    if sizeD
+;                                              push  ds
+;                                          endif
+
+_if     MACRO   cond,text
+    if  cond
+        text
+    endif
+        ENDM
+
+_ife    MACRO   cond,text
+    ife cond
+        text
+    endif
+        ENDM
+
+_ifd    MACRO   cond,text
+    ifdef   cond
+        text
+    endif
+        ENDM
+
+_ifnd   MACRO   cond,text
+    ifndef  cond
+        text
+    endif
+        ENDM
+
+; Process processor arguments
+
+        .686
+
+;  Set memory model
+
+        .model  flat, C
+
+; Define registers:
+; Instead of using the "word" registers directly, we will use a set of
+; text equates.  This will allow you to use the native word size instead of
+; hard coded to 16 bit words.  We also have some instruction equates for
+; instruction with the register type hard coded in.
+
+    rax equ <eax>
+    rbx equ <ebx>
+    rcx equ <ecx>
+    rdx equ <edx>
+    rdi equ <edi>
+    rsi equ <esi>
+    rbp equ <ebp>
+    rsp equ <esp>
+
+    CBI   equ <movsx eax, al>    ; convert byte to int (al to rax)
+
+; The next set of equates deals with the size of SHORTS, INTS, LONGS, and
+; pointers.
+
+    ; parameters and locals
+    IWORD   equ <dword>
+
+    ; sizes for fixing SP, stepping through tables, etc.
+    ISIZE   equ 4
+
+; Float/double definitions
+; (currently the same for 16- and 32-bit segments)
+
+FLTSIZE  equ    4       ; float
+DBLSIZE  equ    8       ; double
+LDBLSIZE equ    10      ; long double
+
+DFLOAT   equ    <dd>
+DDOUBLE  equ    <dq>
+DLDOUBLE equ    <dt>
+
+; codeseg - Define/declare the standard code segment. Maps to the proper
+; form of the .code directive.
+;
+; Input:
+;
+; Output:
+;       .code _TEXT     ; for large code models
+;       .code           ; for small code models
+;       assume  cs:FLAT ; for 386
+;       assume  ds:FLAT ; for 386
+;       assume  es:FLAT ; for 386
+;       assume  ss:FLAT ; for 386
+;
+
+codeseg MACRO
+
+        .code
+
+        assume  ds:FLAT
+        assume  es:FLAT
+        assume  ss:FLAT
+
+        ENDM
+
+; Define named constants for ISA levels.
+
+__ISA_AVAILABLE_X86     equ 0
+__ISA_AVAILABLE_SSE2    equ 1
+__ISA_AVAILABLE_SSE42   equ 2
+__ISA_AVAILABLE_AVX     equ 3
+
+; Define named constants for favor
+
+__FAVOR_ATOM           equ 0
+__FAVOR_ENFSTRG        equ 1
+
+;***************************************************************
+;*
+;*  Debug lab macro
+;*
+;***************************************************************
+
+lab     macro name
+ifdef   DEBUG
+    public  pascal name     ;; define label public for Symdeb
+endif
+name:
+        endm
+
+
+;***************************************************************
+;*
+;*  Conditional jump short macros
+;*
+;***************************************************************
+
+
+        irp     x,<Z,NZ,E,NE,P,PE,AE,BE,G>
+JS&x    equ   <j&x short>
+        endm
+
+
+;***************************************************************
+;*
+;*  Global data definition macros
+;*
+;*  Usage:
+;*      globalI   Name, InitialValue, Repeat
+;*
+;***************************************************************
+
+
+MakeGlobal  macro   suffix, DataType        ;; makes all of the global* macros
+
+global&suffix  macro   name, data, rep
+public  name
+ifb     <rep>
+    _repeat = 1
+else
+    _repeat = (rep)
+endif
+
+name    &DataType  _repeat dup( data )
+        endm
+
+        endm
+
+
+    MakeGlobal  T, dt                   ; globalT
+    MakeGlobal  Q, dq                   ; globalQ
+    MakeGlobal  D, dd                   ; globalD
+    MakeGlobal  W, dw                   ; globalW
+    MakeGlobal  B, db                   ; globalB
+
+;***************************************************************
+;*
+;*  Static data definition macros
+;*
+;*  Usage:
+;*      staticI   Name, InitialValue, Repeat
+;*
+;***************************************************************
+
+
+MakeStatic  macro   suffix, DataType        ;; makes all of the static* macros
+
+static&suffix  macro   name, data, rep
+
+ifdef  DEBUG
+    public  pascal name                     ;; make statics public if DEBUG
+endif
+
+ifb     <rep>
+    _repeat = 1
+else
+    _repeat = (rep)
+endif
+
+name    &DataType  _repeat dup( data )
+        endm
+
+        endm
+
+
+    MakeStatic  T, dt                   ; staticT
+    MakeStatic  Q, dq                   ; staticQ
+    MakeStatic  D, dd                   ; staticD
+    MakeStatic  W, dw                   ; staticW
+    MakeStatic  B, db                   ; staticB
+
+;***************************************************************
+;*
+;*  Label definition macros
+;*
+;*  Usage:
+;*      labelI   Name, {PUBLIC, PASCAL, C}
+;*
+;***************************************************************
+
+__MakePublic    macro   name, option    ;; decides if a label should be
+ifidni  <option>, <PUBLIC>              ;; made public
+    public  name
+elseifidni  <option>, <PASCAL>
+    public  pascal name
+elseifidni  <option>, <C>
+    public  C name
+elseifb  <option>
+    ifdef  DEBUG
+        public  pascal name     ;; make public if DEBUG
+    endif
+endif
+                endm
+
+
+MakeLabel   macro suffix, LabelType     ;; makes all of the label* macros
+
+%@CatStr(<label>,<suffix>)      macro   name, option
+        __MakePublic    <name>,<option>
+name    label   &LabelType
+        endm
+
+        endm
+
+
+        MakeLabel   T, tbyte    ; make labelT
+        MakeLabel   Q, qword    ; make labelQ
+        MakeLabel   D, dword    ; make labelD
+        MakeLabel   W, word     ; make labelW
+        MakeLabel   B, byte     ; make labelB
+
+        MakeLabel   NP, near    ; make labelNP
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/clock_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/clock_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0ee0b9ade086d7705a8743450739b8689b95df0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/clock_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// clock_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" int __cdecl __acrt_initialize_clock();
+
+extern "C" _CRTALLOC(".CRT$XIC") _PIFV const __acrt_clock_initializer = __acrt_initialize_clock;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/console_input_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/console_input_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed7825feadba96d3b2a6743fd8d060ad23d053d8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/console_input_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// console_input_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" void __cdecl __dcrt_terminate_console_input();
+
+extern "C" _CRTALLOC(".CRT$XPX") _PVFV const __dcrt_console_input_terminator = __dcrt_terminate_console_input;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/console_output_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/console_output_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24cf1a2c032097c82eca896d8b6596121c965b3b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/console_output_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// console_output_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" void __cdecl __dcrt_terminate_console_output();
+
+extern "C" _CRTALLOC(".CRT$XPX") _PVFV const __dcrt_console_output_terminator = __dcrt_terminate_console_output;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/fma3_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/fma3_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1744e3e4fc9d5b1e7afc7a10deaaa578b5daf1ba
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/fma3_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// fma3_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" int __cdecl __acrt_initialize_fma3();
+
+extern "C" _CRTALLOC(".CRT$XIC") _PIFV const __acrt_tran_fma3_initializer = __acrt_initialize_fma3;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/fmode_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/fmode_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8995a8c381106bae8ba6fb8bb276566bb51d94e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/fmode_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// fmode_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" int  __cdecl __acrt_initialize_fmode();
+
+extern "C" _CRTALLOC(".CRT$XIC")  _PIFV const __acrt_fmode_initializer = __acrt_initialize_fmode;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/i386/sse2_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/i386/sse2_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8002712a1770bdad3646752d9db95cca1c0ee382
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/i386/sse2_initializer.cpp	
@@ -0,0 +1,27 @@
+//
+// sse2_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" int __cdecl __acrt_initialize_sse2();
+
+#ifdef _M_HYBRID_X86_ARM64
+#pragma intrinsic(_HybridGenerateThunks)
+
+extern "C" int __cdecl __acrt_initialize_sse2()
+{
+    _HybridGenerateThunks(__acrt_initialize_sse2, 1);
+    return 0;
+}
+#endif
+
+extern "C" _CRTALLOC(".CRT$XIC") _PIFV const __acrt_tran_sse2_initializer = __acrt_initialize_sse2;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/locale_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/locale_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1e34cd73b784e08242bbdf00e38413a4e51093f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/locale_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// locale_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" void __cdecl __acrt_uninitialize_locale();
+
+extern "C" _CRTALLOC(".CRT$XPX") _PVFV const __acrt_locale_terminator = __acrt_uninitialize_locale;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/multibyte_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/multibyte_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9df6b43fc583a276a1ea34e08bf476c5576fc87d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/multibyte_initializer.cpp	
@@ -0,0 +1,20 @@
+//
+// multibyte_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+static int __cdecl initialize_multibyte() throw()
+{
+    return !__acrt_initialize_multibyte();
+}
+
+extern "C" _CRTALLOC(".CRT$XIC") _PIFV const __acrt_multibyte_initializer = initialize_multibyte;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/stdio_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/stdio_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9305be49b9f41d696f3c90083a2148393f15eb4c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/stdio_initializer.cpp	
@@ -0,0 +1,19 @@
+//
+// stdio_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" int  __cdecl __acrt_initialize_stdio();
+extern "C" void __cdecl __acrt_uninitialize_stdio();
+
+extern "C" _CRTALLOC(".CRT$XIC")  _PIFV const __acrt_stdio_initializer = __acrt_initialize_stdio;
+extern "C" _CRTALLOC(".CRT$XPXA") _PVFV const __acrt_stdio_terminator  = __acrt_uninitialize_stdio;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/timeset_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/timeset_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f7e7630e4025396c9bcab5c71899229364558c11
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/timeset_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// timeset_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" int  __cdecl __acrt_initialize_timeset();
+
+extern "C" _CRTALLOC(".CRT$XIC")  _PIFV const __acrt_timeset_initializer = __acrt_initialize_timeset;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/tmpfile_initializer.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/tmpfile_initializer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..209f83329ab89b91471d581c93e09d4815837382
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/initializers/tmpfile_initializer.cpp	
@@ -0,0 +1,17 @@
+//
+// tmpfile_initializer.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// CRT initializers and terminators have been extracted from the main CRT sources
+// to enable the CRT DLL to be built with LTCG enabled.  The source files in which
+// the CRT initializers and terminators are defined cannot be compiled as /GL
+// because the compiler will optimize them away during link-time code generation.
+// We inhibit this optimization by defining the initializers and terminators in
+// separate source files that are not compiled with /GL.
+//
+#include <corecrt_internal.h>
+
+extern "C" void __cdecl __acrt_uninitialize_tmpfile();
+
+extern "C" _CRTALLOC(".CRT$XPX") _PVFV const __acrt_tmpfile_terminator = __acrt_uninitialize_tmpfile;
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/CreateProcessA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/CreateProcessA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fcaf8c2cf3fb6e2f66abaf1cea1356c76cd56a1c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/CreateProcessA.cpp	
@@ -0,0 +1,79 @@
+//
+// CreateProcessA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_CreateProcessA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+BOOL __cdecl __acrt_CreateProcessA(
+    LPCSTR const                lpApplicationName,
+    LPSTR const                 lpCommandLine,
+    LPSECURITY_ATTRIBUTES const lpProcessAttributes,
+    LPSECURITY_ATTRIBUTES const lpThreadAttributes,
+    BOOL const                  bInheritHandles,
+    DWORD const                 dwCreationFlags,
+    LPVOID const                lpEnvironment,
+    LPCSTR const                lpCurrentDirectory,
+    LPSTARTUPINFOW const        lpStartupInfo,
+    LPPROCESS_INFORMATION const lpProcessInformation
+    )
+{
+    __crt_internal_win32_buffer<wchar_t> wide_application_name;
+    __crt_internal_win32_buffer<wchar_t> wide_command_line;
+    __crt_internal_win32_buffer<wchar_t> wide_current_directory;
+
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
+        lpApplicationName,
+        wide_application_name,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt1 != 0) {
+        return FALSE;
+    }
+
+    errno_t const cvt2 = __acrt_mbs_to_wcs_cp(
+        lpCommandLine,
+        wide_command_line,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt2 != 0) {
+        return FALSE;
+    }
+
+    LPWSTR wide_current_directory_ptr = nullptr;
+
+    if (lpCurrentDirectory != nullptr) {
+        errno_t const cvt3 = __acrt_mbs_to_wcs_cp(
+            lpCurrentDirectory,
+            wide_current_directory,
+            __acrt_get_utf8_acp_compatibility_codepage()
+            );
+
+        if (cvt3 != 0) {
+            return FALSE;
+        }
+
+        wide_current_directory_ptr = wide_current_directory.data();
+    }
+
+    // converted_command_line is an out parameter, but is not reconverted to utf8 string,
+    // since it is only written to in the Wide version. CreateProcessA does not expect it
+    // to have changed.
+    return ::CreateProcessW(
+        wide_application_name.data(),
+        wide_command_line.data(),
+        lpProcessAttributes,
+        lpThreadAttributes,
+        bInheritHandles,
+        dwCreationFlags,
+        lpEnvironment,
+        wide_current_directory_ptr,
+        lpStartupInfo,
+        lpProcessInformation
+        );
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/GetModuleFileNameA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/GetModuleFileNameA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..72f1f82ad93acb967468c1cfcfc2f38d761a06e2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/GetModuleFileNameA.cpp	
@@ -0,0 +1,40 @@
+//
+// GetModuleFileNameA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_GetModuleFileNameA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+DWORD __cdecl __acrt_GetModuleFileNameA(
+    HMODULE const hModule,
+    char * const  lpFilename,
+    DWORD const   nSize
+    )
+{
+    size_t const wide_buffer_size = MAX_PATH + 1;
+    wchar_t wide_buffer[wide_buffer_size];
+
+    DWORD const amount_copied = GetModuleFileNameW(
+        hModule,
+        wide_buffer,
+        wide_buffer_size
+        );
+
+    if (amount_copied == 0) {
+        __acrt_errno_map_os_error(GetLastError());
+        return 0;
+    }
+
+    __crt_no_alloc_win32_buffer<char> filename_buffer(lpFilename, static_cast<size_t>(nSize));
+
+    errno_t const cvt = __acrt_wcs_to_mbs_cp(
+        wide_buffer,
+        filename_buffer,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    return static_cast<DWORD>(filename_buffer.size());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/LoadLibraryExA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/LoadLibraryExA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9ec0fee4e27112169f239c65bbb962871a07631a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/LoadLibraryExA.cpp	
@@ -0,0 +1,34 @@
+//
+// LoadLibraryExA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_LoadLibraryExA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+HMODULE __cdecl __acrt_LoadLibraryExA(
+    LPCSTR const lpFilename,
+    HANDLE const hFile,
+    DWORD const  dwFlags
+    )
+{
+    __crt_internal_win32_buffer<wchar_t> wide_file_name;
+
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
+        lpFilename,
+        wide_file_name,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt1 != 0) {
+        return nullptr;
+    }
+
+    return ::LoadLibraryExW(
+        wide_file_name.data(),
+        hFile,
+        dwFlags
+        );
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/OutputDebugStringA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/OutputDebugStringA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5bdb3775967211faf597fa2e41ffe18e12b12ece
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/OutputDebugStringA.cpp	
@@ -0,0 +1,31 @@
+//
+// OutputDebugStringA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_OutputDebugStringA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+void WINAPI __acrt_OutputDebugStringA(
+    LPCSTR const text
+    )
+{
+    if (text == nullptr)
+    {
+        return;
+    }
+    size_t const text_size = strlen(text) + 1;
+    if (text_size == 0)
+    {
+        return;
+    }
+    // Use alloca instead of heap, since this code is executed during asserts
+    auto text_wide = (wchar_t*)_alloca(text_size * sizeof(wchar_t));
+    size_t converted;
+    if (mbstowcs_s(&converted, text_wide, text_size, text, text_size - 1) == 0)
+    {
+        OutputDebugStringW(text_wide);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetCurrentDirectoryA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetCurrentDirectoryA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3fa40cd6de3c70072796839db14f8a4113ae9953
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetCurrentDirectoryA.cpp	
@@ -0,0 +1,28 @@
+//
+// SetCurrentDirectoryA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_SetCurrentDirectoryA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+BOOL __cdecl __acrt_SetCurrentDirectoryA(
+    LPCSTR const lpPathName
+    )
+{
+    __crt_internal_win32_buffer<wchar_t> wide_path_name;
+
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
+        lpPathName,
+        wide_path_name,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt1 != 0) {
+        return FALSE;
+    }
+
+    return ::SetCurrentDirectoryW(wide_path_name.data());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetEnvironmentVariableA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetEnvironmentVariableA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8cea682d52978eabfd138e751645fd87f518ba15
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/SetEnvironmentVariableA.cpp	
@@ -0,0 +1,40 @@
+//
+// SetEnvironmentVariableA.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of __acrt_SetEnvironmentVariableA.
+//
+
+#include <corecrt_internal_win32_buffer.h>
+
+BOOL __cdecl __acrt_SetEnvironmentVariableA(
+    LPCSTR const lpName,
+    LPCSTR const lpValue
+    )
+{
+    __crt_internal_win32_buffer<wchar_t> wide_name;
+    __crt_internal_win32_buffer<wchar_t> wide_value;
+
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
+        lpName,
+        wide_name,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt1 != 0) {
+        return FALSE;
+    }
+
+    errno_t const cvt2 = __acrt_mbs_to_wcs_cp(
+        lpValue,
+        wide_value,
+        __acrt_get_utf8_acp_compatibility_codepage()
+        );
+
+    if (cvt2 != 0) {
+        return FALSE;
+    }
+
+    return ::SetEnvironmentVariableW(wide_name.data(), wide_value.data());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/initialization.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/initialization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9fe7ceb47aa845b0df21cd7b0791c5b7465b76b8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/initialization.cpp	
@@ -0,0 +1,345 @@
+//
+// initialization.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This file defines the main initialization and uninitialization routines for
+// the AppCRT, shared by both the static and dynamic AppCRT libraries.  In the
+// dynamic AppCRT library, these are called by DllMain.  In the static AppCRT
+// library, these are called by the initialization code.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_stdio.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+extern "C" {
+
+
+
+extern _onexit_table_t __acrt_atexit_table;
+extern _onexit_table_t __acrt_at_quick_exit_table;
+extern void*           __acrt_stdout_buffer;
+extern void*           __acrt_stderr_buffer;
+
+
+
+static bool __cdecl initialize_global_variables()
+{
+    __acrt_current_locale_data.initialize(&__acrt_initial_locale_data);
+    return true;
+}
+
+
+
+#ifdef CRTDLL
+
+    static bool __cdecl initialize_c()
+    {
+        _initialize_onexit_table(&__acrt_atexit_table);
+        _initialize_onexit_table(&__acrt_at_quick_exit_table);
+
+        // Do C initialization:
+        if (_initterm_e(__xi_a, __xi_z) != 0)
+        {
+            return false;
+        }
+
+        // Do C++ initialization:
+        _initterm(__xc_a, __xc_z);
+        return true;
+    }
+
+    static bool __cdecl uninitialize_c(bool)
+    {
+        // Do pre-termination:
+        _initterm(__xp_a, __xp_z);
+
+        // Do termination:
+        _initterm(__xt_a, __xt_z);
+        return true;
+    }
+
+// C4505: unreferenced local function
+#pragma warning( suppress: 4505 )
+    static bool __cdecl initialize_environment()
+    {
+        if (_initialize_narrow_environment() < 0)
+        {
+            return false;
+        }
+
+        if (!_get_initial_narrow_environment())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+#else
+
+    static bool __cdecl initialize_c()
+    {
+        _initialize_onexit_table(&__acrt_atexit_table);
+        _initialize_onexit_table(&__acrt_at_quick_exit_table);
+        return true;
+    }
+
+    static bool __cdecl uninitialize_c(bool)
+    {
+        return true;
+    }
+
+// C4505: unreferenced local function
+#pragma warning( suppress: 4505 )
+    static bool __cdecl initialize_environment()
+    {
+        return true;
+    }
+
+#endif
+
+// C4505: unreferenced local function
+#pragma warning( suppress: 4505 )
+static bool __cdecl uninitialize_environment(bool const terminating)
+{
+    UNREFERENCED_PARAMETER(terminating);
+
+    #ifdef _DEBUG
+    if (terminating)
+    {
+        return true;
+    }
+    #endif
+
+    __dcrt_uninitialize_environments_nolock();
+    return true;
+}
+
+#ifdef _CRT_GLOBAL_STATE_ISOLATION
+
+    static bool __cdecl initialize_global_state_isolation()
+    {
+        // Configure CRT's per-thread global state mode data
+        return __crt_state_management::initialize_global_state_isolation();
+    }
+
+    static bool __cdecl uninitialize_global_state_isolation(bool const terminating)
+    {
+        // Configure CRT's per-thread global state mode data
+        __crt_state_management::uninitialize_global_state_isolation(terminating);
+        return true;
+    }
+
+#else
+
+    static bool __cdecl initialize_global_state_isolation()
+    {
+        return true;
+    }
+
+    static bool __cdecl uninitialize_global_state_isolation(bool const /* terminating */)
+    {
+        return true;
+    }
+
+#endif
+
+
+
+static bool __cdecl initialize_pointers()
+{
+    void* const encoded_null = __crt_fast_encode_pointer(nullptr);
+    __acrt_initialize_invalid_parameter_handler(encoded_null);
+    __acrt_initialize_new_handler(encoded_null);
+    __acrt_initialize_signal_handlers(encoded_null);
+    __acrt_initialize_user_matherr(encoded_null);
+    __acrt_initialize_thread_local_exit_callback(encoded_null);
+    return true;
+}
+
+static bool __cdecl uninitialize_vcruntime(const bool /* terminating */)
+{
+    return __vcrt_uninitialize(false);
+}
+
+static bool __cdecl uninitialize_allocated_memory(bool const /* terminating */)
+{
+    __acrt_current_multibyte_data.uninitialize([](__crt_multibyte_data*& multibyte_data)
+    {
+        if (_InterlockedDecrement(&multibyte_data->refcount) == 0 &&
+            multibyte_data != &__acrt_initial_multibyte_data)
+        {
+            _free_crt(multibyte_data);
+            multibyte_data = &__acrt_initial_multibyte_data;
+        }
+    });
+
+    return true;
+}
+
+// C4505: unreferenced local function
+#pragma warning( suppress: 4505 )
+static bool __cdecl uninitialize_allocated_io_buffers(bool const /* terminating */)
+{
+    _free_crt(__acrt_stdout_buffer);
+    __acrt_stdout_buffer = nullptr;
+
+    _free_crt(__acrt_stderr_buffer);
+    __acrt_stderr_buffer = nullptr;
+
+    _free_crt(__argv);
+    __argv = nullptr;
+
+    _free_crt(__wargv);
+    __wargv = nullptr;
+
+    return true;
+}
+
+static bool __cdecl report_memory_leaks(bool const /* terminating */)
+{
+    #ifdef _DEBUG
+    if (_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) & _CRTDBG_LEAK_CHECK_DF)
+    {
+        _CrtSetDumpClient(nullptr);
+        _CrtDumpMemoryLeaks();
+    }
+    #endif
+
+    return true;
+}
+
+
+
+// This is the table of initializer/uninitializer pairs that is used to perform
+// AppCRT initialization.  Initializers are run first-to-last during AppCRT
+// initialization, and uninitializers are run last-to-first during termination.
+static __acrt_initializer const __acrt_initializers[] =
+{
+    // Init globals that can't be set at compile time because they have c'tors
+    { initialize_global_variables,             nullptr                                  },
+
+    // Global pointers are stored in encoded form; they must be dynamically
+    // initialized to the encoded nullptr value before they are used by the CRT.
+    { initialize_pointers,                     nullptr                                  },
+    // Enclaves only require initializers for supported features.
+#ifndef _UCRT_ENCLAVE_BUILD
+    { __acrt_initialize_winapi_thunks,         __acrt_uninitialize_winapi_thunks        },
+#endif
+
+    // Configure CRT's global state isolation system.  This system calls FlsAlloc
+    // and thus must occur after the initialize_pointers initialization, otherwise
+    // it will fall back to call TlsAlloc, then try to use the allocated TLS slot
+    // with the FLS functions.  This does not turn out well.  By running this
+    // initialization after the initialize_pointers step, we ensure that it can
+    // call FlsAlloc.
+    { initialize_global_state_isolation,       uninitialize_global_state_isolation      },
+
+    // The heap and locks must be initialized before most other initialization
+    // takes place, as other initialization steps rely on the heap and locks:
+    { __acrt_initialize_locks,                 __acrt_uninitialize_locks                },
+    { __acrt_initialize_heap,                  __acrt_uninitialize_heap                 },
+
+    // During uninitialization, before the heap is uninitialized, the AppCRT
+    // needs to notify all VCRuntime instances in the process to allow them to
+    // release any memory that they allocated via the AppCRT heap.
+    //
+    // First, we notify all modules that registered for shutdown notification.
+    // This only occurs in the AppCRT DLL, because the static CRT is only ever
+    // used by a single module, so this notification is never required.
+    //
+    // Then, we notify our own VCRuntime instance.  Note that after this point
+    // during uninitialization, no exception handling may take place in any
+    // CRT module.
+    { nullptr,                                 uninitialize_vcruntime                   },
+
+    { __acrt_initialize_ptd,                   __acrt_uninitialize_ptd                  },
+    // Enclaves only require initializers for supported features.
+#ifndef _UCRT_ENCLAVE_BUILD
+    { __acrt_initialize_lowio,                 __acrt_uninitialize_lowio                },
+    { __acrt_initialize_command_line,          __acrt_uninitialize_command_line         },
+#endif
+    { __acrt_initialize_multibyte,             nullptr                                  },
+    { nullptr,                                 report_memory_leaks                      },
+    // Enclaves only require initializers for supported features.
+#ifndef _UCRT_ENCLAVE_BUILD
+    { nullptr,                                 uninitialize_allocated_io_buffers        },
+#endif
+    { nullptr,                                 uninitialize_allocated_memory            },
+    // Enclaves only require initializers for supported features.
+#ifndef _UCRT_ENCLAVE_BUILD
+    { initialize_environment,                  uninitialize_environment                 },
+#endif
+    { initialize_c,                            uninitialize_c                           },
+};
+
+
+
+
+__crt_bool __cdecl __acrt_initialize()
+{
+    #if defined CRTDLL
+    __isa_available_init();
+    #endif
+
+    return __acrt_execute_initializers(
+        __acrt_initializers,
+        __acrt_initializers + _countof(__acrt_initializers)
+        );
+}
+
+__crt_bool __cdecl __acrt_uninitialize(__crt_bool const terminating)
+{
+    UNREFERENCED_PARAMETER(terminating);
+
+    // If the process is terminating, there's no point in cleaning up, except
+    // in debug builds.
+    #ifndef _DEBUG
+    if (terminating) {
+        #ifndef _UCRT_ENCLAVE_BUILD
+        if (__acrt_stdio_is_initialized()) {
+            _flushall();
+        }
+        #endif
+        return TRUE;
+    }
+    #endif
+
+    return __acrt_execute_uninitializers(
+        __acrt_initializers,
+        __acrt_initializers + _countof(__acrt_initializers)
+        );
+}
+
+__crt_bool __cdecl __acrt_uninitialize_critical(__crt_bool const terminating)
+{
+    __acrt_uninitialize_ptd(terminating);
+
+    #ifdef _CRT_GLOBAL_STATE_ISOLATION
+    uninitialize_global_state_isolation(terminating);
+    #endif
+
+    return true;
+}
+
+__crt_bool __cdecl __acrt_thread_attach()
+{
+    // Create a per-thread data structure for this thread (getptd will attempt
+    // to create a new per-thread data structure if one does not already exist
+    // for this thread):
+    if (__acrt_getptd_noexit() == nullptr)
+        return false;
+
+    return true;
+}
+
+__crt_bool __cdecl __acrt_thread_detach()
+{
+    // Free the per-thread data structure for this thread:
+    __acrt_freeptd();
+    return true;
+}
+
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/locks.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/locks.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b1b913037f33c0df7b71686b1e69f3b94a29a9b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/locks.cpp	
@@ -0,0 +1,71 @@
+//
+// locks.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Critical sections used for synchronization in the CoreCRT.
+//
+#include <corecrt_internal.h>
+
+
+
+// This table holds the locks used by the CoreCRT.  It is indexed using the
+// enumerators of the __acrt_lock_id enumeration.
+static CRITICAL_SECTION __acrt_lock_table[__acrt_lock_count];
+
+// This variable stores the number of locks that have been successfully
+// initialized.  Locks are initialized in order and are destroyed in reverse
+// order.  The startup and exit code must ensure that initialization and
+// destruction is synchronized:  these functions should never be executed
+// concurrently.
+static unsigned __acrt_locks_initialized;
+
+
+
+extern "C" bool __cdecl __acrt_initialize_locks()
+{
+    for (unsigned i = 0; i < __acrt_lock_count; ++i)
+    {
+        if (!__acrt_InitializeCriticalSectionEx(&__acrt_lock_table[i], _CORECRT_SPINCOUNT, 0))
+        {
+            __acrt_uninitialize_locks(false);
+            return false;
+        }
+
+        ++__acrt_locks_initialized;
+    }
+
+    return true;
+}
+
+extern "C" bool __cdecl __acrt_uninitialize_locks(bool const /* terminating */)
+{
+    for (unsigned i = __acrt_locks_initialized; i > 0; --i)
+    {
+        DeleteCriticalSection(&__acrt_lock_table[i - 1]);
+        --__acrt_locks_initialized;
+    }
+
+    return true;
+}
+
+extern "C" void __cdecl __acrt_lock(_In_ __acrt_lock_id _Lock)
+{
+    EnterCriticalSection(&__acrt_lock_table[_Lock]);
+}
+
+extern "C" void __cdecl __acrt_unlock(_In_ __acrt_lock_id _Lock)
+{
+    LeaveCriticalSection(&__acrt_lock_table[_Lock]);
+}
+
+extern "C" void __cdecl _lock_locales()
+{
+	__acrt_eagerly_load_locale_apis();
+    __acrt_lock(__acrt_locale_lock);
+}
+
+extern "C" void __cdecl _unlock_locales()
+{
+    __acrt_unlock(__acrt_locale_lock);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/peb_access.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/peb_access.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dde7a72efb5cea77cd1ff2b588fef9525bb3a53
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/peb_access.cpp	
@@ -0,0 +1,22 @@
+//
+// peb_access.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Wrapper functions to access fields in the PEB.
+//
+
+// Using internal headers for definitions. Only call publicly available functions.
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+
+extern "C" bool __cdecl __acrt_app_verifier_enabled()
+{
+    return (NtCurrentTeb()->ProcessEnvironmentBlock->NtGlobalFlag & FLG_APPLICATION_VERIFIER) != 0;
+}
+
+extern "C" bool __cdecl __acrt_is_secure_process()
+{
+    return (NtCurrentTeb()->ProcessEnvironmentBlock->ProcessParameters->Flags & RTL_USER_PROC_SECURE_PROCESS) != 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/per_thread_data.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/per_thread_data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d283a766a1f2e8a0466d812b3de6f012bb5dc20c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/per_thread_data.cpp	
@@ -0,0 +1,394 @@
+//
+// per_thread_data.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Per-Thread Data (PTD) used by the AppCRT.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stddef.h>
+
+
+
+#ifdef _CRT_GLOBAL_STATE_ISOLATION
+    extern "C" DWORD __crt_global_state_mode_flsindex = FLS_OUT_OF_INDEXES;
+#endif
+
+
+
+static void WINAPI destroy_fls(void*) throw();
+
+
+
+static unsigned long __acrt_flsindex = FLS_OUT_OF_INDEXES;
+
+
+bool __acrt_use_tls2_apis;
+
+extern "C" bool __cdecl __acrt_initialize_ptd()
+{
+#if !defined(_M_ARM64EC) && !((defined(_M_ARM64_) || defined(_UCRT_ENCLAVE_BUILD)) && _UCRT_DLL)
+    __acrt_use_tls2_apis = __acrt_tls2_supported();
+#endif
+
+    __acrt_flsindex = __acrt_FlsAlloc(destroy_fls);
+    if (__acrt_flsindex == FLS_OUT_OF_INDEXES)
+    {
+        return false;
+    }
+
+    if (__acrt_getptd_noexit() == nullptr)
+    {
+        __acrt_uninitialize_ptd(false);
+        return false;
+    }
+
+    return true;
+}
+
+extern "C" bool __cdecl __acrt_uninitialize_ptd(bool)
+{
+    if (__acrt_flsindex != FLS_OUT_OF_INDEXES)
+    {
+        __acrt_FlsFree(__acrt_flsindex);
+        __acrt_flsindex = FLS_OUT_OF_INDEXES;
+    }
+
+    return true;
+}
+
+
+
+static void __cdecl replace_current_thread_locale_nolock(
+    __acrt_ptd*        const ptd,
+    __crt_locale_data* const new_locale_info
+    ) throw()
+{
+    if (ptd->_locale_info)
+    {
+        __acrt_release_locale_ref(ptd->_locale_info);
+        if (ptd->_locale_info != __acrt_current_locale_data.value() &&
+            ptd->_locale_info != &__acrt_initial_locale_data &&
+            ptd->_locale_info->refcount == 0)
+        {
+            __acrt_free_locale(ptd->_locale_info);
+        }
+    }
+
+    ptd->_locale_info = new_locale_info;
+    if (ptd->_locale_info)
+    {
+        __acrt_add_locale_ref(ptd->_locale_info);
+    }
+}
+
+
+
+// Constructs a single PTD object, copying the given 'locale_data' if provided.
+static void __cdecl construct_ptd(
+    __acrt_ptd*         const ptd,
+    __crt_locale_data** const locale_data
+    ) throw()
+{
+    ptd->_rand_state  = 1;
+    ptd->_pxcptacttab = const_cast<__crt_signal_action_t*>(__acrt_exception_action_table);
+
+    // It is necessary to always have GLOBAL_LOCALE_BIT set in perthread data
+    // because when doing bitwise or, we won't get __UPDATE_LOCALE to work when
+    // global per thread locale is set.
+    // See _configthreadlocale() and __acrt_should_sync_with_global_locale().
+    ptd->_own_locale = _GLOBAL_LOCALE_BIT;
+
+    ptd->_multibyte_info = &__acrt_initial_multibyte_data;
+
+    // Initialize _setloc_data. These are the only valuse that need to be
+    // initialized.
+    ptd->_setloc_data._cachein[0]  = L'C';
+    ptd->_setloc_data._cacheout[0] = L'C';
+
+    // Downlevel data is not initially used
+    ptd->_setloc_downlevel_data = nullptr;
+
+    __acrt_lock_and_call(__acrt_multibyte_cp_lock, [&]
+    {
+        _InterlockedIncrement(&ptd->_multibyte_info->refcount);
+    });
+
+    // We need to make sure that ptd->ptlocinfo in never nullptr, this saves us
+    // perf counts when UPDATING locale.
+    __acrt_lock_and_call(__acrt_locale_lock, [&]
+    {
+        replace_current_thread_locale_nolock(ptd, *locale_data);
+    });
+}
+
+// Constructs each of the 'state_index_count' PTD objects in the array of PTD
+// objects pointed to by 'ptd'.
+static void __cdecl construct_ptd_array(__acrt_ptd* const ptd) throw()
+{
+    for (size_t i = 0; i != __crt_state_management::state_index_count; ++i)
+    {
+        construct_ptd(&ptd[i], &__acrt_current_locale_data.dangerous_get_state_array()[i]);
+    }
+}
+
+// Cleans up all resources used by a single PTD; does not free the PTD structure
+// itself.
+static void __cdecl destroy_ptd(__acrt_ptd* const ptd) throw()
+{
+    if (ptd->_pxcptacttab != __acrt_exception_action_table)
+    {
+        _free_crt(ptd->_pxcptacttab);
+    }
+
+    _free_crt(ptd->_cvtbuf);
+    _free_crt(ptd->_asctime_buffer);
+    _free_crt(ptd->_wasctime_buffer);
+    _free_crt(ptd->_gmtime_buffer);
+    _free_crt(ptd->_tmpnam_narrow_buffer);
+    _free_crt(ptd->_tmpnam_wide_buffer);
+    _free_crt(ptd->_strerror_buffer);
+    _free_crt(ptd->_wcserror_buffer);
+    _free_crt(ptd->_beginthread_context);
+
+    __acrt_lock_and_call(__acrt_multibyte_cp_lock, [&]
+    {
+        __crt_multibyte_data* const multibyte_data = ptd->_multibyte_info;
+        if (!multibyte_data)
+        {
+            return;
+        }
+
+        if (_InterlockedDecrement(&multibyte_data->refcount) != 0)
+        {
+            return;
+        }
+
+        if (multibyte_data == &__acrt_initial_multibyte_data)
+        {
+            return;
+        }
+
+        _free_crt(multibyte_data);
+    });
+
+    __acrt_lock_and_call(__acrt_locale_lock, [&]
+    {
+        replace_current_thread_locale_nolock(ptd, nullptr);
+    });
+}
+
+// Destroys each of the 'state_index_count' PTD objects in the array of PTD
+// objects pointed to by 'ptd'.
+static void __cdecl destroy_ptd_array(__acrt_ptd* const ptd) throw()
+{
+    for (size_t i = 0; i != __crt_state_management::state_index_count; ++i)
+    {
+        destroy_ptd(&ptd[i]);
+    }
+}
+
+// This function is called by the operating system when a thread is being
+// destroyed, to allow us the opportunity to clean up.
+static void WINAPI destroy_fls(void* const pfd) throw()
+{
+    if (!pfd)
+    {
+        return;
+    }
+
+    destroy_ptd_array(static_cast<__acrt_ptd*>(pfd));
+    _free_crt(pfd);
+}
+
+template<typename flsgetvalue_type>
+__forceinline
+__acrt_ptd* try_get_ptd_head(
+    flsgetvalue_type flsgetvalue
+    ) throw()
+{
+    // If we haven't allocated per-thread data for this module, return failure:
+    if (__acrt_flsindex == FLS_OUT_OF_INDEXES)
+    {
+        return nullptr;
+    }
+
+    __acrt_ptd* const ptd_head = static_cast<__acrt_ptd*>(flsgetvalue(__acrt_flsindex));
+    if (!ptd_head)
+    {
+        return nullptr;
+    }
+
+    return ptd_head;
+}
+
+// We use the CRT heap to allocate the PTD.  If the CRT heap fails to
+// allocate the requested memory, it will attempt to set errno to ENOMEM,
+// which will in turn attempt to acquire the PTD, resulting in infinite
+// recursion that causes a stack overflow.
+//
+// We set the PTD to this sentinel value for the duration of the allocation
+// in order to detect this case.
+static void* const reentrancy_sentinel = reinterpret_cast<void*>(SIZE_MAX);
+
+_Success_(return != nullptr)
+DECLSPEC_NOINLINE
+__acrt_ptd* internal_get_ptd_head_slow() throw()
+{
+    __crt_scoped_get_last_error_reset const last_error_reset;
+    if (!__acrt_FlsSetValue(__acrt_flsindex, reentrancy_sentinel))
+    {
+        return nullptr;
+    }
+
+    __crt_unique_heap_ptr<__acrt_ptd> new_ptd_head(_calloc_crt_t(__acrt_ptd, __crt_state_management::state_index_count));
+    if (!new_ptd_head)
+    {
+        __acrt_FlsSetValue(__acrt_flsindex, nullptr);
+        return nullptr;
+    }
+
+    if (!__acrt_FlsSetValue(__acrt_flsindex, new_ptd_head.get()))
+    {
+        __acrt_FlsSetValue(__acrt_flsindex, nullptr);
+        return nullptr;
+    }
+
+    construct_ptd_array(new_ptd_head.get());
+    return new_ptd_head.detach();
+}
+
+template<typename flsgetvalue_type>
+_Success_(return != nullptr)
+__forceinline
+__acrt_ptd* internal_get_ptd_head(
+    flsgetvalue_type flsgetvalue
+    ) throw()
+{
+    __acrt_ptd* const existing_ptd_head = try_get_ptd_head(flsgetvalue);
+    if (existing_ptd_head == reentrancy_sentinel)
+    {
+        return nullptr;
+    }
+    else if (existing_ptd_head != nullptr)
+    {
+        return existing_ptd_head;
+    }
+
+    return internal_get_ptd_head_slow();
+}
+
+// This functionality has been split out of __acrt_getptd_noexit so that we can
+// force it to be inlined into both __acrt_getptd_noexit and __acrt_getptd.  These
+// functions are performance critical and this change has substantially improved
+// __acrt_getptd performance.
+static __forceinline __acrt_ptd* __cdecl internal_getptd_noexit(
+    __crt_scoped_get_last_error_reset const& last_error_reset,
+    size_t                            const  global_state_index
+    ) throw()
+{
+    UNREFERENCED_PARAMETER(last_error_reset);
+    __acrt_ptd* const ptd_head = internal_get_ptd_head(__acrt_FlsGetValue);
+    if (!ptd_head)
+    {
+        return nullptr;
+    }
+
+    return ptd_head + global_state_index;
+}
+
+static __forceinline __acrt_ptd* __cdecl internal_getptd_noexit() throw()
+{
+    __crt_scoped_get_last_error_reset const last_error_reset;
+    return internal_getptd_noexit(last_error_reset, __crt_state_management::get_current_state_index(last_error_reset));
+}
+
+static __forceinline __acrt_ptd* __cdecl internal_getptd_noexit2() throw()
+{
+    __acrt_ptd* const ptd_head = internal_get_ptd_head(__acrt_FlsGetValue2);
+    if (!ptd_head)
+    {
+        return nullptr;
+    }
+
+    return ptd_head + __crt_state_management::get_current_state_index2();
+}
+
+__acrt_ptd* __cdecl __acrt_getptd_noexit_explicit(__crt_scoped_get_last_error_reset const& last_error_reset, size_t const global_state_index)
+{   // An extra function to grab the PTD while a GetLastError() reset guard is already in place
+    // and the global state index is already known.
+
+    return internal_getptd_noexit(last_error_reset, global_state_index);
+}
+
+extern "C" __acrt_ptd* __cdecl __acrt_getptd_noexit()
+{
+    __acrt_ptd* ptd;
+
+#if (defined(_M_ARM64_) || defined(_M_ARM64EC) || defined(_UCRT_ENCLAVE_BUILD)) && _UCRT_DLL
+    ptd = internal_getptd_noexit2();
+#elif defined(_M_ARM64EC)
+    ptd = internal_getptd_noexit();
+#else
+    if (__acrt_use_tls2_apis)
+    {
+        ptd = internal_getptd_noexit2();
+    }
+    else
+    {
+        ptd = internal_getptd_noexit();
+    }
+#endif
+
+    return ptd;
+}
+
+extern "C" __acrt_ptd* __cdecl __acrt_getptd()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (!ptd)
+    {
+        abort();
+    }
+
+    return ptd;
+}
+
+extern "C" __acrt_ptd* __cdecl __acrt_getptd_head()
+{
+    __acrt_ptd* const ptd_head = internal_get_ptd_head(__acrt_FlsGetValue);
+    if (!ptd_head)
+    {
+        abort();
+    }
+
+    return ptd_head;
+}
+
+
+
+extern "C" void __cdecl __acrt_freeptd()
+{
+    __acrt_ptd* const ptd_head = try_get_ptd_head(__acrt_FlsGetValue);
+    if (!ptd_head)
+    {
+        return;
+    }
+
+    __acrt_FlsSetValue(__acrt_flsindex, nullptr);
+    destroy_fls(ptd_head);
+}
+
+
+
+// These functions are simply wrappers around the Windows API functions.
+extern "C" unsigned long __cdecl __threadid()
+{
+    return GetCurrentThreadId();
+}
+
+extern "C" uintptr_t __cdecl __threadhandle()
+{
+    return reinterpret_cast<uintptr_t>(GetCurrentThread());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/report_runtime_error.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/report_runtime_error.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9911e483163643067e60af69dba8575078d03176
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/report_runtime_error.cpp	
@@ -0,0 +1,200 @@
+/***
+*report_runtime_error.cpp - startup error messages
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Prints out banner for runtime error messages.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+
+
+// This is used during the expansion of the runtime error text.
+#define EOL L"\r\n"
+
+static bool __cdecl issue_debug_notification(wchar_t const* const message) throw()
+{
+    // This is referenced only in the Debug CRT build
+    UNREFERENCED_PARAMETER(message);
+
+#ifdef _DEBUG
+    switch (_CrtDbgReportW(_CRT_ERROR, nullptr, 0, nullptr, L"%ls", message))
+    {
+    case 1:
+        _CrtDbgBreak();
+        return true;
+
+    case 0:
+        return true;
+    }
+#endif // _DEBUG
+
+    return false;
+}
+
+
+
+
+// Enclaves do not support error messages outside of OutputDebugString.
+#ifdef _UCRT_ENCLAVE_BUILD
+
+extern "C" void __cdecl __acrt_report_runtime_error(wchar_t const* const message)
+{
+    // Report the error using the debug
+    issue_debug_notification(message);
+}
+
+#else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */
+
+/*
+ * __acrt_app_type, together with __error_mode, determine how error messages
+ * are written out.
+ */
+static _crt_app_type __acrt_app_type = _crt_unknown_app;
+
+/***
+*void _set_app_type(int apptype) - interface to change __acrt_app_type
+*
+*Purpose:
+*       Set, or change, the value of __acrt_app_type.
+*
+*       Set the default debug lib report destination for console apps.
+*
+*       This function is for INTERNAL USE ONLY.
+*
+*Entry:
+*       int modeval =   _crt_unknown_app,   unknown
+*                       _crt_console_app,   console, or command line, application
+*                       _crt_gui_app,       GUI, or Windows, application
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl _set_app_type(_crt_app_type const new_app_type)
+{
+    __acrt_app_type = new_app_type;
+}
+
+extern "C" _crt_app_type __cdecl _query_app_type()
+{
+    return __acrt_app_type;
+}
+
+
+
+static bool __cdecl should_write_error_to_console() throw()
+{
+    int const error_mode = _set_error_mode(_REPORT_ERRMODE);
+
+    if (error_mode == _OUT_TO_STDERR)
+    {
+        return true;
+    }
+
+    if (error_mode == _OUT_TO_DEFAULT && __acrt_app_type == _crt_console_app)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+
+static void write_string_to_console(wchar_t const* const wide_string) throw()
+{
+    HANDLE const handle = GetStdHandle(STD_ERROR_HANDLE);
+    if (handle == nullptr || handle == INVALID_HANDLE_VALUE)
+    {
+        return;
+    }
+
+    // We convert the wide string to a narrow string by truncating each character.
+    // Currently, the text for each runtime error consists only of ASCII, so this
+    // is acceptable.  If the error text is ever localized, this would need to
+    // change.
+    size_t const narrow_buffer_count = 500;
+    char narrow_buffer[narrow_buffer_count];
+
+    char* const narrow_first = narrow_buffer;
+    char* const narrow_last  = narrow_first + narrow_buffer_count;
+
+    // Note that this loop copies the null terminator if the loop terminates
+    // befoe running out of buffer space:
+    char*          narrow_it = narrow_first;
+    wchar_t const* wide_it   = wide_string;
+    do
+    {
+        *narrow_it = static_cast<char>(*wide_it);
+    }
+    while (++narrow_it != narrow_last && *wide_it++ != '\0');
+
+    // If we did run out of buffer space, this will null-terminate the text that
+    // we were able to copy:
+    *(narrow_last - 1) = '\0';
+
+    DWORD const bytes_to_write = static_cast<DWORD>(narrow_it - narrow_first - 1); // Account for null terminator
+    DWORD       bytes_written  = 0;
+    WriteFile(handle, narrow_buffer, bytes_to_write, &bytes_written, nullptr);
+}
+
+
+
+extern "C" void __cdecl __acrt_report_runtime_error(wchar_t const* const message)
+{
+    // Before we report the error via the normal path, report the error using
+    // the debug
+    if (issue_debug_notification(message))
+    {
+        return;
+    }
+
+    if (should_write_error_to_console())
+    {
+        write_string_to_console(message);
+    }
+    else
+    {
+        #define MSGTEXTPREFIX L"Runtime Error!\n\nProgram: "
+        static wchar_t outmsg[sizeof(MSGTEXTPREFIX) / sizeof(wchar_t) + _MAX_PATH + 2 + 500];
+        // runtime error msg + progname + 2 newline + runtime error text.
+        wchar_t* progname = &outmsg[sizeof(MSGTEXTPREFIX) / sizeof(wchar_t) - 1];
+        size_t progname_size = _countof(outmsg) - (progname - outmsg);
+        wchar_t* pch = progname;
+
+        _ERRCHECK(wcscpy_s(outmsg, _countof(outmsg), MSGTEXTPREFIX));
+
+        progname[MAX_PATH] = L'\0';
+        if (!GetModuleFileNameW(nullptr, progname, MAX_PATH))
+        {
+            _ERRCHECK(wcscpy_s(progname, progname_size, L"<program name unknown>"));
+        }
+
+        #define MAXLINELEN 60
+        if (wcslen(pch) + 1 > MAXLINELEN)
+        {
+            pch += wcslen(progname) + 1 - MAXLINELEN;
+            _ERRCHECK(wcsncpy_s(pch, progname_size - (pch - progname), L"...", 3));
+        }
+
+        _ERRCHECK(wcscat_s(outmsg, _countof(outmsg), L"\n\n"));
+        _ERRCHECK(wcscat_s(outmsg, _countof(outmsg), message));
+
+        // Okay to ignore return value here, this is just to display the message box.
+        // Only caller is abort() (so we shouldn't/can't handle IDABORT), so the process
+        // will end shortly.
+        __acrt_show_wide_message_box(
+            outmsg,
+            L"Microsoft Visual C++ Runtime Library",
+            MB_OK | MB_ICONHAND | MB_SETFOREGROUND | MB_TASKMODAL);
+    }
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/shared_initialization.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/shared_initialization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af15c02816eb1029fe83adfa28329e62a63eed97
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/shared_initialization.cpp	
@@ -0,0 +1,67 @@
+//
+// shared_initialization.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Shared initialization logic used by both the AppCRT and the DesktopCRT.
+//
+#include <corecrt_internal.h>
+
+extern "C" bool __cdecl __acrt_execute_initializers(
+    __acrt_initializer const* const first,
+    __acrt_initializer const* const last
+    )
+{
+    if (first == last)
+        return true;
+
+    // Execute the initializers in [first, last), in order:
+    __acrt_initializer const* it = first;
+    for (; it != last; ++it)
+    {
+        if (it->_initialize == nullptr)
+            continue;
+
+        if (!(it->_initialize)())
+            break;
+    }
+
+    // If we reached the end, all initializers completed successfully:
+    if (it == last)
+        return true;
+
+    // Otherwise, the initializer pointed to by it failed.  We need to roll back
+    // the initialization by executing the uninitializers corresponding to each
+    // of the initializers that completed successfully:
+    for (; it != first; --it)
+    {
+        // During initialization roll back, we do not execute uninitializers
+        // that have no corresponding initializer:
+        if ((it - 1)->_initialize == nullptr || (it - 1)->_uninitialize == nullptr)
+            continue;
+
+        (it - 1)->_uninitialize(false);
+    }
+
+    return false;
+}
+
+extern "C" bool __cdecl __acrt_execute_uninitializers(
+    __acrt_initializer const* const first,
+    __acrt_initializer const* const last
+    )
+{
+    if (first == last)
+        return true;
+
+    // Execute the uninitializers in [first, last), in reverse order:
+    for (__acrt_initializer const* it = last; it != first; --it)
+    {
+        if ((it - 1)->_uninitialize == nullptr)
+            continue;
+
+        (it - 1)->_uninitialize(false);
+    }
+
+    return true;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/win_policies.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/win_policies.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7226be8c2be253be25a42981e8e6e3e17c300a99
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/win_policies.cpp	
@@ -0,0 +1,182 @@
+//
+// win_policies.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Wrapper functions that determine what policies should apply for the process in question.
+//
+
+#include <corecrt_internal.h>
+
+template<typename TPolicy>
+static typename TPolicy::policy_type __cdecl get_win_policy(typename TPolicy::appmodel_policy_type defaultValue)
+{
+    TPolicy::appmodel_policy_type appmodelPolicy = defaultValue;
+
+    // Secure processes cannot load the appmodel DLL, so only attempt loading
+    // policy information if this is not a secure process.
+    if (!__acrt_is_secure_process())
+    {
+        TPolicy::appmodel_get_policy(&appmodelPolicy);
+    }
+
+    return TPolicy::appmodel_policy_to_policy_type(appmodelPolicy);
+}
+
+template<typename TPolicy>
+static typename TPolicy::policy_type __cdecl get_cached_win_policy(typename TPolicy::appmodel_policy_type defaultValue)
+{
+    static long state_cache = 0;
+    if (long const cached_state = __crt_interlocked_read(&state_cache))
+    {
+        return static_cast<TPolicy::policy_type>(cached_state);
+    }
+
+    TPolicy::appmodel_policy_type appmodelPolicy = defaultValue;
+
+    // Secure processes cannot load the appmodel DLL, so only attempt loading
+    // policy information if this is not a secure process.
+    if (!__acrt_is_secure_process())
+    {
+        TPolicy::appmodel_get_policy(&appmodelPolicy);
+    }
+
+    TPolicy::policy_type const policyValue = TPolicy::appmodel_policy_to_policy_type(appmodelPolicy);
+
+    long const cached_state = _InterlockedExchange(&state_cache, static_cast<long>(policyValue));
+    if (cached_state)
+    {
+        _ASSERTE(cached_state == static_cast<long>(policyValue));
+    }
+
+    return policyValue;
+}
+
+// Determines whether ExitProcess() or TerminateProcess() should be used to end the process
+extern "C" process_end_policy __cdecl __acrt_get_process_end_policy()
+{
+    struct process_end_policy_properties
+    {
+        typedef process_end_policy policy_type;
+        typedef AppPolicyProcessTerminationMethod appmodel_policy_type;
+
+        static policy_type appmodel_policy_to_policy_type(appmodel_policy_type const appmodelPolicy) throw()
+        {
+            if (appmodelPolicy == AppPolicyProcessTerminationMethod_TerminateProcess)
+            {
+                return process_end_policy_terminate_process;
+            }
+            else
+            {
+                return process_end_policy_exit_process;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetProcessTerminationMethodInternal(appmodelPolicy);
+        }
+    };
+
+    return get_win_policy<process_end_policy_properties>(AppPolicyProcessTerminationMethod_ExitProcess);
+}
+
+// Determines whether RoInitialize() should be called when creating a thread
+extern "C" begin_thread_init_policy __cdecl __acrt_get_begin_thread_init_policy()
+{
+    struct begin_thread_init_policy_properties
+    {
+        typedef begin_thread_init_policy policy_type;
+        typedef AppPolicyThreadInitializationType appmodel_policy_type;
+
+        static_assert(begin_thread_init_policy_unknown == 0, "Default value for cache must be 0");
+
+        static policy_type appmodel_policy_to_policy_type(long const appmodelPolicy) throw()
+        {
+            if (appmodelPolicy == AppPolicyThreadInitializationType_InitializeWinRT)
+            {
+                return begin_thread_init_policy_ro_initialize;
+            }
+            else
+            {
+                return begin_thread_init_policy_none;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetThreadInitializationTypeInternal(appmodelPolicy);
+        }
+    };
+
+    return get_cached_win_policy<begin_thread_init_policy_properties>(AppPolicyThreadInitializationType_None);
+}
+
+// Determines whether we should attempt to display assert dialog
+extern "C" developer_information_policy __cdecl __acrt_get_developer_information_policy()
+{
+    struct developer_information_policy_properties
+    {
+        typedef developer_information_policy policy_type;
+        typedef AppPolicyShowDeveloperDiagnostic appmodel_policy_type;
+
+        static_assert(developer_information_policy_unknown == 0, "Default value for cache must be 0");
+
+        static policy_type appmodel_policy_to_policy_type(long const appmodelPolicy) throw()
+        {
+            if (appmodelPolicy == AppPolicyShowDeveloperDiagnostic_ShowUI)
+            {
+                return developer_information_policy_ui;
+            }
+            else
+            {
+                return developer_information_policy_none;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetShowDeveloperDiagnosticInternal(appmodelPolicy);
+        }
+    };
+
+    return get_cached_win_policy<developer_information_policy_properties>(AppPolicyShowDeveloperDiagnostic_ShowUI);
+}
+
+// Determines what type of windowing model technology is available
+extern "C" windowing_model_policy __cdecl __acrt_get_windowing_model_policy()
+{
+    struct windowing_model_policy_properties
+    {
+        typedef windowing_model_policy policy_type;
+        typedef AppPolicyWindowingModel appmodel_policy_type;
+
+        static_assert(windowing_model_policy_unknown == 0, "Default value for cache must be 0");
+
+        static policy_type appmodel_policy_to_policy_type(long const appmodelPolicy) throw()
+        {
+            switch (appmodelPolicy)
+            {
+                case AppPolicyWindowingModel_ClassicDesktop:
+                    return windowing_model_policy_hwnd;
+
+                case AppPolicyWindowingModel_Universal:
+                    return windowing_model_policy_corewindow;
+
+                case AppPolicyWindowingModel_ClassicPhone:
+                    return windowing_model_policy_legacyphone;
+
+                case AppPolicyWindowingModel_None:
+                default:
+                    return windowing_model_policy_none;
+            }
+        }
+
+        static LONG appmodel_get_policy(appmodel_policy_type* appmodelPolicy)
+        {
+            return __acrt_AppPolicyGetWindowingModelInternal(appmodelPolicy);
+        }
+    };
+
+    return get_cached_win_policy<windowing_model_policy_properties>(AppPolicyWindowingModel_ClassicDesktop);
+}
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/winapi_thunks.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/winapi_thunks.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa8c082310f7d7b47980b9831ba7c0d52455276c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/internal/winapi_thunks.cpp	
@@ -0,0 +1,982 @@
+//
+// winapi_thunks.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of wrappers for Windows API functions that cannot be called
+// directly because they are not available on all supported operating systems.
+//
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <ntsecapi.h>
+#include <corecrt_internal.h>
+#include <appmodel.h>
+#include <roapi.h>
+
+ WINBASEAPI
+ _Success_(return > 0 && return < BufferLength)
+ DWORD
+ WINAPI
+ GetTempPath2W(
+     _In_ DWORD BufferLength,
+     _Out_writes_to_opt_(BufferLength,return + 1) LPWSTR Buffer
+     );
+
+// The XState APIs are declared by the Windows headers only when building for
+// x86 and x64.  We declare them here unconditionally so that we can share the
+// same code for all architectures (we simply avoid use of these functions on
+// other architectures).
+extern "C" WINBASEAPI DWORD64 WINAPI GetEnabledXStateFeatures();
+
+_Must_inspect_result_
+extern "C" WINBASEAPI BOOL WINAPI GetXStateFeaturesMask(
+    _In_  PCONTEXT context,
+    _Out_ PDWORD64 feature_mask
+    );
+
+_Success_(return != NULL)
+extern "C" WINBASEAPI PVOID WINAPI LocateXStateFeature(
+    _In_      PCONTEXT context,
+    _In_      DWORD    feature_id,
+    _Out_opt_ PDWORD   length
+    );
+
+_Must_inspect_result_
+extern "C" WINBASEAPI BOOL WINAPI GetFileInformationByName(
+    _In_ PCWSTR FileName,
+    _In_ DWORD /* FILE_INFO_BY_NAME_CLASS */ FileInformationClass,
+    _Out_writes_bytes_(FileInfoBufferSize) PVOID FileInfoBuffer,
+    _In_ ULONG FileInfoBufferSize
+    );
+
+#define _ACRT_APPLY_TO_LATE_BOUND_MODULES_0                                                              \
+    _APPLY(api_ms_win_core_datetime_l1_1_1,              "api-ms-win-core-datetime-l1-1-1"             ) \
+    _APPLY(api_ms_win_core_fibers_l1_1_2,                "api-ms-win-core-fibers-l1-1-2"               ) \
+    _APPLY(api_ms_win_core_file_l1_2_4,                  "api-ms-win-core-file-l1-2-4"                 ) \
+    _APPLY(api_ms_win_core_file_l1_2_2,                  "api-ms-win-core-file-l1-2-2"                 ) \
+    _APPLY(api_ms_win_core_file_l2_1_4,                  "api-ms-win-core-file-l2-1-4"                 ) \
+    _APPLY(api_ms_win_core_localization_l1_2_1,          "api-ms-win-core-localization-l1-2-1"         ) \
+    _APPLY(api_ms_win_core_localization_obsolete_l1_2_0, "api-ms-win-core-localization-obsolete-l1-2-0") \
+    _APPLY(api_ms_win_core_processthreads_l1_1_2,        "api-ms-win-core-processthreads-l1-1-2"       ) \
+    _APPLY(api_ms_win_core_string_l1_1_0,                "api-ms-win-core-string-l1-1-0"               ) \
+    _APPLY(api_ms_win_core_synch_l1_2_0,                 "api-ms-win-core-synch-l1-2-0"                ) \
+    _APPLY(api_ms_win_core_sysinfo_l1_2_1,               "api-ms-win-core-sysinfo-l1-2-1"              ) \
+    _APPLY(api_ms_win_core_winrt_l1_1_0,                 "api-ms-win-core-winrt-l1-1-0"                ) \
+    _APPLY(api_ms_win_core_xstate_l2_1_0,                "api-ms-win-core-xstate-l2-1-0"               ) \
+    _APPLY(api_ms_win_rtcore_ntuser_window_l1_1_0,       "api-ms-win-rtcore-ntuser-window-l1-1-0"      ) \
+    _APPLY(api_ms_win_security_systemfunctions_l1_1_0,   "api-ms-win-security-systemfunctions-l1-1-0"  ) \
+    _APPLY(ext_ms_win_ntuser_dialogbox_l1_1_0,           "ext-ms-win-ntuser-dialogbox-l1-1-0"          ) \
+    _APPLY(ext_ms_win_ntuser_windowstation_l1_1_0,       "ext-ms-win-ntuser-windowstation-l1-1-0"      ) \
+    _APPLY(advapi32,                                     "advapi32"                                    ) \
+    _APPLY(kernel32,                                     "kernel32"                                    ) \
+    _APPLY(kernelbase,                                   "kernelbase"                                  ) \
+    _APPLY(ntdll,                                        "ntdll"                                       ) \
+    _APPLY(api_ms_win_appmodel_runtime_l1_1_2,           "api-ms-win-appmodel-runtime-l1-1-2"          ) \
+    _APPLY(user32,                                       "user32"                                      )
+
+#define _ACRT_APPLY_TO_LATE_BOUND_MODULES  \
+    _ACRT_APPLY_TO_LATE_BOUND_MODULES_0 \
+
+#define _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS_0                                                                                                           \
+    _APPLY(AreFileApisANSI,                             ({ /* api_ms_win_core_file_l1_2_2, */            kernel32                                   })) \
+    _APPLY(CompareStringEx,                             ({ api_ms_win_core_string_l1_1_0,                kernel32                                   })) \
+    _APPLY(EnumSystemLocalesEx,                         ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(FlsGetValue2,                                ({ api_ms_win_core_fibers_l1_1_2,                kernelbase                                 })) \
+    _APPLY(GetActiveWindow,                             ({ api_ms_win_rtcore_ntuser_window_l1_1_0,       user32                                     })) \
+    _APPLY(GetDateFormatEx,                             ({ api_ms_win_core_datetime_l1_1_1,              kernel32                                   })) \
+    _APPLY(GetTempPath2W,                               ({ api_ms_win_core_file_l1_2_4,                  kernelbase                                 })) \
+    _APPLY(GetFileInformationByName,                    ({ api_ms_win_core_file_l2_1_4,                  kernelbase                                 })) \
+    _APPLY(GetEnabledXStateFeatures,                    ({ api_ms_win_core_xstate_l2_1_0,                kernel32                                   })) \
+    _APPLY(GetLastActivePopup,                          ({ ext_ms_win_ntuser_dialogbox_l1_1_0,           user32                                     })) \
+    _APPLY(GetLocaleInfoEx,                             ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(GetProcessWindowStation,                     ({ ext_ms_win_ntuser_windowstation_l1_1_0,       user32                                     })) \
+    _APPLY(GetSystemTimePreciseAsFileTime,              ({ api_ms_win_core_sysinfo_l1_2_1                                                           })) \
+    _APPLY(GetTimeFormatEx,                             ({ api_ms_win_core_datetime_l1_1_1,              kernel32                                   })) \
+    _APPLY(GetUserDefaultLocaleName,                    ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(GetUserObjectInformationW,                   ({ ext_ms_win_ntuser_windowstation_l1_1_0,       user32                                     })) \
+    _APPLY(GetXStateFeaturesMask,                       ({ api_ms_win_core_xstate_l2_1_0,                kernel32                                   })) \
+    _APPLY(IsValidLocaleName,                           ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(LCMapStringEx,                               ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(LCIDToLocaleName,                            ({ api_ms_win_core_localization_obsolete_l1_2_0, kernel32                                   })) \
+    _APPLY(LocaleNameToLCID,                            ({ api_ms_win_core_localization_l1_2_1,          kernel32                                   })) \
+    _APPLY(LocateXStateFeature,                         ({ api_ms_win_core_xstate_l2_1_0,                kernel32                                   })) \
+    _APPLY(MessageBoxA,                                 ({ ext_ms_win_ntuser_dialogbox_l1_1_0,           user32                                     })) \
+    _APPLY(MessageBoxW,                                 ({ ext_ms_win_ntuser_dialogbox_l1_1_0,           user32                                     })) \
+    _APPLY(RoInitialize,                                ({ api_ms_win_core_winrt_l1_1_0                                                             })) \
+    _APPLY(RoUninitialize,                              ({ api_ms_win_core_winrt_l1_1_0                                                             })) \
+    _APPLY(AppPolicyGetProcessTerminationMethod,        ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(AppPolicyGetThreadInitializationType,        ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(AppPolicyGetShowDeveloperDiagnostic,         ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(AppPolicyGetWindowingModel,                  ({ api_ms_win_appmodel_runtime_l1_1_2                                                       })) \
+    _APPLY(SetThreadStackGuarantee,                     ({ api_ms_win_core_processthreads_l1_1_2,        kernel32                                   })) \
+    _APPLY(SystemFunction036,                           ({ api_ms_win_security_systemfunctions_l1_1_0,   advapi32                                   }))
+
+#define _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS \
+    _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS_0 \
+
+namespace
+{
+    // Generate enumerators for each of the modules:
+    enum module_id : unsigned
+    {
+        #define _APPLY(_SYMBOL, _NAME) _SYMBOL,
+        _ACRT_APPLY_TO_LATE_BOUND_MODULES
+        #undef _APPLY
+
+        module_id_count
+    };
+
+    // Generate a table of module names that can be indexed by the module_id
+    // enumerators:
+    static wchar_t const* const module_names[module_id_count] =
+    {
+        #define _APPLY(_SYMBOL, _NAME) _CRT_WIDE(_NAME),
+        _ACRT_APPLY_TO_LATE_BOUND_MODULES
+        #undef _APPLY
+    };
+
+    // Generate enumerators for each of the functions:
+    enum function_id : unsigned
+    {
+        #define _APPLY(_FUNCTION, _MODULES) _CRT_CONCATENATE(_FUNCTION, _id),
+        _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+        #undef _APPLY
+
+        function_id_count
+    };
+
+    // Generate a typedef for each function of the form function_pft.
+    #define _APPLY(_FUNCTION, _MODULES) \
+        using _CRT_CONCATENATE(_FUNCTION, _pft) = decltype(_FUNCTION)*;
+    _ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+    #undef _APPLY
+}
+
+// This table stores the module handles that we have obtained via LoadLibrary.
+// If a handle is null, we have not yet attempted to load that module.  If a
+// handle is -1 (INVALID_HANDLE_VALUE), we have attempted to load the module
+// but the attempt failed.
+static HMODULE module_handles[module_id_count];
+
+// This table stores the function pointers that we have loaded dynamically. 
+// If a function pointer is a null pointer, we have not yet attempted to
+// get that function pointer.  If a function pointer is an -1, we have
+// attempted to get that function pointer but the attempt failed.
+#pragma data_seg(push, almostro, ".fptable")
+#pragma bss_seg(push, almostro, ".fptable")
+static void* function_pointers[function_id_count];
+#pragma bss_seg(pop, almostro)
+#pragma data_seg(pop, almostro)
+
+extern "C" bool __cdecl __acrt_initialize_winapi_thunks()
+{
+    DWORD old_prot;
+    return VirtualProtect(function_pointers, sizeof(function_pointers), PAGE_READONLY, &old_prot) ? true : false;
+}
+
+extern "C" bool __cdecl __acrt_uninitialize_winapi_thunks(bool const terminating)
+{
+    // If the process is terminating, there's no need to free any module handles
+    if (terminating)
+    {
+        return true;
+    }
+
+    for (HMODULE& module : module_handles)
+    {
+        if (module)
+        {
+            if (module != INVALID_HANDLE_VALUE)
+            {
+                FreeLibrary(module);
+            }
+
+            module = nullptr;
+        }
+    }
+
+    return true;
+}
+
+static __forceinline void* __cdecl invalid_function_sentinel() throw()
+{
+    return reinterpret_cast<void*>(static_cast<uintptr_t>(-1));
+}
+
+static HMODULE __cdecl try_load_library_from_system_directory(wchar_t const* const name) throw()
+{
+    HMODULE const handle = LoadLibraryExW(name, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+    if (handle)
+    {
+        return handle;
+    }
+
+    // LOAD_LIBRARY_SEARCH_SYSTEM32 is only supported by Windows 7 and above; if
+    // the OS does not support this flag, try again without it.  On these OSes,
+    // all APISets will be forwarders.  To prevent DLL hijacking, do not attempt
+    // to load the APISet forwarders dynamically.  This will cause our caller to
+    // fall back to the real DLL (e.g. kernel32).  All of those are known DLLs.
+    if (GetLastError() == ERROR_INVALID_PARAMETER &&
+        wcsncmp(name, L"api-ms-", 7) != 0 &&
+        wcsncmp(name, L"ext-ms-", 7) != 0)
+    {
+        return LoadLibraryExW(name, nullptr, 0);
+    }
+
+    return nullptr;
+}
+
+static HMODULE __cdecl try_get_module(module_id const id) throw()
+{
+    // First check to see if we've cached the module handle:
+    if (HMODULE const cached_handle = __crt_interlocked_read_pointer(module_handles + id))
+    {
+        if (cached_handle == INVALID_HANDLE_VALUE)
+        {
+            return nullptr;
+        }
+
+        return cached_handle;
+    }
+
+    // If we haven't yet cached the module handle, try to load the library.  If
+    // this fails, cache the sentinel handle value INVALID_HANDLE_VALUE so that
+    // we don't attempt to load the module again:
+    HMODULE const new_handle = try_load_library_from_system_directory(module_names[id]);
+    if (!new_handle)
+    {
+        if (HMODULE const cached_handle = __crt_interlocked_exchange_pointer(module_handles + id, INVALID_HANDLE_VALUE))
+        {
+            _ASSERTE(cached_handle == INVALID_HANDLE_VALUE);
+        }
+
+        return nullptr;
+    }
+
+    // Swap the new handle into the cache.  If the cache no longer contained a
+    // null handle, then some other thread loaded the module and cached the
+    // handle while we were doing the same.  In that case, we free the handle
+    // once to maintain the reference count:
+    if (HMODULE const cached_handle = __crt_interlocked_exchange_pointer(module_handles + id, new_handle))
+    {
+        _ASSERTE(cached_handle == new_handle);
+        FreeLibrary(new_handle);
+    }
+
+    return new_handle;
+}
+
+static HMODULE __cdecl try_get_first_available_module(
+    module_id const* const first,
+    module_id const* const last
+    ) throw()
+{
+    for (module_id const* it = first; it != last; ++it)
+    {
+        HMODULE const handle = try_get_module(*it);
+        if (handle)
+        {
+            return handle;
+        }
+    }
+
+    return nullptr;
+}
+
+static __forceinline void* __cdecl try_get_proc_address_from_first_available_module(
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    HMODULE const module_handle = try_get_first_available_module(first_module_id, last_module_id);
+    if (!module_handle)
+    {
+        return nullptr;
+    }
+
+    return reinterpret_cast<void*>(GetProcAddress(module_handle, name));
+}
+
+DECLSPEC_NOINLINE
+static void* __cdecl try_get_function_slow(
+    function_id      const id,
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    // If we haven't yet cached the function pointer, try to import it from any
+    // of the modules in which it might be defined.  If this fails, cache the
+    // sentinel pointer so that we don't attempt to load this function again:
+    void* const new_fp = try_get_proc_address_from_first_available_module(name, first_module_id, last_module_id);
+
+    __acrt_lock(__acrt_function_pointer_table_lock);
+
+    DWORD old_prot;
+    BOOL vp_result = VirtualProtect(function_pointers, sizeof(function_pointers), PAGE_READWRITE, &old_prot);
+    if (vp_result == FALSE)
+    {
+        abort();
+    }
+
+    if (!new_fp)
+    {
+        void* const cached_fp =
+            __crt_interlocked_exchange_pointer(
+                function_pointers + id,
+                invalid_function_sentinel());
+
+        if (cached_fp)
+        {
+            _ASSERTE(cached_fp == invalid_function_sentinel());
+        }
+
+        goto end;
+    }
+
+    // Swap the newly obtained function pointer into the cache.  The cache may
+    // no longer contain a null pointer if another thread obtained the
+    // function address while we were doing the same (both threads should have
+    // gotten the same function pointer):
+    {
+        void* const cached_fp =
+            __crt_interlocked_exchange_pointer(
+                function_pointers + id,
+                new_fp);
+
+        if (cached_fp)
+        {
+            _ASSERTE(cached_fp == new_fp);
+        }
+    }
+
+end:
+    vp_result = VirtualProtect(function_pointers, sizeof(function_pointers), PAGE_READONLY, &old_prot);
+    if (vp_result == FALSE)
+    {
+        abort();
+    }
+
+    __acrt_unlock(__acrt_function_pointer_table_lock);
+
+    return new_fp;
+}
+
+static __forceinline void* __cdecl try_get_function(
+    function_id      const id,
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    // First check to see if we've cached the function pointer:
+    {
+        void* const cached_fp =
+            ReadPointerNoFence(function_pointers + id);
+
+        if (cached_fp == invalid_function_sentinel())
+        {
+            return nullptr;
+        }
+
+        if (cached_fp)
+        {
+            return cached_fp;
+        }
+    }
+
+    return try_get_function_slow(id, name, first_module_id, last_module_id);
+}
+
+// Generate accessors that wrap the general try_get_function for each function,
+// passing the correct set of candidate modules and returning a function pointer
+// of the correct type:
+#define _APPLY(_FUNCTION, _MODULES)                                                                   \
+    static _CRT_CONCATENATE(_FUNCTION, _pft) __cdecl _CRT_CONCATENATE(try_get_, _FUNCTION)() throw()  \
+    {                                                                                                 \
+        static module_id const candidate_modules[] = _CRT_UNPARENTHESIZE(_MODULES);                   \
+                                                                                                      \
+        return reinterpret_cast<_CRT_CONCATENATE(_FUNCTION, _pft)>(try_get_function(                  \
+            _CRT_CONCATENATE(_FUNCTION, _id),                                                         \
+            _CRT_STRINGIZE(_FUNCTION),                                                                \
+            candidate_modules,                                                                        \
+            candidate_modules + _countof(candidate_modules)));                                        \
+    }
+_ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+#undef _APPLY
+
+static __forceinline void* __cdecl get_function(
+    function_id      const id,
+    char      const* const name,
+    module_id const* const first_module_id,
+    module_id const* const last_module_id
+    ) throw()
+{
+    UNREFERENCED_PARAMETER(name);
+    UNREFERENCED_PARAMETER(first_module_id);
+    UNREFERENCED_PARAMETER(last_module_id);
+
+    // This function assumes the cached function pointer is always valid
+    void* const cached_fp =
+        ReadPointerNoFence(function_pointers + id);
+
+    return cached_fp;
+
+}
+
+#pragma warning(push)
+#pragma warning(disable: 4505) // unreferenced local function has been removed
+// Generate accessors that wrap the general try_get_function for each function,
+// passing the correct set of candidate modules and returning a function pointer
+// of the correct type:
+#define _APPLY(_FUNCTION, _MODULES)                                                                   \
+    static __forceinline _CRT_CONCATENATE(_FUNCTION, _pft) __cdecl _CRT_CONCATENATE(get_, _FUNCTION)() throw()  \
+    {                                                                                                 \
+        static module_id const candidate_modules[] = _CRT_UNPARENTHESIZE(_MODULES);                   \
+                                                                                                      \
+        return reinterpret_cast<_CRT_CONCATENATE(_FUNCTION, _pft)>(get_function(                      \
+            _CRT_CONCATENATE(_FUNCTION, _id),                                                         \
+            _CRT_STRINGIZE(_FUNCTION),                                                                \
+            candidate_modules,                                                                        \
+            candidate_modules + _countof(candidate_modules)));                                        \
+    }
+_ACRT_APPLY_TO_LATE_BOUND_FUNCTIONS
+#undef _APPLY
+#pragma warning(pop)
+
+extern "C" BOOL WINAPI __acrt_AreFileApisANSI()
+{
+    if (auto const are_file_apis_ansi = try_get_AreFileApisANSI())
+    {
+        return are_file_apis_ansi();
+    }
+
+    // If we were unable to get the AreFileApisANSI function, we can safely
+    // assume that the file APIs are, in fact, ANSI:
+    return TRUE;
+}
+
+extern "C" int WINAPI __acrt_CompareStringEx(
+    LPCWSTR          const locale_name,
+    DWORD            const flags,
+    LPCWCH           const string1,
+    int              const string1_count,
+    LPCWCH           const string2,
+    int              const string2_count,
+    LPNLSVERSIONINFO const version,
+    LPVOID           const reserved,
+    LPARAM           const param
+    )
+{
+    if (auto const compare_string_ex = try_get_CompareStringEx())
+    {
+        // On WCOS devices, CompareStringEx may calls into icu.dll which is an OS component using the UCRT.
+        // If icu.dll calls any UCRT export under OS mode (ex: malloc), then CompareStringEx will return under Prog Mode even if
+        // we started in OS mode. To prevent this, an OS mode guard is in place.
+        __crt_state_management::scoped_global_state_reset os_mode_guard;
+        return compare_string_ex(locale_name, flags, string1, string1_count, string2, string2_count, version, reserved, param);
+    }
+
+    return CompareStringW(__acrt_LocaleNameToLCID(locale_name, 0), flags, string1, string1_count, string2, string2_count);
+}
+
+// This has been split into its own function to work around a bug in the Dev12
+// C++ compiler where nested captureless lambdas are not convertible to the
+// required function pointer type.
+static BOOL enum_system_locales_ex_nolock(
+    LOCALE_ENUMPROCEX const enum_proc
+    ) throw()
+{
+    static LOCALE_ENUMPROCEX static_enum_proc;
+
+    static_enum_proc = enum_proc;
+    BOOL const result = EnumSystemLocalesW(
+        [](LPWSTR locale_string) { return (static_enum_proc)(locale_string, 0, 0); },
+        LCID_INSTALLED);
+    static_enum_proc = nullptr;
+
+    return result;
+}
+
+extern "C" BOOL WINAPI __acrt_EnumSystemLocalesEx(
+    LOCALE_ENUMPROCEX const enum_proc,
+    DWORD             const flags,
+    LPARAM            const param,
+    LPVOID            const reserved
+    )
+{
+    if (auto const enum_system_locales_ex = try_get_EnumSystemLocalesEx())
+    {
+        return enum_system_locales_ex(enum_proc, flags, param, reserved);
+    }
+
+    return __acrt_lock_and_call(__acrt_locale_lock, [&]() -> BOOL
+    {
+        return enum_system_locales_ex_nolock(enum_proc);
+    });
+}
+
+// Historically, we needed to conditionally call FLS functions for x86 since the UCRT needed to be consumable down to XP.
+// This is no longer the case as XP is no longer supported, however the enclave implementations of these functions
+// unconditionally call the TLS equivalent APIs (TlsAlloc, etc), hence why these are still kept around
+extern "C" DWORD WINAPI __acrt_FlsAlloc(PFLS_CALLBACK_FUNCTION const callback)
+{
+    return FlsAlloc(callback);
+}
+
+extern "C" BOOL WINAPI __acrt_FlsFree(DWORD const fls_index)
+{
+    return FlsFree(fls_index);
+}
+
+extern "C" PVOID WINAPI __acrt_FlsGetValue(DWORD const fls_index)
+{
+    return FlsGetValue(fls_index);
+}
+
+extern "C"
+DECLSPEC_GUARDNOCF
+PVOID WINAPI __acrt_FlsGetValue2(DWORD const fls_index)
+{
+#if (defined(_M_ARM64_) || defined(_M_ARM64EC)) && _UCRT_DLL
+    return FlsGetValue2(fls_index);
+#else
+    /*
+    * N.B.: This function must be called after checking __acrt_use_tls2_apis.
+    */
+    auto const flsgetvalue2 = get_FlsGetValue2();
+    return flsgetvalue2(fls_index);
+#endif
+}
+
+extern "C" BOOL WINAPI __acrt_FlsSetValue(DWORD const fls_index, PVOID const fls_data)
+{
+    return FlsSetValue(fls_index, fls_data);
+}
+
+extern "C" BOOL WINAPI __acrt_IsThreadAFiber()
+{
+    return IsThreadAFiber();
+}
+
+extern "C" int WINAPI __acrt_GetDateFormatEx(
+    LPCWSTR           const locale_name,
+    DWORD             const flags,
+    SYSTEMTIME CONST* const date,
+    LPCWSTR           const format,
+    LPWSTR            const buffer,
+    int               const buffer_count,
+    LPCWSTR           const calendar
+    )
+{
+    if (auto const get_date_format_ex = try_get_GetDateFormatEx())
+    {
+        return get_date_format_ex(locale_name, flags, date, format, buffer, buffer_count, calendar);
+    }
+
+    return GetDateFormatW(__acrt_LocaleNameToLCID(locale_name, 0), flags, date, format, buffer, buffer_count);
+}
+
+extern "C" int WINAPI __acrt_GetTempPath2W(
+    DWORD nBufferLength,
+    LPWSTR lpBuffer
+)
+{
+    if (auto const get_temp_path2w = try_get_GetTempPath2W())
+    {
+        return get_temp_path2w(nBufferLength, lpBuffer);
+    }
+    return GetTempPathW(nBufferLength, lpBuffer);
+}
+
+extern "C" BOOL WINAPI __acrt_GetFileInformationByName(
+    LPCWSTR FileName,
+    DWORD FileInformationClass,                // FILE_INFO_BY_NAME_CLASS
+    PVOID FileInfoBuffer,
+    ULONG FileInfoBufferSize
+)
+{
+    if (auto const get_file_info = try_get_GetFileInformationByName())
+    {
+        return get_file_info(FileName, FileInformationClass, FileInfoBuffer, FileInfoBufferSize);
+    }
+    return FALSE;
+}
+
+extern "C" DWORD64 WINAPI __acrt_GetEnabledXStateFeatures()
+{
+    if (auto const get_enabled_xstate_features = try_get_GetEnabledXStateFeatures())
+    {
+        return get_enabled_xstate_features();
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" int WINAPI __acrt_GetLocaleInfoEx(
+    LPCWSTR const locale_name,
+    LCTYPE  const lc_type,
+    LPWSTR  const data,
+    int     const data_count
+    )
+{
+    if (auto const get_locale_info_ex = try_get_GetLocaleInfoEx())
+    {
+        return get_locale_info_ex(locale_name, lc_type, data, data_count);
+    }
+
+    return GetLocaleInfoW(__acrt_LocaleNameToLCID(locale_name, 0), lc_type, data, data_count);
+}
+
+extern "C" VOID WINAPI __acrt_GetSystemTimePreciseAsFileTime(LPFILETIME const system_time)
+{
+    if (auto const get_system_time_precise_as_file_time = try_get_GetSystemTimePreciseAsFileTime())
+    {
+        return get_system_time_precise_as_file_time(system_time);
+    }
+
+    return GetSystemTimeAsFileTime(system_time);
+}
+
+extern "C" int WINAPI __acrt_GetTimeFormatEx(
+    LPCWSTR           const locale_name,
+    DWORD             const flags,
+    SYSTEMTIME CONST* const time,
+    LPCWSTR           const format,
+    LPWSTR            const buffer,
+    int               const buffer_count
+    )
+{
+    if (auto const get_time_format_ex = try_get_GetTimeFormatEx())
+    {
+        return get_time_format_ex(locale_name, flags, time, format, buffer, buffer_count);
+    }
+
+    return GetTimeFormatW(__acrt_LocaleNameToLCID(locale_name, 0), flags, time, format, buffer, buffer_count);
+}
+
+extern "C" int WINAPI __acrt_GetUserDefaultLocaleName(
+    LPWSTR const locale_name,
+    int    const locale_name_count
+    )
+{
+    if (auto const get_user_default_locale_name = try_get_GetUserDefaultLocaleName())
+    {
+        return get_user_default_locale_name(locale_name, locale_name_count);
+    }
+
+    return __acrt_LCIDToLocaleName(GetUserDefaultLCID(), locale_name, locale_name_count, 0);
+}
+
+extern "C" BOOL WINAPI __acrt_GetXStateFeaturesMask(
+    PCONTEXT const context,
+    PDWORD64 const feature_mask
+    )
+{
+    if (auto const get_xstate_features_mask = try_get_GetXStateFeaturesMask())
+    {
+        return get_xstate_features_mask(context, feature_mask);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" BOOL WINAPI __acrt_InitializeCriticalSectionEx(
+    LPCRITICAL_SECTION const critical_section,
+    DWORD              const spin_count,
+    DWORD              const flags
+    )
+{
+    return InitializeCriticalSectionEx(critical_section, spin_count, flags);
+}
+
+extern "C" BOOL WINAPI __acrt_IsValidLocaleName(LPCWSTR const locale_name)
+{
+    if (auto const is_valid_locale_name = try_get_IsValidLocaleName())
+    {
+        return is_valid_locale_name(locale_name);
+    }
+
+    return IsValidLocale(__acrt_LocaleNameToLCID(locale_name, 0), LCID_INSTALLED);
+}
+
+extern "C" int WINAPI __acrt_LCMapStringEx(
+    LPCWSTR          const locale_name,
+    DWORD            const flags,
+    LPCWSTR          const source,
+    int              const source_count,
+    LPWSTR           const destination,
+    int              const destination_count,
+    LPNLSVERSIONINFO const version,
+    LPVOID           const reserved,
+    LPARAM           const sort_handle
+    )
+{
+    if (auto const lc_map_string_ex = try_get_LCMapStringEx())
+    {
+        return lc_map_string_ex(locale_name, flags, source, source_count, destination, destination_count, version, reserved, sort_handle);
+    }
+#pragma warning(disable:__WARNING_PRECONDITION_NULLTERMINATION_VIOLATION) // 26035 LCMapStringW annotation is presently incorrect 11/26/2014 Jaykrell
+    return LCMapStringW(__acrt_LocaleNameToLCID(locale_name, 0), flags, source, source_count, destination, destination_count);
+}
+
+extern "C" int WINAPI __acrt_LCIDToLocaleName(
+    LCID   const locale,
+    LPWSTR const name,
+    int    const name_count,
+    DWORD  const flags
+    )
+{
+    if (auto const lcid_to_locale_name = try_get_LCIDToLocaleName())
+    {
+        return lcid_to_locale_name(locale, name, name_count, flags);
+    }
+
+    return __acrt_DownlevelLCIDToLocaleName(locale, name, name_count);
+}
+
+extern "C" LCID WINAPI __acrt_LocaleNameToLCID(
+    LPCWSTR const name,
+    DWORD   const flags
+    )
+{
+    if (auto const locale_name_to_lcid = try_get_LocaleNameToLCID())
+    {
+        return locale_name_to_lcid(name, flags);
+    }
+
+    return __acrt_DownlevelLocaleNameToLCID(name);
+}
+
+extern "C" PVOID WINAPI __acrt_LocateXStateFeature(
+    PCONTEXT const content,
+    DWORD    const feature_id,
+    PDWORD   const length
+    )
+{
+    if (auto const locate_xstate_feature = try_get_LocateXStateFeature())
+    {
+        return locate_xstate_feature(content, feature_id, length);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" int WINAPI __acrt_MessageBoxA(
+    HWND   const hwnd,
+    LPCSTR const text,
+    LPCSTR const caption,
+    UINT   const type
+    )
+{
+    if (auto const message_box_a = try_get_MessageBoxA())
+    {
+        return message_box_a(hwnd, text, caption, type);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" int WINAPI __acrt_MessageBoxW(
+    HWND    const hwnd,
+    LPCWSTR const text,
+    LPCWSTR const caption,
+    UINT    const type
+    )
+{
+    if (auto const message_box_w = try_get_MessageBoxW())
+    {
+        return message_box_w(hwnd, text, caption, type);
+    }
+
+    abort(); // No fallback; callers should check availablility before calling
+}
+
+extern "C" BOOLEAN WINAPI __acrt_RtlGenRandom(
+    PVOID const buffer,
+    ULONG const buffer_count
+    )
+{
+    if (auto const rtl_gen_random = try_get_SystemFunction036())
+    {
+        return rtl_gen_random(buffer, buffer_count);
+    }
+
+    abort(); // No fallback (this function should exist)
+}
+
+extern "C" HRESULT WINAPI __acrt_RoInitialize(RO_INIT_TYPE const init_type)
+{
+    if (auto const ro_initialize = try_get_RoInitialize())
+    {
+        return ro_initialize(init_type);
+    }
+
+    return S_OK; // No fallback (this is a best-effort wrapper)
+}
+
+extern "C" void WINAPI __acrt_RoUninitialize()
+{
+    if (auto const ro_uninitialize = try_get_RoUninitialize())
+    {
+        return ro_uninitialize();
+    }
+
+    // No fallback (this is a best-effort wrapper)
+}
+
+LONG WINAPI __acrt_AppPolicyGetProcessTerminationMethodInternal(_Out_ AppPolicyProcessTerminationMethod* policy)
+{
+    if (auto const app_policy_get_process_terminaton_method_claims = try_get_AppPolicyGetProcessTerminationMethod())
+    {
+        return app_policy_get_process_terminaton_method_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+LONG WINAPI __acrt_AppPolicyGetThreadInitializationTypeInternal(_Out_ AppPolicyThreadInitializationType* policy)
+{
+    if (auto const app_policy_get_thread_initialization_type_claims = try_get_AppPolicyGetThreadInitializationType())
+    {
+        return app_policy_get_thread_initialization_type_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+LONG WINAPI __acrt_AppPolicyGetShowDeveloperDiagnosticInternal(_Out_ AppPolicyShowDeveloperDiagnostic* policy)
+{
+    if (auto const app_policy_get_show_developer_diagnostic_claims = try_get_AppPolicyGetShowDeveloperDiagnostic())
+    {
+        return app_policy_get_show_developer_diagnostic_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+LONG WINAPI __acrt_AppPolicyGetWindowingModelInternal(_Out_ AppPolicyWindowingModel* policy)
+{
+    if (auto const app_policy_get_windowing_model_claims = try_get_AppPolicyGetWindowingModel())
+    {
+        return app_policy_get_windowing_model_claims(GetCurrentThreadEffectiveToken(), policy);
+    }
+
+    return STATUS_NOT_FOUND;
+}
+
+extern "C" BOOL WINAPI __acrt_SetThreadStackGuarantee(PULONG const stack_size_in_bytes)
+{
+    if (auto const set_thread_stack_guarantee = try_get_SetThreadStackGuarantee())
+    {
+        return set_thread_stack_guarantee(stack_size_in_bytes);
+    }
+
+    return FALSE;
+}
+
+extern "C" bool __cdecl __acrt_can_show_message_box()
+{
+    bool can_show_message_box = false;
+    if (__acrt_get_windowing_model_policy() == windowing_model_policy_hwnd
+        && try_get_MessageBoxA() != nullptr
+        && try_get_MessageBoxW() != nullptr)
+    {
+        can_show_message_box = true;
+    }
+    return can_show_message_box;
+}
+
+extern "C" bool __cdecl __acrt_can_use_vista_locale_apis()
+{
+    return try_get_CompareStringEx() != nullptr;
+}
+
+// This function simply attempts to get each of the locale-related APIs.  This
+// allows a caller to "pre-load" the modules in which these APIs are hosted.  We
+// use this in the _wsetlocale implementation to avoid calls to LoadLibrary while
+// the locale lock is held.
+extern "C" void __cdecl __acrt_eagerly_load_locale_apis()
+{
+    try_get_AreFileApisANSI();
+    try_get_CompareStringEx();
+    try_get_EnumSystemLocalesEx();
+    try_get_GetDateFormatEx();
+    try_get_GetLocaleInfoEx();
+    try_get_GetTimeFormatEx();
+    try_get_GetUserDefaultLocaleName();
+    try_get_IsValidLocaleName();
+    try_get_LCMapStringEx();
+    try_get_LCIDToLocaleName();
+    try_get_LocaleNameToLCID();
+}
+
+extern "C" bool __cdecl __acrt_tls2_supported()
+{
+    return (try_get_FlsGetValue2() != nullptr);
+}
+
+extern "C" bool __cdecl __acrt_can_use_xstate_apis()
+{
+    return try_get_LocateXStateFeature() != nullptr;
+}
+
+extern "C" HWND __cdecl __acrt_get_parent_window()
+{
+    auto const get_active_window = try_get_GetActiveWindow();
+    if (!get_active_window)
+    {
+        return nullptr;
+    }
+
+    HWND const active_window = get_active_window();
+    if (!active_window)
+    {
+        return nullptr;
+    }
+
+    auto const get_last_active_popup = try_get_GetLastActivePopup();
+    if (!get_last_active_popup)
+    {
+        return active_window;
+    }
+
+    return get_last_active_popup(active_window);
+}
+
+extern "C" bool __cdecl __acrt_is_interactive()
+{
+    auto const get_process_window_station = try_get_GetProcessWindowStation();
+    if (!get_process_window_station)
+    {
+        return true;
+    }
+
+    auto const get_user_object_information = try_get_GetUserObjectInformationW();
+    if (!get_user_object_information)
+    {
+        return true;
+    }
+
+    HWINSTA const hwinsta = get_process_window_station();
+    if (!hwinsta)
+    {
+        return false;
+    }
+
+    USEROBJECTFLAGS uof{};
+    if (!get_user_object_information(hwinsta, UOI_FLAGS, &uof, sizeof(uof), nullptr))
+    {
+        return false;
+    }
+
+    if ((uof.dwFlags & WSF_VISIBLE) == 0)
+    {
+        return false;
+    }
+
+    return true;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a2ef8a90f42daf5a62b1e006d5c336d9a95a910f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringA.cpp	
@@ -0,0 +1,232 @@
+/***
+*a_cmp.c - A version of CompareString.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Use either CompareStringA or CompareStringW depending on which is
+*       available
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+
+
+
+/***
+*int __cdecl __acrt_CompareStringA - Get type information about an ANSI string.
+*
+*Purpose:
+*       Internal support function. Assumes info in ANSI string format. Tries
+*       to use NLS API call CompareStringA if available and uses CompareStringW
+*       if it must. If neither are available it fails and returns 0.
+*
+*Entry:
+*       LPCWSTR LocaleName  - locale context for the comparison.
+*       DWORD   dwCmpFlags  - see NT\Chicago docs
+*       LPCSTR  lpStringn   - multibyte string to be compared
+*       int     cchCountn   - char (byte) count (NOT including nullptr)
+*                             (-1 if nullptr terminated)
+*       int     code_page   - for MB/WC conversion. If 0, use __lc_codepage
+*
+*Exit:
+*       Success: 1 - if lpString1 <  lpString2
+*                2 - if lpString1 == lpString2
+*                3 - if lpString1 >  lpString2
+*       Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static int __cdecl InternalCompareStringA(
+    _locale_t plocinfo,
+    LPCWSTR   LocaleName,
+    DWORD     dwCmpFlags,
+    PCCH      lpString1,
+    int       cchCount1,
+    PCCH      lpString2,
+    int       cchCount2,
+    int       code_page
+    ) throw()
+{
+    /*
+     * CompareString will compare past nullptr. Must find nullptr if in string
+     * before cchCountn chars.
+     */
+
+    if (cchCount1 > 0)
+        cchCount1 = static_cast<int>(__strncnt(lpString1, cchCount1));
+    else if (cchCount1 < -1)
+        return FALSE;
+
+    if (cchCount2 > 0)
+        cchCount2 = static_cast<int>(__strncnt(lpString2, cchCount2));
+    else if (cchCount2 < -1)
+        return FALSE;
+
+
+    int buff_size1;
+    int buff_size2;
+
+    /*
+     * Use __lc_codepage for conversion if code_page not specified
+     */
+
+    if (0 == code_page)
+        code_page = plocinfo->locinfo->_public._locale_lc_codepage;
+
+    /*
+     * Special case: at least one count is zero
+     */
+
+    if (!cchCount1 || !cchCount2)
+    {
+        unsigned char *cp;  // char pointer
+        CPINFO cpInfo;      // struct for use with GetCPInfo
+
+        /* both strings zero */
+        if (cchCount1 == cchCount2)
+            return 2;
+
+        /* string 1 greater */
+        if (cchCount2 > 1)
+            return 1;
+
+        /* string 2 greater */
+        if (cchCount1 > 1)
+            return 3;
+
+        /*
+         * one has zero count, the other has a count of one
+         * - if the one count is a naked lead byte, the strings are equal
+         * - otherwise it is a single character and they are unequal
+         */
+
+        if (GetCPInfo(code_page, &cpInfo) == FALSE)
+            return 0;
+
+        _ASSERTE(cchCount1==0 && cchCount2==1 || cchCount1==1 && cchCount2==0);
+
+        /* string 1 has count of 1 */
+        if (cchCount1 > 0)
+        {
+            if (cpInfo.MaxCharSize < 2)
+                return 3;
+
+            for ( cp = (unsigned char *)cpInfo.LeadByte ;
+                  cp[0] && cp[1] ;
+                  cp += 2 )
+                if ( (*(unsigned char *)lpString1 >= cp[0]) &&
+                     (*(unsigned char *)lpString1 <= cp[1]) )
+                    return 2;
+
+            return 3;
+        }
+
+        /* string 2 has count of 1 */
+        if (cchCount2 > 0)
+        {
+            if (cpInfo.MaxCharSize < 2)
+            return 1;
+
+            for ( cp = (unsigned char *)cpInfo.LeadByte ;
+                  cp[0] && cp[1] ;
+                  cp += 2 )
+                if ( (*(unsigned char *)lpString2 >= cp[0]) &&
+                     (*(unsigned char *)lpString2 <= cp[1]) )
+                    return 2;
+
+            return 1;
+        }
+    }
+
+    /*
+     * Convert strings and return the requested information.
+     */
+
+    /* find out how big a buffer we need (includes nullptr if any) */
+    if ( 0 == (buff_size1 = __acrt_MultiByteToWideChar( code_page,
+                                                 MB_PRECOMPOSED |
+                                                    MB_ERR_INVALID_CHARS,
+                                                 lpString1,
+                                                 cchCount1,
+                                                 nullptr,
+                                                 0 )) )
+        return 0;
+
+    /* allocate enough space for chars */
+    __crt_scoped_stack_ptr<wchar_t> wbuffer1(_malloca_crt_t(wchar_t, buff_size1));
+    if (wbuffer1.get() == nullptr)
+        return 0;
+
+    /* do the conversion */
+    if ( 0 == __acrt_MultiByteToWideChar( code_page,
+                                   MB_PRECOMPOSED,
+                                   lpString1,
+                                   cchCount1,
+                                   wbuffer1.get(),
+                                   buff_size1 ) )
+        return 0;
+
+    /* find out how big a buffer we need (includes nullptr if any) */
+    if ( 0 == (buff_size2 = __acrt_MultiByteToWideChar( code_page,
+                                                 MB_PRECOMPOSED |
+                                                    MB_ERR_INVALID_CHARS,
+                                                 lpString2,
+                                                 cchCount2,
+                                                 nullptr,
+                                                 0 )) )
+        return 0;
+
+    /* allocate enough space for chars */
+    __crt_scoped_stack_ptr<wchar_t> const wbuffer2(_malloca_crt_t(wchar_t, buff_size2));
+    if (wbuffer2.get() == nullptr)
+        return 0;
+
+    int const actual_size = __acrt_MultiByteToWideChar(
+        code_page,
+        MB_PRECOMPOSED,
+        lpString2,
+        cchCount2,
+        wbuffer2.get(),
+        buff_size2);
+
+    if (actual_size == 0)
+        return 0;
+
+    return __acrt_CompareStringEx(
+        LocaleName,
+        dwCmpFlags,
+        wbuffer1.get(),
+        buff_size1,
+        wbuffer2.get(),
+        buff_size2,
+        nullptr,
+        nullptr,
+        0);
+}
+
+extern "C" int __cdecl __acrt_CompareStringA(
+    _locale_t const locale,
+    LPCWSTR   const locale_name,
+    DWORD     const compare_flags,
+    PCCH      const string1,
+    int       const string1_count,
+    PCCH      const string2,
+    int       const string2_count,
+    int       const code_page
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    return InternalCompareStringA(
+        locale_update.GetLocaleT(),
+        locale_name,
+        compare_flags,
+        string1,
+        string1_count,
+        string2,
+        string2_count,
+        code_page
+        );
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringW.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringW.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..09b3c211021367d81995aa9517933b724c5ff248
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/CompareStringW.cpp	
@@ -0,0 +1,67 @@
+/***
+*w_cmp.c - W versions of CompareString.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Wrapper for CompareStringW.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+
+/***
+*int __cdecl __acrt_CompareStringW - Get type information about a wide string.
+*
+*Purpose:
+*  Internal support function. Assumes info in wide string format.
+*
+*Entry:
+*  LPCWSTR  LocaleName  - locale context for the comparison.
+*  DWORD    dwCmpFlags  - see NT\Chicago docs
+*  LPCWSTR  lpStringn   - wide string to be compared
+*  int      cchCountn   - wide char (word) count (NOT including nullptr)
+*                       (-1 if nullptr terminated)
+*
+*Exit:
+*  Success: 1 - if lpString1 <  lpString2
+*           2 - if lpString1 == lpString2
+*           3 - if lpString1 >  lpString2
+*  Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl __acrt_CompareStringW(
+        LPCWSTR  LocaleName,
+        DWORD    dwCmpFlags,
+        PCWCH    lpString1,
+        int      cchCount1,
+        PCWCH    lpString2,
+        int      cchCount2
+        )
+{
+    /*
+     * CompareString will compare past nullptr. Must find nullptr if in string
+     * before cchCountn wide characters.
+     */
+
+    if (cchCount1 > 0)
+        cchCount1= (int) wcsnlen(lpString1, cchCount1);
+    if (cchCount2 > 0)
+        cchCount2= (int) wcsnlen(lpString2, cchCount2);
+
+    if (!cchCount1 || !cchCount2)
+        return (cchCount1 - cchCount2 == 0) ? 2 :
+               (cchCount1 - cchCount2 < 0) ? 1 : 3;
+
+    return __acrt_CompareStringEx( LocaleName,
+                           dwCmpFlags,
+                           lpString1,
+                           cchCount1,
+                           lpString2,
+                           cchCount2,
+                           nullptr,
+                           nullptr,
+                           0);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetLocaleInfoA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetLocaleInfoA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa3cf6668736bc0e544fa069d44cae835f7dc4bb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetLocaleInfoA.cpp	
@@ -0,0 +1,165 @@
+//
+// GetLocaleInfoA.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the CRT-internal GetLocaleInfoA implementation.
+//
+#include <corecrt_internal.h>
+
+
+
+// Wraps a call to GetLocaleInfoEx and translates the result into a narrow string.
+_Success_(return > 0)
+static int __cdecl InternalGetLocaleInfoA(
+                                _locale_t   const   locale,
+                                PCWSTR      const   locale_name,
+                                LCTYPE      const   locale_type,
+    _Out_writes_z_(result_size) char*       const   result,
+                                int         const   result_size
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    int const code_page = locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
+
+    int const buffer_size = __acrt_GetLocaleInfoEx(locale_name, locale_type, nullptr, 0);
+    if (buffer_size == 0)
+        return 0;
+
+    __crt_scoped_stack_ptr<wchar_t> const buffer(_malloca_crt_t(wchar_t, buffer_size));
+    if (buffer.get() == nullptr)
+        return 0;
+
+    if (__acrt_GetLocaleInfoEx(locale_name, locale_type, buffer.get(), buffer_size) == 0)
+        return 0;
+
+    // Convert from wide to narrow strings:
+    return __acrt_WideCharToMultiByte(
+        code_page,
+        0,
+        buffer.get(),
+        -1,
+        result_size != 0 ? result : nullptr,
+        result_size,
+        nullptr,
+        nullptr);
+}
+
+
+
+// Gets locale information appropriate for use in the setlocale initialization
+// functions.  In particular, wide locale strings can be converted to narrow
+// strings or numeric values depending on the value of the lc_type parameter.
+//
+// The void_result must be reinterpretable as a pointer to one of the following
+// types, depending on the value of LC_TYPE:
+//
+//  * LC_STR_TYPE:   char*
+//  * LC_WSTR_TYPE:  wchar_t*
+//  * LC_INT_TYPE:   unsigned char
+//
+// For the first two cases, where a pointer to a pointer is passed, if the
+// function succeeds, the caller is responsible for freeing the pointed-to
+// buffer.
+//
+// Returns 0 on success; -1 on failure.
+//
+// Future optimization:  When converting a large number of wide strings to
+// multibyte, we do not need to query the size of the result.  We can convert
+// them one after another into a large character buffer.
+int __cdecl __acrt_GetLocaleInfoA(
+    _locale_t      const locale,
+    int            const lc_type,
+    wchar_t const* const locale_name,
+    LCTYPE         const locale_type,
+    void*          const void_result
+    )
+{
+    *static_cast<void**>(void_result) = nullptr;
+
+    if (lc_type == LC_STR_TYPE)
+    {
+        char** const char_result = static_cast<char**>(void_result);
+
+        int const local_buffer_size = 128;
+        char local_buffer[local_buffer_size];
+
+        int const local_length = InternalGetLocaleInfoA(
+            locale, locale_name, locale_type, local_buffer, local_buffer_size);
+
+        if (local_length != 0)
+        {
+            *char_result = _calloc_crt_t(char, local_length).detach();
+            if (*char_result == nullptr)
+                return -1;
+
+            _ERRCHECK(strncpy_s(*char_result, local_length, local_buffer, local_length - 1));
+            return 0;
+        }
+
+        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+            return -1;
+
+        // If the buffer size was too small, compute the required size and use a
+        // dynamically allocated buffer:
+        int const required_length = InternalGetLocaleInfoA(
+            locale, locale_name, locale_type, nullptr, 0);
+
+        if (required_length == 0)
+            return -1;
+
+        __crt_unique_heap_ptr<char> dynamic_buffer(_calloc_crt_t(char, required_length));
+        if (dynamic_buffer.get() == nullptr)
+            return -1;
+
+        int const actual_length = InternalGetLocaleInfoA(
+            locale, locale_name, locale_type, dynamic_buffer.get(), required_length);
+
+        if (actual_length == 0)
+            return -1;
+
+        *char_result = dynamic_buffer.detach();
+        return 0;
+    }
+    else if (lc_type == LC_WSTR_TYPE)
+    {
+        wchar_t** const wchar_result = static_cast<wchar_t**>(void_result);
+
+        int const required_length = __acrt_GetLocaleInfoEx(locale_name, locale_type, nullptr, 0);
+        if (required_length == 0)
+            return -1;
+
+        __crt_unique_heap_ptr<wchar_t> dynamic_buffer(_calloc_crt_t(wchar_t, required_length));
+        if (dynamic_buffer.get() == nullptr)
+            return -1;
+
+        int const actual_length = __acrt_GetLocaleInfoEx(
+            locale_name, locale_type, dynamic_buffer.get(), required_length);
+
+        if (actual_length == 0)
+            return -1;
+
+        *wchar_result = dynamic_buffer.detach();
+        return 0;
+    }
+    else if (lc_type == LC_INT_TYPE)
+    {
+        unsigned char* const uchar_result = static_cast<unsigned char*>(void_result);
+
+        DWORD value = 0;
+        int const actual_length = __acrt_GetLocaleInfoEx(
+            locale_name,
+            locale_type | LOCALE_RETURN_NUMBER,
+            reinterpret_cast<wchar_t*>(&value),
+            sizeof(value) / sizeof(wchar_t));
+
+        if (actual_length == 0)
+            return -1;
+
+        *uchar_result = static_cast<unsigned char>(value);
+        return 0;
+    }
+
+    return -1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetStringTypeA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetStringTypeA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9d3a06519d863cf8c8211dc546982bb65376812
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/GetStringTypeA.cpp	
@@ -0,0 +1,100 @@
+/***
+*a_str.c - A version of GetStringType.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Use either GetStringTypeA or GetStringTypeW depending on which is
+*       unstubbed.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+
+/***
+*int __cdecl __acrt_GetStringTypeA - Get type information about an ANSI string.
+*
+*Purpose:
+*       Internal support function. Assumes info in ANSI string format. Tries
+*       to use NLS API call GetStringTypeA if available and uses GetStringTypeW
+*       if it must. If neither are available it fails and returns FALSE.
+*
+*Entry:
+*       DWORD    dwInfoType  - see NT\Chicago docs
+*       PCCH     lpSrcStr    - char (byte) string for which character types
+*                              are requested
+*       int      cchSrc      - char (byte) count of lpSrcStr (including nullptr
+*                              if any)
+*       LPWORD   lpCharType  - word array to receive character type information
+*                              (must be twice the size of lpSrcStr)
+*       int      code_page   - for MB/WC conversion. If 0, use __lc_codepage
+*       BOOL     bError      - TRUE if MB_ERR_INVALID_CHARS set on call to
+*                              MultiByteToWideChar when GetStringTypeW used.
+*
+*Exit:
+*       Success: TRUE
+*       Failure: FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" BOOL __cdecl __acrt_GetStringTypeA(
+    _locale_t       const locale,
+    DWORD           const info_type,
+    LPCSTR          const string,
+    int             const string_size_in_bytes,
+    unsigned short* const char_type,
+    int             const code_page,
+    BOOL            const error
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    // Convert string and return the requested information. Note that
+    // we are converting to a wide character string so there is not a
+    // one-to-one correspondence between number of multibyte chars in the
+    // input string and the number of wide chars in the buffer. However,
+    // there had *better be* a one-to-one correspondence between the
+    // number of multibyte characters and the number of WORDs in the
+    // return buffer.
+
+    // Use __lc_codepage for conversion if code_page not specified:
+    int const actual_code_page = code_page != 0
+        ? code_page
+        : locale_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
+
+    // Find out how big a buffer we need:
+    int const required_extent = __acrt_MultiByteToWideChar(
+        actual_code_page,
+        error ? (MB_PRECOMPOSED | MB_ERR_INVALID_CHARS) : MB_PRECOMPOSED,
+        string,
+        string_size_in_bytes,
+        nullptr,
+        0);
+
+    if (required_extent == 0)
+        return FALSE;
+
+    // Allocate enough space for the wide character string:
+    __crt_scoped_stack_ptr<wchar_t> buffer(_malloca_crt_t(wchar_t, required_extent));
+    if (buffer.get() == nullptr)
+        return FALSE;
+
+    memset(buffer.get(), 0, sizeof(wchar_t) * required_extent);
+
+    // Do the conversion:
+    int const actual_extent = __acrt_MultiByteToWideChar(
+        actual_code_page,
+        MB_PRECOMPOSED,
+        string,
+        string_size_in_bytes,
+        buffer.get(),
+        required_extent);
+
+    if (actual_extent == 0)
+        return FALSE;
+
+    return GetStringTypeW(info_type, buffer.get(), actual_extent, char_type);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringA.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringA.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bde4a05fcb8d18b624d771420b9f6a7fb432e3f7
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringA.cpp	
@@ -0,0 +1,235 @@
+/***
+*a_map.c - A version of LCMapString.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Use either LCMapStringA or LCMapStringW depending on which is available
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+
+/***
+*int __cdecl __acrt_LCMapStringA - Get type information about an ANSI string.
+*
+*Purpose:
+*       Internal support function. Assumes info in ANSI string format. Tries
+*       to use NLS API call LCMapStringA if available and uses LCMapStringW
+*       if it must. If neither are available it fails and returns 0.
+*
+*Entry:
+*       LPCWSTR  LocaleName  - locale context for the comparison.
+*       DWORD    dwMapFlags  - see NT\Chicago docs
+*       PCCH     cchSrc      - wide char (word) count of input string
+*                              (including nullptr if any)
+*                              (-1 if nullptr terminated)
+*       PCH    lpDestStr     - pointer to memory to store mapping
+*       int      cchDest     - char (byte) count of buffer (including nullptr)
+*       int      code_page   - for MB/WC conversion. If 0, use __lc_codepage
+*       BOOL     bError      - TRUE if MB_ERR_INVALID_CHARS set on call to
+*                              MultiByteToWideChar when GetStringTypeW used.
+*
+*Exit:
+*       Success: number of chars written to lpDestStr (including nullptr)
+*       Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static _Success_(return != 0) int __cdecl __acrt_LCMapStringA_stat(
+        _In_opt_                    _locale_t plocinfo,
+        _In_                        LPCWSTR   LocaleName,
+        _In_                        DWORD     dwMapFlags,
+        _In_CRT_NLS_string_(cchSrc) PCCH      lpSrcStr,
+        _In_                        int       cchSrc,
+        _Out_writes_opt_(cchDest)   PCH       lpDestStr,
+        _In_                        int       cchDest,
+        _In_                        int       code_page,
+        _In_                        BOOL      bError
+        )
+{
+    // LCMapString will map past the null terminator.  We must find the null
+    // terminator if it occurs in the string before cchSrc characters
+    // and cap the number of characters to be considered.
+    if (cchSrc > 0)
+    {
+        int cchSrcCnt = static_cast<int>(__strncnt(lpSrcStr, cchSrc));
+
+        // Include the null terminator if the source string is terminated within
+        // the buffer.
+        if (cchSrcCnt < cchSrc)
+        {
+            cchSrc = cchSrcCnt + 1;
+        }
+        else
+        {
+            cchSrc = cchSrcCnt;
+        }
+    }
+
+    int retval = 0;
+    int inbuff_size;
+    int outbuff_size;
+
+    /*
+     * Convert string and return the requested information. Note that
+     * we are converting to a wide string so there is not a
+     * one-to-one correspondence between number of wide chars in the
+     * input string and the number of *bytes* in the buffer. However,
+     * there had *better be* a one-to-one correspondence between the
+     * number of wide characters and the number of multibyte characters
+     * or the resulting mapped string will be worthless to the user.
+     */
+
+    /*
+     * Use __lc_codepage for conversion if code_page not specified
+     */
+
+    if (0 == code_page)
+        code_page = plocinfo->locinfo->_public._locale_lc_codepage;
+
+    /* find out how big a buffer we need (includes nullptr if any) */
+    if ( 0 == (inbuff_size =
+               __acrt_MultiByteToWideChar( code_page,
+                                           bError ? MB_PRECOMPOSED |
+                                               MB_ERR_INVALID_CHARS :
+                                               MB_PRECOMPOSED,
+                                           lpSrcStr,
+                                           cchSrc,
+                                           nullptr,
+                                           0 )) )
+        return 0;
+
+    /* allocate enough space for wide chars */
+    __crt_scoped_stack_ptr<wchar_t> const inwbuffer(_malloca_crt_t(wchar_t, inbuff_size));
+    if (!inwbuffer)
+        return 0;
+
+    /* do the conversion */
+    if ( 0 == __acrt_MultiByteToWideChar( code_page,
+                                          MB_PRECOMPOSED,
+                                          lpSrcStr,
+                                          cchSrc,
+                                          inwbuffer.get(),
+                                          inbuff_size) )
+        return retval;
+
+    /* get size required for string mapping */
+    if ( 0 == (retval = __acrt_LCMapStringEx( LocaleName,
+                                              dwMapFlags,
+                                              inwbuffer.get(),
+                                              inbuff_size,
+                                              nullptr,
+                                              0,
+                                              nullptr,
+                                              nullptr,
+                                              0)) )
+        return retval;
+
+    if (dwMapFlags & LCMAP_SORTKEY) {
+        /* retval is size in BYTES */
+
+        if (0 != cchDest) {
+
+            if (retval > cchDest)
+                return 0;
+
+            /* do string mapping */
+            // The buffer overflow warning here is due to an inadequate annotation
+            // on __acrt_LCMapStringEx.  When the map flags include LCMAP_SORTKEY,
+            // the destination buffer is actually required to be an array of bytes,
+            // despite the type of the buffer being a wchar_t*.
+            __pragma(warning(suppress: __WARNING_BUFFER_OVERFLOW))
+            if ( 0 == (retval = __acrt_LCMapStringEx( LocaleName,
+                                    dwMapFlags,
+                                    inwbuffer.get(),
+                                    inbuff_size,
+                                    reinterpret_cast<PWCH>(lpDestStr),
+                                    cchDest,
+                                    nullptr,
+                                    nullptr,
+                                    0)) )
+                return retval;
+        }
+    }
+    else {
+        /* retval is size in wide chars */
+
+        outbuff_size = retval;
+
+        /* allocate enough space for wide chars (includes nullptr if any) */
+        __crt_scoped_stack_ptr<wchar_t> const outwbuffer(_malloca_crt_t(wchar_t, outbuff_size));
+        if (!outwbuffer)
+            return 0;
+
+        /* do string mapping */
+        if ( 0 == (retval = __acrt_LCMapStringEx( LocaleName,
+                                dwMapFlags,
+                                inwbuffer.get(),
+                                inbuff_size,
+                                outwbuffer.get(),
+                                outbuff_size,
+                                nullptr,
+                                nullptr,
+                                0)) )
+            return retval;
+
+        if (0 == cchDest) {
+            /* get size required */
+            if ( 0 == (retval =
+                       __acrt_WideCharToMultiByte( code_page,
+                                                   0,
+                                                   outwbuffer.get(),
+                                                   outbuff_size,
+                                                   nullptr,
+                                                   0,
+                                                   nullptr,
+                                                   nullptr )) )
+                return retval;
+        }
+        else {
+            /* convert mapping */
+            if ( 0 == (retval =
+                       __acrt_WideCharToMultiByte( code_page,
+                                                   0,
+                                                   outwbuffer.get(),
+                                                   outbuff_size,
+                                                   lpDestStr,
+                                                   cchDest,
+                                                   nullptr,
+                                                   nullptr )) )
+                return retval;
+        }
+    }
+
+    return retval;
+}
+
+extern "C" int __cdecl __acrt_LCMapStringA(
+        _locale_t const plocinfo,
+        PCWSTR    const LocaleName,
+        DWORD     const dwMapFlags,
+        PCCH      const lpSrcStr,
+        int       const cchSrc,
+        PCH       const lpDestStr,
+        int       const cchDest,
+        int       const code_page,
+        BOOL      const bError
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return __acrt_LCMapStringA_stat(
+            _loc_update.GetLocaleT(),
+            LocaleName,
+            dwMapFlags,
+            lpSrcStr,
+            cchSrc,
+            lpDestStr,
+            cchDest,
+            code_page,
+            bError
+            );
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringW.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringW.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93c6ad382ceeaaec3ce65c6e8f0cf97965887c41
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/LCMapStringW.cpp	
@@ -0,0 +1,74 @@
+/***
+*w_map.c - W version of LCMapString.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Wrapper for LCMapStringW.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+
+/***
+*int __cdecl __acrt_LCMapStringW - Get type information about a wide string.
+*
+*Purpose:
+*       Internal support function. Assumes info in wide string format.
+*
+*Entry:
+*       LPCWSTR  LocaleName  - locale context for the comparison.
+*       DWORD    dwMapFlags  - see NT\Chicago docs
+*       LPCWSTR  lpSrcStr    - pointer to string to be mapped
+*       int      cchSrc      - wide char (word) count of input string
+*                              (including nullptr if any)
+*                              (-1 if nullptr terminated)
+*       LPWSTR   lpDestStr   - pointer to memory to store mapping
+*       int      cchDest     - wide char (word) count of buffer (including nullptr)
+*
+*       NOTE:    if LCMAP_SORTKEY is specified, then cchDest refers to number
+*                of BYTES, not number of wide chars. The return string will be
+*                a series of bytes with a nullptr byte terminator.
+*
+*Exit:
+*       Success: if LCMAP_SORKEY:
+*                   number of bytes written to lpDestStr (including nullptr byte
+*                   terminator)
+*               else
+*                   number of wide characters written to lpDestStr (including
+*                   nullptr)
+*       Failure: 0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl __acrt_LCMapStringW(
+    LPCWSTR const locale_name,
+    DWORD   const map_flags,
+    LPCWSTR const source,
+    int           source_count,
+    LPWSTR  const destination,
+    int     const destination_count
+    )
+{
+    // LCMapString will map past the null terminator.  We must find the null
+    // terminator if it occurs in the string before source_count characters
+    // and cap the number of characters to be considered.
+    if (source_count > 0)
+    {
+        int const source_length = static_cast<int>(wcsnlen(source, source_count));
+
+        // Include the null terminator if the source string is terminated within
+        // the buffer.
+        if (source_length < source_count)
+        {
+            source_count = source_length + 1;
+        }
+        else
+        {
+            source_count = source_length;
+        }
+    }
+
+    return __acrt_LCMapStringEx(locale_name, map_flags, source, source_count, destination, destination_count, nullptr, nullptr, 0);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/ctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/ctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a64be939e703fbeb19fbd34d4f6f4a9cff4052d5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/ctype.cpp	
@@ -0,0 +1,745 @@
+//
+// ctype.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definition of the character classification data used by the character
+// classification macros in <ctype.h>.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+
+
+
+extern "C" unsigned short const* __cdecl __pwctype_func()
+{
+    return _pwctype;
+}
+
+extern "C" unsigned short const* __cdecl __pctype_func()
+{
+    // This is a leaf function and thus use of _LocaleUpdate is not required.
+    __acrt_ptd* const ptd{__acrt_getptd()};
+    __crt_locale_data* locale_info{ptd->_locale_info};
+
+    __acrt_update_locale_info(ptd, &locale_info);
+    return locale_info->_public._locale_pctype;
+}
+
+
+
+// NOTE:  The characteristics stored in this lookup table are not always
+// consistent with what is required by C.  For example, GetStringTypeW returns
+// _DIGIT and _PUNCT for U+00B2 and U+00B3 (SUBSCRIPT TWO and SUBSCRIPT THREE),
+// but these categories are mutually exclusive in C.  We have chosen to
+// implement this lookup table for consistency with GetStringTypeW, rather than
+// try to implement something completely different.  We expect this is sufficient,
+// as C character classification does not map well to Unicode.
+extern "C" extern unsigned short const _wctype[]
+{
+    0,                              // -1 EOF
+    _CONTROL ,                      // 00 (NUL)
+    _CONTROL ,                      // 01 (SOH)
+    _CONTROL ,                      // 02 (STX)
+    _CONTROL ,                      // 03 (ETX)
+    _CONTROL ,                      // 04 (EOT)
+    _CONTROL ,                      // 05 (ENQ)
+    _CONTROL ,                      // 06 (ACK)
+    _CONTROL ,                      // 07 (BEL)
+    _CONTROL ,                      // 08 (BS)
+    // \t is a blank character, but is not registered as _Blank on the table, because that will make it
+    //printable. Also Windows (via GetStringType()) considered all _BLANK characters to also be _PRINT characters,
+    //so does not have a way to specify blank, non-printable.
+    _SPACE | _CONTROL ,             // 09 (HT)
+    _SPACE | _CONTROL ,             // 0A (LF)
+    _SPACE | _CONTROL ,             // 0B (VT)
+    _SPACE | _CONTROL ,             // 0C (FF)
+    _SPACE | _CONTROL ,             // 0D (CR)
+    _CONTROL ,                      // 0E (SI)
+    _CONTROL ,                      // 0F (SO)
+    _CONTROL ,                      // 10 (DLE)
+    _CONTROL ,                      // 11 (DC1)
+    _CONTROL ,                      // 12 (DC2)
+    _CONTROL ,                      // 13 (DC3)
+    _CONTROL ,                      // 14 (DC4)
+    _CONTROL ,                      // 15 (NAK)
+    _CONTROL ,                      // 16 (SYN)
+    _CONTROL ,                      // 17 (ETB)
+    _CONTROL ,                      // 18 (CAN)
+    _CONTROL ,                      // 19 (EM)
+    _CONTROL ,                      // 1A (SUB)
+    _CONTROL ,                      // 1B (ESC)
+    _CONTROL ,                      // 1C (FS)
+    _CONTROL ,                      // 1D (GS)
+    _CONTROL ,                      // 1E (RS)
+    _CONTROL ,                      // 1F (US)
+    _SPACE | _BLANK ,               // 20 SPACE
+    _PUNCT ,                        // 21 !
+    _PUNCT ,                        // 22 "
+    _PUNCT ,                        // 23 #
+    _PUNCT ,                        // 24 $
+    _PUNCT ,                        // 25 %
+    _PUNCT ,                        // 26 &
+    _PUNCT ,                        // 27 '
+    _PUNCT ,                        // 28 (
+    _PUNCT ,                        // 29 )
+    _PUNCT ,                        // 2A *
+    _PUNCT ,                        // 2B +
+    _PUNCT ,                        // 2C ,
+    _PUNCT ,                        // 2D -
+    _PUNCT ,                        // 2E .
+    _PUNCT ,                        // 2F /
+    _DIGIT | _HEX ,                 // 30 0
+    _DIGIT | _HEX ,                 // 31 1
+    _DIGIT | _HEX ,                 // 32 2
+    _DIGIT | _HEX ,                 // 33 3
+    _DIGIT | _HEX ,                 // 34 4
+    _DIGIT | _HEX ,                 // 35 5
+    _DIGIT | _HEX ,                 // 36 6
+    _DIGIT | _HEX ,                 // 37 7
+    _DIGIT | _HEX ,                 // 38 8
+    _DIGIT | _HEX ,                 // 39 9
+    _PUNCT ,                        // 3A :
+    _PUNCT ,                        // 3B ;
+    _PUNCT ,                        // 3C <
+    _PUNCT ,                        // 3D =
+    _PUNCT ,                        // 3E >
+    _PUNCT ,                        // 3F ?
+    _PUNCT ,                        // 40 @
+    _UPPER | _HEX | C1_ALPHA ,      // 41 A
+    _UPPER | _HEX | C1_ALPHA ,      // 42 B
+    _UPPER | _HEX | C1_ALPHA ,      // 43 C
+    _UPPER | _HEX | C1_ALPHA ,      // 44 D
+    _UPPER | _HEX | C1_ALPHA ,      // 45 E
+    _UPPER | _HEX | C1_ALPHA ,      // 46 F
+    _UPPER | C1_ALPHA ,             // 47 G
+    _UPPER | C1_ALPHA ,             // 48 H
+    _UPPER | C1_ALPHA ,             // 49 I
+    _UPPER | C1_ALPHA ,             // 4A J
+    _UPPER | C1_ALPHA ,             // 4B K
+    _UPPER | C1_ALPHA ,             // 4C L
+    _UPPER | C1_ALPHA ,             // 4D M
+    _UPPER | C1_ALPHA ,             // 4E N
+    _UPPER | C1_ALPHA ,             // 4F O
+    _UPPER | C1_ALPHA ,             // 50 P
+    _UPPER | C1_ALPHA ,             // 51 Q
+    _UPPER | C1_ALPHA ,             // 52 R
+    _UPPER | C1_ALPHA ,             // 53 S
+    _UPPER | C1_ALPHA ,             // 54 T
+    _UPPER | C1_ALPHA ,             // 55 U
+    _UPPER | C1_ALPHA ,             // 56 V
+    _UPPER | C1_ALPHA ,             // 57 W
+    _UPPER | C1_ALPHA ,             // 58 X
+    _UPPER | C1_ALPHA ,             // 59 Y
+    _UPPER | C1_ALPHA ,             // 5A Z
+    _PUNCT ,                        // 5B [
+    _PUNCT ,                        // 5C \ 
+    _PUNCT ,                        // 5D ]
+    _PUNCT ,                        // 5E ^
+    _PUNCT ,                        // 5F _
+    _PUNCT ,                        // 60 `
+    _LOWER | _HEX | C1_ALPHA ,      // 61 a
+    _LOWER | _HEX | C1_ALPHA ,      // 62 b
+    _LOWER | _HEX | C1_ALPHA ,      // 63 c
+    _LOWER | _HEX | C1_ALPHA ,      // 64 d
+    _LOWER | _HEX | C1_ALPHA ,      // 65 e
+    _LOWER | _HEX | C1_ALPHA ,      // 66 f
+    _LOWER | C1_ALPHA ,             // 67 g
+    _LOWER | C1_ALPHA ,             // 68 h
+    _LOWER | C1_ALPHA ,             // 69 i
+    _LOWER | C1_ALPHA ,             // 6A j
+    _LOWER | C1_ALPHA ,             // 6B k
+    _LOWER | C1_ALPHA ,             // 6C l
+    _LOWER | C1_ALPHA ,             // 6D m
+    _LOWER | C1_ALPHA ,             // 6E n
+    _LOWER | C1_ALPHA ,             // 6F o
+    _LOWER | C1_ALPHA ,             // 70 p
+    _LOWER | C1_ALPHA ,             // 71 q
+    _LOWER | C1_ALPHA ,             // 72 r
+    _LOWER | C1_ALPHA ,             // 73 s
+    _LOWER | C1_ALPHA ,             // 74 t
+    _LOWER | C1_ALPHA ,             // 75 u
+    _LOWER | C1_ALPHA ,             // 76 v
+    _LOWER | C1_ALPHA ,             // 77 w
+    _LOWER | C1_ALPHA ,             // 78 x
+    _LOWER | C1_ALPHA ,             // 79 y
+    _LOWER | C1_ALPHA ,             // 7A z
+    _PUNCT ,                        // 7B {
+    _PUNCT ,                        // 7C |
+    _PUNCT ,                        // 7D }
+    _PUNCT ,                        // 7E ~
+    _CONTROL ,                      // 7F (DEL)
+    _CONTROL ,                      // 80 (XXX)
+    _CONTROL ,                      // 81 (XXX)
+    _CONTROL ,                      // 82 (BPH / BREAK PERMITTED HERE)
+    _CONTROL ,                      // 83 (NBH / NO BREAK HERE)
+    _CONTROL ,                      // 84 (IND / formerly known as INDEX)
+    _SPACE | _CONTROL ,             // 85 (NEL / NEXT LINE)
+    _CONTROL ,                      // 86 (SSA / START OF SELCETED AREA)
+    _CONTROL ,                      // 87 (ESA / END OF SELECTED AREA)
+    _CONTROL ,                      // 88 (HTS / CHARACTER TABULATION SET)
+    _CONTROL ,                      // 89 (HTJ / CHARACTER TABULATION WITH JUSTIFICATION)
+    _CONTROL ,                      // 8A (VTS / LINE TABULATION SET)
+    _CONTROL ,                      // 8B (PLD / PARTIAL LINE FORWARD)
+    _CONTROL ,                      // 8C (PLU / PARTIAL LINE BACKWARD)
+    _CONTROL ,                      // 8D (RI  / REVERSE LINE FEED)
+    _CONTROL ,                      // 8E (SS2 / SINGLE SHIFT TWO)
+    _CONTROL ,                      // 8F (SS3 / SINGLE SHIFT THREE)
+    _CONTROL ,                      // 90 (DCS / DEVICE CONTROL STRING)
+    _CONTROL ,                      // 91 (PU1 / PRIVATE USE ONE)
+    _CONTROL ,                      // 92 (PU2 / PRIVATE USE TWO)
+    _CONTROL ,                      // 93 (STS / SET TRANSMIT STATE)
+    _CONTROL ,                      // 94 (CCH / CANCEL CHARACTER)
+    _CONTROL ,                      // 95 (MW  / MESSAGE WAITING)
+    _CONTROL ,                      // 96 (SPA / START OF GUARDED AREA)
+    _CONTROL ,                      // 97 (EPA / END OF GUARDED AREA)
+    _CONTROL ,                      // 98 (SOS / START OF STRING)
+    _CONTROL ,                      // 99 (XXX)
+    _CONTROL ,                      // 9A (SCI / SINGLE CHARACTER INTRODUCER)
+    _CONTROL ,                      // 9B (CSI / CONTROL SEQUENCE INTRODUCER)
+    _CONTROL ,                      // 9C (ST  / STRING TERMINATOR)
+    _CONTROL ,                      // 9D (OSC / OPERATING SYSTEM COMMAND)
+    _CONTROL ,                      // 9E (PM  / PRIVACY MESSAGE)
+    _CONTROL ,                      // 9F (APC / APPLICATION PROGRAM COMMAND)
+    _SPACE ,                        // A0 (NBSP / NO-BREAK SPACE)
+    _PUNCT ,                        // A1 (INVERTED EXCLAMATION MARK)
+    _PUNCT ,                        // A2 (CENT SIGN)
+    _PUNCT ,                        // A3 (POUND SIGN)
+    _PUNCT ,                        // A4 (CURRENCY SIGN)
+    _PUNCT ,                        // A5 (YEN SIGN)
+    _PUNCT ,                        // A6 (BROKEN BAR)
+    _PUNCT ,                        // A7 (SECTION SIGN)
+    _PUNCT ,                        // A8 (DIAERESIS)
+    _PUNCT ,                        // A9 (COPYRIGHT SIGN)
+    _LOWER | _PUNCT | C1_ALPHA,     // AA (FEMININE ORDINAL INDICATOR)
+    _PUNCT ,                        // AB (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+    _PUNCT ,                        // AC (NOT SIGN)
+    _PUNCT | _CONTROL ,             // AD (SOFT HYPHEN)
+    _PUNCT ,                        // AE (REGISTERED SIGN)
+    _PUNCT ,                        // AF (MACRON)
+    _PUNCT ,                        // B0 (DEGREE SIGN)
+    _PUNCT ,                        // B1 (PLUS-MINUS SIGN)
+    _DIGIT | _PUNCT ,               // B2 (SUPERSCRIPT TWO)
+    _DIGIT | _PUNCT ,               // B3 (SUPERSCRIPT THREE)
+    _PUNCT ,                        // B4 (ACUTE ACCENT)
+    _LOWER | _PUNCT | C1_ALPHA,     // B5 (MICRO SIGN)
+    _PUNCT ,                        // B6 (PILCROW SIGN)
+    _PUNCT ,                        // B7 (MIDDLE DOT)
+    _PUNCT ,                        // B8 (CEDILLA)
+    _DIGIT | _PUNCT ,               // B9 (SUPERSCRIPT ONE)
+    _LOWER | _PUNCT | C1_ALPHA,     // BA (MASCULINE ORDINAL INDICATOR)
+    _PUNCT ,                        // BB (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+    _PUNCT ,                        // BC (VULGAR FRACTION ONE QUARTER)
+    _PUNCT ,                        // BD (VULGAR FRACTION ONE HALF)
+    _PUNCT ,                        // BE (VULGAR FRACTION THREE QUARTERS)
+    _PUNCT ,                        // BF (INVERTED QUESTION MARK)
+    _UPPER | C1_ALPHA ,             // C0 (LATIN CAPTIAL LETTER A WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // C1 (LATIN CAPITAL LETTER A WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // C2 (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // C3 (LATIN CAPITAL LETTER A WITH TILDE)
+    _UPPER | C1_ALPHA ,             // C4 (LATIN CAPITAL LETTER A WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             // C5 (LATIN CAPITAL LETTER A WITH RING ABOVE)
+    _UPPER | C1_ALPHA ,             // C6 (LATIN CAPITAL LETTER AE)
+    _UPPER | C1_ALPHA ,             // C7 (LATIN CAPITAL LETTER C WITH CEDILLA)
+    _UPPER | C1_ALPHA ,             // C8 (LATIN CAPITAL LETTER E WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // C9 (LATIN CAPITAL LETTER E WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // CA (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // CB (LATIN CAPITAL LETTER E WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             // CC (LATIN CAPITAL LETTER I WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // CD (LATIN CAPITAL LETTER I WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // CE (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // CF (LATIN CAPITAL LETTER I WITH DIAERESIS
+    _UPPER | C1_ALPHA ,             // D0 (LATIN CAPITAL LETTER ETH)
+    _UPPER | C1_ALPHA ,             // D1 (LATIN CAPITAL LETTER N WITH TILDE)
+    _UPPER | C1_ALPHA ,             // D2 (LATIN CAPITAL LETTER O WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // D3 (LATIN CAPITAL LETTER O WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // D4 (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // D5 (LATIN CAPITAL LETTER O WITH TILDE)
+    _UPPER | C1_ALPHA ,             // D6 (LATIN CAPITAL LETTER O WITH DIAERESIS)
+    _PUNCT ,                        // D7 (MULTIPLICATION SIGN)
+    _UPPER | C1_ALPHA ,             // D8 (LATIN CAPITAL LETTER O WITH STROKE)
+    _UPPER | C1_ALPHA ,             // D9 (LATIN CAPITAL LETTER U WITH GRAVE)
+    _UPPER | C1_ALPHA ,             // DA (LATIN CAPITAL LETTER U WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // DB (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+    _UPPER | C1_ALPHA ,             // DC (LATIN CAPITAL LETTER U WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             // DD (LATIN CAPITAL LETTER Y WITH ACUTE)
+    _UPPER | C1_ALPHA ,             // DE (LATIN CAPITAL LETTER THORN)
+    _LOWER | C1_ALPHA ,             // DF (LATIN SMALL LETTER SHARP S)
+    _LOWER | C1_ALPHA ,             // E0 (LATIN SMALL LETTER A WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // E1 (LATIN SMALL LETTER A WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // E2 (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // E3 (LATIN SMALL LETTER A WITH TILDE)
+    _LOWER | C1_ALPHA ,             // E4 (LATIN SMALL LETTER A WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // E5 (LATIN SMALL LETTER A WITH RING ABOVE)
+    _LOWER | C1_ALPHA ,             // E6 (LATIN SMALL LETTER AE)
+    _LOWER | C1_ALPHA ,             // E7 (LATIN SMALL LETTER C WITH CEDILLA)
+    _LOWER | C1_ALPHA ,             // E8 (LATIN SMALL LETTER E WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // E9 (LATIN SMALL LETTER E WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // EA (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // EB (LATIN SMALL LETTER E WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // EC (LATIN SMALL LETTER I WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // ED (LATIN SMALL LETTER I WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // EE (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // EF (LATIN SMALL LETTER I WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // F0 (LATIN SMALL LETTER ETH)
+    _LOWER | C1_ALPHA ,             // F1 (LATIN SMALL LETTER N WITH TILDE)
+    _LOWER | C1_ALPHA ,             // F2 (LATIN SMALL LETTER O WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // F3 (LATIN SMALL LETTER O WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // F4 (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // F5 (LATIN SMALL LETTER O WITH TILDE)
+    _LOWER | C1_ALPHA ,             // F6 (LATIN SMALL LETTER O WITH DIAERESIS)
+    _PUNCT ,                        // F7 (DIVISION SIGN)
+    _LOWER | C1_ALPHA ,             // F8 (LATIN SMALL LETTER O WITH STROKE)
+    _LOWER | C1_ALPHA ,             // F9 (LATIN SMALL LETTER U WITH GRAVE)
+    _LOWER | C1_ALPHA ,             // FA (LATIN SMALL LETTER U WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // FB (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+    _LOWER | C1_ALPHA ,             // FC (LATIN SMALL LETTER U WITH DIAERESIS)
+    _LOWER | C1_ALPHA ,             // FD (LATIN SMALL LETTER Y WITH ACUTE)
+    _LOWER | C1_ALPHA ,             // FE (LATIN SMALL LETTER THORN)
+    _LOWER | C1_ALPHA ,             // FF (LATIN SMALL LETTER Y WITH DIAERESIS)
+    _UPPER | C1_ALPHA ,             //100 (LATIN CAPITAL LETTER A WITH MACRON)
+};
+
+extern "C" extern unsigned short const __newctype[384]
+{
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0,
+    0,                         // -1 EOF
+    _CONTROL,                  // 00 (NUL)
+    _CONTROL,                  // 01 (SOH)
+    _CONTROL,                  // 02 (STX)
+    _CONTROL,                  // 03 (ETX)
+    _CONTROL,                  // 04 (EOT)
+    _CONTROL,                  // 05 (ENQ)
+    _CONTROL,                  // 06 (ACK)
+    _CONTROL,                  // 07 (BEL)
+    _CONTROL,                  // 08 (BS)
+    // \t is a blank character, but is not registered as _Blank on the table, because that will make it
+    //printable. Also Windows (via GetStringType()) considered all _BLANK characters to also be _PRINT characters,
+    //so does not have a way to specify blank, non-printable.
+    _SPACE+_CONTROL,           // 09 (HT)
+    _SPACE+_CONTROL,           // 0A (LF)
+    _SPACE+_CONTROL,           // 0B (VT)
+    _SPACE+_CONTROL,           // 0C (FF)
+    _SPACE+_CONTROL,           // 0D (CR)
+    _CONTROL,                  // 0E (SI)
+    _CONTROL,                  // 0F (SO)
+    _CONTROL,                  // 10 (DLE)
+    _CONTROL,                  // 11 (DC1)
+    _CONTROL,                  // 12 (DC2)
+    _CONTROL,                  // 13 (DC3)
+    _CONTROL,                  // 14 (DC4)
+    _CONTROL,                  // 15 (NAK)
+    _CONTROL,                  // 16 (SYN)
+    _CONTROL,                  // 17 (ETB)
+    _CONTROL,                  // 18 (CAN)
+    _CONTROL,                  // 19 (EM)
+    _CONTROL,                  // 1A (SUB)
+    _CONTROL,                  // 1B (ESC)
+    _CONTROL,                  // 1C (FS)
+    _CONTROL,                  // 1D (GS)
+    _CONTROL,                  // 1E (RS)
+    _CONTROL,                  // 1F (US)
+    _SPACE+_BLANK,             // 20 SPACE
+    _PUNCT,                    // 21 !
+    _PUNCT,                    // 22 "
+    _PUNCT,                    // 23 #
+    _PUNCT,                    // 24 $
+    _PUNCT,                    // 25 %
+    _PUNCT,                    // 26 &
+    _PUNCT,                    // 27 '
+    _PUNCT,                    // 28 (
+    _PUNCT,                    // 29 )
+    _PUNCT,                    // 2A *
+    _PUNCT,                    // 2B +
+    _PUNCT,                    // 2C ,
+    _PUNCT,                    // 2D -
+    _PUNCT,                    // 2E .
+    _PUNCT,                    // 2F /
+    _DIGIT+_HEX,               // 30 0
+    _DIGIT+_HEX,               // 31 1
+    _DIGIT+_HEX,               // 32 2
+    _DIGIT+_HEX,               // 33 3
+    _DIGIT+_HEX,               // 34 4
+    _DIGIT+_HEX,               // 35 5
+    _DIGIT+_HEX,               // 36 6
+    _DIGIT+_HEX,               // 37 7
+    _DIGIT+_HEX,               // 38 8
+    _DIGIT+_HEX,               // 39 9
+    _PUNCT,                    // 3A :
+    _PUNCT,                    // 3B ;
+    _PUNCT,                    // 3C <
+    _PUNCT,                    // 3D =
+    _PUNCT,                    // 3E >
+    _PUNCT,                    // 3F ?
+    _PUNCT,                    // 40 @
+    _UPPER+_HEX,               // 41 A
+    _UPPER+_HEX,               // 42 B
+    _UPPER+_HEX,               // 43 C
+    _UPPER+_HEX,               // 44 D
+    _UPPER+_HEX,               // 45 E
+    _UPPER+_HEX,               // 46 F
+    _UPPER,                    // 47 G
+    _UPPER,                    // 48 H
+    _UPPER,                    // 49 I
+    _UPPER,                    // 4A J
+    _UPPER,                    // 4B K
+    _UPPER,                    // 4C L
+    _UPPER,                    // 4D M
+    _UPPER,                    // 4E N
+    _UPPER,                    // 4F O
+    _UPPER,                    // 50 P
+    _UPPER,                    // 51 Q
+    _UPPER,                    // 52 R
+    _UPPER,                    // 53 S
+    _UPPER,                    // 54 T
+    _UPPER,                    // 55 U
+    _UPPER,                    // 56 V
+    _UPPER,                    // 57 W
+    _UPPER,                    // 58 X
+    _UPPER,                    // 59 Y
+    _UPPER,                    // 5A Z
+    _PUNCT,                    // 5B [
+    _PUNCT,                    // 5C \ backslash
+    _PUNCT,                    // 5D ]
+    _PUNCT,                    // 5E ^
+    _PUNCT,                    // 5F _
+    _PUNCT,                    // 60 `
+    _LOWER+_HEX,               // 61 a
+    _LOWER+_HEX,               // 62 b
+    _LOWER+_HEX,               // 63 c
+    _LOWER+_HEX,               // 64 d
+    _LOWER+_HEX,               // 65 e
+    _LOWER+_HEX,               // 66 f
+    _LOWER,                    // 67 g
+    _LOWER,                    // 68 h
+    _LOWER,                    // 69 i
+    _LOWER,                    // 6A j
+    _LOWER,                    // 6B k
+    _LOWER,                    // 6C l
+    _LOWER,                    // 6D m
+    _LOWER,                    // 6E n
+    _LOWER,                    // 6F o
+    _LOWER,                    // 70 p
+    _LOWER,                    // 71 q
+    _LOWER,                    // 72 r
+    _LOWER,                    // 73 s
+    _LOWER,                    // 74 t
+    _LOWER,                    // 75 u
+    _LOWER,                    // 76 v
+    _LOWER,                    // 77 w
+    _LOWER,                    // 78 x
+    _LOWER,                    // 79 y
+    _LOWER,                    // 7A z
+    _PUNCT,                    // 7B {
+    _PUNCT,                    // 7C |
+    _PUNCT,                    // 7D }
+    _PUNCT,                    // 7E ~
+    _CONTROL,                  // 7F (DEL)
+    // and the rest are 0...
+};
+
+extern "C" extern unsigned char const __newclmap[384]
+{
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+    0x00,   // 00 (NUL)
+    0x01,   // 01 (SOH)
+    0x02,   // 02 (STX)
+    0x03,   // 03 (ETX)
+    0x04,   // 04 (EOT)
+    0x05,   // 05 (ENQ)
+    0x06,   // 06 (ACK)
+    0x07,   // 07 (BEL)
+    0x08,   // 08 (BS)
+    0x09,   // 09 (HT)
+    0x0A,   // 0A (LF)
+    0x0B,   // 0B (VT)
+    0x0C,   // 0C (FF)
+    0x0D,   // 0D (CR)
+    0x0E,   // 0E (SI)
+    0x0F,   // 0F (SO)
+    0x10,   // 10 (DLE)
+    0x11,   // 11 (DC1)
+    0x12,   // 12 (DC2)
+    0x13,   // 13 (DC3)
+    0x14,   // 14 (DC4)
+    0x15,   // 15 (NAK)
+    0x16,   // 16 (SYN)
+    0x17,   // 17 (ETB)
+    0x18,   // 18 (CAN)
+    0x19,   // 19 (EM)
+    0x1A,   // 1A (SUB)
+    0x1B,   // 1B (ESC)
+    0x1C,   // 1C (FS)
+    0x1D,   // 1D (GS)
+    0x1E,   // 1E (RS)
+    0x1F,   // 1F (US)
+    0x20,   // 20 SPACE
+    0x21,   // 21 !
+    0x22,   // 22 "
+    0x23,   // 23 #
+    0x24,   // 24 $
+    0x25,   // 25 %
+    0x26,   // 26 &
+    0x27,   // 27 '
+    0x28,   // 28 (
+    0x29,   // 29 )
+    0x2A,   // 2A *
+    0x2B,   // 2B +
+    0x2C,   // 2C ,
+    0x2D,   // 2D -
+    0x2E,   // 2E .
+    0x2F,   // 2F /
+    0x30,   // 30 0
+    0x31,   // 31 1
+    0x32,   // 32 2
+    0x33,   // 33 3
+    0x34,   // 34 4
+    0x35,   // 35 5
+    0x36,   // 36 6
+    0x37,   // 37 7
+    0x38,   // 38 8
+    0x39,   // 39 9
+    0x3A,   // 3A :
+    0x3B,   // 3B ;
+    0x3C,   // 3C <
+    0x3D,   // 3D =
+    0x3E,   // 3E >
+    0x3F,   // 3F ?
+    0x40,   // 40 @
+    0x61,   // 41 A
+    0x62,   // 42 B
+    0x63,   // 43 C
+    0x64,   // 44 D
+    0x65,   // 45 E
+    0x66,   // 46 F
+    0x67,   // 47 G
+    0x68,   // 48 H
+    0x69,   // 49 I
+    0x6A,   // 4A J
+    0x6B,   // 4B K
+    0x6C,   // 4C L
+    0x6D,   // 4D M
+    0x6E,   // 4E N
+    0x6F,   // 4F O
+    0x70,   // 50 P
+    0x71,   // 51 Q
+    0x72,   // 52 R
+    0x73,   // 53 S
+    0x74,   // 54 T
+    0x75,   // 55 U
+    0x76,   // 56 V
+    0x77,   // 57 W
+    0x78,   // 58 X
+    0x79,   // 59 Y
+    0x7A,   // 5A Z
+    0x5B,   // 5B [
+    0x5C,   // 5C \ 
+    0x5D,   // 5D ]
+    0x5E,   // 5E ^
+    0x5F,   // 5F _
+    0x60,   // 60 `
+    0x61,   // 61 a
+    0x62,   // 62 b
+    0x63,   // 63 c
+    0x64,   // 64 d
+    0x65,   // 65 e
+    0x66,   // 66 f
+    0x67,   // 67 g
+    0x68,   // 68 h
+    0x69,   // 69 i
+    0x6A,   // 6A j
+    0x6B,   // 6B k
+    0x6C,   // 6C l
+    0x6D,   // 6D m
+    0x6E,   // 6E n
+    0x6F,   // 6F o
+    0x70,   // 70 p
+    0x71,   // 71 q
+    0x72,   // 72 r
+    0x73,   // 73 s
+    0x74,   // 74 t
+    0x75,   // 75 u
+    0x76,   // 76 v
+    0x77,   // 77 w
+    0x78,   // 78 x
+    0x79,   // 79 y
+    0x7A,   // 7A z
+    0x7B,   // 7B {
+    0x7C,   // 7C |
+    0x7D,   // 7D }
+    0x7E,   // 7E ~
+    0x7F,   // 7F (DEL)
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+extern "C" extern unsigned char const __newcumap[384]
+{
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+    0x00,   // 00 (NUL)
+    0x01,   // 01 (SOH)
+    0x02,   // 02 (STX)
+    0x03,   // 03 (ETX)
+    0x04,   // 04 (EOT)
+    0x05,   // 05 (ENQ)
+    0x06,   // 06 (ACK)
+    0x07,   // 07 (BEL)
+    0x08,   // 08 (BS)
+    0x09,   // 09 (HT)
+    0x0A,   // 0A (LF)
+    0x0B,   // 0B (VT)
+    0x0C,   // 0C (FF)
+    0x0D,   // 0D (CR)
+    0x0E,   // 0E (SI)
+    0x0F,   // 0F (SO)
+    0x10,   // 10 (DLE)
+    0x11,   // 11 (DC1)
+    0x12,   // 12 (DC2)
+    0x13,   // 13 (DC3)
+    0x14,   // 14 (DC4)
+    0x15,   // 15 (NAK)
+    0x16,   // 16 (SYN)
+    0x17,   // 17 (ETB)
+    0x18,   // 18 (CAN)
+    0x19,   // 19 (EM)
+    0x1A,   // 1A (SUB)
+    0x1B,   // 1B (ESC)
+    0x1C,   // 1C (FS)
+    0x1D,   // 1D (GS)
+    0x1E,   // 1E (RS)
+    0x1F,   // 1F (US)
+    0x20,   // 20 SPACE
+    0x21,   // 21 !
+    0x22,   // 22 "
+    0x23,   // 23 #
+    0x24,   // 24 $
+    0x25,   // 25 %
+    0x26,   // 26 &
+    0x27,   // 27 '
+    0x28,   // 28 (
+    0x29,   // 29 )
+    0x2A,   // 2A *
+    0x2B,   // 2B +
+    0x2C,   // 2C ,
+    0x2D,   // 2D -
+    0x2E,   // 2E .
+    0x2F,   // 2F /
+    0x30,   // 30 0
+    0x31,   // 31 1
+    0x32,   // 32 2
+    0x33,   // 33 3
+    0x34,   // 34 4
+    0x35,   // 35 5
+    0x36,   // 36 6
+    0x37,   // 37 7
+    0x38,   // 38 8
+    0x39,   // 39 9
+    0x3A,   // 3A :
+    0x3B,   // 3B ;
+    0x3C,   // 3C <
+    0x3D,   // 3D =
+    0x3E,   // 3E >
+    0x3F,   // 3F ?
+    0x40,   // 40 @
+    0x41,   // 41 A
+    0x42,   // 42 B
+    0x43,   // 43 C
+    0x44,   // 44 D
+    0x45,   // 45 E
+    0x46,   // 46 F
+    0x47,   // 47 G
+    0x48,   // 48 H
+    0x49,   // 49 I
+    0x4A,   // 4A J
+    0x4B,   // 4B K
+    0x4C,   // 4C L
+    0x4D,   // 4D M
+    0x4E,   // 4E N
+    0x4F,   // 4F O
+    0x50,   // 50 P
+    0x51,   // 51 Q
+    0x52,   // 52 R
+    0x53,   // 53 S
+    0x54,   // 54 T
+    0x55,   // 55 U
+    0x56,   // 56 V
+    0x57,   // 57 W
+    0x58,   // 58 X
+    0x59,   // 59 Y
+    0x5A,   // 5A Z
+    0x5B,   // 5B [
+    0x5C,   // 5C \ 
+    0x5D,   // 5D ]
+    0x5E,   // 5E ^
+    0x5F,   // 5F _
+    0x60,   // 60 `
+    0x41,   // 61 a
+    0x42,   // 62 b
+    0x43,   // 63 c
+    0x44,   // 64 d
+    0x45,   // 65 e
+    0x46,   // 66 f
+    0x47,   // 67 g
+    0x48,   // 68 h
+    0x49,   // 69 i
+    0x4A,   // 6A j
+    0x4B,   // 6B k
+    0x4C,   // 6C l
+    0x4D,   // 6D m
+    0x4E,   // 6E n
+    0x4F,   // 6F o
+    0x50,   // 70 p
+    0x51,   // 71 q
+    0x52,   // 72 r
+    0x53,   // 73 s
+    0x54,   // 74 t
+    0x55,   // 75 u
+    0x56,   // 76 v
+    0x57,   // 77 w
+    0x58,   // 78 x
+    0x59,   // 79 y
+    0x5A,   // 7A z
+    0x7B,   // 7B {
+    0x7C,   // 7C |
+    0x7D,   // 7D }
+    0x7E,   // 7E ~
+    0x7F,   // 7F (DEL)
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+
+
+extern "C" unsigned short const* _pctype {__newctype + 128}; // Pointer to table for char's
+extern "C" unsigned short const* _pwctype{_wctype    + 1  }; // Pointer to table for wchar_t's
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/get_qualified_locale.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/get_qualified_locale.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1c4734bf8c87d29fa3a9ebe0be034a43a1215546
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/get_qualified_locale.cpp	
@@ -0,0 +1,851 @@
+/***
+*getqloc.c - get qualified locale
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines __acrt_get_qualified_locale - get complete locale information
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+extern "C" {
+
+
+
+//  local defines
+#define __LOC_DEFAULT  0x1     //  default language locale for country
+#define __LOC_PRIMARY  0x2     //  primary language locale for country
+#define __LOC_FULL     0x4     //  fully matched language locale for country
+#define __LOC_LANGUAGE 0x100   //  language default seen
+#define __LOC_EXISTS   0x200   //  language is installed
+
+
+
+//  non-NLS language string table
+//  The three letter Windows names are non-standard and very limited and should not be used.
+extern __crt_locale_string_table const __acrt_rg_language[]
+{
+    { L"american",                    L"ENU" },
+    { L"american english",            L"ENU" },
+    { L"american-english",            L"ENU" },
+    { L"australian",                  L"ENA" },
+    { L"belgian",                     L"NLB" },
+    { L"canadian",                    L"ENC" },
+    { L"chh",                         L"ZHH" },
+    { L"chi",                         L"ZHI" },
+    { L"chinese",                     L"CHS" },
+    { L"chinese-hongkong",            L"ZHH" },
+    { L"chinese-simplified",          L"CHS" },
+    { L"chinese-singapore",           L"ZHI" },
+    { L"chinese-traditional",         L"CHT" },
+    { L"dutch-belgian",               L"NLB" },
+    { L"english-american",            L"ENU" },
+    { L"english-aus",                 L"ENA" },
+    { L"english-belize",              L"ENL" },
+    { L"english-can",                 L"ENC" },
+    { L"english-caribbean",           L"ENB" },
+    { L"english-ire",                 L"ENI" },
+    { L"english-jamaica",             L"ENJ" },
+    { L"english-nz",                  L"ENZ" },
+    { L"english-south africa",        L"ENS" },
+    { L"english-trinidad y tobago",   L"ENT" },
+    { L"english-uk",                  L"ENG" },
+    { L"english-us",                  L"ENU" },
+    { L"english-usa",                 L"ENU" },
+    { L"french-belgian",              L"FRB" },
+    { L"french-canadian",             L"FRC" },
+    { L"french-luxembourg",           L"FRL" },
+    { L"french-swiss",                L"FRS" },
+    { L"german-austrian",             L"DEA" },
+    { L"german-lichtenstein",         L"DEC" },
+    { L"german-luxembourg",           L"DEL" },
+    { L"german-swiss",                L"DES" },
+    { L"irish-english",               L"ENI" },
+    { L"italian-swiss",               L"ITS" },
+    { L"norwegian",                   L"NOR" },
+    { L"norwegian-bokmal",            L"NOR" },
+    { L"norwegian-nynorsk",           L"NON" },
+    { L"portuguese-brazilian",        L"PTB" },
+    { L"spanish-argentina",           L"ESS" },
+    { L"spanish-bolivia",             L"ESB" },
+    { L"spanish-chile",               L"ESL" },
+    { L"spanish-colombia",            L"ESO" },
+    { L"spanish-costa rica",          L"ESC" },
+    { L"spanish-dominican republic",  L"ESD" },
+    { L"spanish-ecuador",             L"ESF" },
+    { L"spanish-el salvador",         L"ESE" },
+    { L"spanish-guatemala",           L"ESG" },
+    { L"spanish-honduras",            L"ESH" },
+    { L"spanish-mexican",             L"ESM" },
+    { L"spanish-modern",              L"ESN" },
+    { L"spanish-nicaragua",           L"ESI" },
+    { L"spanish-panama",              L"ESA" },
+    { L"spanish-paraguay",            L"ESZ" },
+    { L"spanish-peru",                L"ESR" },
+    { L"spanish-puerto rico",         L"ESU" },
+    { L"spanish-uruguay",             L"ESY" },
+    { L"spanish-venezuela",           L"ESV" },
+    { L"swedish-finland",             L"SVF" },
+    { L"swiss",                       L"DES" },
+    { L"uk",                          L"ENG" },
+    { L"us",                          L"ENU" },
+    { L"usa",                         L"ENU" }
+};
+
+//  non-NLS country/region string table
+//  The three letter Windows names are non-standard and very limited and should not be used.
+extern __crt_locale_string_table const __acrt_rg_country[]
+{
+    { L"america",                     L"USA" },
+    { L"britain",                     L"GBR" },
+    { L"china",                       L"CHN" },
+    { L"czech",                       L"CZE" },
+    { L"england",                     L"GBR" },
+    { L"great britain",               L"GBR" },
+    { L"holland",                     L"NLD" },
+    { L"hong-kong",                   L"HKG" },
+    { L"new-zealand",                 L"NZL" },
+    { L"nz",                          L"NZL" },
+    { L"pr china",                    L"CHN" },
+    { L"pr-china",                    L"CHN" },
+    { L"puerto-rico",                 L"PRI" },
+    { L"slovak",                      L"SVK" },
+    { L"south africa",                L"ZAF" },
+    { L"south korea",                 L"KOR" },
+    { L"south-africa",                L"ZAF" },
+    { L"south-korea",                 L"KOR" },
+    { L"trinidad & tobago",           L"TTO" },
+    { L"uk",                          L"GBR" },
+    { L"united-kingdom",              L"GBR" },
+    { L"united-states",               L"USA" },
+    { L"us",                          L"USA" },
+};
+
+// Number of entries in the language and country tables
+extern size_t const __acrt_rg_language_count{_countof(__acrt_rg_language)};
+extern size_t const __acrt_rg_country_count {_countof(__acrt_rg_country )};
+
+
+
+
+//  function prototypes
+BOOL __cdecl __acrt_get_qualified_locale(const __crt_locale_strings*, UINT*, __crt_locale_strings*);
+static BOOL TranslateName(const __crt_locale_string_table *, int, const wchar_t **);
+
+static void GetLocaleNameFromLangCountry (__crt_qualified_locale_data* _psetloc_data);
+static BOOL CALLBACK LangCountryEnumProcEx(_In_z_ LPWSTR, DWORD, LPARAM);
+
+static void GetLocaleNameFromLanguage (__crt_qualified_locale_data* _psetloc_data);
+static BOOL CALLBACK LanguageEnumProcEx(_In_z_ LPWSTR, DWORD, LPARAM);
+
+static void GetLocaleNameFromDefault (__crt_qualified_locale_data* _psetloc_data);
+
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data* _psetloc_data);
+static BOOL TestDefaultCountry(LPCWSTR localeName);
+static BOOL TestDefaultLanguage (LPCWSTR localeName, BOOL bTestPrimary, __crt_qualified_locale_data* _psetloc_data);
+
+static int GetPrimaryLen(LPCWSTR);
+
+
+/***
+*BOOL __acrt_get_qualified_locale - return fully qualified locale
+*
+*Purpose:
+*       get default locale, qualify partially complete locales
+*
+*Entry:
+*       lpInStr - input strings to be qualified
+*       lpOutStr - pointer to string locale names and codepage output
+*
+*Exit:
+*       TRUE if success, qualified locale is valid
+*       FALSE if failure
+*
+*Exceptions:
+*
+*******************************************************************************/
+BOOL __cdecl __acrt_get_qualified_locale(const __crt_locale_strings* lpInStr, UINT* lpOutCodePage, __crt_locale_strings* lpOutStr)
+{
+    int iCodePage;
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+    _psetloc_data->_cacheLocaleName[0] = L'\x0'; // Initialize to invariant localename
+
+    //  initialize pointer to call locale info routine based on operating system
+
+    _psetloc_data->iLocState = 0;
+    _psetloc_data->pchLanguage = lpInStr->szLanguage;
+    _psetloc_data->pchCountry = lpInStr->szCountry;
+
+    //  if country defined
+    //  convert non-NLS country strings to three-letter abbreviations
+    if (*_psetloc_data->pchCountry)
+        TranslateName(__acrt_rg_country, static_cast<int>(__acrt_rg_country_count - 1),
+                      &_psetloc_data->pchCountry);
+
+
+    //  if language defined ...
+    if (*_psetloc_data->pchLanguage)
+    {
+        //  and country defined
+        if (*_psetloc_data->pchCountry)
+        {
+            //  both language and country strings defined
+            //  get locale info using language and country
+            GetLocaleNameFromLangCountry(_psetloc_data);
+        }
+        else
+        {
+            //  language string defined, but country string undefined
+            //  get locale info using language only
+            GetLocaleNameFromLanguage(_psetloc_data);
+        }
+
+        // still not done?
+        if (_psetloc_data->iLocState == 0)
+        {
+            //  first attempt failed, try substituting the language name
+            //  convert non-NLS language strings to three-letter abbrevs
+            if (TranslateName(__acrt_rg_language, static_cast<int>(__acrt_rg_language_count - 1),
+                              &_psetloc_data->pchLanguage))
+            {
+                if (*_psetloc_data->pchCountry)
+                {
+                    //  get locale info using language and country
+                    GetLocaleNameFromLangCountry(_psetloc_data);
+                }
+                else
+                {
+                    //  get locale info using language only
+                    GetLocaleNameFromLanguage(_psetloc_data);
+                }
+            }
+        }
+    }
+    else
+    {
+        //  language is an empty string, use the User Default locale name
+        GetLocaleNameFromDefault(_psetloc_data);
+    }
+
+    //  test for error in locale processing
+    if (_psetloc_data->iLocState == 0)
+        return FALSE;
+
+    //  process codepage value
+    if (lpInStr == nullptr || *lpInStr->szLanguage || *lpInStr->szCodePage )
+    {
+        // If there's no input, then get the current codepage
+        // If they explicitly chose a language, use that default codepage
+        // If they explicilty set a codepage, then use that
+        iCodePage = ProcessCodePage(lpInStr ? lpInStr->szCodePage : nullptr, _psetloc_data);
+    }
+    else
+    {
+        // No language or codepage means that they want to set to the
+        // user default settings, get that codepage (could be UTF-8)
+        iCodePage = GetACP();
+    }
+
+    //  verify codepage validity
+    //  CP_UTF7 is unexpected and has never been previously permitted.
+    //  CP_UTF8 is the current preferred codepage
+    if (!iCodePage || iCodePage == CP_UTF7 || !IsValidCodePage((WORD)iCodePage))
+        return FALSE;
+
+    //  set codepage
+    if (lpOutCodePage)
+    {
+        *lpOutCodePage = (UINT)iCodePage;
+    }
+
+    //  set locale name and codepage results
+    if (lpOutStr)
+    {
+        lpOutStr->szLocaleName[0] = L'\x0'; // Init the locale name to empty string
+
+        _ERRCHECK(wcsncpy_s(lpOutStr->szLocaleName, _countof(lpOutStr->szLocaleName), _psetloc_data->_cacheLocaleName, wcslen(_psetloc_data->_cacheLocaleName) + 1));
+
+        // Get and store the English language lang name, to be returned to user
+        if (__acrt_GetLocaleInfoEx(lpOutStr->szLocaleName, LOCALE_SENGLISHLANGUAGENAME,
+                                    lpOutStr->szLanguage, MAX_LANG_LEN) == 0)
+            return FALSE;
+
+        // Get and store the English language country name, to be returned to user
+        if (__acrt_GetLocaleInfoEx(lpOutStr->szLocaleName, LOCALE_SENGLISHCOUNTRYNAME,
+                                    lpOutStr->szCountry, MAX_CTRY_LEN) == 0)
+            return FALSE;
+
+        // Special case: Both '.' and '_' are separators in string passed to setlocale,
+        // so if found in Country we use abbreviated name instead.
+        if (wcschr(lpOutStr->szCountry, L'_') || wcschr(lpOutStr->szCountry, L'.'))
+            if (__acrt_GetLocaleInfoEx(lpOutStr->szLocaleName, LOCALE_SABBREVCTRYNAME,
+                                    lpOutStr->szCountry, MAX_CTRY_LEN) == 0)
+                return FALSE;
+
+        if (iCodePage == CP_UTF8)
+        {
+            // We want UTF-8 to look like utf8, not 65001
+            _ERRCHECK(wcsncpy_s(lpOutStr->szCodePage, _countof(lpOutStr->szCodePage), L"utf8", 5));
+        }
+        else
+        {
+            _itow_s((int)iCodePage, (wchar_t *)lpOutStr->szCodePage, MAX_CP_LEN, 10);
+        }
+    }
+
+    return TRUE;
+}
+
+/***
+*BOOL TranslateName - convert known non-NLS string to NLS equivalent
+*
+*Purpose:
+*   Provide compatibility with existing code for non-NLS strings
+*
+*Entry:
+*   lpTable  - pointer to __crt_locale_string_table used for translation
+*   high     - maximum index of table (size - 1)
+*   ppchName - pointer to pointer of string to translate
+*
+*Exit:
+*   ppchName - pointer to pointer of string possibly translated
+*   TRUE if string translated, FALSE if unchanged
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TranslateName (
+    const __crt_locale_string_table * lpTable,
+    int               high,
+    const wchar_t**   ppchName)
+{
+    int     i;
+    int     cmp = 1;
+    int     low = 0;
+
+    //  typical binary search - do until no more to search or match
+    while (low <= high && cmp != 0)
+    {
+        i = (low + high) / 2;
+        cmp = _wcsicmp(*ppchName, (const wchar_t *)(*(lpTable + i)).szName);
+
+        if (cmp == 0)
+            *ppchName = (*(lpTable + i)).chAbbrev;
+        else if (cmp < 0)
+            high = i - 1;
+        else
+            low = i + 1;
+    }
+
+    return !cmp;
+}
+
+/***
+*void GetLocaleNameFromLangCountry - get locale names from language and country strings
+*
+*Purpose:
+*   Match the best locale names to the language and country string given.
+*   After global variables are initialized, the LangCountryEnumProcEx
+*   routine is registered as an EnumSystemLocalesEx callback to actually
+*   perform the matching as the locale names are enumerated.
+*
+*
+*WARNING:
+*   This depends on an exact match with a localized string that can change!
+*   It is strongly recommended that locales be selected with valid BCP-47
+*   tags instead of the English names.
+*
+*   This API is also very brute-force and resource intensive, reading in all
+*   of the locales, forcing them to be cached, and looking up their names.
+*
+*WARNING:
+*   In the event of a 2 or 3 letter friendly name (Asu, Edo, Ewe, Yi, ...)
+*   then this function will fail
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   pchCountry      - country string
+*   bAbbrevCountry  - country string ia a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   localeName - locale name of given language and country
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLocaleNameFromLangCountry (__crt_qualified_locale_data* _psetloc_data)
+{
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->bAbbrevCountry = wcslen(_psetloc_data->pchCountry) == 3;
+
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ?
+                             2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    // Enumerate all locales that come with the operating system,
+    // including replacement locales, but excluding alternate sorts.
+    __acrt_EnumSystemLocalesEx(LangCountryEnumProcEx, LOCALE_WINDOWS | LOCALE_SUPPLEMENTAL, 0, nullptr);
+
+    //  locale value is invalid if the language was not installed or the language
+    //  was not available for the country specified
+    if (!(_psetloc_data->iLocState & __LOC_LANGUAGE) ||
+        !(_psetloc_data->iLocState & __LOC_EXISTS) ||
+        !(_psetloc_data->iLocState & (__LOC_FULL |
+                                    __LOC_PRIMARY |
+                                    __LOC_DEFAULT)))
+        _psetloc_data->iLocState = 0;
+}
+
+/***
+*BOOL CALLBACK LangCountryEnumProcEx - callback routine for GetLocaleNameFromLangCountry
+*
+*Purpose:
+*   Determine if locale name given matches the language in pchLanguage
+*   and country in pchCountry.
+*
+*Entry:
+*   lpLocaleString   - pointer to locale name string string
+*   pchCountry     - pointer to country name
+*   bAbbrevCountry - set if country is three-letter abbreviation
+*
+*Exit:
+*   iLocState   - status of match
+*       __LOC_FULL - both language and country match (best match)
+*       __LOC_PRIMARY - primary language and country match (better)
+*       __LOC_DEFAULT - default language and country match (good)
+*       __LOC_LANGUAGE - default primary language exists
+*       __LOC_EXISTS - full match of language string exists
+*       (Overall match occurs for the best of FULL/PRIMARY/DEFAULT
+*        and LANGUAGE/EXISTS both set.)
+*   localeName - lpLocaleString matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LangCountryEnumProcEx(LPWSTR lpLocaleString, DWORD dwFlags, LPARAM lParam)
+{
+    UNREFERENCED_PARAMETER(dwFlags);
+    UNREFERENCED_PARAMETER(lParam);
+
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+    wchar_t  rgcInfo[MAX_LANG_LEN]; // MAX_LANG_LEN == MAX_CTRY_LEN == 64
+
+    //  test locale country against input value
+    if (__acrt_GetLocaleInfoEx(lpLocaleString,
+                               _psetloc_data->bAbbrevCountry ? LOCALE_SABBREVCTRYNAME : LOCALE_SENGLISHCOUNTRYNAME,
+                               rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_data->iLocState = 0;
+        return TRUE;
+    }
+
+    //  if country names matched
+    if (_wcsicmp(_psetloc_data->pchCountry, rgcInfo) == 0)
+    {
+        //  test for language match
+        if (__acrt_GetLocaleInfoEx(lpLocaleString,
+                                   _psetloc_data->bAbbrevLanguage ?
+                                   LOCALE_SABBREVLANGNAME : LOCALE_SENGLISHLANGUAGENAME,
+                                   rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_data->iLocState = 0;
+            return TRUE;
+        }
+
+        if (_wcsicmp(_psetloc_data->pchLanguage, rgcInfo) == 0)
+        {
+            //  language matched also - set state and value
+            //  this is the best match
+            _psetloc_data->iLocState |= (__LOC_FULL |
+                                       __LOC_LANGUAGE |
+                                       __LOC_EXISTS);
+
+            _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+        }
+        //  test if match already for primary langauage
+        else if (!(_psetloc_data->iLocState & __LOC_PRIMARY))
+        {
+            //  if not, use _psetloc_data->iPrimaryLen to partial match language string
+            if (_psetloc_data->iPrimaryLen && !_wcsnicmp(_psetloc_data->pchLanguage, rgcInfo, _psetloc_data->iPrimaryLen))
+            {
+                //  primary language matched - set locale name
+                _psetloc_data->iLocState |= __LOC_PRIMARY;
+                _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+            }
+
+            //  test if default language already defined
+            else if (!(_psetloc_data->iLocState & __LOC_DEFAULT))
+            {
+                //  if not, test if locale language is default for country
+                if (TestDefaultCountry(lpLocaleString))
+                {
+                    //  default language for country - set state, value
+                    _psetloc_data->iLocState |= __LOC_DEFAULT;
+                    _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+                }
+            }
+        }
+    }
+
+    //  test if input language both exists and default primary language defined
+    if ((_psetloc_data->iLocState & (__LOC_LANGUAGE | __LOC_EXISTS)) !=
+                      (__LOC_LANGUAGE | __LOC_EXISTS))
+    {
+        //  test language match to determine whether it is installed
+        if (__acrt_GetLocaleInfoEx(lpLocaleString, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                                           : LOCALE_SENGLISHLANGUAGENAME,
+                           rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_data->iLocState = 0;
+            return TRUE;
+        }
+
+        // the input language matches
+        if (_wcsicmp(_psetloc_data->pchLanguage, rgcInfo) == 0)
+        {
+            //  language matched - set bit for existance
+            _psetloc_data->iLocState |= __LOC_EXISTS;
+
+            if (_psetloc_data->bAbbrevLanguage)
+            {
+                //  abbreviation - set state
+                //  also set language locale name if not set already
+                _psetloc_data->iLocState |= __LOC_LANGUAGE;
+                if (!_psetloc_data->_cacheLocaleName[0])
+                    _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+            }
+
+            //  test if language is primary only (no sublanguage)
+            else if (_psetloc_data->iPrimaryLen && ((int)wcslen(_psetloc_data->pchLanguage) == _psetloc_data->iPrimaryLen))
+            {
+                //  primary language only - test if default locale name
+                if (TestDefaultLanguage(lpLocaleString, TRUE, _psetloc_data))
+                {
+                    //  default primary language - set state
+                    //  also set locale name if not set already
+                    _psetloc_data->iLocState |= __LOC_LANGUAGE;
+                    if (!_psetloc_data->_cacheLocaleName[0])
+                        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+                }
+            }
+            else
+            {
+                //  language with sublanguage - set state
+                //  also set locale name if not set already
+                _psetloc_data->iLocState |= __LOC_LANGUAGE;
+                if (!_psetloc_data->_cacheLocaleName[0])
+                    _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+            }
+        }
+    }
+
+    //  if LOCALE_FULL set, return FALSE to stop enumeration,
+    //  else return TRUE to continue
+    return (_psetloc_data->iLocState & __LOC_FULL) == 0;
+}
+
+/***
+*void GetLocaleNameFromLanguage - get locale name from language string
+*
+*Purpose:
+*   Match the best locale name to the language string given.  After global
+*   variables are initialized, the LanguageEnumProcEx routine is
+*   registered as an EnumSystemLocalesEx callback to actually perform
+*   the matching as the locale names are enumerated.
+*
+*WARNING:
+*   This depends on an exact match with a localized string that can change!
+*   It is strongly recommended that locales be selected with valid BCP-47
+*   tags instead of the English names.
+*
+*   This API is also very brute-force and resource intensive, reading in all
+*   of the locales, forcing them to be cached, and looking up their names.
+*
+*WARNING:
+*   In the event of a 3 letter BCP-47 tag that happens to match a Windows
+*   propriatary language code, this function will return the wrong answer!
+*
+*WARNING:
+*   In the event of a 2 or 3 letter friendly name (Asu, Edo, Ewe, Yi, ...)
+*   then this function will fail
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   localeName - locale name of language with default country
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLocaleNameFromLanguage (__crt_qualified_locale_data* _psetloc_data)
+{
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ? 2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    // Enumerate all locales that come with the operating system, including replacement locales,
+    // but excluding alternate sorts.
+    __acrt_EnumSystemLocalesEx(LanguageEnumProcEx, LOCALE_WINDOWS | LOCALE_SUPPLEMENTAL, 0, nullptr);
+
+    //  locale value is invalid if the language was not installed
+    //  or the language was not available for the country specified
+    if ((_psetloc_data->iLocState & __LOC_FULL) == 0)
+        _psetloc_data->iLocState = 0;
+}
+
+/***
+*BOOL CALLBACK LanguageEnumProcEx - callback routine for GetLocaleNameFromLanguage
+*
+*Purpose:
+*   Determine if locale name given matches the default country for the
+*   language in pchLanguage.
+*
+*Entry:
+*   lpLocaleString    - pointer to string with locale name
+*   dwFlags     - not used
+*   lParam      - not used
+*
+*Exit:
+*   localeName - locale name matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LanguageEnumProcEx (LPWSTR lpLocaleString, DWORD dwFlags, LPARAM lParam)
+{
+    UNREFERENCED_PARAMETER(dwFlags);
+    UNREFERENCED_PARAMETER(lParam);
+
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+    wchar_t    rgcInfo[120];
+
+    //  test locale for language specified
+    if (__acrt_GetLocaleInfoEx(lpLocaleString, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                                              : LOCALE_SENGLISHLANGUAGENAME,
+                               rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_data->iLocState = 0;
+        return TRUE;
+    }
+
+    if (_wcsicmp(_psetloc_data->pchLanguage, rgcInfo) == 0)
+    {
+        //  language matches
+        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), lpLocaleString, wcslen(lpLocaleString) + 1));
+
+        _psetloc_data->iLocState |= __LOC_FULL;
+    }
+
+    return (_psetloc_data->iLocState & __LOC_FULL) == 0;
+}
+
+
+/***
+*void GetLocaleNameFromDefault - get default locale names
+*
+*Purpose:
+*   Set both language and country locale names to the user default.
+*
+*Entry:
+*   None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLocaleNameFromDefault (__crt_qualified_locale_data* _psetloc_data)
+{
+    wchar_t localeName[LOCALE_NAME_MAX_LENGTH];
+    _psetloc_data->iLocState |= (__LOC_FULL | __LOC_LANGUAGE);
+
+    // Store the default user locale name. The returned buffer size includes the
+    // terminating null character, so only store if the size returned is > 1
+    if (__acrt_GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH) > 1)
+    {
+        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), localeName, wcslen(localeName) + 1));
+    }
+}
+
+/***
+*int ProcessCodePage - convert codepage string to numeric value
+*
+*Purpose:
+*   Process codepage string consisting of a decimal string, or the
+*   special case strings "ACP" and "OCP", for ANSI and OEM codepages,
+*   respectively.  Null pointer or string returns the ANSI codepage.
+*
+*Entry:
+*   lpCodePageStr - pointer to codepage string
+*
+*Exit:
+*   Returns numeric value of codepage, zero if GetLocaleInfoEx failed.
+*   (which then would mean caller aborts and locale is not set)
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data* _psetloc_data)
+{
+    int iCodePage;
+
+    if (!lpCodePageStr || !*lpCodePageStr || wcscmp(lpCodePageStr, L"ACP") == 0)
+    {
+        //  get ANSI codepage for the country locale name
+        //  CONSIDER: If system is running UTF-8 ACP, then always return UTF-8?
+        if (__acrt_GetLocaleInfoEx(_psetloc_data->_cacheLocaleName, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+
+        // Locales with no code page ("Unicode only locales") should return UTF-8
+        // (0, 1 & 2 are Unicode-Only ACP, OEMCP & MacCP flags)
+        if (iCodePage < 3)
+        {
+            return CP_UTF8;
+        }
+
+    }
+    else if (_wcsicmp(lpCodePageStr, L"utf8") == 0 ||
+             _wcsicmp(lpCodePageStr, L"utf-8") == 0)
+    {
+        // Use UTF-8
+        return CP_UTF8;
+    }
+    else if (wcscmp(lpCodePageStr, L"OCP") == 0)
+    {
+        //  get OEM codepage for the country locale name
+        //  CONSIDER: If system is running UTF-8 ACP, then always return UTF-8?
+        if (__acrt_GetLocaleInfoEx(_psetloc_data->_cacheLocaleName, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+
+        // Locales with no code page ("unicode only locales") should return UTF-8
+        // (0, 1 & 2 are Unicode-Only ACP, OEMCP & MacCP flags)
+        if (iCodePage < 3)
+        {
+            return CP_UTF8;
+        }
+    }
+    else
+    {
+         // convert decimal string to numeric value
+         iCodePage = (int)_wtol(lpCodePageStr);
+    }
+
+    return iCodePage;
+}
+
+/***
+*BOOL TestDefaultCountry - determine if default locale for country
+*
+*Purpose:
+*   Determine if the locale of the given locale name has the default sublanguage.
+*   This is determined by checking if the given language is neutral.
+*
+*Entry:
+*   localeName - name of locale to test
+*
+*Exit:
+*   Returns TRUE if default sublanguage, else FALSE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultCountry (LPCWSTR localeName)
+{
+    wchar_t sIso639LangName[9]; // The maximum length for LOCALE_SISO3166CTRYNAME
+                                // is 9 including nullptr
+
+    //  Get 2-letter ISO Standard 639 or 3-letter ISO 639-2 value
+    if (__acrt_GetLocaleInfoEx(localeName, LOCALE_SISO639LANGNAME,
+                                sIso639LangName, _countof(sIso639LangName)) == 0)
+        return FALSE;
+
+    // Determine if this is a neutral language
+    if (wcsncmp(sIso639LangName, localeName, _countof(sIso639LangName)) == 0)
+        return TRUE;
+
+    return FALSE;
+}
+
+/***
+*BOOL TestDefaultLanguage - determine if default locale for language
+*
+*Purpose:
+*   Determines if the given locale name has the default sublanguage.
+*   If bTestPrimary is set, also allow TRUE when string contains an
+*   implicit sublanguage.
+*
+*Entry:
+*   localeName         - locale name of locale to test
+*   bTestPrimary - set if testing if language is primary
+*
+*Exit:
+*   Returns TRUE if sublanguage is default for locale tested.
+*   If bTestPrimary set, TRUE is language has implied sublanguge.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultLanguage(LPCWSTR localeName, BOOL bTestPrimary, __crt_qualified_locale_data* _psetloc_data)
+{
+    if (!TestDefaultCountry (localeName))
+    {
+        //  test if string contains an implicit sublanguage by
+        //  having a character other than upper/lowercase letters.
+        if (bTestPrimary && GetPrimaryLen(_psetloc_data->pchLanguage) == (int)wcslen(_psetloc_data->pchLanguage))
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+/***
+*int GetPrimaryLen - get length of primary language name
+*
+*Purpose:
+*   Determine primary language string length by scanning until
+*   first non-alphabetic character.
+*
+*Entry:
+*   pchLanguage - string to scan
+*
+*Exit:
+*   Returns length of primary language string.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int GetPrimaryLen(LPCWSTR pchLanguage)
+{
+    int     len = 0;
+    wchar_t    ch;
+
+    if (!pchLanguage)
+        return 0;
+
+    ch = *pchLanguage++;
+    while ((ch >= L'A' && ch <= L'Z') || (ch >= L'a' && ch <= L'z'))
+    {
+        len++;
+        ch = *pchLanguage++;
+    }
+
+    return len;
+}
+
+
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/getqloc_downlevel.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/getqloc_downlevel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..950579a13751a47c92ef62771f49952d26df1e67
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/getqloc_downlevel.cpp	
@@ -0,0 +1,852 @@
+/***
+*getqloc_downlevel.c - get qualified locale for downlevel OS
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines __acrt_get_qualified_locale_downlevel - get complete locale information
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern "C" {
+
+//  local defines
+#define __LCID_DEFAULT  0x1     //  default language locale for country
+#define __LCID_PRIMARY  0x2     //  primary language locale for country
+#define __LCID_FULL     0x4     //  fully matched language locale for country
+#define __LCID_LANGUAGE 0x100   //  language default seen
+#define __LCID_EXISTS   0x200   //  language is installed
+
+typedef struct tagRGLOCINFO
+{
+    LCID        lcid;
+    wchar_t        chILanguage[8];
+    wchar_t *      pchSEngLanguage;
+    wchar_t        chSAbbrevLangName[4];
+    wchar_t *      pchSEngCountry;
+    wchar_t        chSAbbrevCtryName[4];
+    wchar_t        chIDefaultCodepage[8];
+    wchar_t        chIDefaultAnsiCodepage[8];
+} RGLOCINFO;
+
+static bool TranslateName(const __crt_locale_string_table *, int, const wchar_t **);
+
+static void GetLcidFromLangCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL CALLBACK LangCountryEnumProc(_In_z_ PWSTR);
+
+static void GetLcidFromLanguage (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL CALLBACK LanguageEnumProc(_In_z_ PWSTR);
+
+static void GetLcidFromCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL CALLBACK CountryEnumProc(_In_z_ PWSTR);
+
+static void GetLcidFromDefault (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+static BOOL TestDefaultCountry(LCID);
+static BOOL TestDefaultLanguage (LCID lcid, BOOL bTestPrimary, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data);
+
+static LCID LcidFromHexString(_In_z_ PCWSTR);
+static int GetPrimaryLen(wchar_t const*);
+
+//  LANGID's of locales of nondefault languages
+extern __declspec(selectany) LANGID const __rglangidNotDefault[] =
+{
+    MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_CANADIAN),
+    MAKELANGID(LANG_SERBIAN, SUBLANG_SERBIAN_CYRILLIC),
+    MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_LUXEMBOURG),
+    MAKELANGID(LANG_AFRIKAANS, SUBLANG_DEFAULT),
+    MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_BELGIAN),
+    MAKELANGID(LANG_BASQUE, SUBLANG_DEFAULT),
+    MAKELANGID(LANG_CATALAN, SUBLANG_DEFAULT),
+    MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH_SWISS),
+    MAKELANGID(LANG_ITALIAN, SUBLANG_ITALIAN_SWISS),
+    MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH_FINLAND)
+};
+
+/***
+*BOOL __acrt_get_qualified_locale_downlevel - return fully qualified locale
+*
+*Purpose:
+*       get default locale, qualify partially complete locales
+*
+*Entry:
+*       lpInStr - input strings to be qualified
+*       lpOutId - pointer to numeric LCIDs and codepage output
+*       lpOutStr - pointer to string LCIDs and codepage output
+*
+*Exit:
+*       TRUE if success, qualified locale is valid
+*       FALSE if failure
+*
+*Exceptions:
+*
+*******************************************************************************/
+BOOL __cdecl __acrt_get_qualified_locale_downlevel(const __crt_locale_strings* lpInStr, UINT* lpOutCodePage, __crt_locale_strings* lpOutStr)
+{
+    int     iCodePage;
+
+    // Get setloc data from per thread data struct
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    // Set downlevel setloc data in per thread data struct for use by LCID downlevel APIs
+    __crt_qualified_locale_data_downlevel downlevel_setloc;
+    __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data;
+
+    memset(&downlevel_setloc, '\0', sizeof(__crt_qualified_locale_data_downlevel));
+    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data = &downlevel_setloc;
+
+    //  initialize pointer to call locale info routine based on operating system
+
+    _psetloc_data->pchLanguage = lpInStr->szLanguage;
+
+    //  convert non-NLS country strings to three-letter abbreviations
+    _psetloc_data->pchCountry = lpInStr->szCountry;
+    if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+        TranslateName(__acrt_rg_country,
+                      static_cast<int>(__acrt_rg_country_count - 1),
+                      &_psetloc_data->pchCountry);
+
+    _psetloc_downlevel_data->iLcidState = 0;
+
+    if (_psetloc_data->pchLanguage && *_psetloc_data->pchLanguage)
+    {
+        if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+        {
+            //  both language and country strings defined
+            GetLcidFromLangCountry(_psetloc_downlevel_data);
+        }
+        else
+        {
+            //  language string defined, but country string undefined
+            GetLcidFromLanguage(_psetloc_downlevel_data);
+        }
+
+        if (!_psetloc_downlevel_data->iLcidState) {
+            //  first attempt failed, try substituting the language name
+            //  convert non-NLS language strings to three-letter abbrevs
+            if (TranslateName(__acrt_rg_language,
+                              static_cast<int>(__acrt_rg_language_count - 1),
+                              &_psetloc_data->pchLanguage))
+            {
+                if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+                {
+                    GetLcidFromLangCountry(_psetloc_downlevel_data);
+                }
+                else
+                {
+                    GetLcidFromLanguage(_psetloc_downlevel_data);
+                }
+            }
+        }
+    }
+    else
+    {
+        if (_psetloc_data->pchCountry && *_psetloc_data->pchCountry)
+        {
+            //  country string defined, but language string undefined
+            GetLcidFromCountry(_psetloc_downlevel_data);
+        }
+        else
+        {
+            //  both language and country strings undefined
+            GetLcidFromDefault(_psetloc_downlevel_data);
+        }
+    }
+
+    //  test for error in LCID processing
+    if (!_psetloc_downlevel_data->iLcidState)
+        return FALSE;
+
+    //  process codepage value
+    iCodePage = ProcessCodePage(lpInStr ? lpInStr->szCodePage: nullptr, _psetloc_downlevel_data);
+
+    //  verify codepage validity
+    if (!iCodePage || !IsValidCodePage((WORD)iCodePage))
+        return FALSE;
+
+    //  verify locale is installed
+    if (!IsValidLocale(_psetloc_downlevel_data->lcidLanguage, LCID_INSTALLED))
+        return FALSE;
+
+    //  set codepage
+    if (lpOutCodePage)
+    {
+        *lpOutCodePage = (UINT)iCodePage;
+    }
+
+    // store locale name in cache
+    __acrt_LCIDToLocaleName(
+        _psetloc_downlevel_data->lcidLanguage,
+        _psetloc_data->_cacheLocaleName,
+        (int)_countof(_psetloc_data->_cacheLocaleName),
+        0);
+
+    //  set locale name and codepage results
+    if (lpOutStr)
+    {
+        __acrt_LCIDToLocaleName(
+            _psetloc_downlevel_data->lcidLanguage,
+            lpOutStr->szLocaleName,
+            (int)_countof(lpOutStr->szLocaleName),
+            0);
+
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidLanguage, LOCALE_SENGLANGUAGE,
+                                 lpOutStr->szLanguage, MAX_LANG_LEN) == 0)
+            return FALSE;
+
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidCountry, LOCALE_SENGCOUNTRY,
+                                 lpOutStr->szCountry, MAX_CTRY_LEN) == 0)
+            return FALSE;
+
+        _itow_s((int)iCodePage, (wchar_t *)lpOutStr->szCodePage, MAX_CP_LEN, 10);
+    }
+
+    return TRUE;
+}
+
+/***
+*BOOL TranslateName - convert known non-NLS string to NLS equivalent
+*
+*Purpose:
+*   Provide compatibility with existing code for non-NLS strings
+*
+*Entry:
+*   lpTable  - pointer to __crt_locale_string_table used for translation
+*   high     - maximum index of table (size - 1)
+*   ppchName - pointer to pointer of string to translate
+*
+*Exit:
+*   ppchName - pointer to pointer of string possibly translated
+*   TRUE if string translated, FALSE if unchanged
+*
+*Exceptions:
+*
+*******************************************************************************/
+static bool TranslateName (
+    const __crt_locale_string_table* lpTable,
+    int                              high,
+    const wchar_t **                 ppchName)
+{
+    int low = 0;
+
+    //  typical binary search - do until no more to search or match
+    while (low <= high)
+    {
+        int const i = (low + high) / 2;
+        int const cmp = _wcsicmp(*ppchName, lpTable[i].szName);
+
+        if (cmp == 0)
+        {
+            *ppchName = lpTable[i].chAbbrev;
+            return true;
+        }
+        else if (cmp < 0)
+            high = i - 1;
+        else
+            low = i + 1;
+    }
+
+    return false;
+}
+
+/***
+*void GetLcidFromLangCountry - get LCIDs from language and country strings
+*
+*Purpose:
+*   Match the best LCIDs to the language and country string given.
+*   After global variables are initialized, the LangCountryEnumProc
+*   routine is registered as an EnumSystemLocalesA callback to actually
+*   perform the matching as the LCIDs are enumerated.
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   pchCountry      - country string
+*   bAbbrevCountry  - country string ia a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   lcidLanguage - LCID of language string
+*   lcidCountry  - LCID of country string
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromLangCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->bAbbrevCountry = wcslen(_psetloc_data->pchCountry) == 3;
+    _psetloc_downlevel_data->lcidLanguage = 0;
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ?
+                             2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    EnumSystemLocalesW(LangCountryEnumProc, LCID_INSTALLED);
+
+    //  locale value is invalid if the language was not installed or the language
+    //  was not available for the country specified
+    if (!(_psetloc_downlevel_data->iLcidState & __LCID_LANGUAGE) ||
+        !(_psetloc_downlevel_data->iLcidState & __LCID_EXISTS) ||
+        !(_psetloc_downlevel_data->iLcidState & (__LCID_FULL |
+                                    __LCID_PRIMARY |
+                                    __LCID_DEFAULT)))
+        _psetloc_downlevel_data->iLcidState = 0;
+}
+
+/***
+*BOOL CALLBACK LangCountryEnumProc - callback routine for GetLcidFromLangCountry
+*
+*Purpose:
+*   Determine if LCID given matches the language in pchLanguage
+*   and country in pchCountry.
+*
+*Entry:
+*   lpLcidString   - pointer to string with decimal LCID
+*   pchCountry     - pointer to country name
+*   bAbbrevCountry - set if country is three-letter abbreviation
+*
+*Exit:
+*   iLcidState   - status of match
+*       __LCID_FULL - both language and country match (best match)
+*       __LCID_PRIMARY - primary language and country match (better)
+*       __LCID_DEFAULT - default language and country match (good)
+*       __LCID_LANGUAGE - default primary language exists
+*       __LCID_EXISTS - full match of language string exists
+*       (Overall match occurs for the best of FULL/PRIMARY/DEFAULT
+*        and LANGUAGE/EXISTS both set.)
+*   lcidLanguage - LCID matched
+*   lcidCountry  - LCID matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LangCountryEnumProc (_In_z_ PWSTR lpLcidString)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    __crt_qualified_locale_data_downlevel*    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data;
+    LCID    lcid = LcidFromHexString(lpLcidString);
+    wchar_t    rgcInfo[120];
+
+    //  test locale country against input value
+    if (GetLocaleInfoW(lcid,
+                             _psetloc_data->bAbbrevCountry ?
+                             LOCALE_SABBREVCTRYNAME : LOCALE_SENGCOUNTRY,
+                             rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_downlevel_data->iLcidState = 0;
+        return TRUE;
+    }
+    if (!_wcsicmp(_psetloc_data->pchCountry, rgcInfo))
+    {
+        //  country matched - test for language match
+        if (GetLocaleInfoW(lcid,
+                                 _psetloc_data->bAbbrevLanguage ?
+                                 LOCALE_SABBREVLANGNAME : LOCALE_SENGLANGUAGE,
+                                 rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_downlevel_data->iLcidState = 0;
+            return TRUE;
+        }
+        if (!_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+        {
+            //  language matched also - set state and value
+            _psetloc_downlevel_data->iLcidState |= (__LCID_FULL |
+                                       __LCID_LANGUAGE |
+                                       __LCID_EXISTS);
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+        }
+
+        //  test if match already for primary langauage
+        else if (!(_psetloc_downlevel_data->iLcidState & __LCID_PRIMARY))
+        {
+            //  if not, use _psetloc_data->iPrimaryLen to partial match language string
+            if (_psetloc_data->iPrimaryLen && !_wcsnicmp(_psetloc_data->pchLanguage, rgcInfo, _psetloc_data->iPrimaryLen))
+            {
+                //  primary language matched - set state and country LCID
+                _psetloc_downlevel_data->iLcidState |= __LCID_PRIMARY;
+                _psetloc_downlevel_data->lcidCountry = lcid;
+
+                //  if language is primary only (no subtype), set language LCID
+                if ((int)wcslen(_psetloc_data->pchLanguage) == _psetloc_data->iPrimaryLen)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+
+            //  test if default language already defined
+            else if (!(_psetloc_downlevel_data->iLcidState & __LCID_DEFAULT))
+            {
+                //  if not, test if locale language is default for country
+                if (TestDefaultCountry(lcid))
+                {
+                    //  default language for country - set state, value
+                    _psetloc_downlevel_data->iLcidState |= __LCID_DEFAULT;
+                    _psetloc_downlevel_data->lcidCountry = lcid;
+                }
+            }
+        }
+    }
+    //  test if input language both exists and default primary language defined
+    if ((_psetloc_downlevel_data->iLcidState & (__LCID_LANGUAGE | __LCID_EXISTS)) !=
+                      (__LCID_LANGUAGE | __LCID_EXISTS))
+    {
+        //  test language match to determine whether it is installed
+        if (GetLocaleInfoW(lcid, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                       : LOCALE_SENGLANGUAGE,
+                           rgcInfo, _countof(rgcInfo)) == 0)
+        {
+            //  set error condition and exit
+            _psetloc_downlevel_data->iLcidState = 0;
+            return TRUE;
+        }
+
+        if (!_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+        {
+            //  language matched - set bit for existance
+            _psetloc_downlevel_data->iLcidState |= __LCID_EXISTS;
+
+            if (_psetloc_data->bAbbrevLanguage)
+            {
+                //  abbreviation - set state
+                //  also set language LCID if not set already
+                _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                if (!_psetloc_downlevel_data->lcidLanguage)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+
+            //  test if language is primary only (no sublanguage)
+            else if (_psetloc_data->iPrimaryLen && ((int)wcslen(_psetloc_data->pchLanguage) == _psetloc_data->iPrimaryLen))
+            {
+                //  primary language only - test if default LCID
+                if (TestDefaultLanguage(lcid, TRUE, _psetloc_downlevel_data))
+                {
+                    //  default primary language - set state
+                    //  also set LCID if not set already
+                    _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                    if (!_psetloc_downlevel_data->lcidLanguage)
+                        _psetloc_downlevel_data->lcidLanguage = lcid;
+                }
+            }
+            else
+            {
+                //  language with sublanguage - set state
+                //  also set LCID if not set already
+                _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                if (!_psetloc_downlevel_data->lcidLanguage)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+        }
+        else if (!_psetloc_data->bAbbrevLanguage && _psetloc_data->iPrimaryLen
+                               && !_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+        {
+            //  primary language match - test for default language only
+            if (TestDefaultLanguage(lcid, FALSE, _psetloc_downlevel_data))
+            {
+                //  default primary language - set state
+                //  also set LCID if not set already
+                _psetloc_downlevel_data->iLcidState |= __LCID_LANGUAGE;
+                if (!_psetloc_downlevel_data->lcidLanguage)
+                    _psetloc_downlevel_data->lcidLanguage = lcid;
+            }
+        }
+    }
+
+    //  if LOCALE_FULL set, return FALSE to stop enumeration,
+    //  else return TRUE to continue
+    return (_psetloc_downlevel_data->iLcidState & __LCID_FULL) == 0;
+}
+
+/***
+*void GetLcidFromLanguage - get LCIDs from language string
+*
+*Purpose:
+*   Match the best LCIDs to the language string given.  After global
+*   variables are initialized, the LanguageEnumProc routine is
+*   registered as an EnumSystemLocalesA callback to actually perform
+*   the matching as the LCIDs are enumerated.
+*
+*Entry:
+*   pchLanguage     - language string
+*   bAbbrevLanguage - language string is a three-letter abbreviation
+*   iPrimaryLen     - length of language string with primary name
+*
+*Exit:
+*   lcidLanguage - lcidCountry  - LCID of language with default
+*                                 country
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromLanguage (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    //  initialize static variables for callback use
+    _psetloc_data->bAbbrevLanguage = wcslen(_psetloc_data->pchLanguage) == 3;
+    _psetloc_data->iPrimaryLen = _psetloc_data->bAbbrevLanguage ? 2 : GetPrimaryLen(_psetloc_data->pchLanguage);
+
+    EnumSystemLocalesW(LanguageEnumProc, LCID_INSTALLED);
+
+    //  locale value is invalid if the language was not installed
+    //  or the language was not available for the country specified
+    if (!(_psetloc_downlevel_data->iLcidState & __LCID_FULL))
+        _psetloc_downlevel_data->iLcidState = 0;
+}
+
+/***
+*BOOL CALLBACK LanguageEnumProc - callback routine for GetLcidFromLanguage
+*
+*Purpose:
+*   Determine if LCID given matches the default country for the
+*   language in pchLanguage.
+*
+*Entry:
+*   lpLcidString    - pointer to string with decimal LCID
+*   pchLanguage     - pointer to language name
+*   bAbbrevLanguage - set if language is three-letter abbreviation
+*
+*Exit:
+*   lcidLanguage - lcidCountry - LCID matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK LanguageEnumProc (_In_z_ PWSTR lpLcidString)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    __crt_qualified_locale_data_downlevel*    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data;
+
+    LCID    lcid = LcidFromHexString(lpLcidString);
+    wchar_t    rgcInfo[120];
+
+    //  test locale for language specified
+    if (GetLocaleInfoW(lcid, _psetloc_data->bAbbrevLanguage ? LOCALE_SABBREVLANGNAME
+                                                   : LOCALE_SENGLANGUAGE,
+                       rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_downlevel_data->iLcidState = 0;
+        return TRUE;
+    }
+
+    if (!_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+    {
+        //  language matched - test if locale country is default
+        //  or if locale is implied in the language string
+        if (_psetloc_data->bAbbrevLanguage || TestDefaultLanguage(lcid, TRUE, _psetloc_downlevel_data))
+        {
+            //  this locale has the default country
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+            _psetloc_downlevel_data->iLcidState |= __LCID_FULL;
+        }
+    }
+    else if (!_psetloc_data->bAbbrevLanguage && _psetloc_data->iPrimaryLen
+                              && !_wcsicmp(_psetloc_data->pchLanguage, rgcInfo))
+    {
+        //  primary language matched - test if locale country is default
+        if (TestDefaultLanguage(lcid, FALSE, _psetloc_downlevel_data))
+        {
+            //  this is the default country
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+            _psetloc_downlevel_data->iLcidState |= __LCID_FULL;
+        }
+    }
+
+    return (_psetloc_downlevel_data->iLcidState & __LCID_FULL) == 0;
+}
+
+/***
+*void GetLcidFromCountry - get LCIDs from country string
+*
+*Purpose:
+*   Match the best LCIDs to the country string given.  After global
+*   variables are initialized, the CountryEnumProc routine is
+*   registered as an EnumSystemLocalesA callback to actually perform
+*   the matching as the LCIDs are enumerated.
+*
+*Entry:
+*   pchCountry     - country string
+*   bAbbrevCountry - country string is a three-letter abbreviation
+*
+*Exit:
+*   lcidLanguage - lcidCountry  - LCID of country with default
+*                                 language
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromCountry (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    _psetloc_data->bAbbrevCountry = wcslen(_psetloc_data->pchCountry) == 3;
+
+    EnumSystemLocalesW(CountryEnumProc, LCID_INSTALLED);
+
+    //  locale value is invalid if the country was not defined or
+    //  no default language was found
+    if (!(_psetloc_downlevel_data->iLcidState & __LCID_FULL))
+        _psetloc_downlevel_data->iLcidState = 0;
+}
+
+/***
+*BOOL CALLBACK CountryEnumProc - callback routine for GetLcidFromCountry
+*
+*Purpose:
+*   Determine if LCID given matches the default language for the
+*   country in pchCountry.
+*
+*Entry:
+*   lpLcidString   - pointer to string with decimal LCID
+*   pchCountry     - pointer to country name
+*   bAbbrevCountry - set if country is three-letter abbreviation
+*
+*Exit:
+*   lcidLanguage - lcidCountry - LCID matched
+*   FALSE if match occurred to terminate enumeration, else TRUE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL CALLBACK CountryEnumProc (_In_z_ PWSTR lpLcidString)
+{
+    __crt_qualified_locale_data*    _psetloc_data = &__acrt_getptd()->_setloc_data;
+    __crt_qualified_locale_data_downlevel*    _psetloc_downlevel_data = __acrt_getptd()->_setloc_downlevel_data;
+    LCID    lcid = LcidFromHexString(lpLcidString);
+    wchar_t    rgcInfo[120];
+
+    //  test locale for country specified
+    if (GetLocaleInfoW(lcid, _psetloc_data->bAbbrevCountry ? LOCALE_SABBREVCTRYNAME
+                                                  : LOCALE_SENGCOUNTRY,
+                       rgcInfo, _countof(rgcInfo)) == 0)
+    {
+        //  set error condition and exit
+        _psetloc_downlevel_data->iLcidState = 0;
+        return TRUE;
+    }
+    if (!_wcsicmp(_psetloc_data->pchCountry, rgcInfo))
+    {
+        //  language matched - test if locale country is default
+        if (TestDefaultCountry(lcid))
+        {
+            //  this locale has the default language
+            _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = lcid;
+            _psetloc_downlevel_data->iLcidState |= __LCID_FULL;
+        }
+    }
+    return (_psetloc_downlevel_data->iLcidState & __LCID_FULL) == 0;
+}
+
+/***
+*void GetLcidFromDefault - get default LCIDs
+*
+*Purpose:
+*   Set both language and country LCIDs to the system default.
+*
+*Entry:
+*   None.
+*
+*Exit:
+*   lcidLanguage - set to system LCID
+*   lcidCountry  - set to system LCID
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void GetLcidFromDefault (__crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    _psetloc_downlevel_data->iLcidState |= (__LCID_FULL | __LCID_LANGUAGE);
+    _psetloc_downlevel_data->lcidLanguage = _psetloc_downlevel_data->lcidCountry = GetUserDefaultLCID();
+}
+
+/***
+*int ProcessCodePage - convert codepage string to numeric value
+*
+*Purpose:
+*   Process codepage string consisting of a decimal string, or the
+*   special case strings "ACP" and "OCP", for ANSI and OEM codepages,
+*   respectively.  Null pointer or string returns the ANSI codepage.
+*
+*Entry:
+*   lpCodePageStr - pointer to codepage string
+*
+*Exit:
+*   Returns numeric value of codepage.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int ProcessCodePage (LPCWSTR lpCodePageStr, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    int iCodePage;
+
+    if (!lpCodePageStr || !*lpCodePageStr || !wcscmp(lpCodePageStr, L"ACP"))
+    {
+        //  get ANSI codepage for the country LCID
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidCountry, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+
+        if (iCodePage == 0) // for locales have no assoicated ANSI codepage, e.g. Hindi locale
+            return GetACP();
+    }
+    else if (!wcscmp(lpCodePageStr, L"OCP"))
+    {
+        //  get OEM codepage for the country LCID
+        if (GetLocaleInfoW(_psetloc_downlevel_data->lcidCountry, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
+                                 (LPWSTR) &iCodePage, sizeof(iCodePage) / sizeof(wchar_t)) == 0)
+            return 0;
+    }
+    else
+    {
+         // convert decimal string to numeric value
+         iCodePage = (int)_wtol(lpCodePageStr);
+    }
+
+    return iCodePage;
+}
+
+/***
+*BOOL TestDefaultCountry - determine if default locale for country
+*
+*Purpose:
+*   Using a hardcoded list, determine if the locale of the given LCID
+*   has the default sublanguage for the locale primary language.  The
+*   list contains the locales NOT having the default sublanguage.
+*
+*Entry:
+*   lcid - LCID of locale to test
+*
+*Exit:
+*   Returns TRUE if default sublanguage, else FALSE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultCountry (LCID lcid)
+{
+    LANGID  langid = LANGIDFROMLCID(lcid);
+    int     i;
+
+    for (i = 0; i < _countof(__rglangidNotDefault); i++)
+    {
+        if (langid == __rglangidNotDefault[i])
+            return FALSE;
+    }
+    return TRUE;
+}
+
+/***
+*BOOL TestDefaultLanguage - determine if default locale for language
+*
+*Purpose:
+*   Determines if the given LCID has the default sublanguage.
+*   If bTestPrimary is set, also allow TRUE when string contains an
+*   implicit sublanguage.
+*
+*Entry:
+*   LCID         - lcid of locale to test
+*   bTestPrimary - set if testing if language is primary
+*
+*Exit:
+*   Returns TRUE if sublanguage is default for locale tested.
+*   If bTestPrimary set, TRUE is language has implied sublanguge.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static BOOL TestDefaultLanguage (LCID lcid, BOOL bTestPrimary, __crt_qualified_locale_data_downlevel* _psetloc_downlevel_data)
+{
+    UNREFERENCED_PARAMETER(_psetloc_downlevel_data); // CRT_REFACTOR TODO
+
+    DWORD dwLanguage;
+    LCID lcidDefault = MAKELCID(MAKELANGID(PRIMARYLANGID(LANGIDFROMLCID(lcid)), SUBLANG_DEFAULT), SORT_DEFAULT);
+    __crt_qualified_locale_data* _psetloc_data = &__acrt_getptd()->_setloc_data;
+
+    if (GetLocaleInfoW(lcidDefault, LOCALE_ILANGUAGE | LOCALE_RETURN_NUMBER,
+                                          (LPWSTR) &dwLanguage, sizeof(dwLanguage) / sizeof(wchar_t)) == 0)
+        return FALSE;
+
+    if (lcid != dwLanguage)
+    {
+        //  test if string contains an implicit sublanguage by
+        //  having a character other than upper/lowercase letters.
+        if (bTestPrimary && GetPrimaryLen(_psetloc_data->pchLanguage) == (int)wcslen(_psetloc_data->pchLanguage))
+            return FALSE;
+    }
+    return TRUE;
+}
+
+/***
+*LCID LcidFromHexString - convert hex string to value for LCID
+*
+*Purpose:
+*   LCID values returned in hex ANSI strings - straight conversion
+*
+*Entry:
+*   lpHexString - pointer to hex string to convert
+*
+*Exit:
+*   Returns LCID computed.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static LCID LcidFromHexString (_In_z_ PCWSTR lpHexString)
+{
+    wchar_t    ch;
+    DWORD   lcid = 0;
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 This is an idiomatic nul termination check that Prefast doesn't understand.
+    while ((ch = *lpHexString++) != '\0')
+    {
+        if (ch >= 'a' && ch <= 'f')
+            ch += static_cast<wchar_t>('9' + 1 - 'a');
+        else if (ch >= 'A' && ch <= 'F')
+            ch += static_cast<wchar_t>('9' + 1 - 'A');
+        lcid = lcid * 0x10 + ch - '0';
+    }
+
+    return (LCID)lcid;
+}
+
+/***
+*int GetPrimaryLen - get length of primary language name
+*
+*Purpose:
+*   Determine primary language string length by scanning until
+*   first non-alphabetic character.
+*
+*Entry:
+*   pchLanguage - string to scan
+*
+*Exit:
+*   Returns length of primary language string.
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int GetPrimaryLen (wchar_t const* pchLanguage)
+{
+    int     len = 0;
+    wchar_t    ch;
+
+    ch = *pchLanguage++;
+    while ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
+    {
+        len++;
+        ch = *pchLanguage++;
+    }
+
+    return len;
+}
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/glstatus.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/glstatus.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c670ad20182127ca734b25a23428e695c4434ef6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/glstatus.cpp	
@@ -0,0 +1,13 @@
+/***
+*glstatus.c - sets the __globallocalestatus flag
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Sets the __globallocalestatus flag to disable per thread locale
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+
+extern "C" int __globallocalestatus = (~_GLOBAL_LOCALE_BIT);
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6e77998d7b6dd6f8e9517ca1cb65bebfbafbcff
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initctype.cpp	
@@ -0,0 +1,339 @@
+/***
+*initctype.cpp - contains __acrt_locale_initialize_ctype
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the locale-category initialization function: __acrt_locale_initialize_ctype().
+*
+*       Each initialization function sets up locale-specific information
+*       for their category, for use by functions which are affected by
+*       their locale category.
+*
+*       *** For internal use by setlocale() only ***
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+#define _CTABSIZE   257     /* size of ctype tables */
+
+// Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+/***
+*int __acrt_locale_initialize_ctype() - initialization for LC_CTYPE locale category.
+*
+*Purpose:
+*       In non-C locales, preread ctype tables for chars and wide-chars.
+*       Old tables are freed when new tables are fully established, else
+*       the old tables remain intact (as if original state unaltered).
+*       The leadbyte table is implemented as the high bit in ctype1.
+*
+*       In the C locale, ctype tables are freed, and pointers point to
+*       the static ctype table.
+*
+*       Tables contain 257 entries: -1 to 256.
+*       Table pointers point to entry 0 (to allow index -1).
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       0 success
+*       1 fail
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl __acrt_locale_initialize_ctype (
+        __crt_locale_data* ploci
+        )
+{
+    /* non-C locale table for char's */
+    unsigned short *newctype1 = nullptr;          /* temp new table */
+    unsigned char *newclmap = nullptr;            /* temp new map table */
+    unsigned char *newcumap = nullptr;            /* temp new map table */
+
+    /* non-C locale table for wchar_t's */
+
+    unsigned char *cbuffer = nullptr;      /* char working buffer */
+
+    int i;                              /* general purpose counter */
+    unsigned char *cp;                  /* char pointer */
+    CPINFO cpInfo;                      /* struct for use with GetCPInfo */
+    int mb_cur_max;
+    __crt_locale_pointers locinfo;
+
+    locinfo.locinfo = ploci;
+    locinfo.mbcinfo = 0;
+
+    /* allocate and set up buffers before destroying old ones */
+    /* codepage will be restored by setlocale if error */
+
+    if (ploci->locale_name[LC_CTYPE] != nullptr)
+    {
+        long* refcount = nullptr;
+
+        if (ploci->_public._locale_lc_codepage == 0)
+        { /* code page was not specified */
+            if ( __acrt_GetLocaleInfoA( &locinfo, LC_INT_TYPE,
+                                  ploci->locale_name[LC_CTYPE],
+                                  LOCALE_IDEFAULTANSICODEPAGE,
+                                  (char **)&ploci->_public._locale_lc_codepage ) )
+                goto error_cleanup;
+        }
+
+        /* allocate a new (thread) reference counter */
+        refcount = _calloc_crt_t(long, 1).detach();
+
+        /* allocate new buffers for tables */
+        newctype1 = _calloc_crt_t(unsigned short, _COFFSET + _CTABSIZE).detach();
+        newclmap  = _calloc_crt_t(unsigned char,  _COFFSET + _CTABSIZE).detach();
+        newcumap  = _calloc_crt_t(unsigned char,  _COFFSET + _CTABSIZE).detach();
+        cbuffer   = _calloc_crt_t(unsigned char,  _CTABSIZE).detach();
+
+        if (!refcount || !newctype1 || !cbuffer || !newclmap || !newcumap)
+            goto error_cleanup;
+
+        /* construct string composed of first 256 chars in sequence */
+        for (cp=cbuffer, i=0; i<_CTABSIZE-1; i++)
+            *cp++ = (unsigned char)i;
+
+        if (GetCPInfo( ploci->_public._locale_lc_codepage, &cpInfo) == FALSE)
+            goto error_cleanup;
+
+        if (cpInfo.MaxCharSize > MB_LEN_MAX)
+            goto error_cleanup;
+
+        mb_cur_max = (unsigned short) cpInfo.MaxCharSize;
+
+        /* zero (space actually) out leadbytes so GetStringType and
+           LCMapStringA don't interpret them as multi-byte chars */
+        if (mb_cur_max > 1)
+        {
+            if (ploci->_public._locale_lc_codepage == CP_UTF8)
+            {
+                // For UTF-8 anything above 0x7f is part of a multibyte sequence and
+                // would confuse the codepage/character code below.
+                for (i = 0x80; i <= 0xff; i++)
+                {
+                    // spaces are safe.
+                    cbuffer[i] = ' ';
+                }
+            }
+            else
+            {
+                // use the lead byte table to mark off the appropriate bytes
+                for (cp = (unsigned char *)cpInfo.LeadByte; cp[0] && cp[1]; cp += 2)
+                {
+                    for (i = cp[0]; i <= cp[1]; i++)
+                        cbuffer[i] = ' ';
+                }
+            }
+        }
+
+        /*
+         * LCMapString will map past nullptr. Must find nullptr if in string
+         * before cchSrc characters.
+         */
+        if ( __acrt_LCMapStringA(nullptr,
+                    ploci->locale_name[LC_CTYPE],
+                    LCMAP_LOWERCASE,
+                    reinterpret_cast<char*>(cbuffer + 1),
+                    _CTABSIZE-2,
+                    reinterpret_cast<char*>(newclmap + 2 + _COFFSET),
+                    _CTABSIZE-2,
+                    ploci->_public._locale_lc_codepage,
+                    FALSE ) == FALSE)
+            goto error_cleanup;
+
+        if ( __acrt_LCMapStringA(nullptr,
+                    ploci->locale_name[LC_CTYPE],
+                    LCMAP_UPPERCASE,
+                    reinterpret_cast<char*>(cbuffer + 1),
+                    _CTABSIZE-2,
+                    reinterpret_cast<char*>(newcumap + 2 + _COFFSET),
+                    _CTABSIZE-2,
+                    ploci->_public._locale_lc_codepage,
+                    FALSE ) == FALSE)
+            goto error_cleanup;
+
+        /* convert to newctype1 table - ignore invalid char errors */
+        if ( __acrt_GetStringTypeA(nullptr,  CT_CTYPE1,
+                                  reinterpret_cast<char*>(cbuffer),
+                                  _CTABSIZE-1,
+                                  newctype1+1+_COFFSET,
+                                  ploci->_public._locale_lc_codepage,
+                                  FALSE ) == FALSE )
+            goto error_cleanup;
+
+        newctype1[_COFFSET] = 0; /* entry for EOF */
+        newclmap[_COFFSET] = 0;
+        newcumap[_COFFSET] = 0;
+        newclmap[_COFFSET+1] = 0; /* entry for null */
+        newcumap[_COFFSET+1] = 0; /* entry for null */
+
+        /* ignore DefaultChar */
+
+        /* mark lead-byte entries in newctype1 table and
+           restore original values for lead-byte entries for clmap/cumap */
+        if (mb_cur_max > 1)
+        {
+            if (ploci->_public._locale_lc_codepage == CP_UTF8)
+            {
+                // For UTF-8 anything above 0x7f is part of a multibyte sequence
+                // "real" leadbytes start with C0 and end at F7
+                // However, C0 & C1 are overlong encoded ASCII, F5 & F6 would be > U+10FFFF.
+                // Note that some starting with E0 and F0 are overlong and not legal though.
+                for (i = 0x80; i <= 0xff; i++)
+                {
+                    newctype1[_COFFSET + i + 1] = (i >= 0xc2 && i < 0xf5) ? _LEADBYTE : 0;
+                    newclmap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                    newcumap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                }
+            }
+            else
+            {
+                for (cp = (unsigned char *)cpInfo.LeadByte; cp[0] && cp[1]; cp += 2)
+                {
+                    for (i = cp[0]; i <= cp[1]; i++)
+                    {
+                        newctype1[_COFFSET + i + 1] = _LEADBYTE;
+                        newclmap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                        newcumap[_COFFSET + i + 1] = static_cast<unsigned char>(i);
+                    }
+                }
+            }
+        }
+        /* copy last-1 _COFFSET unsigned short to front
+         * note -1, we don't really want to copy 0xff
+         */
+        memcpy(newctype1,newctype1+_CTABSIZE-1,_COFFSET*sizeof(unsigned short));
+        memcpy(newclmap,newclmap+_CTABSIZE-1,_COFFSET*sizeof(char));
+        memcpy(newcumap,newcumap+_CTABSIZE-1,_COFFSET*sizeof(char));
+
+        /* free old tables */
+        if ((ploci->ctype1_refcount) &&
+            (InterlockedDecrement(ploci->ctype1_refcount) == 0))
+        {
+            _ASSERT(0);
+            _free_crt(ploci->ctype1 - _COFFSET);
+            _free_crt((char *)(ploci->pclmap - _COFFSET - 1));
+            _free_crt((char *)(ploci->pcumap - _COFFSET - 1));
+            _free_crt(ploci->ctype1_refcount);
+        }
+        (*refcount) = 1;
+        ploci->ctype1_refcount = refcount;
+        /* set pointers to point to entry 0 of tables */
+        ploci->_public._locale_pctype     = newctype1 + 1 + _COFFSET;
+        ploci->ctype1                     = newctype1 +     _COFFSET;
+        ploci->pclmap                     = newclmap  + 1 + _COFFSET;
+        ploci->pcumap                     = newcumap  + 1 + _COFFSET;
+        ploci->_public._locale_mb_cur_max = mb_cur_max;
+
+        /* cleanup and return success */
+        _free_crt (cbuffer);
+        return 0;
+
+error_cleanup:
+        _free_crt (refcount);
+        _free_crt (newctype1);
+        _free_crt (newclmap);
+        _free_crt (newcumap);
+        _free_crt (cbuffer);
+        return 1;
+
+    } else {
+
+        if ( (ploci->ctype1_refcount != nullptr)&&
+             (InterlockedDecrement(ploci->ctype1_refcount) == 0))
+        {
+            _ASSERTE(ploci->ctype1_refcount > 0);
+        }
+        ploci->ctype1_refcount        = nullptr;
+        ploci->ctype1                 = nullptr;
+        ploci->_public._locale_pctype = __newctype + 1 + _COFFSET;
+        ploci->pclmap                 = __newclmap + 1 + _COFFSET;
+        ploci->pcumap                 = __newcumap + 1 + _COFFSET;
+        ploci->_public._locale_mb_cur_max = 1;
+
+        return 0;
+    }
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/* Define a number of functions which exist so, under _STATIC_CPPLIB, the
+ * static multithread C++ Library libcpmt.lib can access data found in the
+ * main CRT DLL without using __declspec(dllimport).
+ */
+
+int __cdecl ___mb_cur_max_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->_public._locale_mb_cur_max;
+}
+
+int __cdecl ___mb_cur_max_l_func(_locale_t locale)
+{
+    return locale == nullptr
+        ? ___mb_cur_max_func()
+        : locale->locinfo->_public._locale_mb_cur_max;
+}
+
+unsigned int __cdecl ___lc_codepage_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->_public._locale_lc_codepage;
+}
+
+unsigned int __cdecl ___lc_collate_cp_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->lc_collate_cp;
+}
+
+wchar_t** __cdecl ___lc_locale_name_func()
+{
+    /*
+     * Note that we don't need _LocaleUpdate in this function.
+     * The main reason being, that this is a leaf function in
+     * locale usage terms.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* ptloci = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &ptloci);
+
+    return ptloci->locale_name;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initmon.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initmon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24811946b5b21244b67ccee6b5c6488ecb6b69f1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initmon.cpp	
@@ -0,0 +1,312 @@
+/***
+*initmon.c - contains __acrt_locale_initialize_monetary
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the locale-category initialization function: __acrt_locale_initialize_monetary().
+*
+*       Each initialization function sets up locale-specific information
+*       for their category, for use by functions which are affected by
+*       their locale category.
+*
+*       *** For internal use by setlocale() only ***
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+
+extern "C" {
+
+
+    // Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+static void fix_grouping(_Inout_z_ char *);
+
+/*
+ *  Note that __acrt_lconv_c is used when the monetary category is in the C locale
+ *  but the numeric category may not necessarily be in the C locale.
+ */
+
+
+/***
+*int __acrt_locale_initialize_monetary() - initialization for LC_MONETARY locale category.
+*
+*Purpose:
+*       In non-C locales, read the localized monetary strings into
+*       __acrt_lconv_intl, and also copy the numeric strings from __acrt_lconv into
+*       __acrt_lconv_intl.  Set __acrt_lconv to point to __acrt_lconv_intl.  The old
+*       __acrt_lconv_intl is not freed until the new one is fully established.
+*
+*       In the C locale, the monetary fields in lconv are filled with
+*       contain C locale values.  Any allocated __acrt_lconv_intl fields are freed.
+*
+*       At startup, __acrt_lconv points to a static lconv structure containing
+*       C locale strings.  This structure is never used again if
+*       __acrt_locale_initialize_monetary is called.
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       0 success
+*       1 fail
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl __acrt_locale_initialize_monetary (
+        __crt_locale_data* ploci
+        )
+{
+    struct lconv *lc;
+    int ret;
+    wchar_t* ctrylocalename;
+    long *lc_refcount;
+    long *lconv_mon_refcount = nullptr;
+    __crt_locale_pointers locinfo;
+
+    locinfo.locinfo = ploci;
+    locinfo.mbcinfo = 0;
+
+    if ( (ploci->locale_name[LC_MONETARY] != nullptr) ||
+         (ploci->locale_name[LC_NUMERIC] != nullptr) )
+    {
+        /*
+         * Allocate structure filled with nullptr pointers
+         */
+        if ((lc = _calloc_crt_t(lconv, 1).detach()) == nullptr)
+            return 1;
+
+        /*
+         * Allocate a new reference counter for the lconv structure
+         */
+        if ( (lc_refcount = _calloc_crt_t(long, 1).detach()) == nullptr )
+        {
+            _free_crt(lc);
+            return 1;
+        }
+
+        if ( ploci->locale_name[LC_MONETARY] != nullptr )
+        {
+            /*
+             * Allocate a new reference counter for the numeric info
+             */
+            if ( (lconv_mon_refcount = _calloc_crt_t(long, 1).detach()) == nullptr )
+            {
+                _free_crt(lc);
+                _free_crt(lc_refcount);
+                return 1;
+            }
+
+            /*
+             * Currency is country--not language--dependent. NT
+             * work-around.
+             */
+            ctrylocalename = ploci->locale_name[LC_MONETARY];
+
+            ret = 0;
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SINTLSYMBOL, (void *)&lc->int_curr_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SCURRENCY, (void *)&lc->currency_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SMONDECIMALSEP, (void *)&lc->mon_decimal_point );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SMONTHOUSANDSEP, (void *)&lc->mon_thousands_sep );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SMONGROUPING, (void *)&lc->mon_grouping );
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SPOSITIVESIGN, (void *)&lc->positive_sign);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename,
+                    LOCALE_SNEGATIVESIGN, (void *)&lc->negative_sign);
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IINTLCURRDIGITS, (void *)&lc->int_frac_digits);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_ICURRDIGITS, (void *)&lc->frac_digits);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IPOSSYMPRECEDES, (void *)&lc->p_cs_precedes);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IPOSSEPBYSPACE, (void *)&lc->p_sep_by_space);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_INEGSYMPRECEDES, (void *)&lc->n_cs_precedes);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_INEGSEPBYSPACE, (void *)&lc->n_sep_by_space);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_IPOSSIGNPOSN, (void *)&lc->p_sign_posn);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, ctrylocalename,
+                    LOCALE_INEGSIGNPOSN, (void *)&lc->n_sign_posn);
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SINTLSYMBOL, (void *)&lc->_W_int_curr_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SCURRENCY, (void *)&lc->_W_currency_symbol );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SMONDECIMALSEP, (void *)&lc->_W_mon_decimal_point );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SMONTHOUSANDSEP, (void *)&lc->_W_mon_thousands_sep );
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SPOSITIVESIGN, (void *)&lc->_W_positive_sign);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename,
+                    LOCALE_SNEGATIVESIGN, (void *)&lc->_W_negative_sign);
+
+            if ( ret != 0 ) {
+                __acrt_locale_free_monetary(lc);
+                _free_crt(lc);
+                _free_crt(lc_refcount);
+                _free_crt(lconv_mon_refcount);
+                return 1;
+            }
+
+            fix_grouping(lc->mon_grouping);
+        }
+        else {
+            /*
+             * C locale for monetary category (the numeric category fields,
+             * which are NOT of the C locale, get fixed up below). Note
+             * that __acrt_lconv_c is copied, rather than directly assigning
+             * the fields of lc because of the uncertainty of the values of
+             * the int_frac_digits,..., n_sign_posn fields (SCHAR_MAX or
+             * UCHAR_MAX, depending on whether or a compliand was built
+             * with -J.
+             */
+            *lc = __acrt_lconv_c;
+        }
+
+        /*
+         * Copy the numeric locale fields from the old struct
+         */
+        lc->decimal_point = ploci->lconv->decimal_point;
+        lc->thousands_sep = ploci->lconv->thousands_sep;
+        lc->grouping = ploci->lconv->grouping;
+        lc->_W_decimal_point = ploci->lconv->_W_decimal_point;
+        lc->_W_thousands_sep = ploci->lconv->_W_thousands_sep;
+
+        *lc_refcount = 1;
+        if (lconv_mon_refcount)
+            *lconv_mon_refcount = 1;
+    }
+    else {
+        /*
+         * C locale for BOTH monetary and numeric categories.
+         */
+        lconv_mon_refcount = nullptr;
+        lc_refcount = nullptr;
+        lc = &__acrt_lconv_c;           /* point to new one */
+
+    }
+
+    if ( (ploci->lconv_mon_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_mon_refcount) == 0))
+    {
+        _ASSERTE(ploci->lconv_mon_refcount > 0);
+    }
+    if ( (ploci->lconv_intl_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_intl_refcount) == 0))
+    {
+        _free_crt(ploci->lconv);
+        _free_crt(ploci->lconv_intl_refcount);
+    }
+    ploci->lconv_mon_refcount = lconv_mon_refcount;
+    ploci->lconv_intl_refcount = lc_refcount;
+    ploci->lconv = lc;                       /* point to new one */
+
+    return 0;
+}
+
+static void fix_grouping(
+        char *grouping
+        )
+{
+    /*
+     * ANSI specifies that the fields should contain "\3" [\3\0] to indicate
+     * thousands groupings (100,000,000.00 for example).
+     * NT uses "3;0"; ASCII 3 instead of value 3 and the ';' is extra.
+     * So here we convert the NT version to the ANSI version.
+     */
+
+    while (*grouping)
+    {
+        /* convert '3' to '\3' */
+        if (*grouping >= '0' && *grouping <= '9')
+        {
+            *grouping = *grouping - '0';
+            grouping++;
+        }
+
+        /* remove ';' */
+        else if (*grouping == ';')
+        {
+            char *tmp = grouping;
+
+            do
+                *tmp = *(tmp+1);
+            while (*++tmp);
+        }
+
+        /* unknown (illegal) character, ignore */
+        else
+            grouping++;
+    }
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/*
+ *  Free the lconv monetary strings.
+ *  Numeric values do not need to be freed.
+ */
+void __cdecl __acrt_locale_free_monetary(lconv* l)
+{
+    if (l == nullptr)
+        return;
+
+    if ( l->int_curr_symbol != __acrt_lconv_c.int_curr_symbol )
+        _free_crt(l->int_curr_symbol);
+
+    if ( l->currency_symbol != __acrt_lconv_c.currency_symbol )
+        _free_crt(l->currency_symbol);
+
+    if ( l->mon_decimal_point != __acrt_lconv_c.mon_decimal_point )
+        _free_crt(l->mon_decimal_point);
+
+    if ( l->mon_thousands_sep != __acrt_lconv_c.mon_thousands_sep )
+        _free_crt(l->mon_thousands_sep);
+
+    if ( l->mon_grouping != __acrt_lconv_c.mon_grouping )
+        _free_crt(l->mon_grouping);
+
+    if ( l->positive_sign != __acrt_lconv_c.positive_sign )
+        _free_crt(l->positive_sign);
+
+    if ( l->negative_sign != __acrt_lconv_c.negative_sign )
+        _free_crt(l->negative_sign);
+
+    if ( l->_W_int_curr_symbol != __acrt_lconv_c._W_int_curr_symbol )
+        _free_crt(l->_W_int_curr_symbol);
+
+    if ( l->_W_currency_symbol != __acrt_lconv_c._W_currency_symbol )
+        _free_crt(l->_W_currency_symbol);
+
+    if ( l->_W_mon_decimal_point != __acrt_lconv_c._W_mon_decimal_point )
+        _free_crt(l->_W_mon_decimal_point);
+
+    if ( l->_W_mon_thousands_sep != __acrt_lconv_c._W_mon_thousands_sep )
+        _free_crt(l->_W_mon_thousands_sep);
+
+    if ( l->_W_positive_sign != __acrt_lconv_c._W_positive_sign )
+        _free_crt(l->_W_positive_sign);
+
+    if ( l->_W_negative_sign != __acrt_lconv_c._W_negative_sign )
+        _free_crt(l->_W_negative_sign);
+}
+
+
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initnum.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initnum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..087beb544c556a403659b1e7bbbef0f0ca9d2504
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/initnum.cpp	
@@ -0,0 +1,235 @@
+/***
+*initnum.c - contains __acrt_locale_initialize_numeric
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the locale-category initialization function: __acrt_locale_initialize_numeric().
+*
+*       Each initialization function sets up locale-specific information
+*       for their category, for use by functions which are affected by
+*       their locale category.
+*
+*       *** For internal use by setlocale() only ***
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+
+extern "C" {
+
+    // Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+static void fix_grouping(
+        _Inout_z_   char *  grouping
+        )
+{
+    /*
+     * ANSI specifies that the fields should contain "\3" [\3\0] to indicate
+     * thousands groupings (100,000,000.00 for example).
+     * NT uses "3;0"; ASCII 3 instead of value 3 and the ';' is extra.
+     * So here we convert the NT version to the ANSI version.
+     */
+
+    while (*grouping)
+    {
+        /* convert '3' to '\3' */
+        if (*grouping >= '0' && *grouping <= '9')
+        {
+            *grouping = *grouping - '0';
+            grouping++;
+        }
+
+        /* remove ';' */
+        else if (*grouping == ';')
+        {
+            char *tmp = grouping;
+
+            do
+                *tmp = *(tmp+1);
+            while (*++tmp);
+        }
+
+        /* unknown (illegal) character, ignore */
+        else
+            grouping++;
+    }
+}
+
+/***
+*int __acrt_locale_initialize_numeric() - initialization for LC_NUMERIC locale category.
+*
+*Purpose:
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       0 success
+*       1 fail
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl __acrt_locale_initialize_numeric (
+        __crt_locale_data* ploci
+        )
+{
+    struct lconv *lc;
+    int ret = 0;
+    wchar_t* ctrylocalename;
+    long *lc_refcount;
+    long *lconv_num_refcount = nullptr;
+    __crt_locale_pointers locinfo;
+
+    locinfo.locinfo = ploci;
+    locinfo.mbcinfo = 0;
+
+    if ( (ploci->locale_name[LC_NUMERIC] != nullptr) ||
+         (ploci->locale_name[LC_MONETARY] != nullptr) )
+    {
+        /*
+         * Allocate structure filled with nullptr pointers
+         */
+        if ( (lc = (struct lconv *)_calloc_crt(1, sizeof(struct lconv)))
+             == nullptr )
+            return 1;
+
+        /*
+         * Copy over all fields (esp., the monetary category)
+         */
+        *lc = *ploci->lconv;
+
+        /*
+         * Allocate a new reference counter for the lconv structure
+         */
+        if ( (lc_refcount = _malloc_crt_t(long, 1).detach()) == nullptr )
+        {
+            _free_crt(lc);
+            return 1;
+        }
+        *lc_refcount = 0;
+
+        if ( ploci->locale_name[LC_NUMERIC] != nullptr )
+        {
+            /*
+             * Allocate a new reference counter for the numeric info
+             */
+            if ( (lconv_num_refcount = _malloc_crt_t(long, 1).detach()) == nullptr )
+            {
+                _free_crt(lc);
+                _free_crt(lc_refcount);
+                return 1;
+            }
+            *lconv_num_refcount = 0;
+
+            /*
+             * Numeric data is country--not language--dependent.
+             */
+            ctrylocalename = ploci->locale_name[LC_NUMERIC];
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename, LOCALE_SDECIMAL,
+                    (void *)&lc->decimal_point);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename, LOCALE_STHOUSAND,
+                    (void *)&lc->thousands_sep);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, ctrylocalename, LOCALE_SGROUPING,
+                    (void *)&lc->grouping);
+
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename, LOCALE_SDECIMAL,
+                    (void *)&lc->_W_decimal_point);
+            ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, ctrylocalename, LOCALE_STHOUSAND,
+                    (void *)&lc->_W_thousands_sep);
+
+            if (ret) {
+                    /* Clean up before returning failure */
+                    __acrt_locale_free_numeric(lc);
+                    _free_crt(lc);
+                    _free_crt(lconv_num_refcount);
+                    _free_crt(lc_refcount);
+                    return -1;
+            }
+
+            fix_grouping(lc->grouping);
+        }
+        else {
+            /*
+             * C locale for just the numeric category.
+             */
+            /*
+             * nullptr out the reference count pointer
+             */
+            lconv_num_refcount = nullptr;
+            lc->decimal_point = __acrt_lconv_c.decimal_point;
+            lc->thousands_sep = __acrt_lconv_c.thousands_sep;
+            lc->grouping = __acrt_lconv_c.grouping;
+            lc->_W_decimal_point = __acrt_lconv_c._W_decimal_point;
+            lc->_W_thousands_sep = __acrt_lconv_c._W_thousands_sep;
+        }
+        (*lc_refcount) = 1;
+        if (lconv_num_refcount)
+            (*lconv_num_refcount) = 1;
+    }
+
+    else {
+        /*
+         * C locale for BOTH numeric and monetary categories.
+         */
+        lconv_num_refcount = nullptr;
+        lc_refcount = nullptr;
+        lc = &__acrt_lconv_c;           /* point to new one */
+    }
+    /*
+     * If this is part of LC_ALL, then we need to free the old ploci->lconv
+     * set up in init_monetary() before this.
+     */
+    if ( (ploci->lconv_num_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_num_refcount) == 0))
+    {
+        _ASSERTE(ploci->lconv_num_refcount > 0);
+    }
+    if ( (ploci->lconv_intl_refcount != nullptr) &&
+         (InterlockedDecrement(ploci->lconv_intl_refcount) == 0))
+    {
+        _free_crt(ploci->lconv_intl_refcount);
+        _free_crt(ploci->lconv);
+    }
+
+    ploci->lconv_num_refcount = lconv_num_refcount;
+    ploci->lconv_intl_refcount = lc_refcount;
+
+    ploci->lconv = lc;
+    return 0;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/*
+ *  Free the lconv numeric strings.
+ *  Numeric values do not need to be freed.
+ */
+void __cdecl __acrt_locale_free_numeric(lconv* l)
+{
+    if (l == nullptr)
+        return;
+
+    if ( l->decimal_point != __acrt_lconv_c.decimal_point )
+        _free_crt(l->decimal_point);
+
+    if ( l->thousands_sep != __acrt_lconv_c.thousands_sep )
+        _free_crt(l->thousands_sep);
+
+    if ( l->grouping != __acrt_lconv_c.grouping )
+        _free_crt(l->grouping);
+
+    if ( l->_W_decimal_point != __acrt_lconv_c._W_decimal_point )
+        _free_crt(l->_W_decimal_point);
+
+    if ( l->_W_thousands_sep != __acrt_lconv_c._W_thousands_sep )
+        _free_crt(l->_W_thousands_sep);
+}
+
+
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/inittime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/inittime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2cce22dfe0b2d794e302ce9295ccc7211c2aaea
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/inittime.cpp	
@@ -0,0 +1,177 @@
+//
+// inittime.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functionality for initializing and destroying LC_TIME category data structures
+//
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+
+// Enclaves have no ability to create new locales.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+_Success_(return != false)
+static bool __cdecl initialize_lc_time(
+    _Inout_ __crt_lc_time_data* const lc_time,
+    _In_    __crt_locale_data*  const locale_data
+    ) throw()
+{
+    wchar_t const* const locale_name = locale_data->locale_name[LC_TIME];
+
+    __crt_locale_pointers locinfo = { locale_data, nullptr };
+
+    lc_time->_W_ww_locale_name = __acrt_copy_locale_name(locale_name);
+
+    int ret = 0;
+
+    // The days of the week.  Note that the OS days are numbered 1-7, starting
+    // with Monday, whereas the lc_time days are numbered (indexed, really) 0-6
+    // starting with Sunday (thus the adjustment to the index in the loop).
+    for (unsigned int i = 0; i != 7; ++i)
+    {
+        unsigned int const result_index = (i + 1) % 7;
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SABBREVDAYNAME1 + i, &lc_time->wday_abbr[result_index]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SDAYNAME1       + i, &lc_time->wday     [result_index]);
+
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SABBREVDAYNAME1 + i, &lc_time->_W_wday_abbr[result_index]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SDAYNAME1       + i, &lc_time->_W_wday     [result_index]);
+    }
+
+    // The months of the year
+    for (unsigned int i = 0; i != 12; ++i)
+    {
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE,  locale_name, LOCALE_SABBREVMONTHNAME1 + i, &lc_time->month_abbr[i]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE,  locale_name, LOCALE_SMONTHNAME1       + i, &lc_time->month     [i]);
+
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SABBREVMONTHNAME1 + i, &lc_time->_W_month_abbr[i]);
+        ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SMONTHNAME1       + i, &lc_time->_W_month     [i]);
+    }
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_S1159, &lc_time->ampm[0]);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_S2359, &lc_time->ampm[1]);
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_S1159, &lc_time->_W_ampm[0]);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_S2359, &lc_time->_W_ampm[1]);
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SSHORTDATE,    &lc_time->ww_sdatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_SLONGDATE,     &lc_time->ww_ldatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_STR_TYPE, locale_name, LOCALE_STIMEFORMAT,   &lc_time->ww_timefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_INT_TYPE, locale_name, LOCALE_ICALENDARTYPE, &lc_time->ww_caltype);
+
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SSHORTDATE,  &lc_time->_W_ww_sdatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_SLONGDATE,   &lc_time->_W_ww_ldatefmt);
+    ret |= __acrt_GetLocaleInfoA(&locinfo, LC_WSTR_TYPE, locale_name, LOCALE_STIMEFORMAT, &lc_time->_W_ww_timefmt);
+
+    return ret == 0;
+}
+
+
+
+_Success_(return != nullptr)
+static __crt_lc_time_data const* __cdecl get_or_create_lc_time(
+    _In_ __crt_locale_data* const locale_data
+    ) throw()
+{
+    // C Locale
+    if (!locale_data->locale_name[LC_TIME])
+    {
+        return &__lc_time_c;
+    }
+
+    // Non-C Locale
+    __crt_unique_heap_ptr<__crt_lc_time_data> lc_time = _calloc_crt_t(__crt_lc_time_data, 1);
+    if (!lc_time)
+    {
+        return nullptr;
+    }
+
+    if (!initialize_lc_time(lc_time.get(), locale_data))
+    {
+        __acrt_locale_free_time(lc_time.get());
+        return nullptr;
+    }
+
+    lc_time.get()->refcount = 1;
+
+    return lc_time.detach();
+}
+
+
+
+extern "C" int __cdecl __acrt_locale_initialize_time(
+    __crt_locale_data* const locale_data
+    )
+{
+    __crt_lc_time_data const* const lc_time = get_or_create_lc_time(locale_data);
+    if (!lc_time)
+    {
+        return 1;
+    }
+
+    if (__acrt_locale_release_lc_time_reference(locale_data->lc_time_curr) == 0)
+    {
+        _ASSERTE(("lc_time_curr unexpectedly has no remaining references", 0));
+    }
+
+    locale_data->lc_time_curr = lc_time;
+    return 0;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+
+static void __cdecl free_crt_array_internal(
+    _Inout_updates_(array_count) void const** const array,
+    _In_                         size_t       const array_count
+    ) throw()
+{
+    for (void const* const* it = array; it != array + array_count; ++it)
+    {
+        _free_crt(const_cast<void*>(*it));
+    }
+}
+
+
+
+template <typename T, size_t N>
+static void __cdecl free_crt_array(_Inout_ T* (&array)[N]) throw()
+{
+    return free_crt_array_internal(const_cast<void const**>(reinterpret_cast<void const* const*>(array)), N);
+}
+
+
+
+extern "C" void __cdecl __acrt_locale_free_time(
+    __crt_lc_time_data* const lc_time
+    )
+{
+    if (!lc_time)
+    {
+        return;
+    }
+
+    free_crt_array(lc_time->wday_abbr);
+    free_crt_array(lc_time->wday);
+    free_crt_array(lc_time->month_abbr);
+    free_crt_array(lc_time->month);
+    free_crt_array(lc_time->ampm);
+
+    _free_crt(lc_time->ww_sdatefmt);
+    _free_crt(lc_time->ww_ldatefmt);
+    _free_crt(lc_time->ww_timefmt);
+
+    free_crt_array(lc_time->_W_wday_abbr);
+    free_crt_array(lc_time->_W_wday);
+    free_crt_array(lc_time->_W_month_abbr);
+    free_crt_array(lc_time->_W_month);
+    free_crt_array(lc_time->_W_ampm);
+
+    _free_crt(lc_time->_W_ww_sdatefmt);
+    _free_crt(lc_time->_W_ww_ldatefmt);
+    _free_crt(lc_time->_W_ww_timefmt);
+
+    _free_crt(lc_time->_W_ww_locale_name);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lcidtoname_downlevel.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lcidtoname_downlevel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e274f0ba902fe55beb2cdb9dad7eaee382196cd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lcidtoname_downlevel.cpp	
@@ -0,0 +1,604 @@
+//
+// lcidtoname_downlevel.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of wrappers for the Windows XP API functions that are not available on
+// all supported operating system versions.
+//
+
+#include <corecrt_internal.h>
+
+namespace {
+
+// Map of LCID to locale name.
+struct LcidToLocaleName
+{
+    LCID      lcid;
+    wchar_t*  localeName;
+};
+
+// Map of locale name to an index.
+struct LocaleNameIndex
+{
+    wchar_t*  name;
+    int       index;
+};
+
+// Map of LCID to locale name for Windows XP.
+// Data in this table has been obtained from National Language Support (NLS) API Reference at
+// http://msdn.microsoft.com/en-us/goglobal/bb896001.aspx
+// The table is sorted to improve search performance.
+static const LcidToLocaleName LcidToLocaleNameTable[] =
+{
+    { 0x0001, L"ar"         },
+    { 0x0002, L"bg"         },
+    { 0x0003, L"ca"         },
+    { 0x0004, L"zh-CHS"     },
+    { 0x0005, L"cs"         },
+    { 0x0006, L"da"         },
+    { 0x0007, L"de"         },
+    { 0x0008, L"el"         },
+    { 0x0009, L"en"         },
+    { 0x000A, L"es"         },
+    { 0x000B, L"fi"         },
+    { 0x000C, L"fr"         },
+    { 0x000D, L"he"         },
+    { 0x000E, L"hu"         },
+    { 0x000F, L"is"         },
+    { 0x0010, L"it"         },
+    { 0x0011, L"ja"         },
+    { 0x0012, L"ko"         },
+    { 0x0013, L"nl"         },
+    { 0x0014, L"no"         },
+    { 0x0015, L"pl"         },
+    { 0x0016, L"pt"         },
+    { 0x0018, L"ro"         },
+    { 0x0019, L"ru"         },
+    { 0x001A, L"hr"         },
+    { 0x001B, L"sk"         },
+    { 0x001C, L"sq"         },
+    { 0x001D, L"sv"         },
+    { 0x001E, L"th"         },
+    { 0x001F, L"tr"         },
+    { 0x0020, L"ur"         },
+    { 0x0021, L"id"         },
+    { 0x0022, L"uk"         },
+    { 0x0023, L"be"         },
+    { 0x0024, L"sl"         },
+    { 0x0025, L"et"         },
+    { 0x0026, L"lv"         },
+    { 0x0027, L"lt"         },
+    { 0x0029, L"fa"         },
+    { 0x002A, L"vi"         },
+    { 0x002B, L"hy"         },
+    { 0x002C, L"az"         },
+    { 0x002D, L"eu"         },
+    { 0x002F, L"mk"         },
+    { 0x0036, L"af"         },
+    { 0x0037, L"ka"         },
+    { 0x0038, L"fo"         },
+    { 0x0039, L"hi"         },
+    { 0x003E, L"ms"         },
+    { 0x003F, L"kk"         },
+    { 0x0040, L"ky"         },
+    { 0x0041, L"sw"         },
+    { 0x0043, L"uz"         },
+    { 0x0044, L"tt"         },
+    { 0x0046, L"pa"         },
+    { 0x0047, L"gu"         },
+    { 0x0049, L"ta"         },
+    { 0x004A, L"te"         },
+    { 0x004B, L"kn"         },
+    { 0x004E, L"mr"         },
+    { 0x004F, L"sa"         },
+    { 0x0050, L"mn"         },
+    { 0x0056, L"gl"         },
+    { 0x0057, L"kok"        },
+    { 0x005A, L"syr"        },
+    { 0x0065, L"div"        },
+    { 0x007f, L""           },
+    { 0x0401, L"ar-SA"      },
+    { 0x0402, L"bg-BG"      },
+    { 0x0403, L"ca-ES"      },
+    { 0x0404, L"zh-TW"      },
+    { 0x0405, L"cs-CZ"      },
+    { 0x0406, L"da-DK"      },
+    { 0x0407, L"de-DE"      },
+    { 0x0408, L"el-GR"      },
+    { 0x0409, L"en-US"      },
+    { 0x040B, L"fi-FI"      },
+    { 0x040C, L"fr-FR"      },
+    { 0x040D, L"he-IL"      },
+    { 0x040E, L"hu-HU"      },
+    { 0x040F, L"is-IS"      },
+    { 0x0410, L"it-IT"      },
+    { 0x0411, L"ja-JP"      },
+    { 0x0412, L"ko-KR"      },
+    { 0x0413, L"nl-NL"      },
+    { 0x0414, L"nb-NO"      },
+    { 0x0415, L"pl-PL"      },
+    { 0x0416, L"pt-BR"      },
+    { 0x0418, L"ro-RO"      },
+    { 0x0419, L"ru-RU"      },
+    { 0x041A, L"hr-HR"      },
+    { 0x041B, L"sk-SK"      },
+    { 0x041C, L"sq-AL"      },
+    { 0x041D, L"sv-SE"      },
+    { 0x041E, L"th-TH"      },
+    { 0x041F, L"tr-TR"      },
+    { 0x0420, L"ur-PK"      },
+    { 0x0421, L"id-ID"      },
+    { 0x0422, L"uk-UA"      },
+    { 0x0423, L"be-BY"      },
+    { 0x0424, L"sl-SI"      },
+    { 0x0425, L"et-EE"      },
+    { 0x0426, L"lv-LV"      },
+    { 0x0427, L"lt-LT"      },
+    { 0x0429, L"fa-IR"      },
+    { 0x042A, L"vi-VN"      },
+    { 0x042B, L"hy-AM"      },
+    { 0x042C, L"az-AZ-Latn" },
+    { 0x042D, L"eu-ES"      },
+    { 0x042F, L"mk-MK"      },
+    { 0x0432, L"tn-ZA"      },
+    { 0x0434, L"xh-ZA"      },
+    { 0x0435, L"zu-ZA"      },
+    { 0x0436, L"af-ZA"      },
+    { 0x0437, L"ka-GE"      },
+    { 0x0438, L"fo-FO"      },
+    { 0x0439, L"hi-IN"      },
+    { 0x043A, L"mt-MT"      },
+    { 0x043B, L"se-NO"      },
+    { 0x043E, L"ms-MY"      },
+    { 0x043F, L"kk-KZ"      },
+    { 0x0440, L"ky-KG"      },
+    { 0x0441, L"sw-KE"      },
+    { 0x0443, L"uz-UZ-Latn" },
+    { 0x0444, L"tt-RU"      },
+    { 0x0445, L"bn-IN"      },
+    { 0x0446, L"pa-IN"      },
+    { 0x0447, L"gu-IN"      },
+    { 0x0449, L"ta-IN"      },
+    { 0x044A, L"te-IN"      },
+    { 0x044B, L"kn-IN"      },
+    { 0x044C, L"ml-IN"      },
+    { 0x044E, L"mr-IN"      },
+    { 0x044F, L"sa-IN"      },
+    { 0x0450, L"mn-MN"      },
+    { 0x0452, L"cy-GB"      },
+    { 0x0456, L"gl-ES"      },
+    { 0x0457, L"kok-IN"     },
+    { 0x045A, L"syr-SY"     },
+    { 0x0465, L"div-MV"     },
+    { 0x046B, L"quz-BO"     },
+    { 0x046C, L"ns-ZA"      },
+    { 0x0481, L"mi-NZ"      },
+    { 0x0801, L"ar-IQ"      },
+    { 0x0804, L"zh-CN"      },
+    { 0x0807, L"de-CH"      },
+    { 0x0809, L"en-GB"      },
+    { 0x080A, L"es-MX"      },
+    { 0x080C, L"fr-BE"      },
+    { 0x0810, L"it-CH"      },
+    { 0x0813, L"nl-BE"      },
+    { 0x0814, L"nn-NO"      },
+    { 0x0816, L"pt-PT"      },
+    { 0x081A, L"sr-SP-Latn" },
+    { 0x081D, L"sv-FI"      },
+    { 0x082C, L"az-AZ-Cyrl" },
+    { 0x083B, L"se-SE"      },
+    { 0x083E, L"ms-BN"      },
+    { 0x0843, L"uz-UZ-Cyrl" },
+    { 0x086B, L"quz-EC"     },
+    { 0x0C01, L"ar-EG"      },
+    { 0x0C04, L"zh-HK"      },
+    { 0x0C07, L"de-AT"      },
+    { 0x0C09, L"en-AU"      },
+    { 0x0C0A, L"es-ES"      },
+    { 0x0C0C, L"fr-CA"      },
+    { 0x0C1A, L"sr-SP-Cyrl" },
+    { 0x0C3B, L"se-FI"      },
+    { 0x0C6B, L"quz-PE"     },
+    { 0x1001, L"ar-LY"      },
+    { 0x1004, L"zh-SG"      },
+    { 0x1007, L"de-LU"      },
+    { 0x1009, L"en-CA"      },
+    { 0x100A, L"es-GT"      },
+    { 0x100C, L"fr-CH"      },
+    { 0x101A, L"hr-BA"      },
+    { 0x103B, L"smj-NO"     },
+    { 0x1401, L"ar-DZ"      },
+    { 0x1404, L"zh-MO"      },
+    { 0x1407, L"de-LI"      },
+    { 0x1409, L"en-NZ"      },
+    { 0x140A, L"es-CR"      },
+    { 0x140C, L"fr-LU"      },
+    { 0x141A, L"bs-BA-Latn" },
+    { 0x143B, L"smj-SE"     },
+    { 0x1801, L"ar-MA"      },
+    { 0x1809, L"en-IE"      },
+    { 0x180A, L"es-PA"      },
+    { 0x180C, L"fr-MC"      },
+    { 0x181A, L"sr-BA-Latn" },
+    { 0x183B, L"sma-NO"     },
+    { 0x1C01, L"ar-TN"      },
+    { 0x1C09, L"en-ZA"      },
+    { 0x1C0A, L"es-DO"      },
+    { 0x1C1A, L"sr-BA-Cyrl" },
+    { 0x1C3B, L"sma-SE"     },
+    { 0x2001, L"ar-OM"      },
+    { 0x2009, L"en-JM"      },
+    { 0x200A, L"es-VE"      },
+    { 0x203B, L"sms-FI"     },
+    { 0x2401, L"ar-YE"      },
+    { 0x2409, L"en-CB"      },
+    { 0x240A, L"es-CO"      },
+    { 0x243B, L"smn-FI"     },
+    { 0x2801, L"ar-SY"      },
+    { 0x2809, L"en-BZ"      },
+    { 0x280A, L"es-PE"      },
+    { 0x2C01, L"ar-JO"      },
+    { 0x2C09, L"en-TT"      },
+    { 0x2C0A, L"es-AR"      },
+    { 0x3001, L"ar-LB"      },
+    { 0x3009, L"en-ZW"      },
+    { 0x300A, L"es-EC"      },
+    { 0x3401, L"ar-KW"      },
+    { 0x3409, L"en-PH"      },
+    { 0x340A, L"es-CL"      },
+    { 0x3801, L"ar-AE"      },
+    { 0x380A, L"es-UY"      },
+    { 0x3C01, L"ar-BH"      },
+    { 0x3C0A, L"es-PY"      },
+    { 0x4001, L"ar-QA"      },
+    { 0x400A, L"es-BO"      },
+    { 0x440A, L"es-SV"      },
+    { 0x480A, L"es-HN"      },
+    { 0x4C0A, L"es-NI"      },
+    { 0x500A, L"es-PR"      },
+    { 0x7C04, L"zh-CHT"     },
+    { 0x7C1A, L"sr"         }
+};
+
+// Map of locale name to an index in LcidToLocaleNameTable, for Windows XP.
+// Data in this table has been obtained from National Language Support (NLS) API Reference at
+// http://msdn.microsoft.com/en-us/goglobal/bb896001.aspx
+// The table is sorted to improve search performance.
+static const LocaleNameIndex LocaleNameToIndexTable[] =
+{
+    { L""           , 66  },
+    { L"af"         , 44  },
+    { L"af-za"      , 113 },
+    { L"ar"         , 0   },
+    { L"ar-ae"      , 216 },
+    { L"ar-bh"      , 218 },
+    { L"ar-dz"      , 177 },
+    { L"ar-eg"      , 160 },
+    { L"ar-iq"      , 143 },
+    { L"ar-jo"      , 207 },
+    { L"ar-kw"      , 213 },
+    { L"ar-lb"      , 210 },
+    { L"ar-ly"      , 169 },
+    { L"ar-ma"      , 185 },
+    { L"ar-om"      , 196 },
+    { L"ar-qa"      , 220 },
+    { L"ar-sa"      , 67  },
+    { L"ar-sy"      , 204 },
+    { L"ar-tn"      , 191 },
+    { L"ar-ye"      , 200 },
+    { L"az"         , 41  },
+    { L"az-az-cyrl" , 155 },
+    { L"az-az-latn" , 107 },
+    { L"be"         , 33  },
+    { L"be-by"      , 99  },
+    { L"bg"         , 1   },
+    { L"bg-bg"      , 68  },
+    { L"bn-in"      , 125 },
+    { L"bs-ba-latn" , 183 },
+    { L"ca"         , 2   },
+    { L"ca-es"      , 69  },
+    { L"cs"         , 4   },
+    { L"cs-cz"      , 71  },
+    { L"cy-gb"      , 135 },
+    { L"da"         , 5   },
+    { L"da-dk"      , 72  },
+    { L"de"         , 6   },
+    { L"de-at"      , 162 },
+    { L"de-ch"      , 145 },
+    { L"de-de"      , 73  },
+    { L"de-li"      , 179 },
+    { L"de-lu"      , 171 },
+    { L"div"        , 65  },
+    { L"div-mv"     , 139 },
+    { L"el"         , 7   },
+    { L"el-gr"      , 74  },
+    { L"en"         , 8   },
+    { L"en-au"      , 163 },
+    { L"en-bz"      , 205 },
+    { L"en-ca"      , 172 },
+    { L"en-cb"      , 201 },
+    { L"en-gb"      , 146 },
+    { L"en-ie"      , 186 },
+    { L"en-jm"      , 197 },
+    { L"en-nz"      , 180 },
+    { L"en-ph"      , 214 },
+    { L"en-tt"      , 208 },
+    { L"en-us"      , 75  },
+    { L"en-za"      , 192 },
+    { L"en-zw"      , 211 },
+    { L"es"         , 9   },
+    { L"es-ar"      , 209 },
+    { L"es-bo"      , 221 },
+    { L"es-cl"      , 215 },
+    { L"es-co"      , 202 },
+    { L"es-cr"      , 181 },
+    { L"es-do"      , 193 },
+    { L"es-ec"      , 212 },
+    { L"es-es"      , 164 },
+    { L"es-gt"      , 173 },
+    { L"es-hn"      , 223 },
+    { L"es-mx"      , 147 },
+    { L"es-ni"      , 224 },
+    { L"es-pa"      , 187 },
+    { L"es-pe"      , 206 },
+    { L"es-pr"      , 225 },
+    { L"es-py"      , 219 },
+    { L"es-sv"      , 222 },
+    { L"es-uy"      , 217 },
+    { L"es-ve"      , 198 },
+    { L"et"         , 35  },
+    { L"et-ee"      , 101 },
+    { L"eu"         , 42  },
+    { L"eu-es"      , 108 },
+    { L"fa"         , 38  },
+    { L"fa-ir"      , 104 },
+    { L"fi"         , 10  },
+    { L"fi-fi"      , 76  },
+    { L"fo"         , 46  },
+    { L"fo-fo"      , 115 },
+    { L"fr"         , 11  },
+    { L"fr-be"      , 148 },
+    { L"fr-ca"      , 165 },
+    { L"fr-ch"      , 174 },
+    { L"fr-fr"      , 77  },
+    { L"fr-lu"      , 182 },
+    { L"fr-mc"      , 188 },
+    { L"gl"         , 62  },
+    { L"gl-es"      , 136 },
+    { L"gu"         , 55  },
+    { L"gu-in"      , 127 },
+    { L"he"         , 12  },
+    { L"he-il"      , 78  },
+    { L"hi"         , 47  },
+    { L"hi-in"      , 116 },
+    { L"hr"         , 24  },
+    { L"hr-ba"      , 175 },
+    { L"hr-hr"      , 90  },
+    { L"hu"         , 13  },
+    { L"hu-hu"      , 79  },
+    { L"hy"         , 40  },
+    { L"hy-am"      , 106 },
+    { L"id"         , 31  },
+    { L"id-id"      , 97  },
+    { L"is"         , 14  },
+    { L"is-is"      , 80  },
+    { L"it"         , 15  },
+    { L"it-ch"      , 149 },
+    { L"it-it"      , 81  },
+    { L"ja"         , 16  },
+    { L"ja-jp"      , 82  },
+    { L"ka"         , 45  },
+    { L"ka-ge"      , 114 },
+    { L"kk"         , 49  },
+    { L"kk-kz"      , 120 },
+    { L"kn"         , 58  },
+    { L"kn-in"      , 130 },
+    { L"ko"         , 17  },
+    { L"kok"        , 63  },
+    { L"kok-in"     , 137 },
+    { L"ko-kr"      , 83  },
+    { L"ky"         , 50  },
+    { L"ky-kg"      , 121 },
+    { L"lt"         , 37  },
+    { L"lt-lt"      , 103 },
+    { L"lv"         , 36  },
+    { L"lv-lv"      , 102 },
+    { L"mi-nz"      , 142 },
+    { L"mk"         , 43  },
+    { L"mk-mk"      , 109 },
+    { L"ml-in"      , 131 },
+    { L"mn"         , 61  },
+    { L"mn-mn"      , 134 },
+    { L"mr"         , 59  },
+    { L"mr-in"      , 132 },
+    { L"ms"         , 48  },
+    { L"ms-bn"      , 157 },
+    { L"ms-my"      , 119 },
+    { L"mt-mt"      , 117 },
+    { L"nb-no"      , 85  },
+    { L"nl"         , 18  },
+    { L"nl-be"      , 150 },
+    { L"nl-nl"      , 84  },
+    { L"nn-no"      , 151 },
+    { L"no"         , 19  },
+    { L"ns-za"      , 141 },
+    { L"pa"         , 54  },
+    { L"pa-in"      , 126 },
+    { L"pl"         , 20  },
+    { L"pl-pl"      , 86  },
+    { L"pt"         , 21  },
+    { L"pt-br"      , 87  },
+    { L"pt-pt"      , 152 },
+    { L"quz-bo"     , 140 },
+    { L"quz-ec"     , 159 },
+    { L"quz-pe"     , 168 },
+    { L"ro"         , 22  },
+    { L"ro-ro"      , 88  },
+    { L"ru"         , 23  },
+    { L"ru-ru"      , 89  },
+    { L"sa"         , 60  },
+    { L"sa-in"      , 133 },
+    { L"se-fi"      , 167 },
+    { L"se-no"      , 118 },
+    { L"se-se"      , 156 },
+    { L"sk"         , 25  },
+    { L"sk-sk"      , 91  },
+    { L"sl"         , 34  },
+    { L"sl-si"      , 100 },
+    { L"sma-no"     , 190 },
+    { L"sma-se"     , 195 },
+    { L"smj-no"     , 176 },
+    { L"smj-se"     , 184 },
+    { L"smn-fi"     , 203 },
+    { L"sms-fi"     , 199 },
+    { L"sq"         , 26  },
+    { L"sq-al"      , 92  },
+    { L"sr"         , 227 },
+    { L"sr-ba-cyrl" , 194 },
+    { L"sr-ba-latn" , 189 },
+    { L"sr-sp-cyrl" , 166 },
+    { L"sr-sp-latn" , 153 },
+    { L"sv"         , 27  },
+    { L"sv-fi"      , 154 },
+    { L"sv-se"      , 93  },
+    { L"sw"         , 51  },
+    { L"sw-ke"      , 122 },
+    { L"syr"        , 64  },
+    { L"syr-sy"     , 138 },
+    { L"ta"         , 56  },
+    { L"ta-in"      , 128 },
+    { L"te"         , 57  },
+    { L"te-in"      , 129 },
+    { L"th"         , 28  },
+    { L"th-th"      , 94  },
+    { L"tn-za"      , 110 },
+    { L"tr"         , 29  },
+    { L"tr-tr"      , 95  },
+    { L"tt"         , 53  },
+    { L"tt-ru"      , 124 },
+    { L"uk"         , 32  },
+    { L"uk-ua"      , 98  },
+    { L"ur"         , 30  },
+    { L"ur-pk"      , 96  },
+    { L"uz"         , 52  },
+    { L"uz-uz-cyrl" , 158 },
+    { L"uz-uz-latn" , 123 },
+    { L"vi"         , 39  },
+    { L"vi-vn"      , 105 },
+    { L"xh-za"      , 111 },
+    { L"zh-chs"     , 3   },
+    { L"zh-cht"     , 226 },
+    { L"zh-cn"      , 144 },
+    { L"zh-hk"      , 161 },
+    { L"zh-mo"      , 178 },
+    { L"zh-sg"      , 170 },
+    { L"zh-tw"      , 70  },
+    { L"zu-za"      , 112 }
+};
+
+} // unnamed namespace
+
+// Maps input locale name to the index on LcidToLocaleNameTable
+static int GetTableIndexFromLocaleName(const wchar_t* localeName) throw()
+{
+    LocaleNameIndex *localeNamesIndex = (LocaleNameIndex *) LocaleNameToIndexTable;
+    int bottom = 0;
+    int top = _countof(LocaleNameToIndexTable) - 1;
+
+    while (bottom <= top)
+    {
+        int middle = (bottom + top) / 2;
+        int testIndex = __ascii_wcsnicmp(localeName, localeNamesIndex[middle].name, LOCALE_NAME_MAX_LENGTH);
+
+        if (testIndex == 0)
+            return localeNamesIndex[middle].index;
+
+        if (testIndex < 0)
+            top = middle - 1;
+        else
+            bottom = middle + 1;
+    }
+
+    return -1;
+}
+
+// Maps input LCID to an index in LcidToLocaleNameTable
+static int GetTableIndexFromLcid(LCID lcid) throw()
+{
+
+    int bottom = 0;
+    int top = _countof(LcidToLocaleNameTable) - 1;
+
+    while (bottom <= top)
+    {
+        int middle = (bottom + top) / 2;
+        int testIndex = lcid - LcidToLocaleNameTable[middle].lcid;
+
+        if (testIndex == 0)
+            return middle;
+
+        if (testIndex < 0)
+            top = middle - 1;
+        else
+            bottom = middle + 1;
+    }
+
+    return -1;
+}
+
+
+extern "C" LCID __cdecl __acrt_DownlevelLocaleNameToLCID(LPCWSTR localeName)
+{
+    int index;
+
+    if (localeName == nullptr)
+        return 0;
+
+    index = GetTableIndexFromLocaleName(localeName);
+
+    if (index < 0 || (index >= _countof(LcidToLocaleNameTable)))
+        return 0;
+
+    return LcidToLocaleNameTable[index].lcid;
+}
+
+extern "C" int __cdecl __acrt_DownlevelLCIDToLocaleName(
+    LCID   lcid,
+    LPWSTR outLocaleName,
+    int    cchLocaleName
+    )
+{
+    size_t     count;
+    wchar_t*   buffer;
+    int        index;
+
+    if (lcid == 0                           ||
+        lcid == LOCALE_USER_DEFAULT         ||
+        lcid == LOCALE_SYSTEM_DEFAULT)
+    {
+        return 0;
+    }
+
+    if ((outLocaleName == nullptr && cchLocaleName>0) || cchLocaleName < 0)
+    {
+        return 0;
+    }
+
+    index = GetTableIndexFromLcid(lcid);
+    if (index < 0)
+        return 0;
+
+    buffer = LcidToLocaleNameTable[index].localeName;
+    count = wcsnlen(buffer, LOCALE_NAME_MAX_LENGTH);
+
+    if (cchLocaleName > 0)
+    {
+        if ((int)count >= cchLocaleName)
+            return 0;
+
+        _ERRCHECK(wcscpy_s(outLocaleName, cchLocaleName, buffer));
+    }
+
+    return (int) count + 1;
+}
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lconv_unsigned_char_initialization.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lconv_unsigned_char_initialization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..be4076a64a2f1c40c605b76a32d629da50ce8c4e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/lconv_unsigned_char_initialization.cpp	
@@ -0,0 +1,52 @@
+//
+// lconv_unsigned_char_initialization.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// lconv initialization used to support an unsigned 'char' type (enabled by the
+// -J flag during compilation).  Per the specification, some members of the lconv
+// structure must be initialized to CHAR_MAX.  The value of CHAR_MAX, however,
+// depends on whether the 'char' type is signed or unsigned (it is 127 for a
+// signed 'char'; 255 for an unsigned 'char').
+//
+// By default, these members of lconv are initialized to SCHAR_MAX (127).  If an
+// unsigned 'char' type is used, we call this function to update those members
+// to UCHAR_MAX (255).  Note that this is not done for DLLs that are linked to
+// the CRT DLL, because we do not want such DLLs to override the -J setting for
+// an EXE linked to the CRT DLL.
+//
+// There is code in several other files that is required to make all of this work:
+//
+// * locale.h:  When -J is used to compile a source file that includes <locale.h>,
+//   it generates an unresolved external to __do_unsigned_char_lconv_initialization.
+//
+// * lconv_unsigned_char_static.cpp:  This file defines a global variable named
+//   __do_unsigned_char_lconv_initialization, and is used during the link to
+//   satisfy the unresolved external.  This file adds a call to
+//   __initialize_lconv_for_unsigned_char to the list of initializers to be
+//   executed.  That function (defined below) updates the fields of the lconv
+//   structure to be set to UCHAR_MAX.
+//
+// * localeconv.cpp:  This file defines the __acrt_lconv_c structure.
+//
+#include <corecrt_internal.h>
+#include <limits.h>
+#include <locale.h>
+
+#pragma warning(disable: 4310) // cast truncates constant value
+
+
+
+extern "C" int __cdecl __initialize_lconv_for_unsigned_char()
+{
+    __acrt_lconv_c.int_frac_digits = (char)UCHAR_MAX;
+    __acrt_lconv_c.frac_digits     = (char)UCHAR_MAX;
+    __acrt_lconv_c.p_cs_precedes   = (char)UCHAR_MAX;
+    __acrt_lconv_c.p_sep_by_space  = (char)UCHAR_MAX;
+    __acrt_lconv_c.n_cs_precedes   = (char)UCHAR_MAX;
+    __acrt_lconv_c.n_sep_by_space  = (char)UCHAR_MAX;
+    __acrt_lconv_c.p_sign_posn     = (char)UCHAR_MAX;
+    __acrt_lconv_c.n_sign_posn     = (char)UCHAR_MAX;
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_refcounting.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_refcounting.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c775db354f26b53d4f9ea0a84cecdb3fc2c96221
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_refcounting.cpp	
@@ -0,0 +1,353 @@
+/***
+*localref.c - Contains the __[add|remove]localeref() functions.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Contains the __[add|remove]localeref() functions.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+
+
+
+/***
+* __acrt_add_locale_ref(__crt_locale_data* ptloci)
+*
+* Purpose:
+*       Increment the refrence count for each element in the localeinfo struct.
+*
+*******************************************************************************/
+extern "C" void __cdecl __acrt_add_locale_ref(__crt_locale_data* ptloci)
+{
+    _InterlockedIncrement(&ptloci->refcount);
+
+    if (ptloci->lconv_intl_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->lconv_intl_refcount);
+    }
+
+    if (ptloci->lconv_mon_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->lconv_mon_refcount);
+    }
+
+    if (ptloci->lconv_num_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->lconv_num_refcount);
+    }
+
+    if (ptloci->ctype1_refcount != nullptr)
+    {
+        _InterlockedIncrement(ptloci->ctype1_refcount);
+    }
+
+    for (int category = LC_MIN; category <= LC_MAX; ++category)
+    {
+        if (ptloci->lc_category[category].wlocale != __acrt_wide_c_locale_string &&
+            ptloci->lc_category[category].wrefcount != nullptr)
+        {
+            _InterlockedIncrement(ptloci->lc_category[category].wrefcount);
+        }
+
+        if (ptloci->lc_category[category].locale != nullptr &&
+            ptloci->lc_category[category].refcount != nullptr)
+        {
+            _InterlockedIncrement(ptloci->lc_category[category].refcount);
+        }
+    }
+
+    __acrt_locale_add_lc_time_reference(ptloci->lc_time_curr);
+}
+
+/***
+* __acrt_release_locale_ref(__crt_locale_data* ptloci)
+*
+* Purpose:
+*       Decrement the refrence count for each elemnt in the localeinfo struct.
+*
+******************************************************************************/
+extern "C" void __cdecl __acrt_release_locale_ref(__crt_locale_data* ptloci)
+{
+    if (ptloci == nullptr)
+        return;
+
+    _InterlockedDecrement(&ptloci->refcount);
+
+    if (ptloci->lconv_intl_refcount != nullptr)
+        _InterlockedDecrement(ptloci->lconv_intl_refcount);
+
+    if (ptloci->lconv_mon_refcount != nullptr)
+        _InterlockedDecrement(ptloci->lconv_mon_refcount);
+
+    if (ptloci->lconv_num_refcount != nullptr)
+        _InterlockedDecrement(ptloci->lconv_num_refcount);
+
+    if (ptloci->ctype1_refcount != nullptr)
+        _InterlockedDecrement(ptloci->ctype1_refcount);
+
+    for (int category = LC_MIN; category <= LC_MAX; ++category)
+    {
+        if (ptloci->lc_category[category].wlocale != __acrt_wide_c_locale_string &&
+            ptloci->lc_category[category].wrefcount != nullptr)
+        {
+            _InterlockedDecrement(ptloci->lc_category[category].wrefcount);
+        }
+
+        if (ptloci->lc_category[category].locale != nullptr &&
+            ptloci->lc_category[category].refcount != nullptr)
+        {
+            _InterlockedDecrement(ptloci->lc_category[category].refcount);
+        }
+    }
+
+    __acrt_locale_release_lc_time_reference(ptloci->lc_time_curr);
+}
+
+
+/***
+*__acrt_free_locale() - free __crt_locale_data
+*
+*Purpose:
+*       Free up the per-thread locale info structure specified by the passed
+*       pointer.
+*
+*Entry:
+*       __crt_locale_data* ptloci
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl __acrt_free_locale(__crt_locale_data* ptloci)
+{
+    /*
+     * Free up lconv struct
+     */
+    if (ptloci->lconv != nullptr &&
+        ptloci->lconv != &__acrt_lconv_c &&
+        ptloci->lconv_intl_refcount != nullptr &&
+        *ptloci->lconv_intl_refcount == 0)
+    {
+        if (ptloci->lconv_mon_refcount != nullptr && *ptloci->lconv_mon_refcount == 0)
+        {
+            _free_crt(ptloci->lconv_mon_refcount);
+            __acrt_locale_free_monetary(ptloci->lconv);
+        }
+
+        if (ptloci->lconv_num_refcount != nullptr && *ptloci->lconv_num_refcount == 0)
+        {
+            _free_crt(ptloci->lconv_num_refcount);
+            __acrt_locale_free_numeric(ptloci->lconv);
+        }
+
+        _free_crt(ptloci->lconv_intl_refcount);
+        _free_crt(ptloci->lconv);
+    }
+
+    /*
+     * Free up ctype tables
+     */
+    if (ptloci->ctype1_refcount != nullptr && *ptloci->ctype1_refcount == 0)
+    {
+        _free_crt(ptloci->ctype1 - _COFFSET);
+        _free_crt(const_cast<unsigned char*>(ptloci->pclmap - _COFFSET - 1));
+        _free_crt(const_cast<unsigned char*>(ptloci->pcumap - _COFFSET - 1));
+        _free_crt(ptloci->ctype1_refcount);
+    }
+
+    __acrt_locale_free_lc_time_if_unreferenced(ptloci->lc_time_curr);
+
+    for (int category = LC_MIN; category <= LC_MAX; ++category)
+    {
+        if (ptloci->lc_category[category].wlocale != __acrt_wide_c_locale_string &&
+            ptloci->lc_category[category].wrefcount != nullptr &&
+            *ptloci->lc_category[category].wrefcount == 0)
+        {
+            _free_crt(ptloci->lc_category[category].wrefcount);
+            _free_crt(ptloci->locale_name[category]);
+        }
+
+        _ASSERTE((ptloci->lc_category[category].locale != nullptr && ptloci->lc_category[category].refcount != nullptr) ||
+                 (ptloci->lc_category[category].locale == nullptr && ptloci->lc_category[category].refcount == nullptr));
+
+        if (ptloci->lc_category[category].locale != nullptr &&
+            ptloci->lc_category[category].refcount != nullptr &&
+            *ptloci->lc_category[category].refcount == 0)
+        {
+            _free_crt(ptloci->lc_category[category].refcount);
+        }
+    }
+
+    /*
+     * Free up the __crt_locale_data struct
+     */
+    _free_crt(ptloci);
+}
+
+
+/***
+*
+* _updatelocinfoEx_nolock(__crt_locale_data* *pptlocid, __crt_locale_data* ptlocis)
+*
+* Purpose:
+*       Update *pptlocid to ptlocis. This might include freeing contents of *pptlocid.
+*
+******************************************************************************/
+extern "C" __crt_locale_data* __cdecl _updatetlocinfoEx_nolock(
+    __crt_locale_data** pptlocid,
+    __crt_locale_data*  ptlocis
+    )
+{
+    if (ptlocis == nullptr || pptlocid == nullptr)
+        return nullptr;
+
+    __crt_locale_data* const ptloci = *pptlocid;
+    if (ptloci == ptlocis)
+        return ptlocis;
+
+    /*
+    * Update to the current locale info structure and increment the
+    * reference counts.
+    */
+    *pptlocid = ptlocis;
+    __acrt_add_locale_ref(ptlocis);
+
+    /*
+    * Decrement the reference counts in the old locale info
+    * structure.
+    */
+    if (ptloci != nullptr)
+    {
+        __acrt_release_locale_ref(ptloci);
+    }
+
+    /*
+    * Free the old locale info structure, if necessary.  Must be done
+    * after incrementing reference counts in current locale in case
+    * any refcounts are shared with the old locale.
+    */
+    if (ptloci != nullptr &&
+        ptloci->refcount == 0 &&
+        ptloci != &__acrt_initial_locale_data)
+    {
+        __acrt_free_locale(ptloci);
+    }
+
+    return ptlocis;
+}
+
+
+/***
+*__acrt_update_thread_locale_data() - refresh the thread's locale info
+*
+*Purpose:
+*       If this thread does not have it's ownlocale which means that either
+*       ownlocale flag in ptd is not set or ptd->ptloci == nullptr, then Update
+*       the current thread's reference to the locale information to match the
+*       current global locale info. Decrement the reference on the old locale
+*       information struct and if this count is now zero (so that no threads
+*       are using it), free it.
+*
+*Entry:
+*
+*Exit:
+*
+*       if (!_getptd()->ownlocale || _getptd()->ptlocinfo == nullptr)
+*           _getptd()->ptlocinfo == __acrt_current_locale_data
+*       else
+*           _getptd()->ptlocinfo
+*
+*Exceptions:
+*
+*******************************************************************************/
+extern "C" __crt_locale_data* __cdecl __acrt_update_thread_locale_data()
+{
+    __crt_locale_data* ptloci = nullptr;
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    if (__acrt_should_sync_with_global_locale(ptd) || ptd->_locale_info == nullptr)
+    {
+        __acrt_lock(__acrt_locale_lock);
+        __try
+        {
+            ptloci = _updatetlocinfoEx_nolock(&ptd->_locale_info, __acrt_current_locale_data.value());
+        }
+        __finally
+        {
+            __acrt_unlock(__acrt_locale_lock);
+        }
+    }
+    else
+    {
+        ptloci = ptd->_locale_info;
+    }
+
+    if (!ptloci)
+    {
+        abort();
+    }
+
+    return ptloci;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// __crt_lc_time_data reference counting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// The C locale lc_time data is immutable and persistent.  The lc_time data for
+// any other locale is dynamically allocated (and thus not actually immutable).
+// The lc_time_curr data member of __crt_locale_data is declared const to help
+// ensure that code does not accidentally attempt to modify the C locale lc_time
+// data.
+//
+// These functions encapsulate all mutation of the lc_time_curr.  They accept a
+// __crt_lc_time_data const*, handle the C locale as a special case, then cast
+// away constness to mutate the lc_time data.
+extern "C" long __cdecl __acrt_locale_add_lc_time_reference(
+    __crt_lc_time_data const* const lc_time
+    )
+{
+    if (lc_time == nullptr || lc_time == &__lc_time_c)
+    {
+        return LONG_MAX;
+    }
+
+    return _InterlockedIncrement(&const_cast<__crt_lc_time_data*>(lc_time)->refcount);
+}
+
+extern "C" long __cdecl __acrt_locale_release_lc_time_reference(
+    __crt_lc_time_data const* const lc_time
+    )
+{
+    if (lc_time == nullptr || lc_time == &__lc_time_c)
+    {
+        return LONG_MAX;
+    }
+
+    return _InterlockedDecrement(&const_cast<__crt_lc_time_data*>(lc_time)->refcount);
+}
+
+extern "C" void __cdecl __acrt_locale_free_lc_time_if_unreferenced(
+    __crt_lc_time_data const* const lc_time
+    )
+{
+    if (lc_time == nullptr || lc_time == &__lc_time_c)
+    {
+        return;
+    }
+
+    if (__crt_interlocked_read(&lc_time->refcount) != 0)
+    {
+        return;
+    }
+
+    __acrt_locale_free_time(const_cast<__crt_lc_time_data*>(lc_time));
+    _free_crt(const_cast<__crt_lc_time_data*>(lc_time));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_update.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_update.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1a6cf5d083897b2cd2c432ea352c5475f440ce9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/locale_update.cpp	
@@ -0,0 +1,55 @@
+//
+// locale_update.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Encapsulated implementation details of _LocaleUpdate that cannot be defined
+// in the header because they refer to data not exported from the AppCRT DLL.
+//
+#include <corecrt_internal.h>
+
+extern "C" void __acrt_update_locale_info(
+    __acrt_ptd*         const ptd,
+    __crt_locale_data** const locale_info
+    )
+{
+    if (*locale_info != __acrt_current_locale_data.value() && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *locale_info = __acrt_update_thread_locale_data();
+    }
+}
+
+extern "C" void __acrt_update_multibyte_info(
+    __acrt_ptd*            const ptd,
+    __crt_multibyte_data** const multibyte_info
+    )
+{
+    if (*multibyte_info != __acrt_current_multibyte_data.value() && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *multibyte_info = __acrt_update_thread_multibyte_data();
+    }
+}
+
+extern "C" void __acrt_update_locale_info_explicit(
+    __acrt_ptd*         const ptd,
+    __crt_locale_data** const locale_info,
+    size_t              const current_global_state_index
+    )
+{
+    if (*locale_info != __acrt_current_locale_data.value_explicit(current_global_state_index) && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *locale_info = __acrt_update_thread_locale_data();
+    }
+}
+
+extern "C" void __acrt_update_multibyte_info_explicit(
+    __acrt_ptd*            const ptd,
+    __crt_multibyte_data** const multibyte_info,
+    size_t                 const current_global_state_index
+    )
+{
+    if (*multibyte_info != __acrt_current_multibyte_data.value_explicit(current_global_state_index) && __acrt_should_sync_with_global_locale(ptd))
+    {
+        *multibyte_info = __acrt_update_thread_multibyte_data();
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/localeconv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/localeconv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca5c0e587f906cd8280989ea4895b80ff6aae86d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/localeconv.cpp	
@@ -0,0 +1,86 @@
+/***
+*lconv.c - Contains the localeconv function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the localeconv() function.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <limits.h>
+#include <locale.h>
+
+
+
+/* pointer to original static to avoid freeing */
+extern "C" char    __acrt_lconv_static_decimal  []{"."};
+extern "C" char    __acrt_lconv_static_null     []{""};
+extern "C" wchar_t __acrt_lconv_static_W_decimal[]{L"."};
+extern "C" wchar_t __acrt_lconv_static_W_null   []{L""};
+
+/* lconv settings for "C" locale */
+extern "C" struct lconv __acrt_lconv_c
+{
+    __acrt_lconv_static_decimal,   // decimal_point
+    __acrt_lconv_static_null,      // thousands_sep
+    __acrt_lconv_static_null,      // grouping
+    __acrt_lconv_static_null,      // int_curr_symbol
+    __acrt_lconv_static_null,      // currency_symbol
+    __acrt_lconv_static_null,      // mon_decimal_point
+    __acrt_lconv_static_null,      // mon_thousands_sep
+    __acrt_lconv_static_null,      // mon_grouping
+    __acrt_lconv_static_null,      // positive_sign
+    __acrt_lconv_static_null,      // negative_sign
+    CHAR_MAX,                      // int_frac_digits
+    CHAR_MAX,                      // frac_digits
+    CHAR_MAX,                      // p_cs_precedes
+    CHAR_MAX,                      // p_sep_by_space
+    CHAR_MAX,                      // n_cs_precedes
+    CHAR_MAX,                      // n_sep_by_space
+    CHAR_MAX,                      // p_sign_posn
+    CHAR_MAX,                      // n_sign_posn
+    __acrt_lconv_static_W_decimal, // _W_decimal_point
+    __acrt_lconv_static_W_null,    // _W_thousands_sep
+    __acrt_lconv_static_W_null,    // _W_int_curr_symbol
+    __acrt_lconv_static_W_null,    // _W_currency_symbol
+    __acrt_lconv_static_W_null,    // _W_mon_decimal_point
+    __acrt_lconv_static_W_null,    // _W_mon_thousands_sep
+    __acrt_lconv_static_W_null,    // _W_positive_sign
+    __acrt_lconv_static_W_null,    // _W_negative_sign
+};
+
+
+/* pointer to current lconv structure */
+
+extern "C" struct lconv* __acrt_lconv{&__acrt_lconv_c};
+
+/***
+*struct lconv *localeconv(void) - Return the numeric formatting convention
+*
+*Purpose:
+*       The localeconv() routine returns the numeric formatting conventions
+*       for the current locale setting.  [ANSI]
+*
+*Entry:
+*       void
+*
+*Exit:
+*       struct lconv * = pointer to struct indicating current numeric
+*                        formatting conventions.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" lconv* __cdecl localeconv()
+{
+    // Note that we don't need _LocaleUpdate in this function.  The main reason
+    // being, that this is a leaf function in locale usage terms.
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_locale_data* locale_info = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &locale_info);
+
+    return locale_info->lconv;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/nlsdata.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/nlsdata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91c2f02d0077daf2a7c31cc25f28c4c80dfa5aaf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/nlsdata.cpp	
@@ -0,0 +1,140 @@
+//
+// nlsdata.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Globals for the locale and code page implementation.  These are utilized by
+// almost all locale-dependent functions.
+//
+#include <corecrt_internal.h>
+
+
+
+extern "C" int __mb_cur_max{1};
+
+
+
+extern "C" int* __cdecl __p___mb_cur_max()
+{
+    __acrt_ptd* ptd = __acrt_getptd();
+    __crt_locale_data* locale_info = ptd->_locale_info;
+
+    __acrt_update_locale_info(ptd, &locale_info);
+    return &locale_info->_public._locale_mb_cur_max;
+}
+
+
+
+extern "C" wchar_t __acrt_wide_c_locale_string[]{L"C"};
+
+
+
+extern "C" __crt_lc_time_data const __lc_time_c
+{
+    { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
+
+    {
+        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+        "Friday", "Saturday"
+    },
+
+    {
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
+        "Sep", "Oct", "Nov", "Dec"
+    },
+
+    {
+        "January", "February", "March", "April", "May", "June",
+        "July", "August", "September", "October",
+        "November", "December"
+    },
+
+    { "AM", "PM" },
+
+    "MM/dd/yy",
+    "dddd, MMMM dd, yyyy",
+    "HH:mm:ss",
+
+    1,
+    0,
+
+    { L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat" },
+
+    {
+        L"Sunday", L"Monday", L"Tuesday", L"Wednesday",
+        L"Thursday", L"Friday", L"Saturday"
+    },
+
+    {
+        L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun", L"Jul",
+        L"Aug", L"Sep", L"Oct", L"Nov", L"Dec"
+    },
+
+    {
+        L"January", L"February", L"March", L"April", L"May",
+        L"June", L"July", L"August", L"September", L"October",
+        L"November", L"December"
+    },
+
+    { L"AM", L"PM" },
+
+    L"MM/dd/yy",
+    L"dddd, MMMM dd, yyyy",
+    L"HH:mm:ss",
+    L"en-US"
+};
+
+
+
+// The initial locale information structure, containing the C locale data.  It
+// is used until the first call to setlocale().
+extern "C" __crt_locale_data __acrt_initial_locale_data
+{
+    {
+        __newctype + 128,    // _locale_pctype
+        1,                   // _locale_mb_cur_max
+        CP_ACP               // _locale_lc_codepage
+    },
+    1,                       // refcount
+    CP_ACP,                  // lc_collate_cp
+    CP_ACP,                  // lc_time_cp
+    1,                       // lc_clike
+    {
+        { nullptr, nullptr,                     nullptr, nullptr }, // lc_category[LC_ALL]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_COLLATE]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_CTYPE]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_MONETARY]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }, // lc_category[LC_NUMERIC]
+        { nullptr, __acrt_wide_c_locale_string, nullptr, nullptr }  // lc_category[LC_TIME]
+    },
+    nullptr,                 // lconv_intl_refcount
+    nullptr,                 // lconv_num_refcount
+    nullptr,                 // lconv_mon_refcount
+    &__acrt_lconv_c,         // lconv
+    nullptr,                 // ctype1_refcount
+    nullptr,                 // ctype1
+    __newclmap + 128,        // pclmap
+    __newcumap + 128,        // pcumap
+    &__lc_time_c,            // lc_time_curr
+    {
+        nullptr,             // locale_name[LC_ALL]
+        nullptr,             // locale_name[LC_COLLATE]
+        nullptr,             // locale_name[LC_CTYPE]
+        nullptr,             // locale_name[LC_MONETARY]
+        nullptr,             // locale_name[LC_NUMERIC]
+        nullptr              // locale_name[LC_TIME]
+    }
+};
+
+
+
+// Global pointer to the current per-thread locale information structure.
+__crt_state_management::dual_state_global<__crt_locale_data*> __acrt_current_locale_data;
+
+
+
+extern "C" __crt_locale_pointers __acrt_initial_locale_pointers
+{
+    &__acrt_initial_locale_data,
+    &__acrt_initial_multibyte_data
+};
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/setlocale.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/setlocale.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..599e38663e337e27c282fc38bf0cf5a3896277de
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/setlocale.cpp	
@@ -0,0 +1,118 @@
+/***
+*setlocal.c - Contains the setlocale function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Contains the _wsetlocale() function.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <stdlib.h>
+
+extern "C" static wchar_t* __cdecl call_wsetlocale(int const category, char const* const narrow_locale)
+{
+    if (narrow_locale == nullptr)
+        return _wsetlocale(category, nullptr);
+
+    size_t size;
+    _ERRCHECK_EINVAL_ERANGE(mbstowcs_s(&size, nullptr, 0, narrow_locale, INT_MAX));
+
+    __crt_unique_heap_ptr<wchar_t> wide_locale(_calloc_crt_t(wchar_t, size));
+    if (wide_locale.get() == nullptr)
+        return nullptr;
+
+    if (_ERRCHECK_EINVAL_ERANGE(mbstowcs_s(nullptr, wide_locale.get(), size, narrow_locale, _TRUNCATE)) != 0)
+        return nullptr;
+
+    return _wsetlocale(category, wide_locale.get());
+}
+
+extern "C" char* __cdecl setlocale(int _category, char const* _locale)
+{
+    // Deadlock Avoidance:  See the comment in _wsetlocale on usage of this function.
+    __acrt_eagerly_load_locale_apis();
+
+    return __acrt_lock_and_call(__acrt_locale_lock, [&]() -> char*
+    {
+        // Convert ASCII string into a wide character string:
+        wchar_t* const outwlocale = call_wsetlocale(_category, _locale);
+        if (outwlocale == nullptr)
+        {
+            return nullptr;
+        }
+
+        __acrt_ptd* const ptd = __acrt_getptd();
+
+        __crt_locale_pointers locale;
+        locale.locinfo = ptd->_locale_info;
+        locale.mbcinfo = ptd->_multibyte_info;
+
+        // We now have a locale string, but the global locale can be changed by
+        // another thread.  If we allow this thread's locale to be updated before
+        // we're done with this string, it might be freed from under us.  We call
+        // the versions of the wide-to-multibyte conversions that do not update the
+        // current thread's locale.
+        size_t size = 0;
+        if (_ERRCHECK_EINVAL_ERANGE(_wcstombs_s_l(&size, nullptr, 0, outwlocale, 0, &locale)) != 0)
+        {
+            return nullptr;
+        }
+
+        long* const refcount = static_cast<long*>(_malloc_crt(size + sizeof(long)));
+        if (refcount == nullptr)
+        {
+            return nullptr;
+        }
+
+        char* outlocale = reinterpret_cast<char*>(&refcount[1]);
+
+        /* convert return value to ASCII */
+        if (_ERRCHECK_EINVAL_ERANGE(_wcstombs_s_l(nullptr, outlocale, size, outwlocale, _TRUNCATE, &locale)) != 0)
+        {
+            _free_crt(refcount);
+            return nullptr;
+        }
+
+        __crt_locale_data* ptloci = locale.locinfo;
+
+        _ASSERTE((ptloci->lc_category[_category].locale != nullptr && ptloci->lc_category[_category].refcount != nullptr) ||
+                 (ptloci->lc_category[_category].locale == nullptr && ptloci->lc_category[_category].refcount == nullptr));
+
+        if (ptloci->lc_category[_category].refcount != nullptr &&
+            _InterlockedDecrement(ptloci->lc_category[_category].refcount) == 0)
+        {
+            _free_crt(ptloci->lc_category[_category].refcount);
+            ptloci->lc_category[_category].refcount = nullptr;
+        }
+
+        if (__acrt_should_sync_with_global_locale(ptd))
+        {
+            if (ptloci->lc_category[_category].refcount != nullptr &&
+                _InterlockedDecrement(ptloci->lc_category[_category].refcount) == 0)
+            {
+                _free_crt(ptloci->lc_category[_category].refcount);
+                ptloci->lc_category[_category].refcount = nullptr;
+            }
+        }
+
+        /*
+        * Note that we are using a risky trick here.  We are adding this
+        * locale to an existing __crt_locale_data struct, and thus starting
+        * the locale's refcount with the same value as the whole struct.
+        * That means all code which modifies both __crt_locale_data::refcount
+        * and __crt_locale_data::lc_category[]::refcount in structs that are
+        * potentially shared across threads must make those modifications
+        * under the locale lock.  Otherwise, there's a race condition
+        * for some other thread modifying __crt_locale_data::refcount after
+        * we load it but before we store it to refcount.
+        */
+        *refcount = ptloci->refcount;
+        ptloci->lc_category[_category].refcount = refcount;
+        ptloci->lc_category[_category].locale = outlocale;
+
+        return outlocale;
+    });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/wsetlocale.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/wsetlocale.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d9dc22837194135cdbd76d017d5dd8b87face9e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/locale/wsetlocale.cpp	
@@ -0,0 +1,1430 @@
+/***
+*wsetlocale.cpp - Contains the wsetlocale function
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Contains the wsetlocale() function.
+*
+****/
+
+#include <corecrt_internal.h>
+#include <locale.h>
+
+extern "C" {
+
+static const char _first_127char[] = {
+        1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17,
+        18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+        35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+        69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
+        86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,101,102,
+        103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,
+        120,121,122,123,124,125,126,127
+};
+
+extern __crt_locale_data __acrt_initial_locale_data;
+extern const unsigned short _wctype[];
+static const unsigned short *_ctype_loc_style = _wctype + 2;
+
+long __acrt_locale_changed_data = FALSE;
+
+/* helper function prototypes */
+_Success_(return != 0)
+static wchar_t * _expandlocale(
+    _In_z_                                wchar_t const * expr,
+    _Out_writes_z_(sizeInChars)           wchar_t *       output,
+    _In_                                  size_t          sizeInChars,
+    _Out_writes_z_(localeNameSizeInChars) wchar_t *       localeNameOutput,
+    _In_                                  size_t          localeNameSizeInChars,
+    _Out_                                 UINT&           cp
+    );
+
+void _wcscats(_Inout_updates_z_(_Param_(2)) wchar_t *, size_t, int, ...);
+void __lc_lctowcs(_Inout_updates_z_(_Param_(2)) wchar_t *, size_t, const __crt_locale_strings *);
+int __lc_wcstolc(__crt_locale_strings *, const wchar_t *);
+static wchar_t * __cdecl _wsetlocale_set_cat(__crt_locale_data*, int, const wchar_t *);
+static wchar_t * __cdecl _wsetlocale_get_all(__crt_locale_data*);
+static __crt_locale_data* __cdecl _updatetlocinfo_nolock(void);
+static wchar_t * __cdecl _wsetlocale_nolock(__crt_locale_data*, int, const wchar_t *);
+int __cdecl _setmbcp_nolock(int, __crt_multibyte_data*);
+__crt_locale_data* __cdecl _updatetlocinfoEx_nolock(__crt_locale_data**, __crt_locale_data*);
+
+void __cdecl __acrt_set_locale_changed()
+{
+    _InterlockedExchange(&__acrt_locale_changed_data, TRUE);
+}
+
+/***
+* _configthreadlocale(int i)
+*
+* Purpose:
+*       To set _own_locale flag on threadinfo sturct. If this flag is set, this thread
+*       is going own it's threadlocinfo struct. Setlocale call on other thread will have
+*       no effect on this thread's locale. If 0 is passed then nothing is changed, but
+*       current status is returned.
+* Exit   :
+*       Returns the current status - i.e. per thread locale is enabled or not.
+*
+*******************************************************************************/
+int __cdecl _configthreadlocale(int i)
+{
+    /*
+     * ownlocale flag struct:
+     * bits: 000000000000000000000000 000W 00P1
+     * P is set when _ENABLE_PER_THREAD_LOCALE is called for this thread
+     * or _ENABLE_PER_THREAD_LOCALE_NEW was set when this thread was created.
+     * W is set when _WSETLOCALE_AVOID_SYNC_LOCALE_BIT is set by _wsetlocale.
+     * It is used to disable global-ptd resynchronization during a call to _wsetlocale.
+     *
+     * __globallocalestatus structure:
+     * bits: 111111111111111111111111 1111 1N1G
+     * G is set if _ENABLE_PER_THREAD_LOCALE_GLOBAL is set.
+     * G is 0 if _ENABLE_PER_THREAD_LOCALE_GLOBAL is not set.
+     * N is set if _ENABLE_PER_THREAD_LOCALE_NEW is set.
+     * N is 0 if _ENABLE_PER_THREAD_LOCALE_NEW is not set.
+     */
+    __acrt_ptd* const ptd = __acrt_getptd();
+    int retval = (ptd->_own_locale & _PER_THREAD_LOCALE_BIT)==0 ? _DISABLE_PER_THREAD_LOCALE:_ENABLE_PER_THREAD_LOCALE;
+
+    switch(i)
+    {
+        case _ENABLE_PER_THREAD_LOCALE:
+            // same behavior as __acrt_disable_global_locale_sync()
+            ptd->_own_locale = ptd->_own_locale | _PER_THREAD_LOCALE_BIT;
+            break;
+
+        case _DISABLE_PER_THREAD_LOCALE:
+            // same behavior as __acrt_enable_global_locale_sync()
+            ptd->_own_locale = ptd->_own_locale & ~_PER_THREAD_LOCALE_BIT;
+            break;
+
+        case 0:
+            break;
+
+        /* used only during dll startup for linkopt */
+        case -1:
+            __globallocalestatus = -1;
+            break;
+
+        default:
+            _VALIDATE_RETURN(("Invalid parameter for _configthreadlocale",0),EINVAL,-1);
+            break;
+    }
+
+    return retval;
+}
+
+extern "C" void __cdecl __acrt_uninitialize_locale()
+{
+    __acrt_lock_and_call(__acrt_locale_lock, [&]
+    {
+        __acrt_current_locale_data.uninitialize([](__crt_locale_data*& locale)
+        {
+            if (locale == &__acrt_initial_locale_data)
+            {
+                return;
+            }
+
+            locale = _updatetlocinfoEx_nolock(&locale, &__acrt_initial_locale_data);
+        });
+    });
+}
+
+/***
+*_free_locale() - free threadlocinfo
+*
+*Purpose:
+*       Free up the per-thread locale info structure specified by the passed
+*       pointer.
+*
+*Entry:
+*       __crt_locale_data* ptloci
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void __cdecl _free_locale(
+        _locale_t plocinfo
+        )
+{
+    if (plocinfo != nullptr)
+    {
+        __acrt_lock(__acrt_multibyte_cp_lock);
+        __try
+        {
+            if (plocinfo->mbcinfo != nullptr &&
+                    InterlockedDecrement(&(plocinfo->mbcinfo->refcount)) == 0 &&
+                    plocinfo->mbcinfo != &__acrt_initial_multibyte_data )
+            {
+                _free_crt(plocinfo->mbcinfo);
+            }
+        }
+        __finally
+        {
+            __acrt_unlock(__acrt_multibyte_cp_lock);
+        }
+
+        if (plocinfo->locinfo != nullptr)
+        {
+            /*
+             * this portion has to be in locale lock as there may be case when
+             * not this thread but some other thread is still holding to this
+             * locale and is also trying to free this locale. In this case
+             * we may end up leaking memory.
+             */
+
+            __acrt_lock(__acrt_locale_lock);
+            __try
+            {
+                __acrt_release_locale_ref(plocinfo->locinfo);
+                if ( (plocinfo->locinfo != nullptr) &&
+                     (plocinfo->locinfo->refcount == 0) &&
+                     (plocinfo->locinfo != &__acrt_initial_locale_data) )
+                    __acrt_free_locale(plocinfo->locinfo);
+            }
+            __finally
+            {
+                __acrt_unlock(__acrt_locale_lock);
+            }
+        }
+
+        _free_crt(plocinfo);
+    }
+}
+
+/*
+* _locale_t _get_current_locale() -
+*    Gets the current locale setting.
+*
+* Purpose:
+*       Gets the current locale setting for this thread. Returns locale
+*       in form of _locale_t, which then can be used with other locale
+*       aware string functions.
+*
+*/
+
+_locale_t __cdecl _get_current_locale(void)
+{
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    auto locale_copy(_calloc_crt_t(__crt_locale_pointers, 1));
+    if (!locale_copy)
+        return nullptr; // calloc will set errno
+
+    __acrt_update_thread_locale_data();
+    __acrt_update_thread_multibyte_data();
+
+    // No one can free the data pointed to by ptlocinfo while we're copying
+    // it, since we're copying this thread's ptlocinfo, which won't be updated
+    // during the copy.  So there are no worries about it being freed from
+    // under us.  We still need a lock while adding a reference for the new
+    // copy, though, because of the race condition found in _wsetlocale.
+    locale_copy.get()->locinfo = ptd->_locale_info;
+    locale_copy.get()->mbcinfo = ptd->_multibyte_info;
+    __acrt_lock_and_call(__acrt_locale_lock, [&]
+    {
+        __acrt_add_locale_ref(locale_copy.get()->locinfo);
+    });
+
+    __acrt_lock_and_call(__acrt_multibyte_cp_lock, [&]
+    {
+        InterlockedIncrement(&locale_copy.get()->mbcinfo->refcount);
+    });
+
+    return locale_copy.detach();
+}
+
+// Enclaves do not support dynamic locales, but they support reading the default one.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+// This is used as the initializer if a category does not need initialization.
+static int __cdecl no_op_initialize(__crt_locale_data*)
+{
+    return 0;
+}
+
+void __cdecl __acrt_free_locale(__crt_locale_data*);
+
+_CRT_LINKER_FORCE_INCLUDE(__acrt_locale_terminator);
+
+extern __declspec(selectany) struct {
+        const wchar_t * catname;
+        wchar_t * locale;
+        int (* init)(__crt_locale_data*);
+} const __lc_category[LC_MAX-LC_MIN+1] = {
+        /* code assumes locale initialization is "__wclocalestr" */
+        { L"LC_ALL",     nullptr,                        no_op_initialize                  },
+        { L"LC_COLLATE", __acrt_wide_c_locale_string,    no_op_initialize                  },
+        { L"LC_CTYPE",   __acrt_wide_c_locale_string,    __acrt_locale_initialize_ctype    },
+        { L"LC_MONETARY",__acrt_wide_c_locale_string,    __acrt_locale_initialize_monetary },
+        { L"LC_NUMERIC", __acrt_wide_c_locale_string,    __acrt_locale_initialize_numeric  },
+        { L"LC_TIME",    __acrt_wide_c_locale_string,    __acrt_locale_initialize_time     }
+};
+
+/***
+*
+* _copytlocinfo_nolock(__crt_locale_data* ptlocid, __crt_locale_data* ptlocis)
+*
+* Purpose:
+*       Copy the contents of ptlocis to ptlocid and increase the refcount of all the
+*       elements in ptlocid after copy.
+*
+******************************************************************************/
+static void __cdecl _copytlocinfo_nolock(
+    __crt_locale_data* ptlocid,
+    __crt_locale_data* ptlocis)
+{
+    if (ptlocis != nullptr && ptlocid != nullptr && ptlocid != ptlocis) {
+        *ptlocid = *ptlocis;
+        ptlocid->refcount = 0;
+        __acrt_add_locale_ref(ptlocid);
+    }
+}
+
+/***
+* void sync_legacy_variables_lk()
+*
+* Purpose:
+*   Syncs all the legacy locale specific variables to the global locale.
+*
+*******************************************************************************/
+static __inline void sync_legacy_variables_lk()
+{
+    __acrt_lconv = __acrt_current_locale_data.value()->lconv;
+    _pctype = __acrt_current_locale_data.value()->_public._locale_pctype;
+    __mb_cur_max = __acrt_current_locale_data.value()->_public._locale_mb_cur_max;
+}
+
+/***
+* _locale_t _wcreate_locale(int category, char *wlocale) -
+*    Set one or all locale categories of global locale structure
+*
+* Purpose:
+*       The _wcreate_locale() routine allows the user to create a _locale_t
+*       object that can be used with other locale functions.
+*
+* Entry:
+*       int category = One of the locale categories defined in locale.h
+*       char *locale = String identifying a specific locale.
+*
+* Exit:
+*       If supplied locale pointer != nullptr:
+*
+*           If locale string is '\0', set locale to default.
+*
+*           If desired setting can be honored, return a pointer to the
+*           locale string for the appropriate category.
+*
+*           If desired setting can NOT be honored, return nullptr.
+*
+* Exceptions:
+*       Compound locale strings of the form "LC_COLLATE=xxx;LC_CTYPE=xxx;..."
+*       are allowed for the LC_ALL category.  This is to support the ability
+*       to restore locales with the returned string, as specified by ANSI.
+*       Setting the locale with a compound locale string will succeed unless
+*       *all* categories failed.  The returned string will reflect the current
+*       locale.  For example, if LC_CTYPE fails in the above string, setlocale
+*       will return "LC_COLLATE=xxx;LC_CTYPE=yyy;..." where yyy is the
+*       previous locale (or the C locale if restoring the previous locale
+*       also failed).  Unrecognized LC_* categories are ignored.
+*
+*******************************************************************************/
+
+_locale_t __cdecl _wcreate_locale(
+        int _category,
+        const wchar_t *locale
+        )
+{
+    if (_category < LC_MIN || _category > LC_MAX || locale == nullptr)
+        return nullptr;
+
+    auto result = _calloc_crt_t(__crt_locale_pointers, 1);
+    _VALIDATE_RETURN_NOEXC(result, ENOMEM, nullptr);
+
+    auto locale_data = _calloc_crt_t(__crt_locale_data, 1);
+    _VALIDATE_RETURN_NOEXC(locale_data, ENOMEM, nullptr);
+
+    auto multibyte_data = _calloc_crt_t(__crt_multibyte_data, 1);
+    _VALIDATE_RETURN_NOEXC(multibyte_data, ENOMEM, nullptr);
+
+    _copytlocinfo_nolock(locale_data.get(), &__acrt_initial_locale_data);
+
+    if (_wsetlocale_nolock(locale_data.get(), _category, locale) == nullptr ||
+        _setmbcp_nolock(locale_data.get()->_public._locale_lc_codepage, multibyte_data.get()) != 0)
+    {
+        __acrt_release_locale_ref(locale_data.get());
+        __acrt_free_locale(locale_data.detach());
+        return nullptr;
+    }
+
+    multibyte_data.get()->refcount = 1;
+
+    result.get()->locinfo = locale_data.detach();
+    result.get()->mbcinfo = multibyte_data.detach();
+    return result.detach();
+}
+
+/***
+* _locale_t _create_locale(int category, char *locale) -
+*    Set one or all locale categories of global locale structure
+****/
+_locale_t __cdecl _create_locale(
+        int _category,
+        const char *_locale
+        )
+{
+    wchar_t _wlocale[MAX_LC_LEN];
+
+    /* Early input validation */
+    if ( (_category < LC_MIN) || (_category > LC_MAX) || _locale == nullptr)
+        return nullptr;
+
+    if ( __acrt_MultiByteToWideChar(CP_ACP, 0, _locale, -1, _wlocale, _countof(_wlocale)) == 0 )
+    { // conversion to wide char failed
+        return nullptr;
+    }
+
+    return _wcreate_locale(_category, _wlocale);
+}
+
+/*
+*char * setlocale(int category, char *locale) - Set one or all locale categories
+*
+*Purpose:
+*       The setlocale() routine allows the user to set one or more of
+*       the locale categories to the specific locale selected by the
+*       user.  [ANSI]
+*
+*       NOTE: Under !_INTL, the C libraries only support the "C" locale.
+*       Attempts to change the locale will fail.
+*
+*Entry:
+*       int category = One of the locale categories defined in locale.h
+*       char *locale = String identifying a specific locale or nullptr to
+*                  query the current locale.
+*
+*Exit:
+*       If supplied locale pointer == nullptr:
+*
+*           Return pointer to current locale string and do NOT change
+*           the current locale.
+*
+*       If supplied locale pointer != nullptr:
+*
+*           If locale string is '\0', set locale to default.
+*
+*           If desired setting can be honored, return a pointer to the
+*           locale string for the appropriate category.
+*
+*           If desired setting can NOT be honored, return nullptr.
+*
+*Exceptions:
+*       Compound locale strings of the form "LC_COLLATE=xxx;LC_CTYPE=xxx;..."
+*       are allowed for the LC_ALL category.  This is to support the ability
+*       to restore locales with the returned string, as specified by ANSI.
+*       Setting the locale with a compound locale string will succeed unless
+*       *all* categories failed.  The returned string will reflect the current
+*       locale.  For example, if LC_CTYPE fails in the above string, setlocale
+*       will return "LC_COLLATE=xxx;LC_CTYPE=yyy;..." where yyy is the
+*       previous locale (or the C locale if restoring the previous locale
+*       also failed).  Unrecognized LC_* categories are ignored.
+*
+*/
+
+wchar_t * __cdecl _wsetlocale (
+        int _category,
+        const wchar_t *_wlocale
+        )
+{
+    wchar_t * retval=nullptr;
+    __crt_locale_data* ptloci = nullptr;
+
+    /* Validate category */
+    _VALIDATE_RETURN(LC_MIN <= _category && _category <= LC_MAX, EINVAL, nullptr);
+
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    // Deadlock Avoidance:  When a new thread is created in the process, we
+    // create a new PTD for the thread.  The PTD initialization function is
+    // called under the loader lock.  This initialization function will also
+    // acquire the locale lock in order to acquire a reference to the current
+    // global locale for the new thread.
+    //
+    // Some of the locale APIs are not available on all supported target OSes.
+    // We dynamically obtain these libraries via LoadLibrary/GetProcAddress.
+    // We must ensure that no call to LoadLibrary is made while we hold the
+    // locale lock, lest we deadlock due to lock order inversion between the
+    // loader lock and the locale lock.
+    //
+    // This function call here will ensure that any required modules are loaded
+    // before we acquire the locale lock.
+    __acrt_eagerly_load_locale_apis();
+
+    __acrt_update_thread_locale_data();
+
+    // Prevent global locale resynchronization - we call things like stricmp() further down
+    // without passing our _locale_t which would trigger a resynchronization.
+    // Use _WSETLOCALE_AVOID_SYNC_LOCALE_BIT to avoid interfering with other locale settings
+    // (see _configthreadlocale() for details).
+
+    // This may not be necessary anymore and may be a hold-over from when _wsetlocale called
+    // setlocale instead of the other way around.
+    // (MSFT:20394962 - Investigate whether _WSETLOCALE_AVOID_SYNC_LOCALE_BIT is needed)
+    __acrt_disable_global_locale_sync(ptd, _WSETLOCALE_AVOID_SYNC_LOCALE_BIT);
+
+    __crt_call_and_cleanup([&]
+    {
+        if ((ptloci = _calloc_crt_t(__crt_locale_data, 1).detach()) != nullptr)
+        {
+            __acrt_lock_and_call(__acrt_locale_lock, [&]
+            {
+                _copytlocinfo_nolock(ptloci, ptd->_locale_info);
+
+                if ((retval = _wsetlocale_nolock(ptloci, _category, _wlocale)) != 0)
+                {
+                    // If no call has been made to setlocale to change locale from "C" locale
+                    // to some other locale, we keep locale_changed = 0. Other functions that
+                    // depend on locale use this variable to optimize performance for C locale
+                    // which is normally the case in applications.
+                    if (_wlocale != nullptr)
+                    {
+                        if (wcscmp(_wlocale, __acrt_wide_c_locale_string) != 0)
+                        {
+                            __acrt_set_locale_changed();
+                        }
+                        // If it is again set to the C locale, could we not retain that state?
+                        // else
+                        // {
+                        //    __acrt_set_locale_unchanged();
+                        // }
+                    }
+
+                    (void)_updatetlocinfoEx_nolock(&ptd->_locale_info, ptloci);
+                    __acrt_release_locale_ref(ptloci);
+                    // Note that after incrementing _own_locale, if this thread doesn't
+                    // have its own locale, _own_locale variable should be 1.
+
+                    // Do not use __acrt_should_sync_with_global_locale() because
+                    // _WSETLOCALE_AVOID_SYNC_LOCALE_BIT will interfere.
+                    if (!(ptd->_own_locale & _PER_THREAD_LOCALE_BIT) &&
+                        !(__globallocalestatus & _GLOBAL_LOCALE_BIT))
+                    {
+                        (void)_updatetlocinfoEx_nolock(&__acrt_current_locale_data.value(), ptd->_locale_info);
+                        sync_legacy_variables_lk();
+                    }
+                }
+                else
+                {
+                    __acrt_release_locale_ref(ptloci);
+                    __acrt_free_locale(ptloci);
+                }
+            });
+        }
+    },
+    [&]{ __acrt_enable_global_locale_sync(ptd, _WSETLOCALE_AVOID_SYNC_LOCALE_BIT); });
+
+    return retval;
+}
+
+static wchar_t * __cdecl _wsetlocale_nolock(
+        __crt_locale_data* ploci,
+        int _category,
+        const wchar_t *_wlocale
+        )
+{
+    wchar_t * retval;
+    /* Interpret locale */
+
+    if (_category != LC_ALL)
+    {
+        retval = (_wlocale) ? _wsetlocale_set_cat(ploci, _category,_wlocale) :
+            ploci->lc_category[_category].wlocale;
+
+    } else { /* LC_ALL */
+        wchar_t lctemp[MAX_LC_LEN];
+        int i;
+        int same = 1;
+        int fLocaleSet = 0; /* flag to indicate if anything successfully set */
+
+        if (_wlocale != nullptr)
+        {
+            if ( (_wlocale[0]==L'L') && (_wlocale[1]==L'C') && (_wlocale[2]==L'_') )
+            {
+                /* parse compound locale string */
+                size_t len;
+                const wchar_t * p = _wlocale;  /* start of string to parse */
+                const wchar_t * s;
+
+                do {
+                    s = wcspbrk(p, L"=;");
+
+                    if (s == nullptr || (len=(size_t)(s - p)) == 0 || (*s == L';'))
+                        return nullptr;  /* syntax error */
+
+                    /* match with known LC_ strings, if possible, else ignore */
+                    for (i=LC_ALL+1; i<=LC_MAX; i++)
+                    {
+                        if ((!wcsncmp(__lc_category[i].catname,p,len))
+                            && (len==wcslen(__lc_category[i].catname)))
+                        {
+                            break;  /* matched i */
+                        }
+                    } /* no match if (i>LC_MAX) -- just ignore */
+
+                    if ((len = wcscspn(++s, L";")) == 0 && *s != L';')
+                        return nullptr;  /* syntax error */
+
+                    if (i<=LC_MAX)
+                    {
+                        _ERRCHECK(wcsncpy_s(lctemp, _countof(lctemp), s, len));
+                        lctemp[len]=L'\0';   /* null terminate string */
+
+                        /* don't fail unless all categories fail */
+                        if (_wsetlocale_set_cat(ploci, i,lctemp))
+                            fLocaleSet++;       /* record a success */
+                    }
+                    if (*(p = s+len)!=L'\0')
+                        p++;  /* skip ';', if present */
+
+                } while (*p);
+
+                retval = (fLocaleSet) ? _wsetlocale_get_all(ploci) : nullptr;
+
+            } else { /* simple LC_ALL locale string */
+
+                UINT code_page;
+                wchar_t localeNameTemp[LOCALE_NAME_MAX_LENGTH];
+                /* confirm locale is supported, get expanded locale */
+                retval = _expandlocale(_wlocale, lctemp, _countof(lctemp), localeNameTemp, _countof(localeNameTemp), code_page);
+                if (retval != 0)
+                {
+                    for (i=LC_MIN; i<=LC_MAX; i++)
+                    {
+                        if (i!=LC_ALL)
+                        {
+                            if (wcscmp(lctemp, ploci->lc_category[i].wlocale) != 0)
+                            { // does not match the LC_ALL locale
+                                if (_wsetlocale_set_cat(ploci, i, lctemp))
+                                {
+                                    fLocaleSet++;   /* record a success */
+                                }
+                                else
+                                {
+                                    same = 0;       /* record a failure */
+                                }
+                            }
+                            else
+                                fLocaleSet++;   /* trivial succcess */
+                        }
+                    }
+                    if (same) /* needn't call setlocale_get_all() if all the same */
+                    {
+                        retval = _wsetlocale_get_all(ploci);
+                        /* retval set above */
+                    }
+                    else
+                        retval = (fLocaleSet) ? _wsetlocale_get_all(ploci) : nullptr;
+                }
+            }
+        } else { /* LC_ALL & nullptr */
+            retval = _wsetlocale_get_all (ploci);
+        }
+    }
+
+    /* common exit point */
+    return retval;
+} /* setlocale */
+
+
+static wchar_t * __cdecl _wsetlocale_set_cat (
+        __crt_locale_data* ploci,
+        int category,
+        const wchar_t * wlocale
+        )
+{
+    wchar_t * oldlocale;
+    wchar_t * oldlocalename;
+    UINT oldcodepage;
+
+    UINT cptemp;
+    wchar_t lctemp[MAX_LC_LEN];
+    wchar_t localeNameString[LOCALE_NAME_MAX_LENGTH];
+    wchar_t * pch = nullptr;
+    wchar_t * pch_cat_locale = nullptr;
+    size_t cch = 0;
+    unsigned short out[sizeof(_first_127char)];
+    int i;
+    __acrt_ptd* const ptd = __acrt_getptd();
+    __crt_ctype_compatibility_data* _Loc_c = ptd->_setloc_data._Loc_c; // __setloc_data._Loc_c is array
+    int _LOC_CCACHE = _countof(ptd->_setloc_data._Loc_c);
+    __crt_ctype_compatibility_data buf1, buf2;
+
+    if (!_expandlocale(wlocale, lctemp, _countof(lctemp), localeNameString, _countof(localeNameString), cptemp))
+        return nullptr;
+
+    // if this category's locale hadn't changed
+    if (wcscmp(lctemp, ploci->lc_category[category].wlocale) == 0)
+    {
+        return ploci->lc_category[category].wlocale;
+    }
+
+    cch = wcslen(lctemp) + 1;
+    if ((pch = static_cast<wchar_t*>(_malloc_crt(sizeof(int) + (cch * sizeof(wchar_t))))) == nullptr)
+        return nullptr;  /* error if malloc fails */
+
+    pch_cat_locale = pch + (sizeof(int) / sizeof(wchar_t));
+
+     /* save for possible restore */
+    oldlocale = ploci->lc_category[category].wlocale;
+    oldlocalename = ploci->locale_name[category];
+    oldcodepage = ploci->_public._locale_lc_codepage;
+
+    /* update locale string */
+    _ERRCHECK(wcscpy_s(pch_cat_locale, cch, lctemp));
+    ploci->lc_category[category].wlocale = pch_cat_locale;
+
+    /* Copy locale name */
+    if (lctemp[0] == L'C' && lctemp[1] == L'\x0') // if "C" locale
+        ploci->locale_name[category] = nullptr;
+    else
+        ploci->locale_name[category] = __acrt_copy_locale_name(localeNameString);
+
+    /* To speedup locale based comparisions, we identify if the current
+     * local has first 127 character set same as CLOCALE. If yes then
+     * ploci->lc_clike = TRUE.
+     */
+
+    if (category==LC_CTYPE)
+    {
+        ploci->_public._locale_lc_codepage = cptemp;
+        buf1 = _Loc_c[_LOC_CCACHE -1];
+        /* brings the recently used codepage to the top. or else shifts
+         * every thing down by one so that new _Loc_c can be placed at
+         * the top.
+         */
+        for ( i = 0; i < _LOC_CCACHE; i++)
+        {
+            if (ploci->_public._locale_lc_codepage == _Loc_c[i].id)
+            {
+                /* We don't really want to swap cache around in case what we are looking
+                 *  for is the first element of the cache
+                 */
+                if (i!=0)
+                {
+                    _Loc_c[0] = _Loc_c[i];
+                    _Loc_c[i] = buf1;
+                }
+                break;
+            }
+            else
+            {
+                buf2 = _Loc_c[i];
+                _Loc_c[i] = buf1;
+                buf1 = buf2;
+            }
+        }
+        if ( i == _LOC_CCACHE)
+        {
+            if ( __acrt_GetStringTypeA(nullptr, CT_CTYPE1,
+                                       _first_127char,
+                                       sizeof(_first_127char),
+                                       out,
+                                       ploci->_public._locale_lc_codepage,
+                                       TRUE ))
+            {
+                int j;
+                for ( j = 0; j < sizeof(_first_127char); j++)
+                    out[j] = out[j]&
+                            (_UPPER|_LOWER|_DIGIT|_SPACE|_PUNCT|_CONTROL|_BLANK|_HEX|_ALPHA);
+                if ( !memcmp(out, _ctype_loc_style, (sizeof(_first_127char)/sizeof(char))*sizeof(short)))
+                {
+                    _Loc_c[0].is_clike = TRUE;
+                }
+                else
+                {
+                    _Loc_c[0].is_clike = FALSE;
+                }
+            }
+            else
+                _Loc_c[0].is_clike = FALSE;
+            _Loc_c[0].id = ploci->_public._locale_lc_codepage;
+        }
+        ploci->lc_clike = _Loc_c[0].is_clike;
+    } /* category==LC_CTYPE */
+    else if ( category == LC_COLLATE )
+        ploci->lc_collate_cp = cptemp;
+    else if ( category == LC_TIME )
+        ploci->lc_time_cp = cptemp;
+
+    if (__lc_category[category].init(ploci) != 0)
+    {
+        /* restore previous state */
+        ploci->lc_category[category].wlocale = oldlocale;
+        _free_crt(ploci->locale_name[category]);
+        ploci->locale_name[category] = oldlocalename;
+        _free_crt(pch);
+        ploci->_public._locale_lc_codepage = oldcodepage;
+
+        return nullptr; /* error if non-zero return */
+    }
+
+    /* locale set up successfully */
+    /* Cleanup */
+    if ((oldlocale != __acrt_wide_c_locale_string) &&
+        (InterlockedDecrement(ploci->lc_category[category].wrefcount) == 0)
+        )
+    {
+        _ASSERT(0);
+        _free_crt(ploci->lc_category[category].wrefcount);
+        _free_crt(ploci->lc_category[category].refcount);
+        _free_crt(ploci->locale_name[category]);
+        ploci->lc_category[category].wlocale = nullptr;
+        ploci->locale_name[category] = nullptr;
+    }
+    if (pch)
+    {
+        reinterpret_cast<long&>(*pch) = 1;
+    }
+    ploci->lc_category[category].wrefcount = reinterpret_cast<long*>(pch);
+
+    return ploci->lc_category[category].wlocale;
+} /* _wsetlocale_set_cat */
+
+
+
+static wchar_t * __cdecl _wsetlocale_get_all ( __crt_locale_data* ploci)
+{
+    int i;
+    int same = 1;
+    wchar_t *pch = nullptr;
+    size_t cch = 0;
+    long *refcount = nullptr;
+    size_t refcountSize = 0;
+
+    /* allocate memory if necessary */
+    refcountSize = sizeof(int) + (sizeof(wchar_t) * (MAX_LC_LEN+1) * (LC_MAX-LC_MIN+1)) + (sizeof(wchar_t) * CATNAMES_LEN);
+    if ( (refcount = static_cast<long*>(_malloc_crt(refcountSize))) == nullptr)
+        return nullptr;
+
+    pch = ((wchar_t*)refcount) + (sizeof(int) / sizeof(wchar_t));
+    cch = (refcountSize - sizeof(int)) / sizeof(wchar_t);
+    *pch = L'\0';
+    *refcount = 1;
+    for (i=LC_MIN+1; ; i++)
+    {
+        _wcscats(pch, cch, 3, __lc_category[i].catname, L"=", ploci->lc_category[i].wlocale);
+        if (i<LC_MAX)
+        {
+            _ERRCHECK(wcscat_s(pch, cch, L";"));
+            if (wcscmp(ploci->lc_category[i].wlocale, ploci->lc_category[i+1].wlocale))
+                same=0;
+        }
+        else
+        {
+            if (!same) {
+                if (ploci->lc_category[LC_ALL].wrefcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].wrefcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].wrefcount);
+                }
+                if (ploci->lc_category[LC_ALL].refcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].refcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].refcount);
+                }
+                ploci->lc_category[LC_ALL].refcount = nullptr;
+                ploci->lc_category[LC_ALL].locale = nullptr;
+                ploci->lc_category[LC_ALL].wrefcount = refcount;
+                return ploci->lc_category[LC_ALL].wlocale = pch;
+            } else {
+                _free_crt(refcount);
+                if (ploci->lc_category[LC_ALL].wrefcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].wrefcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].wrefcount);
+                }
+                if (ploci->lc_category[LC_ALL].refcount != nullptr &&
+                    InterlockedDecrement(ploci->lc_category[LC_ALL].refcount) == 0) {
+                    _ASSERT(0);
+                    _free_crt(ploci->lc_category[LC_ALL].refcount);
+                }
+                ploci->lc_category[LC_ALL].refcount = nullptr;
+                ploci->lc_category[LC_ALL].locale = nullptr;
+                ploci->lc_category[LC_ALL].wrefcount = nullptr;
+                ploci->lc_category[LC_ALL].wlocale = nullptr;
+                return ploci->lc_category[LC_CTYPE].wlocale;
+            }
+        }
+    }
+} /* _wsetlocale_get_all */
+
+// --- BCP-47 tag parsing for _expandlocale() ---
+//
+// Provides parse_bcp47() which parses a given locale expression and updates a __crt_locale_strings structure accordingly.
+// Unsupported:
+// * Extension and private tags
+// * 4-8 character language subtags
+// * Grandfathered tags
+// * Lone code page specifiers (POSIX extension for BCP-47)
+
+enum class _bcp47_section_delimiter
+{
+    normal,
+    end_of_string,
+    code_page
+};
+
+struct _bcp47_section
+{
+    wchar_t const *          ptr;
+    size_t                   length;
+    _bcp47_section_delimiter delimiter;
+};
+
+static _bcp47_section_delimiter categorize_delimiter(wchar_t const wc)
+{
+    switch (wc)
+    {
+        case '-':
+        case '_':
+            return _bcp47_section_delimiter::normal;
+        case '.':
+            return _bcp47_section_delimiter::code_page;
+        case '\0':
+        default:
+            return _bcp47_section_delimiter::end_of_string;
+    }
+}
+
+static bool string_is_alpha(wchar_t const * const str, size_t const len)
+{
+    for (size_t i = 0; i < len; ++i)
+    {
+        if (!__ascii_isalpha(str[i]))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool string_is_digit(wchar_t const * const str, size_t const len)
+{
+    for (size_t i = 0; i < len; ++i)
+    {
+        if (!__ascii_isdigit(str[i]))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool parse_bcp47_language(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::normal)
+    {
+        return false;
+    }
+
+    if (section.length < 2 || section.length > 3)
+    {
+        return false; // Failure, only 2-3 letter language codes permitted.
+    }
+
+    if (!string_is_alpha(section.ptr, section.length))
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncpy_s(names->szLanguage, _countof(names->szLanguage), section.ptr, section.length));
+    _ERRCHECK(wcsncpy_s(names->szLocaleName, _countof(names->szLocaleName), section.ptr, section.length));
+    return true;
+}
+
+static bool parse_bcp47_script(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::normal)
+    {
+        return false;
+    }
+
+    if (section.length != 4) {
+        return false; // Failure, only 4 letter script codes permitted.
+    }
+
+    if (!string_is_alpha(section.ptr, section.length))
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), L"-", 1));
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), section.ptr, section.length));
+    return true;
+}
+
+static bool parse_bcp47_region(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::normal)
+    {
+        return false;
+    }
+
+    if (   !(section.length == 2 && string_is_alpha(section.ptr, section.length))  // if not 2 letters
+        && !(section.length == 3 && string_is_digit(section.ptr, section.length))) // and not 3 digits
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncpy_s(names->szCountry, _countof(names->szCountry), section.ptr, section.length));
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), L"-", 1));
+    _ERRCHECK(wcsncat_s(names->szLocaleName, _countof(names->szLocaleName), section.ptr, section.length));
+    return true;
+}
+
+static bool parse_bcp47_code_page(__crt_locale_strings * const names, _bcp47_section const& section)
+{
+    if (section.delimiter != _bcp47_section_delimiter::code_page)
+    {
+        return false;
+    }
+
+    _ERRCHECK(wcsncpy_s(names->szCodePage, _countof(names->szCodePage), section.ptr, section.length));
+    return true; // Success
+}
+
+static bool parse_bcp47(__crt_locale_strings * const names, const wchar_t * const expr)
+{
+    wchar_t const * p = expr;
+    wchar_t const * const delimiters = L"-_.";
+
+    memset(names, 0, sizeof(__crt_locale_strings));
+
+    size_t const max_sections = 4;
+    _bcp47_section sections[max_sections];
+    size_t num_sections = 0;
+
+    for (auto last_delimiter = _bcp47_section_delimiter::normal;
+         last_delimiter != _bcp47_section_delimiter::end_of_string;
+         last_delimiter = categorize_delimiter(*p++)
+        )
+    {
+        if (num_sections >= max_sections)
+        {
+            // Didn't reach end of string before running out of sections to parse.
+            return false;
+        }
+
+        size_t const section_length = (last_delimiter != _bcp47_section_delimiter::code_page)
+            ? wcscspn(p, delimiters) : wcslen(p);
+
+        sections[num_sections].ptr = p;
+        sections[num_sections].length = section_length;
+        sections[num_sections].delimiter = last_delimiter;
+
+        p += section_length;
+        ++num_sections;
+    }
+
+    switch (num_sections)
+    {
+        case 1:
+            // en
+            return parse_bcp47_language(names, sections[0]);
+        case 2:
+            // en-US
+            // zh-Hans
+            // en.utf-8
+            // .utf-8
+            return parse_bcp47_language(names, sections[0])
+                   && (   parse_bcp47_script(names, sections[1])
+                       || parse_bcp47_region(names, sections[1])
+                       || parse_bcp47_code_page(names, sections[1])
+                      );
+        case 3:
+            // en-US.utf-8
+            // zh-Hans-HK
+            return parse_bcp47_language(names, sections[0])
+                   && (    parse_bcp47_script(names, sections[1]) && (parse_bcp47_region(names, sections[2]) || parse_bcp47_code_page(names, sections[2]))
+                       || (parse_bcp47_region(names, sections[1]) &&  parse_bcp47_code_page(names, sections[2]))
+                      );
+        case 4:
+            // zh-Hans-HK.utf-8
+            return parse_bcp47_language(names, sections[0])
+                && parse_bcp47_script(names, sections[1])
+                && parse_bcp47_region(names, sections[2])
+                && parse_bcp47_code_page(names, sections[3]);
+        default:
+            return false;
+    }
+}
+
+// Utility functions/structs for _expandlocale().
+
+static int get_default_code_page(wchar_t const * const valid_windows_locale_name)
+{
+    int code_page{};
+
+    int const size_written = __acrt_GetLocaleInfoEx(
+        valid_windows_locale_name,
+        LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
+        reinterpret_cast<LPWSTR>(&code_page),
+        sizeof(int) / sizeof(wchar_t)
+        );
+
+    if (size_written == 0 || code_page == 0)
+    {   // Default to UTF-8 if could not find or no default code page.
+        return CP_UTF8;
+    }
+
+    return code_page;
+}
+
+class _expandlocale_locale_name_cache
+{
+    // Scope guard to keep invariants in _expandlocale for the localeNameOutput and _cacheLocaleName variables.
+    // The cacheLocaleName/localeNameOutput is the only cache where work is done progressively in the cache value,
+    // (inside __acrt_get_qualified_locale and __acrt_get_qualified_locale_downlevel)
+    // so we must save/restore at function start and invalidate the cache once we have stuff to commit to both.
+public:
+    _expandlocale_locale_name_cache(
+        wchar_t *                     const localeNameOutput,
+        size_t                        const localeNameSizeInChars,
+        __crt_qualified_locale_data * const psetloc_data
+    ) : _localeNameOutput(localeNameOutput),
+        _localeNameSizeInChars(localeNameSizeInChars),
+        _psetloc_data(psetloc_data),
+        _committed(false)
+    {
+        _ERRCHECK(wcsncpy_s(localeNameOutput, localeNameSizeInChars, psetloc_data->_cacheLocaleName, _countof(psetloc_data->_cacheLocaleName)));
+    }
+
+    ~_expandlocale_locale_name_cache()
+    {
+        if (!_committed)
+        {
+            _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), _localeNameOutput, _localeNameSizeInChars));
+        }
+    }
+
+    _expandlocale_locale_name_cache(_expandlocale_locale_name_cache const&) = delete;
+    _expandlocale_locale_name_cache& operator=(_expandlocale_locale_name_cache const&) = delete;
+
+    void commit_locale_name(wchar_t const * const new_locale_name, size_t const new_locale_name_length)
+    {
+        _ERRCHECK(wcsncpy_s(_psetloc_data->_cacheLocaleName, _countof(_psetloc_data->_cacheLocaleName), new_locale_name, new_locale_name_length));
+        commit_locale_name_cache_already_updated(new_locale_name, new_locale_name_length);
+    }
+
+    void commit_locale_name_cache_already_updated(wchar_t const * const new_locale_name, size_t const new_locale_name_length)
+    {
+        _ERRCHECK(wcsncpy_s(_localeNameOutput, _localeNameSizeInChars, new_locale_name, new_locale_name_length));
+        _committed = true;
+    }
+
+private:
+    wchar_t *                     _localeNameOutput;
+    size_t                        _localeNameSizeInChars;
+    __crt_qualified_locale_data * _psetloc_data;
+    bool                          _committed;
+};
+
+wchar_t * _expandlocale(
+    wchar_t const * const expr,
+    wchar_t *       const output,
+    size_t          const sizeInChars,
+    wchar_t *       const localeNameOutput,
+    size_t          const localeNameSizeInChars,
+    UINT&                 output_code_page
+    )
+{
+    // Returns: locale name to return to user (lifetime bound to PTD variable _cacheout)
+    // Out Parameters:
+    //  * output: locale name to return to user (lifetime bound to supplied buffer)
+    //  * localeNameOutput: normalized locale name to be used internally (lifetime bound to supplied buffer)
+    //  * output_code_page: code page used
+    //
+    // Effects:
+    //  Parses an input locale string and returns the string that will replicate the effects just taken (output), the string to be used
+    //  for Win32 calls (localeNameOutput), and the code page.
+    //  Note that there are three modes here:
+    //  * Legacy and Windows Locale Names:
+    //      The output locale string and internally used locale string become normalized for Win32 APIs.
+    //      Neither necessarily match the user input locale.
+    //      Uses ACP as default if Windows does not know the code page.
+    //  * Permissive Windows locale names:
+    //      Ask Windows whether full given user string is a known locale name.
+    //      In that case, the output locale string, internally used locale string, and user input locale all match.
+    //      Uses UTF-8 as default if Windows does not know the code page.
+    //  * BCP-47 Locale Names:
+    //      Windows doesn't recognize BCP-47 + code page specifiers, but we must support them for proper UTF-8 support.
+    //      The output locale name must include the code page, but internally we modify the format so Windows understands it.
+    //      Uses UTF-8 as default if Windows does not know the code page.
+    //
+    //  Also populates _psetloc_data structure from the PTD:
+    //  Caching Internals:
+    //    * _cachein: Caches last successful 'expr'.
+    //    * _cacheout: Caches last successful 'output' (which is also the return value).
+    //    * _cachecp: Caches last successful 'output_code_page'.
+    //    * _cacheLocaleName: Caches last successful 'localeNameOutput'.
+    //  Legacy Internals (used by __acrt_get_qualified_locale and __acrt_get_qualified_locale_downlevel only):
+    //    * pchLanguage: Pointer to start of language name, ex: "English"
+    //    * pchCountry: Pointer to start of country/region name, ex: "United States"
+    //    * iLocState: Used to record the match degree for locales checked (i.e. language and region match vs just language match)
+    //    * bAbbrevLanguage: Whether language name is a three-letter short-form, ex: "ENU"
+    //    * bAbbrevCountry: Whether country/region name is a three letter short-form, ex: "USA"
+    //    * iPrimaryLen: Length of pchLanguage portion of locale string
+    //  Also in _psetloc_data, but not used in _expandlocale: _Loc_c
+
+    if (!expr)
+    {
+        return nullptr; // error if no input
+    }
+
+    // C locale
+    // Callers know that LocaleNameOutput has not been updated and check for "C" locale before using it.
+    if (expr[0] == L'C' && expr[1] == L'\0')
+    {
+        _ERRCHECK(wcscpy_s(output, sizeInChars, L"C"));
+        output_code_page = CP_ACP;
+        return output;
+    }
+
+    __crt_qualified_locale_data * const _psetloc_data    = &__acrt_getptd()->_setloc_data;
+    UINT *                        const pcachecp         = &_psetloc_data->_cachecp;
+    wchar_t *                     const cachein          = _psetloc_data->_cachein;
+    size_t                        const cacheinLen       = _countof(_psetloc_data->_cachein);
+    wchar_t *                     const cacheout         = _psetloc_data->_cacheout;
+    size_t                        const cacheoutLen      = _countof(_psetloc_data->_cacheout);
+    size_t                              charactersInExpression = 0;
+    int                                 iCodePage = 0;
+
+    // This guard owns access to localeNameOutput. It expresses the invariants that localeNameOutput and _cacheLocaleName have.
+    _expandlocale_locale_name_cache locale_name_guard(localeNameOutput, localeNameSizeInChars, _psetloc_data);
+
+    // First, make sure we didn't just do this one
+    charactersInExpression = wcslen(expr);
+    if (charactersInExpression >= MAX_LC_LEN ||       // we would never have cached this
+        (wcscmp(cacheout, expr) && wcscmp(cachein, expr)))
+    {
+        __crt_locale_strings names;
+        BOOL getqloc_results = FALSE;
+        BOOL const isDownlevel = !__acrt_can_use_vista_locale_apis();
+
+        // Check if can parse as Legacy/Windows locale name
+        if (__lc_wcstolc(&names, expr) == 0)
+        {
+            if (isDownlevel)
+            {
+                getqloc_results = __acrt_get_qualified_locale_downlevel(&names, pcachecp, &names);
+            }
+            else
+            {
+                getqloc_results = __acrt_get_qualified_locale(&names, pcachecp, &names);
+            }
+        }
+
+        // If successfully parsed as Legacy/Windows name
+        if (getqloc_results)
+        {
+            // Legacy/Windows name resolution returns applies normalization to both returned and internally used locale names.
+            __lc_lctowcs(cacheout, cacheoutLen, &names);
+
+            // __acrt_get_qualified_locale and __acrt_get_qualified_locale_downlevel update _cacheLocaleName - if successful commit locale changes
+            locale_name_guard.commit_locale_name_cache_already_updated(names.szLocaleName, wcslen(names.szLocaleName) + 1);
+        }
+        else if (__acrt_IsValidLocaleName(expr))
+        {
+            // Windows recognizes the locale expression - only work is to grab the code page to be used.
+            iCodePage = get_default_code_page(expr);
+
+            // Commit code page
+            *pcachecp = static_cast<WORD>(iCodePage);
+
+            // Commit locale name that we will return to the user (same as input locale string).
+            _ERRCHECK(wcsncpy_s(cacheout, cacheoutLen, expr, charactersInExpression + 1));
+
+            // Commit locale name for internal use (same as input locale string).
+            locale_name_guard.commit_locale_name(expr, charactersInExpression + 1);
+        }
+        else if (parse_bcp47(&names, expr) && __acrt_IsValidLocaleName(names.szLocaleName))
+        {
+            // Parsed as Windows-recognized BCP-47 tag
+            wchar_t const * const normalized_locale_name = names.szLocaleName;
+
+            if (names.szCodePage[0])
+            {
+                wchar_t const * const cp = names.szCodePage;
+
+                // Allow .utf8/.utf-8 for BCP-47 tags.
+                if (   __ascii_towlower(cp[0]) == L'u'
+                    && __ascii_towlower(cp[1]) == L't'
+                    && __ascii_towlower(cp[2]) == L'f'
+                    &&     (cp[3] == L'8' && cp[4] == L'\0')
+                        || (cp[3] == L'-' && cp[4] == L'8' && cp[5] == L'\0'))
+                {
+                    iCodePage = CP_UTF8;
+                }
+                else
+                {
+                    // Other codepage tokens (fr-FR.1252, etc.) aren't supported for BCP-47 tags (eg: Use Unicode!)
+                    return nullptr;
+                }
+            }
+            else
+            {
+                iCodePage = get_default_code_page(normalized_locale_name);
+            }
+
+            // Commit code page
+            *pcachecp = static_cast<WORD>(iCodePage);
+
+            // Commit locale name that we will return to the user (same as input locale string).
+            _ERRCHECK(wcsncpy_s(cacheout, cacheoutLen, expr, charactersInExpression + 1));
+
+            // Commit normalized name for internal use.
+            locale_name_guard.commit_locale_name(normalized_locale_name, wcslen(normalized_locale_name) + 1);
+        }
+        else
+        {
+            return nullptr;  // input unrecognized as locale name
+        }
+
+        // Operation succeeded - commit input cache.
+        if (*expr && charactersInExpression < MAX_LC_LEN)
+        {
+            _ERRCHECK(wcsncpy_s(cachein, cacheinLen, expr, charactersInExpression + 1));
+        }
+        else
+        {
+            *cachein = L'\x0';
+        }
+    }
+
+    output_code_page = *pcachecp; // Update code page
+
+    _ERRCHECK(wcscpy_s(output, sizeInChars, cacheout));
+    return cacheout; // Return locale name to be given back to user, with lifetime bound in PTD
+}
+
+/* helpers */
+
+void _wcscats ( wchar_t *outstr, size_t numberOfElements, int n, ...)
+{
+    int i;
+    va_list substr;
+
+    va_start (substr, n);
+
+    for (i =0; i<n; i++)
+    {
+        _ERRCHECK(wcscat_s(outstr, numberOfElements, va_arg(substr, wchar_t *)));
+    }
+    va_end(substr);
+}
+
+// Parse the wlocale string to find the array of language/region/codepage strings (if available)
+// in the form .CodePage, Language, Language_Region, Language_Region.Codepage, or Language.CodePage
+// If the input is a BCP-47 tag, then that tag is returned in the names language.
+int __lc_wcstolc ( __crt_locale_strings *names, const wchar_t *wlocale)
+{
+    int i;
+    size_t len;
+    wchar_t wch;
+
+    memset((void *)names, '\0', sizeof(__crt_locale_strings));  /* clear out result */
+
+    if (*wlocale==L'\0')
+        return 0; /* trivial case */
+
+    /* only code page is given */
+    if (wlocale[0] == L'.' && wlocale[1] != L'\0')
+    {
+        _ERRCHECK(wcsncpy_s(names->szCodePage, _countof(names->szCodePage), &wlocale[1], MAX_CP_LEN-1));
+        /* Make sure to null terminate the string in case wlocale is > MAX_CP_LEN */
+        names->szCodePage[ MAX_CP_LEN -1] = 0;
+        return 0;
+    }
+
+    // Looks like Language_Country/Region.Codepage
+    for (i=0; ; i++)
+    {
+        // _ language country/region separator, . is before codepage, either , or \0 are end of string.
+        len = wcscspn(wlocale, L"_.,");
+        if (len == 0)
+            return -1;  /* syntax error, can't start with a separator */
+
+        wch = wlocale[len];
+
+        if ((i == 0) && (len < MAX_LANG_LEN))
+        {
+            _ERRCHECK(wcsncpy_s(names->szLanguage, _countof(names->szLanguage), wlocale, len));
+            if (wch == L'.')
+            {
+                // '.' is a delimiter before codepage, so codepage is expected next (skip country/region)
+                i++;
+            }
+        }
+
+        else if ((i==1) && (len<MAX_CTRY_LEN) && (wch!=L'_'))
+            _ERRCHECK(wcsncpy_s(names->szCountry, _countof(names->szCountry), wlocale, len));
+
+        else if ((i==2) && (len<MAX_CP_LEN) && (wch==L'\0' || wch==L','))
+            _ERRCHECK(wcsncpy_s(names->szCodePage, _countof(names->szCodePage), wlocale, len));
+
+        else
+            return -1;  /* error parsing wlocale string */
+
+        if (wch==L',')
+        {
+            /* modifier not used in current implementation, but it
+               must be parsed to for POSIX/XOpen conformance */
+            /*  wcsncpy(names->szModifier, wlocale, MAX_MODIFIER_LEN-1); */
+            break;
+        }
+
+        if (!wch)
+            break;
+        wlocale+=(len+1);
+    }
+    return 0;
+}
+// Append locale name pieces together in the form of "Language_country/region.CodePage"
+// Note that the preferred form is the BCP-47 tag, but we don't want to change legacy names
+void __lc_lctowcs ( wchar_t *locale, size_t numberOfElements, const __crt_locale_strings *names)
+{
+    _ERRCHECK(wcscpy_s(locale, numberOfElements, names->szLanguage));
+    if (*(names->szCountry))
+        _wcscats(locale, numberOfElements, 2, L"_", names->szCountry);
+    if (*(names->szCodePage))
+        _wcscats(locale, numberOfElements, 2, L".", names->szCodePage);
+}
+
+// Create a copy of a locale name string
+LPWSTR __cdecl __acrt_copy_locale_name(LPCWSTR localeName)
+{
+    size_t cch;
+    wchar_t* localeNameCopy;
+
+    if (!localeName) // Input cannot be nullptr
+        return nullptr;
+
+    cch = wcsnlen(localeName, LOCALE_NAME_MAX_LENGTH);
+    if (cch >= LOCALE_NAME_MAX_LENGTH) // locale name length must be <= LOCALE_NAME_MAX_LENGTH
+        return nullptr;
+
+    if ((localeNameCopy = (wchar_t *) _malloc_crt((cch + 1) * sizeof(wchar_t))) == nullptr)
+        return nullptr;
+
+    _ERRCHECK(wcsncpy_s(localeNameCopy, cch+1, localeName, cch+1));
+    return localeNameCopy;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/chsize.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/chsize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..79131ad38ce05da9a8abb207339a2b4c96e6905b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/chsize.cpp	
@@ -0,0 +1,148 @@
+//
+// chsize.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _chsize() and _chsize_s(), which change the size of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+// Changes the size of the given file, either extending or truncating it.  The
+// file must have been opened with write permissions or this will fail.  Returns
+// 0 on success; returns an errno error code on failure,
+static errno_t __cdecl _chsize_s_internal(int const fh, __int64 const size, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN_ERRCODE(ptd, fh, EBADF);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, (_osfile(fh) & FOPEN), EBADF);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE(ptd, (size >= 0), EINVAL);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if (_osfile(fh) & FOPEN)
+        {
+            return _chsize_nolock_internal(fh, size, ptd);
+        }
+        else
+        {
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread", 0));
+            return ptd.get_errno().set(EBADF);
+        }
+    });
+}
+
+extern "C" errno_t __cdecl _chsize_s(int const fh, __int64 const size)
+{
+    __crt_cached_ptd_host ptd;
+    return _chsize_s_internal(fh, size, ptd);
+}
+
+struct __crt_seek_guard
+{
+
+    __crt_seek_guard(int const fh, __int64 const size)
+        : place(_lseeki64_nolock(fh, 0, SEEK_CUR)),
+        end(_lseeki64_nolock(fh, 0, SEEK_END)),
+        extend(size - end),
+        fhh(fh)
+    {
+    }
+
+    ~__crt_seek_guard()
+    {
+        _lseeki64_nolock(fhh, place, SEEK_SET);
+    }
+
+    __crt_seek_guard(__crt_seek_guard const &) = delete;
+    __crt_seek_guard& operator=(__crt_seek_guard const &) = delete;
+
+    __int64 place;
+    __int64 end;
+    __int64 extend;
+    int fhh;
+};
+
+extern "C" errno_t __cdecl _chsize_nolock_internal(int const fh, __int64 const size, __crt_cached_ptd_host& ptd)
+{
+    // Get current file position and seek to end
+    __crt_seek_guard seek_guard(fh, size);
+
+    if (seek_guard.place == -1 || seek_guard.end == -1)
+    {
+        // EBADF if earlier lseek (in __crt_seek_guard) failed
+        // EINVAL otherwise (ex: too large of a offset)
+        return ptd.get_errno().value_or(EINVAL);
+    }
+
+    // Grow or shrink the file as necessary:
+    if (seek_guard.extend > 0)
+    {
+        // Extend the file by filling the new area with zeroes:
+        __crt_unique_heap_ptr<char> const zero_buffer(_calloc_crt_t(char, _INTERNAL_BUFSIZ));
+        if (!zero_buffer)
+        {
+            return ptd.get_errno().set(ENOMEM);
+        }
+
+        int const old_mode = _setmode_nolock(fh, _O_BINARY);
+
+        do
+        {
+            int const bytes_to_write = seek_guard.extend >= static_cast<__int64>(_INTERNAL_BUFSIZ)
+                ? _INTERNAL_BUFSIZ
+                : static_cast<int>(seek_guard.extend);
+
+            int const bytes_written = _write_nolock(fh, zero_buffer.get(), bytes_to_write, ptd);
+            if (bytes_written == -1)
+            {
+                // Error on write:
+                if (ptd.get_doserrno().check(ERROR_ACCESS_DENIED))
+                {
+                    ptd.get_errno().set(EACCES);
+                }
+
+                return ptd.get_errno().value_or(0);
+            }
+
+            seek_guard.extend -= bytes_written;
+        } while (seek_guard.extend > 0);
+
+#pragma warning(suppress:6031) // return value ignored
+        _setmode_nolock(fh, old_mode);
+    }
+    else if (seek_guard.extend < 0)
+    {
+        // Shorten the file by truncating it:
+        __int64 const new_end = _lseeki64_nolock(fh, size, SEEK_SET);
+        if (new_end == -1)
+        {
+            return ptd.get_errno().value_or(0);
+        }
+
+        if (!SetEndOfFile(reinterpret_cast<HANDLE>(_get_osfhandle(fh))))
+        {
+            ptd.get_doserrno().set(GetLastError());
+            return ptd.get_errno().set(EACCES);
+        }
+    }
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _chsize_nolock(int const fh, __int64 const size)
+{   // TODO: _chsize_nolock is already internal-only.
+    // Once PTD is propagated everywhere, rename _chsize_nolock_internal to _chsize_nolock.
+    __crt_cached_ptd_host ptd;
+    return _chsize_nolock_internal(fh, size, ptd);
+}
+
+
+// Changes the size of the given file, either extending or truncating it.  The
+// file must have been opened with write permissions or this will fail.  Returns
+// 0 on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl _chsize(int const fh, long const size)
+{
+    return _chsize_s(fh, size) == 0 ? 0 : -1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/close.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/close.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d2607b874cc88be85dcb53e7ab90d772b2a6a10
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/close.cpp	
@@ -0,0 +1,101 @@
+//
+// close.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _close(), which closes a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Closes the underlying OS file handle, if and only if nt needs to be closed.
+// Returns 0 on success; returns the OS error on failure.
+static DWORD close_os_handle_nolock(int const fh) throw()
+{
+    // If the underlying handle is INVALID_HANDLE_VALUE, don't try to acutally
+    // close it:
+    if (_get_osfhandle(fh) == (intptr_t)INVALID_HANDLE_VALUE)
+    {
+        return 0;
+    }
+
+    // If the file handle is stdout or stderr, and if stdout and stderr are
+    // mapped to the same OS file handle, skip the CloseHandle without error.
+    //
+    // stdout and stderr are the only handles for which this support is
+    // provided.  Other handles may be mapped to the same OS file handle only
+    // at the programmer's risk.
+    bool is_other_std_handle_open =
+        fh == 1 && (_osfile(2) & FOPEN) ||
+        fh == 2 && (_osfile(1) & FOPEN);
+
+    if (is_other_std_handle_open && _get_osfhandle(1) == _get_osfhandle(2))
+    {
+        return 0;
+    }
+
+    // Otherwise, we can go ahead and close the handle:
+    if (CloseHandle(reinterpret_cast<HANDLE>(_get_osfhandle(fh))))
+    {
+        return 0;
+    }
+
+    return GetLastError();
+}
+
+
+
+// Closes the file associated with the given file handle.  On success, returns 0.
+// On failure, returns -1 and sets errno.
+extern "C" int __cdecl _close_internal(int const fh, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if (_osfile(fh) & FOPEN)
+        {
+            return _close_nolock_internal(fh, ptd);
+        }
+        else
+        {
+            ptd.get_errno().set(EBADF);
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            return -1;
+        }
+    });
+}
+
+extern "C" int __cdecl _close(int const fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _close_internal(fh, ptd);
+}
+
+
+
+extern "C" int __cdecl _close_nolock_internal(int const fh, __crt_cached_ptd_host& ptd)
+{
+    DWORD const close_os_handle_error = close_os_handle_nolock(fh);
+
+    _free_osfhnd(fh);
+    _osfile(fh) = 0;
+
+    if (close_os_handle_error != 0)
+    {
+        __acrt_errno_map_os_error_ptd(close_os_handle_error, ptd);
+        return -1;
+    }
+
+    return 0;
+}
+
+extern "C" int __cdecl _close_nolock(int const fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _close_nolock_internal(fh, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/commit.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/commit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f5a6b5f628d3f9693f74c739acf81960e57b7c6f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/commit.cpp	
@@ -0,0 +1,36 @@
+//
+// commit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _commit(), which flushes a file buffer to disk.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+// Flushes the buffer for the given file to disk.
+//
+// On success, 0 is returned.  On failure, -1 is returned and errno is set.
+extern "C" int __cdecl _commit(int const fh)
+{
+    _CHECK_FH_RETURN(fh, EBADF, -1);
+    _VALIDATE_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _VALIDATE_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if (_osfile(fh) & FOPEN)
+        {
+            if (FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(fh))))
+                return 0; // Success
+
+            _doserrno = GetLastError();
+        }
+
+        errno = EBADF;
+
+        _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+        return -1;
+    });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/creat.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/creat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a2bec190d1fb38fa9dec26f9b5f00ac16c4acd8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/creat.cpp	
@@ -0,0 +1,41 @@
+//
+// creat.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _creat() (and _wcreat(), via inclusion), which creates a new file.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+// Creates a new file.
+//
+// If the file does not exist, this function creates a new file with the given
+// permission setting and opens it for writing.  If the file already exists and
+// its permission allows writing, this function truncates it to zero length and
+// opens it for writing.
+//
+// The only XENIX mode bit supported is user write (S_IWRITE).
+//
+// On success, the handle for the newly created file is returned.  On failure,
+// -1 is returned and errno is set.
+template <typename Character>
+static int __cdecl common_creat(Character const* const path, int const pmode) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+    // creat is just the same as open...
+    int fh = -1;
+    errno_t e = traits::tsopen_s(&fh, path, _O_CREAT + _O_TRUNC + _O_RDWR, _SH_DENYNO, pmode);
+    return e == 0 ? fh : -1;
+}
+
+extern "C" int __cdecl _creat(char const* const path, int const pmode)
+{
+    return common_creat(path, pmode);
+}
+
+extern "C" int __cdecl _wcreat(wchar_t const* const path, int const pmode)
+{
+    return common_creat(path, pmode);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d18af17fd1dddb002621a5df1d447da1b1f6df1f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup.cpp	
@@ -0,0 +1,95 @@
+//
+// dup.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _dup() and _dup_nolock, which duplicate lowio file handles
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+static int __cdecl duplicate_osfhnd(int const fh, int const new_fh, __crt_cached_ptd_host& ptd) throw()
+{
+    // Duplicate the file handle:
+    intptr_t new_osfhandle;
+
+    BOOL const result = DuplicateHandle(
+        GetCurrentProcess(),
+        reinterpret_cast<HANDLE>(_get_osfhandle(fh)),
+        GetCurrentProcess(),
+        &reinterpret_cast<HANDLE&>(new_osfhandle),
+        0L,
+        TRUE,
+        DUPLICATE_SAME_ACCESS);
+
+    if (!result)
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    // Duplicate the handle state:
+    __acrt_lowio_set_os_handle(new_fh, new_osfhandle);
+    _osfile(new_fh) = _osfile(fh) & ~FNOINHERIT;
+    _textmode(new_fh) = _textmode(fh);
+    _tm_unicode(new_fh) = _tm_unicode(fh);
+    return new_fh;
+}
+
+static int __cdecl _dup_nolock_internal(int const fh, __crt_cached_ptd_host& ptd) throw()
+{
+    if ((_osfile(fh) & FOPEN) == 0)
+    {
+        ptd.get_errno().set(EBADF);
+        ptd.get_doserrno().set(0);
+        _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread", 0));
+        return -1;
+    }
+
+    // Allocate a duplicate handle
+    int const new_fh = _alloc_osfhnd();
+    if (new_fh == -1)
+    {
+        ptd.get_errno().set(EMFILE);
+        ptd.get_doserrno().set(0);
+        return -1;
+    }
+
+    int return_value = -1;
+    __try
+    {
+        return_value = duplicate_osfhnd(fh, new_fh, ptd);
+    }
+    __finally
+    {
+        // The handle returned by _alloc_osfhnd is both open and locked.  If we
+        // failed to duplicate the handle, we need to abandon the handle by
+        // unsetting the open flag.  We always need to unlock the handle:
+        if (return_value == -1)
+        {
+            _osfile(new_fh) &= ~FOPEN;
+        }
+
+        __acrt_lowio_unlock_fh(new_fh);
+    }
+    return return_value;
+}
+
+static int __cdecl _dup_internal(int const fh, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&](){
+        return _dup_nolock_internal(fh, ptd);
+    });
+}
+
+// _dup() duplicates a file handle and returns the duplicate.  If the function
+// fails, -1 is returned and errno is set.
+extern "C" int __cdecl _dup(int const fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _dup_internal(fh, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup2.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup2.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..effff31256b61ae8d276089ce9f452d454172efe
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/dup2.cpp	
@@ -0,0 +1,120 @@
+//
+// dup2.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _dup2() and _dup2_nolock, which duplicate lowio file handles
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+static int __cdecl _dup2_nolock_internal(int const source_fh, int const target_fh, __crt_cached_ptd_host& ptd) throw()
+{
+    if ((_osfile(source_fh) & FOPEN) == 0)
+    {
+        // If the source handle is not open, return an error.  Noe that the
+        // DuplicateHandle API will not detect this error, because it implies
+        // that _osfhnd(source_fh) == INVALID_HANDLE_VALUE, and this is a
+        // legal HANDLE value to be duplicated.
+        ptd.get_errno().set(EBADF);
+        ptd.get_doserrno().set(0);
+        _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+        return -1;
+    }
+
+    // Duplicate the source file onto the target file:
+    intptr_t new_osfhandle;
+
+    BOOL const result = DuplicateHandle(
+        GetCurrentProcess(),
+        reinterpret_cast<HANDLE>(_get_osfhandle(source_fh)),
+        GetCurrentProcess(),
+        &reinterpret_cast<HANDLE&>(new_osfhandle),
+        0,
+        TRUE,
+        DUPLICATE_SAME_ACCESS);
+
+    if (!result)
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    // If the target is open, close it once we know the OS handle was duplicated successfully.
+    // We ignore the possibility of an error here: an error simply means that the OS handle
+    // value may remain bound for the duration of the process.
+    if (_osfile(target_fh) & FOPEN)
+    {
+        _close_nolock_internal(target_fh, ptd);
+    }
+
+    __acrt_lowio_set_os_handle(target_fh, new_osfhandle);
+
+    // Copy the _osfile information, with the FNOINHERIT bit cleared:
+    _osfile(target_fh) = _osfile(source_fh) & ~FNOINHERIT;
+    _textmode(target_fh) = _textmode(source_fh);
+    _tm_unicode(target_fh) = _tm_unicode(source_fh);
+
+    return 0;
+}
+
+static int __cdecl _dup2_internal(int const source_fh, int const target_fh, __crt_cached_ptd_host& ptd) throw()
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, source_fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (source_fh >= 0 && (unsigned)source_fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(source_fh) & FOPEN), EBADF, -1);
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, target_fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, ((unsigned)target_fh < _NHANDLE_), EBADF, -1);
+
+    // Make sure there is an __crt_lowio_handle_data struct corresponding to the target_fh:
+    if (target_fh >= _nhandle && __acrt_lowio_ensure_fh_exists(target_fh) != 0)
+    {
+        return -1;
+    }
+
+    // If the source and target are the same, return success (we've already
+    // verified that the file handle is open, above).  This is for conformance
+    // with the POSIX specification for dup2.
+    if (source_fh == target_fh)
+    {
+        return 0;
+    }
+
+    // Obtain the two file handle locks.  In order to prevent deadlock, we
+    // always obtain the lock for the lower-numbered file handle first:
+    if (source_fh < target_fh)
+    {
+        __acrt_lowio_lock_fh(source_fh);
+        __acrt_lowio_lock_fh(target_fh);
+    }
+    else if (source_fh > target_fh)
+    {
+        __acrt_lowio_lock_fh(target_fh);
+        __acrt_lowio_lock_fh(source_fh);
+    }
+
+    int result = 0;
+
+    __try
+    {
+        result = _dup2_nolock_internal(source_fh, target_fh, ptd);
+    }
+    __finally
+    {
+        // The order in which we unlock the file handles does not matter:
+        __acrt_lowio_unlock_fh(source_fh);
+        __acrt_lowio_unlock_fh(target_fh);
+    }
+    return result;
+}
+
+// _dup2() makes the target file handle a duplicate of the source file handle,
+// so that both handles refer to the same file.  If the target handle is open
+// upon entry, it is closed so that it is not leaked.
+//
+// Returns 0 if successful; returns -1 and sets errno on failure.
+extern "C" int __cdecl _dup2(int const source_fh, int const target_fh)
+{
+    __crt_cached_ptd_host ptd;
+    return _dup2_internal(source_fh, target_fh, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/eof.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/eof.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8231de0876a4d9a112a70ae6f24cfacdf7a6643
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/eof.cpp	
@@ -0,0 +1,50 @@
+//
+// eof.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _eof(), which tests whether a file is at EOF.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+// Tests if a file is at EOF.  Returns:
+//  *  1 if at EOF
+//  *  0 if not at EOF
+//  * -1 on failure (errno is set)
+extern "C" int __cdecl _eof(int const fh)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
+
+    return __acrt_lowio_lock_fh_and_call(fh, [&]()
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            return -1;
+        }
+
+        __int64 const here = _lseeki64_nolock(fh, 0i64, SEEK_CUR);
+        if (here == -1i64)
+            return -1;
+
+
+        __int64 const end = _lseeki64_nolock(fh, 0i64, SEEK_END);
+        if (end == -1i64)
+            return -1;
+
+        // Now we can test if we're at the end:
+        if (here == end)
+            return 1;
+
+        // If we aren't at the end, we need to reset the stream to its original
+        // state before we return:
+        _lseeki64_nolock(fh, here, SEEK_SET);
+        return 0;
+    });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/filelength.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/filelength.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..05d7196afa41ae9d6219f76011ee8e27d27cd589
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/filelength.cpp	
@@ -0,0 +1,62 @@
+//
+// filelength.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _filelength(), which computes the length of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+// Computes the length, in bytes, of the given file. Returns -1 on failure.
+template <typename Integer>
+_Success_(return != -1)
+static Integer __cdecl common_filelength(int const fh) throw()
+{
+    typedef __crt_integer_traits<Integer> traits;
+
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN,                          EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    Integer end = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread", 0));
+            __leave;
+        }
+
+        // Seek to the end to get the length:
+        Integer const here = traits::lseek_nolock(fh, 0, SEEK_CUR);
+        if (here == -1)
+            __leave;
+
+        end = traits::lseek_nolock(fh, 0, SEEK_END);
+        if (here != end)
+            traits::lseek_nolock(fh, here, SEEK_SET);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return end;
+}
+
+extern "C" long __cdecl _filelength(int const fh)
+{
+    return common_filelength<long>(fh);
+}
+
+extern "C" __int64 __cdecl _filelengthi64(int const fh)
+{
+    return common_filelength<__int64>(fh);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/ioinit.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/ioinit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..795050fc9ac530cc836a6ca20be26a9ac8996674
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/ioinit.cpp	
@@ -0,0 +1,265 @@
+//
+// ioinit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines initialization and termination routines for the lowio library, along
+// with global data shared by most of the lowio library.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_stdio.h>
+
+
+
+// This is a special static lowio file object referenced only by the safe access
+// functionality in the internal headers.  It is used in certain stdio-level
+// functions to more gracefully handle a FILE with -1 as its lowio file id.
+extern "C" __crt_lowio_handle_data __badioinfo =
+{
+    { },                         // lock
+    static_cast<intptr_t>(-1),   // osfhnd
+    0,                           // startpos
+    FTEXT,                       // osfile
+    __crt_lowio_text_mode::ansi, // textmode
+    { LF, LF, LF },              // _pipe_lookahead
+};
+
+
+
+// This is the number of lowio file objects that have been allocated.  This
+// includes both in-use and unused elements, since not all allocated files
+// are necessarily in use at any given time.
+//
+// This number is in the range of [IOINFO_ARRAY_ELTS, _NHANDLE_]
+extern "C" int _nhandle = 0;
+
+
+
+// This is the global array of file object arrays:
+extern "C" __crt_lowio_handle_data* __pioinfo[IOINFO_ARRAYS] = { 0 };
+
+
+
+static DWORD __cdecl get_std_handle_id(int const fh) throw()
+{
+    // Convert the CRT file handle to the OS file handle for the three 
+    // standard streams:
+    switch (fh)
+    {
+    case 0: return STD_INPUT_HANDLE;
+    case 1: return STD_OUTPUT_HANDLE;
+    case 2: return STD_ERROR_HANDLE;
+    }
+
+    return STD_ERROR_HANDLE; // Unreachable, but the compiler can't know.
+}
+
+
+
+static void __cdecl initialize_inherited_file_handles_nolock() throw()
+{
+    STARTUPINFOW startup_info;
+    GetStartupInfoW(&startup_info);
+
+    // First check and see if we inherited any file handles.  If we didn't, then
+    // we don't have anything to initialize:
+    if (startup_info.cbReserved2 == 0 || startup_info.lpReserved2 == nullptr)
+        return;
+
+    // Get the number of inherited handles:
+    int const handle_count = *reinterpret_cast<UNALIGNED int*>(startup_info.lpReserved2);
+
+    // Compute the start of the passed file info and OS HANDLEs:
+    unsigned char* const first_file =
+        reinterpret_cast<unsigned char*>(startup_info.lpReserved2) + sizeof(int);
+
+    UNALIGNED intptr_t* const first_handle =
+        reinterpret_cast<UNALIGNED intptr_t*>(first_file + handle_count);
+
+    // Do not attempt to inherit more than the maximum number of supported handles:
+    int handles_to_inherit = handle_count < _NHANDLE_ 
+        ? handle_count
+        : _NHANDLE_;
+
+    // Attempt to allocate the required number of handles.  If we fail for any
+    // reason, we'll inherit as many handles as we can:
+    __acrt_lowio_ensure_fh_exists(handles_to_inherit);
+    if (handles_to_inherit > _nhandle)
+        handles_to_inherit = _nhandle;
+
+    // Validate and copy the provided file information:
+    unsigned char*      it_file   = first_file;
+    UNALIGNED intptr_t* it_handle = first_handle;
+
+    for (int fh = 0; fh != handles_to_inherit; ++fh, ++it_file, ++it_handle)
+    {
+        HANDLE const real_handle = reinterpret_cast<HANDLE>(*it_handle);
+
+        // If the provided information does not appear to describe an open,
+        // valid file or device, skip it:
+        if (real_handle == INVALID_HANDLE_VALUE)
+            continue;
+
+        if (*it_handle == _NO_CONSOLE_FILENO)
+            continue;
+
+        if ((*it_file & FOPEN) == 0)
+            continue;
+
+        // GetFileType cannot be called for pipe handles since it may "hang" if
+        // there is a blocked read pending on the pipe in the parent.
+        if ((*it_file & FPIPE) == 0 && GetFileType(real_handle) == FILE_TYPE_UNKNOWN)
+            continue;
+
+        // Okay, the file looks valid:
+        __crt_lowio_handle_data* const pio = _pioinfo(fh);
+        pio->osfhnd = *it_handle;
+        pio->osfile = *it_file;
+    }
+}
+
+
+
+static void initialize_stdio_handles_nolock() throw()
+{
+    for (int fh = 0; fh != STDIO_HANDLES_COUNT; ++fh)
+    {
+        __crt_lowio_handle_data* const pio = _pioinfo(fh);
+
+        // If this handle was inherited from the parent process and initialized
+        // already, make sure it has the FTEXT flag and continue:
+        if (pio->osfhnd != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) &&
+            pio->osfhnd != _NO_CONSOLE_FILENO)
+        {
+            pio->osfile |= FTEXT;
+            continue;
+        }
+
+        // Regardless what happens next, the file will be treated as if it is
+        // open in text mode:
+        pio->osfile = FOPEN | FTEXT;
+
+        // This handle has not yet been initialized, so  let's see if we can get
+        // the handle from the OS:
+        intptr_t const os_handle = reinterpret_cast<intptr_t>(GetStdHandle(get_std_handle_id(fh)));
+
+        bool const is_valid_handle = 
+            os_handle != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) &&
+            os_handle != reinterpret_cast<intptr_t>(nullptr);
+
+        DWORD const handle_type = is_valid_handle
+            ? GetFileType(reinterpret_cast<HANDLE>(os_handle))
+            : FILE_TYPE_UNKNOWN;
+
+
+        if (handle_type != FILE_TYPE_UNKNOWN)
+        {
+            // The file type is known, so we obtained a valid handle from the
+            // OS.  Finish initializing the lowio file object for this handle,
+            // including the flag specifying whether this is a character device
+            // or a pipe:
+            pio->osfhnd = os_handle;
+
+            if ((handle_type & 0xff) == FILE_TYPE_CHAR)
+                pio->osfile |= FDEV;
+
+            else if ((handle_type & 0xff) == FILE_TYPE_PIPE)
+                pio->osfile |= FPIPE;
+        }
+        else
+        {
+            // We were unable to get the handles from the OS.  For stdin, stdout,
+            // and stderr, if there is no valid OS handle, treat the CRT handle
+            // as being open in text mode on a device with _NO_CONSOLE_FILENO
+            // underlying it.  We use this value instead of INVALID_HANDLE_VALUE
+            // to distinguish between a failure in opening a file and a program
+            // run without a console:
+            pio->osfile |= FDEV;
+            pio->osfhnd = _NO_CONSOLE_FILENO;
+
+            // Also update the corresponding stdio stream, unless stdio was
+            // already terminated:
+            if (__piob)
+                __piob[fh]->_file = _NO_CONSOLE_FILENO;
+        }
+    }
+}
+
+
+
+// Initializes the lowio library.  This initialization comprises several steps:
+//
+// [1] An initial array of __crt_lowio_handle_data structures is allocated.
+//
+// [2] Inherited file handles are initialized.  To do this, sthe startup info
+//     is obtained from the OS, via the lpReserved2 member.  The format of the
+//     information is as follows:
+//
+//     [Bytes 0 - 3]       Integer value N, which is the number of handles that
+//                         are provided by the parent process.
+//
+//     [Bytes 4 - N+3]     The N osfile values.
+//
+//     [Bytes N+4 - 5*N+3] The N OS HANDLE values, as DWORDs
+//
+// [3] Next, the first three lowio files (corresponding to stdin, stdout, and
+//     stderr) are initialized as follows:  If the value in osfhnd is 
+//     INVALID_HANDLE_VALUE, then we try to obtain a HANDLE from the OS.  These
+//     handles are forced to text mode, as standard input, output, and error
+//     always start out in text mode.
+//
+// Notes:
+//
+// [1] In general, not all of the pased info from the parent process will
+//     describe open handles.  If, for example, only C handle 1 (stdout) and
+//     C handle 6 are open in the parent, info for C handles 0 through 6 are
+//     passed to the child.  0, 2, 3, 4, and 5 will not describe open handles.
+//
+// [2] Care is taken not to "overflow" the arrays of lowio file objects.
+//
+// [3] See the dospawn logic for the encoding of the file handle info to be
+//     passed to a child process.
+//
+// This funtion returns 0 on success; -1 on failure.
+extern "C" bool __cdecl __acrt_initialize_lowio()
+{
+    __acrt_lock(__acrt_lowio_index_lock);
+    bool result = false;
+    __try
+    {
+        // First, allocate and initialize the initial array of lowio files:
+        if (__acrt_lowio_ensure_fh_exists(0) != 0)
+            __leave;
+
+        // Next, process and initialize all inherited file handles:
+        initialize_inherited_file_handles_nolock();
+
+        // Finally, initialize the stdio handles, if they were not inherited:
+        initialize_stdio_handles_nolock();
+        result = true;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_lowio_index_lock);
+    }
+
+    return result;
+}
+
+
+
+// Shuts down the lowio library, freeing all allocated memory and destroying all
+// created synchronization objects.
+extern "C" bool __cdecl __acrt_uninitialize_lowio(bool const /* terminating */)
+{
+    for (size_t i = 0; i < IOINFO_ARRAYS; ++i)
+    {
+        if (!__pioinfo[i])
+            continue;
+
+        __acrt_lowio_destroy_handle_array(__pioinfo[i]);
+        __pioinfo[i] = nullptr;
+    }
+
+    return true;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/isatty.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/isatty.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d6fa32994e42161d6de168467c15e0a762eab43
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/isatty.cpp	
@@ -0,0 +1,32 @@
+//
+// isatty.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _isatty(), which tests whether a file refers to a character device.
+//
+#include <corecrt_internal_lowio.h>
+
+// VSO 41542369 - Ruby tries to locate the __pioinfo pointer by looking 
+// backwards from the ret instruction. This is not supported in general,
+// but in addition Ruby expects an [add rsp] instruction before the ret.
+// Whether that pattern exists depends on what optimizations are applied.
+// This creates AppCompat issues as Ruby based applications abort at start.
+// We work around it having _isatty being a jmp to the real fucntion,
+// followed by non-reachable code that Ruby looks for.
+// See also isatty_ruby.asm
+
+// Tests if the given file refers to a character device (e.g. terminal, console,
+// printer, serial port, etc.).  Returns nonzero if so; zero if not.
+
+#if defined(_ISATTY_ASM) && !defined(_ARM64EC_)
+extern "C" int __cdecl _isatty_proc(int const fh)
+#else
+extern "C" int __cdecl _isatty(int const fh)
+#endif
+{
+    _CHECK_FH_RETURN(fh, EBADF, 0);
+    _VALIDATE_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, 0);
+
+    return static_cast<int>(_osfile(fh) & FDEV);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/locking.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/locking.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e21d3aec2fc154bd4bd52f15857c41470b2073b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/locking.cpp	
@@ -0,0 +1,120 @@
+//
+// locking.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _locking(), which locks and unlocks regions of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <sys\locking.h>
+
+
+
+static int __cdecl locking_nolock(int const fh, int const locking_mode, long const number_of_bytes) throw()
+{
+    __int64 const lock_offset = _lseeki64_nolock(fh, 0L, SEEK_CUR);
+    if (lock_offset == -1)
+        return -1;
+
+    OVERLAPPED overlapped = { 0 };
+    overlapped.Offset     = static_cast<DWORD>(lock_offset);
+    overlapped.OffsetHigh = static_cast<DWORD>((lock_offset >> 32) & 0xffffffff);
+
+    // Set the retry count, based on the mode:
+    bool const allow_retry = locking_mode == _LK_LOCK || locking_mode == _LK_RLCK;
+    int  const retry_count = allow_retry ? 10 : 1;
+
+    // Ask the OS to lock the file either until the request succeeds or the
+    // retry count is reached, whichever comes first.  Note that the only error
+    // possible is a locking violation, since an invalid handle would have
+    // already failed above.
+    bool succeeded = false;
+    for (int i = 0; i != retry_count; ++i)
+    {
+        if (locking_mode == _LK_UNLCK)
+        {
+            succeeded = UnlockFileEx(
+                reinterpret_cast<HANDLE>(_get_osfhandle(fh)),
+                0,
+                number_of_bytes,
+                0,
+                &overlapped) == TRUE;
+        }
+        else
+        {
+            // Ensure exclusive lock access, and return immediately if lock
+            // acquisition fails:
+            succeeded = LockFileEx(
+                reinterpret_cast<HANDLE>(_get_osfhandle(fh)),
+                LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,
+                0,
+                number_of_bytes,
+                0,
+                &overlapped) == TRUE;
+        }
+
+        if (succeeded)
+        {
+            break;
+        }
+
+        // Doesnt sleep on the last try
+        if (i != retry_count - 1)
+        {
+            Sleep(1000);
+        }
+    }
+
+    // If an OS error occurred (e.g., if the file was already locked), return
+    // EDEADLOCK if this was ablocking call; otherwise map the error noramlly:
+    if (!succeeded)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        if (locking_mode == _LK_LOCK || locking_mode == _LK_RLCK)
+        {
+            errno = EDEADLOCK;
+        }
+
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+// Locks or unlocks the requested number of bytes in the specified file.
+//
+// Note that this function acquires the lock for the specified file and holds
+// this lock for the entire duration of the call, even during the one second
+// delays between calls into the operating system.  This is to prevent other
+// threads from changing the file during the call.
+//
+// Returns 0 on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl _locking(int const fh, int const locking_mode, long const number_of_bytes)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(number_of_bytes >= 0, EINVAL, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0)); 
+            __leave;
+        }
+
+        result = locking_nolock(fh, locking_mode, number_of_bytes);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/lseek.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/lseek.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..abed21c948b460622039656169bde66914db986c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/lseek.cpp	
@@ -0,0 +1,171 @@
+//
+// lseek.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lseek(), which seeks the file pointer of a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <stdlib.h>
+
+#if SEEK_SET != FILE_BEGIN || SEEK_CUR != FILE_CURRENT || SEEK_END != FILE_END
+    #error Xenix and Win32 seek constants not compatible
+#endif
+
+
+
+// These functions actually seek the underlying operating system file handle.
+// The logic is different for 32-bit and 64-bit seek values because a seek may
+// end up moving out of range of 32-bit values.
+static long __cdecl common_lseek_do_seek_nolock(HANDLE const os_handle, long const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    LARGE_INTEGER const origin_pos = { 0 };
+
+    LARGE_INTEGER saved_pos;
+    if (!SetFilePointerEx(os_handle, origin_pos, &saved_pos, FILE_CURRENT))
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    LARGE_INTEGER seek_pos = { 0 };
+    seek_pos.QuadPart = offset;
+
+    LARGE_INTEGER new_pos = { 0 };
+    if (!SetFilePointerEx(os_handle, seek_pos, &new_pos, origin))
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    // The call succeeded, but the new file pointer location is too large for
+    // the return type or is a negative value.  So, restore the file pointer
+    // to the saved location and return an error:
+    if (new_pos.QuadPart > LONG_MAX)
+    {
+        SetFilePointerEx(os_handle, saved_pos, nullptr, FILE_BEGIN);
+        ptd.get_errno().set(EINVAL);
+        return -1;
+    }
+
+    return static_cast<long>(new_pos.LowPart);
+}
+
+static __int64 __cdecl common_lseek_do_seek_nolock(HANDLE const os_handle, __int64 const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    LARGE_INTEGER new_pos;
+    if (!SetFilePointerEx(os_handle, *reinterpret_cast<LARGE_INTEGER const*>(&offset), &new_pos, origin))
+    {
+        __acrt_errno_map_os_error_ptd(GetLastError(), ptd);
+        return -1;
+    }
+
+    return new_pos.QuadPart;
+}
+
+
+template <typename Integer>
+static Integer __cdecl common_lseek_nolock(int const fh, Integer const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_get_osfhandle(fh));
+    if (os_handle == reinterpret_cast<HANDLE>(-1))
+    {
+        ptd.get_errno().set(EBADF);
+        _ASSERTE(("Invalid file descriptor",0));
+        return -1;
+    }
+
+    Integer const new_position = common_lseek_do_seek_nolock(os_handle, offset, origin, ptd);
+    if (new_position == -1)
+    {
+        return -1;
+    }
+
+    // The call succeeded, so return success:
+    _osfile(fh) &= ~FEOFLAG; // Clear the Ctrl-Z flag
+    return new_position;
+}
+
+// Moves the file pointer associated with the given file to a new position.  The
+// new position is 'offset' bytes (the offset may be negative) away from the
+// origin specified by 'origin'.
+//
+//     If origin == SEEK_SET, the origin in the beginning of file
+//     If origin == SEEK_CUR, the origin is the current file pointer position
+//     If origin == SEEK_END, the origin is the end of the file
+//
+// Returns the offset, in bytes, of the new position, from the beginning of the
+// file.  Returns -1 and sets errno on failure.  Note that seeking beyond the
+// end of the file is not an error, but seeking before the beginning is.
+template <typename Integer>
+static Integer __cdecl common_lseek(int const fh, Integer const offset, int const origin, __crt_cached_ptd_host& ptd) throw()
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, _osfile(fh) & FOPEN, EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    Integer result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            ptd.get_errno().set(EBADF);
+            ptd.get_doserrno().set(0);
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = common_lseek_nolock(fh, offset, origin, ptd);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+extern "C" long __cdecl _lseek_internal(int const fh, long const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64_internal(int const fh, __int64 const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" long __cdecl _lseek_nolock_internal(int const fh, long const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64_nolock_internal(int const fh, __int64 const offset, int const origin, __crt_cached_ptd_host& ptd)
+{
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
+
+extern "C" long __cdecl _lseek(int const fh, long const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64(int const fh, __int64 const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek(fh, offset, origin, ptd);
+}
+
+extern "C" long __cdecl _lseek_nolock(int const fh, long const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
+
+extern "C" __int64 __cdecl _lseeki64_nolock(int const fh, __int64 const offset, int const origin)
+{
+    __crt_cached_ptd_host ptd;
+    return common_lseek_nolock(fh, offset, origin, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/mktemp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/mktemp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8521fa3faca88c3c4dca2239ab996bd9c13e289b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/mktemp.cpp	
@@ -0,0 +1,168 @@
+//
+// mktemp.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _tmktemp() and _tmktemp_s(), which create unique file names.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_securecrt.h>
+#include <mbctype.h>
+#include <process.h>
+#include <stddef.h>
+#include <stdio.h>
+
+
+
+// These functions test whether we should continue scanning for X's.
+static bool common_mktemp_s_continue(char const* const string, char const* const current) throw()
+{
+    return !_ismbstrail(
+        reinterpret_cast<unsigned char const*>(string),
+        reinterpret_cast<unsigned char const*>(current));
+}
+
+static bool common_mktemp_s_continue(wchar_t const* const, wchar_t const* const) throw()
+{
+    return true;
+}
+
+
+
+// Creates a unique file name given a template string of the form "fnamXXXXXX".
+// The "XXXXXX" sequence is replaced by a letter and the five-digit thread
+// identifier.
+//
+// The template string is modified in-place.  Returns 0 on success; returns an
+// errno error code on failure.
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_mktemp_s(
+    _Inout_updates_z_(buffer_size_in_chars) Character* const    template_string,
+                                            size_t     const    buffer_size_in_chars
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(template_string != nullptr && buffer_size_in_chars > 0, EINVAL);
+
+    size_t const template_string_length = traits::tcsnlen(template_string, buffer_size_in_chars);
+    if (template_string_length >= buffer_size_in_chars)
+    {
+        _RESET_STRING(template_string, buffer_size_in_chars);
+        _RETURN_DEST_NOT_NULL_TERMINATED(template_string, buffer_size_in_chars);
+    }
+    _FILL_STRING(template_string, buffer_size_in_chars, template_string_length + 1);
+
+    if(template_string_length < 6 || buffer_size_in_chars <= template_string_length)
+    {
+        _RESET_STRING(template_string, buffer_size_in_chars);
+        _VALIDATE_RETURN_ERRCODE(("Incorrect Input for mktemp", 0), EINVAL);
+    }
+
+    // The Win32 thread identifier is unique across all threads in all processes.
+    // Note, however, that unlike *NIX process identifiers, which are not reused
+    // until all values up to 32K have been used, Win32 thread identifiers are
+    // frequenty reused and usually have small numbers.
+    unsigned number = GetCurrentThreadId();
+
+    // 'string' points to the null-terminator:
+    Character* string = template_string + template_string_length;
+
+    size_t template_length = 0;
+
+    // Replace the last five 'X' characters with the number:
+    while (--string >= template_string 
+        && common_mktemp_s_continue(template_string, string)
+        && *string == 'X'
+        && template_length < 5)
+    {
+        ++template_length;
+        *string = static_cast<Character>((number % 10) + '0');
+        number /= 10;
+    }
+
+    // Too few X's?
+    if (*string != 'X' || template_length < 5)
+    {
+        _RESET_STRING(template_string, buffer_size_in_chars);
+        _VALIDATE_RETURN_ERRCODE(("Incorrect Input for mktemp", 0), EINVAL);
+    }
+
+    // Finally, add the letter:
+    Character letter = 'a';
+
+    *string = letter++;
+
+    errno_t const saved_errno = errno;
+    errno = 0;
+
+    // Test each letter, from a-z, until we find a name that is not yet used:
+    while (traits::taccess_s(template_string, 0) == 0)
+    {
+        if (letter == 'z' + 1)
+        {
+            _RESET_STRING(template_string, buffer_size_in_chars);
+            errno = EEXIST;
+            return errno;
+        }
+
+        *string = letter++;
+        errno = 0;
+    }
+
+    // Restore the old value of errno and return success:
+    errno = saved_errno;
+    return 0;
+}
+
+extern "C" errno_t __cdecl _mktemp_s(
+    char*  const template_string,
+    size_t const buffer_size_in_chars
+    )
+{
+    return common_mktemp_s(template_string, buffer_size_in_chars);
+}
+
+extern "C" errno_t __cdecl _wmktemp_s(
+    wchar_t* const template_string,
+    size_t   const buffer_size_in_chars
+    )
+{
+    return common_mktemp_s(template_string, buffer_size_in_chars);
+}
+
+
+
+// Creates a unique file name given a template string of the form "fnamXXXXXX".
+// The "XXXXXX" sequence is replaced by a letter and the five-digit thread
+// identifier.  The template string is modified in-place.
+//
+// On success, returns the pointer to the modified template string.  On failure,
+// nullptr is returned (e.g. if the template string is malformed or there are no
+// more unique names).
+template <typename Character>
+static Character* __cdecl common_mktemp(
+    Character* const template_string
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(template_string != nullptr, EINVAL, nullptr);
+
+    errno_t const result = common_mktemp_s(
+        template_string,
+        static_cast<size_t>(traits::tcslen(template_string) + 1));
+
+    return result == 0 ? template_string : nullptr;
+}
+
+extern "C" char* __cdecl _mktemp(char* const template_string)
+{
+    return common_mktemp(template_string);
+}
+
+extern "C" wchar_t* __cdecl _wmktemp(wchar_t* const template_string)
+{
+    return common_mktemp(template_string);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/open.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/open.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3f778c786b448d23ab3116244cd352d61ef61e4
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/open.cpp	
@@ -0,0 +1,907 @@
+//
+// open.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _open() and its friends, who are used to open or create files.
+//
+// These functions are used to open a file.
+//
+// oflag:   The primary file open flags are passed via this parameter.  It may
+//          have a combination of the following flags:
+//           * _O_APPEND:     Reposition file ptr to end before every write
+//           * _O_BINARY:     Open in binary mode
+//           * _O_CREAT:      Create a new file* no effect if file already exists
+//           * _O_EXCL:       Return error if file exists, only use with O_CREAT
+//           * _O_RDONLY:     Open for reading only
+//           * _O_RDWR:       Open for reading and writing
+//           * _O_TEXT:       Open in text mode
+//           * _O_TRUNC:      Open and truncate to 0 length (must have write permission)
+//           * _O_WRONLY:     Open for writing only
+//           * _O_NOINHERIT:  Handle will not be inherited by child processes.
+//          Exactly one of _O_RDONLY, _O_WRONLY, and _O_RDWR must be present.
+//
+// shflag:  Specifies the sharing options with which the file is to be opened.
+//          This parameter is only supported by the sharing-enabled open
+//          functions (_tsopen, _tsopen_s, etc.). The following flags are
+//          supported:
+//           * _SH_COMPAT:  Set compatability mode
+//           * _SH_DENYRW:  Deny read and write access to the file
+//           * _SH_DENYWR:  Deny write access to the file
+//           * _SH_DENYRD:  Deny read access to the file
+//           * _SH_DENYNO:  Permit read and write access
+//
+// pmode:   The pmode argument is only required when _O_CREAT is specified.  Its
+//          flags are as follows:
+//           * _S_IWRITE:
+//           * _S_IREAD:
+//          These flags may be combined (_S_IWRITE | _S_IREAD) to enable both
+//          reading and writing.  The current file permission mask is applied to
+//          pmode before setting the permission (see umask).
+//
+// Functions that return an errno_t return 0 on success and an error code on
+// failure.  Functions that return an int return the file handle on success, and
+// return -1 and set errno on failure.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+
+
+namespace
+{
+    DWORD const GENERIC_READ_WRITE = (GENERIC_READ | GENERIC_WRITE);
+
+    struct file_options
+    {
+        // These are the flags that are used for the osflag of the CRT file
+        // object that is created.
+        char  crt_flags;
+
+        // These are the flags that are eventually passed to CreateFile to tell
+        // the Operating System how to create the file:
+        DWORD access;
+        DWORD create;
+        DWORD share;
+        DWORD attributes;
+        DWORD flags;
+    };
+}
+
+
+
+#define UTF16LE_BOM     0xFEFF      // UTF16 Little Endian Byte Order Mark
+#define UTF16BE_BOM     0xFFFE      // UTF16 Big Endian Byte Order Mark
+#define BOM_MASK        0xFFFF      // Mask for testing Byte Order Mark
+#define UTF8_BOM        0xBFBBEF    // UTF8 Byte Order Mark
+#define UTF16_BOMLEN    2           // No of Bytes in a UTF16 BOM
+#define UTF8_BOMLEN     3           // No of Bytes in a UTF8 BOM
+
+template <typename Character>
+static int __cdecl common_open(
+    _In_z_  Character const* const  path,
+            int              const  oflag,
+            int              const  pmode
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(path != nullptr, EINVAL, -1);
+
+    int fh = -1;
+    int unlock_flag = 0;
+    errno_t error_code = 0;
+    __try
+    {
+        error_code = traits::tsopen_nolock(&unlock_flag, &fh, path, oflag, _SH_DENYNO, pmode, 0);
+    }
+    __finally
+    {
+        if (unlock_flag)
+        {
+            if (error_code)
+            {
+                _osfile(fh) &= ~FOPEN;
+            }
+
+            __acrt_lowio_unlock_fh(fh);
+        }
+    }
+
+    if (error_code != 0)
+    {
+        errno = error_code;
+        return -1;
+    }
+
+    return fh;
+}
+
+extern "C" int _open(char const* const path, int const oflag, ...)
+{
+    va_list arglist;
+    va_start(arglist, oflag);
+    int const pmode = va_arg(arglist, int);
+    va_end(arglist);
+
+    return common_open(path, oflag, pmode);
+}
+
+extern "C" int _wopen(wchar_t const* const path, int const oflag, ...)
+{
+    va_list arglist;
+    va_start(arglist, oflag);
+    int const pmode = va_arg(arglist, int);
+    va_end(arglist);
+
+    return common_open(path, oflag, pmode);
+}
+
+
+
+template <typename Character>
+static errno_t __cdecl common_sopen_dispatch(
+    _In_z_  Character const* const path,
+            int              const oflag,
+            int              const shflag,
+            int              const pmode,
+            int*             const pfh,
+            int              const secure
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(pfh != nullptr, EINVAL);
+    *pfh = -1;
+
+    _VALIDATE_RETURN_ERRCODE(path != nullptr, EINVAL);
+
+    if(secure)
+    {
+        _VALIDATE_RETURN_ERRCODE((pmode & (~(_S_IREAD | _S_IWRITE))) == 0, EINVAL);
+    }
+
+
+    int unlock_flag = 0;
+    errno_t error_code = 0;
+    __try
+    {
+        error_code = traits::tsopen_nolock(&unlock_flag, pfh, path, oflag, shflag, pmode, secure);
+    }
+    __finally
+    {
+        if (unlock_flag)
+        {
+            if (error_code)
+            {
+                _osfile(*pfh) &= ~FOPEN;
+            }
+            __acrt_lowio_unlock_fh(*pfh);
+        }
+    }
+
+    if (error_code != 0)
+    {
+        *pfh = -1;
+    }
+
+    return error_code;
+}
+
+extern "C" errno_t __cdecl _sopen_dispatch(
+    char const* const path,
+    int         const oflag,
+    int         const shflag,
+    int         const pmode,
+    int*        const pfh,
+    int         const secure
+    )
+{
+    return common_sopen_dispatch(path, oflag, shflag, pmode, pfh, secure);
+}
+
+extern "C" errno_t __cdecl _wsopen_dispatch(
+    wchar_t const* const path,
+    int            const oflag,
+    int            const shflag,
+    int            const pmode,
+    int*           const pfh,
+    int            const secure
+    )
+{
+    return common_sopen_dispatch(path, oflag, shflag, pmode, pfh, secure);
+}
+
+
+
+static HANDLE __cdecl create_file(
+    PCWSTR               const path,
+    SECURITY_ATTRIBUTES* const security_attributes,
+    file_options         const options
+    ) throw()
+{
+    return CreateFileW(
+        path,
+        options.access,
+        options.share,
+        security_attributes,
+        options.create,
+        options.flags | options.attributes,
+        nullptr);
+}
+
+
+
+static DWORD decode_access_flags(int const oflag) throw()
+{
+    switch (oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR))
+    {
+    case _O_RDONLY:
+            return GENERIC_READ;
+
+    case _O_WRONLY:
+        // If the file is being opened in append mode, we give read access as
+        // well because in append (a, not a+) mode, we need to read the BOM to
+        // determine the encoding (ANSI, UTF-8, or UTF-16).
+        if ((oflag & _O_APPEND) && (oflag & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT)) != 0)
+            return GENERIC_READ | GENERIC_WRITE;
+
+        return GENERIC_WRITE;
+
+    case _O_RDWR:
+        return GENERIC_READ | GENERIC_WRITE;
+    }
+
+    // This is unreachable, but the compiler can't tell.
+    _VALIDATE_RETURN(("Invalid open flag", 0), EINVAL, static_cast<DWORD>(-1));
+    return 0;
+}
+
+static DWORD decode_open_create_flags(int const oflag) throw()
+{
+    switch (oflag & (_O_CREAT | _O_EXCL | _O_TRUNC))
+    {
+    case 0:
+    case _O_EXCL: // ignore EXCL w/o CREAT
+        return OPEN_EXISTING;
+
+    case _O_CREAT:
+        return OPEN_ALWAYS;
+
+    case _O_CREAT | _O_EXCL:
+    case _O_CREAT | _O_TRUNC | _O_EXCL:
+        return CREATE_NEW;
+
+    case _O_TRUNC:
+    case _O_TRUNC | _O_EXCL: // ignore EXCL w/o CREAT
+        return TRUNCATE_EXISTING;
+
+    case _O_CREAT | _O_TRUNC:
+        return CREATE_ALWAYS;
+    }
+
+    // This is unreachable, but the compiler can't tell.
+    _VALIDATE_RETURN(("Invalid open flag", 0), EINVAL, static_cast<DWORD>(-1));
+    return 0;
+}
+
+static DWORD decode_sharing_flags(int const shflag, int const access) throw()
+{
+    switch (shflag)
+    {
+    case _SH_DENYRW:
+        return 0;
+
+    case _SH_DENYWR:
+        return FILE_SHARE_READ;
+
+    case _SH_DENYRD:
+        return FILE_SHARE_WRITE;
+
+    case _SH_DENYNO:
+        return FILE_SHARE_READ | FILE_SHARE_WRITE;
+
+    case _SH_SECURE:
+        if (access == GENERIC_READ)
+            return FILE_SHARE_READ;
+        else
+            return 0;
+    }
+
+    _VALIDATE_RETURN(("Invalid sharing flag", 0), EINVAL, static_cast<DWORD>(-1));
+    return 0;
+}
+
+static bool is_text_mode(int const oflag) throw()
+{
+    if (oflag & _O_BINARY)
+        return false;
+
+    if (oflag & (_O_TEXT | _O_WTEXT | _O_U16TEXT | _O_U8TEXT))
+        return true;
+
+    // Finally, check the global default mode:
+    int fmode;
+    _ERRCHECK(_get_fmode(&fmode));
+    if (fmode != _O_BINARY)
+        return true;
+
+    return false;
+}
+
+static file_options decode_options(int const oflag, int const shflag, int const pmode) throw()
+{
+    file_options result;
+    result.crt_flags  = 0;
+    result.access     = decode_access_flags(oflag);
+    result.create     = decode_open_create_flags(oflag);
+    result.share      = decode_sharing_flags(shflag, result.access);
+    result.attributes = FILE_ATTRIBUTE_NORMAL;
+    result.flags      = 0;
+
+    if (oflag & _O_NOINHERIT)
+    {
+        result.crt_flags |= FNOINHERIT;
+    }
+
+    if (is_text_mode(oflag))
+    {
+        result.crt_flags |= FTEXT;
+    }
+
+    if (oflag & _O_CREAT)
+    {
+        if (((pmode & ~_umaskval) & _S_IWRITE) == 0)
+            result.attributes = FILE_ATTRIBUTE_READONLY;
+    }
+
+    if (oflag & _O_TEMPORARY)
+    {
+        result.flags  |= FILE_FLAG_DELETE_ON_CLOSE;
+        result.access |= DELETE;
+        result.share  |= FILE_SHARE_DELETE;
+    }
+
+    if (oflag & _O_SHORT_LIVED)
+    {
+        result.attributes |= FILE_ATTRIBUTE_TEMPORARY;
+    }
+
+    if (oflag & _O_OBTAIN_DIR)
+    {
+        result.flags |= FILE_FLAG_BACKUP_SEMANTICS;
+    }
+
+    if (oflag & _O_SEQUENTIAL)
+    {
+        result.flags |= FILE_FLAG_SEQUENTIAL_SCAN;
+    }
+    else if (oflag & _O_RANDOM)
+    {
+        result.flags |= FILE_FLAG_RANDOM_ACCESS;
+    }
+
+    return result;
+}
+
+
+
+// If we open a text mode file for writing, and the file ends in Ctrl+Z, we need
+// to remove the Ctrl+Z character so that appending will work.  We do this by
+// seeking to the end of the file, testing if the last character is a Ctrl+Z,
+// truncating the file if it is, then rewinding back to the beginning.
+static errno_t truncate_ctrl_z_if_present(int const fh) throw()
+{
+    // No truncation is possible for devices and pipes:
+    if (_osfile(fh) & (FDEV | FPIPE))
+        return 0;
+
+    // No truncation is necessary for binary files:
+    if ((_osfile(fh) & FTEXT) == 0)
+        return 0;
+
+    // Find the end of the file:
+    __int64 const last_char_position = _lseeki64_nolock(fh, -1, SEEK_END);
+
+    // If the seek failed, either the file is empty or an error occurred.
+    // (It's not an error if the file is empty.)
+    if (last_char_position == -1)
+    {
+        if (_doserrno == ERROR_NEGATIVE_SEEK)
+            return 0;
+
+        return errno;
+    }
+
+    // Read the last character.  If the read succeeds and the character
+    // is a Ctrl+Z, remove the character from the file by shortening:
+    wchar_t c = 0;
+    if (_read_nolock(fh, &c, 1) == 0 && c == 26)
+    {
+        if (_chsize_nolock(fh, last_char_position) == -1)
+            return errno;
+    }
+
+    // Now, rewind the file pointer back to the beginning:
+    if (_lseeki64_nolock(fh, 0, SEEK_SET) == -1)
+        return errno;
+
+    return 0;
+}
+
+
+
+// Computes the text mode to be used for a file, using a combination of the
+// options passed into the open function and the BOM read from the file.
+static errno_t configure_text_mode(
+    int              const fh,
+    file_options     const options,
+    int                    oflag,
+    __crt_lowio_text_mode& text_mode
+    ) throw()
+{
+    // The text mode is ANSI by default:
+    text_mode = __crt_lowio_text_mode::ansi;
+
+    // If the file is open in binary mode, it gets the default text mode:
+    if ((_osfile(fh) & FTEXT) == 0)
+        return 0;
+
+    // Set the default text mode per the oflag.  The BOM may change the default,
+    // if one is present.  If oflag does not specify a text mode, use the _fmode
+    // default:
+    DWORD const text_mode_mask = (_O_TEXT | _O_WTEXT | _O_U16TEXT | _O_U8TEXT);
+    if ((oflag & text_mode_mask) == 0)
+    {
+        int fmode = 0;
+        _ERRCHECK(_get_fmode(&fmode));
+
+        if ((fmode & text_mode_mask) == 0)
+            oflag |= _O_TEXT; // Default to ANSI.
+        else
+            oflag |= fmode & text_mode_mask;
+    }
+
+    // Now oflags should be set to one of the text modes:
+    _ASSERTE((oflag & text_mode_mask) != 0);
+
+    switch (oflag & text_mode_mask)
+    {
+    case _O_TEXT:
+        text_mode = __crt_lowio_text_mode::ansi;
+        break;
+
+    case _O_WTEXT:
+    case _O_WTEXT | _O_TEXT:
+        if ((oflag & (_O_WRONLY | _O_CREAT | _O_TRUNC)) == (_O_WRONLY | _O_CREAT | _O_TRUNC))
+            text_mode = __crt_lowio_text_mode::utf16le;
+        break;
+
+    case _O_U16TEXT:
+    case _O_U16TEXT | _O_TEXT:
+        text_mode = __crt_lowio_text_mode::utf16le;
+        break;
+
+    case _O_U8TEXT:
+    case _O_U8TEXT | _O_TEXT:
+        text_mode = __crt_lowio_text_mode::utf8;
+        break;
+    }
+
+
+    // If the file hasn't been opened with the UNICODE flags then we have
+    // nothing to do:  the text mode is the default mode that we just set:
+    if ((oflag & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT)) == 0)
+        return 0;
+
+    // If this file refers to a device, we cannot check the BOM, so we have
+    // nothing to do:  the text mode is the default mode that we just set:
+    if ((options.crt_flags & FDEV) != 0)
+        return 0;
+
+
+    // Determine whether we need to check or write the BOM, by testing the
+    // access with which the file was opened and whether the file already
+    // existed or was just created:
+    int check_bom = 0;
+    int write_bom = 0;
+    switch (options.access & GENERIC_READ_WRITE)
+    {
+    case GENERIC_READ:
+        check_bom = 1;
+        break;
+
+    case GENERIC_WRITE:
+    case GENERIC_READ_WRITE:
+        switch (options.create)
+        {
+        // If this file was opened, we will read the BOM if the file was opened
+        // with read/write access.  We will write the BOM if and only if the
+        // file is empty:
+        case OPEN_EXISTING:
+        case OPEN_ALWAYS:
+        {
+            if (_lseeki64_nolock(fh, 0, SEEK_END) != 0)
+            {
+                if (_lseeki64_nolock(fh, 0, SEEK_SET) == -1)
+                    return errno;
+
+                // If we have read access, then we need to check the BOM.  Note
+                // that we've taken a shortcut here:  if the file is empty, then
+                // we do not set this flag because the file doesn't have a BOM
+                // to be read.
+                check_bom = (options.access & GENERIC_READ) != 0;
+            }
+            else
+            {
+                write_bom = 1;
+                break;
+            }
+            break;
+        }
+
+        // If this is a new or truncated file, then we always write the BOM:
+        case CREATE_NEW:
+        case CREATE_ALWAYS:
+        case TRUNCATE_EXISTING:
+        {
+            write_bom = 1;
+            break;
+        }
+        }
+        break;
+    }
+
+    if (check_bom)
+    {
+        int bom = 0;
+        int const count = _read_nolock(fh, &bom, UTF8_BOMLEN);
+
+        // Intrernal validation:  This branch should never be taken if write_bom
+        // is true and count > 0:
+        if (count > 0 && write_bom == 1)
+        {
+            _ASSERTE(0 && "Internal Error");
+            write_bom = 0;
+        }
+
+        switch (count)
+        {
+        case -1:
+            return errno;
+
+        case UTF8_BOMLEN:
+            if (bom == UTF8_BOM)
+            {
+                text_mode = __crt_lowio_text_mode::utf8;
+                break;
+            }
+
+        case UTF16_BOMLEN:
+            if((bom & BOM_MASK) == UTF16BE_BOM)
+            {
+                _ASSERTE(0 && "Only UTF-16 little endian & UTF-8 is supported for reads");
+                errno = EINVAL;
+                return errno;
+            }
+
+            if((bom & BOM_MASK) == UTF16LE_BOM)
+            {
+                // We have read three bytes, so we should seek back one byte:
+                if(_lseeki64_nolock(fh, UTF16_BOMLEN, SEEK_SET) == -1)
+                    return errno;
+
+                text_mode = __crt_lowio_text_mode::utf16le;
+                break;
+            }
+
+            // Fall through to default case to lseek to beginning of file
+
+        default:
+            // The file has no BOM, so we seek back to the beginning:
+            if (_lseeki64_nolock(fh, 0, SEEK_SET) == -1)
+                return errno;
+
+            break;
+        }
+    }
+
+    if (write_bom)
+    {
+        // If we are creating a new file, we write a UTF-16LE or UTF8 BOM:
+        int bom_length = 0;
+        int bom = 0;
+        switch (text_mode)
+        {
+        case __crt_lowio_text_mode::utf16le:
+        {
+            bom        = UTF16LE_BOM;
+            bom_length = UTF16_BOMLEN;
+            break;
+        }
+        case __crt_lowio_text_mode::utf8:
+        {
+            bom        = UTF8_BOM;
+            bom_length = UTF8_BOMLEN;
+            break;
+        }
+        }
+
+        for (int total_written = 0; bom_length > total_written; )
+        {
+            char const* const bom_begin = reinterpret_cast<char const*>(&bom);
+
+            // Note that the call to write may write less than bom_length
+            // characters but not really fail.  We retry until the write fails
+            // or we have written all of the characters:
+            int const written = _write(fh, bom_begin + total_written, bom_length - total_written);
+            if (written == -1)
+                return errno;
+
+            total_written += written;
+        }
+    }
+
+    return 0; // Success!
+}
+
+
+
+extern "C" errno_t __cdecl _wsopen_nolock(
+    int*           const punlock_flag,
+    int*           const pfh,
+    wchar_t const* const path,
+    int            const oflag,
+    int            const shflag,
+    int            const pmode,
+    int            const secure
+    )
+{
+    UNREFERENCED_PARAMETER(secure);
+
+    // First, do the initial parse of the options.  The only thing that can fail
+    // here is the parsing of the share options, in which case -1 is returned
+    // and errno is set.
+    file_options options = decode_options(oflag, shflag, pmode);
+    if (options.share == static_cast<DWORD>(-1))
+    {
+        _doserrno = 0;
+        *pfh = -1;
+        return errno;
+    }
+
+    // Allocate the CRT file handle.  Note that if a handle is allocated, it is
+    // locked when it is returned by the allocation function.  It is our caller's
+    // responsibility to unlock the file handle (we do not unlock it before
+    // returning).
+    *pfh = _alloc_osfhnd();
+    if (*pfh == -1)
+    {
+        _doserrno = 0;
+        *pfh = -1;
+        errno = EMFILE;
+        return errno;
+    }
+
+    // Beyond this point, do not change *pfh, even if an error occurs.  Our
+    // caller requires the handle in order to release its lock.
+    *punlock_flag = 1;
+
+
+
+    SECURITY_ATTRIBUTES security_attributes;
+    security_attributes.nLength = sizeof(security_attributes);
+    security_attributes.lpSecurityDescriptor = nullptr;
+    security_attributes.bInheritHandle = (oflag & _O_NOINHERIT) == 0;
+
+
+    // Try to open or create the file:
+    HANDLE os_handle = create_file(path, &security_attributes, options);
+    if (os_handle == INVALID_HANDLE_VALUE)
+    {
+        if ((options.access & GENERIC_READ_WRITE) == GENERIC_READ_WRITE && (oflag & _O_WRONLY))
+        {
+            // The call may have failed because we may be trying to open
+            // something for reading that does not allow reading (e.g. a pipe or
+            // a device).  So, we try again with just GENERIC_WRITE.  If this
+            // succeeds, we will have to assume the default encoding because we
+            // will have no way to read the BOM.
+            options.access &= ~GENERIC_READ;
+
+            os_handle = create_file(path, &security_attributes, options);
+        }
+    }
+
+    if (os_handle == INVALID_HANDLE_VALUE)
+    {
+        // We failed to open the file.  We need to free the CRT file handle, but
+        // we do not release the lock--our caller releases the lock.
+        _osfile(*pfh) &= ~FOPEN;
+        __acrt_errno_map_os_error(GetLastError());
+        return errno;
+    }
+
+    // Find out what type of file this is (e.g., file, device, pipe, etc.)
+    DWORD const file_type = GetFileType(os_handle);
+
+    if (file_type == FILE_TYPE_UNKNOWN)
+    {
+        DWORD const last_error = GetLastError();
+        __acrt_errno_map_os_error(last_error);
+
+        _osfile(*pfh) &= ~FOPEN;
+        CloseHandle(os_handle);
+
+        // If GetFileType returns FILE_TYPE_UNKNOWN but doesn't fail, the file
+        // type really is unknown.  This function is not designed to handle
+        // unknown types of files, so we must return an error.
+        if (last_error == ERROR_SUCCESS)
+            errno = EACCES;
+
+        return errno;
+    }
+
+    if (file_type == FILE_TYPE_CHAR)
+    {
+        options.crt_flags |= FDEV;
+    }
+    else if (file_type == FILE_TYPE_PIPE)
+    {
+        options.crt_flags |= FPIPE;
+    }
+
+    // The file is open and valid.  Set the OS handle:
+    __acrt_lowio_set_os_handle(*pfh, reinterpret_cast<intptr_t>(os_handle));
+
+
+    // Mark the handle as open, and store the flags we gathered so far:
+    options.crt_flags |= FOPEN;
+    _osfile(*pfh) = options.crt_flags;
+
+
+    // The text mode is set to ANSI by default.  If we find a BOM, then we will
+    // reset this to the appropriate type (this check happens below).
+    _textmode(*pfh) = __crt_lowio_text_mode::ansi;
+
+
+    // If the text mode file is opened for writing and allows reading, remove
+    // any trailing Ctrl+Z character, if present, to ensure appending works:
+    if (oflag & _O_RDWR)
+    {
+        errno_t const result = truncate_ctrl_z_if_present(*pfh);
+        if (result != 0)
+        {
+            _close_nolock(*pfh);
+            return result;
+        }
+    }
+
+    // Configure the text mode:
+    __crt_lowio_text_mode text_mode = __crt_lowio_text_mode::ansi;
+    errno_t const text_mode_result = configure_text_mode(*pfh, options, oflag, text_mode);
+    if (text_mode_result != 0)
+    {
+        _close_nolock(*pfh);
+        return text_mode_result;
+    }
+
+    _textmode(*pfh)   = text_mode;
+    _tm_unicode(*pfh) = (oflag & _O_WTEXT) != 0;
+
+
+    // Set FAPPEND flag if appropriate. Don't do this for devices or pipes:
+    if ((options.crt_flags & (FDEV | FPIPE)) == 0 && (oflag & _O_APPEND))
+        _osfile(*pfh) |= FAPPEND;
+
+
+    // Finally, if we were asked only to open the file with write access but we
+    // opened it with read and write access in order to read the BOM, close the
+    // file and re-open it with only write access:
+    if ((options.access & GENERIC_READ_WRITE) == GENERIC_READ_WRITE && (oflag & _O_WRONLY))
+    {
+        CloseHandle(os_handle);
+        options.access &= ~GENERIC_READ;
+        os_handle = create_file(path, &security_attributes, options);
+
+        if (os_handle == INVALID_HANDLE_VALUE)
+        {
+            // Note that we can't use the normal close function here because the
+            // file isn't really open anymore.  We need only release the file
+            // handle by unsetting the FOPEN flag:
+            __acrt_errno_map_os_error(GetLastError());
+            _osfile(*pfh) &= ~FOPEN;
+            _free_osfhnd(*pfh);
+            return errno;
+        }
+        else
+        {
+            // We were able to open the file successfully, set the file
+            // handle in the _ioinfo structure, then we are done.  All
+            // the options.crt_flags should have been set properly already.
+            _osfhnd(*pfh) = reinterpret_cast<intptr_t>(os_handle);
+        }
+    }
+
+    return 0; // Success!
+}
+
+
+
+extern "C" errno_t __cdecl _sopen_nolock(
+    int*        const punlock_flag,
+    int*        const pfh,
+    char const* const path,
+    int         const oflag,
+    int         const shflag,
+    int         const pmode,
+    int         const secure
+    )
+{
+    // At this point we know path is not null already
+    __crt_internal_win32_buffer<wchar_t> wide_path;
+
+    errno_t const cvt = __acrt_mbs_to_wcs_cp(path, wide_path, __acrt_get_utf8_acp_compatibility_codepage());
+
+    if (cvt != 0) {
+        return -1;
+    }
+
+    return _wsopen_nolock(punlock_flag, pfh, wide_path.data(), oflag, shflag, pmode, secure);
+}
+
+
+
+extern "C" int __cdecl _sopen(char const* const path, int const oflag, int const shflag, ...)
+{
+    va_list ap;
+    va_start(ap, shflag);
+    int const pmode = va_arg(ap, int);
+    va_end(ap);
+
+    // The last argument is 0 so thta the pmode is not validated in open_s:
+    int fh = -1;
+    errno_t const result = _sopen_dispatch(path, oflag, shflag, pmode, &fh, FALSE);
+    return result ? -1 : fh;
+}
+
+extern "C" int __cdecl _wsopen(wchar_t const* const path, int const oflag, int const shflag, ...)
+{
+    va_list ap;
+    va_start(ap, shflag);
+    int const pmode = va_arg(ap, int);
+    va_end(ap);
+
+    // The last argument is 0 so thta the pmode is not validated in open_s:
+    int fh = -1;
+    errno_t const result = _wsopen_dispatch(path, oflag, shflag, pmode, &fh, FALSE);
+    return result ? -1 : fh;
+}
+
+
+
+extern "C" errno_t __cdecl _sopen_s(
+    int*        const pfh,
+    char const* const path,
+    int         const oflag,
+    int         const shflag,
+    int         const pmode
+    )
+{
+    // The last argument is 1 so that pmode is validated in open_s:
+    return _sopen_dispatch(path, oflag, shflag, pmode, pfh, TRUE);
+}
+
+extern "C" errno_t __cdecl _wsopen_s(
+    int*           const pfh,
+    wchar_t const* const path,
+    int            const oflag,
+    int            const shflag,
+    int            const pmode
+    )
+{
+    // The last argument is 1 so that pmode is validated in open_s:
+    return _wsopen_dispatch(path, oflag, shflag, pmode, pfh, TRUE);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/osfinfo.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/osfinfo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b4bd8d548966737dadd74234ee689448f8b95e1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/osfinfo.cpp	
@@ -0,0 +1,348 @@
+//
+// osfinfo.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the functions used to control allocation, locking, and freeing of CRT
+// file handles.
+//
+#include <corecrt_internal_lowio.h>
+
+
+
+extern "C" __crt_lowio_handle_data* __cdecl __acrt_lowio_create_handle_array()
+{
+    __crt_unique_heap_ptr<__crt_lowio_handle_data> array(_calloc_crt_t(
+        __crt_lowio_handle_data,
+        IOINFO_ARRAY_ELTS));
+
+    if (!array)
+        return nullptr;
+
+    __crt_lowio_handle_data* const first = array.get();
+    __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
+    for (auto it = first; it != last; ++it)
+    {
+        __acrt_InitializeCriticalSectionEx(&it->lock, _CORECRT_SPINCOUNT, 0);
+        it->osfhnd             = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+        it->startpos           = 0;
+        it->osfile             = 0;
+        it->textmode           = __crt_lowio_text_mode::ansi;
+        it->_pipe_lookahead[0] = LF;
+        it->_pipe_lookahead[1] = LF;
+        it->_pipe_lookahead[2] = LF;
+        it->unicode            = false;
+        it->utf8translations   = false;
+        it->dbcsBufferUsed     = false;
+        for (int i = 0; i < sizeof(it->mbBuffer); ++i)
+        {
+            it->mbBuffer[i] = '\0';
+        }
+    }
+
+    return array.detach();
+}
+
+extern "C" void __cdecl __acrt_lowio_destroy_handle_array(__crt_lowio_handle_data* const array)
+{
+    if (!array)
+        return;
+
+    __crt_lowio_handle_data* const first = array;
+    __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
+    for (auto it = first; it != last; ++it)
+    {
+        DeleteCriticalSection(&it->lock);
+    }
+
+    _free_crt(array);
+}
+
+// Ensures that a lowio handle data object has been created for file handle 'fh'.
+// The 'fh' must be less than the hard maximum, _NHANDLE_.  If 'fh' is already
+// backed by a handle data object, this function has no effect.  Otherwise, this
+// function extends the global arrays of handle data objects until 'fh' is backed
+// by a handle data object. 
+extern "C" errno_t __cdecl __acrt_lowio_ensure_fh_exists(int const fh)
+{
+    _VALIDATE_RETURN_ERRCODE(static_cast<unsigned>(fh) < _NHANDLE_, EBADF);
+
+    errno_t status = 0;
+
+    __acrt_lock(__acrt_lowio_index_lock);
+    __try
+    {
+        for (size_t i = 0; fh >= _nhandle; ++i)
+        {
+            if (__pioinfo[i])
+            {
+                continue;
+            }
+
+            __pioinfo[i] = __acrt_lowio_create_handle_array();
+            if (!__pioinfo[i])
+            {
+                status = ENOMEM;
+                __leave;
+            }
+
+            _nhandle += IOINFO_ARRAY_ELTS;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_lowio_index_lock);
+    }
+
+    return status;
+}
+
+
+
+// Allocates a CRT file handle.  This function finds the first free entry in
+// the arrays of file objects and returns the index of that entry (that index
+// is the CRT file handle) to the caller.  The FOPEN flag is set in the new
+// entry, to pevent multithreaded race conditions and deadlocks.
+//
+// Returns the CRT file handle on success; returns -1 on failure (e.g. if no
+// more file handles are available or if memory allocation is required but
+// fails).
+//
+// MULTITHREADING NOTE:  If this function is successful and returns a CRT file
+// handle, the handle is locked when it is returned and the FOPEN flag has been
+// set.  The caller must be sure to release the lock, and if the caller abandons
+// the file handle, it must clear the FOPEN flag to free the handle.
+extern "C" int __cdecl _alloc_osfhnd()
+{
+    __acrt_lock(__acrt_lowio_index_lock);
+    int result = -1;
+    __try
+    {
+        // Search the arrays of file objects, in order, looking for the first
+        // free entry.  The compound index of this free entry is the return
+        // value.
+        //
+        // The compound index of the file object entry *(__pioinfo[i] + j) is
+        // k = i * IOINFO_ARRAY_ELTS + j.
+        for (int i = 0; i < IOINFO_ARRAYS; ++i)
+        {
+            // If this __crt_lowio_handle_data array does not yet exist, create a new one:
+            if (!__pioinfo[i])
+            {
+                __pioinfo[i] = __acrt_lowio_create_handle_array();
+                if (!__pioinfo[i])
+                    __leave;
+
+                _nhandle += IOINFO_ARRAY_ELTS;
+
+                // The first element of the newly allocated array of handle data
+                // objects is our first free entry.  Note that since we hold the
+                // index lock, no one else can allocate this handle.
+                int const fh = i * IOINFO_ARRAY_ELTS;
+
+                __acrt_lowio_lock_fh(fh);
+                _osfile(fh) = FOPEN;
+                result = fh;
+                __leave;
+            }
+
+            // Otherwise, this file object array already exists.  Search it looking
+            // for the first free entry:
+            __crt_lowio_handle_data* const first = __pioinfo[i];
+            __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
+            for (__crt_lowio_handle_data* pio = first; pio != last; ++pio)
+            {
+                if (pio->osfile & FOPEN)
+                    continue;
+
+                // Another thread may have grabbed this file handle out from
+                // under us while we waited for the lock.  If so, continue on
+                // searching through the array.
+                //
+                // CRT_REFACTOR TODO:  Resolve lowio synchronization issues.
+                EnterCriticalSection(&pio->lock);
+                if ((pio->osfile & FOPEN) != 0)
+                {
+                    LeaveCriticalSection(&pio->lock);
+                    continue;
+                }
+
+                // Otherwise, this entry is ours:  we hold the lock, so we can
+                // initialize it and return its handle:
+                int const fh = i * IOINFO_ARRAY_ELTS + static_cast<int>(pio - first);
+                _osfile(fh) = FOPEN;
+                _osfhnd(fh) = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+                result = fh;
+                __leave;
+            }
+        }
+
+        // All entries are in use if we fall out of the loop.  return -1 in this case (which result is already set to)
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_lowio_index_lock);
+    }
+    return result;
+}
+
+
+
+// Sets the Win32 HANDLE associated with the specified CRT file.  Returns 0
+// on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl __acrt_lowio_set_os_handle(int const fh, intptr_t const value)
+{
+    if (fh >= 0 &&
+        static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle) &&
+        _osfhnd(fh) == reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE))
+    {
+        if (_query_app_type() == _crt_console_app)
+        {
+            HANDLE const handle_value = reinterpret_cast<HANDLE>(value);
+            switch (fh)
+            {
+            case 0: SetStdHandle(STD_INPUT_HANDLE,  handle_value); break;
+            case 1: SetStdHandle(STD_OUTPUT_HANDLE, handle_value); break;
+            case 2: SetStdHandle(STD_ERROR_HANDLE,  handle_value); break;
+            }
+        }
+
+        _osfhnd(fh) = value;
+        return 0 ;
+    }
+    else
+    {
+        errno = EBADF; // Bad handle
+        _doserrno = 0; // This is not an OS error
+        return -1;
+    }
+}
+
+
+
+// Marks the specified CRT file handle as free and available for allocation.
+// Returns 0 on success; returns -1 and sets errno on failure.
+extern "C" int __cdecl _free_osfhnd(int const fh)
+{
+    if (fh >= 0 &&
+        static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle) &&
+        (_osfile(fh) & FOPEN) &&
+        _osfhnd(fh) != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE))
+    {
+        if (_query_app_type() == _crt_console_app)
+        {
+            switch (fh)
+            {
+            case 0: SetStdHandle(STD_INPUT_HANDLE,  nullptr); break;
+            case 1: SetStdHandle(STD_OUTPUT_HANDLE, nullptr); break;
+            case 2: SetStdHandle(STD_ERROR_HANDLE,  nullptr); break;
+            }
+        }
+
+        _osfhnd(fh) = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
+        return 0;
+    }
+    else
+    {
+        errno = EBADF; // Bad handle
+        _doserrno = 0; // This is not an OS error
+        return -1;
+    }
+}
+
+
+
+// Gets the Win32 HANDLE with which the given CRT file handle is associated.
+// On success, returns the Win32 HANDLE; on failure, returns -1 and sets errno.
+extern "C" intptr_t __cdecl _get_osfhandle(int const fh)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1 );
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+
+    return _osfhnd(fh);
+}
+
+
+
+// Allocates a free CRT file handle and associates it with the provided Win32
+// HANDLE and sets its flags to the given flags.  Returns the CRT file handle
+// on success; returns -1 on failure.
+extern "C" int __cdecl _open_osfhandle(intptr_t const osfhandle, int const source_flags)
+{
+    // Copy relevant source_flags from second parameter
+    unsigned char file_flags = 0;
+
+    if (source_flags & _O_APPEND)
+        file_flags |= FAPPEND;
+
+    if (source_flags & _O_TEXT)
+        file_flags |= FTEXT;
+
+    if (source_flags & _O_NOINHERIT)
+        file_flags |= FNOINHERIT;
+
+    // Find out what type of file (file/device/pipe):
+    DWORD const file_type = GetFileType(reinterpret_cast<HANDLE>(osfhandle));
+    if (file_type == FILE_TYPE_UNKNOWN)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    if (file_type == FILE_TYPE_CHAR)
+        file_flags |= FDEV;
+
+    else if (file_type == FILE_TYPE_PIPE)
+        file_flags |= FPIPE;
+
+    // Attempt to allocate a CRT file handle:
+    int const fh = _alloc_osfhnd();
+    if (fh == -1)
+    {
+        errno = EMFILE; // Too many open files
+        _doserrno = 0L; // This is not an OS error
+        return -1;
+    }
+
+    bool success = false;
+    __try
+    {
+        // The file is open. now set the info in _osfhnd array:
+        __acrt_lowio_set_os_handle(fh, osfhandle);
+
+        file_flags |= FOPEN;
+
+        _osfile(fh) = file_flags;
+        _textmode(fh) = __crt_lowio_text_mode::ansi;
+        _tm_unicode(fh) = false;
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            _osfile(fh) &= ~FOPEN;
+        }
+
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return fh;
+}
+
+
+
+// Acquires the lock associated with the given file handle.
+extern "C" void __cdecl __acrt_lowio_lock_fh(int const fh)
+{
+    EnterCriticalSection(&_pioinfo(fh)->lock);
+}
+
+
+
+// Releases the lock associated with the given file handle.
+extern "C" void __cdecl __acrt_lowio_unlock_fh(int const fh)
+{
+    LeaveCriticalSection(&_pioinfo(fh)->lock);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/read.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/read.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e3c037e2f0db89e7ccb097c3b43d8727588d6b41
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/read.cpp	
@@ -0,0 +1,635 @@
+//
+// read.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _read(), which reads bytes from a file.
+//
+#include <corecrt_internal_lowio.h>
+
+// Lookup table for UTF-8 lead bytes
+// Probably preferable to just ask if the bits are set than use an entire
+// table, however the macros using this were #defined in the header so
+// removing this extern table would break apps compiled to an earlier verison.
+//    1 for pattern 110xxxxx - 1 trailbyte
+//    2 for pattern 1110xxxx - 2 trailbytes
+//    3 for pattern 11110xxx - 3 trailbytes
+//    0 for everything else, including invalid patterns.
+// We return 0 for invalid patterns because we rely on MultiByteToWideChar to
+// do the validations.
+extern "C" char _lookuptrailbytes[256] =
+{
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+static void store_lookahead(int const fh, char const c) throw()
+{
+    _pipe_lookahead(fh)[0] = c;
+}
+
+static void store_lookahead(int const fh, wchar_t const c) throw()
+{
+    char const* const byte_pointer = reinterpret_cast<char const*>(&c);
+    _pipe_lookahead(fh)[0] = byte_pointer[0];
+    _pipe_lookahead(fh)[1] = byte_pointer[1];
+    _pipe_lookahead(fh)[2] = LF; // Mark as empty
+}
+
+
+
+static int __cdecl translate_utf16_from_console_nolock(
+                            int      const  fh,
+    _Inout_updates_(count)  wchar_t* const  buffer,
+                            size_t   const  count
+    ) throw()
+{
+    // The translation can be performend in-place, because we are converting
+    // CRLF sequences into LF, so the resulting text will never be longer than
+    // any corresponding source text.
+    wchar_t* const buffer_end = buffer + count;
+
+    wchar_t* source_it = buffer;
+    wchar_t* result_it = buffer;
+
+    while (source_it < buffer_end)
+    {
+        // If at any point during translation we encounter a Ctrl+Z, we stop
+        // translating immediately:
+        if (*source_it == CTRLZ)
+        {
+            _osfile(fh) |= FEOFLAG;
+            break;
+        }
+
+        // When a CR character is encountered, we must check to see if the next
+        // character is an LF.  If it is, then we skip the CR and copy only the
+        // LF:
+        if (*source_it == CR && source_it + 1 < buffer_end && *(source_it + 1) == LF)
+        {
+            source_it += 2;
+            *result_it++ = LF;
+            continue;
+        }
+
+        // Otherwise, we just copy the character:
+        *result_it++ = *source_it++;
+    }
+
+    // Return the number of bytes that we translated:
+    return static_cast<int>((result_it - buffer) * sizeof(wchar_t));
+}
+
+
+
+template <typename Character>
+static int __cdecl translate_text_mode_nolock(
+    _In_                                                         int        const fh,
+    _Pre_writable_size_(count) _Post_readable_byte_size_(return) Character* const buffer,
+    _In_                                                         size_t     const count
+    ) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_osfhnd(fh));
+
+    // If there is an LF at the beginning of the buffer, set the CRLF flag:
+    if (count != 0 && *buffer == LF)
+    {
+        _osfile(fh) |= FCRLF;
+    }
+    else
+    {
+        _osfile(fh) &= ~FCRLF;
+    }
+
+    // The translation can be performend in-place, because we are converting
+    // CRLF sequences into LF, so the resulting text will never be longer than
+    // any corresponding source text.
+    Character* const buffer_end = buffer + count;
+
+    Character* source_it = buffer;
+    Character* result_it = buffer;
+
+    while (source_it < buffer_end)
+    {
+        // If during translation we encounter a Ctrl+Z, we stop translating
+        // immeidately.  For devices, we need to just set the Ctrl+Z flag;
+        // for other files, we just copy the Ctrl+Z as a normal character
+        // before returning:
+        if (*source_it == CTRLZ)
+        {
+            if ((_osfile(fh) & FDEV) == 0)
+            {
+                _osfile(fh) |= FEOFLAG;
+            }
+            else
+            {
+                *result_it++ = *source_it++;
+            }
+
+            break;
+        }
+
+        // If the character is not a CR, then we can simply copy it:
+        if (*source_it != CR)
+        {
+            *result_it++ = *source_it++;
+            continue;
+        }
+
+        // Otherwise, the character is a CR.  We need to look-ahead to see if
+        // the next character is an LF, so that we can perform the CRLF => LF
+        // translation.  First, handle the easy case where the CR does not
+        // appear at the end of the buffer:
+        if (source_it + 1 < buffer_end)
+        {
+            if (*(source_it + 1) == LF)
+            {
+                source_it += 2;
+                *result_it++ = LF; // Convert CRLF => LF
+            }
+            else
+            {
+                *result_it++ = *source_it++;
+            }
+
+            continue;
+        }
+
+        // This is the hard case:  The CR is at the end of the buffer.  We need
+        // to peek ahead to see if the next character is an LF:
+        ++source_it;
+
+        Character peek;
+        DWORD     peek_size;
+        if (!ReadFile(os_handle, &peek, sizeof(peek), &peek_size, nullptr) || peek_size == 0)
+        {
+            // We couldn't peek ahead; just store the CR:
+            *result_it++ = CR;
+            continue;
+        }
+
+        // The peek succeeded.  What we do next depends on whether the file is
+        // seekable or not.  First we handle the case where the file does not
+        // allow seeking:
+        if (_osfile(fh) & (FDEV | FPIPE))
+        {
+            // If the peek character is an LF, then we just need to copy that
+            // character to the output buffer:
+            if (peek == LF)
+            {
+                *result_it++ = LF;
+            }
+            // Otherwise, it was some other character.  We need to write the CR
+            // to the output buffer, then we need to store the peek character
+            // for later retrieval:
+            else
+            {
+                *result_it++ = CR;
+                store_lookahead(fh, peek);
+            }
+        }
+        // If the file does allow seeking, then we handle the peek differently.
+        // For seekable files, we translate the CRLF => LF by eliminating the
+        // CR.  If the peek character is an LF, we simply do not write it to
+        // the output buffer; instead, we will seek backwards to unpeek the
+        // character, then let the LF get retrieved during the next call to
+        // read().
+        else
+        {
+            // However, if the buffer is currenty empty, then this is a one-
+            // character read, so we store the LF in order that we make progress
+            if (peek == LF && result_it == buffer)
+            {
+                *result_it++ = LF;
+            }
+            // Otherwise, we do what is described above:  we seek backwards and
+            // write the CR if and only if the peek character was not an LF:
+            else
+            {
+                _lseeki64_nolock(fh, -1 * static_cast<int>(sizeof(Character)), FILE_CURRENT);
+                if (peek != LF)
+                {
+                    *result_it++ = CR;
+                }
+            }
+        }
+    }
+
+    // Return the number of bytes that we translated:
+    return static_cast<int>((result_it - buffer) * sizeof(Character));
+}
+
+
+
+_Success_(return != -1)
+static int __cdecl translate_ansi_or_utf8_nolock(
+                                                                        int      const fh,
+    _In_reads_(source_count)                                            char*    const source_buffer,
+                                                                        size_t   const source_count,
+    _Pre_writable_size_(result_count) _Post_readable_byte_size_(return) wchar_t* const result_buffer,
+                                                                        size_t   const result_count
+    ) throw()
+{
+    int const text_mode_translation_result_size = translate_text_mode_nolock(fh, source_buffer, source_count);
+
+    // If we read no characters, then we are done:
+    if (text_mode_translation_result_size == 0)
+    {
+        return 0;
+    }
+
+    // If the file is open in ANSI mode, then no further translation is
+    // required; we can simply return the number of bytes that we read.
+    // Even though there is no translation, there may still be
+    // characters in the buffer due to CRLF translation (a CR without
+    // a LF would 'unget' the would-be LF).
+    // text_mode_translation_result_size has already been adjusted for
+    // CRLF translation by translate_text_mode_nolock().
+    if (_textmode(fh) == __crt_lowio_text_mode::ansi)
+    {
+        return text_mode_translation_result_size;
+    }
+
+    // Otherwise, the file is open in UTF-8 mode and we read a nonzero number
+    // of characters.  We need to translate from UTF-8 to UTF-16.  To do this,
+    // we first need to hunt for the end of the translatable buffer.  This may
+    // not be result_it, because we may have read a partial multibyte UTF-8
+    // character.
+    char* result_it = source_buffer + text_mode_translation_result_size - 1;
+
+    // If the last character is an independent character, then we can
+    // translate the entire buffer:
+    if (_utf8_is_independent(*result_it))
+    {
+        ++result_it; // Reset the result_it
+    }
+    // Otherwise, we have to find the end of the last full UTF-8 character
+    // that was read:
+    else
+    {
+        // Walk backwards from the end of the buffer until we find a lead byte:
+        unsigned counter = 1;
+        while (!_utf8_is_leadbyte(*result_it) && counter <= 4 && result_it >= source_buffer)
+        {
+            --result_it;
+            ++counter;
+        }
+
+        // Now that we've found the last lead byte, determine whether the
+        // character is complete or incomplete.  We compute the number of
+        // trailbytes...
+        unsigned const trailbyte_count = _utf8_no_of_trailbytes(static_cast<const unsigned char>(*result_it));
+        if (trailbyte_count == 0)
+        {
+            // Oh, apparently that wasn't a lead byte; the file contains invalid
+            // UTF-8 character sequences:
+            errno = EILSEQ;
+            return -1;
+        }
+
+        // If the lead byte plus the remaining bytes form a full set, then we
+        // can translate the entire buffer:
+        if (trailbyte_count + 1 == counter)
+        {
+            result_it += counter;
+        }
+        // Otherwise, the last character is incomplete, so we will not include
+        // this character in the result.  We unget the last characters, either
+        // by seeking backwards if the file is seekable, or by buffering the
+        // characters.  Note that result_it currently points one-past-the-end
+        // of the translatable buffer, because it points to the lead byte of
+        // the partially read character.
+        else
+        {
+            // If the file does not support seeking, buffer the characters:
+            if (_osfile(fh) & (FDEV | FPIPE))
+            {
+                _pipe_lookahead(fh)[0] = *result_it++;
+
+                if (counter >= 2)
+                {
+                    _pipe_lookahead(fh)[1] = *result_it++;
+                }
+
+                if (counter == 3)
+                {
+                    _pipe_lookahead(fh)[2] = *result_it++;
+                }
+
+                // Now that we've buffered the characters, seek the end iterator
+                // back to the actual end of the translatable sequence:
+                result_it -= counter;
+
+            }
+            // If the file does support seeking, we can just seek backwards so
+            // that the next read will get the characters directly:
+            else
+            {
+                _lseeki64_nolock(fh, -static_cast<int>(counter), FILE_CURRENT);
+            }
+        }
+    }
+
+    // Finally, we can translate the characters into the result buffer:
+    int const characters_translated = static_cast<int>(__acrt_MultiByteToWideChar(
+            CP_UTF8,
+            0,
+            source_buffer,
+            static_cast<DWORD>(result_it - source_buffer),
+            result_buffer,
+            static_cast<DWORD>(result_count)));
+
+    if (characters_translated == 0)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    _utf8translations(fh) = (characters_translated != static_cast<int>(result_it - source_buffer));
+
+    // MultiByteToWideChar returns the number of wide characters that
+    // it produced; we need to return the number of bytes:
+    return characters_translated * sizeof(wchar_t);
+}
+
+
+
+// Reads bytes from a file.  This function attempts to read enough bytes to fill
+// the provided buffer.  If the file is in text mode, CRLF sequences are mapped
+// to LF, thus affecting the number of characters read.  This mapping does not
+// affect the file pointer.
+//
+// Returns the number of bytes read, which may be less than the number of bytes
+// requested if EOF was reached or if the file is in text mode.  Returns -1 and
+// sets errno on failure.
+extern "C" int __cdecl _read(int const fh, void* const buffer, unsigned const buffer_size)
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(buffer_size <= INT_MAX, EINVAL, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _doserrno = 0;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = _read_nolock(fh, buffer, buffer_size);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _read_nolock(
+    int      const fh,
+    void*    const result_buffer,
+    unsigned const result_buffer_size
+    )
+{
+    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1 );
+    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+    _VALIDATE_CLEAR_OSSERR_RETURN(result_buffer_size <= INT_MAX, EINVAL, -1);
+
+    // If there is no data to be written or if the file is at EOF, no work to do:
+    if (result_buffer_size == 0 || (_osfile(fh) & FEOFLAG))
+        return 0;
+
+    _VALIDATE_CLEAR_OSSERR_RETURN(result_buffer != nullptr, EINVAL, -1);
+
+
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    __crt_lowio_text_mode const text_mode = _textmode(fh);
+
+
+    __crt_unique_heap_ptr<char> owned_internal_buffer;
+
+    char*    internal_buffer;
+    unsigned internal_buffer_remaining;
+    switch (text_mode)
+    {
+    case __crt_lowio_text_mode::utf8:
+        // For UTF-8 files, we need two buffers, because after reading we need
+        // to convert the text into Unicode.  MultiByteToWideChar doesn't do
+        // in-place conversions.
+        //
+        // The multibyte to wide character conversion may double the size of the
+        // text, hence we halve the size here.
+        //
+        // Since we are reading a UTF-8 stream, the number of bytes read may
+        // vary from 'size' characters to 'size/4' characters.  For this reason,
+        // if we need to read 'size' characters, we will allocate an MBCS buffer
+        // of size 'size'.  In case the size is zero, we will use four as a
+        // minimum value.  This will make sure we don't overflow when we read
+        // from a pipe.
+        //
+        // In this case, the number of wide characters that we can read is
+        // size / 2.  This means that we require a buffer of size size / 2.
+
+        // For UTF-8 the count always needs to be an even number:
+        _VALIDATE_CLEAR_OSSERR_RETURN(result_buffer_size % 2 == 0, EINVAL, -1);
+
+        internal_buffer_remaining = (result_buffer_size / 2) < 4
+            ? 4
+            : (result_buffer_size/2);
+
+        owned_internal_buffer = _malloc_crt_t(char, internal_buffer_remaining);
+        internal_buffer = owned_internal_buffer.get();
+        if (!internal_buffer)
+        {
+            errno = ENOMEM;
+            _doserrno = ERROR_NOT_ENOUGH_MEMORY;
+            return -1;
+        }
+
+        _startpos(fh) = _lseeki64_nolock(fh, 0, FILE_CURRENT);
+        break;
+
+    case __crt_lowio_text_mode::utf16le:
+        // For UTF-16 the count always needs to be an even number:
+        _VALIDATE_CLEAR_OSSERR_RETURN((result_buffer_size % 2) == 0, EINVAL, -1);
+
+        // For UTF-16 files, we can directly use the input buffer:
+        internal_buffer_remaining = result_buffer_size;
+        internal_buffer           = static_cast<char*>(result_buffer);
+        break;
+
+    default:
+        // For ANSI files, we can directly use the input buffer:
+        internal_buffer_remaining = result_buffer_size;
+        internal_buffer           = static_cast<char*>(result_buffer);
+        break;
+    }
+
+    wchar_t* wide_internal_buffer = reinterpret_cast<wchar_t*>(internal_buffer);
+
+    int bytes_read = 0;
+
+    // We may have buffered look-ahead characters during the last read.  If
+    // so, read them into the buffer and set the look-ahead buffers back to
+    // empty state (with the value of LF):
+    //
+    // CRT_REFACTOR This look-ahead buffering could use additional work, but
+    // will require nonlocal changes, so that work is not included in this
+    // changeset.
+    if ((_osfile(fh) & (FPIPE | FDEV)) &&
+        _pipe_lookahead(fh)[0] != LF &&
+        internal_buffer_remaining != 0)
+    {
+        *internal_buffer++ = _pipe_lookahead(fh)[0];
+        ++bytes_read;
+        --internal_buffer_remaining;
+        _pipe_lookahead(fh)[0] = LF;
+
+        // For UTF-16, there may be an additional look-ahead character
+        // bufferred.  For UTF-8, there may be two more:
+        if (text_mode != __crt_lowio_text_mode::ansi &&
+            _pipe_lookahead(fh)[1] != LF &&
+            internal_buffer_remaining != 0)
+        {
+            *internal_buffer++ = _pipe_lookahead(fh)[1];
+            ++bytes_read;
+            --internal_buffer_remaining;
+            _pipe_lookahead(fh)[1] = LF;
+
+            if (text_mode == __crt_lowio_text_mode::utf8 &&
+                _pipe_lookahead(fh)[2] != LF &&
+                internal_buffer_remaining != 0)
+            {
+                *internal_buffer++ = _pipe_lookahead(fh)[2];
+                ++bytes_read;
+                --internal_buffer_remaining;
+                _pipe_lookahead(fh)[2] = LF;
+            }
+        }
+    }
+
+    DWORD console_mode;
+    bool const from_console =
+        _isatty(fh) &&
+        (_osfile(fh) & FTEXT) &&
+        GetConsoleMode(os_handle, &console_mode);
+
+    // Read the data directly from the console:
+    if (from_console && text_mode == __crt_lowio_text_mode::utf16le)
+    {
+        DWORD console_characters_read;
+        if (!ReadConsoleW(
+                os_handle,
+                internal_buffer,
+                internal_buffer_remaining / sizeof(wchar_t),
+                &console_characters_read,
+                nullptr))
+        {
+            __acrt_errno_map_os_error(GetLastError());
+            return -1;
+        }
+
+        // In UTF-16 mode, the return value is the actual number of wide
+        // characters read; we need the number of bytes:
+        bytes_read += console_characters_read * sizeof(wchar_t);
+    }
+    // Otherwise, read the data from the file normally:
+    else
+    {
+        DWORD bytes_read_from_file;
+        if (!ReadFile(
+                os_handle,
+                internal_buffer,
+                internal_buffer_remaining,
+                &bytes_read_from_file,
+                nullptr
+            ) || bytes_read_from_file > result_buffer_size)
+        {
+            DWORD const last_error = GetLastError();
+            if (last_error == ERROR_ACCESS_DENIED)
+            {
+                // ERROR_ACCESS_DENIED occurs if the file is open with the wrong
+                // read/write mode.  For this error, we should return EBADF, not
+                // the EACCES that will be set by __acrt_errno_map_os_error:
+                errno = EBADF;
+                _doserrno = last_error;
+                return -1;
+
+            }
+            else if (last_error == ERROR_BROKEN_PIPE)
+            {
+                // Return 0 if ERROR_BROKEN_PIPE occurs.  It means the handle is
+                // a read handle on a pipe for which all write handles have been
+                // closed and all data has been read:
+                return 0;
+            }
+            else
+            {
+                // Otherwise, map the error normally and return:
+                __acrt_errno_map_os_error(last_error);
+                return -1;
+            }
+        }
+
+        bytes_read += bytes_read_from_file;
+    }
+
+
+    // If the file is open in binary mode, no translation is required, so we
+    // can skip all of the rest of this function:
+    if ((_osfile(fh) & FTEXT) == 0)
+        return bytes_read;
+
+
+    // Perform the CRLF => LF translation and convert to the required
+    // encoding (UTF-8 must be converted to UTF-16).  This first case
+    // handles UTF-8 and ANSI:
+    if (text_mode != __crt_lowio_text_mode::utf16le)
+    {
+        return translate_ansi_or_utf8_nolock(
+            fh,
+            internal_buffer,
+            bytes_read,
+            static_cast<wchar_t*>(result_buffer),
+            result_buffer_size / sizeof(wchar_t));
+    }
+
+    // The text mode is __crt_lowio_text_mode::utf16le and we are reading from the
+    // console:
+    else if (from_console)
+    {
+        return translate_utf16_from_console_nolock(
+            fh,
+            wide_internal_buffer,
+            bytes_read / sizeof(wchar_t));
+    }
+    // Otherwise, the text mode is __crt_lowio_text_mode::utf16le and we are NOT
+    // reading from the console:
+    else
+    {
+        return translate_text_mode_nolock(
+            fh,
+            wide_internal_buffer,
+            bytes_read / sizeof(wchar_t));
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/setmode.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/setmode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4793573f5ad036a533eee9e773a98a3d1c3c7d4f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/setmode.cpp	
@@ -0,0 +1,121 @@
+//
+// setmode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _setmode(), which sets the translation mode for a file, and
+// _set_fmode() and _get_fmode(), which control the global default translation
+// mode.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdlib.h>
+
+
+
+// Sets the file translation mode.  This changes the file mode to text or binary,
+// depending on the mode argument.  This affects whether reads and writes on the
+// file translate between CRLF and LF.  Returns the old file translation mode on
+// success, or -1 on failure.
+extern "C" int __cdecl _setmode(int const fh, int const mode)
+{
+    _VALIDATE_RETURN(mode == _O_TEXT   ||
+                     mode == _O_BINARY ||
+                     mode == _O_WTEXT  ||
+                     mode == _O_U8TEXT ||
+                     mode == _O_U16TEXT,
+                     EINVAL, -1);
+
+    _CHECK_FH_RETURN(fh, EBADF, -1);
+    _VALIDATE_RETURN((fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _VALIDATE_RETURN((_osfile(fh) & FOPEN), EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            errno = EBADF;
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = _setmode_nolock(fh, mode);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+
+
+extern "C" int __cdecl _setmode_nolock(int const fh, int const mode)
+{
+    int const old_mode = _osfile(fh) & FTEXT;
+    __crt_lowio_text_mode const old_textmode = _textmode(fh);
+
+    switch (mode)
+    {
+    case _O_BINARY:
+        _osfile(fh) &= ~FTEXT;
+        break;
+
+    case _O_TEXT:
+        _osfile(fh) |= FTEXT;
+        _textmode(fh) = __crt_lowio_text_mode::ansi;
+        break;
+
+    case _O_U8TEXT:
+        _osfile(fh) |= FTEXT;
+        _textmode(fh) = __crt_lowio_text_mode::utf8;
+        break;
+
+    case _O_U16TEXT:
+    case _O_WTEXT:
+        _osfile(fh) |= FTEXT;
+        _textmode(fh) = __crt_lowio_text_mode::utf16le;
+        break;
+    }
+
+    if (old_mode == 0)
+        return _O_BINARY;
+
+	if (old_textmode == __crt_lowio_text_mode::ansi)
+	{
+		return _O_TEXT;
+	}
+	else if (old_textmode == __crt_lowio_text_mode::utf8)
+	{
+		return _O_U8TEXT;
+	}
+
+    return _O_WTEXT;
+}
+
+
+
+extern "C" errno_t __cdecl _set_fmode(int const mode)
+{
+    _VALIDATE_RETURN_ERRCODE(mode == _O_TEXT || mode == _O_BINARY || mode == _O_WTEXT, EINVAL);
+
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    _InterlockedExchange(reinterpret_cast<long*>(&_fmode.value()), mode);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+
+    return 0;
+}
+
+
+
+extern "C" errno_t __cdecl _get_fmode(int* const pMode)
+{
+    _VALIDATE_RETURN_ERRCODE(pMode != nullptr, EINVAL);
+
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    *pMode = __crt_interlocked_read(&_fmode.value());
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/tell.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/tell.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1c6b88032383ff2a55571b7b5086104321b94f0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/tell.cpp	
@@ -0,0 +1,18 @@
+//
+// tell.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _tell(), which gets the current position of the file pointer.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdio.h>
+
+
+
+// Gets the current position of the file pointer, without adjustment for
+// buffering.  Returns -1 on error.
+extern "C" long __cdecl _tell(int const fh)
+{
+    return _lseek(fh, 0, SEEK_CUR);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/telli64.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/telli64.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..be6240f29042e27fa3b1e5be13337cf4697f4e55
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/telli64.cpp	
@@ -0,0 +1,18 @@
+//
+// telli64.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _telli64(), which gets the current position of the file pointer.
+//
+#include <corecrt_internal_lowio.h>
+#include <stdio.h>
+
+
+
+// Gets the current position of the file pointer, without adjustment for
+// buffering.  Returns -1 on error.
+extern "C" __int64 __cdecl _telli64(int const fh)
+{
+    return _lseeki64(fh, 0, SEEK_CUR);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/txtmode.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/txtmode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d4571e2b550402230a5b21bea494e1ab855bcaa9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/txtmode.cpp	
@@ -0,0 +1,47 @@
+//
+// txtmode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the global _fmode variable and sets the global file mode to text.
+// This is the default behavior.
+//
+#include <corecrt_internal.h>
+#include <fcntl.h>
+#include <stdlib.h>
+
+// Clients of the static CRT can choose to access _fmode directly as a global variable; they do so as if it was declared as an int.
+// Because state separation is disabled in the static CRT, the dual_state_global<int> has the same representation as an int, so this is okay, if a bit messy.
+__crt_state_management::dual_state_global<int> _fmode;  // This is automatically initialized to zero by the compiler
+
+extern "C" int* __cdecl __p__fmode()
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return &_fmode.value();
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
+
+// Initializer for fmode global correction.
+_CRT_LINKER_FORCE_INCLUDE(__acrt_fmode_initializer);
+
+extern "C" int __cdecl __acrt_initialize_fmode()
+{
+    // The initial mode for _fmode is initialized during pre_c_initializer() in vcstartup, so that it can be overridden with a linkopt.
+    // The default value is provided by _get_startup_file_mode(), but this value is not used to initialize both _fmode states.
+    // (ex: if exe is Prog-Mode, OS-Mode _fmode is uninitialized, if exe is OS-Mode, Prog-Mode _fmode is uninitialized)
+
+    // To fix this, we adjust zero-value _fmode to _O_TEXT, since that is the default.
+    // Only the exe can use the linkopt, so the state that is not being initialized could not have requested _O_BINARY.
+
+    int * const fmode_states = _fmode.dangerous_get_state_array();
+    for (unsigned int i = 0; i != __crt_state_management::state_index_count; ++i)
+    {
+        int& fmode_state = fmode_states[i];
+        if (fmode_state == 0)
+        {
+            fmode_state = _O_TEXT;
+        }
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/umask.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/umask.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd8d54614b05a179ca05c47cec51844b63c0acd5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/umask.cpp	
@@ -0,0 +1,66 @@
+/***
+*umask.c - set file permission mask
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _umask() - sets file permission mask of current process*
+*       affecting files created by creat, open, or sopen.
+*
+*******************************************************************************/
+
+#include <corecrt_internal_lowio.h>
+#include <sys\stat.h>
+
+extern "C" int _umaskval = 0;
+
+/***
+*errno_t _umask(mode, poldmode) - set the file mode mask
+*
+*Purpose :
+*    Works similiar to umask except it validates input params.
+*
+*
+*******************************************************************************/
+
+extern "C" errno_t __cdecl _umask_s(
+    int  const mode,
+    int* const old_mode
+    )
+{
+    _VALIDATE_RETURN_ERRCODE(old_mode != nullptr, EINVAL);
+    *old_mode = _umaskval;
+    _VALIDATE_RETURN_ERRCODE((mode & ~(_S_IREAD | _S_IWRITE)) == 0, EINVAL);
+
+    _umaskval = mode;
+    return 0;
+}
+
+/***
+*int _umask(mode) - set the file mode mask
+*
+*Purpose:
+*       Sets the file-permission mask of the current process* which
+*       modifies the permission setting of new files created by creat,
+*       open, or sopen.
+*
+*Entry:
+*       int mode - new file permission mask
+*                  may contain _S_IWRITE, _S_IREAD, _S_IWRITE | _S_IREAD.
+*                  The S_IREAD bit has no effect under Win32
+*
+*Exit:
+*       returns the previous setting of the file permission mask.
+*
+*Exceptions:
+*
+*******************************************************************************/
+extern "C" int __cdecl _umask(int const mode)
+{
+    // Silently ignore non-Windows modes:
+    int const masked_mode = mode & (_S_IREAD | _S_IWRITE);
+
+    int old_mode = 0;
+    _umask_s(masked_mode, &old_mode);
+    return old_mode;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/write.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/write.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f5c0b1ead9ff7970f9f91f92d5d8a04c5c811a5f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/lowio/write.cpp	
@@ -0,0 +1,754 @@
+//
+// write.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _write(), which writes a buffer to a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <ctype.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+
+
+namespace
+{
+    struct write_result
+    {
+        DWORD error_code;
+        DWORD char_count;
+        DWORD lf_count;
+    };
+}
+
+
+
+// This is the normal size of the LF => CRLF translation buffer.  The default
+// buffer is 4K, plus extra room for LF characters.  Not all buffers are exactly
+// this size, but this is used as the base size.
+static size_t const BUF_SIZE = 5 * 1024;
+
+
+
+// Writes a buffer to a file.  The way in which the buffer is written depends on
+// the mode in which the file was opened (e.g., if the file is a text mode file,
+// linefeed translation will take place).
+//
+// On success, this function returns the number of bytes actually written (note
+// that "bytes" here is "bytes from the original buffer;" more or fewer bytes
+// may have actually been written, due to linefeed translation, codepage
+// translation, and other transformations).  On failure, this function returns 0
+// and sets errno.
+extern "C" int __cdecl _write_internal(int const fh, void const* const buffer, unsigned const size, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_CHECK_FH_CLEAR_OSSERR_RETURN(ptd, fh, EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (fh >= 0 && (unsigned)fh < (unsigned)_nhandle), EBADF, -1);
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, (_osfile(fh) & FOPEN), EBADF, -1);
+
+    __acrt_lowio_lock_fh(fh);
+    int result = -1;
+    __try
+    {
+        if ((_osfile(fh) & FOPEN) == 0)
+        {
+            ptd.get_errno().set(EBADF);
+            ptd.get_doserrno().set(0);
+            _ASSERTE(("Invalid file descriptor. File possibly closed by a different thread",0));
+            __leave;
+        }
+
+        result = _write_nolock(fh, buffer, size, ptd);
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh(fh);
+    }
+    return result;
+}
+
+extern "C" int __cdecl _write(int const fh, void const* const buffer, unsigned const size)
+{
+    __crt_cached_ptd_host ptd;
+    return _write_internal(fh, buffer, size, ptd);
+}
+
+static bool __cdecl write_requires_double_translation_nolock(int const fh, __crt_cached_ptd_host& ptd) throw()
+{
+    // Double translation is required if both [a] the current locale is not the C
+    // locale or the file is open in a non-ANSI mode and [b] we are writing to the
+    // console.
+
+    // If this isn't a TTY or a text mode screen, then it isn't the console:
+    if (!_isatty(fh))
+    {
+        return false;
+    }
+
+    if ((_osfile(fh) & FTEXT) == 0) {
+        return false;
+    }
+
+    // Get the current locale.  If we're in the C locale and the file is open
+    // in ANSI mode, we don't need double translation:
+    bool const is_c_locale = ptd.get_locale()->locinfo->locale_name[LC_CTYPE] == nullptr;
+    if (is_c_locale && _textmode(fh) == __crt_lowio_text_mode::ansi)
+    {
+        return false;
+    }
+
+    // If we can't get the console mode, it's not the console:
+    DWORD mode;
+    if (!GetConsoleMode(reinterpret_cast<HANDLE>(_osfhnd(fh)), &mode))
+    {
+        return false;
+    }
+
+    // Otherwise, double translation is required:
+    return true;
+}
+
+
+
+static write_result __cdecl write_double_translated_ansi_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size,
+    __crt_cached_ptd_host&                    ptd
+    ) throw()
+{
+    HANDLE      const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    char const* const buffer_end = buffer + buffer_size;
+    UINT        const console_cp = GetConsoleOutputCP();
+    _locale_t   const locale     = ptd.get_locale();
+    bool        const is_utf8    = locale->locinfo->_public._locale_lc_codepage == CP_UTF8;
+
+    write_result result = { 0 };
+
+    for (char const* source_it = buffer; source_it < buffer_end; )
+    {
+        char const c = *source_it;
+
+        // We require double conversion, to convert from the source multibyte
+        // to Unicode, then from Unicode back to multibyte, but in the console
+        // codepage.
+        //
+        // Here, we have to take into account that _write() might be called
+        // byte-by-byte, so when we see a lead byte without a trail byte, we
+        // have to store it and return no error.  When this function is called
+        // again, that byte will be combined with the next available character.
+        wchar_t wc[2] = { 0 };
+        int wc_used = 1;
+        if (is_utf8)
+        {
+            _ASSERTE(!_dbcsBufferUsed(fh));
+            const int mb_buf_size = sizeof(_mbBuffer(fh));
+            int mb_buf_used;
+            for (mb_buf_used = 0; mb_buf_used < mb_buf_size && _mbBuffer(fh)[mb_buf_used]; ++mb_buf_used)
+            {}
+
+            if (mb_buf_used > 0)
+            {
+                const int mb_len = _utf8_no_of_trailbytes(_mbBuffer(fh)[0]) + 1;
+                _ASSERTE(1 < mb_len && mb_buf_used < mb_len);
+                const int remaining_bytes = mb_len - mb_buf_used;
+                if (remaining_bytes <= (buffer_end - source_it))
+                {
+                    // We now have enough bytes to complete the code point
+                    char mb_buffer[MB_LEN_MAX];
+
+                    for (int i = 0; i < mb_buf_used; ++i)
+                    {
+                        mb_buffer[i] = _mbBuffer(fh)[i];
+                    }
+                    for (int i = 0; i < remaining_bytes; ++i)
+                    {
+                        mb_buffer[i + mb_buf_used] = source_it[i];
+                    }
+
+                    // Clear out the temp buffer
+                    for (int i = 0; i < mb_buf_used; ++i)
+                    {
+                        _mbBuffer(fh)[i] = 0;
+                    }
+
+                    mbstate_t state{};
+                    const char* str = mb_buffer;
+                    if (mb_len == 4)
+                    {
+                        wc_used = 2;
+                    }
+                    if (__crt_mbstring::__mbsrtowcs_utf8(wc, &str, wc_used, &state, ptd) == -1)
+                    {
+                        return result;
+                    }
+                    source_it += (remaining_bytes - 1);
+                }
+                else
+                {
+                    // Need to add some more bytes to the buffer for later
+                    const auto bytes_to_add = buffer_end - source_it;
+                    _ASSERTE(mb_buf_used + bytes_to_add < mb_buf_size);
+                    for (int i = 0; i < bytes_to_add; ++i)
+                    {
+                        _mbBuffer(fh)[i + mb_buf_used] = source_it[i];
+                    }
+                    // Pretend we wrote the bytes, because this isn't an error *yet*.
+                    result.char_count += static_cast<DWORD>(bytes_to_add);
+                    return result;
+                }
+            }
+            else
+            {
+                const int mb_len = _utf8_no_of_trailbytes(*source_it) + 1;
+                const auto available_bytes = buffer_end - source_it;
+                if (mb_len <= (available_bytes))
+                {
+                    // We have enough bytes to write the entire code point
+                    mbstate_t state{};
+                    const char* str = source_it;
+                    if (mb_len == 4)
+                    {
+                        wc_used = 2;
+                    }
+                    if (__crt_mbstring::__mbsrtowcs_utf8(wc, &str, wc_used, &state, ptd) == -1)
+                    {
+                        return result;
+                    }
+                    source_it += (mb_len - 1);
+                }
+                else
+                {
+                    // Not enough bytes for this code point
+                    _ASSERTE(available_bytes <= sizeof(_mbBuffer(fh)));
+                    for (int i = 0; i < available_bytes; ++i)
+                    {
+                        _mbBuffer(fh)[i] = source_it[i];
+                    }
+                    // Pretend we wrote the bytes, because this isn't an error *yet*.
+                    result.char_count += static_cast<DWORD>(available_bytes);
+                    return result;
+                }
+            }
+        }
+        else if (_dbcsBufferUsed(fh))
+        {
+            // We already have a DBCS lead byte buffered.  Take the current
+            // character, combine it with the lead byte, and convert:
+            _ASSERTE(_isleadbyte_fast_internal(_dbcsBuffer(fh), locale));
+
+            char mb_buffer[MB_LEN_MAX];
+            mb_buffer[0] = _dbcsBuffer(fh);
+            mb_buffer[1] = *source_it;
+
+            _dbcsBufferUsed(fh) = false;
+
+            if (_mbtowc_internal(wc, mb_buffer, 2, ptd) == -1)
+            {
+                return result;
+            }
+        }
+        else
+        {
+            if (_isleadbyte_fast_internal(*source_it, locale))
+            {
+                if ((source_it + 1) < buffer_end)
+                {
+                    // And we have more bytes to read, just convert...
+                    if (_mbtowc_internal(wc, source_it, 2, ptd) == -1)
+                    {
+                        return result;
+                    }
+
+                    // Increment the source_it to accomodate the DBCS character:
+                    ++source_it;
+                }
+                else
+                {
+                    // And we ran out of bytes to read, so buffer the lead byte:
+                    _dbcsBuffer(fh) = *source_it;
+                    _dbcsBufferUsed(fh) = true;
+
+                    // We lie here that we actually wrote the last character, to
+                    // ensure we don't consider this an error:
+                    ++result.char_count;
+                    return result;
+                }
+            }
+            else
+            {
+                // single character conversion:
+                if (_mbtowc_internal(wc, source_it, 1, ptd) == -1)
+                {
+                    return result;
+                }
+            }
+        }
+
+        ++source_it;
+
+        // Translate the Unicode character into Multibyte in the console codepage
+        // and write the character to the file:
+        char mb_buffer[MB_LEN_MAX];
+        DWORD const size = static_cast<DWORD>(__acrt_WideCharToMultiByte(
+            console_cp, 0, wc, wc_used, mb_buffer, sizeof(mb_buffer), nullptr, nullptr));
+
+        if(size == 0)
+            return result;
+
+        DWORD written;
+        if (!WriteFile(os_handle, mb_buffer, size, &written, nullptr))
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        // When we are converting, some conversions may result in:
+        //
+        //     2 MBCS characters => 1 wide character => 1 MBCS character.
+        //
+        // For example, when printing Japanese characters in the English console
+        // codepage, each source character is transformed into a single question
+        // mark.  Therefore, we want to track the number of bytes we converted,
+        // plus the linefeed count, instead of how many bytes we actually wrote.
+        result.char_count = result.lf_count + static_cast<DWORD>(source_it - buffer);
+
+        // If the write succeeded but didn't write all of the characters, return:
+        if (written < size)
+        {
+            return result;
+        }
+
+        // If the original character that we read was an LF, write a CR too:
+        // CRT_REFACTOR TODO Doesn't this write LFCR instead of CRLF?
+        if (c == LF)
+        {
+            wchar_t const cr = CR;
+            if (!WriteFile(os_handle, &cr, 1, &written, nullptr))
+            {
+                result.error_code = GetLastError();
+                return result;
+            }
+
+            if (written < 1)
+            {
+                return result;
+            }
+
+            ++result.lf_count;
+            ++result.char_count;
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_double_translated_unicode_nolock(
+    _In_reads_(buffer_size)                      char const* const buffer,
+    _In_ _Pre_satisfies_((buffer_size % 2) == 0) unsigned    const buffer_size
+    ) throw()
+{
+    // When writing to a Unicode file (UTF-8 or UTF-16LE) that corresponds to
+    // the console, we don't actually need double translation.  We just need to
+    // print each character to the console, one-by-one.  (This function is
+    // named what it is because its use is guarded by the double translation
+    // check, and to match the name of the corresponding ANSI function.)
+
+    write_result result = { 0 };
+
+    // Needed for SAL to clarify that buffer_size is even.
+    _Analysis_assume_((buffer_size/2) != ((buffer_size-1)/2));
+    char const* const buffer_end = buffer + buffer_size;
+    for (char const* pch = buffer; pch < buffer_end; pch += 2)
+    {
+        wchar_t const c = *reinterpret_cast<wchar_t const*>(pch);
+
+        // _putwch_nolock does not depend on global state, no PTD needed to be propagated.
+        if (_putwch_nolock(c) == c)
+        {
+            result.char_count += 2;
+        }
+        else
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        // If the character was a carriage return, also emit a line feed.
+        // CRT_REFACTOR TODO Doesn't this print LFCR instead of CRLF?
+        if (c == LF)
+        {
+            // _putwch_nolock does not depend on global state, no PTD needed to be propagated.
+            if (_putwch_nolock(CR) != CR)
+            {
+                result.error_code = GetLastError();
+                return result;
+            }
+
+            ++result.char_count;
+            ++result.lf_count;
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_text_ansi_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE      const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    char const* const buffer_end = buffer + buffer_size;
+
+    write_result result = { 0 };
+
+    for (char const* source_it = buffer; source_it < buffer_end; )
+    {
+        char lfbuf[BUF_SIZE]; // The LF => CRLF translation buffer
+
+        // One-past-the-end of the translation buffer.  Note that we subtract
+        // one to account for the case where we're pointing to the last element
+        // in the buffer and we need to write both a CR and an LF.
+        char* const lfbuf_end = lfbuf + sizeof(lfbuf) - 1;
+
+        // Translate the source buffer into the translation buffer.  Note that
+        // both source_it and lfbuf_it are incremented in the loop.
+        char* lfbuf_it = lfbuf;
+        while (lfbuf_it < lfbuf_end && source_it < buffer_end)
+        {
+            char const c = *source_it++;
+
+            if (c == LF)
+            {
+                ++result.lf_count;
+                *lfbuf_it++ = CR;
+            }
+
+            *lfbuf_it++ = c;
+        }
+
+        DWORD const lfbuf_length = static_cast<DWORD>(lfbuf_it - lfbuf);
+
+        DWORD written;
+        if (!WriteFile(os_handle, lfbuf, lfbuf_length, &written, nullptr))
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        result.char_count += written;
+        if (written < lfbuf_length)
+        {
+            return result; // The write succeeded but didn't write everything
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_text_utf16le_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE         const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    wchar_t const* const buffer_end = reinterpret_cast<wchar_t const*>(buffer + buffer_size);
+
+    write_result result = { 0 };
+
+    wchar_t const* source_it = reinterpret_cast<wchar_t const*>(buffer);
+    while (source_it < buffer_end)
+    {
+        wchar_t lfbuf[BUF_SIZE / sizeof(wchar_t)]; // The translation buffer
+
+        // One-past-the-end of the translation buffer.  Note that we subtract
+        // one to account for the case where we're pointing to the last element
+        // in the buffer and we need to write both a CR and an LF.
+        wchar_t const* lfbuf_end = lfbuf + BUF_SIZE / sizeof(wchar_t) - 1;
+
+        // Translate the source buffer into the translation buffer.  Note that
+        // both source_it and lfbuf_it are incremented in the loop.
+        wchar_t* lfbuf_it = lfbuf;
+        while (lfbuf_it < lfbuf_end && source_it < buffer_end)
+        {
+            wchar_t const c = *source_it++;
+
+            if (c == LF)
+            {
+                result.lf_count += 2;
+                *lfbuf_it++ = CR;
+            }
+
+            *lfbuf_it++ = c;
+        }
+
+        // Note that this length is in bytes, not wchar_t elemnts, since we need
+        // to tell WriteFile how many bytes (not characters) to write:
+        DWORD const lfbuf_length = static_cast<DWORD>(lfbuf_it - lfbuf) * sizeof(wchar_t);
+
+
+        // Attempt the write and return immediately if it fails:
+        DWORD written;
+        if (!WriteFile(os_handle, lfbuf, lfbuf_length, &written, nullptr))
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        result.char_count += written;
+        if (written < lfbuf_length)
+        {
+            return result; // The write succeeded, but didn't write everything
+        }
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_text_utf8_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE         const os_handle  = reinterpret_cast<HANDLE>(_osfhnd(fh));
+    wchar_t const* const buffer_end = reinterpret_cast<wchar_t const*>(buffer + buffer_size);
+
+    write_result result = { 0 };
+
+    wchar_t const* source_it = reinterpret_cast<wchar_t const*>(buffer);
+    while (source_it < buffer_end)
+    {
+        // The translation buffer.  We use two buffers:  the first is used to
+        // store the UTF-16 LF => CRLF translation (this is that buffer here).
+        // The second is used for storing the conversion to UTF-8 (defined
+        // below).  The sizes are selected to handle the worst-case scenario
+        // where each UTF-8 character is four bytes long.
+        wchar_t utf16_buf[BUF_SIZE / 6];
+
+        // One-past-the-end of the translation buffer.  Note that we subtract
+        // one to account for the case where we're pointing to the last element
+        // in the buffer and we need to write both a CR and an LF.
+        wchar_t const* utf16_buf_end = utf16_buf + (BUF_SIZE / 6 - 1);
+
+        // Translate the source buffer into the translation buffer.  Note that
+        // both source_it and lfbuf_it are incremented in the loop.
+        wchar_t* utf16_buf_it = utf16_buf;
+        while (utf16_buf_it < utf16_buf_end && source_it < buffer_end)
+        {
+            wchar_t const c = *source_it++;
+
+            if (c == LF)
+            {
+                // No need to count the number of line-feeds translated; we
+                // track the number of written characters by counting the total
+                // number of characters written from the UTF8 buffer (see below
+                // where we update the char_count).
+                *utf16_buf_it++ = CR;
+            }
+
+            *utf16_buf_it++ = c;
+        }
+
+        // Note that this length is in characters, not bytes.
+        DWORD const utf16_buf_length = static_cast<DWORD>(utf16_buf_it - utf16_buf);
+
+
+        // This is the second translation, where we translate the UTF-16 text to
+        // UTF-8, into the UTF-8 buffer:
+        char utf8_buf[(BUF_SIZE * 2) / 3];
+        DWORD const bytes_converted = static_cast<DWORD>(__acrt_WideCharToMultiByte(
+                CP_UTF8,
+                0,
+                utf16_buf,
+                utf16_buf_length,
+                utf8_buf,
+                sizeof(utf8_buf),
+                nullptr,
+                nullptr));
+
+        if (bytes_converted == 0)
+        {
+            result.error_code = GetLastError();
+            return result;
+        }
+
+        // Here, we need to make every attempt to write all of the converted
+        // characters to avoid corrupting the stream.  If, for example, we write
+        // only half of the bytes of a UTF-8 character, the stream may be
+        // corrupted.
+        //
+        // This loop will ensure that we exit only if either (a) all of the
+        // bytes are written, ensuring that no partial MBCSes are written, or
+        // (b) there is an error in the stream.
+        for (DWORD bytes_written = 0; bytes_written < bytes_converted; )
+        {
+            char const* const current      = utf8_buf + bytes_written;
+            DWORD       const current_size = bytes_converted - bytes_written;
+
+            DWORD written;
+            if (!WriteFile(os_handle, current, current_size, &written, nullptr))
+            {
+                result.error_code = GetLastError();
+                return result;
+            }
+
+            bytes_written += written;
+        }
+
+        // If this chunk was committed successfully, update the character count:
+        result.char_count = static_cast<DWORD>(reinterpret_cast<char const*>(source_it) - buffer);
+    }
+
+    return result;
+}
+
+
+
+static write_result __cdecl write_binary_nolock(
+    int                                 const fh,
+    _In_reads_(buffer_size) char const* const buffer,
+    unsigned                            const buffer_size
+    ) throw()
+{
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_osfhnd(fh));
+
+    // Compared to text files, binary files are easy...
+    write_result result = { 0 };
+    if (!WriteFile(os_handle, buffer, buffer_size, &result.char_count, nullptr))
+    {
+        result.error_code = GetLastError();
+    }
+
+    return result;
+}
+
+
+
+extern "C" int __cdecl _write_nolock(int const fh, void const* const buffer, unsigned const buffer_size, __crt_cached_ptd_host& ptd)
+{
+    // If the buffer is empty, there is nothing to be written:
+    if (buffer_size == 0)
+    {
+        return 0;
+    }
+
+    // If the buffer is null, though... well, that is not allowed:
+    _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, buffer != nullptr, EINVAL, -1);
+
+    __crt_lowio_text_mode const fh_textmode = _textmode(fh);
+
+    // If the file is open for Unicode, the buffer size must always be even:
+    if (fh_textmode == __crt_lowio_text_mode::utf16le || fh_textmode == __crt_lowio_text_mode::utf8)
+    {
+        _UCRT_VALIDATE_CLEAR_OSSERR_RETURN(ptd, buffer_size % 2 == 0, EINVAL, -1);
+    }
+
+    // If the file is opened for appending, seek to the end of the file.  We
+    // ignore errors because the underlying file may not allow seeking.
+    if (_osfile(fh) & FAPPEND)
+    {
+        (void)_lseeki64_nolock_internal(fh, 0, FILE_END, ptd);
+    }
+
+    char const* const char_buffer = static_cast<char const*>(buffer);
+
+    // Dispatch the actual writing to one of the helper routines based on the
+    // text mode of the file and whether or not the file refers to the console.
+    //
+    // Note that in the event that the handle belongs to the console, WriteFile
+    // will generate garbage output.  To print to the console correctly, we need
+    // to print ANSI.  Also note that when printing to the console, we need to
+    // convert the characters to the console codepge.
+    write_result result = { 0 };
+    if (write_requires_double_translation_nolock(fh, ptd))
+    {
+        switch (fh_textmode)
+        {
+        case __crt_lowio_text_mode::ansi:
+            result = write_double_translated_ansi_nolock(fh, char_buffer, buffer_size, ptd);
+            break;
+
+        case __crt_lowio_text_mode::utf16le:
+        case __crt_lowio_text_mode::utf8:
+            _Analysis_assume_((buffer_size % 2) == 0);
+            result = write_double_translated_unicode_nolock(char_buffer, buffer_size);
+            break;
+        }
+    }
+    else if (_osfile(fh) & FTEXT)
+    {
+        switch (fh_textmode)
+        {
+        case __crt_lowio_text_mode::ansi:
+            result = write_text_ansi_nolock(fh, char_buffer, buffer_size);
+            break;
+
+        case __crt_lowio_text_mode::utf16le:
+            result = write_text_utf16le_nolock(fh, char_buffer, buffer_size);
+            break;
+
+        case __crt_lowio_text_mode::utf8:
+            result = write_text_utf8_nolock(fh, char_buffer, buffer_size);
+            break;
+        }
+    }
+    else
+    {
+        result = write_binary_nolock(fh, char_buffer, buffer_size);
+    }
+
+
+    // Why did we not write anything?  Lettuce find out...
+    if (result.char_count == 0)
+    {
+        // If nothing was written, check to see if it was due to an OS error:
+        if (result.error_code != 0)
+        {
+            // An OS error occurred.  ERROR_ACCESS_DENIED should be mapped in
+            // this case to EBADF, not EACCES.  All other errors are mapped
+            // normally:
+            if (result.error_code == ERROR_ACCESS_DENIED)
+            {
+                ptd.get_errno().set(EBADF);
+                ptd.get_doserrno().set(result.error_code);
+            }
+            else
+            {
+                __acrt_errno_map_os_error_ptd(result.error_code, ptd);
+            }
+
+            return -1;
+        }
+
+        // If this file is a device and the first character was Ctrl+Z, then
+        // writing nothing is the expected behavior and is not an error:
+        if ((_osfile(fh) & FDEV) && *char_buffer == CTRLZ)
+        {
+            return 0;
+        }
+
+        // Otherwise, the error is reported as ENOSPC:
+        ptd.get_errno().set(ENOSPC);
+        ptd.get_doserrno().set(0);
+        return -1;
+    }
+
+    // The write succeeded.  Return the adjusted number of bytes written:
+    return result.char_count - result.lf_count;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbalnm.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbalnm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15c8ebc0a76a12a37729bfb55bc24cf3e4ad6dcc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbalnm.cpp	
@@ -0,0 +1,54 @@
+/***
+*ismbalnm - Test if character is alpha numeric (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is alpha numeric (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbcalnum - Test if character is alpha numeric (MBCS)
+*
+*Purpose:
+*       Test if the supplied character is alpha numeric or not.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if c is an alpha numeric character; else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcalnum_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _ismbbalnum_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _ALPHA | _DIGIT, true);
+}
+
+extern "C" int __cdecl _ismbcalnum(unsigned int const c)
+{
+    return _ismbcalnum_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbalph.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbalph.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3cc9389bd1d27902f2829e5bb93f89fffb35e88b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbalph.cpp	
@@ -0,0 +1,54 @@
+/***
+*ismbalph.c - Test if character is alphabetic (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is alphabetic (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbcalpha - Test if character is alphabetic (MBCS)
+*
+*Purpose:
+*       Test if character is alphabetic.
+*       Handles MBCS chars correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if c is alphabetic, else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcalpha_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _ismbbalpha_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _ALPHA, true);
+}
+
+extern "C" int __cdecl _ismbcalpha(unsigned int const c)
+{
+    return _ismbcalpha_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbbyte.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbbyte.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc92a3dc3abcbec33756be2e57313d3a68239113
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbbyte.cpp	
@@ -0,0 +1,233 @@
+/***
+*ismbbyte.c - Function versions of MBCS ctype macros
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       This files provides function versions of the character
+*       classification a*d conversion macros in mbctype.h.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/* defined in mbctype.h
+; Define masks
+
+; set bit masks for the possible kanji character types
+; (all MBCS bit masks start with "_M")
+
+_MS             equ     01h     ; MBCS non-ascii single byte char
+_MP             equ     02h     ; MBCS punct
+_M1             equ     04h     ; MBCS 1st (lead) byte
+_M2             equ     08h     ; MBCS 2nd byte
+
+*/
+
+/* defined in ctype.h
+; set bit masks for the possible character types
+
+_UPPER          equ     01h     ; upper case letter
+_LOWER          equ     02h     ; lower case letter
+_DIGIT          equ     04h     ; digit[0-9]
+_SPACE          equ     08h     ; tab, carriage return, newline,
+                                ; vertical tab or form feed
+_PUNCT          equ     10h     ; punctuation character
+_CONTROL        equ     20h     ; control character
+_BLANK          equ     40h     ; space char
+_HEX            equ     80h     ; hexadecimal digit
+
+*/
+
+/* defined in ctype.h, mbdata.h
+        extrn   __mbctype:byte          ; MBCS ctype table
+        extrn   __ctype_:byte           ; ANSI/ASCII ctype table
+*/
+
+
+/***
+* ismbbyte - Function versions of mbctype macros
+*
+*Purpose:
+*
+*Entry:
+*       int = character to be tested
+*Exit:
+*       ax = non-zero = character is of the requested type
+*          =        0 = character is NOT of the requested type
+*
+*Uses:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static int __cdecl x_ismbbtype_l(_locale_t plocinfo, unsigned int, int, int) throw();
+
+
+/* ismbbk functions */
+
+extern "C" int (__cdecl _ismbbkalnum_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,0,_MS);
+}
+
+extern "C" int (__cdecl _ismbbkalnum) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,0,_MS);
+}
+
+extern "C" int (__cdecl _ismbbkprint_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,0,(_MS | _MP));
+}
+
+extern "C" int (__cdecl _ismbbkprint) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,0,(_MS | _MP));
+}
+
+extern "C" int (__cdecl _ismbbkpunct_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,0,_MP);
+}
+
+extern "C" int (__cdecl _ismbbkpunct) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,0,_MP);
+}
+
+
+/* ismbb functions */
+
+extern "C" int (__cdecl _ismbbalnum_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,(_ALPHA | _DIGIT), _MS);
+}
+
+extern "C" int (__cdecl _ismbbalnum) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,(_ALPHA | _DIGIT), _MS);
+}
+
+extern "C" int (__cdecl _ismbbalpha_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,_ALPHA, _MS);
+}
+
+extern "C" int (__cdecl _ismbbalpha) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,_ALPHA, _MS);
+}
+
+extern "C" int (__cdecl _ismbbgraph_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,(_PUNCT | _ALPHA | _DIGIT),(_MS | _MP));
+}
+
+extern "C" int (__cdecl _ismbbgraph) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,(_PUNCT | _ALPHA | _DIGIT),(_MS | _MP));
+}
+
+extern "C" int (__cdecl _ismbbprint_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,(_BLANK | _PUNCT | _ALPHA | _DIGIT),(_MS | _MP));
+}
+
+extern "C" int (__cdecl _ismbbprint) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,(_BLANK | _PUNCT | _ALPHA | _DIGIT),(_MS | _MP));
+}
+
+extern "C" int (__cdecl _ismbbpunct_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return x_ismbbtype_l(plocinfo,tst,_PUNCT, _MP);
+}
+
+extern "C" int (__cdecl _ismbbpunct) (unsigned int tst)
+{
+    return x_ismbbtype_l(nullptr,tst,_PUNCT, _MP);
+}
+
+extern "C" int (__cdecl _ismbbblank_l) (unsigned int tst, _locale_t plocinfo)
+{
+    return (tst == '\t') ? _BLANK : x_ismbbtype_l(plocinfo,tst,_BLANK, _MP);
+}
+
+extern "C" int (__cdecl _ismbbblank) (unsigned int tst)
+{
+    return (tst == '\t') ? _BLANK : x_ismbbtype_l(nullptr,tst,_BLANK, _MP);
+}
+
+
+/* lead and trail */
+// These expect single or double byte codepages and are undefined for UTF-8
+// UTF-8 queries will always return false for lead/trail bytes.
+extern "C" int (__cdecl _ismbblead_l) (unsigned int tst, _locale_t plocinfo)
+{
+    // Note: Lookup is always FALSE for UTF-8
+    return x_ismbbtype_l(plocinfo,tst,0,_M1);
+}
+
+extern "C" int (__cdecl _ismbblead) (unsigned int tst)
+{
+    // Note: Lookup is always FALSE for UTF-8
+    return x_ismbbtype_l(nullptr, tst, 0, _M1);
+}
+
+extern "C" int (__cdecl _ismbbtrail_l) (unsigned int tst, _locale_t plocinfo)
+{
+    // Note: Lookup is always FALSE for UTF-8
+    return x_ismbbtype_l(plocinfo,tst,0,_M2);
+}
+
+extern "C" int (__cdecl _ismbbtrail) (unsigned int tst)
+{
+    // Note: Lookup is always FALSE for UTF-8
+    return x_ismbbtype_l(nullptr, tst, 0, _M2);
+}
+
+
+/* 932 specific */
+
+extern "C" int (__cdecl _ismbbkana_l) (unsigned int tst, _locale_t plocinfo)
+{
+    _LocaleUpdate _loc_update(plocinfo);
+    if(_loc_update.GetLocaleT()->mbcinfo &&
+       _loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP)
+    {
+        return x_ismbbtype_l(plocinfo,tst,0,(_MS | _MP));
+    }
+    return FALSE;
+}
+
+extern "C" int (__cdecl _ismbbkana) (unsigned int tst)
+{
+    return _ismbbkana_l(tst, nullptr);
+}
+
+/***
+* Common code
+*
+*      cmask = mask for _ctype[] table
+*      kmask = mask for _mbctype[] table
+*
+*******************************************************************************/
+
+static int __cdecl x_ismbbtype_l (_locale_t plocinfo, unsigned int tst, int cmask, int kmask) throw()
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /*
+     * get input character and make sure < 256
+     */
+    tst = (unsigned int)(unsigned char)tst;
+
+    return  ((*(_loc_update.GetLocaleT()->mbcinfo->mbctype+1+tst)) & kmask) ||
+            ((cmask) ? ((*(_loc_update.GetLocaleT()->locinfo->_public._locale_pctype + tst)) & cmask) : 0);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbdgt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbdgt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1a939bbbcae93d70390e68ad6c294973764f905f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbdgt.cpp	
@@ -0,0 +1,54 @@
+/***
+*ismbdgt.cpp - Test if character is a digit (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is a digit (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbcdigit - Test if character is a digit (MBCS)
+*
+*Purpose:
+*       Tests the character to see if it is a digit.
+*       Handles MBCS chars correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int *c = character to test
+*
+*Exit:
+*       Returns TRUE if character is a digit, else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcdigit_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _isdigit_fast_internal(static_cast<unsigned char>(c), locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _DIGIT, true);
+}
+
+extern "C" int __cdecl _ismbcdigit(unsigned int const c)
+{
+    return _ismbcdigit_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbgrph.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbgrph.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..920b198b3d8b630b8edc9e1ec97e45ba2971144e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbgrph.cpp	
@@ -0,0 +1,54 @@
+/***
+*ismbgrph - Test if character is graphical (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is graphical (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbcgraph - Test if character is graphical (MBCS)
+*
+*Purpose:
+*       Test if the supplied character is graphical or not.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if c is an graphical character; else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcgraph_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _ismbbgraph_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _PUNCT | _ALPHA | _DIGIT, true);
+}
+
+extern "C" int __cdecl _ismbcgraph(unsigned int const c)
+{
+    return _ismbcgraph_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbknj.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbknj.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ac025f4a703c340564347b32fdee26fe7b15813
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbknj.cpp	
@@ -0,0 +1,118 @@
+/***
+*ismbcknj.c - contains the Kanji specific is* functions.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Provide non-portable Kanji support for MBCS libs.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+*int _ismbchira(c) - test character for hiragana (Japanese)
+*
+*Purpose:
+*       Test if the character c is a hiragana character.
+*
+*Entry:
+*       unsigned int c - character to test
+*
+*Exit:
+*       returns TRUE if CP == KANJI and character is hiragana, else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbchira_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return(_loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP && c >= 0x829f && c <= 0x82f1);
+}
+
+extern "C" int __cdecl _ismbchira(
+        unsigned int c
+        )
+{
+    return _ismbchira_l(c, nullptr);
+}
+
+
+/***
+*int _ismbckata(c) - test character for katakana (Japanese)
+*
+*Purpose:
+*       Tests to see if the character c is a katakana character.
+*
+*Entry:
+*       unsigned int c - character to test
+*
+*Exit:
+*       Returns TRUE if CP == KANJI and c is a katakana character, else FALSE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbckata_l (
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return(_loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP && c >= 0x8340 && c <= 0x8396 && c != 0x837f);
+}
+extern "C" int __cdecl _ismbckata(
+        unsigned int c
+        )
+{
+    return _ismbckata_l(c, nullptr);
+}
+
+
+/***
+*int _ismbcsymbol(c) - Tests if char is punctuation or symbol of Microsoft Kanji
+*                  code.
+*
+*Purpose:
+*       Returns non-zero if the character is kanji punctuation.
+*
+*Entry:
+*       unsigned int c - character to be tested
+*
+*Exit:
+*       Returns non-zero if CP == KANJI and the specified char is punctuation or symbol of
+*               Microsoft Kanji code, else 0.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcsymbol_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return(_loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP && c >= 0x8141 && c <= 0x81ac && c != 0x817f);
+}
+
+extern "C" int (__cdecl _ismbcsymbol)(
+        unsigned int c
+        )
+{
+    return _ismbcsymbol_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismblgl.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismblgl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e803da828a8925bb7ae972d27cee8e503735fe1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismblgl.cpp	
@@ -0,0 +1,49 @@
+/***
+*ismblgl.c - Tests to see if a given character is a legal MBCS char.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Tests to see if a given character is a legal MBCS character.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+*int _ismbclegal(c) - tests for a valid MBCS character.
+*
+*Purpose:
+*       Tests to see if a given character is a legal MBCS character.
+*
+*Entry:
+*       unsigned int c - character to test
+*
+*Exit:
+*       returns non-zero if Microsoft Kanji code, else 0
+*
+*Exceptions:
+*
+******************************************************************************/
+
+extern "C" int __cdecl _ismbclegal_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        _LocaleUpdate _loc_update(plocinfo);
+
+        return( (_ismbblead_l(c >> 8, _loc_update.GetLocaleT())) &&
+                (_ismbbtrail_l(c & 0x0ff, _loc_update.GetLocaleT())) );
+}
+extern "C" int (__cdecl _ismbclegal)(
+        unsigned int c
+        )
+{
+    return _ismbclegal_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismblwr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismblwr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a422cbf17e8ccb8bed1c0f5072c73fe99d95238
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismblwr.cpp	
@@ -0,0 +1,54 @@
+/***
+*ismblwr - Test if character is lower case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is lower case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbclower - Test if character is lower case (MBCS)
+*
+*Purpose:
+*       Test if the supplied character is lower case or not.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       returns TRUE if character is lower case, else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbclower_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _mbbislower_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _LOWER, true);
+}
+
+extern "C" int __cdecl _ismbclower(unsigned int const c)
+{
+    return _ismbclower_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbprn.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbprn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c43ba3b05febe1185f79e19f6f22c9d16b58738
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbprn.cpp	
@@ -0,0 +1,53 @@
+/***
+*ismbprn.c - Test character for display character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test character for display character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbcprint - Test character for display character (MBCS)
+*
+*Purpose:
+*       Test if the character is a display character.
+*       Handles MBCS chars correctly.
+*
+*       Note:  Use test against 0x00FF to ensure that we don't
+*       call SBCS routine with a two-byte value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if character is display character, else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcprint_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _ismbbprint_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _CONTROL, false);
+}
+
+extern "C" int __cdecl _ismbcprint(unsigned int const c)
+{
+    return _ismbcprint_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbpunc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbpunc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba969873e729aee027a569f8e70bbdf18d74de9d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbpunc.cpp	
@@ -0,0 +1,92 @@
+/***
+*ismbpunc - Test if character is punctuation (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is punctuation (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _ismbcpunct - Test if character is punctuation (MBCS)
+*
+*Purpose:
+*       Test if the supplied character is punctuation or not.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if c is an punctuation character; else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcpunct_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _ismbbpunct_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _PUNCT, true);
+}
+
+extern "C" int __cdecl _ismbcpunct(unsigned int const c)
+{
+    return _ismbcpunct_l(c, nullptr);
+}
+
+/***
+* _ismbcblank - Test if character is blank (MBCS)
+*
+*Purpose:
+*       Test if the supplied character is blank or not.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if c is a blank character; else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcblank_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _ismbbblank_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _BLANK, true);
+}
+
+extern "C" int __cdecl _ismbcblank(unsigned int const c)
+{
+    return _ismbcblank_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbsle.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbsle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf399c5d388451c476b52f5cdf32cdebc8b17171
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbsle.cpp	
@@ -0,0 +1,76 @@
+/***
+*ismbslead.c - True _ismbslead function
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Contains the function _ismbslead, which is a true context-sensitive
+*       MBCS lead-byte function.  While much less efficient than _ismbblead,
+*       it is also much more sophisticated, in that it determines whether a
+*       given sub-string pointer points to a lead byte or not, taking into
+*       account the context in the string.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* int _ismbslead(const unsigned char *string, const unsigned char *current);
+*
+*Purpose:
+*
+*       _ismbslead - Check, in context, for MBCS lead byte
+*
+*Entry:
+*       unsigned char *string   - ptr to start of string or previous known lead byte
+*       unsigned char *current  - ptr to position in string to be tested
+*
+*Exit:
+*       TRUE    : -1
+*       FALSE   : 0
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbslead_l(
+        const unsigned char *string,
+        const unsigned char *current,
+        _locale_t plocinfo
+        )
+{
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, 0);
+        _VALIDATE_RETURN(current != nullptr, EINVAL, 0);
+
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return 0;
+
+        while (string <= current && *string) {
+            if ( _ismbblead_l((*string), _loc_update.GetLocaleT()) ) {
+                if (string++ == current)        /* check lead byte */
+                    return -1;
+                if (!(*string))
+                    return 0;
+            }
+            ++string;
+        }
+
+        return 0;
+}
+
+extern "C" int (__cdecl _ismbslead)(
+        const unsigned char *string,
+        const unsigned char *current
+        )
+{
+        return _ismbslead_l(string, current, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbspc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbspc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dcfa0ba3166dd250b39d2682b5fe0b0b58eb6099
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbspc.cpp	
@@ -0,0 +1,53 @@
+/***
+*ismbspc.c - Test is character is whitespace (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test is character is whitespace (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+* _ismbcspace - Test is character is whitespace (MBCS)
+*
+*Purpose:
+*       Test if the character is a whitespace character.
+*       Handles MBCS chars correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if character is whitespace, else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcspace_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _isspace_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _SPACE, true);
+}
+
+extern "C" int __cdecl _ismbcspace(unsigned int const c)
+{
+    return _ismbcspace_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbupr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbupr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c06bceecadcb2916aac78f08623a64651f2d5bac
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/ismbupr.cpp	
@@ -0,0 +1,52 @@
+/***
+*ismbupr - Test if character is upper case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Test if character is upper case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+/***
+* _ismbcupper - Test if character is upper case (MBCS)
+*
+*Purpose:
+*       Test if the supplied character is upper case or not.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to test
+*
+*Exit:
+*       Returns TRUE if c is an upper case character; else FALSE
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcupper_l(unsigned int const c, _locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+
+    if (c <= 0x00FF)
+    {
+        return _mbbisupper_l(c, locale_update.GetLocaleT());
+    }
+
+    return __dcrt_multibyte_check_type(c, locale_update.GetLocaleT(), _UPPER, true);
+}
+
+extern "C" int __cdecl _ismbcupper(unsigned int const c)
+{
+    return _ismbcupper_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbbtype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbbtype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c49e83b873d1a445b1580571fcb967a5e9614e0a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbbtype.cpp	
@@ -0,0 +1,81 @@
+/***
+*mbbtype.c - Return type of byte based on previous byte (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Return type of byte based on previous byte (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+*int _mbbtype(c, ctype) - Return type of byte based on previous byte (MBCS)
+*
+*Purpose:
+*       Returns type of supplied byte.  This decision is context
+*       sensitive so a control test condition is supplied.  Normally,
+*       this is the type of the previous byte in the string.
+*
+*Entry:
+*       unsigned char c = character to be checked
+*       int ctype = control test condition (i.e., type of previous char)
+*
+*Exit:
+*       _MBC_LEAD      = if 1st byte of MBCS char
+*       _MBC_TRAIL     = if 2nd byte of MBCS char
+*       _MBC_SINGLE    = valid single byte char
+*
+*       _MBC_ILLEGAL   = if illegal char
+*
+*WARNING:
+*       These fail for UTF-8, which doesn't have lead bytes matched with single
+*       trail bytes as this function expects.
+*
+*       Applications should not be trying to reverse engineer how any encoding works.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbbtype_l(
+    unsigned char const c,
+    int           const ctype,
+    _locale_t     const locale
+    )
+{
+    _LocaleUpdate locale_update(locale);
+
+    switch(ctype)
+    {
+    case _MBC_LEAD:
+        if (_ismbbtrail_l(c, locale_update.GetLocaleT()))
+            return _MBC_TRAIL;
+
+        else
+            return _MBC_ILLEGAL;
+
+    case _MBC_TRAIL:
+    case _MBC_SINGLE:
+    case _MBC_ILLEGAL:
+    default:
+        if (_ismbblead_l(c, locale_update.GetLocaleT()))
+            return _MBC_LEAD;
+
+        else if (_ismbbprint_l(c, locale_update.GetLocaleT()))
+            return _MBC_SINGLE;
+
+        else
+            return _MBC_ILLEGAL;
+    }
+}
+
+extern "C" int __cdecl _mbbtype(unsigned char const c, int const ctype)
+{
+    return _mbbtype_l(c, ctype, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..023652001205a8266406d71b5c79eb2d6d3e9be5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy.cpp	
@@ -0,0 +1,48 @@
+/***
+*mbccpy.c - Copy one character  to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Copy one MBCS character to another (1 or 2 bytes)
+*
+*******************************************************************************/
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+* _mbccpy - Copy one character to another (MBCS)
+*
+*Purpose:
+*       Copies exactly one MBCS character from src to dst.  Copies _mbclen(src)
+*       bytes from src to dst.
+*
+*Entry:
+*       unsigned char *dst = destination for copy
+*       unsigned char *src = source for copy
+*
+*Exit:
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" void __cdecl _mbccpy_l(
+        unsigned char *dst,
+        const unsigned char *src,
+        _locale_t plocinfo
+        )
+{
+    /* _mbccpy_s_l sets errno */
+    _mbccpy_s_l(dst, 2, nullptr, src, plocinfo);
+}
+
+extern "C" void (__cdecl _mbccpy)(
+        unsigned char *dst,
+        const unsigned char *src
+        )
+{
+    _mbccpy_s_l(dst, 2, nullptr, src, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d455ad40baa4abe66a4ab0c4a00352a8711d8b2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy_s.cpp	
@@ -0,0 +1,14 @@
+/***
+*mbccpy_s.c - Copy one character  to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Copy one MBCS character to another (1 or 2 bytes)
+*
+*******************************************************************************/
+
+#include <corecrt_internal_mbstring.h>
+
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbccpy_s, unsigned char *, size_t , int *, const unsigned char *)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9ba949a656bed9bc1f6294b117a6e76290c0d568
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbccpy_s_l.cpp	
@@ -0,0 +1,58 @@
+/***
+*mbccpy_s_l.c - Copy one character  to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Copy one MBCS character to another (1 or 2 bytes)
+*
+*******************************************************************************/
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+#include <locale.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+errno_t __cdecl _mbccpy_s_l(unsigned char *_Dst, size_t _SizeInBytes, int *_PCopied, const unsigned char *_Src, _LOCALE_ARG_DECL)
+{
+    /* validation section */
+    _ASSIGN_IF_NOT_NULL(_PCopied, 0);
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+    if (_Src == nullptr)
+    {
+        *_Dst = '\0';
+        _RETURN_EINVAL;
+    }
+
+    _LOCALE_UPDATE;
+
+    /* copy */
+    if (_ISMBBLEAD(*_Src))
+    {
+        if (_Src[1] == '\0')
+        {
+            /* the source string contained a lead byte followed by the null terminator:
+               we copy only the null terminator and return EILSEQ to indicate the
+               malformed char */
+            *_Dst = '\0';
+            _ASSIGN_IF_NOT_NULL(_PCopied, 1);
+            _RETURN_MBCS_ERROR;
+        }
+        if (_SizeInBytes < 2)
+        {
+            *_Dst = '\0';
+            _RETURN_BUFFER_TOO_SMALL(_Dst, _SizeInBytes);
+        }
+        *_Dst++ = *_Src++;
+        *_Dst = *_Src;
+        _ASSIGN_IF_NOT_NULL(_PCopied, 2);
+    }
+    else
+    {
+        *_Dst = *_Src;
+        _ASSIGN_IF_NOT_NULL(_PCopied, 1);
+    }
+
+    _RETURN_NO_ERROR;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbclen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbclen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1893fe31f8a8c16da93f93329121b5e6e1d00bfa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbclen.cpp	
@@ -0,0 +1,49 @@
+/***
+*mbclen.c - Find length of MBCS character
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Find length of MBCS character
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbclen - Find length of MBCS character
+*
+*Purpose:
+*       Find the length of the MBCS character (in bytes).
+*
+*Entry:
+*       unsigned char *c = MBCS character
+*
+*Exit:
+*       Returns the number of bytes in the MBCS character
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl _mbclen_l(unsigned char const* c, _locale_t locale)
+{
+    /*  Don't return two if we have leadbyte, EOS.
+        Don't assert here; too low level
+    */
+    return ((_ismbblead_l)(*c, locale) && c[1] != '\0') ? 2 : 1;
+}
+
+extern "C" size_t __cdecl _mbclen(unsigned char const* c)
+{
+    /*  Don't return two if we have leadbyte, EOS.
+        Don't assert here; too low level
+    */
+    return (_ismbblead(*c) && c[1]!='\0')  ? 2 : 1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbclevel.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbclevel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab75d1bc30a3e3f8fa75a0fc61cef26986d39170
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbclevel.cpp	
@@ -0,0 +1,127 @@
+/***
+*mbclevel.c - Tests if char is hiragana, katakana, alphabet or digit.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Tests for the various industry defined levels of Microsoft Kanji
+*       Code.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+*int _ismbcl0(c) - Tests if char is hiragana, katakana, alphabet or digit.
+*
+*Purpose:
+*       Tests if a given char is hiragana, katakana, alphabet, digit or symbol
+*       of Microsoft Kanji code.
+*
+*Entry:
+*       unsigned int c - Character to test.
+*
+*Exit:
+*       Returns non-zero if 0x8140 <= c <= 0x889E, else 0.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcl0_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return( (_loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP) &&
+            (_ismbblead_l(c >> 8, _loc_update.GetLocaleT())) &&
+            (_ismbbtrail_l(c & 0x0ff, _loc_update.GetLocaleT())) &&
+            (c < 0x889f) );
+}
+
+extern "C" int (__cdecl _ismbcl0)(
+        unsigned int c
+        )
+{
+    return _ismbcl0_l(c, nullptr);
+}
+
+
+/***
+*int _ismbcl1(c) - Tests for 1st-level Microsoft Kanji code set.
+*
+*Purpose:
+*       Tests if a given char belongs to Microsoft 1st-level Kanji code set.
+*
+*Entry:
+*       unsigned int c - character to test.
+*
+*Exit:
+*       Returns non-zero if 1st-level, else 0.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcl1_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return( (_loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP) &&
+            (_ismbblead_l(c >> 8, _loc_update.GetLocaleT())) &&
+            (_ismbbtrail_l(c & 0x0ff, _loc_update.GetLocaleT())) &&
+            (c >= 0x889f) && (c <= 0x9872) );
+}
+
+extern "C" int (__cdecl _ismbcl1)(
+    unsigned int c
+    )
+{
+    return _ismbcl1_l(c, nullptr);
+}
+
+
+/***
+*int _ismbcl2(c) - Tests for a 2nd-level Microsoft Kanji code character.
+*
+*Purpose:
+*       Tests if a given char belongs to the Microsoft 2nd-level Kanji code set.
+*
+*Entry:
+*       unsigned int c - character to test.
+*
+*Exit:
+*       Returns non-zero if 2nd-level, else 0.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _ismbcl2_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return( (_loc_update.GetLocaleT()->mbcinfo->mbcodepage == _KANJI_CP) &&
+            (_ismbblead_l(c >> 8, _loc_update.GetLocaleT())) &&
+            (_ismbbtrail_l(c & 0x0ff, _loc_update.GetLocaleT())) &&
+            (c >= 0x989f) && (c <= 0xEAA4) );
+}
+extern "C" int __cdecl _ismbcl2(
+        unsigned int c
+        )
+{
+    return _ismbcl2_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6e6e6c60c35de551ac41241b7ddddf357e1f5e3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbctype.cpp	
@@ -0,0 +1,1105 @@
+/***
+*mbctype.c - MBCS table used by the functions that test for types of char
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       table used to determine the type of char
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <locale.h>
+#include <corecrt_internal_mbstring.h>
+#include <mbctype.h>
+#include <winnls.h>
+
+#ifndef CRTDLL
+
+_CRT_LINKER_FORCE_INCLUDE(__acrt_multibyte_initializer);
+
+#endif  /* CRTDLL */
+
+#define _CHINESE_SIMP_CP    936
+#define _KOREAN_WANGSUNG_CP 949
+#define _CHINESE_TRAD_CP    950
+#define _KOREAN_JOHAB_CP    1361
+
+#define NUM_CHARS 257 /* -1 through 255 */
+
+#define NUM_CTYPES 4 /* table contains 4 types of info */
+#define MAX_RANGES 8 /* max number of ranges needed given languages so far */
+
+/* character type info in ranges (pair of low/high), zeros indicate end */
+typedef struct
+{
+    int             code_page;
+    unsigned short  mbulinfo[NUM_ULINFO];
+    unsigned char   rgrange[NUM_CTYPES][MAX_RANGES];
+} code_page_info;
+
+extern "C"
+{
+__crt_multibyte_data __acrt_initial_multibyte_data =
+{
+    0,                       /* refcount */
+    CP_ACP,                  /* mbcodepage: _MB_CP_ANSI */
+    0,                       /* ismbcodepage */
+    { 0, 0, 0, 0, 0, 0 },    /* mbulinfo[6] */
+    {                        /* mbctype[257] */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00 /* rest is zero */
+    },
+    {     /* mbcasemap[256] */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+    0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
+    0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
+    0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+    0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00 /* rest is zero */
+    },
+    nullptr /* mblocalename */
+};
+
+#define _MBCTYPE_DEFAULT                                                        \
+    {                                                                           \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, \
+        0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, \
+        0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, \
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, \
+        0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00 /* rest is zero */       \
+    }
+
+/* MBCS ctype array */
+static unsigned char _mbctypes[__crt_state_management::state_index_count][NUM_CHARS] =
+{
+    _MBCTYPE_DEFAULT
+    #ifdef _CRT_GLOBAL_STATE_ISOLATION
+    ,_MBCTYPE_DEFAULT
+    #endif
+};
+
+#define _MBCASEMAP_DEFAULT                                                      \
+    {                                                                           \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, \
+        0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, \
+        0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, \
+        0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, \
+        0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00 /* rest is zero */       \
+    }
+
+static unsigned char _mbcasemaps[__crt_state_management::state_index_count][256] =
+{
+    _MBCASEMAP_DEFAULT
+    #ifdef _CRT_GLOBAL_STATE_ISOLATION
+    ,_MBCASEMAP_DEFAULT
+    #endif
+};
+
+/* global pointer to the multi-byte case type (i.e. upper or lower or n/a) */
+__crt_state_management::dual_state_global<unsigned char*> _mbctype;
+
+/* global pointer to the multi-byte casemap */
+__crt_state_management::dual_state_global<unsigned char*> _mbcasemap;
+
+/* global pointer to the current per-thread mbc information structure. */
+__crt_state_management::dual_state_global<__crt_multibyte_data*> __acrt_current_multibyte_data;
+}
+
+static int fSystemSet;
+
+static char __rgctypeflag[NUM_CTYPES] = { _MS, _MP, _M1, _M2 };
+
+static code_page_info __rgcode_page_info[] =
+{
+    {
+      _KANJI_CP, /* Kanji (Japanese) Code Page */
+      { 0x8260, 0x8279,   /* Full-Width Latin Upper Range 1 */
+        0x8281 - 0x8260,  /* Full-Width Latin Case Difference 1 */
+
+        0x0000, 0x0000,   /* Full-Width Latin Upper Range 2 */
+        0x0000            /* Full-Width Latin Case Difference 2 */
+      },
+      {
+        { 0xA6, 0xDF, 0,    0,    0,    0,    0, 0, }, /* Single Byte Ranges */
+        { 0xA1, 0xA5, 0,    0,    0,    0,    0, 0, }, /* Punctuation Ranges */
+        { 0x81, 0x9F, 0xE0, 0xFC, 0,    0,    0, 0, }, /* Lead Byte Ranges */
+        { 0x40, 0x7E, 0x80, 0xFC, 0,    0,    0, 0, }, /* Trail Byte Ranges */
+      }
+    },
+    {
+      _CHINESE_SIMP_CP, /* Chinese Simplified (PRC) Code Page */
+      { 0xA3C1, 0xA3DA,   /* Full-Width Latin Upper Range 1 */
+        0xA3E1 - 0xA3C1,  /* Full-Width Latin Case Difference 1 */
+
+        0x0000, 0x0000,   /* Full-Width Latin Upper Range 2 */
+        0x0000            /* Full-Width Latin Case Difference 2 */
+      },
+      {
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Single Byte Ranges */
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Punctuation Ranges */
+        { 0x81, 0xFE, 0,    0,    0,    0,    0, 0, }, /* Lead Byte Ranges */
+        { 0x40, 0xFE, 0,    0,    0,    0,    0, 0, }, /* Trail Byte Ranges */
+      }
+    },
+    {
+      _KOREAN_WANGSUNG_CP, /* Wangsung (Korean) Code Page */
+      { 0xA3C1, 0xA3DA,   /* Full-Width Latin Upper Range 1 */
+        0xA3E1 - 0xA3C1,  /* Full-Width Latin Case Difference 1 */
+
+        0x0000, 0x0000,   /* Full-Width Latin Upper Range 2 */
+        0x0000            /* Full-Width Latin Case Difference 2 */
+      },
+      {
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Single Byte Ranges */
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Punctuation Ranges */
+        { 0x81, 0xFE, 0,    0,    0,    0,    0, 0, }, /* Lead Byte Ranges */
+        { 0x41, 0xFE, 0,    0,    0,    0,    0, 0, }, /* Trail Byte Ranges */
+      }
+    },
+    {
+      _CHINESE_TRAD_CP, /* Chinese Traditional (Taiwan) Code Page */
+      { 0xA2CF, 0xA2E4,   /* Full-Width Latin Upper Range 1 */
+        0xA2E9 - 0xA2CF,  /* Full-Width Latin Case Difference 1 */
+
+        0xA2E5, 0xA2E8,   /* Full-Width Latin Upper Range 2 */
+        0xA340 - 0XA2E5   /* Full-Width Latin Case Difference 2 */
+      },
+      {
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Single Byte Ranges */
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Punctuation Ranges */
+        { 0x81, 0xFE, 0,    0,    0,    0,    0, 0, }, /* Lead Byte Ranges */
+        { 0x40, 0x7E, 0xA1, 0xFE, 0,    0,    0, 0, }, /* Trail Byte Ranges */
+      }
+    },
+    {
+      _KOREAN_JOHAB_CP, /* Johab (Korean) Code Page */
+      { 0xDA51, 0xDA5E,   /* Full-Width Latin Upper Range 1 */
+        0xDA71 - 0xDA51,  /* Full-Width Latin Case Difference 1 */
+
+        0xDA5F, 0xDA6A,   /* Full-Width Latin Upper Range 2 */
+        0xDA91 - 0xDA5F   /* Full-Width Latin Case Difference 2 */
+      },
+      {
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Single Byte Ranges */
+        { 0,    0,    0,    0,    0,    0,    0, 0, }, /* Punctuation Ranges */
+        { 0x81, 0xD3, 0xD8, 0xDE, 0xE0, 0xF9, 0, 0, }, /* Lead Byte Ranges */
+        { 0x31, 0x7E, 0x81, 0xFE, 0,    0,    0, 0, }, /* Trail Byte Ranges */
+      }
+    }
+};
+
+#define JAPANSE_DEFAULT_LOCALE_NAME_INDEX         0
+#define CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX      1
+#define KOREAN_DEFAULT_LOCALE_NAME_INDEX          2
+#define CHINESE_TRADITIONAL_LOCALE_NAME_INDEX     3
+
+const wchar_t* const _mb_locale_names[] =
+{
+    L"ja-JP",   /* JAPANSE_DEFAULT_LOCALE_NAME_INDEX     */
+    L"zh-CN",   /* CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX  */
+    L"ko-KR",   /* KOREAN_DEFAULT_LOCALE_NAME_INDEX      */
+    L"zh-TW",   /* CHINESE_TRADITIONAL_LOCALE_NAME_INDEX */
+};
+
+
+
+extern "C" unsigned char* __cdecl __p__mbctype()
+{
+    return _mbctype.value();
+}
+
+extern "C" unsigned char* __cdecl __p__mbcasemap()
+{
+    return _mbcasemap.value();
+}
+
+
+
+extern "C" int __cdecl _setmbcp_nolock(int, __crt_multibyte_data*);
+
+static int getSystemCP (int);
+
+/***
+*setSBCS() - Set MB code page to SBCS.
+*
+*Purpose:
+*           Set MB code page to SBCS.
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static void setSBCS (__crt_multibyte_data* ptmbci)
+{
+    int i;
+
+    /* set for single-byte code page */
+    for (i = 0; i < NUM_CHARS; i++)
+        ptmbci->mbctype[i] = 0;
+
+    /* code page has changed, set global flag */
+    ptmbci->mbcodepage = 0;
+
+    /* clear flag to indicate single-byte code */
+    ptmbci->ismbcodepage = 0;
+
+    ptmbci->mblocalename = nullptr;
+
+    for (i = 0; i < NUM_ULINFO; i++)
+        ptmbci->mbulinfo[i] = 0;
+
+    for ( i = 0 ; i < 257 ; i++ )
+        ptmbci->mbctype[i] = __acrt_initial_multibyte_data.mbctype[i];
+
+    for ( i = 0 ; i < 256 ; i++ )
+        ptmbci->mbcasemap[i] = __acrt_initial_multibyte_data.mbcasemap[i];
+}
+
+/***
+*__acrt_update_thread_multibyte_data() - refresh the thread's mbc info
+*
+*Purpose:
+*       Update the current thread's reference to the multibyte character
+*       information to match the current global mbc info. Decrement the
+*       reference on the old mbc information struct and if this count is now
+*       zero (so that no threads are using it), free it.
+*
+*Entry:
+*
+*Exit:
+*       _getptd()->ptmbcinfo == current_multibyte_data (which should always be __acrt_current_multibyte_data)
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static __crt_multibyte_data* __cdecl update_thread_multibyte_data_internal(
+    __acrt_ptd*           const ptd,
+    __crt_multibyte_data** const current_multibyte_data
+    ) throw()
+{
+        __crt_multibyte_data* ptmbci = nullptr;
+
+        if (__acrt_should_sync_with_global_locale(ptd) || ptd->_locale_info == nullptr)
+        {
+            __acrt_lock(__acrt_multibyte_cp_lock);
+            __try
+            {
+                ptmbci = ptd->_multibyte_info;
+                if (ptmbci != *current_multibyte_data)
+                {
+                    /*
+                     * Decrement the reference count in the old mbc info structure
+                     * and free it, if necessary
+                     */
+                    if (ptmbci != nullptr &&
+                        InterlockedDecrement(&ptmbci->refcount) == 0 &&
+                        ptmbci != &__acrt_initial_multibyte_data)
+                    {
+                        /*
+                         * Free it
+                         */
+                        _free_crt(ptmbci);
+                    }
+
+                    /*
+                     * Point to the current mbc info structure and increment its
+                     * reference count.
+                     */
+                    ptmbci = ptd->_multibyte_info = *current_multibyte_data;
+                    InterlockedIncrement(&ptmbci->refcount);
+                }
+            }
+            __finally
+            {
+                __acrt_unlock(__acrt_multibyte_cp_lock);
+            }
+        }
+        else
+        {
+            ptmbci = ptd->_multibyte_info;
+        }
+
+        if (!ptmbci)
+        {
+            abort();
+        }
+
+        return ptmbci;
+}
+
+extern "C" __crt_multibyte_data* __cdecl __acrt_update_thread_multibyte_data()
+{
+    return update_thread_multibyte_data_internal(__acrt_getptd(), &__acrt_current_multibyte_data.value());
+}
+
+/***
+*_setmbcp() - Set MBC data based on code page
+*
+*Purpose:
+*       Init MBC character type tables based on code page number. If
+*       given code page is supported, load that code page info into
+*       mbctype table. If not, query OS to find the information,
+*       otherwise set up table with single byte info.
+*
+*       Multithread Notes: First, allocate an mbc information struct. Set the
+*       mbc info in the static vars and arrays as does the single-thread
+*       version. Then, copy this info into the new allocated struct and set
+*       the current mbc info pointer (__acrt_current_multibyte_data) to point to it.
+*
+*Entry:
+*       codepage - code page to initialize MBC table
+*           _MB_CP_OEM = use system OEM code page
+*           _MB_CP_ANSI = use system ANSI code page
+*           _MB_CP_SBCS = set to single byte 'code page'
+*
+*Exit:
+*        0 = Success
+*       -1 = Error, code page not changed.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static int __cdecl setmbcp_internal(
+    int                    const requested_codepage,
+    bool                   const is_for_crt_initialization,
+    __acrt_ptd*            const ptd,
+    __crt_multibyte_data** const current_multibyte_data
+    ) throw()
+{
+    update_thread_multibyte_data_internal(ptd, current_multibyte_data);
+    int const system_codepage = getSystemCP(requested_codepage);
+
+    // If it's not a new codepage, just return success:
+    if (system_codepage == ptd->_multibyte_info->mbcodepage)
+    {
+        return 0;
+    }
+
+    // Always allocate space so that we don't have to take a lock for any update:
+    __crt_unique_heap_ptr<__crt_multibyte_data> mb_data(_malloc_crt_t(__crt_multibyte_data, 1));
+    if (!mb_data)
+    {
+        return -1;
+    }
+
+    // Initialize the new multibyte data structure from the current multibyte
+    // data structure for this thread, resetting the reference count (since it
+    // is not actually referenced by anything yet).
+    *mb_data.get() = *ptd->_multibyte_info;
+    mb_data.get()->refcount = 0;
+
+    // Actually initialize the new multibyte data using the new codepage:
+    // CRT_REFACTOR TODO _setmbcp_nolock is a terrible name.
+    int const setmbcp_status = _setmbcp_nolock(system_codepage, mb_data.get());
+    if (setmbcp_status == -1)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    // At this point, we have a valid, new set of multibyte data to swap in.  If
+    // this is not the initial codepage initialization during process startup,
+    // we need to toggle the locale-changed state:
+    if (!is_for_crt_initialization)
+    {
+        __acrt_set_locale_changed();
+    }
+
+    if (InterlockedDecrement(&ptd->_multibyte_info->refcount) == 0 &&
+        ptd->_multibyte_info != &__acrt_initial_multibyte_data)
+    {
+        _free_crt(ptd->_multibyte_info);
+    }
+
+    // Update the multibyte codepage for this thread:
+    mb_data.get()->refcount = 1;
+    ptd->_multibyte_info = mb_data.detach();
+
+    // If this thread has its own locale, do not update the global codepage:
+    if (!__acrt_should_sync_with_global_locale(ptd))
+    {
+        return setmbcp_status;
+    }
+
+    // Otherwise, update the global codepage:
+    __acrt_lock_and_call(__acrt_multibyte_cp_lock, [&]
+    {
+        memcpy_s(_mbctype.value(),   sizeof(_mbctypes[0]),   ptd->_multibyte_info->mbctype,   sizeof(ptd->_multibyte_info->mbctype));
+        memcpy_s(_mbcasemap.value(), sizeof(_mbcasemaps[0]), ptd->_multibyte_info->mbcasemap, sizeof(ptd->_multibyte_info->mbcasemap));
+
+        if (InterlockedDecrement(&(*current_multibyte_data)->refcount) == 0 &&
+            (*current_multibyte_data) != &__acrt_initial_multibyte_data)
+        {
+            _free_crt(*current_multibyte_data);
+        }
+
+        *current_multibyte_data = ptd->_multibyte_info;
+        InterlockedIncrement(&ptd->_multibyte_info->refcount);
+    });
+
+    if (is_for_crt_initialization)
+    {
+        __acrt_initial_locale_pointers.mbcinfo = *current_multibyte_data;
+    }
+
+    return setmbcp_status;
+}
+
+/* Enclaves only support built-in CP_ACP */
+#ifdef _UCRT_ENCLAVE_BUILD
+
+static int getSystemCP(int)
+{
+    return CP_ACP;
+}
+
+
+extern "C" int __cdecl _setmbcp_nolock(int, __crt_multibyte_data* ptmbci)
+{
+    setSBCS(ptmbci);
+    return 0;
+}
+
+#else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */
+
+    /***
+*CPtoLocaleName() - Code page to locale name.
+*
+*Purpose:
+*       Some API calls want a locale name, so convert MB CP to appropriate locale name,
+*       and then API converts back to ANSI CP for that locale name.
+*
+*Entry:
+*   codepage - code page to convert
+*Exit:
+*       returns appropriate locale name
+*       Returned locale names are stored in static structs, so they must not be deleted.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static const wchar_t* CPtoLocaleName (int codepage)
+{
+    switch (codepage) {
+    case 932:
+        return _mb_locale_names[JAPANSE_DEFAULT_LOCALE_NAME_INDEX];
+    case 936:
+        return _mb_locale_names[CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX];
+    case 949:
+        return _mb_locale_names[KOREAN_DEFAULT_LOCALE_NAME_INDEX];
+    case 950:
+        return _mb_locale_names[CHINESE_TRADITIONAL_LOCALE_NAME_INDEX];
+    }
+
+    return 0;
+}
+
+/***
+*getSystemCP - Get system default CP if requested.
+*
+*Purpose:
+*       Get system default CP if requested.
+*
+*Entry:
+*       codepage - user requested code page/world script
+*
+*       Docs specify:
+*          _MB_CP_SBCS    0 - Use a single byte codepage
+*          _MB_CP_OEM    -2 - use the OEMCP
+*          _MB_CP_ANSI   -3 - use the ACP
+*          _MB_CP_LOCALE -4 - use the codepage for a previous setlocale call
+*          Codepage #       - use the specified codepage (UTF-7 is disallowed)
+*                           - 54936 and other interesting stateful codepages aren't
+*                           - explicitly disallowed but I can't imagine them working right.
+*
+*Exit:
+*       requested code page
+*
+*Exceptions:
+*
+*******************************************************************************/
+static int getSystemCP(int codepage)
+{
+    _locale_t plocinfo = nullptr;
+    _LocaleUpdate _loc_update(plocinfo);
+    fSystemSet = 0;
+
+    /* get system code page values if requested */
+
+    if (codepage == _MB_CP_OEM)
+    {
+        fSystemSet = 1;
+        return GetOEMCP();
+    }
+    else if (codepage == _MB_CP_ANSI)
+    {
+        fSystemSet = 1;
+        return GetACP();
+    }
+    else if (codepage == _MB_CP_LOCALE)
+    {
+        fSystemSet = 1;
+        return _loc_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
+    }
+
+    return codepage;
+}
+
+/***
+*setSBUpLow() - Set single byte range upper/lower mappings
+*
+*Purpose:
+*           Set single byte mapping for tolower/toupper.
+*           Basically this is ASCII-mapping plus a few if you're a lucky
+*           SBCS codepage.
+*           DBCS + UTF ranges > 0x7f are basically ignored.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static void setSBUpLow (__crt_multibyte_data* ptmbci)
+{
+    BYTE *  pbPair;
+    UINT    ich;
+    CPINFO  cpInfo;
+    UCHAR   sbVector[256];
+    UCHAR   upVector[256];
+    UCHAR   lowVector[256];
+    USHORT  wVector[512];
+
+    //    test if codepage exists
+    if (ptmbci->mbcodepage != CP_UTF8 && GetCPInfo(ptmbci->mbcodepage, &cpInfo) != 0)
+    {
+        // This code attempts to generate casing tables for characters 0-255
+        // For DBCS codepages that will be basically ASCII casing but won't help DBCS mapping.
+        // For SBCS codepages that will include the codepage-specific characters.
+        // Mappings do not appear to include Turkish-i variations.
+
+        //  if so, create vector 0-255
+        for (ich = 0; ich < 256; ich++)
+            sbVector[ich] = (UCHAR) ich;
+
+        //  set byte 0 and any leading byte value to non-alpha char ' '
+        sbVector[0] = (UCHAR)' ';
+        for (pbPair = &cpInfo.LeadByte[0]; *pbPair; pbPair += 2)
+            // make sure ich within a valid range
+            for (ich = *pbPair; ich <= *(pbPair + 1) && ich < 256; ich++)
+                sbVector[ich] = (UCHAR)' ';
+
+        //  get char type for character vector
+
+        __acrt_GetStringTypeA(nullptr, CT_CTYPE1, (LPCSTR)sbVector, 256, wVector,
+                            ptmbci->mbcodepage, FALSE);
+
+        //  get lower case mappings for character vector
+
+        __acrt_LCMapStringA(nullptr, ptmbci->mblocalename, LCMAP_LOWERCASE, (LPCSTR)sbVector, 256,
+                                    (LPSTR)lowVector, 256, ptmbci->mbcodepage, FALSE);
+
+        //  get upper case mappings for character vector
+
+        __acrt_LCMapStringA(nullptr, ptmbci->mblocalename, LCMAP_UPPERCASE, (LPCSTR)sbVector, 256,
+                                    (LPSTR)upVector, 256, ptmbci->mbcodepage, FALSE);
+
+        //  set _SBUP, _SBLOW in ptmbci->mbctype if type is upper. lower
+        //  set mapping array with lower or upper mapping value
+
+        for (ich = 0; ich < 256; ich++)
+        {
+            if (wVector[ich] & _UPPER)
+            {
+                // WARNING: +1 because the mbctype array starts with a -1 EOF character
+                ptmbci->mbctype[ich + 1] |= _SBUP;
+                ptmbci->mbcasemap[ich] = lowVector[ich];
+            }
+            else if (wVector[ich] & _LOWER)
+            {
+                // WARNING: +1 because the mbctype array starts with a -1 EOF character
+                ptmbci->mbctype[ich + 1] |= _SBLOW;
+                ptmbci->mbcasemap[ich] = upVector[ich];
+            }
+            else
+                ptmbci->mbcasemap[ich] = 0;
+        }
+    }
+    else
+    {
+        //  Either no codepage or UTF-8 (which looks a lot like ASCII in the lower bits)
+        //  Set 'A'-'Z' as upper, 'a'-'z' as lower (eg: ASCII casing)
+        for (ich = 0; ich < 256; ich++)
+        {
+            if (ich >= (UINT)'A' && ich <= (UINT)'Z')
+            {
+                // WARNING: +1 because the mbctype array starts with a -1 EOF character
+                ptmbci->mbctype[ich + 1] |= _SBUP;
+                ptmbci->mbcasemap[ich] = static_cast<unsigned char>(ich + ('a' - 'A'));
+            }
+            else if (ich >= (UINT)'a' && ich <= (UINT)'z')
+            {
+                // WARNING: +1 because the mbctype array starts with a -1 EOF character
+                ptmbci->mbctype[ich + 1] |= _SBLOW;
+                ptmbci->mbcasemap[ich] = static_cast<unsigned char>(ich - ('a' - 'A'));
+            }
+            else
+                ptmbci->mbcasemap[ich] = 0;
+        }
+    }
+}
+
+extern "C" int __cdecl _setmbcp(int const codepage)
+{
+    return setmbcp_internal(codepage, false, __acrt_getptd(), &__acrt_current_multibyte_data.value());
+}
+
+extern "C" int __cdecl _setmbcp_nolock(int codepage, __crt_multibyte_data* ptmbci)
+{
+        unsigned int icp;
+        unsigned int irg;
+        unsigned int ich;
+        unsigned char *rgptr;
+        CPINFO cpInfo;
+
+        codepage = getSystemCP(codepage);
+
+        /* user wants 'single-byte' MB code page */
+        if (codepage == _MB_CP_SBCS)
+        {
+            setSBCS(ptmbci);
+            return 0;
+        }
+
+        /* check for CRT code page info */
+        for (icp = 0;
+            icp < (sizeof(__rgcode_page_info) / sizeof(code_page_info));
+            icp++)
+        {
+            /* see if we have info for this code page */
+            if (__rgcode_page_info[icp].code_page == codepage)
+            {
+                /* clear the table */
+                for (ich = 0; ich < NUM_CHARS; ich++)
+                    ptmbci->mbctype[ich] = 0;
+
+                /* for each type of info, load table */
+                for (irg = 0; irg < NUM_CTYPES; irg++)
+                {
+                    /* go through all the ranges for each type of info */
+                    for (rgptr = (unsigned char *)__rgcode_page_info[icp].rgrange[irg];
+                        rgptr[0] && rgptr[1];
+                        rgptr += 2)
+                    {
+                        /* set the type for every character in range */
+                        for (ich = rgptr[0]; ich <= rgptr[1] && ich < 256; ich++)
+                            ptmbci->mbctype[ich + 1] |= __rgctypeflag[irg];
+                    }
+                }
+                /* code page has changed */
+                ptmbci->mbcodepage = codepage;
+                /* all the code pages we keep info for are truly multibyte */
+                ptmbci->ismbcodepage = 1;
+                ptmbci->mblocalename = CPtoLocaleName(ptmbci->mbcodepage);
+                for (irg = 0; irg < NUM_ULINFO; irg++)
+                {
+                    ptmbci->mbulinfo[irg] = __rgcode_page_info[icp].mbulinfo[irg];
+                }
+
+                /* return success */
+                setSBUpLow(ptmbci);
+                return 0;
+            }
+        }
+
+        /*  verify codepage validity */
+        // Unclear why UTF7 is excluded yet stateful and other complex encodings are not
+        if (codepage == 0 || codepage == CP_UTF7 || !IsValidCodePage((WORD)codepage))
+        {
+            /* return failure, code page not changed */
+            return -1;
+        }
+
+        // Special case for UTF-8
+        if (codepage == CP_UTF8)
+        {
+            ptmbci->mbcodepage = CP_UTF8;
+            ptmbci->mblocalename = nullptr;
+
+            // UTF-8 does not have lead or trail bytes in the terms
+            // the CRT thinks of it for DBCS codepages, so we'll
+            // clear the flags for all bytes.
+            // Note that this array is 257 bytes because there's a
+            // "-1" that is used someplaces for EOF.  So this array
+            // is actually -1 based.
+            for (ich = 0; ich < NUM_ULINFO; ich++)
+            {
+                ptmbci->mbctype[ich] = 0;
+            }
+
+            // not really a multibyte code page, we'll have to test
+            // ptmbci->mbcodepage == CP_UTF8 when we use this structure.
+            ptmbci->ismbcodepage = 0;
+
+            // CJK encodings have some full-width mappings, but not here.
+            for (irg = 0; irg < NUM_ULINFO; irg++)
+            {
+                ptmbci->mbulinfo[irg] = 0;
+            }
+
+            setSBUpLow(ptmbci);
+
+            // return success
+            return 0;
+        }
+        /* code page not supported by CRT, try the OS */\
+        else if (GetCPInfo(codepage, &cpInfo) != 0)
+        {
+            BYTE *lbptr;
+
+            /* clear the table */
+            for (ich = 0; ich < NUM_CHARS; ich++)
+            {
+                ptmbci->mbctype[ich] = 0;
+            }
+
+            ptmbci->mbcodepage = codepage;
+            ptmbci->mblocalename = nullptr;
+
+            // Special case for DBCS where we know there may be a leadbyte/trailbyte pattern
+            if (cpInfo.MaxCharSize == 2)
+            {
+                /* LeadByte range always terminated by two 0's */
+                for (lbptr = cpInfo.LeadByte; *lbptr && *(lbptr + 1); lbptr += 2)
+                {
+                    for (ich = *lbptr; ich <= *(lbptr + 1); ich++)
+                        ptmbci->mbctype[ich + 1] |= _M1;
+                }
+
+                /* All chars > 1 must be considered valid trail bytes */
+                for (ich = 0x01; ich < 0xFF; ich++)
+                {
+                    ptmbci->mbctype[ich + 1] |= _M2;
+                }
+
+                /* code page has changed */
+                ptmbci->mblocalename = CPtoLocaleName(ptmbci->mbcodepage);
+
+                /* really a multibyte code page */
+                ptmbci->ismbcodepage = 1;
+            }
+            else
+            {
+                /* single-byte code page */
+                ptmbci->ismbcodepage = 0;
+            }
+
+            for (irg = 0; irg < NUM_ULINFO; irg++)
+            {
+                ptmbci->mbulinfo[irg] = 0;
+            }
+
+            setSBUpLow(ptmbci);
+            /* return success */
+            return 0;
+        }
+
+
+        /* If system default call, don't fail - set to SBCS */
+        if (fSystemSet)
+        {
+            setSBCS(ptmbci);
+            return 0;
+        }
+
+        /* return failure, code page not changed */
+        return -1;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/***
+*_getmbcp() - Get the current MBC code page
+*
+*Purpose:
+*           Get code page value.
+*Entry:
+*       none.
+*Exit:
+*           return current MB codepage value.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _getmbcp()
+{
+    _locale_t plocinfo = nullptr;
+    _LocaleUpdate _loc_update(plocinfo);
+    if ( _loc_update.GetLocaleT()->mbcinfo->ismbcodepage )
+        return _loc_update.GetLocaleT()->mbcinfo->mbcodepage;
+    else
+        return 0;
+}
+
+
+/***
+*_initmbctable() - Set MB ctype table to initial default value.
+*
+*Purpose:
+*       Initialization.
+*Entry:
+*       none.
+*Exit:
+*       Returns 0 to indicate no error.
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" bool __cdecl __acrt_initialize_multibyte()
+{
+    static bool initialized = false;
+
+    // Synchronization note:  it is not possible for a data race to occur here.
+    // In the CRT DLLs, this function is called during CRT startup, befor any
+    // user code using the CRT may run.  In the static CRT, this function is
+    // called by a CRT initializer (at the top of this file), so 'initialized'
+    // will be true before any user code can enter the CRT.
+    //
+    // CRT_REFACTOR TODO We should split this function into two parts:  one that
+    // does the initialization (without any check), and one that does nothing,
+    // but can be used to cause this object to be linked in.
+    if (!initialized)
+    {
+        // initialize global pointer to the current per-thread mbc information structure
+        __acrt_current_multibyte_data.initialize(&__acrt_initial_multibyte_data);
+
+        // initialize mbc pointers
+        _mbcasemap.initialize_from_array(_mbcasemaps);
+        _mbctype  .initialize_from_array(_mbctypes);
+
+        // initialize the multibyte globals
+        __acrt_ptd* const ptd_head = __acrt_getptd_head();
+        for (size_t i = 0; i != __crt_state_management::state_index_count; ++i)
+        {
+            setmbcp_internal(_MB_CP_ANSI, true, ptd_head + i, &__acrt_current_multibyte_data.dangerous_get_state_array()[i]);
+        }
+
+        initialized = 1;
+    }
+
+    return true;
+}
+
+
+/************************ Code Page info from NT/Win95 ********************
+
+
+*** Code Page 932 ***
+
+0x824f  ;Fullwidth Digit Zero
+0x8250  ;Fullwidth Digit One
+0x8251  ;Fullwidth Digit Two
+0x8252  ;Fullwidth Digit Three
+0x8253  ;Fullwidth Digit Four
+0x8254  ;Fullwidth Digit Five
+0x8255  ;Fullwidth Digit Six
+0x8256  ;Fullwidth Digit Seven
+0x8257  ;Fullwidth Digit Eight
+0x8258  ;Fullwidth Digit Nine
+
+0x8281  0x8260  ;Fullwidth Small A -> Fullwidth Capital A
+0x8282  0x8261  ;Fullwidth Small B -> Fullwidth Capital B
+0x8283  0x8262  ;Fullwidth Small C -> Fullwidth Capital C
+0x8284  0x8263  ;Fullwidth Small D -> Fullwidth Capital D
+0x8285  0x8264  ;Fullwidth Small E -> Fullwidth Capital E
+0x8286  0x8265  ;Fullwidth Small F -> Fullwidth Capital F
+0x8287  0x8266  ;Fullwidth Small G -> Fullwidth Capital G
+0x8288  0x8267  ;Fullwidth Small H -> Fullwidth Capital H
+0x8289  0x8268  ;Fullwidth Small I -> Fullwidth Capital I
+0x828a  0x8269  ;Fullwidth Small J -> Fullwidth Capital J
+0x828b  0x826a  ;Fullwidth Small K -> Fullwidth Capital K
+0x828c  0x826b  ;Fullwidth Small L -> Fullwidth Capital L
+0x828d  0x826c  ;Fullwidth Small M -> Fullwidth Capital M
+0x828e  0x826d  ;Fullwidth Small N -> Fullwidth Capital N
+0x828f  0x826e  ;Fullwidth Small O -> Fullwidth Capital O
+0x8290  0x826f  ;Fullwidth Small P -> Fullwidth Capital P
+0x8291  0x8270  ;Fullwidth Small Q -> Fullwidth Capital Q
+0x8292  0x8271  ;Fullwidth Small R -> Fullwidth Capital R
+0x8293  0x8272  ;Fullwidth Small S -> Fullwidth Capital S
+0x8294  0x8273  ;Fullwidth Small T -> Fullwidth Capital T
+0x8295  0x8274  ;Fullwidth Small U -> Fullwidth Capital U
+0x8296  0x8275  ;Fullwidth Small V -> Fullwidth Capital V
+0x8297  0x8276  ;Fullwidth Small W -> Fullwidth Capital W
+0x8298  0x8277  ;Fullwidth Small X -> Fullwidth Capital X
+0x8299  0x8278  ;Fullwidth Small Y -> Fullwidth Capital Y
+0x829a  0x8279  ;Fullwidth Small Z -> Fullwidth Capital Z
+
+
+*** Code Page 936 ***
+
+0xa3b0  ;Fullwidth Digit Zero
+0xa3b1  ;Fullwidth Digit One
+0xa3b2  ;Fullwidth Digit Two
+0xa3b3  ;Fullwidth Digit Three
+0xa3b4  ;Fullwidth Digit Four
+0xa3b5  ;Fullwidth Digit Five
+0xa3b6  ;Fullwidth Digit Six
+0xa3b7  ;Fullwidth Digit Seven
+0xa3b8  ;Fullwidth Digit Eight
+0xa3b9  ;Fullwidth Digit Nine
+
+0xa3e1  0xa3c1  ;Fullwidth Small A -> Fullwidth Capital A
+0xa3e2  0xa3c2  ;Fullwidth Small B -> Fullwidth Capital B
+0xa3e3  0xa3c3  ;Fullwidth Small C -> Fullwidth Capital C
+0xa3e4  0xa3c4  ;Fullwidth Small D -> Fullwidth Capital D
+0xa3e5  0xa3c5  ;Fullwidth Small E -> Fullwidth Capital E
+0xa3e6  0xa3c6  ;Fullwidth Small F -> Fullwidth Capital F
+0xa3e7  0xa3c7  ;Fullwidth Small G -> Fullwidth Capital G
+0xa3e8  0xa3c8  ;Fullwidth Small H -> Fullwidth Capital H
+0xa3e9  0xa3c9  ;Fullwidth Small I -> Fullwidth Capital I
+0xa3ea  0xa3ca  ;Fullwidth Small J -> Fullwidth Capital J
+0xa3eb  0xa3cb  ;Fullwidth Small K -> Fullwidth Capital K
+0xa3ec  0xa3cc  ;Fullwidth Small L -> Fullwidth Capital L
+0xa3ed  0xa3cd  ;Fullwidth Small M -> Fullwidth Capital M
+0xa3ee  0xa3ce  ;Fullwidth Small N -> Fullwidth Capital N
+0xa3ef  0xa3cf  ;Fullwidth Small O -> Fullwidth Capital O
+0xa3f0  0xa3d0  ;Fullwidth Small P -> Fullwidth Capital P
+0xa3f1  0xa3d1  ;Fullwidth Small Q -> Fullwidth Capital Q
+0xa3f2  0xa3d2  ;Fullwidth Small R -> Fullwidth Capital R
+0xa3f3  0xa3d3  ;Fullwidth Small S -> Fullwidth Capital S
+0xa3f4  0xa3d4  ;Fullwidth Small T -> Fullwidth Capital T
+0xa3f5  0xa3d5  ;Fullwidth Small U -> Fullwidth Capital U
+0xa3f6  0xa3d6  ;Fullwidth Small V -> Fullwidth Capital V
+0xa3f7  0xa3d7  ;Fullwidth Small W -> Fullwidth Capital W
+0xa3f8  0xa3d8  ;Fullwidth Small X -> Fullwidth Capital X
+0xa3f9  0xa3d9  ;Fullwidth Small Y -> Fullwidth Capital Y
+0xa3fa  0xa3da  ;Fullwidth Small Z -> Fullwidth Capital Z
+
+
+*** Code Page 949 ***
+
+0xa3b0  ;Fullwidth Digit Zero
+0xa3b1  ;Fullwidth Digit One
+0xa3b2  ;Fullwidth Digit Two
+0xa3b3  ;Fullwidth Digit Three
+0xa3b4  ;Fullwidth Digit Four
+0xa3b5  ;Fullwidth Digit Five
+0xa3b6  ;Fullwidth Digit Six
+0xa3b7  ;Fullwidth Digit Seven
+0xa3b8  ;Fullwidth Digit Eight
+0xa3b9  ;Fullwidth Digit Nine
+
+0xa3e1  0xa3c1  ;Fullwidth Small A -> Fullwidth Capital A
+0xa3e2  0xa3c2  ;Fullwidth Small B -> Fullwidth Capital B
+0xa3e3  0xa3c3  ;Fullwidth Small C -> Fullwidth Capital C
+0xa3e4  0xa3c4  ;Fullwidth Small D -> Fullwidth Capital D
+0xa3e5  0xa3c5  ;Fullwidth Small E -> Fullwidth Capital E
+0xa3e6  0xa3c6  ;Fullwidth Small F -> Fullwidth Capital F
+0xa3e7  0xa3c7  ;Fullwidth Small G -> Fullwidth Capital G
+0xa3e8  0xa3c8  ;Fullwidth Small H -> Fullwidth Capital H
+0xa3e9  0xa3c9  ;Fullwidth Small I -> Fullwidth Capital I
+0xa3ea  0xa3ca  ;Fullwidth Small J -> Fullwidth Capital J
+0xa3eb  0xa3cb  ;Fullwidth Small K -> Fullwidth Capital K
+0xa3ec  0xa3cc  ;Fullwidth Small L -> Fullwidth Capital L
+0xa3ed  0xa3cd  ;Fullwidth Small M -> Fullwidth Capital M
+0xa3ee  0xa3ce  ;Fullwidth Small N -> Fullwidth Capital N
+0xa3ef  0xa3cf  ;Fullwidth Small O -> Fullwidth Capital O
+0xa3f0  0xa3d0  ;Fullwidth Small P -> Fullwidth Capital P
+0xa3f1  0xa3d1  ;Fullwidth Small Q -> Fullwidth Capital Q
+0xa3f2  0xa3d2  ;Fullwidth Small R -> Fullwidth Capital R
+0xa3f3  0xa3d3  ;Fullwidth Small S -> Fullwidth Capital S
+0xa3f4  0xa3d4  ;Fullwidth Small T -> Fullwidth Capital T
+0xa3f5  0xa3d5  ;Fullwidth Small U -> Fullwidth Capital U
+0xa3f6  0xa3d6  ;Fullwidth Small V -> Fullwidth Capital V
+0xa3f7  0xa3d7  ;Fullwidth Small W -> Fullwidth Capital W
+0xa3f8  0xa3d8  ;Fullwidth Small X -> Fullwidth Capital X
+0xa3f9  0xa3d9  ;Fullwidth Small Y -> Fullwidth Capital Y
+0xa3fa  0xa3da  ;Fullwidth Small Z -> Fullwidth Capital Z
+
+
+*** Code Page 950 ***
+
+0xa2af  ;Fullwidth Digit Zero
+0xa2b0  ;Fullwidth Digit One
+0xa2b1  ;Fullwidth Digit Two
+0xa2b2  ;Fullwidth Digit Three
+0xa2b3  ;Fullwidth Digit Four
+0xa2b4  ;Fullwidth Digit Five
+0xa2b5  ;Fullwidth Digit Six
+0xa2b6  ;Fullwidth Digit Seven
+0xa2b7  ;Fullwidth Digit Eight
+0xa2b8  ;Fullwidth Digit Nine
+
+0xa2e9  0xa2cf  ;Fullwidth Small A -> Fullwidth Capital A
+0xa2ea  0xa2d0  ;Fullwidth Small B -> Fullwidth Capital B
+0xa2eb  0xa2d1  ;Fullwidth Small C -> Fullwidth Capital C
+0xa2ec  0xa2d2  ;Fullwidth Small D -> Fullwidth Capital D
+0xa2ed  0xa2d3  ;Fullwidth Small E -> Fullwidth Capital E
+0xa2ee  0xa2d4  ;Fullwidth Small F -> Fullwidth Capital F
+0xa2ef  0xa2d5  ;Fullwidth Small G -> Fullwidth Capital G
+0xa2f0  0xa2d6  ;Fullwidth Small H -> Fullwidth Capital H
+0xa2f1  0xa2d7  ;Fullwidth Small I -> Fullwidth Capital I
+0xa2f2  0xa2d8  ;Fullwidth Small J -> Fullwidth Capital J
+0xa2f3  0xa2d9  ;Fullwidth Small K -> Fullwidth Capital K
+0xa2f4  0xa2da  ;Fullwidth Small L -> Fullwidth Capital L
+0xa2f5  0xa2db  ;Fullwidth Small M -> Fullwidth Capital M
+0xa2f6  0xa2dc  ;Fullwidth Small N -> Fullwidth Capital N
+0xa2f7  0xa2dd  ;Fullwidth Small O -> Fullwidth Capital O
+0xa2f8  0xa2de  ;Fullwidth Small P -> Fullwidth Capital P
+0xa2f9  0xa2df  ;Fullwidth Small Q -> Fullwidth Capital Q
+0xa2fa  0xa2e0  ;Fullwidth Small R -> Fullwidth Capital R
+0xa2fb  0xa2e1  ;Fullwidth Small S -> Fullwidth Capital S
+0xa2fc  0xa2e2  ;Fullwidth Small T -> Fullwidth Capital T
+0xa2fd  0xa2e3  ;Fullwidth Small U -> Fullwidth Capital U
+0xa2fe  0xa2e4  ;Fullwidth Small V -> Fullwidth Capital V
+
+...Note break in sequence...
+
+0xa340  0xa2e5  ;Fullwidth Small W -> Fullwidth Capital W
+0xa341  0xa2e6  ;Fullwidth Small X -> Fullwidth Capital X
+0xa342  0xa2e7  ;Fullwidth Small Y -> Fullwidth Capital Y
+0xa343  0xa2e8  ;Fullwidth Small Z -> Fullwidth Capital Z
+
+
+*** Code Page 1361 ***
+
+Not yet available (05/17/94)
+
+
+
+****************************************************************************/
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsbtype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsbtype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d42afa023b6e006324ad9f57d7ad77dda64f43b8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsbtype.cpp	
@@ -0,0 +1,82 @@
+/***
+*mbsbtype.c - Return type of byte within a string (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Return type of byte within a string (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbsbtype - Return type of byte within a string
+*
+*Purpose:
+*       Test byte within a string for MBCS char type.
+*       This function requires the start of the string because
+*       context must be taken into account.
+*
+*Entry:
+*       const unsigned char *string = pointer to string
+*       size_t len = position of the char in string
+*
+*Exit:
+*       returns one of the following values:
+*
+*       _MBC_LEAD      = if 1st byte of MBCS char
+*       _MBC_TRAIL     = if 2nd byte of MBCS char
+*       _MBC_SINGLE    = valid single byte char
+*
+*       _MBC_ILLEGAL   = if illegal char
+*
+*WARNING:
+*       This function was intended for SBCS/DBCS code pages.  UTF-8 will always return _MBC_SINGLE
+*       It is recommended that apps do not try to reverse engineer how encodings work.
+*
+*Exceptions:
+*       Returns _MBC_ILLEGAL if char is invalid.
+*       Calls invalid parameter if len is bigger than string length (and errno is set to EINVAL).
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsbtype_l(unsigned char const* string, size_t length, _locale_t const locale)
+{
+    _VALIDATE_RETURN(string != nullptr, EINVAL, _MBC_ILLEGAL);
+
+    _LocaleUpdate locale_update(locale);
+
+    if (locale_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+        return _MBC_SINGLE;
+
+    int chartype = _MBC_ILLEGAL;
+
+    do
+    {
+        /* If the char at the position asked for is a '\0' we return
+        _MBC_ILLEGAL. But, If any char before the position asked for is
+        a '\0', then we call invalid_param */
+
+        if (length == 0 && *string == '\0')
+            return _MBC_ILLEGAL;
+
+        _VALIDATE_RETURN(*string != '\0', EINVAL, _MBC_ILLEGAL);
+
+        chartype = _mbbtype_l(*string++, chartype, locale_update.GetLocaleT());
+    }  while (length--);
+
+    return chartype;
+}
+
+int __cdecl _mbsbtype(unsigned char const* const string, size_t const length)
+{
+    return _mbsbtype_l(string, length, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f54051093408f1cebd227a71ca240b21d262aafb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscat_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbscat_s.c - Concatenate one string to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Concatenate one string to another (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_3(errno_t, _mbscat_s, unsigned char *, size_t, const unsigned char *)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscat_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscat_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ed7bcc1ea7d42b84b1f9e6bfedc927304954918
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscat_s_l.cpp	
@@ -0,0 +1,122 @@
+/***
+*mbscat_s_l.c - Concatenate one string to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Concatenate one string to another (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+
+
+errno_t __cdecl _mbscat_s_l(unsigned char *_Dst, size_t _SizeInBytes, const unsigned char *_Src, _LOCALE_ARG_DECL)
+{
+    unsigned char *p;
+    size_t available;
+    BOOL fFoundInvalidMBC, fIsLeadPrefix;
+
+    /* validation section */
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+    _VALIDATE_POINTER_RESET_STRING(_Src, _Dst, _SizeInBytes);
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return strcat_s((char *)_Dst, _SizeInBytes, (const char *)_Src);
+    }
+
+    fFoundInvalidMBC = FALSE;
+    p = _Dst;
+    available = _SizeInBytes;
+    while (available > 0 && *p != 0)
+    {
+        p++;
+        available--;
+    }
+
+    /*
+     * Ran out of room while looking for end of dst string.
+     * p points 1 past end of buffer. We can't look past
+     * end of buffer so can't tell if dst ended with an
+     * invalid mbc.
+     */
+
+    if (available == 0)
+    {
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_DEST_NOT_NULL_TERMINATED(_Dst, _SizeInBytes);
+    }
+
+    /*
+     * Otherwise we have space available, p points at null that lies
+     * within _SizeInBytes, so available > 0. Check if dst ended with
+     * an invalid MBC (lead+null), if so then clear that lead byte,
+     * move the pointer back one and increase available by one.
+     */
+
+    _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, p-1);
+    if (fIsLeadPrefix)
+    {
+        fFoundInvalidMBC = TRUE;
+        p--;
+        *p = 0;
+        available++;
+    }
+
+    /* Append dst to src. */
+
+    while ((*p++ = *_Src++) != 0 && --available > 0)
+    {
+    }
+
+    /*
+     * We've run out of room in the destination before finding null in the src.
+     * It could be that the src was terminated with an invalid mbc (lead+null).
+     * In that case its ok to clear the copied lead byte and return mbcs_error.
+     */
+
+    if (available == 0)
+    {
+        if (*_Src == 0)
+        {
+            _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, p-1);
+            if (fIsLeadPrefix)
+            {
+                /* the source string ended with a lead byte: we remove it */
+                p[-1] = 0;
+                _RETURN_MBCS_ERROR;
+            }
+        }
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_BUFFER_TOO_SMALL(_Dst, _SizeInBytes);
+    }
+
+    /*
+     * If the src string ended with an invalid mbc (lead+null) then clear the
+     * lead byte.
+     */
+
+    _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, p-2);
+    if (fIsLeadPrefix)
+    {
+        p[-2] = 0;
+        available++;
+        fFoundInvalidMBC = TRUE;
+    }
+
+    _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+
+    if (fFoundInvalidMBC)
+    {
+        _RETURN_MBCS_ERROR;
+    }
+
+    _RETURN_NO_ERROR;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbschr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbschr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d90e1d29318b3fba7d17b7e3fe232e98ba7f9be
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbschr.cpp	
@@ -0,0 +1,84 @@
+/***
+* mbschr.c - Search MBCS string for character
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Search MBCS string for a character
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbschr - Search MBCS string for character
+*
+*Purpose:
+*       Search the given string for the specified character.
+*       MBCS characters are handled correctly.
+*
+*Entry:
+*       unsigned char *string = string to search
+*       int c = character to search for
+*
+*Exit:
+*       returns a pointer to the first occurence of the specified char
+*       within the string.
+*
+*       returns nullptr if the character is not found n the string.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+
+extern "C" _CONST_RETURN unsigned char * __cdecl _mbschr_l(
+        const unsigned char *string,
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        unsigned short cc = '\0';
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (_CONST_RETURN unsigned char *)strchr((const char *)string, (int)c);
+
+        for (; (cc = *string) != '\0'; string++)
+        {
+            if ( _ismbblead_l(cc, _loc_update.GetLocaleT()) )
+            {
+                if (*++string == '\0')
+                    return nullptr;        /* error */
+                if ( c == (unsigned int)((cc << 8) | *string) ) /* DBCS match */
+                    return (unsigned char *)(string - 1);
+            }
+            else if (c == (unsigned int)cc)
+                break;  /* SBCS match */
+        }
+
+        if (c == (unsigned int)cc)      /* check for SBCS match--handles NUL char */
+            return (unsigned char *)(string);
+
+        return nullptr;
+}
+
+extern "C" _CONST_RETURN unsigned char * (__cdecl _mbschr)(
+        const unsigned char *string,
+        unsigned int c
+        )
+{
+    return _mbschr_l(string, c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..089445763551d524c023bcdbb37cb7c1a7ae3b7b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscmp.cpp	
@@ -0,0 +1,87 @@
+/***
+*mbscmp.c - Compare MBCS strings
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Compare MBCS strings
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbscmp - Compare MBCS strings
+*
+*Purpose:
+*       Compares two strings in ordinal order. 
+*       Single byte strings are compared byte-by-byte
+*       Double byte strings are compared by character
+*           (basically ensuring that double byte sequences are higher than single byte)
+*       UTF-8 is compared byte-by-byte, which work since its the same as character order.
+*
+*Entry:
+*       char *s1, *s2 = strings to compare
+*
+*WARNING:
+*       No validation for improper UTF-8 strings, mixed up lead/trail byte orders are not defined.
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbscmp_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        _locale_t plocinfo
+        )
+{
+        unsigned short c1, c2;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return strcmp((const char *)s1, (const char *)s2);
+
+        for (;;) {
+
+            c1 = *s1++;
+            if ( _ismbblead_l(c1, _loc_update.GetLocaleT()) )
+                c1 = ( (*s1 == '\0') ? 0 : ((c1<<8) | *s1++) );
+
+            c2 = *s2++;
+            if ( _ismbblead_l(c2, _loc_update.GetLocaleT()) )
+                c2 = ( (*s2 == '\0') ? 0 : ((c2<<8) | *s2++) );
+
+            if (c1 != c2)
+                return (c1 > c2) ? 1 : -1;
+
+            if (c1 == 0)
+                return 0;
+
+        }
+}
+
+extern "C" int (__cdecl _mbscmp)(
+        const unsigned char *s1,
+        const unsigned char *s2
+        )
+{
+    return _mbscmp_l(s1, s2, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..937f3c8d7e330f267bb6fbf01c9b0d3999cecba4
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscoll.cpp	
@@ -0,0 +1,81 @@
+/***
+*mbscoll.c - Collate MBCS strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Collate MBCS strings
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+* _mbscoll - Collate MBCS strings
+*
+*Purpose:
+*       Collates two strings for lexical order.   Strings
+*       are collated on a character basis, not a byte basis.
+*
+*Entry:
+*       char *s1, *s2 = strings to collate
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbscoll_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        _locale_t plocinfo
+        )
+{
+        int ret;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strcoll_l((const char *)s1, (const char *)s2, plocinfo);
+
+        if (0 == (ret = __acrt_CompareStringA(
+                        _loc_update.GetLocaleT(),
+                        _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                        SORT_STRINGSORT,
+                        (LPCSTR)s1,
+                        -1,
+                        (LPSTR)s2,
+                        -1,
+                        _loc_update.GetLocaleT()->mbcinfo->mbcodepage )))
+        {
+            errno = EINVAL;
+
+            return _NLSCMPERROR;
+        }
+
+        return ret - 2;
+
+}
+
+extern "C" int (__cdecl _mbscoll)(
+        const unsigned char *s1,
+        const unsigned char *s2
+        )
+{
+    return _mbscoll_l(s1, s2, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..64e56c7e180b5350e28f9130a40426039f4c21e8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscpy_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbscpy_s.c - Copy one string to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_3(errno_t, _mbscpy_s, unsigned char *, size_t, const unsigned char *)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscpy_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscpy_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e4ff70acb41bc4bd50e366f7c01088030148c64e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscpy_s_l.cpp	
@@ -0,0 +1,76 @@
+/***
+*mbscpy_s_l.c - Copy one string to another (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+errno_t __cdecl _mbscpy_s_l(unsigned char *_Dst, size_t _SizeInBytes, const unsigned char *_Src, _LOCALE_ARG_DECL)
+{
+    unsigned char *p;
+    size_t available;
+    BOOL fIsLeadPrefix;
+
+    /* validation section */
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+    _VALIDATE_POINTER_RESET_STRING(_Src, _Dst, _SizeInBytes);
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return strcpy_s((char *)_Dst, _SizeInBytes, (const char *)_Src);
+    }
+    
+    p = _Dst;
+    available = _SizeInBytes;
+    while ((*p++ = *_Src++) != 0 && --available > 0)
+    {
+    }
+
+    /*
+     * If we ran out of destination bytes then we did so before copying null.
+     * Only exception to that is if last mbc was invalid (leadbyte+null), which
+     * is treated as null. In that case clear the copied lead byte and return ok.
+     */
+
+    if (available == 0)
+    {
+        if (*_Src == 0) {
+            _ISMBBLEADPREFIX(fIsLeadPrefix,_Dst,p-1);
+            if (fIsLeadPrefix)
+            {
+                p[-1] = 0;
+                _RETURN_MBCS_ERROR;
+            }
+        }
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_BUFFER_TOO_SMALL(_Dst, _SizeInBytes);
+    }
+
+    /*
+     * Otherwise we have space left in the dst buffer and stopped copying because
+     * we saw a null in the src. If null is part of invalid MBC (lead byte + null)
+     * then clear the lead byte also.
+     */
+
+    _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, p-2);
+    if (fIsLeadPrefix && (p - 2) >= _Dst)
+    {
+        p[-2] = 0;
+        available++;
+        _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+        _RETURN_MBCS_ERROR;
+    }
+
+    _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+    _RETURN_NO_ERROR;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscspn.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscspn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d6eeebfd8fd63fcbdd64fb2d27d3739faacd647
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbscspn.cpp	
@@ -0,0 +1,143 @@
+/***
+*mbscspn.c - Find first string char in charset (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Find first string char in charset (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+#include <string.h>
+
+/***
+*ifndef _RETURN_PTR
+* _mbscspn - Find first string char in charset (MBCS)
+*else
+* _mbspbrk - Find first string char in charset, pointer return (MBCS)
+*endif
+*
+*Purpose:
+*       Returns maximum leading segment of string
+*       which consists solely of characters NOT from charset.
+*       Handles MBCS chars correctly.
+*
+*Entry:
+*       char *string = string to search in
+*       char *charset = set of characters to scan over
+*
+*Exit:
+*
+*ifndef _RETURN_PTR
+*       Returns the index of the first char in string
+*       that is in the set of characters specified by control.
+*
+*       Returns 0, if string begins with a character in charset.
+*else
+*       Returns pointer to first character in charset.
+*
+*       Returns nullptr if string consists entirely of characters
+*       not from charset.
+*endif
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+#ifndef _RETURN_PTR
+
+extern "C" size_t __cdecl _mbscspn_l(
+        const unsigned char *string,
+        const unsigned char *charset,
+        _locale_t plocinfo
+        )
+#else  /* _RETURN_PTR */
+
+extern "C" const unsigned char * __cdecl _mbspbrk_l(
+        const unsigned char *string,
+        const unsigned char  *charset,
+        _locale_t plocinfo
+        )
+#endif  /* _RETURN_PTR */
+
+{
+        unsigned char *p, *q;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+#ifndef _RETURN_PTR
+            return strcspn((const char *)string, (const char *)charset);
+#else  /* _RETURN_PTR */
+            return (const unsigned char *)strpbrk((const char *)string, (const char *)charset);
+#endif  /* _RETURN_PTR */
+
+        /* validation section */
+#ifndef _RETURN_PTR
+        _VALIDATE_RETURN(string != nullptr, EINVAL, 0);
+        _VALIDATE_RETURN(charset != nullptr, EINVAL, 0);
+#else  /* _RETURN_PTR */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+        _VALIDATE_RETURN(charset != nullptr, EINVAL, nullptr);
+#endif  /* _RETURN_PTR */
+
+        /* loop through the string to be inspected */
+        for (q = (unsigned char *)string; *q ; q++) {
+
+            /* loop through the charset */
+            for (p = (unsigned char *)charset; *p ; p++) {
+
+                if ( _ismbblead_l(*p, _loc_update.GetLocaleT()) ) {
+                    if (((*p == *q) && (p[1] == q[1])) || p[1] == '\0')
+                        break;
+                    p++;
+                }
+                else
+                    if (*p == *q)
+                        break;
+            }
+
+            if (*p != '\0')         /* end of charset? */
+                break;              /* no, match on this char */
+
+            if ( _ismbblead_l(*q, _loc_update.GetLocaleT()) )
+                if (*++q == '\0')
+                    break;
+        }
+
+#ifndef _RETURN_PTR
+        return((size_t) (q - string));  /* index */
+#else  /* _RETURN_PTR */
+        return((*q) ? q : nullptr);        /* pointer */
+#endif  /* _RETURN_PTR */
+
+}
+
+#ifndef _RETURN_PTR
+
+extern "C" size_t (__cdecl _mbscspn)(
+        const unsigned char *string,
+        const unsigned char *charset
+        )
+#else  /* _RETURN_PTR */
+
+extern "C" const unsigned char * (__cdecl _mbspbrk)(
+        const unsigned char *string,
+        const unsigned char  *charset
+        )
+#endif  /* _RETURN_PTR */
+
+{
+#ifndef _RETURN_PTR
+        return _mbscspn_l(string, charset, nullptr);
+#else  /* _RETURN_PTR */
+        return _mbspbrk_l(string, charset, nullptr);
+#endif  /* _RETURN_PTR */
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsdec.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsdec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bfc9887302288b6d26ba791ca361a59e90b6dbcb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsdec.cpp	
@@ -0,0 +1,109 @@
+/***
+*mbsdec.c - Move MBCS string pointer backward one charcter.
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Move MBCS string pointer backward one character.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+
+/***
+*_mbsdec - Move MBCS string pointer backward one charcter.
+*
+*Purpose:
+*       Move the supplied string pointer backwards by one
+*       character.  MBCS characters are handled correctly.
+*
+*Entry:
+*       const unsigned char *string = pointer to beginning of string
+*       const unsigned char *current = current char pointer (legal MBCS boundary)
+*
+*Exit:
+*       Returns pointer after moving it.
+*       Returns nullptr if string >= current.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsdec_l(
+        const unsigned char *string,
+        const unsigned char *current,
+        _locale_t plocinfo
+        )
+{
+        const unsigned char *temp;
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+        _VALIDATE_RETURN(current != nullptr, EINVAL, nullptr);
+
+        if (string >= current)
+                return(nullptr);
+
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)--current;
+
+        temp = current - 1;
+
+/* There used to be an optimisation here:
+ *
+ *  If (current-1) returns true from _ismbblead, it is a trail byte, because
+ *  current is a known character start point, and so current-1 would have to be a
+ *  legal single byte MBCS character, which a lead byte is not.  Therefore, if so,
+ *  return (current-2) because it must be the trailbyte's lead.
+ *
+ *      if ( _ismbblead(*temp) )
+ *           return (unsigned char *)(temp - 1);
+ *
+ * But this is not a valid optimisation if you want to cope correctly with an
+ * MBCS string which is terminated by a leadbyte and a 0 byte, when you are passed
+ * an initial position pointing to the \0 at the end of the string.
+ *
+ * This optimisation is also invalid if you are passed a pointer to half-way
+ * through an MBCS pair.
+ *
+ * Neither of these are truly valid input conditions, but to ensure predictably
+ * correct behaviour in the presence of these conditions, we have removed
+ * the optimisation.
+ */
+
+/*
+ *  It is unknown whether (current - 1) is a single byte character or a
+ *  trail.  Now decrement temp until
+ *      a)  The beginning of the string is reached, or
+ *      b)  A non-lead byte (either single or trail) is found.
+ *  The difference between (current-1) and temp is the number of non-single
+ *  byte characters preceding (current-1).  There are two cases for this:
+ *      a)  (current - temp) is odd, and
+ *      b)  (current - temp) is even.
+ *  If odd, then there are an odd number of "lead bytes" preceding the
+ *  single/trail byte (current - 1), indicating that it is a trail byte.
+ *  If even, then there are an even number of "lead bytes" preceding the
+ *  single/trail byte (current - 1), indicating a single byte character.
+ */
+        while ( (string <= --temp) && (_ismbblead_l(*temp, _loc_update.GetLocaleT())) )
+                ;
+
+        return (unsigned char *)(current - 1 - ((current - temp) & 0x01) );
+}
+
+extern "C" unsigned char * (__cdecl _mbsdec)(
+        const unsigned char *string,
+        const unsigned char *current
+        )
+{
+    return _mbsdec_l(string, current, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsicmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsicmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..67bec271d402d6ffeb358fc67e7fe64a63da0303
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsicmp.cpp	
@@ -0,0 +1,142 @@
+/***
+*mbsicmp.c - Case-insensitive string comparision routine (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Case-insensitive string comparision routine (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbsicmp - Case-insensitive string comparision routine (MBCS)
+*
+*Purpose:
+*       Compares two strings for ordinal order without regard to case.
+*       Strings are compared on a character basis, not a byte basis.
+*
+*Entry:
+*       char *s1, *s2 = strings to compare
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR if something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsicmp_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        _locale_t plocinfo
+        )
+{
+        unsigned short c1, c2;
+        _LocaleUpdate _loc_update(plocinfo);
+        int    retval;
+        unsigned char szResult[4];
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _stricmp_l((const char *)s1, (const char *)s2, _loc_update.GetLocaleT());
+
+        for (;;)
+        {
+            c1 = *s1++;
+            if ( _ismbblead_l(c1, _loc_update.GetLocaleT()) )
+            {
+                if (*s1 == '\0')
+                    c1 = 0;
+                else
+                {
+                    retval = __acrt_LCMapStringA(
+                            _loc_update.GetLocaleT(),
+                            _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                            LCMAP_UPPERCASE,
+                            (LPCSTR)s1 - 1,
+                            2,
+                            (LPSTR)szResult,
+                            2,
+                            _loc_update.GetLocaleT()->mbcinfo->mbcodepage,
+                            TRUE );
+
+                    if (retval == 1)
+                        c1 = szResult[0];
+                    else if (retval == 2)
+                        c1 = (szResult[0] << 8) + szResult[1];
+                    else
+                    {
+                        errno = EINVAL;
+                        return _NLSCMPERROR;
+                    }
+                    s1++;
+                }
+            }
+            else
+                c1 = _mbbtolower_l(c1, _loc_update.GetLocaleT());
+
+            c2 = *s2++;
+            if ( _ismbblead_l(c2, _loc_update.GetLocaleT()) )
+            {
+                if (*s2 == '\0')
+                    c2 = 0;
+                else
+                {
+                    retval = __acrt_LCMapStringA(
+                            _loc_update.GetLocaleT(),
+                            _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                            LCMAP_UPPERCASE,
+                            (LPCSTR)s2 - 1,
+                            2,
+                            (LPSTR)szResult,
+                            2,
+                            _loc_update.GetLocaleT()->mbcinfo->mbcodepage,
+                            TRUE );
+
+                    if (retval == 1)
+                        c2 = szResult[0];
+                    else if (retval == 2)
+                        c2 = (szResult[0] << 8) + szResult[1];
+                    else
+                    {
+                        errno = EINVAL;
+                        return _NLSCMPERROR;
+                    }
+                    s2++;
+                }
+            }
+            else
+                c2 = _mbbtolower_l(c2, _loc_update.GetLocaleT());
+
+            if (c1 != c2)
+                return( (c1 > c2) ? 1 : -1 );
+
+            if (c1 == 0)
+                return(0);
+        }
+}
+
+extern "C" int (__cdecl _mbsicmp)(
+        const unsigned char *s1,
+        const unsigned char *s2
+        )
+{
+    return _mbsicmp_l(s1, s2, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsicoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsicoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ba17259b0969bf44109c1584415df7be2202fb2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsicoll.cpp	
@@ -0,0 +1,79 @@
+/***
+*mbsicoll.c - Collate MBCS strings, ignoring case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Collate MBCS strings, ignoring case
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+* _mbsicoll - Collate MBCS strings, ignoring case
+*
+*Purpose:
+*       Collates two strings for lexical order (ignoring case).
+*       Strings are collated on a character basis, not a byte basis.
+*
+*Entry:
+*       char *s1, *s2 = strings to collate
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsicoll_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        _locale_t plocinfo
+        )
+{
+        int ret;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _stricoll_l((const char *)s1, (const char *)s2, plocinfo);
+
+        if ( 0 == (ret = __acrt_CompareStringA(
+                        _loc_update.GetLocaleT(),
+                        _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                        SORT_STRINGSORT | NORM_IGNORECASE,
+                        (LPCSTR)s1,
+                        -1,
+                        (LPSTR)s2,
+                        -1,
+                        _loc_update.GetLocaleT()->mbcinfo->mbcodepage )) )
+        {
+            errno = EINVAL;
+            return _NLSCMPERROR;
+        }
+
+        return ret - 2;
+
+}
+
+extern "C" int (__cdecl _mbsicoll)(
+        const unsigned char *s1,
+        const unsigned char *s2
+        )
+{
+    return _mbsicoll_l(s1, s2, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsinc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsinc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7f1b57f3cc69e70c93b6381cf4beb022d36af5ac
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsinc.cpp	
@@ -0,0 +1,76 @@
+/***
+*mbsinc.c - Move MBCS string pointer ahead one charcter.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Move MBCS string pointer ahead one character.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <stddef.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*_mbsinc - Move MBCS string pointer ahead one charcter.
+*
+*Purpose:
+*       Move the supplied string pointer ahead by one
+*       character.  MBCS characters are handled correctly.
+*
+*Entry:
+*       const unsigned char *current = current char pointer (legal MBCS boundary)
+*
+*Exit:
+*       Returns pointer after moving it.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsinc_l(
+        const unsigned char *current,
+        _locale_t plocinfo
+        )
+{
+        if ( (_ismbblead_l)(*(current++),plocinfo))
+        {
+            /* don't move forward two if we get leadbyte, EOS
+               also don't assert here as we are too low level
+            */
+            if(*current!='\0')
+            {
+                current++;
+            }
+        }
+
+        return (unsigned char *)current;
+}
+
+extern "C" unsigned char * (__cdecl _mbsinc)(
+        const unsigned char *current
+        )
+{
+        /* validation section */
+        _VALIDATE_RETURN(current != nullptr, EINVAL, nullptr);
+
+        if ( _ismbblead(*(current++)))
+        {
+            /* don't move forward two if we get leadbyte, EOS
+               also don't assert here as we are too low level
+            */
+            if(*current!='\0')
+            {
+                current++;
+            }
+        }
+
+        return (unsigned char *)current;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..83d51417d602f25850702e50cad514135c9ae4ad
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslen.cpp	
@@ -0,0 +1,61 @@
+/***
+*mbslen.c - Find length of MBCS string
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Find length of MBCS string
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* _mbslen - Find length of MBCS string
+*
+*Purpose:
+*       Find the length of the MBCS string (in characters).
+*
+*Entry:
+*       unsigned char *s = string
+*
+*Exit:
+*       Returns the number of MBCS chars in the string.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl _mbslen_l(
+        const unsigned char *s,
+        _locale_t plocinfo
+        )
+{
+        int n;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return strlen((const char *)s);
+
+        for (n = 0; *s; n++, s++) {
+            if ( _ismbblead_l(*s, _loc_update.GetLocaleT()) ) {
+                if (*++s == '\0')
+                    break;
+            }
+        }
+
+        return(n);
+}
+
+extern "C" size_t (__cdecl _mbslen)(
+        const unsigned char *s
+        )
+{
+    return _mbslen_l(s, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslen_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslen_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3594b373342e1e923ac799a1aa76971d42510fb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslen_s.cpp	
@@ -0,0 +1,84 @@
+/***
+*mbslen_s.c - Find length of MBCS string
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Find length of MBCS string
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* _mbsnlen - Find length of MBCS string
+*
+*Purpose:
+*       Find the length of the MBCS string (in characters).
+*
+*Entry:
+*       unsigned char *s = string
+*       size_t maxsize
+*
+*Exit:
+*       Returns the number of MBCS chars in the string.
+*       Only the first sizeInBytes bytes of the string are inspected: if the null
+*       terminator is not found, sizeInBytes is returned.
+*       If the string is null terminated in sizeInBytes bytes, the return value
+*       will always be less than sizeInBytes.
+*       Returns (size_t)-1 if something went wrong.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+size_t __cdecl _mbsnlen_l(
+        const unsigned char *s,
+        size_t sizeInBytes,
+        _locale_t plocinfo
+        )
+{
+        size_t n, size;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return strnlen((const char *)s, sizeInBytes);
+
+        /* Note that we do not check if s == nullptr, because we do not
+         * return errno_t...
+         */
+
+        /* Note that sizeInBytes here is the number of bytes, not mb characters! */
+        for (n = 0, size = 0; size < sizeInBytes && *s; n++, s++, size++)
+        {
+            if ( _ismbblead_l(*s, _loc_update.GetLocaleT()) )
+                        {
+                                size++;
+                                if (size >= sizeInBytes)
+                                {
+                                        break;
+                                }
+                if (*++s == '\0')
+                                {
+                    break;
+                                }
+            }
+        }
+
+                return (size >= sizeInBytes ? sizeInBytes : n);
+}
+
+size_t __cdecl _mbsnlen(
+        const unsigned char *s,
+        size_t maxsize
+        )
+{
+    return _mbsnlen_l(s,maxsize, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslwr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslwr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7234e29cf09169893eb1e0bea6db529a40dcc266
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbslwr.cpp	
@@ -0,0 +1,136 @@
+/***
+*mbslwr.c - Convert string lower case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Convert string lower case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbslwr - Convert string lower case (MBCS)
+*
+*Purpose:
+*       Convrts all the upper case characters in a string
+*       to lower case in place.  MBCS chars are handled
+*       correctly.
+*
+*Entry:
+*       unsigned char *string = pointer to string
+*
+*Exit:
+*       Returns a pointer to the input string.
+*       Returns nullptr on error.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+errno_t __cdecl _mbslwr_s_l(
+        unsigned char *string,
+        size_t sizeInBytes,
+        _locale_t plocinfo
+        )
+{
+        size_t stringlen;
+
+        /* validation section */
+        _VALIDATE_RETURN_ERRCODE((string != nullptr && sizeInBytes > 0) || (string == nullptr && sizeInBytes == 0), EINVAL);
+
+        if (string == nullptr)
+        {
+            /* nothing to do */
+            return 0;
+        }
+
+        stringlen = strnlen((char *)string, sizeInBytes);
+        if (stringlen >= sizeInBytes)
+        {
+            _RESET_STRING(string, sizeInBytes);
+            _RETURN_DEST_NOT_NULL_TERMINATED(string, sizeInBytes);
+        }
+        _FILL_STRING(string, sizeInBytes, stringlen + 1);
+
+        unsigned char *cp, *dst;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        for (cp = string, dst = string; *cp != '\0'; ++cp)
+        {
+            if (_ismbblead_l(*cp, _loc_update.GetLocaleT()))
+            {
+
+
+                int retval;
+                unsigned char ret[4];
+                if ((retval = __acrt_LCMapStringA(
+                                _loc_update.GetLocaleT(),
+                                _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                                LCMAP_LOWERCASE,
+                                (const char *)cp,
+                                2,
+                                (char *)ret,
+                                2,
+                                _loc_update.GetLocaleT()->mbcinfo->mbcodepage,
+                                TRUE )) == 0 )
+                {
+                    errno = EILSEQ;
+                    _RESET_STRING(string, sizeInBytes);
+                    return errno;
+                }
+
+                *(dst++) = ret[0];
+                ++cp;
+                if (retval > 1)
+                {
+                    *(dst++) = ret[1];
+                }
+
+
+            }
+            else
+            {
+                /* single byte, macro version */
+                *(dst++) = (unsigned char) _mbbtolower_l(*cp, _loc_update.GetLocaleT());
+            }
+        }
+        /* null terminate the string */
+        *dst = '\0';
+
+        return 0;
+}
+
+errno_t (__cdecl _mbslwr_s)(
+        unsigned char *string,
+        size_t sizeInBytes
+        )
+{
+    return _mbslwr_s_l(string, sizeInBytes, nullptr);
+}
+
+unsigned char * (__cdecl _mbslwr_l)(
+        unsigned char *string,
+        _locale_t plocinfo
+        )
+{
+    return (_mbslwr_s_l(string, (string == nullptr ? 0 : (size_t)-1), plocinfo) == 0 ? string : nullptr);
+}
+
+unsigned char * (__cdecl _mbslwr)(
+        unsigned char *string
+        )
+{
+    return (_mbslwr_s_l(string, (string == nullptr ? 0 : (size_t)-1), nullptr) == 0 ? string : nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2cb9d5b48d8c0ece7bc987e1af3b34d9cc8b3f3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat.cpp	
@@ -0,0 +1,116 @@
+/***
+*mbsnbcat.c - concatenate string2 onto string1, max length n bytes
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       defines mbsnbcat() - concatenate maximum of n bytes
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+* _mbsnbcat - concatenate max cnt bytes onto dst
+*
+*Purpose:
+*       Concatenates src onto dst, with a maximum of cnt bytes copied.
+*       Handles 2-byte MBCS characters correctly.
+*
+*Entry:
+*       unsigned char *dst - string to concatenate onto
+*       unsigned char *src - string to concatenate from
+*       int cnt - number of bytes to copy
+*
+*Exit:
+*       returns dst, with src (at least part) concatenated on
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsnbcat_l(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *start;
+
+        if (!cnt)
+                return(dst);
+
+        /* validation section */
+        _VALIDATE_RETURN(dst != nullptr, EINVAL, nullptr);
+        _VALIDATE_RETURN(src != nullptr, EINVAL, nullptr);
+
+        _LocaleUpdate _loc_update(plocinfo);
+
+        _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)strncat((char *)dst, (const char *)src, cnt);
+        _END_SECURE_CRT_DEPRECATION_DISABLE
+
+        start = dst;
+        while (*dst++)
+                ;
+        --dst;          // dst now points to end of dst string
+
+        /* if last char in string is a lead byte, back up pointer */
+        if ( dst!=start && _mbsbtype_l(start, (int) ((dst - start) - 1), _loc_update.GetLocaleT()) == _MBC_LEAD )
+        {
+            --dst;
+        }
+
+        /* copy over the characters */
+
+        while (cnt--) {
+
+            if ( _ismbblead_l(*src, _loc_update.GetLocaleT()) ) {
+                *dst++ = *src++;
+                if (cnt == 0) {   /* write null if cnt exhausted */
+                    dst[-1] = '\0';
+                    break;
+                }
+                cnt--;
+                if ((*dst++ = *src++)=='\0') { /* or if no trail byte */
+                    dst[-2] = '\0';
+                    break;
+                }
+            }
+            else if ((*dst++ = *src++) == '\0')
+                break;
+
+        }
+
+        if ( dst!=start && _mbsbtype_l(start, (int) ((dst - start) - 1), _loc_update.GetLocaleT()) == _MBC_LEAD )
+        {
+            dst[-1] = '\0';
+        }
+        else
+        {
+            *dst = '\0';
+        }
+
+        return(start);
+}
+
+extern "C" unsigned char * (__cdecl _mbsnbcat)(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt
+        )
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsnbcat_l(dst, src, cnt, nullptr);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7a3e160bfa17e59e5cc0541624db20c56386b19
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbsnbcat_s.c - concatenate string2 onto string1, max length n bytes
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       defines mbsnbcat_s() - concatenate maximum of n bytes
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbsnbcat_s, unsigned char *, size_t, const unsigned char *, size_t)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..936378bff2fd39eb495673fe7f1b3d7c3cfaa4d6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcat_s_l.cpp	
@@ -0,0 +1,21 @@
+/***
+*mbsnbcat_s_l.c - concatenate string2 onto string1, max length n bytes
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       defines mbsnbcat_s_l() - concatenate maximum of n bytes
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+#define _FUNC_NAME _mbsnbcat_s_l
+#define _COUNT _CountInBytes
+#define _COUNT_IN_BYTES 1
+
+#include "mbsncat_s.inl"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7178442e0cd676bf2de984f5f30e0bc98834cb70
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcmp.cpp	
@@ -0,0 +1,107 @@
+/***
+*mbsnbcmp.c - Compare n bytes of two MBCS strings
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Compare n bytes of two MBCS strings
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*int mbsnbcmp(s1, s2, n) - Compare n bytes of two MBCS strings
+*
+*Purpose:
+*       Compares up to n bytes of two strings for ordinal order.
+*
+*       UTF-8 and SBCS are merely compared in byte order.
+*       DBCS are compared by codepoint to ensure double byte chars sort last
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to compare
+*       size_t n = maximum number of bytes to compare
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsnbcmp_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        unsigned short c1, c2;
+
+        if (n==0)
+                return(0);
+
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return strncmp((const char *)s1, (const char *)s2, n);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        while (n--) {
+
+            c1 = *s1++;
+            if ( _ismbblead_l(c1, _loc_update.GetLocaleT()) )
+            {
+                if (n==0)
+                {
+                    c1 = 0; /* 'naked' lead - end of string */
+                    c2 = _ismbblead_l(*s2, _loc_update.GetLocaleT()) ? 0 : *s2;
+                    goto test;
+                }
+                c1 = ( (*s1 == '\0') ? 0 : ((c1<<8) | *s1++) );
+            }
+
+            c2 = *s2++;
+            if ( _ismbblead_l(c2, _loc_update.GetLocaleT()) )
+            {
+                if (n==0)
+                {
+                    c2 = 0; /* 'naked' lead - end of string */
+                    goto test;
+                }
+                --n;
+                c2 = ( (*s2 == '\0') ? 0 : ((c2<<8) | *s2++) );
+            }
+test:
+            if (c1 != c2)
+                return( (c1 > c2) ? 1 : -1);
+
+            if (c1 == 0)
+                return(0);
+        }
+
+        return(0);
+}
+
+extern "C" int (__cdecl _mbsnbcmp)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsnbcmp_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcnt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcnt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8cbf684dcaeb25e98af4e24f19db7b73361aa4dc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcnt.cpp	
@@ -0,0 +1,71 @@
+/***
+*mbsnbcnt.c - Returns byte count of MBCS string
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Returns byte count of MBCS string
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+* _mbsnbcnt - Returns byte count of MBCS string
+*
+*Purpose:
+*       Returns the number of bytes between the start of the supplied
+*       string and the char count supplied.  That is, this routine
+*       indicates how many bytes are in the first "ccnt" characters
+*       of the string.
+*
+*Entry:
+*       unsigned char *string = pointer to string
+*       unsigned int ccnt = number of characters to scan
+*
+*Exit:
+*       Returns number of bytes between string and ccnt.
+*
+*       If the end of the string is encountered before ccnt chars were
+*       scanned, then the length of the string in bytes is returned.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl _mbsnbcnt_l(
+        const unsigned char *string,
+        size_t ccnt,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *p;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr || ccnt == 0, EINVAL, 0);
+
+        for (p = (unsigned char *)string; (ccnt-- && *p); p++) {
+            if ( _ismbblead_l(*p, _loc_update.GetLocaleT()) ) {
+                if (*++p == '\0') {
+                    --p;
+                    break;
+                }
+            }
+        }
+
+        return ((size_t) ((char *)p - (char *)string));
+}
+
+extern "C" size_t (__cdecl _mbsnbcnt)(
+        const unsigned char *string,
+        size_t ccnt
+        )
+{
+        return _mbsnbcnt_l(string, ccnt, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcol.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca6e18baede2321e446470097d31ed64c49a4bb2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcol.cpp	
@@ -0,0 +1,86 @@
+/***
+*mbsnbcol.c - Collate n bytes of two MBCS strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Collate n bytes of two MBCS strings
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <limits.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* _mbsnbcoll(s1, s2, n) - Collate n bytes of two MBCS strings
+*
+*Purpose:
+*       Collates up to n bytes of two strings for lexical order.
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to collate
+*       size_t n = maximum number of bytes to collate
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsnbcoll_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        int ret;
+
+        if (n == 0)
+            return 0;
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(n <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strncoll_l((const char *)s1, (const char *)s2, n, plocinfo);
+
+        if ( 0 == (ret = __acrt_CompareStringA(_loc_update.GetLocaleT(),
+                                              _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                                              SORT_STRINGSORT,
+                                              (const char *)s1,
+                                              (int)n,
+                                              (char *)s2,
+                                              (int)n,
+                                              _loc_update.GetLocaleT()->mbcinfo->mbcodepage )) )
+        {
+            errno = EINVAL;
+            return _NLSCMPERROR;
+        }
+
+        return ret - 2;
+
+}
+
+extern "C" int (__cdecl _mbsnbcoll)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsnbcoll_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a5f8db4f3e19685f4e61f0f3f7c37531b85a691e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy.cpp	
@@ -0,0 +1,103 @@
+/***
+*mbsnbcpy.c - Copy one string to another, n bytes only (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another, n bytes only (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbsnbcpy - Copy one string to another, n bytes only (MBCS)
+*
+*Purpose:
+*       Copies exactly cnt bytes from src to dst.  If strlen(src) < cnt, the
+*       remaining character are padded with null bytes.  If strlen >= cnt, no
+*       terminating null byte is added.  2-byte MBCS characters are handled
+*       correctly.
+*
+*Entry:
+*       unsigned char *dst = destination for copy
+*       unsigned char *src = source for copy
+*       int cnt = number of bytes to copy
+*
+*Exit:
+*       returns dst = destination of copy
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+#pragma warning(suppress:6101) // Returning uninitialized memory '*dst'.  A successful path through the function does not set the named _Out_ parameter.
+unsigned char * __cdecl _mbsnbcpy_l(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt,
+        _locale_t plocinfo
+        )
+{
+
+        unsigned char *start = dst;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(dst != nullptr || cnt == 0, EINVAL, nullptr);
+        _VALIDATE_RETURN(src != nullptr || cnt == 0, EINVAL, nullptr);
+
+        _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+#pragma warning(suppress:__WARNING_BANNED_API_USAGE)
+            return (unsigned char *)strncpy((char *)dst, (const char *)src, cnt);
+        _END_SECURE_CRT_DEPRECATION_DISABLE
+
+        while (cnt) {
+
+            cnt--;
+            if ( _ismbblead_l(*src, _loc_update.GetLocaleT()) ) {
+                *dst++ = *src++;
+                if (!cnt) {
+                    dst[-1] = '\0';
+                    break;
+                }
+                cnt--;
+                if ((*dst++ = *src++) == '\0') {
+                    dst[-2] = '\0';
+                    break;
+                }
+            }
+
+            else
+                if ((*dst++ = *src++) == '\0')
+                    break;
+
+        }
+
+        /* pad with nulls as needed */
+
+        while (cnt--)
+            *dst++ = '\0';
+
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036
+        return start;
+}
+unsigned char * (__cdecl _mbsnbcpy)(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt
+        )
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsnbcpy_l(dst, src, cnt, nullptr);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..055f38cc3d229b04fd7885a867278d37813f1edb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbsnbcpy_s.c - Copy one string to another, n bytes only (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another, n bytes only (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbsnbcpy_s, unsigned char *, size_t, const unsigned char *, size_t)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5a83547aa22f9e6779377e7fc6f53ff579c0a312
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbcpy_s_l.cpp	
@@ -0,0 +1,21 @@
+/***
+*mbsnbcpy_s_l.c - Copy one string to another, n bytes only (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another, n bytes only (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+#define _FUNC_NAME _mbsnbcpy_s_l
+#define _COUNT _CountInBytes
+#define _COUNT_IN_BYTES 1
+
+#include "mbsncpy_s.inl"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbicm.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbicm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..38e1a166bf2b723b5509e5eb0d5441e786a191a7
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbicm.cpp	
@@ -0,0 +1,133 @@
+/***
+*mbsnbicmp.c - Compare n bytes of strings, ignoring case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Compare n bytes of strings, ignoring case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbsnbicmp - Compare n bytes of strings, ignoring case (MBCS)
+*
+*Purpose:
+*       Compares up to n bytes of two strings for ordinal order.
+*       Strings are compared on a character basis, not a byte basis.
+*       Case of characters is not considered.
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to compare
+*       size_t n = maximum number of bytes to compare
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+int __cdecl _mbsnbicmp_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        unsigned short c1, c2;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (n==0)
+            return(0);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strnicmp((const char *)s1, (const char *)s2, n);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        while (n--) {
+
+            c1 = *s1++;
+            if ( _ismbblead_l(c1, _loc_update.GetLocaleT()) )
+            {
+                if (n==0)
+                {
+                    c1 = 0; /* 'naked' lead - end of string */
+                    c2 = _ismbblead_l(*s2, _loc_update.GetLocaleT()) ? 0 : *s2;
+                    goto test;
+                }
+                if (*s1 == '\0')
+                    c1 = 0;
+                else {
+                    c1 = ((c1<<8) | *s1++);
+
+                    if ( ((c1 >= _MBUPPERLOW1_MT(_loc_update.GetLocaleT())) &&
+                          (c1 <= _MBUPPERHIGH1_MT(_loc_update.GetLocaleT()))) )
+                        c1 += _MBCASEDIFF1_MT(_loc_update.GetLocaleT());
+                    else if ( ((c1 >= _MBUPPERLOW2_MT(_loc_update.GetLocaleT())) &&
+                               (c1 <= _MBUPPERHIGH2_MT(_loc_update.GetLocaleT()))) )
+                        c1 += _MBCASEDIFF2_MT(_loc_update.GetLocaleT());
+                }
+            }
+            else
+                c1 = _mbbtolower_l(c1, _loc_update.GetLocaleT());
+
+                c2 = *s2++;
+                if ( _ismbblead_l(c2, _loc_update.GetLocaleT()) )
+                {
+                    if (n==0)
+                    {
+                        c2 = 0; /* 'naked' lead - end of string */
+                        goto test;
+                    }
+                    n--;
+                    if (*s2 == '\0')
+                        c2 = 0;
+                    else {
+                        c2 = ((c2<<8) | *s2++);
+
+                        if ( ((c2 >= _MBUPPERLOW1_MT(_loc_update.GetLocaleT())) &&
+                              (c2 <= _MBUPPERHIGH1_MT(_loc_update.GetLocaleT()))) )
+                            c2 += _MBCASEDIFF1_MT(_loc_update.GetLocaleT());
+                        else if ( ((c2 >= _MBUPPERLOW2_MT(_loc_update.GetLocaleT())) &&
+                                   (c2 <= _MBUPPERHIGH2_MT(_loc_update.GetLocaleT()))) )
+                            c2 += _MBCASEDIFF2_MT(_loc_update.GetLocaleT());
+                    }
+                }
+                else
+                    c2 = _mbbtolower_l(c2, _loc_update.GetLocaleT());
+
+test:
+            if (c1 != c2)
+                return( (c1 > c2) ? 1 : -1);
+
+            if (c1 == 0)
+                return(0);
+        }
+
+        return(0);
+}
+
+int (__cdecl _mbsnbicmp)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsnbicmp_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbico.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbico.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..584ec9db9532ff2dc82d9b9a486c358e9f590763
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbico.cpp	
@@ -0,0 +1,82 @@
+/***
+*mbsnbico.c - Collate n bytes of strings, ignoring case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Collate n bytes of strings, ignoring case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _mbsnbicoll - Collate n bytes of strings, ignoring case (MBCS)
+*
+*Purpose:
+*       Collates up to n bytes of two strings for lexical order.
+*       Strings are collated on a character basis, not a byte basis.
+*       Case of characters is not considered.
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to collate
+*       size_t n = maximum number of bytes to collate
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsnbicoll_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        int ret;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (n == 0)
+            return 0;
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(n <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strnicoll_l((const char *)s1, (const char *)s2, n, plocinfo);
+
+        if ( 0 == (ret = __acrt_CompareStringA(_loc_update.GetLocaleT(),
+                                             _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                                              SORT_STRINGSORT | NORM_IGNORECASE,
+                                              (const char *)s1,
+                                              (int)n,
+                                              (char *)s2,
+                                              (int)n,
+                                              _loc_update.GetLocaleT()->mbcinfo->mbcodepage )) )
+            return _NLSCMPERROR;
+
+        return ret - 2;
+
+}
+extern "C" int __cdecl _mbsnbicoll(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsnbicoll_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b9eec869bacc369ca84208ea2f33f3a461f8a766
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset.cpp	
@@ -0,0 +1,136 @@
+/***
+*mbsnbset.c - Sets first n bytes of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Sets first n bytes of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* _mbsnbset - Sets first n bytes of string to given character (MBCS)
+*
+*Purpose:
+*       Sets the first n bytes of string to the supplied
+*       character value.  If the length of string is less than n,
+*       the length of string is used in place of n.  Handles
+*       MBCS chars correctly.
+*
+*       There are several factors that make this routine complicated:
+*               (1) The fill value may be 1 or 2 bytes long.
+*               (2) The fill operation may end by hitting the count value
+*               or by hitting the end of the string.
+*               (3) A null terminating char is NOT placed at the end of
+*               the string.
+*
+*       Cases to be careful of (both of these can occur at once):
+*               (1) Leaving an "orphaned" trail byte in the string (e.g.,
+*               overwriting a lead byte but not the corresponding trail byte).
+*               (2) Writing only the 1st byte of a 2-byte fill value because the
+*               end of string was encountered.
+*
+*Entry:
+*       unsigned char *string = string to modify
+*       unsigned int val = value to fill string with
+*       size_t count = count of characters to fill
+*
+*
+*Exit:
+*       Returns string = now filled with char val
+*
+*Uses:
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsnbset_l(
+        unsigned char *string,
+        unsigned int val,
+        size_t count,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *start = string;
+        unsigned char highval, lowval;
+        _LocaleUpdate _loc_update(plocinfo);
+
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)_strnset((char *)string, val, count);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr || count == 0, EINVAL, nullptr);
+
+        /*
+         * leadbyte flag indicates if the last byte we overwrote was
+         * a lead byte or not.
+         */
+
+        highval = static_cast<unsigned char>(val >> 8);
+        if (highval)
+        {
+                /* double byte value */
+
+                lowval = (unsigned char)(val & 0x00ff);
+
+                if(lowval=='\0')
+                {
+                    _ASSERTE(("invalid MBCS pair passed to mbsnbset",0));
+
+                    /* Ideally we would return nullptr here and signal an error
+                       condition. But since this function has no other
+                       error modes, there would be a good chance of crashing
+                       the caller. So instead we fill the string with spaces
+                       to ensure that no information leaks through
+                       unexpectedly. Anyway, we do set errno to EINVAL.
+                    */
+                    errno = EINVAL;
+                    lowval=highval=' ';
+                }
+
+                while ((count--) && *string) {
+
+                        /* pad with ' ' if no room for both bytes -- odd len */
+                        if ((!count--) || (!*(string+1))) {
+                                *string = ' ';
+                                break;
+                        }
+
+                        *string++ = highval;
+                        *string++ = lowval;
+                }
+        }
+
+        else {
+                /* single byte value */
+
+                while (count-- && *string) {
+                        *string++ = (unsigned char)val;
+                }
+
+        }
+
+        return( start );
+}
+
+extern "C" unsigned char * (__cdecl _mbsnbset)(
+        unsigned char *string,
+        unsigned int val,
+        size_t count
+        )
+{
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsnbset_l(string, val, count, nullptr);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..922c443c87fd52fb9296b1a893e6692673607136
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset_s.cpp	
@@ -0,0 +1,17 @@
+/***
+*mbsnbset_s.c - Sets first n bytes of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets first n bytes of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal.h>
+
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbsnbset_s, unsigned char *, size_t, unsigned int, size_t)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4ce6ed0babed33321bee094e40643d217ceddd9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnbset_s_l.cpp	
@@ -0,0 +1,21 @@
+/***
+*mbsset_s_l.c - Sets first n bytes of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets first n bytes of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+#define _FUNC_NAME _mbsnbset_s_l
+#define _COUNT _CountInBytes
+#define _COUNT_IN_BYTES 1
+
+#include "mbsnset_s.inl"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2fbdbcb47cd21a3de0df8d9be1b7e95186fdf131
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat.cpp	
@@ -0,0 +1,110 @@
+/***
+*mbsncat.c - concatenate string2 onto string1, max length n
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       defines mbsncat() - concatenate maximum of n characters
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+* _mbsncat - concatenate max cnt characters onto dst
+*
+*Purpose:
+*       Concatenates src onto dst, with a maximum of cnt characters copied.
+*       Handles 2-byte MBCS characters correctly.
+*
+*Entry:
+*       unsigned char *dst - string to concatenate onto
+*       unsigned char *src - string to concatenate from
+*       int cnt - number of characters to copy
+*
+*Exit:
+*       returns dst, with src (at least part) concatenated on
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsncat_l(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *start;
+
+        if (!cnt)
+            return(dst);
+
+        /* validation section */
+        _VALIDATE_RETURN(dst != nullptr, EINVAL, nullptr);
+        _VALIDATE_RETURN(src != nullptr, EINVAL, nullptr);
+
+        _LocaleUpdate _loc_update(plocinfo);
+
+        _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)strncat((char *)dst, (const char *)src, cnt);
+        _END_SECURE_CRT_DEPRECATION_DISABLE
+
+        start = dst;
+        while (*dst++)
+                ;
+        --dst;          // dst now points to end of dst string
+
+
+        /* if last char in string is a lead byte, back up pointer */
+
+        if ( _ismbslead_l(start, dst, _loc_update.GetLocaleT()) )
+            --dst;
+
+        /* copy over the characters */
+
+        while (cnt--) {
+            if ( _ismbblead_l(*src, _loc_update.GetLocaleT()) ) {
+                *dst++ = *src++;
+                if ((*dst++ = *src++) == '\0') {
+                    dst[-2] = '\0';
+                    break;
+                }
+            }
+
+            else if ((*dst++ = *src++) == '\0')
+                break;
+
+        }
+
+        /* enter final nul, if necessary */
+        if ( dst!=start && _mbsbtype_l(start, (int) ((dst - start) - 1), _loc_update.GetLocaleT()) == _MBC_LEAD )
+        {
+            dst[-1] = '\0';
+        }
+        else
+        {
+            *dst = '\0';
+        }
+
+        return(start);
+}
+
+extern "C" unsigned char * (__cdecl _mbsncat)(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt
+        )
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsncat_l(dst, src, cnt, nullptr);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..605a4dee72262308f1815ddb174139819fb59b4c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbsncat_s.c - concatenate string2 onto string1, max length n
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       defines mbsncat_s() - concatenate maximum of n characters
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbsncat_s, unsigned char *, size_t, const unsigned char *, size_t)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s.inl b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s.inl
new file mode 100644
index 0000000000000000000000000000000000000000..871b178b0a3ee6737d7df08962557c7865d8106d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s.inl	
@@ -0,0 +1,203 @@
+/***
+*mbsncat_s.inl - general implementation of _mbsncat_s and _mbsnbcat_s
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This file contains the general algorithm for _mbsncat_s and _mbsnbcat_s.
+*
+****/
+
+errno_t __cdecl _FUNC_NAME(unsigned char *_Dst, size_t _SizeInBytes, const unsigned char *_Src, size_t _COUNT, _LOCALE_ARG_DECL)
+{
+    unsigned char *p;
+    size_t available;
+    BOOL fIsLeadPrefix;
+    BOOL fFoundInvalidMBC;
+
+    fFoundInvalidMBC = FALSE;
+
+    if (_COUNT == 0 && _Dst == nullptr && _SizeInBytes == 0)
+    {
+        /* this case is allowed; nothing to do */
+        _RETURN_NO_ERROR;
+    }
+
+    /* validation section */
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+    if (_COUNT != 0)
+    {
+        _VALIDATE_POINTER_RESET_STRING(_Src, _Dst, _SizeInBytes);
+    }
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return strncat_s((char *)_Dst, _SizeInBytes, (const char *)_Src, _COUNT);
+    }
+
+    p = _Dst;
+    available = _SizeInBytes;
+    while (available > 0 && *p != 0)
+    {
+        p++;
+        available--;
+    }
+
+    /*
+     * Ran out of room while looking for end of dst string.
+     * p points 1 past end of buffer. We can't look past
+     * end of buffer so can't tell if dst ended with an
+     * invalid mbc.
+     */
+
+    if (available == 0)
+    {
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_DEST_NOT_NULL_TERMINATED(_Dst, _SizeInBytes);
+    }
+
+
+    if (available < _SizeInBytes)
+    {
+        /*
+         * Dst may have terminated with an invalid MBCS, in that case we clear
+         * the bogus lead byte.
+         */
+        fIsLeadPrefix = FALSE;
+        _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, &p[-1]);
+        if (fIsLeadPrefix) {
+            /* the original string ended with a lead byte: we remove it */
+            p--;
+            *p = 0;
+            available++;
+            fFoundInvalidMBC = TRUE;
+        }
+    }
+
+    if (_COUNT == _TRUNCATE)
+    {
+        while ((*p++ = *_Src++) != 0 && --available > 0)
+        {
+        }
+    }
+    else
+    {
+#if _COUNT_IN_BYTES
+        while (_COUNT > 0 && (*p++ = *_Src++) != 0 && --available > 0)
+        {
+            _COUNT--;
+        }
+#else  /* _COUNT_IN_BYTES */
+        while (_COUNT > 0)
+        {
+            if (_ISMBBLEAD(*_Src))
+            {
+                if (_Src[1] == 0)
+                {
+                    /* the source string ended with a lead byte: we remove it */
+                    *p = 0;
+                    fFoundInvalidMBC = TRUE;
+                    break;
+                }
+                if (available <= 2)
+                {
+                    /* not enough space */
+                    available = 0;
+                    break;
+                }
+                *p++ = *_Src++;
+                *p++ = *_Src++;
+                available -= 2;
+            }
+            else
+            {
+                if ((*p++ = *_Src++) == 0 || --available == 0)
+                {
+                    break;
+                }
+            }
+            _COUNT--;
+        }
+#endif  /* _COUNT_IN_BYTES */
+        if (_COUNT == 0)
+        {
+            *p++ = 0;
+        }
+    }
+
+    if (available == 0)
+    {
+#if _COUNT_IN_BYTES
+        /*
+         * defined(_COUNT_IN_BYTES) loop does not track mbc context,
+         * so we must iterate backwards to discover character context.
+         */
+        if (*_Src == 0 || _COUNT == 1)
+        {
+            _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, &p[-1]);
+            if (fIsLeadPrefix)
+            {
+                /* the source string ended with a lead byte: we remove it */
+                p[-1] = 0;
+                _RETURN_MBCS_ERROR;
+            }
+        }
+#endif  /* _COUNT_IN_BYTES */
+
+        /*
+         * _COUNT == _TRUNCATE loop terminated because available became 0.
+         * This means that we copied at least one character, and it wasn't
+         * a null. If this last character acted as a lead then overwrite
+         * it with null. Do not set the mbcs error in this case, due that the
+         * user cannot predict this case and he/she's only asking for truncation.
+         */
+        if (_COUNT == _TRUNCATE)
+        {
+            if (fFoundInvalidMBC)
+            {
+                _SET_MBCS_ERROR;
+            }
+
+            if (_SizeInBytes > 1)
+            {
+                fIsLeadPrefix = FALSE;
+                _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, &_Dst[_SizeInBytes - 2]);
+                if (fIsLeadPrefix)
+                {
+                    _Dst[_SizeInBytes - 2] = 0;
+                    _FILL_BYTE(_Dst[_SizeInBytes - 1]);
+                    _RETURN_TRUNCATE;
+                }
+            }
+
+            _Dst[_SizeInBytes - 1] = 0;
+
+            _RETURN_TRUNCATE;
+        }
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_BUFFER_TOO_SMALL(_Dst, _SizeInBytes);
+    }
+#if _COUNT_IN_BYTES
+    if (available < _SizeInBytes)
+    {
+        _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, &p[-2]);
+        if (fIsLeadPrefix)
+        {
+            /* the source string ended with a lead byte: we remove it */
+            p[-2] = 0;
+            available++;
+            fFoundInvalidMBC = TRUE;
+        }
+    }
+#endif  /* _COUNT_IN_BYTES */
+    _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+
+    if (fFoundInvalidMBC)
+    {
+        _RETURN_MBCS_ERROR;
+    }
+
+    _RETURN_NO_ERROR;
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..279af2da40481988ed4c7ff9a2a570ebca2c2768
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncat_s_l.cpp	
@@ -0,0 +1,21 @@
+/***
+*mbsncat_s_l.c - concatenate string2 onto string1, max length n
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       defines mbsncat_s_l() - concatenate maximum of n characters
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+#define _FUNC_NAME _mbsncat_s_l
+#define _COUNT _CountInChars
+#define _COUNT_IN_BYTES 0
+
+#include "mbsncat_s.inl"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnccnt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnccnt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8321650c87d691410969ff2d5159e79bdb6d624d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnccnt.cpp	
@@ -0,0 +1,67 @@
+/***
+*mbsnccnt.c - Return char count of MBCS string
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Return char count of MBCS string
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+* _mbsnccnt - Return char count of MBCS string
+*
+*Purpose:
+*       Returns the number of chars between the start of the supplied
+*       string and the byte count supplied.  That is, this routine
+*       indicates how many chars are in the first "bcnt" bytes
+*       of the string.
+*
+*Entry:
+*       const unsigned char *string = pointer to string
+*       unsigned int bcnt = number of bytes to scan
+*
+*Exit:
+*       Returns number of chars between string and bcnt.
+*
+*       If the end of the string is encountered before bcnt chars were
+*       scanned, then the length of the string in chars is returned.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl _mbsnccnt_l(
+        const unsigned char *string,
+        size_t bcnt,
+        _locale_t plocinfo
+        )
+{
+        size_t n;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        _VALIDATE_RETURN(string != nullptr || bcnt == 0, EINVAL, 0);
+
+        for (n = 0; (bcnt-- && *string); n++, string++) {
+            if ( _ismbblead_l(*string, _loc_update.GetLocaleT()) ) {
+                if ( (!bcnt--) || (*++string == '\0'))
+                    break;
+            }
+        }
+
+        return(n);
+}
+extern "C" size_t (__cdecl _mbsnccnt)(
+        const unsigned char *string,
+        size_t bcnt
+        )
+{
+    return _mbsnccnt_l(string, bcnt, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..880fb94373c515e24901c4f6f7b35acd6a2bf822
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncmp.cpp	
@@ -0,0 +1,92 @@
+/***
+*mbsncmp.c - Compare n characters of two MBCS strings
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Compare n characters of two MBCS strings
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*int mbsncmp(s1, s2, n) - Compare n characters of two MBCS strings
+*
+*Purpose:
+*       Compares up to n characters of two strings for ordinal order.
+*       Strings are compared on a character basis, not a byte basis.
+*
+*       UTF-8 and SBCS are merely compared in byte order.
+*       DBCS are compared by codepoint to ensure double byte chars sort last
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to compare
+*       size_t n = maximum number of characters to compare
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsncmp_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        unsigned short c1, c2;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (n==0)
+            return(0);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return strncmp((const char *)s1, (const char *)s2, n);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        while (n--) {
+
+            c1 = *s1++;
+            if ( _ismbblead_l(c1, _loc_update.GetLocaleT()) )
+                c1 = ( (*s1 == '\0') ? 0 : ((c1<<8) | *s1++) );
+
+            c2 = *s2++;
+            if ( _ismbblead_l(c2, _loc_update.GetLocaleT()) )
+                c2 = ( (*s2 == '\0') ? 0 : ((c2<<8) | *s2++) );
+
+            if (c1 != c2)
+                return( (c1 > c2) ? 1 : -1);
+
+            if (c1 == 0)
+                return(0);
+        }
+
+        return(0);
+}
+
+extern "C" int (__cdecl _mbsncmp)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsncmp_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22d8a894792c9157d58108b9376c71de8b683efb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncoll.cpp	
@@ -0,0 +1,91 @@
+/***
+*mbsncol.c - Collate n characters of two MBCS strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Collate n characters of two MBCS strings
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <limits.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* _mbsncoll(s1, s2, n) - Collate n characters of two MBCS strings
+*
+*Purpose:
+*       Collates up to n charcters of two strings for lexical order.
+*       Strings are collated on a character basis, not a byte basis.
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to collate
+*       size_t n = maximum number of characters to collate
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsncoll_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        int ret;
+        size_t bcnt1, bcnt2;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (n == 0)
+            return 0;
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(n <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strncoll_l((const char *)s1, (const char *)s2, n, plocinfo);
+
+        bcnt1 = _mbsnbcnt_l(s1, n, _loc_update.GetLocaleT());
+        bcnt2 = _mbsnbcnt_l(s2, n, _loc_update.GetLocaleT());
+
+        if ( 0 == (ret = __acrt_CompareStringA(
+                        _loc_update.GetLocaleT(),
+                        _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                        SORT_STRINGSORT,
+                        (const char *)s1,
+                        (int)bcnt1,
+                        (char *)s2,
+                        (int)bcnt2,
+                        _loc_update.GetLocaleT()->mbcinfo->mbcodepage )) )
+        {
+            errno = EINVAL;
+            return _NLSCMPERROR;
+        }
+
+        return ret - 2;
+
+}
+
+extern "C" int (__cdecl _mbsncoll)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsncoll_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..01f649c604c689d235e81a2cd4fd421730968ea3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy.cpp	
@@ -0,0 +1,96 @@
+/***
+*mbsncpy.c - Copy one string to another, n chars only (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another, n chars only (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_INCORRECT_VALIDATION __WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26014 26018
+
+/***
+* _mbsncpy - Copy one string to another, n chars only (MBCS)
+*
+*Purpose:
+*       Copies exactly cnt character from src to dst.  If strlen(src) < cnt, the
+*       remaining character are padded with null bytes.  If strlen >= cnt, no
+*       terminating null byte is added.  2-byte MBCS characters are handled
+*       correctly.
+*
+*Entry:
+*       unsigned char *dst = destination for copy
+*       unsigned char *src = source for copy
+*       int cnt = number of characters to copy
+*
+*Exit:
+*       returns dst = destination of copy
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+#pragma warning(suppress:6101) // Returning uninitialized memory '*dst'.  A successful path through the function does not set the named _Out_ parameter.
+extern "C" unsigned char * __cdecl _mbsncpy_l(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *start = dst;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(dst != nullptr || cnt == 0, EINVAL, nullptr);
+        _VALIDATE_RETURN(src != nullptr || cnt == 0, EINVAL, nullptr);
+
+        _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+#pragma warning(suppress:__WARNING_BANNED_API_USAGE)
+            return (unsigned char *)strncpy((char *)dst, (const char *)src, cnt);
+        _END_SECURE_CRT_DEPRECATION_DISABLE
+
+        while (cnt) {
+
+            cnt--;
+            if ( _ismbblead_l(*src, _loc_update.GetLocaleT()) ) {
+                *dst++ = *src++;
+                if ((*dst++ = *src++) == '\0') {
+                    dst[-2] = '\0';
+                    break;
+                }
+            }
+            else
+                if ((*dst++ = *src++) == '\0')
+                    break;
+
+        }
+
+        /* pad with nulls as needed */
+
+        while (cnt--)
+            *dst++ = '\0';
+
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036 REVIEW annotation mistake?
+        return start;
+}
+extern "C" unsigned char * (__cdecl _mbsncpy)(
+        unsigned char *dst,
+        const unsigned char *src,
+        size_t cnt
+        )
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsncpy_l(dst, src, cnt, nullptr);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3886c9672739834efe30af139ecd7dff8dbfe36a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbsncpy_s.c - Copy one string to another, n chars only (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another, n chars only (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbsncpy_s, unsigned char *, size_t, const unsigned char *, size_t)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s.inl b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2d422a7c4c6207cc4578e07660c142f8a5c6cbc9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s.inl	
@@ -0,0 +1,208 @@
+/***
+*mbsncpy_s.inl - general implementation of _mbsncpy_s and _mbsnbcpy_s
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This file contains the general algorithm for _mbsncpy_s and _mbsnbcpy_s.
+*
+*       _COUNT_IN_BYTES defined to 1 implements _mbsnbcpy_s
+*       _COUNT_IN_BYTES defined to 0 implements _mbsncpy_s
+*
+****/
+
+errno_t __cdecl _FUNC_NAME(unsigned char *_Dst, size_t _SizeInBytes, const unsigned char *_Src, size_t _COUNT, _LOCALE_ARG_DECL)
+{
+    unsigned char *p;
+    size_t available;
+    BOOL fFoundInvalidMBC;
+    BOOL fIsLeadPrefix;
+
+    fFoundInvalidMBC = FALSE;
+
+    if (_COUNT == 0 && _Dst == nullptr && _SizeInBytes == 0)
+    {
+        /* this case is allowed; nothing to do */
+        _RETURN_NO_ERROR;
+    }
+
+    /* validation section */
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+    if (_COUNT == 0)
+    {
+        /* notice that the source string pointer can be NULL in this case */
+#pragma prefast(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) /* 26015 */
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_NO_ERROR;
+    }
+    _VALIDATE_POINTER_RESET_STRING(_Src, _Dst, _SizeInBytes);
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return strncpy_s((char *)_Dst, _SizeInBytes, (const char *)_Src, _COUNT);
+    }
+
+    p = _Dst;
+    available = _SizeInBytes;
+    if (_COUNT == _TRUNCATE)
+    {
+        while ((*p++ = *_Src++) != 0 && --available > 0)
+        {
+        }
+
+        /*
+         * loop terminates with either:
+         * - src, p pointing 1 byte past null, avail includes the null
+         * - available == 0, p points 1 past end of dst buffer
+         */
+    }
+    else
+    {
+#if _COUNT_IN_BYTES
+        while ((*p++ = *_Src++) != 0 && --available > 0 && --_COUNT > 0)
+        {
+        }
+
+        /*
+         * loop terminates with either:
+         * - p points 1 byte past null, avail includes null, count includes null
+         * - available == 0, p points 1 past end of dst buffer (inaccessible)
+         * - count == 0, p points 1 past last written byte, space available in dst buffer
+         *
+         * always p[-1] is written.
+         * sometimes p[-1] is null.
+         */
+#else  /* _COUNT_IN_BYTES */
+
+        /* at this point, avail count be 1. */
+
+        /* Need to track lead-byte context in order to track character count. */
+        do
+        {
+            if (_ISMBBLEAD(*_Src))
+            {
+                if (_Src[1] == 0)
+                {
+                    /*
+                     * Invalid MBC, write null to dst string, we are finished
+                     * copying. We know that available is >= 1, so there is
+                     * room for the null termination. If we decrement available
+                     * then we will incorrectly report BUFFER_TOO_SMALL.
+                     */
+
+                    *p++ = 0;
+                    fFoundInvalidMBC = TRUE;
+                    break;
+                }
+                if (available <= 2)
+                {
+                    /* not enough space for a dbc and null */
+                    available = 0;
+                    break;
+                }
+                *p++ = *_Src++;
+                *p++ = *_Src++;
+                available -= 2;
+            }
+            else
+            {
+                if ((*p++ = *_Src++) == 0 || --available == 0)
+                {
+                    break;
+                }
+            }
+        }
+        while (--_COUNT > 0);
+#endif  /* _COUNT_IN_BYTES */
+
+        /* If count == 0 then at least one byte was copied and available is still > 0 */
+        if (_COUNT == 0)
+        {
+            *p++ = 0;
+            /* Note that available is not decremented here. */
+        }
+    }
+
+    if (available == 0)
+    {
+#if _COUNT_IN_BYTES
+        /*
+         * For COUNT_IN_BYTES, the above loop copied at least one byte so src,p point
+         * past a written byte.
+         */
+
+        if (*_Src == 0 || _COUNT == 1)
+        {
+            fIsLeadPrefix = FALSE;
+            _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst, &p[-1]);
+            if (fIsLeadPrefix)
+            {
+                /* the source string ended with a lead byte: we remove it */
+                p[-1] = 0;
+                _RETURN_MBCS_ERROR;
+            }
+        }
+#endif  /* _COUNT_IN_BYTES */
+
+        if (_COUNT == _TRUNCATE)
+        {
+            if (fFoundInvalidMBC)
+            {
+                _SET_MBCS_ERROR;
+            }
+
+            if (_SizeInBytes > 1)
+            {
+                fIsLeadPrefix = FALSE;
+                /* Check if 2nd to last copied byte acted as a lead.
+                 * Do not set mbcs error because we are truncating.
+                 */
+                _ISMBBLEADPREFIX(fIsLeadPrefix,_Dst,&_Dst[_SizeInBytes - 2]);
+                if (fIsLeadPrefix)
+                {
+                    _Dst[_SizeInBytes - 2] = 0;
+                    _FILL_BYTE(_Dst[_SizeInBytes - 1]);
+                    _RETURN_TRUNCATE;
+                }
+            }
+
+            _Dst[_SizeInBytes - 1] = 0;
+            _RETURN_TRUNCATE;
+        }
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_BUFFER_TOO_SMALL(_Dst, _SizeInBytes);
+    }
+
+#if _COUNT_IN_BYTES
+    /*
+     * COUNT_IN_BYTES copy loop doesn't track lead-byte context, so can't detect
+     * invalid mbc. Detect them here.
+
+     * available < _SizeInBytes means that at least one byte was copied so p is >= &dstBuffer[1]
+     */
+
+    if ((p - _Dst) >= 2)
+    {
+        _ISMBBLEADPREFIX(fIsLeadPrefix, _Dst,&p[-2]);
+        if (fIsLeadPrefix)
+        {
+            /* the source string ended with a lead byte: we remove it */
+            p[-2] = 0;
+            available++;
+            fFoundInvalidMBC = TRUE;
+        }
+    }
+#endif  /* _COUNT_IN_BYTES */
+
+    _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+
+    if (fFoundInvalidMBC)
+    {
+        _RETURN_MBCS_ERROR;
+    }
+
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) /* 26036 REVIEW TODO test _mbsnbcpy_s_l */
+    _RETURN_NO_ERROR;
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..553f19484d4d043d9d4f214c477d810c6a86e246
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsncpy_s_l.cpp	
@@ -0,0 +1,21 @@
+/***
+*mbsncpy_s_l.c - Copy one string to another, n chars only (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Copy one string to another, n chars only (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_securecrt.h>
+#include <mbstring.h>
+
+#define _FUNC_NAME _mbsncpy_s_l
+#define _COUNT _CountInChars
+#define _COUNT_IN_BYTES 0
+
+#include "mbsncpy_s.inl"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnextc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnextc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c6ff65001c08f8f40580945b181042c5ee99463
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnextc.cpp	
@@ -0,0 +1,64 @@
+/***
+*mbsnextc.c - Get the next character in an MBCS string.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       To return the value of the next character in an MBCS string.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stdlib.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*_mbsnextc:  Returns the next character in a string.
+*
+*Purpose:
+*       To return the value of the next character in an MBCS string.
+*       Does not advance pointer to the next character.
+*
+*Entry:
+*       unsigned char *s = string
+*
+*Exit:
+*       unsigned int next = next character.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbsnextc_l(
+        const unsigned char *s,
+        _locale_t plocinfo
+        )
+{
+        unsigned int  next = 0;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(s != nullptr, EINVAL, 0);
+
+        /* don't skip forward 2 if the leadbyte is followed by EOS (dud string)
+           also don't assert as we are too low-level
+        */
+        if ( _ismbblead_l(*s, _loc_update.GetLocaleT()) && s[1]!='\0')
+            next = ((unsigned int) *s++) << 8;
+
+        next += (unsigned int) *s;
+
+        return(next);
+}
+extern "C" unsigned int (__cdecl _mbsnextc)(
+        const unsigned char *s
+        )
+{
+    return _mbsnextc_l(s, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnicmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnicmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6b954be44f983ced30efa93e65dd9fe9a12c0bb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnicmp.cpp	
@@ -0,0 +1,115 @@
+/***
+*mbsnicmp.c - Compare n characters of strings, ignoring case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Compare n characters of strings, ignoring case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* _mbsnicmp - Compare n characters of strings, ignoring case (MBCS)
+*
+*Purpose:
+*       Compares up to n charcters of two strings for ordinal order.
+*       Strings are compared on a character basis, not a byte basis.
+*       Case of characters is not considered.
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to compare
+*       size_t n = maximum number of characters to compare
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsnicmp_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        unsigned short c1, c2;
+
+        if (n==0)
+            return(0);
+
+        _LocaleUpdate _loc_update(plocinfo);
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strnicmp((const char *)s1, (const char *)s2, n);
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        while (n--) {
+
+            c1 = *s1++;
+            if ( _ismbblead_l(c1, _loc_update.GetLocaleT()) ) {
+                if (*s1 == '\0')
+                    c1 = 0;
+                else {
+                    c1 = ((c1<<8) | *s1++);
+
+                    if ( ((c1 >= _MBUPPERLOW1_MT(_loc_update.GetLocaleT())) &&
+                          (c1 <= _MBUPPERHIGH1_MT(_loc_update.GetLocaleT()))) )
+                        c1 += _MBCASEDIFF1_MT(_loc_update.GetLocaleT());
+                    else if ( ((c1 >= _MBUPPERLOW2_MT(_loc_update.GetLocaleT())) &&
+                               (c1 <= _MBUPPERHIGH2_MT(_loc_update.GetLocaleT()))) )
+                        c1 += _MBCASEDIFF2_MT(_loc_update.GetLocaleT());
+                }
+            }
+            else
+                c1 = _mbbtolower_l(c1, _loc_update.GetLocaleT());
+
+            c2 = *s2++;
+            if ( _ismbblead_l(c2, _loc_update.GetLocaleT()) ) {
+                if (*s2 == '\0')
+                    c2 = 0;
+                else {
+                    c2 = ((c2<<8) | *s2++);
+                    if ( ((c2 >= _MBUPPERLOW1_MT(_loc_update.GetLocaleT())) &&
+                          (c2 <= _MBUPPERHIGH1_MT(_loc_update.GetLocaleT()))) )
+                        c2 += _MBCASEDIFF1_MT(_loc_update.GetLocaleT());
+                    else if ( ((c2 >= _MBUPPERLOW2_MT(_loc_update.GetLocaleT())) &&
+                               (c2 <= _MBUPPERHIGH2_MT(_loc_update.GetLocaleT()))) )
+                        c2 += _MBCASEDIFF2_MT(_loc_update.GetLocaleT());
+                }
+            }
+            else
+                c2 = _mbbtolower_l(c2, _loc_update.GetLocaleT());
+
+            if (c1 != c2)
+                return( (c1 > c2) ? 1 : -1 );
+
+            if (c1 == 0)
+                return(0);
+        }
+
+        return(0);
+}
+
+extern "C" int (__cdecl _mbsnicmp)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsnicmp_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnicol.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnicol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd36d49c5dbd0629910a3524cdf18e189bc8d3be
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnicol.cpp	
@@ -0,0 +1,93 @@
+/***
+*mbsnicol.c - Collate n characters of strings, ignoring case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Collate n characters of strings, ignoring case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <limits.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+* _mbsnicoll - Collate n characters of strings, ignoring case (MBCS)
+*
+*Purpose:
+*       Collates up to n charcters of two strings for lexical order.
+*       Strings are collated on a character basis, not a byte basis.
+*       Case of characters is not considered.
+*
+*Entry:
+*       unsigned char *s1, *s2 = strings to collate
+*       size_t n = maximum number of characters to collate
+*
+*Exit:
+*       Returns <0 if s1 < s2
+*       Returns  0 if s1 == s2
+*       Returns >0 if s1 > s2
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _mbsnicoll_l(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n,
+        _locale_t plocinfo
+        )
+{
+        int ret;
+        size_t bcnt1, bcnt2;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (n == 0)
+            return 0;
+
+        /* validation section */
+        _VALIDATE_RETURN(s1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(s2 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(n <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return _strnicoll_l((const char *)s1, (const char *)s2, n, plocinfo);
+
+        bcnt1 = _mbsnbcnt_l(s1, n, _loc_update.GetLocaleT());
+        bcnt2 = _mbsnbcnt_l(s2, n, _loc_update.GetLocaleT());
+
+        if ( 0 == (ret = __acrt_CompareStringA(
+                        _loc_update.GetLocaleT(),
+                        _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                        SORT_STRINGSORT | NORM_IGNORECASE,
+                        (const char *)s1,
+                        (int)bcnt1,
+                        (char *)s2,
+                        (int)bcnt2,
+                        _loc_update.GetLocaleT()->mbcinfo->mbcodepage )) )
+        {
+            errno = EINVAL;
+            return _NLSCMPERROR;
+        }
+
+        return ret - 2;
+
+}
+
+extern "C" int (__cdecl _mbsnicoll)(
+        const unsigned char *s1,
+        const unsigned char *s2,
+        size_t n
+        )
+{
+    return _mbsnicoll_l(s1, s2, n, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsninc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsninc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1ba7adb7017e3d7cc3b2cb6006582a2cbb170e3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsninc.cpp	
@@ -0,0 +1,56 @@
+/***
+*mbsninc.c - Increment MBCS string pointer by specified char count.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Increment MBCS string pointer by specified char count.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <mbstring.h>
+#include <stddef.h>
+
+/***
+*_mbsninc - Increment MBCS string pointer by specified char count.
+*
+*Purpose:
+*       Increment the supplied string pointer by the specified number
+*       of characters.  MBCS characters are handled correctly.
+*
+*Entry:
+*       const unsigned char *string = pointer to string
+*       unsigned int ccnt = number of char to advance the pointer
+*
+*Exit:
+*       Returns pointer after advancing it.
+*       Returns pointer to end of string if string is not ccnt chars long.
+*       Returns nullptr is supplied pointer is nullptr.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsninc_l(
+        const unsigned char *string,
+        size_t ccnt,
+        _locale_t plocinfo
+        )
+{
+    if (string == nullptr)
+        return nullptr;
+
+    return const_cast<unsigned char*>(string) + (unsigned int)_mbsnbcnt_l(string, ccnt, plocinfo);
+}
+
+extern "C" unsigned char * (__cdecl _mbsninc)(
+        const unsigned char *string,
+        size_t ccnt
+        )
+{
+    return _mbsninc_l(string, ccnt, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2d5c258252fee1de6832c6aa91e5ca3e85c5e7e8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset.cpp	
@@ -0,0 +1,143 @@
+/***
+*mbsnset.c - Sets first n charcaters of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets first n charcaters of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+* _mbsnset - Sets first n charcaters of string to given character (MBCS)
+*
+*Purpose:
+*       Sets the first n characters of string to the supplied
+*       character value.  If the length of string is less than n,
+*       the length of string is used in place of n.  Handles
+*       MBCS chars correctly.
+*
+*       There are several factors that make this routine complicated:
+*               (1) The fill value may be 1 or 2 bytes long.
+*               (2) The fill operation may end by hitting the count value
+*               or by hitting the end of the string.
+*               (3) A null terminating char is NOT placed at the end of
+*               the string.
+*
+*       Cases to be careful of (both of these can occur at once):
+*               (1) Leaving an "orphaned" trail byte in the string (e.g.,
+*               overwriting a lead byte but not the corresponding trail byte).
+*               (2) Writing only the 1st byte of a 2-byte fill value because the
+*               end of string was encountered.
+*
+*Entry:
+*       unsigned char *string = string to modify
+*       unsigned int val = value to fill string with
+*       size_t count = count of characters to fill
+*
+*
+*Exit:
+*       Returns string = now filled with char val
+*
+*Uses:
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsnset_l(
+        unsigned char *string,
+        unsigned int val,
+        size_t count,
+        _locale_t plocinfo
+        )
+{
+        unsigned char  *start = string;
+        unsigned int leadbyte = 0;
+        unsigned char highval, lowval;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr || count == 0, EINVAL, nullptr);
+
+        /*
+         * leadbyte flag indicates if the last byte we overwrote was
+         * a lead byte or not.
+         */
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)_strnset((char *)string, val, count);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+
+        highval = static_cast<unsigned char>(val >> 8);
+        if (highval != 0)
+        {
+
+            /* double byte value */
+
+            lowval = (unsigned char)(val & 0x00ff);
+
+            if(lowval=='\0')
+            {
+                _ASSERTE(("invalid MBCS pair passed to mbsnset",0));
+
+                /* Ideally we would return nullptr here and signal an error
+                    condition. But since this function has no other
+                    error modes, there would be a good chance of crashing
+                    the caller. So instead we fill the string with spaces
+                    to ensure that no information leaks through
+                    unexpectedly. Anyway, we do set errno to EINVAL.
+                */
+                errno = EINVAL;
+                lowval=highval=' ';
+            }
+
+            while (count-- && *string) {
+                leadbyte = _ismbbtruelead_l(leadbyte, *string, _loc_update.GetLocaleT());
+                *string++ = highval;
+
+                if (*string) {
+                    leadbyte = _ismbbtruelead_l(leadbyte, *string, _loc_update.GetLocaleT());
+                    *string++ = lowval;
+                }
+                else
+                    /* overwrite orphaned highval byte */
+                    *(string-1) = ' ';
+            }
+        }
+
+        else {
+            /* single byte value */
+
+            while (count-- && *string) {
+                leadbyte = _ismbbtruelead_l(leadbyte, *string, _loc_update.GetLocaleT());
+                *string++ = (unsigned char)val;
+            }
+        }
+
+        /* overwrite orphaned trailing byte, if necessary */
+        if(leadbyte && *string)
+            *string = ' ';
+
+        return( start );
+}
+
+unsigned char * (__cdecl _mbsnset)(
+        unsigned char *string,
+        unsigned int val,
+        size_t count
+        )
+{
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsnset_l(string, val, count, nullptr);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dfc6dce091208c070c2b42e964c8e507b1105750
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s.cpp	
@@ -0,0 +1,17 @@
+/***
+*mbsnset_s.c - Sets first n characters of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets first n characters of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal.h>
+
+_REDIRECT_TO_L_VERSION_4(errno_t, _mbsnset_s, unsigned char*, size_t, unsigned int, size_t)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s.inl b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s.inl
new file mode 100644
index 0000000000000000000000000000000000000000..0f27cebf43f96828c5a711feb6f7b976513acf4f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s.inl	
@@ -0,0 +1,132 @@
+/***
+*mbsnset_s.inl - general implementation of _mbsnset_s and _mbsnbset_s
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This file contains the general algorithm for _mbsnset_s and _mbsnbset_s.
+*
+****/
+
+errno_t __cdecl _FUNC_NAME(unsigned char *_Dst, size_t _SizeInBytes, unsigned int _Value, size_t _COUNT, _LOCALE_ARG_DECL)
+{
+    int mbcs_error = 0;
+    unsigned char *p;
+    size_t available;
+    unsigned char highval, lowval;
+    int mblead = 0;
+
+    /* validation section */
+    if (_COUNT == 0 && _Dst == nullptr && _SizeInBytes == 0)
+    {
+        /* this case is allowed; nothing to do */
+        _RETURN_NO_ERROR;
+    }
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return _strnset_s((char *)_Dst, _SizeInBytes, (int)_Value, _COUNT);
+    }
+
+    p = _Dst;
+    available = _SizeInBytes;
+    highval = (unsigned char)(_Value >> 8);
+    lowval = (unsigned char)(_Value & 0x00ff);
+
+    /* ensure _Value is a valid mbchar */
+    if ((highval != 0 && (lowval == 0 || !_ISMBBLEAD(highval))) ||
+        (highval == 0 && _ISMBBLEAD(lowval)))
+    {
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_MBCS_ERROR;
+    }
+
+    if (highval != 0)
+    {
+#if _COUNT_IN_BYTES
+        /* if _COUNT is odd, make it even subtracting 1 */
+        /* divide _COUNT by 2 to have a count in chars instead of bytes */
+        if ((_COUNT & 1) == 1)
+        {
+            --_COUNT;
+            mbcs_error = 1;
+        }
+        _COUNT = _COUNT / 2;
+#endif  /* _COUNT_IN_BYTES */
+        while (*p != 0 && _COUNT > 0 && --available > 0)
+        {
+            if (p[1] == 0)
+            {
+                /* do not orphan leadbyte */
+                *p = 0;
+                ++available;
+                mbcs_error = 1;
+                break;
+            }
+            /* track the mblead status in the original string */
+            mblead = mblead ? 0 : _ISMBBLEAD(*p);
+            *p++ = highval;
+            if (--available == 0)
+            {
+                break;
+            }
+            mblead = mblead ? 0 : _ISMBBLEAD(*p);
+            *p++ = lowval;
+            --_COUNT;
+        }
+    }
+    else
+    {
+        while (*p != 0 && _COUNT > 0 && --available > 0)
+        {
+            /* track the mblead status in the original string */
+            mblead = mblead ? 0 : _ISMBBLEAD(*p);
+            *p++ = lowval;
+            --_COUNT;
+        }
+    }
+
+    /* if the last written byte overlapps a leadbyte,
+     * copy a space over the corresponding trailbyte */
+    if (_COUNT == 0 && mblead && *p != 0 && --available > 0)
+    {
+        mbcs_error = 1;
+        if (p[1] == 0)
+        {
+            /* special case: if the space would be followed by 0, just put a 0 */
+            *p = 0;
+            ++available;
+        }
+        else
+        {
+            *p++ = ' ';
+        }
+    }
+
+    if (_COUNT == 0)
+    {
+        /* ensure the string is null-terminated */
+        while (*p != 0 && --available > 0)
+        {
+            ++p;
+        }
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_DEST_NOT_NULL_TERMINATED(_Dst, _SizeInBytes);
+    }
+    _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+    if (mbcs_error)
+    {
+        _RETURN_MBCS_ERROR;
+    }
+    else
+    {
+        _RETURN_NO_ERROR;
+    }
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..00fc5f3cb26ed6b866bf9809bcc905f56cca1e67
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsnset_s_l.cpp	
@@ -0,0 +1,21 @@
+/***
+*mbsnset_s_l.c - Sets first n characters of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets first n characters of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+#define _FUNC_NAME _mbsnset_s_l
+#define _COUNT _CountInChars
+#define _COUNT_IN_BYTES 0
+
+#include "mbsnset_s.inl"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbspbrk.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbspbrk.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa67994eaa502f8fceb5ba8431626d9448e831fe
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbspbrk.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbspbrk.c - Find first string char in charset, pointer return (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Find first string char in charset, pointer return (MBCS)
+*       Shares common source file with mbscspn.c.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#define _RETURN_PTR
+#include "mbscspn.cpp"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsrchr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsrchr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c1467cadd5891c8fc42ba89be02373ec519578ed
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsrchr.cpp	
@@ -0,0 +1,83 @@
+/***
+*mbsrchr.c - Search for last occurence of character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Search for last occurence of character (MBCS)
+*
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+* _mbsrchr - Search for last occurence of character (MBCS)
+*
+*Purpose:
+*       Find the last occurrence of the specified character in
+*       the supplied string.  Handles MBCS chars/strings correctly.
+*
+*Entry:
+*       unsigned char *str = string to search in
+*       unsigned int c = character to search for
+*
+*Exit:
+*       returns pointer to last occurrence of c in str
+*       returns nullptr if c not found
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" _CONST_RETURN unsigned char * __cdecl _mbsrchr_l(
+        const unsigned char *str,
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        char *r = nullptr;
+        unsigned int cc;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(str != nullptr, EINVAL, 0);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (_CONST_RETURN unsigned char *)strrchr((const char *)str, c);
+
+        do {
+            cc = *str;
+            if ( _ismbblead_l(cc, _loc_update.GetLocaleT()) ) {
+                if(*++str) {
+                    if (c == ((cc<<8)|*str))
+                        r = (char *)str - 1;
+                }
+                else if(!r)
+                    /* return pointer to '\0' */
+                    r = (char *)str;
+            }
+            else if (c == cc)
+                r = (char *)str;
+        }
+        while (*str++);
+
+        return((_CONST_RETURN unsigned char *)r);
+}
+
+extern "C" _CONST_RETURN unsigned char * (__cdecl _mbsrchr)(
+        const unsigned char *str,
+        unsigned int c
+        )
+{
+    return _mbsrchr_l(str, c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsrev.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsrev.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed738783a712211e0982b7252c6d6e1b2e9b4d38
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsrev.cpp	
@@ -0,0 +1,108 @@
+/***
+*mbsrev.c - Reverse a string in place (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Reverse a string in place (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+* _mbsrev - Reverse a string in place (MBCS)
+*
+*Purpose:
+*       Reverses the order of characters in the string.  The terminating
+*       null character remains in place.  The order of MBCS characters
+*       is not changed.
+*
+*Entry:
+*       unsigned char *string = string to reverse
+*
+*Exit:
+*       returns string - now with reversed characters
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsrev_l(
+        unsigned char *string,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *start = string;
+        unsigned char *left  = string;
+        unsigned char c;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)_strrev((char *)string);
+
+
+        /* first go through and reverse the bytes in MBCS chars */
+        while ( *string ) {
+            if ( _ismbblead_l(*string++, _loc_update.GetLocaleT()) ) {
+                if ( *string ) {
+                    c = *string;
+                    *string = *(string - 1);
+                    *(string - 1) = c;
+                    string++;
+                }
+                else
+                {
+                    /*  second byte is EOS
+                        There is nothing really satisfying to do here. We have a string
+                        that ends in leadbyte,'\0'. Reversing this would lead to the leadbyte
+                        becoming falsely attached to the character before it:
+                        (XL0 -> LX0, X has suddenly become a trailbyte)
+
+                        So what we choose to do is assert and purge the dud byte from within the
+                        string.
+                    */
+                    errno = EINVAL;
+                    _ASSERTE(("Bad MBCS string passed into _mbsrev",0));
+
+                    /* String has at least moved once already, so this is safe */
+                    _ASSERTE(string>start);
+
+                    /* move back one to point at the dud leadbyte */
+                    --string;
+
+                    /* now truncate the string one byte earlier */
+                    *string='\0';
+
+                    break;
+                }
+            }
+        }
+
+        /* now reverse the whole string */
+        string--;
+        while ( left < string ) {
+            c = *left;
+            *left++ = *string;
+            *string-- = c;
+        }
+
+        return ( start );
+}
+
+extern "C" unsigned char * (__cdecl _mbsrev)(
+        unsigned char *string
+        )
+{
+    return _mbsrev_l(string, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5230f3a8aeb0a80b73636c8a5caa368b0e7111e2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset.cpp	
@@ -0,0 +1,110 @@
+/***
+*mbsset.c - Sets all charcaters of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Sets all charcaters of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+* mbsset - Sets all charcaters of string to given character (MBCS)
+*
+*Purpose:
+*       Sets all of characters in string (except the terminating '/0'
+*       character) equal to the supplied character.  Handles MBCS
+*       chars correctly.
+*
+*Entry:
+*       unsigned char *string = string to modify
+*       unsigned int val = value to fill string with
+*
+*Exit:
+*       returns string = now filled with the specified char
+*
+*Uses:
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbsset_l(
+        unsigned char *string,
+        unsigned int val,
+        _locale_t plocinfo
+        )
+{
+        unsigned char  *start = string;
+        unsigned char highval, lowval;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+                return (unsigned char *)_strset((char *)string, val);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+
+        highval = static_cast<unsigned char>(val >> 8);
+        if (highval != 0)
+        {
+                /* 2-byte value */
+
+                lowval = (unsigned char)(val & 0x00ff);
+
+                if(lowval=='\0')
+                {
+                    _ASSERTE(("invalid MBCS pair passed to mbsset",0));
+
+                    /* Ideally we would return nullptr here and signal an error
+                       condition. But since this function has no other
+                       error modes, there would be a good chance of crashing
+                       the caller. So instead we fill the string with spaces
+                       to ensure that no information leaks through
+                       unexpectedly. Anyway, we do set errno to EINVAL.
+                    */
+                    errno = EINVAL;
+                    lowval=highval=' ';
+                }
+
+                while (*string) {
+
+                        *string++ = highval;
+                        if (*string)
+                                *string++ = lowval;
+                        else
+                                /* don't orphan lead byte */
+                                string[-1] = ' ';
+                        }
+
+        }
+
+        else {
+                /* single byte value */
+
+                while (*string)
+                        *string++ = (unsigned char)val;
+        }
+
+        return(start);
+}
+
+extern "C" unsigned char * (__cdecl _mbsset)(
+        unsigned char *string,
+        unsigned int val
+        )
+{
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbsset_l(string, val, nullptr);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8968d11496eb4467c7bcc6394381aeda73cc72b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset_s.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbsset_s.c - Sets all charcaters of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets all charcaters of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+
+_REDIRECT_TO_L_VERSION_3(errno_t, _mbsset_s, unsigned char*, size_t, unsigned int)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset_s_l.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset_s_l.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..01e43e320d811cd174b643238e40ea7a3e9d9073
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsset_s_l.cpp	
@@ -0,0 +1,89 @@
+/***
+*mbsset_s_l.c - Sets all charcaters of string to given character (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Sets all charcaters of string to given character (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+errno_t __cdecl _mbsset_s_l(unsigned char *_Dst, size_t _SizeInBytes, unsigned int _Value, _LOCALE_ARG_DECL)
+{
+    int mbcs_error = 0;
+    unsigned char *p;
+    size_t available;
+    unsigned char highval, lowval;
+
+    /* validation section */
+    _VALIDATE_STRING(_Dst, _SizeInBytes);
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return _strset_s((char *)_Dst, _SizeInBytes, (int)_Value);
+    }
+
+    p = _Dst;
+    available = _SizeInBytes;
+    highval = (unsigned char)(_Value >> 8);
+    lowval = (unsigned char)(_Value & 0x00ff);
+
+    /* ensure _Value is a valid mbchar */
+    if ((highval != 0 && (lowval == 0 || !_ISMBBLEAD(highval))) ||
+        (highval == 0 && _ISMBBLEAD(lowval)))
+    {
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_MBCS_ERROR;
+    }
+
+    if (highval != 0)
+    {
+        while (*p != 0 && --available > 0)
+        {
+            if (p[1] == 0)
+            {
+                /* do not orphan leadbyte */
+                *p = 0;
+                ++available;
+                mbcs_error = 1;
+                break;
+            }
+            *p++ = highval;
+            if (--available == 0)
+            {
+                break;
+            }
+            *p++ = lowval;
+        }
+    }
+    else
+    {
+        while (*p != 0 && --available > 0)
+        {
+            *p++ = lowval;
+        }
+    }
+
+    if (available == 0)
+    {
+        _RESET_STRING(_Dst, _SizeInBytes);
+        _RETURN_DEST_NOT_NULL_TERMINATED(_Dst, _SizeInBytes);
+    }
+    _FILL_STRING(_Dst, _SizeInBytes, _SizeInBytes - available + 1);
+
+    if (mbcs_error)
+    {
+        _RETURN_MBCS_ERROR;
+    }
+    else
+    {
+        _RETURN_NO_ERROR;
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsspn.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsspn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f685cb2f6feaf4ccc15ae0ff5d3ec99d90e26410
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsspn.cpp	
@@ -0,0 +1,130 @@
+/***
+*mbsspn.c - Search for init substring of chars from control string (MBCS).
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Search for init substring of chars from control string (MBCS).
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+#include <string.h>
+
+/***
+*ifndef _RETURN_PTR
+* _mbsspn - Find first string char not in charset (MBCS)
+*else
+* _mbsspnp - Find first string char not in charset, return pointer (MBCS)
+*endif
+*
+*Purpose:
+*       Returns maximum leading segment of string consisting solely
+*       of characters from charset.  Handles MBCS characters correctly.
+*
+*Entry:
+*       unsigned char *string = string to search in
+*       unsigned char *charset = set of characters to scan over
+*
+*Exit:
+*
+*ifndef _RETURN_PTR
+*       Returns index of first char in string not in control.
+*       Returns 0, if string begins with a character not in charset.
+*else
+*       Returns pointer to first character not in charset.
+*       Returns nullptr if string consists entirely of characters from charset.
+*endif
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+#ifndef _RETURN_PTR
+extern "C" size_t __cdecl _mbsspn_l
+#else  /* _RETURN_PTR */
+extern "C" unsigned char * __cdecl _mbsspnp_l
+#endif  /* _RETURN_PTR */
+        (
+        const unsigned char *string,
+        const unsigned char *charset,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *p, *q;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+#ifndef _RETURN_PTR
+            return strspn((const char *)string, (const char *)charset);
+#else  /* _RETURN_PTR */
+        {
+            size_t retval;
+            retval = strspn((const char *)string, (const char *)charset);
+            return (unsigned char *)(*(string + retval) ? string + retval : nullptr);
+        }
+#endif  /* _RETURN_PTR */
+
+        /* validation section */
+#ifndef _RETURN_PTR
+        _VALIDATE_RETURN(string != nullptr, EINVAL, 0);
+        _VALIDATE_RETURN(charset != nullptr, EINVAL, 0);
+#else  /* _RETURN_PTR */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+        _VALIDATE_RETURN(charset != nullptr, EINVAL, nullptr);
+#endif  /* _RETURN_PTR */
+
+        /* loop through the string to be inspected */
+        for (q = (unsigned char *)string; *q; q++) {
+
+            /* loop through the charset */
+            for (p = (unsigned char *)charset; *p; p++) {
+                if ( _ismbblead_l(*p, _loc_update.GetLocaleT()) ) {
+                    if (((*p == *q) && (p[1] == q[1])) || p[1] == '\0')
+                        break;
+                    p++;
+                }
+                else
+                    if (*p == *q)
+                        break;
+            }
+
+            if (*p == '\0')         /* end of charset? */
+                break;              /* yes, no match on this char */
+
+            if ( _ismbblead_l(*q, _loc_update.GetLocaleT()) )
+                if (*++q == '\0')
+                    break;
+        }
+
+#ifndef _RETURN_PTR
+        return((size_t) (q - string));          /* index */
+#else  /* _RETURN_PTR */
+        return((*q) ? q : nullptr);        /* pointer */
+#endif  /* _RETURN_PTR */
+
+}
+
+#ifndef _RETURN_PTR
+extern "C" size_t (__cdecl _mbsspn)
+#else  /* _RETURN_PTR */
+extern "C" unsigned char * (__cdecl _mbsspnp)
+#endif  /* _RETURN_PTR */
+        (
+        const unsigned char *string,
+        const unsigned char *charset
+        )
+{
+#ifndef _RETURN_PTR
+        return _mbsspn_l(string, charset, nullptr);
+#else  /* _RETURN_PTR */
+        return _mbsspnp_l(string, charset, nullptr);
+#endif  /* _RETURN_PTR */
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsspnp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsspnp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c6401bc12845c5b5ca28171c9a3bbeccf687910
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsspnp.cpp	
@@ -0,0 +1,16 @@
+/***
+*mbsspnp.c - Find first string char in charset, pointer return (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Returns maximum leading segment of string consisting solely
+*       of characters from charset.  Handles MBCS characters correctly.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#define _RETURN_PTR
+#include "mbsspn.cpp"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsstr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsstr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7344a49238d922b13a1e0bbec6e3c5f3dfbc7530
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsstr.cpp	
@@ -0,0 +1,101 @@
+/***
+* mbsstr.c - Search for one MBCS string inside another
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Search for one MBCS string inside another
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+#include <string.h>
+
+/***
+* _mbsstr - Search for one MBCS string inside another
+*
+*Purpose:
+*       Find the first occurrence of str2 in str1.
+*
+*Entry:
+*       unsigned char *str1 = beginning of string
+*       unsigned char *str2 = string to search for
+*
+*Exit:
+*       Returns a pointer to the first occurrence of str2 in
+*       str1, or nullptr if str2 does not occur in str1
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" _CONST_RETURN unsigned char * __cdecl _mbsstr_l(
+        const unsigned char *str1,
+        const unsigned char *str2,
+        _locale_t plocinfo
+        )
+{
+        unsigned char *cp, *s1, *s2, *endp;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->ismbcodepage == 0)
+            return (unsigned char *)strstr((const char *)str1, (const char *)str2);
+
+        /* validation section */
+        _VALIDATE_RETURN(str2 != nullptr, EINVAL, 0);
+        if ( *str2 == '\0')
+            return (unsigned char *)str1;
+        _VALIDATE_RETURN(str1 != nullptr, EINVAL, 0);
+
+        cp = (unsigned char *) str1;
+        endp = (unsigned char *) (str1 + (strlen((const char *)str1) - strlen((const char *)str2)));
+
+        while (*cp && (cp <= endp))
+        {
+            s1 = cp;
+            s2 = (unsigned char *) str2;
+
+            /*
+             * MBCS: ok to ++ since doing equality comparison.
+             * [This depends on MBCS strings being "legal".]
+             */
+            while ( *s1 && *s2 && (*s1 == *s2) )
+                s1++, s2++;
+
+            if (!(*s2))
+                return(cp);     /* success! */
+
+            /*
+             * bump pointer to next char
+             */
+            if ( _ismbblead_l(*(cp++), _loc_update.GetLocaleT()) )
+            {
+                /*  don't move forward if we have leadbyte, EOS
+                    means dud string was passed in.
+                    Don't assert - too low level
+                */
+                if(*cp!='\0')
+                {
+                    cp++;
+                }
+            }
+        }
+
+        return(nullptr);
+
+}
+
+extern "C" _CONST_RETURN unsigned char * (__cdecl _mbsstr)(
+        const unsigned char *str1,
+        const unsigned char *str2
+        )
+{
+    return _mbsstr_l(str1, str2, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbstok.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbstok.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fdab7fee422e81ac6101003cc67688c0dbb2a03d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbstok.cpp	
@@ -0,0 +1,69 @@
+/***
+*mbstok.c - Break string into tokens (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Break string into tokens (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+#include <stddef.h>
+#include <string.h>
+
+/***
+* _mbstok - Break string into tokens (MBCS)
+*
+*Purpose:
+*       strtok considers the string to consist of a sequence of zero or more
+*       text tokens separated by spans of one or more control chars. the first
+*       call, with string specified, returns a pointer to the first char of the
+*       first token, and will write a null char into string immediately
+*       following the returned token. subsequent calls with zero for the first
+*       argument (string) will work thru the string until no tokens remain. the
+*       control string may be different from call to call. when no tokens remain
+*       in string a nullptr pointer is returned. remember the control chars with a
+*       bit map, one bit per ascii char. the null char is always a control char.
+*
+*       MBCS chars supported correctly.
+*
+*Entry:
+*       char *string = string to break into tokens.
+*       char *sepset = set of characters to use as seperators
+*
+*Exit:
+*       returns pointer to token, or nullptr if no more tokens
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" unsigned char * __cdecl _mbstok_l(
+    unsigned char*       const string,
+    unsigned char const* const sepset,
+    _locale_t            const locale
+    )
+{
+    return _mbstok_s_l(string, sepset, &__acrt_getptd()->_mbstok_token, locale);
+}
+
+extern "C" unsigned char * __cdecl _mbstok(
+        unsigned char * string,
+        const unsigned char * sepset
+        )
+{
+    /* We call the deprecated _mbstok_l (and not _mbstok_s_l) so that we keep one
+     * single nextoken in the single thread case, i.e. the nextoken declared as static
+     * inside _mbstok_l
+     */
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    return _mbstok_l(string, sepset, nullptr);
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbstok_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbstok_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..faef0fe9162c3b34aec697db35e16c046e3e3e90
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbstok_s.cpp	
@@ -0,0 +1,147 @@
+/***
+*mbstok_s.c - Break string into tokens (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Break string into tokens (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+
+unsigned char * __cdecl _mbstok_s_l(unsigned char *_String, const unsigned char *_Control, unsigned char **_Context, _LOCALE_ARG_DECL)
+{
+    unsigned char *token;
+    const unsigned char *ctl;
+    int dbc;
+
+    /* validation section */
+    _VALIDATE_POINTER_ERROR_RETURN(_Context, EINVAL, nullptr);
+    _VALIDATE_POINTER_ERROR_RETURN(_Control, EINVAL, nullptr);
+    _VALIDATE_CONDITION_ERROR_RETURN(_String != nullptr || *_Context != nullptr, EINVAL, nullptr);
+
+    _LOCALE_UPDATE;
+    if (_LOCALE_SHORTCUT_TEST)
+    {
+        return (unsigned char*)strtok_s((char *)_String, (const char *)_Control, (char **)_Context);
+    }
+
+    /* If string==nullptr, continue with previous string */
+    if (!_String)
+    {
+        _String = *_Context;
+    }
+
+    /* Find beginning of token (skip over leading delimiters). Note that
+    * there is no token iff this loop sets string to point to the terminal null. */
+    for ( ; *_String != 0; _String++)
+    {
+        for (ctl = _Control; *ctl != 0; ctl++)
+        {
+            if (_ISMBBLEAD(*ctl))
+            {
+                if (ctl[1] == 0)
+                {
+                    ctl++;
+                    _SET_MBCS_ERROR;
+                    break;
+                }
+                if (*ctl == *_String && ctl[1] == _String[1])
+                {
+                    break;
+                }
+                ctl++;
+            }
+            else
+            {
+                if (*ctl == *_String)
+                {
+                    break;
+                }
+            }
+        }
+        if (*ctl == 0)
+        {
+            break;
+        }
+        if (_ISMBBLEAD(*_String))
+        {
+            _String++;
+            if (*_String == 0)
+            {
+                _SET_MBCS_ERROR;
+                break;
+            }
+        }
+    }
+
+    token = _String;
+
+    /* Find the end of the token. If it is not the end of the string,
+    * put a null there. */
+    for ( ; *_String != 0; _String++)
+    {
+        for (ctl = _Control, dbc = 0; *ctl != 0; ctl++)
+        {
+            if (_ISMBBLEAD(*ctl))
+            {
+                if (ctl[1] == 0)
+                {
+                    ctl++;
+                    break;
+                }
+                if (ctl[0] == _String[0] && ctl[1] == _String[1])
+                {
+                    dbc = 1;
+                    break;
+                }
+                ctl++;
+            }
+            else
+            {
+                if (*ctl == *_String)
+                {
+                    break;
+                }
+            }
+        }
+        if (*ctl != 0)
+        {
+            *_String++ = 0;
+            if (dbc)
+            {
+                *_String++ = 0;
+            }
+            break;
+        }
+        if (_ISMBBLEAD(_String[0]))
+        {
+            if (_String[1] == 0)
+            {
+                *_String = 0;
+                break;
+            }
+            _String++;
+        }
+    }
+
+    /* Update the context */
+    *_Context = _String;
+
+    /* Determine if a token has been found. */
+    if (token == _String)
+    {
+        return nullptr;
+    }
+    else
+    {
+        return token;
+    }
+}
+
+_REDIRECT_TO_L_VERSION_3(unsigned char *, _mbstok_s, unsigned char *, const unsigned char *, unsigned char **)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsupr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsupr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4a19f2accbd3e89c1d054486267053a1b17f3a08
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbsupr.cpp	
@@ -0,0 +1,133 @@
+/***
+*mbsupr.c - Convert string upper case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Convert string upper case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_securecrt.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED)
+
+/***
+* _mbsupr - Convert string upper case (MBCS)
+*
+*Purpose:
+*       Converts all the lower case characters in a string
+*       to upper case in place.   Handles MBCS chars correctly.
+*
+*Entry:
+*       unsigned char *string = pointer to string
+*
+*Exit:
+*       Returns a pointer to the input string.
+*       Returns nullptr on error.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" errno_t __cdecl _mbsupr_s_l(
+        unsigned char *string,
+        size_t sizeInBytes,
+        _locale_t plocinfo
+        )
+{
+        size_t stringlen;
+
+        /* validation section */
+        _VALIDATE_RETURN_ERRCODE((string != nullptr && sizeInBytes > 0) || (string == nullptr && sizeInBytes == 0), EINVAL);
+
+        if (string == nullptr)
+        {
+            /* nothing to do */
+            return 0;
+        }
+
+        stringlen = strnlen((char *)string, sizeInBytes);
+        if (stringlen >= sizeInBytes)
+        {
+            _RESET_STRING(string, sizeInBytes);
+            _RETURN_DEST_NOT_NULL_TERMINATED(string, sizeInBytes);
+        }
+        _FILL_STRING(string, sizeInBytes, stringlen + 1);
+
+        unsigned char *cp, *dst;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        for (cp = string, dst = string; *cp; ++cp)
+        {
+            if ( _ismbblead_l(*cp, _loc_update.GetLocaleT()) )
+            {
+
+
+                int retval;
+                unsigned char ret[4];
+
+                if ( (retval = __acrt_LCMapStringA(
+                                _loc_update.GetLocaleT(),
+                                _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                                LCMAP_UPPERCASE,
+                                (const char *)cp,
+                                2,
+                                (char *)ret,
+                                2,
+                                _loc_update.GetLocaleT()->mbcinfo->mbcodepage,
+                                TRUE )) == 0 )
+                {
+                    errno = EILSEQ;
+                    _RESET_STRING(string, sizeInBytes);
+                    return errno;
+                }
+
+                *(dst++) = ret[0];
+                ++cp;
+                if (retval > 1)
+                {
+                    *(dst++) = ret[1];
+                }
+
+
+            }
+            else
+                /* single byte, macro version */
+                *(dst++) = (unsigned char) _mbbtoupper_l(*cp, _loc_update.GetLocaleT());
+        }
+        /* null terminate the string */
+        *dst = '\0';
+
+        return 0;
+}
+
+extern "C" errno_t (__cdecl _mbsupr_s)(
+        unsigned char *string,
+        size_t sizeInBytes
+        )
+{
+    return _mbsupr_s_l(string, sizeInBytes, nullptr);
+}
+
+extern "C" unsigned char * (__cdecl _mbsupr_l)(
+        unsigned char *string,
+        _locale_t plocinfo
+        )
+{
+    return (_mbsupr_s_l(string, (string == nullptr ? 0 : (size_t)-1), plocinfo) == 0 ? string : nullptr);
+}
+
+extern "C" unsigned char * (__cdecl _mbsupr)(
+        unsigned char *string
+        )
+{
+    return (_mbsupr_s_l(string, (string == nullptr ? 0 : (size_t)-1), nullptr) == 0 ? string : nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtohira.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtohira.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..474924b90c60e2d42b5fbebe5334de48fbd48f65
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtohira.cpp	
@@ -0,0 +1,51 @@
+/***
+*mbtohira.c - Convert character from katakana to hiragana (Japanese).
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _jtohira() - convert character to hiragana.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+*unsigned int _mbctohira(c) - Converts character to hiragana.
+*
+*Purpose:
+*       Converts the character c from katakana to hiragana, if possible.
+*
+*Entry:
+*       unsigned int c - Character to convert.
+*
+*Exit:
+*       Returns the converted character.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbctohira_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        if (_ismbckata_l(c, plocinfo) && c <= 0x8393) {
+                if (c < 0x837f)
+                        c -= 0xa1;
+                else
+                        c -= 0xa2;
+        }
+        return(c);
+}
+
+extern "C" unsigned int __cdecl _mbctohira(unsigned int c)
+{
+    return _mbctohira_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtokata.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtokata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..20743a299b81431f262c8af1c19cabc10a504be3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtokata.cpp	
@@ -0,0 +1,52 @@
+/***
+*mbtokata.c - Converts character to katakana.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Converts a character from hiragana to katakana.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+*unsigned short _mbctokata(c) - Converts character to katakana.
+*
+*Purpose:
+*       If the character c is hiragana, convert to katakana.
+*
+*Entry:
+*       unsigned int c - Character to convert.
+*
+*Exit:
+*       Returns converted character.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbctokata_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        if (_ismbchira_l(c, plocinfo)) {
+                c += 0xa1;
+                if (c >= 0x837f)
+                        c++;
+        }
+        return(c);
+}
+
+extern "C" unsigned int (__cdecl _mbctokata)(
+        unsigned int c
+        )
+{
+    return _mbctokata_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtolwr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtolwr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2969628e735ef717b67fbd4d8ffe17d5cab080fa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtolwr.cpp	
@@ -0,0 +1,85 @@
+/***
+*mbtolwr.c - Convert character to lower case (MBCS).
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Convert character to lower case (MBCS).
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+/***
+* _mbctolower - Convert character to lower case (MBCS)
+*
+*Purpose:
+*       If the given character is upper case, convert it to lower case.
+*       Handles MBCS characters correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to convert
+*
+*Exit:
+*       Returns converted character
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbctolower_l (
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        unsigned char val[2];
+        unsigned char ret[4];
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (c > 0x00FF)
+        {
+            val[0] = (c >> 8) & 0xFF;
+            val[1] = c & 0xFF;
+
+            if ( !_ismbblead_l(val[0], _loc_update.GetLocaleT()) )
+                return c;
+
+
+            if ( __acrt_LCMapStringA(
+                        _loc_update.GetLocaleT(),
+                        _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                        LCMAP_LOWERCASE,
+                        (const char *)val,
+                        2,
+                        (char *)ret,
+                        2,
+                        _loc_update.GetLocaleT()->mbcinfo->mbcodepage,
+                        TRUE ) == 0 )
+                return c;
+
+            c = ret[1];
+            c += ret[0] << 8;
+
+            return c;
+
+
+        }
+        else
+            return (unsigned int)_mbbtolower_l((int)c, _loc_update.GetLocaleT());
+}
+
+extern "C" unsigned int (__cdecl _mbctolower) (
+        unsigned int c
+        )
+{
+    return _mbctolower_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtoupr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtoupr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8a4b218efc44a3e4deef97434b7178c7e039fa80
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/mbtoupr.cpp	
@@ -0,0 +1,84 @@
+/***
+*mbtoupr.c - Convert character to upper case (MBCS)
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Convert character to upper case (MBCS)
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+* _mbctoupper - Convert character to upper case (MBCS)
+*
+*Purpose:
+*       If the given character is lower case, convert to upper case.
+*       Handles MBCS chars correctly.
+*
+*       Note:  Use test against 0x00FF instead of _ISLEADBYTE
+*       to ensure that we don't call SBCS routine with a two-byte
+*       value.
+*
+*Entry:
+*       unsigned int c = character to convert
+*
+*Exit:
+*       Returns converted character
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbctoupper_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        unsigned char val[2];
+        unsigned char ret[4];
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (c > 0x00FF)
+        {
+
+            val[0] = (c >> 8) & 0xFF;
+            val[1] = c & 0xFF;
+
+            if ( !_ismbblead_l(val[0], _loc_update.GetLocaleT()) )
+                return c;
+
+
+            if ( __acrt_LCMapStringA(
+                        _loc_update.GetLocaleT(),
+                        _loc_update.GetLocaleT()->mbcinfo->mblocalename,
+                        LCMAP_UPPERCASE,
+                        (const char *)val,
+                        2,
+                        (char *)ret,
+                        2,
+                        _loc_update.GetLocaleT()->mbcinfo->mbcodepage,
+                        TRUE ) == 0 )
+                return c;
+
+            c = ret[1];
+            c += ret[0] << 8;
+
+            return c;
+
+
+        }
+        else
+            return (unsigned int)_mbbtoupper_l((int)c, _loc_update.GetLocaleT());
+}
+unsigned int (__cdecl _mbctoupper)(
+        unsigned int c
+        )
+{
+    return _mbctoupper_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/tojisjms.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/tojisjms.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7729b9a471f933cca7e3f869aa0ad0e15d9b5c0f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/tojisjms.cpp	
@@ -0,0 +1,138 @@
+/***
+*tojisjms.c:  Converts JIS to JMS code, and JMS to JIS code.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Convert JIS code into Microsoft Kanji code, and vice versa.
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+/***
+*unsigned int _mbcjistojms(c) - Converts JIS code to Microsoft Kanji Code.
+*
+*Purpose:
+*       Convert JIS code to Microsoft Kanji code.
+*
+*Entry:
+*       unsigned int c - JIS code to be converted. First byte is the upper
+*                          8 bits, and second is the lower 8 bits.
+*
+*Exit:
+*       Returns related Microsoft Kanji Code. First byte is the upper 8 bits
+*       and second byte is the lower 8 bits.
+*
+*Exceptions:
+*       If c is out of range, _mbcjistojms returns zero.
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbcjistojms_l(
+        unsigned int c,
+        _locale_t plocinfo
+    )
+{
+        unsigned int h, l;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if (_loc_update.GetLocaleT()->mbcinfo->mbcodepage != _KANJI_CP)
+            return (c);
+
+        h = (c >> 8) & 0xff;
+        l = c & 0xff;
+        if (h < 0x21 || h > 0x7e || l < 0x21 || l > 0x7e)
+        {
+            errno = EILSEQ;
+            return 0;
+        }
+        if (h & 0x01) {    /* first byte is odd */
+            if (l <= 0x5f)
+                l += 0x1f;
+            else
+                l += 0x20;
+        }
+        else
+            l += 0x7e;
+
+        h = ((h - 0x21) >> 1) + 0x81;
+        if (h > 0x9f)
+            h += 0x40;
+        return (h << 8) | l;
+}
+extern "C" unsigned int (__cdecl _mbcjistojms)(
+    unsigned int c
+    )
+{
+    return _mbcjistojms_l(c, nullptr);
+}
+
+
+/***
+*unsigned int _mbcjmstojis(c) - Converts Microsoft Kanji code into JIS code.
+*
+*Purpose:
+*       To convert Microsoft Kanji code into JIS code.
+*
+*Entry:
+*       unsigned int c - Microsoft Kanji code to be converted. First byte is
+*                          the upper 8 bits, and the second is the lower 8 bits.
+*
+*Exit:
+*       Returns related JIS Code. First byte is the upper 8 bits and the second
+*       byte is the lower 8 bits. If c is out of range, return zero.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbcjmstojis_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+        unsigned int    h, l;
+        _LocaleUpdate _loc_update(plocinfo);
+
+        if ( _loc_update.GetLocaleT()->mbcinfo->mbcodepage != _KANJI_CP )
+            return (c);
+
+        h = (c >> 8) & 0xff;
+        l = c & 0xff;
+
+        /* make sure input is valid shift-JIS */
+        if ( (!(_ismbblead_l(h, _loc_update.GetLocaleT()))) || (!(_ismbbtrail_l(l, _loc_update.GetLocaleT()))) )
+        {
+            errno = EILSEQ;
+            return 0;
+        }
+
+        h -= (h >= 0xa0) ? 0xc1 : 0x81;
+        if(l >= 0x9f) {
+            c = (h << 9) + 0x2200;
+            c |= l - 0x7e;
+        } else {
+            c = (h << 9) + 0x2100;
+            c |= l - ((l <= 0x7e) ? 0x1f : 0x20);
+        }
+
+        /* not all shift-JIS maps to JIS, so make sure output is valid */
+        if ( (c>0x7E7E) || (c<0x2121) || ((c&0xFF)>0x7E) || ((c&0xFF)<0x21) )
+        {
+            errno = EILSEQ;
+            return 0;
+        }
+
+        return c;
+}
+extern "C" unsigned int (__cdecl _mbcjmstojis)(
+        unsigned int c
+        )
+{
+    return _mbcjmstojis_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/tombbmbc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/tombbmbc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a6d81d2cc123d391297b33224e14d2da33162887
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/mbstring/tombbmbc.cpp	
@@ -0,0 +1,329 @@
+/***
+*tombbmbc.c - convert 1-byte code to and from 2-byte code
+*
+*       Copyright (c) Microsoft Corporation.    All rights reserved.
+*
+*Purpose:
+*       _mbbtombc() - converts 1-byte code to corresponding 2-byte code
+*       _mbctombb() - converts 2-byte code to corresponding 1-byte code
+*
+*******************************************************************************/
+#ifndef _MBCS
+    #error This file should only be compiled with _MBCS defined
+#endif
+
+#include <corecrt_internal_mbstring.h>
+#include <locale.h>
+
+
+#define ASCLOW   0x20
+#define ASCHIGH  0x7e
+
+#define SBLOW   0xA1
+#define SBHIGH  0xDF
+
+#define MBLIMIT 0x8396
+
+static unsigned short const mbbtable[] = {
+        /*20*/  0x8140, 0x8149, 0x8168, 0x8194, 0x8190, 0x8193, 0x8195, 0x8166,
+                0x8169, 0x816a, 0x8196, 0x817b, 0x8143, 0x817c, 0x8144, 0x815e,
+        /*30*/  0x824f, 0x8250, 0x8251, 0x8252, 0x8253, 0x8254, 0x8255, 0x8256,
+                0x8257, 0x8258, 0x8146, 0x8147, 0x8183, 0x8181, 0x8184, 0x8148,
+        /*40*/  0x8197, 0x8260, 0x8261, 0x8262, 0x8263, 0x8264, 0x8265, 0x8266,
+                0x8267, 0x8268, 0x8269, 0x826a, 0x826b, 0x826c, 0x826d, 0x826e,
+        /*50*/  0x826f, 0x8270, 0x8271, 0x8272, 0x8273, 0x8274, 0x8275, 0x8276,
+                0x8277, 0x8278, 0x8279, 0x816d, 0x818f, 0x816e, 0x814f, 0x8151,
+        /*60*/  0x8165, 0x8281, 0x8282, 0x8283, 0x8284, 0x8285, 0x8286, 0x8287,
+                0x8288, 0x8289, 0x828a, 0x828b, 0x828c, 0x828d, 0x828e, 0x828f,
+        /*70*/  0x8290, 0x8291, 0x8292, 0x8293, 0x8294, 0x8295, 0x8296, 0x8297,
+                0x8298, 0x8299, 0x829a, 0x816f, 0x8162, 0x8170, 0x8150,
+};
+
+static struct   {
+    unsigned char   asc;
+    char            synonym;
+    unsigned short  mbccode;
+} const mbctable[] = {
+    //     ASCII Code | Synonym | KANJI Code
+//Katakana Table
+        {    0xA7,         1,       0x8340      },  //  'a'
+        {    0xB1,         1,       0x8341      },  //  'A'
+        {    0xA8,         1,       0x8342      },  //  'i'
+        {    0xB2,         1,       0x8343      },  //  'I'
+        {    0xA9,         1,       0x8344      },  //  'u'
+        {    0xB3,         1,       0x8345      },  //  'U'
+        {    0xAA,         1,       0x8346      },  //  'e'
+        {    0xB4,         1,       0x8347      },  //  'E'
+        {    0xAB,         1,       0x8348      },  //  'o'
+        {    0xB5,         1,       0x8349      },  //  'O'
+
+        {    0xB6,         2,       0x834A      },  //  'KA'
+        {    0xB7,         2,       0x834C      },  //  'KI'
+        {    0xB8,         2,       0x834E      },  //  'KU'
+        {    0xB9,         2,       0x8350      },  //  'KE'
+        {    0xBA,         2,       0x8352      },  //  'KO'
+
+        {    0xBB,         2,       0x8354      },  //  'SA'
+        {    0xBC,         2,       0x8356      },  //  'SI'
+        {    0xBD,         2,       0x8358      },  //  'SU'
+        {    0xBE,         2,       0x835A      },  //  'SE'
+        {    0xBF,         2,       0x835C      },  //  'SO'
+
+        {    0xC0,         2,       0x835E      },  //  'TA'
+        {    0xC1,         2,       0x8360      },  //  'CHI'
+        {    0xAF,         1,       0x8362      },  //  'tsu'
+        {    0xC2,         2,       0x8363      },  //  'TSU'
+        {    0xC3,         2,       0x8365      },  //  'TE''
+        {    0xC4,         2,       0x8367      },  //  'TO''
+
+        {    0xC5,         1,       0x8369      },  //  'NA'
+        {    0xC6,         1,       0x836A      },  //  'NI'
+        {    0xC7,         1,       0x836B      },  //  'NU'
+        {    0xC8,         1,       0x836C      },  //  'NE'
+        {    0xC9,         1,       0x836D      },  //  'NO'
+
+        {    0xCA,         3,       0x836E      },  //  'HA'
+        {    0xCB,         3,       0x8371      },  //  'HI'
+        {    0xCC,         3,       0x8374      },  //  'FU'
+        {    0xCD,         3,       0x8377      },  //  'HE'
+        {    0xCE,         3,       0x837A      },  //  'HO'
+
+        {    0xCF,         1,       0x837D      },  //  'MA'
+        {    0xD0,         1,       0x837E      },  //  'MI'
+        {    0xD1,         1,       0x8380      },  //  'MU'
+        {    0xD2,         1,       0x8381      },  //  'ME'
+        {    0xD3,         1,       0x8382      },  //  'MO'
+
+        {    0xAC,         1,       0x8383      },  //  'ya'
+        {    0xD4,         1,       0x8384      },  //  'YA'
+        {    0xAD,         1,       0x8385      },  //  'yu'
+        {    0xD5,         1,       0x8386      },  //  'YU'
+        {    0xAE,         1,       0x8387      },  //  'yo'
+        {    0xD6,         1,       0x8388      },  //  'YO'
+
+        {    0xD7,         1,       0x8389      },  //  'RA'
+        {    0xD8,         1,       0x838A      },  //  'RI'
+        {    0xD9,         1,       0x838B      },  //  'RU'
+        {    0xDA,         1,       0x838C      },  //  'RE'
+        {    0xDB,         1,       0x838D      },  //  'RO'
+
+        {    0xDC,         2,       0x838E      },  //  'WA'
+        {    0xB2,         1,       0x8390      },  //  'I'
+        {    0xB4,         1,       0x8391      },  //  'E'
+
+        {    0xA6,         1,       0x8392      },  //  'WO'
+        {    0xDD,         1,       0x8393      },  //  'N'
+
+        {    0xB3,         1,       0x8394      },  //  'U'
+        {    0xB6,         1,       0x8395      },  //  'KA'
+        {    0xB9,         1,       0x8396      },  //  'KE'
+
+// Hiragana Table
+        {    0xA7,         1,       0x829F      },  //  'a'
+        {    0xB1,         1,       0x82A0      },  //  'A'
+        {    0xA8,         1,       0x82A1      },  //  'i'
+        {    0xB2,         1,       0x82A2      },  //  'I'
+        {    0xA9,         1,       0x82A3      },  //  'u'
+        {    0xB3,         1,       0x82A4      },  //  'U'
+        {    0xAA,         1,       0x82A5      },  //  'e'
+        {    0xB4,         1,       0x82A6      },  //  'E'
+        {    0xAB,         1,       0x82A7      },  //  'o'
+        {    0xB5,         1,       0x82A8      },  //  'O'
+
+        {    0xB6,         2,       0x82A9      },  //  'KA'
+        {    0xB7,         2,       0x82AB      },  //  'KI'
+        {    0xB8,         2,       0x82AD      },  //  'KU'
+        {    0xB9,         2,       0x82AF      },  //  'KE'
+        {    0xBA,         2,       0x82B1      },  //  'KO'
+
+        {    0xBB,         2,       0x82B3      },  //  'SA'
+        {    0xBC,         2,       0x82B5      },  //  'SI'
+        {    0xBD,         2,       0x82B7      },  //  'SU'
+        {    0xBE,         2,       0x82B9      },  //  'SE'
+        {    0xBF,         2,       0x82BB      },  //  'SO'
+
+        {    0xC0,         2,       0x82BD      },  //  'TA'
+        {    0xC1,         2,       0x82BF      },  //  'CHI'
+        {    0xAF,         1,       0x82C1      },  //  'tsu'
+        {    0xC2,         2,       0x82C2      },  //  'TSU'
+        {    0xC3,         2,       0x82C4      },  //  'TE'
+        {    0xC4,         2,       0x82C6      },  //  'TO'
+
+        {    0xC5,         1,       0x82C8      },  //  'NA'
+        {    0xC6,         1,       0x82C9      },  //  'NI'
+        {    0xC7,         1,       0x82CA      },  //  'NU'
+        {    0xC8,         1,       0x82CB      },  //  'NE'
+        {    0xC9,         1,       0x82CC      },  //  'NO'
+
+        {    0xCA,         3,       0x82CD      },  //  'HA'
+        {    0xCB,         3,       0x82D0      },  //  'HI'
+        {    0xCC,         3,       0x82D3      },  //  'FU'
+        {    0xCD,         3,       0x82D6      },  //  'HE'
+        {    0xCE,         3,       0x82D9      },  //  'HO'
+
+        {    0xCF,         1,       0x82DC      },  //  'MA'
+        {    0xD0,         1,       0x82DD      },  //  'MI'
+        {    0xD1,         1,       0x82DE      },  //  'MU'
+        {    0xD2,         1,       0x82DF      },  //  'ME'
+        {    0xD3,         1,       0x82E0      },  //  'MO'
+
+        {    0xAC,         1,       0x82E1      },  //  'ya'
+        {    0xD4,         1,       0x82E2      },  //  'YA'
+        {    0xAD,         1,       0x82E3      },  //  'yu'
+        {    0xD5,         1,       0x82E4      },  //  'YU'
+        {    0xAE,         1,       0x82E5      },  //  'yo'
+        {    0xD6,         1,       0x82E6      },  //  'YO'
+
+        {    0xD7,         1,       0x82E7      },  //  'RA'
+        {    0xD8,         1,       0x82E8      },  //  'RI'
+        {    0xD9,         1,       0x82E9      },  //  'RU'
+        {    0xDA,         1,       0x82EA      },  //  'RE'
+        {    0xDB,         1,       0x82EB      },  //  'RO'
+
+        {    0xDC,         2,       0x82EC      },  //  'WA'
+        {    0xB2,         1,       0x82EE      },  //  'I'
+        {    0xB4,         1,       0x82EF      },  //  'E'
+
+        {    0xA6,         1,       0x82F0      },  //  'WO'
+        {    0xDD,         1,       0x82F1      },  //  'N'
+
+        {    0x20,         1,       0x8140      },  // ' '
+//      {    0xA0,         1,       0x8140      },  // ' '
+        {    0xA1,         1,       0x8142      },  //
+        {    0xA2,         1,       0x8175      },  //
+        {    0xA3,         1,       0x8176      },  //
+        {    0xA4,         1,       0x8141      },  //
+        {    0xA5,         1,       0x8145      },  //
+        {    0xB0,         1,       0x815b      },  //  '-'
+        {    0xDE,         1,       0x814a      },  //
+        {    0xDF,         1,       0x814b      },  //
+
+        {    0,            0,       0           }   // == End of Table
+
+};
+
+/***
+*unsigned int _mbbtombc(c) - convert mbbvalue to mbcvalue.
+*
+*Purpose:
+*       Converts mbbvalue (1-byte) to corresponding mbcvalue code (2-byte).
+*
+*Entry:
+*       unsigned int c - mbbvalue character code to be converted.
+*
+*Exit:
+*       Returns corresponding mbbvalue (2-byte).
+*
+*Exceptions:
+*       Returns c if corresponding 2-byte code does not exist.
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbbtombc_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+    int i;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    if (_loc_update.GetLocaleT()->mbcinfo->mbcodepage != _KANJI_CP)
+        return (c);
+
+    /* If c is in the ASCII range, then look up the corresponding value
+     * in the mbbtable. */
+
+    if (c >= ASCLOW && c <= ASCHIGH)
+        return (mbbtable[c-ASCLOW]);
+
+    /* Exception for KANJI */
+
+    if (c == 0xdc)
+        return( 0x838f );
+
+    /* If c is a Katakana character, lookup in mbctable. */
+
+    if (c >= SBLOW && c <= SBHIGH)
+    {
+        for(i = 0; mbctable[i].asc != 0; i++)
+        {
+            if ( c == (unsigned int)mbctable[i].asc ) {
+                c = (unsigned int)mbctable[i].mbccode ;
+                break;
+                    }
+        }
+    }
+
+        return(c);
+}
+
+extern "C" unsigned int (__cdecl _mbbtombc)(
+    unsigned int c
+    )
+{
+    return _mbbtombc_l(c, nullptr);
+}
+
+/***
+*unsigned int _mbctombb(c) - convert mbcvalue to mbbvalue.
+*
+*Purpose:
+*       Converts mbcvalue (2-byte) to corresponding mbbvalue (1-byte).
+*
+*Entry:
+*       unsigned int c - mbcvalue character code to convert.
+*
+*Exit:
+*       Returns corresponding mbbvalue (1-byte).
+*
+*Exceptions:
+*       Returns c if corresponding 1-byte code does not exist.
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _mbctombb_l(
+        unsigned int c,
+        _locale_t plocinfo
+        )
+{
+   int i;
+   int result;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    if (_loc_update.GetLocaleT()->mbcinfo->mbcodepage != _KANJI_CP)
+        return (c);
+
+   /* Check to see if c is in the ASCII range.  */
+
+    for (i = 0; i <= ASCHIGH - ASCLOW; i++)
+    {
+        if (c == (unsigned int)mbbtable[i])
+            return((unsigned int)i + ASCLOW);
+    }
+
+
+   /*  If c is a valid MBCS value, search the mbctable for value. */
+
+    if ( c <= MBLIMIT )
+    {
+        for (i = 0; mbctable[i].asc ; i++)
+        {
+            result = (int)c - (int)mbctable[i].mbccode;
+            if (result == 0)
+                return( (unsigned int)mbctable[i].asc );
+            else if (((c & 0xff00) == (unsigned int)(mbctable[i].mbccode & 0xff00))
+            && (result > 0)
+            && ((result - mbctable[i].synonym) < 0))
+                return( (unsigned int)mbctable[i].asc );
+        }
+    }
+
+    return(c);
+}
+
+extern "C" unsigned int (__cdecl _mbctombb)(
+    unsigned int c
+    )
+{
+    return _mbctombb_l(c, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/_strerr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/_strerr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8ca2c7273b999743d5662ffaebb047d0c333b2e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/_strerr.cpp	
@@ -0,0 +1,203 @@
+/***
+*_strerr.c - routine for indexing into system error list
+*
+*   Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*   Returns system error message index by errno; conforms to the
+*   XENIX standard, much compatibility with 1983 uniforum draft standard.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+/***
+*char *_strerror(message) - get system error message
+*
+*Purpose:
+*   builds an error message consisting of the users error message
+*   (the message parameter), followed by ": ", followed by the system
+*   error message (index through errno), followed by a newline.  If
+*   message is nullptr or a null string, returns a pointer to just
+*   the system error message.
+*
+*Entry:
+*   char *message - user's message to prefix system error message
+*
+*Exit:
+*   returns pointer to static memory containing error message.
+*   returns nullptr if malloc() fails in multi-thread versions.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static char*& __cdecl get_strerror_buffer(__acrt_ptd* const ptd, char) throw()
+{
+    return ptd->_strerror_buffer;
+}
+
+static wchar_t*& __cdecl get_strerror_buffer(__acrt_ptd* const ptd, wchar_t) throw()
+{
+    return ptd->_wcserror_buffer;
+}
+
+static errno_t __cdecl append_message(
+    _Inout_updates_z_(buffer_count) char* const buffer,
+    size_t                                const buffer_count,
+    char const*                           const message
+    ) throw()
+{
+    return strncat_s(buffer, buffer_count, message, buffer_count - strlen(buffer) - 2);
+}
+
+static errno_t __cdecl append_message(
+    _Inout_updates_z_(buffer_count) wchar_t* const buffer,
+    size_t                                   const buffer_count,
+    char const*                              const message
+    ) throw()
+{
+    size_t const buffer_length = wcslen(buffer);
+    return mbstowcs_s(
+        nullptr,
+        buffer + buffer_length,
+        buffer_count - buffer_length,
+        message,
+        buffer_count - buffer_length - 2);
+}
+
+template <typename Character>
+_Ret_z_
+_Success_(return != 0)
+static Character* __cdecl common_strerror(
+    Character const* const message
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    errno_t const original_errno_value = errno;
+
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (!ptd)
+        return nullptr;
+
+    Character*& buffer = get_strerror_buffer(ptd, Character());
+    if (!buffer)
+        buffer = _calloc_crt_t(Character, strerror_buffer_count).detach();
+
+    if (!buffer)
+        return nullptr;
+
+    buffer[0] = '\0';
+
+    // CRT_REFACTOR TODO AppCRT/DesktopCRT Dependencies
+    // (We should be using mbs* functions here).
+    if (message && message[0] != '\0')
+    {
+        Character const colon[] = { ':', ' ', '\0' };
+
+        // Leave room for the ": \n\0"
+        _ERRCHECK(traits::tcsncat_s(buffer, strerror_buffer_count, message, strerror_buffer_count - 4));
+        _ERRCHECK(traits::tcscat_s(buffer, strerror_buffer_count, colon));
+    }
+
+    char const* const system_message = _get_sys_err_msg(original_errno_value);
+    _ERRCHECK(append_message(buffer, strerror_buffer_count, system_message));
+
+    Character const newline[] = { '\n', '\0' };
+    _ERRCHECK(traits::tcscat_s(buffer, strerror_buffer_count, newline));
+
+    return buffer;
+}
+
+extern "C" char* __cdecl _strerror(char const* const message)
+{
+    return common_strerror(message);
+}
+
+extern "C" wchar_t* __cdecl __wcserror(wchar_t const* const message)
+{
+    return common_strerror(message);
+}
+
+
+
+/***
+*errno_t _strerror_s(buffer, sizeInTChars, message) - get system error message
+*
+*Purpose:
+*   builds an error message consisting of the users error message
+*   (the message parameter), followed by ": ", followed by the system
+*   error message (index through errno), followed by a newline.  If
+*   message is nullptr or a null string, returns a pointer to just
+*   the system error message.
+*
+*Entry:
+*   TCHAR * buffer - Destination buffer.
+*   size_t sizeInTChars - Size of the destination buffer.
+*   TCHAR * message - user's message to prefix system error message
+*
+*Exit:
+*   The error code.
+*
+*Exceptions:
+*   Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+size_t const minimum_message_length = 5;
+
+template <typename Character>
+static errno_t __cdecl common_strerror_s(
+    _Out_writes_z_(buffer_count)    Character*          const   buffer,
+                                    size_t              const   buffer_count,
+                                    Character const*    const   message
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    errno_t const original_errno_value = errno;
+
+    _VALIDATE_RETURN_ERRCODE(buffer != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(buffer_count > 0,  EINVAL);
+    buffer[0] = '\0';
+
+    if (message &&
+        message[0] != '\0' &&
+        traits::tcslen(message) < (buffer_count - 2 - minimum_message_length))
+    {
+        Character const colon[] = { ':', ' ', '\0' };
+        _ERRCHECK(traits::tcscpy_s(buffer, buffer_count, message));
+        _ERRCHECK(traits::tcscat_s(buffer, buffer_count, colon));
+    }
+
+    // Append the error message at the end of the buffer:
+    return traits::tcserror_s(
+        buffer       + traits::tcslen(buffer),
+        buffer_count - traits::tcslen(buffer),
+        original_errno_value);
+}
+
+extern "C" errno_t __cdecl _strerror_s(
+    char*       const buffer,
+    size_t      const buffer_count,
+    char const* const message
+    )
+{
+    return common_strerror_s(buffer, buffer_count, message);
+}
+
+extern "C" errno_t __cdecl __wcserror_s(
+    wchar_t*       const buffer,
+    size_t         const buffer_count,
+    wchar_t const* const message
+    )
+{
+    return common_strerror_s(buffer, buffer_count, message);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/chdir.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/chdir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73520877b4feab1fc5e564154b9cd6f6f8d2995f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/chdir.cpp	
@@ -0,0 +1,109 @@
+/***
+*chdir.c - change directory
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This file has the _chdir() function - change current directory.
+*
+*******************************************************************************/
+
+#include <direct.h>
+#include <corecrt_internal_traits.h>
+#include <corecrt_internal_win32_buffer.h>
+#include <malloc.h>
+#include <stdlib.h>
+
+/***
+*int _chdir(path) - change current directory
+*
+*Purpose:
+*       Changes the current working directory to that given in path.
+*
+*Entry:
+*       _TSCHAR *path - directory to change to
+*
+*Exit:
+*       returns 0 if successful,
+*       returns -1 and sets errno if unsuccessful
+*
+*Exceptions:
+*
+*******************************************************************************/
+template <typename Character>
+_Success_(return == 0)
+static int __cdecl set_cwd_environment_variable(_In_z_ Character const* const path) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    // If the path is a UNC name, no need to update:
+    if ((path[0] == '\\' || path[0] == '/') && path[0] == path[1])
+        return 0;
+
+#pragma warning(suppress:28931) // unused assignment of variable drive_letter
+    Character const drive_letter = static_cast<Character>(toupper(static_cast<char>(path[0])));
+    Character const name[] = { '=', drive_letter, ':', '\0' };
+
+    if (traits::set_environment_variable(name, path))
+        return 0;
+
+    __acrt_errno_map_os_error(GetLastError());
+    return -1;
+}
+
+
+
+template <typename Character>
+_Success_(return == 0)
+static int __cdecl common_chdir(_In_z_ Character const* const path) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_CLEAR_OSSERR_RETURN(path != nullptr, EINVAL, -1);
+
+    if (!traits::set_current_directory(path))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    // If the new current directory path is not a UNC path, we must update the
+    // OS environment variable specifying the current full current directory,
+    // build the environment variable string, and call SetEnvironmentVariable().
+    // We need to do this because the SetCurrentDirectory() API does not update
+    // the environment variables, and other functions (fullpath, spawn, etc.)
+    // need them to be set.
+    //
+    // If associated with a 'drive', the current directory should have the
+    // form of the example below:
+    //
+    //     D:\nt\private\mytests
+    //
+    // So that the environment variable should be of the form:
+    //
+    //     =D:=D:\nt\private\mytests
+
+    Character buffer_initial_storage[MAX_PATH + 1];
+    __crt_internal_win32_buffer<Character> current_directory_buffer(buffer_initial_storage);
+
+    errno_t const err = traits::get_current_directory(current_directory_buffer);
+
+    if (err != 0) {
+        // Appropriate error already set
+        return -1;
+    }
+
+    return set_cwd_environment_variable(current_directory_buffer.data());
+}
+
+
+
+extern "C" int __cdecl _chdir(char const* const path)
+{
+    return common_chdir(path);
+}
+
+extern "C" int __cdecl _wchdir(wchar_t const* const path)
+{
+    return common_chdir(path);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/crtmbox.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/crtmbox.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c3bdfda01ce182df16cae86cf6a94f0f1a79d90c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/crtmbox.cpp	
@@ -0,0 +1,94 @@
+/***
+*crtmbox.c - CRT MessageBoxA wrapper.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Wrap MessageBoxA.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+
+
+
+namespace
+{
+    template <typename Character>
+    struct message_box_arguments
+    {
+        Character const* _caption;
+        Character const* _text;
+        unsigned int     _type;
+        int              _result;
+    };
+}
+
+template <typename Character>
+static int __cdecl common_show_message_box(
+    Character const* const text,
+    Character const* const caption,
+    unsigned         const type
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    bool const debugger_attached = IsDebuggerPresent();
+    if (debugger_attached)
+    {
+        // Output the message to the attached debugger.  This is useful when
+        // remotely debugging.
+        if (text)
+        {
+            traits::output_debug_string(text);
+        }
+
+        // We do not want to display a message box if a debugger
+        // is already attached, unless it's a desktop app.
+        // Instead, let the caller know that we want to
+        // directly break into the debugger:
+        bool const is_desktop_app = __acrt_get_windowing_model_policy() == windowing_model_policy_hwnd;
+        if (!is_desktop_app)
+        {
+            return IDRETRY; // Retry = Break into the debugger
+        }
+    }
+
+    bool const show_ui = __acrt_get_developer_information_policy() == developer_information_policy_ui;
+    if (!show_ui || !__acrt_can_show_message_box())
+    {
+        // If we can't get the message box pointers (perhaps because running on CoreSys),
+        // just abort, unless a debugger is attached--then break into the debugger instead.
+        // The message string was already output to the debugger above.
+        return debugger_attached ? IDRETRY : IDABORT;
+    }
+
+    // If the current process isn't attached to a visible window station (e.g.
+    // a non-interactive service), then we need to set the MB_SERVICE_NOTIFICATION
+    // flag, otherwise the message box will be invisible, stalling the program.
+    if (!__acrt_is_interactive())
+    {
+        return traits::message_box(nullptr, text, caption, type | MB_SERVICE_NOTIFICATION);
+    }
+
+    return traits::message_box(__acrt_get_parent_window(), text, caption, type);
+}
+
+extern "C" int __cdecl __acrt_show_narrow_message_box(
+    char const* const text,
+    char const* const caption,
+    unsigned    const type
+    )
+{
+    return common_show_message_box(text, caption, type);
+}
+
+extern "C" int __cdecl __acrt_show_wide_message_box(
+    wchar_t const* const text,
+    wchar_t const* const caption,
+    unsigned       const type
+    )
+{
+    return common_show_message_box(text, caption, type);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/dbgrpt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/dbgrpt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..286921c5fdb06b85fa05de3e0b02eff764a39182
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/dbgrpt.cpp	
@@ -0,0 +1,467 @@
+/***
+*dbgrpt.c - Debug CRT Reporting Functions
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*
+*******************************************************************************/
+#ifndef _DEBUG
+    #error This file is supported only in debug builds
+#endif
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <intrin.h>
+#include <malloc.h>
+#include <minmax.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/*---------------------------------------------------------------------------
+ *
+ * Debug Reporting
+ *
+ --------------------------------------------------------------------------*/
+
+extern "C" extern _CRT_REPORT_HOOK _pfnReportHook;
+extern "C" extern __crt_report_hook_node<char>* _pReportHookList;
+extern "C" extern __crt_report_hook_node<wchar_t>* _pReportHookListW;
+
+static __crt_report_hook_node<char>*&    __cdecl get_report_hook_list(char)    throw() { return _pReportHookList;  }
+static __crt_report_hook_node<wchar_t>*& __cdecl get_report_hook_list(wchar_t) throw() { return _pReportHookListW; }
+
+static wchar_t const* const report_type_messages[_CRT_ERRCNT] =
+{
+    L"Warning",
+    L"Error",
+    L"Assertion Failed"
+};
+
+// Enclaves only support MODE_DEBUG for error output
+#ifndef _UCRT_ENCLAVE_BUILD
+
+static wchar_t const* __cdecl get_output_message_format(char) throw()
+{
+    return L"Debug %ls!\n\nProgram: %hs%ls%ls%hs%ls%hs%ls%hs%ls%ls%hs%ls\n\n(Press Retry to debug the application)\n";
+}
+
+static wchar_t const* __cdecl get_output_message_format(wchar_t) throw()
+{
+    return L"Debug %ls!\n\nProgram: %ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls%ls\n\n(Press Retry to debug the application)\n";
+}
+
+static wchar_t const* const more_info_string =
+    L"\n\nFor information on how your program can cause an assertion"
+    L"\nfailure, see the Visual C++ documentation on asserts.";
+
+_GENERATE_TCHAR_STRING_FUNCTIONS(program_name_unknown_text, "<program name unknown>")
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/***
+*_CRT_REPORT_HOOK _CrtSetReportHook2() - configure client report hook in list
+*
+*Purpose:
+*       Install or remove a client report hook from the report list.  Exists
+*       separately from _CrtSetReportHook because the older function doesn't
+*       work well in an environment where DLLs that are loaded and unloaded
+*       dynamically out of LIFO order want to install report hooks.
+*       This function exists in 2 forms - ANSI & UNICODE
+*
+*Entry:
+*       int mode - _CRT_RPTHOOK_INSTALL or _CRT_RPTHOOK_REMOVE
+*       _CRT_REPORT_HOOK pfnNewHook - report hook to install/remove/query
+*
+*Exit:
+*       Returns -1 if an error was encountered, with EINVAL or ENOMEM set,
+*       else returns the reference count of pfnNewHook after the call.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+template <typename Character, typename Hook>
+static int __cdecl common_set_report_hook(
+    int  const mode,
+    Hook const new_hook
+    ) throw()
+{
+    using node_type = __crt_report_hook_node<Character>;
+
+    _VALIDATE_RETURN(mode == _CRT_RPTHOOK_INSTALL || mode == _CRT_RPTHOOK_REMOVE, EINVAL, -1);
+    _VALIDATE_RETURN(new_hook != nullptr,                                         EINVAL, -1);
+
+    return __acrt_lock_and_call(__acrt_debug_lock, [&]
+    {
+        node_type*& hook_list = get_report_hook_list(Character());
+
+        node_type* p;
+        int ret = 0;
+
+        // Search for new hook function to see if it's already installed
+        for (p = hook_list; p != nullptr; p = p->next)
+            if (p->hook == new_hook)
+                break;
+
+        if (mode == _CRT_RPTHOOK_REMOVE)
+        {
+            // Remove request - free list node if refcount goes to zero
+            if (p != nullptr)
+            {
+                if ((ret = --p->refcount) == 0)
+                {
+                    if (p->next)
+                    {
+                        p->next->prev = p->prev;
+                    }
+                    if (p->prev)
+                    {
+                        p->prev->next = p->next;
+                    }
+                    else
+                    {
+                        hook_list = p->next;
+                    }
+
+                    _free_crt(p);
+                }
+            }
+            else
+            {
+                _ASSERTE(("The hook function is not in the list!", 0));
+                errno = EINVAL;
+                return -1;
+            }
+        }
+        else
+        {
+            // Insert request
+            if (p != nullptr)
+            {
+                // Hook function already registered, move to head of list
+                ret = ++p->refcount;
+                if (p != hook_list)
+                {
+                    if (p->next)
+                        p->next->prev = p->prev;
+                    p->prev->next = p->next;
+                    p->prev = nullptr;
+                    p->next = hook_list;
+                    hook_list->prev = p;
+                    hook_list = p;
+                }
+            }
+            else
+            {
+                // Hook function not already registered, insert new node
+                __crt_unique_heap_ptr<node_type> new_node(_calloc_crt_t(node_type, 1));
+                if (!new_node)
+                {
+                    ret = -1;
+                    errno = ENOMEM;
+                }
+                else
+                {
+                    new_node.get()->prev = nullptr;
+                    new_node.get()->next = hook_list;
+
+                    if (hook_list)
+                    {
+                        hook_list->prev = new_node.get();
+                    }
+
+                    ret = new_node.get()->refcount = 1;
+                    new_node.get()->hook = new_hook;
+                    hook_list = new_node.detach();
+                }
+            }
+        }
+
+        return ret;
+    });
+}
+
+extern "C" int __cdecl _CrtSetReportHook2(
+    int              const mode,
+    _CRT_REPORT_HOOK const new_hook
+    )
+{
+    return common_set_report_hook<char>(mode, new_hook);
+}
+
+extern "C" int __cdecl _CrtSetReportHookW2(
+    int               const mode,
+    _CRT_REPORT_HOOKW const new_hook
+    )
+{
+    return common_set_report_hook<wchar_t>(mode, new_hook);
+}
+
+#define MAXLINELEN 64
+
+/***
+*int _CrtDbgReport() - primary reporting function
+*
+*Purpose:
+*       Display a message window with the following format.
+*
+*       ================= Microsft Visual C++ Debug Library ================
+*
+*       {Warning! | Error! | Assertion Failed!}
+*
+*       Program: c:\test\mytest\foo.exe
+*       [Module: c:\test\mytest\bar.dll]
+*       [File: c:\test\mytest\bar.c]
+*       [Line: 69]
+*
+*       {<warning or error message> | Expression: <expression>}
+*
+*       [For information on how your program can cause an assertion
+*        failure, see the Visual C++ documentation on asserts]
+*
+*       (Press Retry to debug the application)
+*
+*       ===================================================================
+*
+*Entry:
+*       int             nRptType    - report type
+*       void *          returnAddress - return address of caller
+*       const TCHAR *    szFile      - file name
+*       int             nLine       - line number
+*       const TCHAR *    szModule    - module name
+*       const TCHAR *    szFormat    - format string
+*       ...                         - var args
+*
+*Exit:
+*       if (MessageBox)
+*       {
+*           Abort -> aborts
+*           Retry -> return TRUE
+*           Ignore-> return FALSE
+*       }
+*       else
+*           return FALSE
+*
+*Exceptions:
+*       If something goes wrong, we do not assert, but we return -1.
+*
+*******************************************************************************/
+extern "C" int __cdecl _CrtDbgReport(
+    int         const report_type,
+    char const* const file_name,
+    int         const line_number,
+    char const* const module_name,
+    char const* const format,
+    ...)
+{
+    va_list arglist;
+    va_start(arglist, format);
+    int const result = _VCrtDbgReportA(report_type, _ReturnAddress(), file_name, line_number, module_name, format, arglist);
+    va_end(arglist);
+    return result;
+}
+
+extern "C" int __cdecl _CrtDbgReportW(
+    int            const report_type,
+    wchar_t const* const file_name,
+    int            const line_number,
+    wchar_t const* const module_name,
+    wchar_t const* const format,
+    ...)
+{
+    va_list arglist;
+    va_start(arglist, format);
+    int const result = _VCrtDbgReportW(report_type, _ReturnAddress(), file_name, line_number, module_name, format, arglist);
+    va_end(arglist);
+    return result;
+}
+
+// Enclaves only support MODE_DEBUG for error output
+#if !defined _UCRT_ENCLAVE_BUILD
+
+/***
+*int __crtMessageWindow() - report to a message window
+*
+*Purpose:
+*       put report into message window, allow user to choose action to take
+*
+*Entry:
+*       int             nRptType      - report type
+*       const TCHAR *    szFile        - file name
+*       const TCHAR *    szLine        - line number
+*       const TCHAR *    szModule      - module name
+*       const TCHAR *    szUserMessage - user message
+*
+*Exit:
+*       if (MessageBox)
+*       {
+*           Abort -> aborts
+*           Retry -> return TRUE
+*           Ignore-> return FALSE
+*       }
+*       else
+*           return FALSE
+*
+*Exceptions:
+*       If something goes wrong, we do not assert, but we simply return -1,
+*       which will trigger the debugger automatically (the same as the user
+*       pressing the Retry button).
+*
+*******************************************************************************/
+template <typename Character>
+static int __cdecl common_message_window(
+    int              const report_type,
+    void*            const return_address,
+    Character const* const file_name,
+    Character const* const line_number,
+    Character const* const module_name,
+    Character const* const user_message
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    if (user_message == nullptr)
+    {
+        return 1;
+    }
+
+    HMODULE module = nullptr;
+    if (!GetModuleHandleExW(
+            GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+            static_cast<LPCWSTR>(return_address),
+            &module))
+    {
+        module = nullptr;
+    }
+    #ifdef CRTDLL
+    else if (module == reinterpret_cast<HMODULE>(&__ImageBase))
+    {
+        // If the message was reported from within the CRT DLL, report it as
+        // having come from the EXE instead:
+        module = nullptr;
+    }
+    #endif
+
+    Character program_name[MAX_PATH + 1]{};
+    if (!traits::get_module_file_name(module, program_name, static_cast<DWORD>(_countof(program_name))))
+    {
+        _ERRCHECK(traits::tcscpy_s(program_name, _countof(program_name), get_program_name_unknown_text(Character())));
+    }
+
+    // Shorten the program name:
+    size_t const program_name_length = traits::tcslen(program_name);
+    Character*   short_program_name  = program_name;
+    if (program_name_length > MAXLINELEN)
+    {
+        short_program_name += program_name_length - MAXLINELEN;
+        static_assert(MAXLINELEN > 3, "");
+#pragma warning(push)
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 26015
+        short_program_name[0] = '.';
+        short_program_name[1] = '.';
+        short_program_name[2] = '.';
+#pragma warning(pop)
+    }
+
+    // Shorten the module name:
+    size_t    const  module_name_length = module_name ? traits::tcslen(module_name) : 0;
+    Character const* short_module_name  = nullptr;
+    if (module_name && module_name_length > MAXLINELEN)
+    {
+        short_module_name = module_name + module_name_length - MAXLINELEN + 3;
+    }
+
+    static Character const empty_string[] = { '\0' };
+
+    wchar_t message_buffer[DBGRPT_MAX_MSG];
+    int const sprintf_result = _snwprintf_s(
+        message_buffer,
+        _countof(message_buffer),
+        _countof(message_buffer) - 1,
+
+        get_output_message_format(Character()),
+
+        report_type_messages[report_type],
+        short_program_name,
+        module_name ? L"\nModule: " : L"",
+        short_module_name ? L"..." : L"",
+        short_module_name ? short_module_name : (module_name ? module_name : empty_string),
+        file_name ? L"\nFile: " : L"",
+        file_name ? file_name : empty_string,
+        line_number ? L"\nLine: " : L"",
+        line_number ? line_number : empty_string,
+        user_message[0] ? L"\n\n" : L"",
+        user_message[0] && _CRT_ASSERT == report_type ? L"Expression: " : L"",
+        user_message[0] ? user_message : empty_string,
+        _CRT_ASSERT == report_type ? more_info_string : L"");
+
+    _ERRCHECK_SPRINTF(sprintf_result);
+
+    if (sprintf_result < 0)
+    {
+        _ERRCHECK(wcscpy_s(message_buffer, DBGRPT_MAX_MSG, _CRT_WIDE(DBGRPT_TOOLONGMSG)));
+    }
+
+    int const message_box_result = __acrt_show_wide_message_box(
+        message_buffer,
+        L"Microsoft Visual C++ Runtime Library",
+        MB_TASKMODAL | MB_ICONHAND | MB_ABORTRETRYIGNORE | MB_SETFOREGROUND);
+
+    switch (message_box_result)
+    {
+    case IDABORT: // Abort:  Terminate execution
+    {
+        // Note that even though we are "aborting," we do not call abort()
+        // because we do not want to invoke Watson (the user has already had an
+        // opportunity to debug the error and chose not to).
+        __crt_signal_handler_t const sigabrt_action = __acrt_get_sigabrt_handler();
+        if (sigabrt_action != SIG_DFL)
+        {
+            raise(SIGABRT);
+        }
+
+        TerminateProcess(GetCurrentProcess(), 3);
+    }
+
+    case IDRETRY:
+    {
+        return 1; // Retry:  Debug break
+    }
+
+    case IDIGNORE:
+    default:
+    {
+        return 0; // Ignore:  Continue execution
+    }
+    }
+}
+
+extern "C" int __cdecl __acrt_MessageWindowA(
+    int         const report_type,
+    void*       const return_address,
+    char const* const file_name,
+    char const* const line_number,
+    char const* const module_name,
+    char const* const user_message
+    )
+{
+    return common_message_window(report_type, return_address, file_name, line_number, module_name, user_message);
+}
+
+extern "C" int __cdecl __acrt_MessageWindowW(
+    int            const report_type,
+    void*          const return_address,
+    wchar_t const* const file_name,
+    wchar_t const* const line_number,
+    wchar_t const* const module_name,
+    wchar_t const* const user_message
+    )
+{
+    return common_message_window(report_type, return_address, file_name, line_number, module_name, user_message);
+}
+
+#endif
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/dbgrptt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/dbgrptt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9eb97ef7d4e2256ff018a195093e5c481a3edd12
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/dbgrptt.cpp	
@@ -0,0 +1,688 @@
+/***
+*dbgrptt.c - Debug CRT Reporting Functions
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*
+*******************************************************************************/
+
+#ifndef _DEBUG
+    #error This file is supported only in debug builds
+    #define _DEBUG // For design-time support, when editing/viewing CRT sources
+#endif
+
+#include <corecrt_internal.h>
+#include <errno.h>
+#include <malloc.h>
+#include <minmax.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+extern "C" int __cdecl __acrt_MessageWindowA(
+    int         report_type,
+    void*       return_address,
+    char const* file_name,
+    char const* line_number,
+    char const* module_name,
+    char const* user_message
+    );
+
+extern "C" int __cdecl __acrt_MessageWindowW(
+    int            report_type,
+    void*          return_address,
+    wchar_t const* file_name,
+    wchar_t const* line_number,
+    wchar_t const* module_name,
+    wchar_t const* user_message
+    );
+
+extern "C" {
+
+_CRT_REPORT_HOOK _pfnReportHook;
+
+__crt_report_hook_node<char> *_pReportHookList;
+__crt_report_hook_node<wchar_t> *_pReportHookListW;
+
+long _crtAssertBusy = -1;
+
+// Enclaves only support MODE_DEBUG for error output
+#ifdef _UCRT_ENCLAVE_BUILD
+
+int const _CrtDbgMode[_CRT_ERRCNT]
+{
+    _CRTDBG_MODE_DEBUG,
+    _CRTDBG_MODE_DEBUG,
+    _CRTDBG_MODE_DEBUG
+};
+
+_HFILE const _CrtDbgFile[_CRT_ERRCNT]
+{
+    _CRTDBG_INVALID_HFILE,
+    _CRTDBG_INVALID_HFILE,
+    _CRTDBG_INVALID_HFILE
+};
+
+#else
+
+int _CrtDbgMode[_CRT_ERRCNT]
+{
+    _CRTDBG_MODE_DEBUG,
+    _CRTDBG_MODE_WNDW,
+    _CRTDBG_MODE_WNDW
+};
+
+_HFILE _CrtDbgFile[_CRT_ERRCNT]
+{
+    _CRTDBG_INVALID_HFILE,
+    _CRTDBG_INVALID_HFILE,
+    _CRTDBG_INVALID_HFILE
+};
+
+/***
+*int _CrtSetReportMode - set the reporting mode for a given report type
+*
+*Purpose:
+*       set the reporting mode for a given report type
+*
+*Entry:
+*       int nRptType    - the report type
+*       int fMode       - new mode for given report type
+*
+*Exit:
+*       previous mode for given report type
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+int __cdecl _CrtSetReportMode(
+    int nRptType,
+    int fMode
+    )
+{
+    int oldMode;
+
+    /* validation section */
+    _VALIDATE_RETURN(nRptType >= 0 && nRptType < _CRT_ERRCNT, EINVAL, -1);
+    _VALIDATE_RETURN(
+        fMode == _CRTDBG_REPORT_MODE ||
+        (fMode & ~(_CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_WNDW)) == 0,
+        EINVAL,
+        -1);
+
+    if (fMode == _CRTDBG_REPORT_MODE)
+        return _CrtDbgMode[nRptType];
+
+    oldMode = _CrtDbgMode[nRptType];
+
+    _CrtDbgMode[nRptType] = fMode;
+
+    return oldMode;
+}
+
+/***
+*int _CrtSetReportFile - set the reporting file for a given report type
+*
+*Purpose:
+*       set the reporting file for a given report type
+*
+*Entry:
+*       int nRptType    - the report type
+*       _HFILE hFile    - new file for given report type
+*
+*Exit:
+*       previous file for given report type
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+_HFILE __cdecl _CrtSetReportFile(
+    int nRptType,
+    _HFILE hFile
+    )
+{
+    _HFILE oldFile;
+
+    /* validation section */
+    _VALIDATE_RETURN(nRptType >= 0 && nRptType < _CRT_ERRCNT, EINVAL, _CRTDBG_HFILE_ERROR);
+
+    if (hFile == _CRTDBG_REPORT_FILE)
+        return _CrtDbgFile[nRptType];
+
+    oldFile = _CrtDbgFile[nRptType];
+
+    if (_CRTDBG_FILE_STDOUT == hFile)
+        _CrtDbgFile[nRptType] = GetStdHandle(STD_OUTPUT_HANDLE);
+    else if (_CRTDBG_FILE_STDERR == hFile)
+        _CrtDbgFile[nRptType] = GetStdHandle(STD_ERROR_HANDLE);
+    else
+        _CrtDbgFile[nRptType] = hFile;
+
+    return oldFile;
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/***
+*_CRT_REPORT_HOOK _CrtSetReportHook() - set client report hook
+*
+*Purpose:
+*       set client report hook. This function is provided only in ANSI
+*       for backward compatibility. No Unicode Version of this function exists
+*
+*Entry:
+*       _CRT_REPORT_HOOK pfnNewHook - new report hook
+*
+*Exit:
+*       return previous hook
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+_CRT_REPORT_HOOK __cdecl _CrtSetReportHook(_CRT_REPORT_HOOK pfnNewHook)
+{
+    _CRT_REPORT_HOOK pfnOldHook = _pfnReportHook;
+    _pfnReportHook = pfnNewHook;
+    return pfnOldHook;
+}
+
+/***
+*_CRT_REPORT_HOOK _CrtGetReportHook() - get client report hook
+*
+*Purpose:
+*       get client report hook.
+*
+*Entry:
+*
+*Exit:
+*       return current hook
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+_CRT_REPORT_HOOK __cdecl _CrtGetReportHook(void)
+{
+    return _pfnReportHook;
+}
+
+#define ASSERTINTRO1 "Assertion failed: "
+#define ASSERTINTRO2 "Assertion failed!"
+
+/***
+*int _VCrtDbgReportA() - _CrtDbgReport calls into this function
+*
+*Purpose:
+*       See remarks for _CrtDbgReport.
+*
+*Entry:
+*       int             nRptType    - report type
+*       char const*    szFile      - file name
+*       int             nLine       - line number
+*       char const*    szModule    - module name
+*       char const*    szFormat    - format string
+*       va_list         arglist      - var args arglist
+*
+*Exit:
+*       See remarks for _CrtDbgReport
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+#pragma warning(push)
+#pragma warning(disable:6262)
+// prefast (6262): This func uses lots of stack because we want to tolerate very large reports, and we can't use malloc here.
+int __cdecl _VCrtDbgReportA(
+    int nRptType,
+    void * returnAddress,
+    char const* szFile,
+    int nLine,
+    char const* szModule,
+    char const* szFormat,
+    va_list arglist
+    )
+{
+    int retval=0;
+    int handled=FALSE;
+
+    char    szLineMessage[DBGRPT_MAX_MSG]{0};
+    char    szOutMessage [DBGRPT_MAX_MSG]{0};
+    wchar_t szOutMessage2[DBGRPT_MAX_MSG]{0};
+    char    szUserMessage[DBGRPT_MAX_MSG]{0};
+
+    if (nRptType < 0 || nRptType >= _CRT_ERRCNT)
+        return -1;
+
+    /*
+     * handle the (hopefully rare) case of
+     *
+     * 1) ASSERT while already dealing with an ASSERT
+     *      or
+     * 2) two threads asserting at the same time
+     */
+
+    __try
+    {
+        if (_CRT_ASSERT == nRptType && _InterlockedIncrement(&_crtAssertBusy) > 0)
+        {
+            /* use only 'safe' functions -- must not assert in here! */
+
+            _ERRCHECK(_itoa_s(nLine, szLineMessage, DBGRPT_MAX_MSG, 10));
+
+            __acrt_OutputDebugStringA("Second Chance Assertion Failed: File ");
+            __acrt_OutputDebugStringA(szFile ? szFile : "<file unknown>");
+            __acrt_OutputDebugStringA(", Line ");
+            __acrt_OutputDebugStringA(szLineMessage);
+            __acrt_OutputDebugStringA("\n");
+
+            _CrtDbgBreak();
+            retval=-1;
+            __leave;
+        }
+
+        // Leave space for ASSERTINTRO1 and "\r\n"
+        if (szFormat)
+        {
+            int szlen = 0;
+            _ERRCHECK_SPRINTF(szlen = _vsnprintf_s(szUserMessage, DBGRPT_MAX_MSG,
+                                                    DBGRPT_MAX_MSG - 2- max(sizeof(ASSERTINTRO1),sizeof(ASSERTINTRO2)),
+                                                    szFormat, arglist));
+            if (szlen < 0)
+            {
+                _ERRCHECK(strcpy_s(szUserMessage, DBGRPT_MAX_MSG, DBGRPT_TOOLONGMSG));
+            }
+        }
+
+        if (_CRT_ASSERT == nRptType)
+        {
+            _ERRCHECK(strcpy_s(szLineMessage, DBGRPT_MAX_MSG, szFormat ? ASSERTINTRO1 : ASSERTINTRO2));
+        }
+
+        _ERRCHECK(strcat_s(szLineMessage, DBGRPT_MAX_MSG, szUserMessage));
+
+        if (_CRT_ASSERT == nRptType)
+        {
+            if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
+            {
+                _ERRCHECK(strcat_s(szLineMessage, DBGRPT_MAX_MSG, "\r"));
+            }
+
+            _ERRCHECK(strcat_s(szLineMessage, DBGRPT_MAX_MSG, "\n"));
+        }
+
+        if (szFile)
+        {
+            int szlen = 0;
+            _ERRCHECK_SPRINTF(szlen = _snprintf_s(szOutMessage, DBGRPT_MAX_MSG, DBGRPT_MAX_MSG - 1, "%s(%d) : %s",
+                                                    szFile, nLine, szLineMessage));
+            if (szlen < 0)
+            {
+                _ERRCHECK(strcpy_s(szOutMessage, DBGRPT_MAX_MSG, DBGRPT_TOOLONGMSG));
+            }
+        }
+        else
+        {
+            _ERRCHECK(strcpy_s(szOutMessage, DBGRPT_MAX_MSG, szLineMessage));
+        }
+
+        {
+            size_t ret = 0;
+            errno_t e = 0;
+            _ERRCHECK_EINVAL_ERANGE(e = mbstowcs_s(&ret, szOutMessage2, DBGRPT_MAX_MSG, szOutMessage, _TRUNCATE));
+            if(e != 0)
+            {
+                _ERRCHECK(wcscpy_s(szOutMessage2, DBGRPT_MAX_MSG, _CRT_WIDE(DBGRPT_INVALIDMSG)));
+            }
+        }
+
+        /* User hook may handle report.
+            We have to check the ANSI Hook2 List & then the UNICODE Hook2 List.
+            Then we have check any ANSI individual Hook set through
+            SetReportHook */
+
+        if (_pReportHookList || _pReportHookListW)
+        {
+            __crt_report_hook_node<char> *pnode=nullptr;
+            __crt_report_hook_node<wchar_t> *pnodeW=nullptr;
+
+            __acrt_lock(__acrt_debug_lock);
+            __try
+            {
+                for (pnode = _pReportHookList; pnode; pnode = pnode->next)
+                {
+                    int hook_retval=0;
+                    if (pnode->hook(nRptType, szOutMessage, &hook_retval))
+                    {
+                        handled=TRUE;
+                        retval=hook_retval;
+                        __leave;
+                    }
+                }
+
+                for (pnodeW = _pReportHookListW; pnodeW; pnodeW = pnodeW->next)
+                {
+                    int hook_retval=0;
+                    if (pnodeW->hook(nRptType, szOutMessage2, &hook_retval))
+                    {
+                        handled=TRUE;
+                        retval=hook_retval;
+                        __leave;
+                    }
+                }
+            }
+            __finally
+            {
+                __acrt_unlock(__acrt_debug_lock);
+            }
+        }
+
+        if (handled)
+            __leave;
+
+        if (_pfnReportHook)
+        {
+            int hook_retval=0;
+            if (_pfnReportHook(nRptType, szOutMessage, &hook_retval))
+            {
+                retval = hook_retval;
+                __leave;
+            }
+        }
+
+        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
+        {
+            if (_CrtDbgFile[nRptType] != _CRTDBG_INVALID_HFILE)
+            {
+                DWORD bytes_written = 0;
+                WriteFile(_CrtDbgFile[nRptType], szOutMessage, static_cast<DWORD>(strlen(szOutMessage)), &bytes_written, nullptr);
+            }
+        }
+
+        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_DEBUG)
+        {
+            __acrt_OutputDebugStringA(szOutMessage);
+        }
+
+        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_WNDW)
+        {
+            szLineMessage[0] = 0;
+            if (nLine)
+            {
+                _ERRCHECK(_itoa_s(nLine, szLineMessage, DBGRPT_MAX_MSG, 10));
+            }
+
+            retval = __acrt_MessageWindowA(nRptType, returnAddress, szFile, (nLine ? szLineMessage : nullptr), szModule, szUserMessage);
+        }
+    }
+    __finally
+    {
+        if (_CRT_ASSERT == nRptType)
+        {
+            _InterlockedDecrement(&_crtAssertBusy);
+        }
+    }
+
+    return retval;
+}
+#pragma warning(pop)
+
+/***
+*int _VCrtDbgReportW() - _CrtDbgReportW calls into this function
+*
+*Purpose:
+*       See remarks for _CrtDbgReport.
+*
+*Entry:
+*       int             nRptType    - report type
+*       wchar_t const* szFile      - file name
+*       int             nLine       - line number
+*       wchar_t const* szModule    - module name
+*       wchar_t const* szFormat    - format string
+*       va_list         arglist      - var args arglist
+*
+*Exit:
+*       See remarks for _CrtDbgReport
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+#pragma warning(push)
+#pragma warning(disable:6262)
+// prefast(6262): This func uses lots of stack because we want to tolerate very large reports, and we can't use malloc here.
+int __cdecl _VCrtDbgReportW
+(
+    int nRptType,
+    void * returnAddress,
+    wchar_t const* szFile,
+    int nLine,
+    wchar_t const* szModule,
+    wchar_t const* szFormat,
+    va_list arglist
+    )
+{
+    int retval=0;
+    int handled=FALSE;
+    wchar_t szLineMessage[DBGRPT_MAX_MSG] = {0};
+    wchar_t szOutMessage[DBGRPT_MAX_MSG] = {0};
+    char szOutMessage2[DBGRPT_MAX_MSG] = {0};
+    wchar_t szUserMessage[DBGRPT_MAX_MSG] = {0};
+
+    if (nRptType < 0 || nRptType >= _CRT_ERRCNT)
+        return -1;
+
+    /*
+     * handle the (hopefully rare) case of
+     *
+     * 1) ASSERT while already dealing with an ASSERT
+     *      or
+     * 2) two threads asserting at the same time
+     */
+
+    __try
+    {
+        if (_CRT_ASSERT == nRptType && _InterlockedIncrement(&_crtAssertBusy) > 0)
+        {
+            /* use only 'safe' functions -- must not assert in here! */
+
+            _ERRCHECK(_itow_s(nLine, szLineMessage, DBGRPT_MAX_MSG, 10));
+
+            OutputDebugStringW(L"Second Chance Assertion Failed: File ");
+            OutputDebugStringW(szFile ? szFile : L"<file unknown>");
+            OutputDebugStringW(L", Line ");
+            OutputDebugStringW(szLineMessage);
+            OutputDebugStringW(L"\n");
+
+            _CrtDbgBreak();
+            retval = -1;
+            __leave;
+        }
+
+        if (szFormat)
+        {
+            // Leave space for ASSERTINTRO{1,2} and "\r\n"
+            size_t const max_assert_intro_count = __max(_countof(ASSERTINTRO1), _countof(ASSERTINTRO2));
+            size_t const max_user_message_count = _countof(szUserMessage) - 2 - max_assert_intro_count;
+
+            // Force use of the legacy stdio wide character format specifiers
+            // mode for source compatibility.  If we ever revisit support for
+            // the standard format specifiers, we'll need to revisit this as
+            // well.
+            int szlen = 0;
+            _ERRCHECK_SPRINTF(szlen = __stdio_common_vsnwprintf_s(
+                _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS,
+                szUserMessage,
+                _countof(szUserMessage),
+                max_user_message_count,
+                szFormat,
+                nullptr,
+                arglist));
+            if (szlen < 0)
+            {
+                _ERRCHECK(wcscpy_s(szUserMessage, DBGRPT_MAX_MSG, _CRT_WIDE(DBGRPT_TOOLONGMSG)));
+            }
+        }
+
+        if (_CRT_ASSERT == nRptType)
+            _ERRCHECK(wcscpy_s(szLineMessage, DBGRPT_MAX_MSG, szFormat ? _CRT_WIDE(ASSERTINTRO1) : _CRT_WIDE(ASSERTINTRO2)));
+
+        _ERRCHECK(wcscat_s(szLineMessage, DBGRPT_MAX_MSG, szUserMessage));
+
+        if (_CRT_ASSERT == nRptType)
+        {
+            if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE)
+                _ERRCHECK(wcscat_s(szLineMessage, DBGRPT_MAX_MSG, L"\r"));
+            {
+                _ERRCHECK(wcscat_s(szLineMessage, DBGRPT_MAX_MSG, L"\n"));
+            }
+        }
+
+        if (szFile)
+        {
+            int szlen = 0;
+            _ERRCHECK_SPRINTF(szlen = _snwprintf_s(szOutMessage, DBGRPT_MAX_MSG, DBGRPT_MAX_MSG, L"%ls(%d) : %ls",
+                                                    szFile, nLine, szLineMessage));
+            if (szlen < 0)
+                _ERRCHECK(wcscpy_s(szOutMessage, DBGRPT_MAX_MSG, _CRT_WIDE(DBGRPT_TOOLONGMSG)));
+        }
+        else
+        {
+            _ERRCHECK(wcscpy_s(szOutMessage, DBGRPT_MAX_MSG, szLineMessage));
+        }
+
+        /* scope */
+        {
+            errno_t e = _ERRCHECK_EINVAL_ERANGE(wcstombs_s(nullptr, szOutMessage2, DBGRPT_MAX_MSG, szOutMessage, _TRUNCATE));
+            if(e != 0)
+                _ERRCHECK(strcpy_s(szOutMessage2, DBGRPT_MAX_MSG, DBGRPT_INVALIDMSG));
+        }
+
+        /* User hook may handle report.
+            We have to check the ANSI Hook2 List & then the UNICODE Hook2 List.
+            Then we have check any ANSI individual Hook set through
+            SetReportHook */
+
+        if (_pReportHookList || _pReportHookListW)
+        {
+            __crt_report_hook_node<char> *pnode=nullptr;
+            __crt_report_hook_node<wchar_t> *pnodeW=nullptr;
+
+            __acrt_lock(__acrt_debug_lock);
+            __try
+            {
+                for (pnode = _pReportHookList; pnode; pnode = pnode->next)
+                {
+                    int hook_retval=0;
+                    if (pnode->hook(nRptType, szOutMessage2, &hook_retval))
+                    {
+                        retval=hook_retval;
+                        handled=TRUE;
+                        __leave;
+                    }
+                }
+
+                for (pnodeW = _pReportHookListW; pnodeW; pnodeW = pnodeW->next)
+                {
+                    int hook_retval=0;
+                    if (pnodeW->hook(nRptType, szOutMessage, &hook_retval))
+                    {
+                        retval=hook_retval;
+                        handled=TRUE;
+                        __leave;
+                    }
+                }
+            }
+            __finally
+            {
+                __acrt_unlock(__acrt_debug_lock);
+            }
+        }
+
+        if (handled)
+            __leave;
+
+        if(_pfnReportHook)
+        {
+            int hook_retval=0;
+            if (_pfnReportHook(nRptType, szOutMessage2, &hook_retval))
+            {
+                retval = hook_retval;
+                __leave;
+            }
+        }
+
+        if ((_CrtDbgMode[nRptType] & _CRTDBG_MODE_FILE) && _CrtDbgFile[nRptType] != _CRTDBG_INVALID_HFILE)
+        {
+            /* Use WriteConsole for Consoles, WriteFile otherwise */
+            switch (GetFileType(_CrtDbgFile[nRptType]))
+            {
+            case FILE_TYPE_CHAR:
+            {
+                DWORD characters_written = 0;
+                if (WriteConsoleW(_CrtDbgFile[nRptType], szOutMessage, static_cast<DWORD>(wcslen(szOutMessage)), &characters_written, nullptr))
+                    break;
+
+                /* If WriteConsole fails & LastError is ERROR_INVALID_VALUE, then the console is redirected */
+                if (GetLastError() != ERROR_INVALID_HANDLE)
+                    break;
+            }
+            default:
+            {
+                char szaOutMessage[DBGRPT_MAX_MSG];
+                size_t ret = 0;
+                errno_t e = _ERRCHECK_EINVAL_ERANGE(wcstombs_s(&ret, szaOutMessage, DBGRPT_MAX_MSG, szOutMessage, _TRUNCATE));
+
+                if (e != 0 && e != STRUNCATE)
+                {
+                    DWORD bytes_written = 0;
+                    WriteFile(_CrtDbgFile[nRptType], szOutMessage, static_cast<DWORD>(wcslen(szOutMessage)) * 2, &bytes_written, nullptr);
+                }
+                else
+                {
+                    /* ret counts for the null terminator as well */
+                    if (ret > 0)
+                    {
+                        --ret;
+                    }
+
+                    DWORD bytes_written = 0;
+                    WriteFile(_CrtDbgFile[nRptType], szaOutMessage, static_cast<DWORD>(ret), &bytes_written, nullptr);
+                }
+            }
+            }
+        }
+
+        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_DEBUG)
+        {
+            ::OutputDebugStringW(szOutMessage);
+        }
+
+        if (_CrtDbgMode[nRptType] & _CRTDBG_MODE_WNDW)
+        {
+            szLineMessage[0] = 0;
+            if (nLine)
+            {
+                _ERRCHECK(_itow_s(nLine, szLineMessage, DBGRPT_MAX_MSG, 10));
+            }
+            retval = __acrt_MessageWindowW(nRptType, returnAddress, szFile, (nLine ? szLineMessage : nullptr), szModule, szUserMessage);
+        }
+    }
+    __finally
+    {
+        if (_CRT_ASSERT == nRptType)
+        {
+            _InterlockedDecrement(&_crtAssertBusy);
+        }
+    }
+
+    return retval;
+}
+#pragma warning(pop)
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/debug_fill_threshold.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/debug_fill_threshold.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52eddf7e38a041f93f1aeecc78f5bd51c1d55936
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/debug_fill_threshold.cpp	
@@ -0,0 +1,29 @@
+//
+// debug_fill_threshold.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Functions to control the debug fill threshold used by the secure string
+// functions.  A threshold of 0 disables filling; a threshold of SIZE_MAX
+// means to always fill to the maximum.
+//
+#include <corecrt_internal.h>
+#include <stdint.h>
+
+
+
+static size_t __acrt_debug_fill_threshold = SIZE_MAX;
+
+
+
+extern "C" size_t __cdecl _CrtSetDebugFillThreshold(size_t const new_threshold)
+{
+    size_t const old_threshold{__acrt_debug_fill_threshold};
+    __acrt_debug_fill_threshold = new_threshold;
+    return old_threshold;
+}
+
+extern "C" size_t __cdecl _CrtGetDebugFillThreshold()
+{
+    return __acrt_debug_fill_threshold;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drive.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drive.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..81d707d4b649f2ef3ef1f1304210c0e512d1699d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drive.cpp	
@@ -0,0 +1,77 @@
+//
+// drive.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _getdrive() and _chdrive() functions, which get and set the current drive.
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <direct.h>
+#include <errno.h>
+
+static int __cdecl get_drive_number_from_path(wchar_t const* const path) throw()
+{
+    if (path[0] == L'\0' || path[1] != L':')
+        return 0;
+
+    return __ascii_towupper(path[0]) - L'A' + 1;
+}
+
+
+
+// Gets the current drive number (A: => 1, B: => 2, etc.).  Returns zero if the
+// current drive cannot be determined.
+extern "C" int __cdecl _getdrive()
+{
+    wchar_t cwd[MAX_PATH + 1] = { 0 };
+
+    DWORD const cwd_length = GetCurrentDirectoryW(MAX_PATH + 1, cwd);
+    if (cwd_length <= MAX_PATH)
+    {
+        return get_drive_number_from_path(cwd);
+    }
+
+    // Otherwise, we need more space for the path, so we'll need to dynamically
+    // allocate a buffer:
+    __crt_unique_heap_ptr<wchar_t> const heap_cwd(_calloc_crt_t(wchar_t, cwd_length + 1));
+    if (heap_cwd.get() == nullptr)
+    {
+        errno = ENOMEM;
+        return 0;
+    }
+
+    DWORD const heap_cwd_length = GetCurrentDirectoryW(cwd_length + 1, heap_cwd.get());
+    if (heap_cwd_length == 0)
+    {
+        errno = ENOMEM;
+        return 0;
+    }
+
+    return get_drive_number_from_path(heap_cwd.get());
+}
+
+
+
+// Changes the current drive to the specified drive number.  Returns zero on
+// success; returns -1 and sets errno and _doserrno on failure.
+extern "C" int __cdecl _chdrive(int const drive_number)
+{
+    if (drive_number < 1 || drive_number > 26)
+    {
+        _doserrno = ERROR_INVALID_DRIVE;
+        _VALIDATE_RETURN(("Invalid Drive Index", 0), EACCES, -1);
+    }
+
+#pragma warning(suppress:__WARNING_UNUSED_ASSIGNMENT) // 28931 unused assignment of variable drive_letter
+    wchar_t const drive_letter   = static_cast<wchar_t>(L'A' + drive_number - 1);
+    wchar_t const drive_string[] = { drive_letter, L':', L'\0' };
+
+    if (!SetCurrentDirectoryW(drive_string))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drivemap.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drivemap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..20778fbac6c0b078f31d1468d7836f8f0e16bda8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drivemap.cpp	
@@ -0,0 +1,31 @@
+/***
+*drivemap.c - _getdrives
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _getdrives()
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <direct.h>
+
+/***
+*void _getdrivemap(void) - Get bit map of all available drives
+*
+*Purpose:
+*
+*Entry:
+*
+*Exit:
+*       drive map with drive A in bit 0, B in 1, etc.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" unsigned long __cdecl _getdrives()
+{
+    return GetLogicalDrives();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drivfree.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drivfree.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2338fcf71e8c2fd78a572496c1b208db9ceb18c6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/drivfree.cpp	
@@ -0,0 +1,55 @@
+/***
+*drivfree.c - Get the size of a disk
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This file has _getdiskfree()
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <direct.h>
+
+
+
+// Gets the size information for the given drive.  The 'drive_number' must be a
+// number, 1 through 26, corresponding to drives A: through Z:.  Returns zero on
+// success; a system error code on failure.
+extern "C" unsigned __cdecl _getdiskfree(
+    unsigned     const drive_number,
+    _diskfree_t* const result
+)
+{
+    _VALIDATE_RETURN(result != nullptr,  EINVAL, ERROR_INVALID_PARAMETER);
+    _VALIDATE_RETURN(drive_number <= 26, EINVAL, ERROR_INVALID_PARAMETER);
+
+    *result = _diskfree_t();
+
+    wchar_t drive_name_buffer[4] = { '_', ':', '\\', '\0' };
+
+    wchar_t const* const drive_name = drive_number == 0
+        ? nullptr
+        : drive_name_buffer;
+
+    if (drive_number != 0)
+    {
+        drive_name_buffer[0] = static_cast<wchar_t>(drive_number) + static_cast<wchar_t>(L'A' - 1);
+    }
+
+    static_assert(sizeof(result->sectors_per_cluster) == sizeof(DWORD), "Unexpected sizeof long");
+
+    if (!GetDiskFreeSpaceW(drive_name,
+        reinterpret_cast<LPDWORD>(&result->sectors_per_cluster),
+        reinterpret_cast<LPDWORD>(&result->bytes_per_sector),
+        reinterpret_cast<LPDWORD>(&result->avail_clusters),
+        reinterpret_cast<LPDWORD>(&result->total_clusters)))
+    {
+        int const os_error = GetLastError();
+        errno = __acrt_errno_from_os_error(os_error);
+
+        return os_error;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/errno.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/errno.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d98b32c0c8f471283bac04cc8746233b32fdf481
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/errno.cpp	
@@ -0,0 +1,254 @@
+//
+// errno.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _errno, _doserrno, and related functions
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <errno.h>
+
+
+
+// This is the error table that defines the mapping between OS error codes and
+// errno values.
+namespace
+{
+    struct errentry
+    {
+        unsigned long oscode; // OS return value
+        int errnocode;        // System V error code
+    };
+}
+
+// errtable's oscode must be sorted in ascending order regarding oscode for
+// a binary search to work.
+static errentry const errtable[]
+{
+    { ERROR_INVALID_FUNCTION,       EINVAL    },  //    1
+    { ERROR_FILE_NOT_FOUND,         ENOENT    },  //    2
+    { ERROR_PATH_NOT_FOUND,         ENOENT    },  //    3
+    { ERROR_TOO_MANY_OPEN_FILES,    EMFILE    },  //    4
+    { ERROR_ACCESS_DENIED,          EACCES    },  //    5
+    { ERROR_INVALID_HANDLE,         EBADF     },  //    6
+    { ERROR_ARENA_TRASHED,          ENOMEM    },  //    7
+    { ERROR_NOT_ENOUGH_MEMORY,      ENOMEM    },  //    8
+    { ERROR_INVALID_BLOCK,          ENOMEM    },  //    9
+    { ERROR_BAD_ENVIRONMENT,        E2BIG     },  //   10
+    { ERROR_BAD_FORMAT,             ENOEXEC   },  //   11
+    { ERROR_INVALID_ACCESS,         EINVAL    },  //   12
+    { ERROR_INVALID_DATA,           EINVAL    },  //   13
+    { ERROR_INVALID_DRIVE,          ENOENT    },  //   15
+    { ERROR_CURRENT_DIRECTORY,      EACCES    },  //   16
+    { ERROR_NOT_SAME_DEVICE,        EXDEV     },  //   17
+    { ERROR_NO_MORE_FILES,          ENOENT    },  //   18
+    { ERROR_LOCK_VIOLATION,         EACCES    },  //   33
+    { ERROR_BAD_NETPATH,            ENOENT    },  //   53
+    { ERROR_NETWORK_ACCESS_DENIED,  EACCES    },  //   65
+    { ERROR_BAD_NET_NAME,           ENOENT    },  //   67
+    { ERROR_FILE_EXISTS,            EEXIST    },  //   80
+    { ERROR_CANNOT_MAKE,            EACCES    },  //   82
+    { ERROR_FAIL_I24,               EACCES    },  //   83
+    { ERROR_INVALID_PARAMETER,      EINVAL    },  //   87
+    { ERROR_NO_PROC_SLOTS,          EAGAIN    },  //   89
+    { ERROR_DRIVE_LOCKED,           EACCES    },  //  108
+    { ERROR_BROKEN_PIPE,            EPIPE     },  //  109
+    { ERROR_DISK_FULL,              ENOSPC    },  //  112
+    { ERROR_INVALID_TARGET_HANDLE,  EBADF     },  //  114
+    { ERROR_WAIT_NO_CHILDREN,       ECHILD    },  //  128
+    { ERROR_CHILD_NOT_COMPLETE,     ECHILD    },  //  129
+    { ERROR_DIRECT_ACCESS_HANDLE,   EBADF     },  //  130
+    { ERROR_NEGATIVE_SEEK,          EINVAL    },  //  131
+    { ERROR_SEEK_ON_DEVICE,         EACCES    },  //  132
+    { ERROR_DIR_NOT_EMPTY,          ENOTEMPTY },  //  145
+    { ERROR_NOT_LOCKED,             EACCES    },  //  158
+    { ERROR_BAD_PATHNAME,           ENOENT    },  //  161
+    { ERROR_MAX_THRDS_REACHED,      EAGAIN    },  //  164
+    { ERROR_LOCK_FAILED,            EACCES    },  //  167
+    { ERROR_ALREADY_EXISTS,         EEXIST    },  //  183
+    { ERROR_FILENAME_EXCED_RANGE,   ENOENT    },  //  206
+    { ERROR_NESTING_NOT_ALLOWED,    EAGAIN    },  //  215
+    { ERROR_NO_UNICODE_TRANSLATION, EILSEQ    },  // 1113
+    { ERROR_NOT_ENOUGH_QUOTA,       ENOMEM    }   // 1816
+};
+
+// Number of elements in the table
+#define ERRTABLECOUNT (sizeof(errtable) / sizeof(errtable[0]))
+
+// The following two constants must be the minimum and maximum
+// values in the (contiguous) range of Exec Failure errors.
+#define MIN_EXEC_ERROR ERROR_INVALID_STARTING_CODESEG
+#define MAX_EXEC_ERROR ERROR_INFLOOP_IN_RELOC_CHAIN
+
+// These are the low and high value in the range of errors that are
+// access violations
+#define MIN_EACCES_RANGE ERROR_WRITE_PROTECT
+#define MAX_EACCES_RANGE ERROR_SHARING_BUFFER_EXCEEDED
+
+// These map Windows error codes into errno error codes
+extern "C" void __cdecl __acrt_errno_map_os_error(unsigned long const oserrno)
+{
+    _doserrno = oserrno;
+    errno     = __acrt_errno_from_os_error(oserrno);
+}
+
+extern "C" void __cdecl __acrt_errno_map_os_error_ptd(unsigned long const oserrno, __crt_cached_ptd_host& ptd)
+{
+    ptd.get_doserrno().set(oserrno);
+    ptd.get_errno().set(__acrt_errno_from_os_error(oserrno));
+}
+
+inline const errentry* bsearch_errentry(
+    unsigned long const oserrno,
+    errentry const* const errtable,
+    size_t num
+    )
+{
+    size_t lo = 0;
+    size_t hi = num - 1;
+
+    while (lo <= hi)
+    {
+        size_t const half = num / 2;
+        if (half != 0)
+        {
+            size_t mid = lo + (num & 1 ? half : (half - 1));
+
+            if (oserrno == errtable[mid].oscode)
+            {
+                return &errtable[mid];
+            }
+            else if (oserrno < errtable[mid].oscode)
+            {
+                hi = mid - 1;
+                num = num & 1 ? half : half - 1;
+            }
+            else
+            {
+                lo = mid + 1;
+                num = half;
+            }
+        }
+        else if (num != 0)
+        {
+            return (oserrno != errtable[lo].oscode) ? nullptr : &errtable[lo];
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return nullptr;
+}
+
+extern "C" int __cdecl __acrt_errno_from_os_error(unsigned long const oserrno)
+{
+    // Check the table for the OS error code
+    if (oserrno >= errtable[0].oscode)
+    {
+        if (oserrno <= ERROR_INVALID_DATA)
+        {
+            return errtable[oserrno-1].errnocode;
+        }
+        else if (oserrno <= errtable[ERRTABLECOUNT - 1].oscode)
+        {
+            const errentry* result = bsearch_errentry(oserrno, errtable, ERRTABLECOUNT);
+            if (result != nullptr)
+            {
+                return result->errnocode;
+            }
+        }
+    }
+
+    // The error code wasn't in the table.  We check for a range of
+    // EACCES errors or exec failure errors (ENOEXEC).  Otherwise
+    // EINVAL is returned.
+    if (oserrno >= MIN_EACCES_RANGE && oserrno <= MAX_EACCES_RANGE)
+    {
+        return EACCES;
+    }
+    else if (oserrno >= MIN_EXEC_ERROR && oserrno <= MAX_EXEC_ERROR)
+    {
+        return ENOEXEC;
+    }
+    else
+    {
+        return EINVAL;
+    }
+}
+
+
+
+// These safely set and get the value of the calling thread's errno
+extern "C" errno_t _set_errno(int const value)
+{
+    __acrt_ptd* const ptd{__acrt_getptd_noexit()};
+    if (!ptd)
+        return ENOMEM;
+
+    errno = value;
+    return 0;
+}
+
+extern "C" errno_t _get_errno(int* const result)
+{
+    _VALIDATE_RETURN_NOERRNO(result != nullptr, EINVAL);
+
+    // Unlike most of our globals, this one is guaranteed to give some answer
+    *result = errno;
+    return 0;
+}
+
+
+
+// These safely set and get the value of the calling thread's doserrno
+extern "C" errno_t _set_doserrno(unsigned long const value)
+{
+    __acrt_ptd* const ptd{__acrt_getptd_noexit()};
+    if (!ptd)
+        return ENOMEM;
+
+    _doserrno = value;
+    return 0;
+}
+
+extern "C" errno_t _get_doserrno(unsigned long* const result)
+{
+    _VALIDATE_RETURN_NOERRNO(result != nullptr, EINVAL);
+
+    // Unlike most of our globals, this one is guaranteed to give some answer:
+    *result = _doserrno;
+    return 0;
+}
+
+
+
+// These return pointers to the calling thread's errno and doserrno values,
+// respectively, and are used to implement errno and _doserrno in the header.
+static int           errno_no_memory   {ENOMEM};
+static unsigned long doserrno_no_memory{ERROR_NOT_ENOUGH_MEMORY};
+
+extern "C" int* __cdecl _errno()
+{
+    __acrt_ptd* const ptd{__acrt_getptd_noexit()};
+    if (!ptd)
+    {
+        return &errno_no_memory;
+    }
+
+    return &ptd->_terrno;
+}
+
+extern "C" unsigned long* __cdecl __doserrno()
+{
+    __acrt_ptd* const ptd{__acrt_getptd_noexit()};
+    if (!ptd)
+    {
+        return &doserrno_no_memory;
+    }
+
+    return &ptd->_tdoserrno;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/exception_filter.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/exception_filter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39887b42d68399c45b07ae8091411825a54be3a6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/exception_filter.cpp	
@@ -0,0 +1,222 @@
+//
+// exception_filter.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The exception filter used by the startup code to transform various exceptions
+// into C signals.
+//
+#include <corecrt_internal.h>
+#include <float.h>
+#include <signal.h>
+#include <stddef.h>
+
+
+
+// The default exception action table.  Exceptions corresponding to the same
+// signal (e.g. SIGFPE) must be grouped together.  If any _action field is
+// changed in this table, that field must be initialized with an encoded
+// function pointer during CRT startup.
+extern "C" extern struct __crt_signal_action_t const __acrt_exception_action_table[] =
+{
+//    _exception_number                          _signal_number   _action
+//  --------------------------------------------------------
+    { STATUS_ACCESS_VIOLATION,         SIGSEGV, SIG_DFL },
+    { STATUS_ILLEGAL_INSTRUCTION,      SIGILL,  SIG_DFL },
+    { STATUS_PRIVILEGED_INSTRUCTION,   SIGILL,  SIG_DFL },
+    { STATUS_FLOAT_DENORMAL_OPERAND,   SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_DIVIDE_BY_ZERO,     SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_INEXACT_RESULT,     SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_INVALID_OPERATION,  SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_OVERFLOW,           SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_STACK_CHECK,        SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_UNDERFLOW,          SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_MULTIPLE_FAULTS,    SIGFPE,  SIG_DFL },
+    { STATUS_FLOAT_MULTIPLE_TRAPS,     SIGFPE,  SIG_DFL },
+};
+
+// WARNING!!! This constant must be the integer value for which
+// __acrt_exception_action_table[__acrt_signal_action_first_fpe_index] is the very FIRST entry in the table
+// corresponding to a floating point exception.
+extern "C" extern size_t const __acrt_signal_action_first_fpe_index = 3;
+
+// There are __acrt_signal_action_fpe_count entries in XcptActTab for floating point exceptions:
+extern "C" extern size_t const __acrt_signal_action_fpe_count = 9;
+
+// Size of the exception-action table in bytes
+extern "C" extern size_t const __acrt_signal_action_table_size = sizeof(__acrt_exception_action_table);
+
+// Number of entries in the exception-action table
+extern "C" extern size_t const __acrt_signal_action_table_count = sizeof(__acrt_exception_action_table) / sizeof(__acrt_exception_action_table[0]);
+
+
+
+// Finds an exception-action entry by exception number
+static __crt_signal_action_t* __cdecl xcptlookup(
+    unsigned long const xcptnum,
+    __crt_signal_action_t* const action_table
+    ) throw()
+{
+    __crt_signal_action_t* const first = action_table;
+    __crt_signal_action_t* const last  = first + __acrt_signal_action_table_count;
+
+    // Search for the matching entry and return it if we find it:
+    for (__crt_signal_action_t* it = first; it != last; ++it)
+        if (it->_exception_number == xcptnum)
+            return it;
+
+    // Otherwise, return nullptr on failure:
+    return nullptr;
+}
+
+
+
+// Wrapper that only calls the exception filter for C++ exceptions
+extern "C" int __cdecl _seh_filter_dll(
+    unsigned long       const xcptnum,
+    PEXCEPTION_POINTERS const pxcptinfoptrs
+    )
+{
+    if (xcptnum != ('msc' | 0xE0000000))
+        return EXCEPTION_CONTINUE_SEARCH;
+
+    return _seh_filter_exe(xcptnum,pxcptinfoptrs);
+}
+
+
+
+// Identifies an exception and the action to be taken with it
+//
+// This function is called by the exception filter expression of the __try-
+// __except statement in the startup code, which guards the call to the user-
+// provided main (or DllMain) function.  This function consults the per-thread
+// exception-action table to identify the exception and determine its
+// disposition.  The disposition of an exception corresponding to a C signal may
+// be modified by a call to signal().  There are three broad cases:
+//
+// (1) Unrecognized exceptions and exceptions for which the action is SIG_DFL
+//
+//     In both of these cases, EXCEPTION_CONTINUE_SEARCH is returned to cause
+//     the OS exception dispatcher to pass the exception on to the next exception
+//     handler in the chain--usually a system default handler.
+//
+// (2) Exceptions corresponding to C signals with an action other than SIG_DFL
+//
+//     These are the C signals whose disposition has been affected by a call to
+//     signal() or whose default semantics differ slightly from the corresponding
+//     OS exception.  In all cases, the appropriate disposition of the C signal is
+//     made by the function (e.g., calling a user-specified signal handler).
+//     Then, EXCEPTION_CONTINUE_EXECUTION is returned to cause the OS exception
+//     dispatcher to dismiss the exception and resume execution at the point
+//     where the exception occurred.
+//
+// (3) Exception for which the action is SIG_DIE
+//
+//     These are the exceptions corresponding to fatal C Runtime errors. For
+//     these, EXCEPTION_EXECUTE_HANDLER is returned to cause control to pass
+//     into the __except block of the __try-__except statement.  There, the
+//     runtime error is identified, an appropriate error message is printed out,
+//     and the program is terminated.
+extern "C" int __cdecl _seh_filter_exe(
+    unsigned long       const xcptnum,
+    PEXCEPTION_POINTERS const pxcptinfoptrs
+    )
+{
+    // Get the PTD and find the action for this exception.  If either of these
+    // fails, return to let the handler search continue.
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+        return EXCEPTION_CONTINUE_SEARCH;
+
+    __crt_signal_action_t* const pxcptact = xcptlookup(xcptnum, ptd->_pxcptacttab);
+    if (pxcptact == nullptr)
+        return EXCEPTION_CONTINUE_SEARCH;
+
+    __crt_signal_handler_t const phandler = pxcptact->_action;
+
+    // The default behavior (SIG_DFL) is not to handle the exception:
+    if (phandler == SIG_DFL)
+        return EXCEPTION_CONTINUE_SEARCH;
+
+    // If the behavior is to die, execute the handler:
+    if (phandler == SIG_DIE)
+    {
+        // Reset the _action (in case of recursion) and enter the __except:
+        pxcptact->_action = SIG_DFL;
+        return EXCEPTION_EXECUTE_HANDLER;
+    }
+
+    // If an exception is ignored, just ignore it:
+    if (phandler == SIG_IGN)
+        return EXCEPTION_CONTINUE_EXECUTION;
+
+    // The remaining exceptions all correspond to C signals which have signal
+    // handlers associated with them.  For some, special setup is required
+    // before the signal handler is called.  In all cases, if the signal handler
+    // returns, -1 is returned by this function to resume execution at the point
+    // where the exception occurred.
+
+    // Save the old exception pointers in case this is a nested exception/signal.
+    PEXCEPTION_POINTERS const old_pxcptinfoptrs = ptd->_tpxcptinfoptrs;
+    ptd->_tpxcptinfoptrs = pxcptinfoptrs;
+
+    // Call the user-supplied signal handler.  Floating point exceptions must be
+    // handled specially since, from the C point of view, there is only one
+    // signal.  The exact identity of the exception is passed in the per-thread
+    // variable _tfpecode.
+    if (pxcptact->_signal_number == SIGFPE)
+    {
+        // Reset the _action field to the default for all SIGFPE entries:
+        __crt_signal_action_t* const first = ptd->_pxcptacttab + __acrt_signal_action_first_fpe_index;
+        __crt_signal_action_t* const last  = first + __acrt_signal_action_fpe_count;
+
+        for (__crt_signal_action_t* it = first; it != last; ++it)
+            it->_action = SIG_DFL;
+
+        // Save the current _tfpecode in case this is a nested floating point
+        // exception.  It's not clear that we need to support this, but it's
+        // easy to support.
+        int const old_fpecode = ptd->_tfpecode;
+
+        // Note:  There are no exceptions corresponding to _FPE_UNEMULATED and
+        // _FPE_SQRTNEG.  Furthermore, STATUS_FLOATING_STACK_CHECK is raised for
+        // both stack overflow and underflow, thus the exception does not
+        // distinguish between _FPE_STACKOVERFLOW and _FPE_STACKUNDERFLOW.
+        // Arbitrarily, _tfpecode is set to the formr value.
+        switch (pxcptact->_exception_number)
+        {
+        case STATUS_FLOAT_DIVIDE_BY_ZERO:    ptd->_tfpecode = _FPE_ZERODIVIDE;      break;
+        case STATUS_FLOAT_INVALID_OPERATION: ptd->_tfpecode = _FPE_INVALID;         break;
+        case STATUS_FLOAT_OVERFLOW:          ptd->_tfpecode = _FPE_OVERFLOW;        break;
+        case STATUS_FLOAT_UNDERFLOW:         ptd->_tfpecode = _FPE_UNDERFLOW;       break;
+        case STATUS_FLOAT_DENORMAL_OPERAND:  ptd->_tfpecode = _FPE_DENORMAL;        break;
+        case STATUS_FLOAT_INEXACT_RESULT:    ptd->_tfpecode = _FPE_INEXACT;         break;
+        case STATUS_FLOAT_STACK_CHECK:       ptd->_tfpecode = _FPE_STACKOVERFLOW;   break;
+        case STATUS_FLOAT_MULTIPLE_TRAPS:    ptd->_tfpecode = _FPE_MULTIPLE_TRAPS;  break;
+        case STATUS_FLOAT_MULTIPLE_FAULTS:   ptd->_tfpecode = _FPE_MULTIPLE_FAULTS; break;
+        }
+
+        // Call the SIGFPE handler.  Note that we cast to the given function
+        // type to support old MS C programs whose SIGFPE handlers expect two
+        // arguments.
+        //
+        // CRT_REFACTOR TODO Can we remove this support?  It's not clear that
+        // this is correct for all architectures (e.g. x64 and ARM).
+        reinterpret_cast<void (__cdecl *)(int, int)>(phandler)(SIGFPE, ptd->_tfpecode);
+
+        // Restore the stored value of _tfpecode:
+        ptd->_tfpecode = old_fpecode;
+    }
+    else
+    {
+        // Reset the _action field to the default, then call the user-
+        // supplied handler:
+        pxcptact->_action = SIG_DFL;
+        phandler(pxcptact->_signal_number);
+    }
+
+    // Restore the stored value of _pxcptinfoptrs:
+    ptd->_tpxcptinfoptrs = old_pxcptinfoptrs;
+
+    return EXCEPTION_CONTINUE_EXECUTION; 
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/getcwd.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/getcwd.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbd1e51549bbb8cbb4d93b8c63aff53da8ecafe6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/getcwd.cpp	
@@ -0,0 +1,265 @@
+/***
+*getcwd.cpp - get current working directory
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*
+*       contains functions _getcwd, _getdcwd and _getcdrv for getting the
+*       current working directory.  getcwd gets the c.w.d. for the default disk
+*       drive, whereas _getdcwd allows one to get the c.w.d. for whatever disk
+*       drive is specified. _getcdrv gets the current drive.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <direct.h>
+#include <errno.h>
+#include <malloc.h>
+#include <stdlib.h>
+
+
+
+// Tests whether the specified drive number is valid.  Returns zero if the drive
+// does not exist; returns one if the drive exists.  Pass zero as an argument to
+// check the default drive.
+static int __cdecl is_valid_drive(unsigned const drive_number) throw()
+{
+    if (drive_number > 26)
+    {
+        _doserrno = ERROR_INVALID_DRIVE;
+        _VALIDATE_RETURN(("Invalid Drive Index" ,0), EACCES, 0);
+    }
+
+    if (drive_number == 0)
+        return 1;
+
+#pragma warning(suppress:__WARNING_UNUSED_ASSIGNMENT) // 28931
+    wchar_t const drive_letter   = static_cast<wchar_t>(L'A' + drive_number - 1);
+    wchar_t const drive_string[] = { drive_letter, L':', L'\\', L'\0' };
+
+    UINT const drive_type = GetDriveTypeW(drive_string);
+    if (drive_type == DRIVE_UNKNOWN || drive_type == DRIVE_NO_ROOT_DIR)
+        return 0;
+
+    return 1;
+}
+
+
+
+/***
+*_TSCHAR *_getcwd(pnbuf, maxlen) - get current working directory of default drive
+*
+*Purpose:
+*       _getcwd gets the current working directory for the user,
+*       placing it in the buffer pointed to by pnbuf. If the length
+*       of the string exceeds the length of the buffer, maxlen,
+*       then nullptr is returned. If pnbuf = nullptr, a buffer of at
+*       least size maxlen is automatically allocated using
+*       malloc() -- a pointer to which is returned by _getcwd().
+*       An entry point "_getdcwd()" is defined which takes the above
+*       parameters, plus a drive number.  "_getcwd()" is implemented
+*       as a call to "_getdcwd()" with the default drive (0).
+*
+*       side effects: no global data is used or affected
+*
+*Entry:
+*       _TSCHAR *pnbuf = pointer to a buffer maintained by the user;
+*       int maxlen = length of the buffer pointed to by pnbuf;
+*
+*Exit:
+*       Returns pointer to the buffer containing the c.w.d. name
+*       (same as pnbuf if non-nullptr; otherwise, malloc is
+*       used to allocate a buffer)
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/***
+*_TSCHAR *_getdcwd(drive, pnbuf, maxlen) - get c.w.d. for given drive
+*
+*Purpose:
+*       _getdcwd gets the current working directory for the user,
+*       placing it in the buffer pointed to by pnbuf. If the length
+*       of the string exceeds the length of the buffer, maxlen,
+*       then nullptr is returned. If pnbuf = nullptr, a buffer of at
+*       least size maxlen is automatically allocated using
+*       malloc() -- a pointer to which is returned by _getdcwd().
+*
+*       side effects: no global data is used or affected
+*
+*Entry:
+*       int drive   - number of the drive being inquired about
+*                     0 = default, 1 = 'a:', 2 = 'b:', etc.
+*       _TSCHAR *pnbuf - pointer to a buffer maintained by the user;
+*       int maxlen  - length of the buffer pointed to by pnbuf;
+*
+*Exit:
+*       Returns pointer to the buffer containing the c.w.d. name
+*       (same as pnbuf if non-nullptr; otherwise, malloc is
+*       used to allocate a buffer)
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+template <typename Character>
+_Success_(return != 0)
+_Ret_z_
+static Character* __cdecl common_getdcwd(
+    int                                            drive_number,
+    _Out_writes_opt_z_(max_count) Character*       user_buffer,
+    int                                      const max_count,
+    int                                      const block_use,
+    _In_opt_z_ char const*                   const file_name,
+    int                                      const line_number
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN(max_count >= 0, EINVAL, nullptr);
+
+    if (drive_number != 0)
+    {
+        // A drive other than the default drive was requested; make sure it
+        // is a valid drive number:
+        if (!is_valid_drive(drive_number))
+        {
+            _doserrno = ERROR_INVALID_DRIVE;
+            _VALIDATE_RETURN(("Invalid Drive", 0), EACCES, nullptr);
+        }
+    }
+    else
+    {
+        // Otherwise, get the drive number of the default drive:
+        drive_number = _getdrive();
+    }
+
+    Character drive_string[4];
+    if (drive_number != 0)
+    {
+        drive_string[0] = static_cast<Character>('A' - 1 + drive_number);
+        drive_string[1] = ':';
+        drive_string[2] = '.';
+        drive_string[3] = '\0';
+    }
+    else
+    {
+        drive_string[0] = '.';
+        drive_string[1] = '\0';
+    }
+
+    if (user_buffer == nullptr)
+    {   // Always new memory suitable for debug mode and releasing to the user.
+        __crt_public_win32_buffer<Character> buffer(
+            __crt_win32_buffer_debug_info(block_use, file_name, line_number)
+        );
+        buffer.allocate(max_count);
+        if (!traits::get_full_path_name(drive_string, buffer))
+        {
+            return buffer.detach();
+        }
+        return nullptr;
+    }
+
+    // Using user buffer. Fail if not enough space.
+    _VALIDATE_RETURN(max_count > 0, EINVAL, nullptr);
+    user_buffer[0] = '\0';
+
+    __crt_no_alloc_win32_buffer<Character> buffer(user_buffer, max_count);
+    if (!traits::get_full_path_name(drive_string, buffer))
+    {
+        return user_buffer;
+    }
+    return nullptr;
+};
+
+
+
+extern "C" char* __cdecl _getcwd(
+    char* const user_buffer,
+    int   const max_length
+    )
+{
+    return common_getdcwd(0, user_buffer, max_length, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" wchar_t* __cdecl _wgetcwd(
+    wchar_t* const user_buffer,
+    int      const max_length
+    )
+{
+    return common_getdcwd(0, user_buffer, max_length, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" char* __cdecl _getdcwd(
+    int   const drive_number,
+    char* const user_buffer,
+    int   const max_length
+    )
+{
+    return common_getdcwd(drive_number, user_buffer, max_length, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" wchar_t* __cdecl _wgetdcwd(
+    int      const drive_number,
+    wchar_t* const user_buffer,
+    int      const max_length
+    )
+{
+    return common_getdcwd(drive_number, user_buffer, max_length, _NORMAL_BLOCK, nullptr, 0);
+}
+
+#ifdef _DEBUG
+
+#undef _getcwd_dbg
+#undef _getdcwd_dbg
+
+extern "C" char* __cdecl _getcwd_dbg(
+    char*       const user_buffer,
+    int         const max_length,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return common_getdcwd(0, user_buffer, max_length, block_use, file_name, line_number);
+}
+
+extern "C" wchar_t* __cdecl _wgetcwd_dbg(
+    wchar_t*       const user_buffer,
+    int            const max_length,
+    int            const block_use,
+    char const*    const file_name,
+    int            const line_number
+    )
+{
+    return common_getdcwd(0, user_buffer, max_length, block_use, file_name, line_number);
+}
+
+extern "C" char* __cdecl _getdcwd_dbg(
+    int         const drive_number,
+    char*       const user_buffer,
+    int         const max_length,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return common_getdcwd(drive_number, user_buffer, max_length, block_use, file_name, line_number);
+}
+
+extern "C" wchar_t* __cdecl _wgetdcwd_dbg(
+    int         const drive_number,
+    wchar_t*    const user_buffer,
+    int         const max_length,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return common_getdcwd(drive_number, user_buffer, max_length, block_use, file_name, line_number);
+}
+
+#endif // _DEBUG
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/getpid.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/getpid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..221d89b179a1ed5d424aead1e6d54eb3f559f8c3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/getpid.cpp	
@@ -0,0 +1,16 @@
+//
+// getpid.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _getpid() function, which gets the current process identifier.
+//
+#include <corecrt_internal.h>
+
+
+
+// Gets the current process identifier.
+extern "C" int __cdecl _getpid()
+{
+    return GetCurrentProcessId();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/invalid_parameter.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/invalid_parameter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..059feabaf6c833192b2f18db5c5226edffe957cd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/invalid_parameter.cpp	
@@ -0,0 +1,309 @@
+//
+// invalid_parameter.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The invalid parameter handlers and related functionality
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+static __crt_state_management::dual_state_global<_invalid_parameter_handler> __acrt_invalid_parameter_handler;
+
+
+
+#if defined _M_X64 && !defined _UCRT_ENCLAVE_BUILD
+
+    static void __cdecl capture_current_context(CONTEXT* const context_record) throw()
+    {
+        ULONG64 ControlPc;
+        ULONG64 EstablisherFrame;
+        ULONG64 ImageBase;
+        PRUNTIME_FUNCTION FunctionEntry;
+        PVOID HandlerData;
+
+        RtlCaptureContext(context_record);
+
+        ControlPc = context_record->Rip;
+        FunctionEntry = RtlLookupFunctionEntry(ControlPc, &ImageBase, nullptr);
+
+        if (FunctionEntry != nullptr)
+        {
+            RtlVirtualUnwind(
+                UNW_FLAG_NHANDLER,
+                ImageBase,
+                ControlPc,
+                FunctionEntry,
+                context_record,
+                &HandlerData,
+                &EstablisherFrame,
+                nullptr);
+        }
+    }
+
+#endif // _M_X64 && !_UCRT_ENCLAVE_BUILD
+
+#if defined _CRT_GLOBAL_STATE_ISOLATION
+
+    // The legacy Windows CRT (msvcrt) does not terminate the process when an
+    // invalid parameter is passed to a library function.  Turning on this
+    // validation for Windows components would be a big app compat problem.
+    //
+    // For OS components the default behavior will be to ignore the invalid parameters
+    // and that is accomplished by providing an empty IPH.
+    static void __cdecl invalid_parameter_handler_continue(
+        wchar_t const * const,    // pszExpression
+        wchar_t const * const,    // pszFunction
+        wchar_t const * const,    // pszFile
+        unsigned int,              // nLine
+        uintptr_t                   // pReserved
+    ) throw()
+    {
+    }
+
+#endif
+
+extern "C" void __cdecl __acrt_initialize_invalid_parameter_handler(void* const encoded_null)
+{
+#if defined _CRT_GLOBAL_STATE_ISOLATION
+    const _invalid_parameter_handler encoded_os_iph = __crt_fast_encode_pointer(invalid_parameter_handler_continue);
+#endif
+    const _invalid_parameter_handler iph[] =
+    {
+        reinterpret_cast<_invalid_parameter_handler>(encoded_null)
+#if defined _CRT_GLOBAL_STATE_ISOLATION
+        ,encoded_os_iph
+#endif
+    };
+
+    __acrt_invalid_parameter_handler.initialize_from_array(iph);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// _invalid_parameter
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" void __cdecl _invalid_parameter_internal(
+    wchar_t const*     const expression,
+    wchar_t const*     const function_name,
+    wchar_t const*     const file_name,
+    unsigned int       const line_number,
+    uintptr_t          const reserved,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    __acrt_ptd * const raw_ptd = ptd.get_raw_ptd_noexit();
+    if (raw_ptd && raw_ptd->_thread_local_iph)
+    {
+        raw_ptd->_thread_local_iph(expression, function_name, file_name, line_number, reserved);
+        return;
+    }
+
+    _invalid_parameter_handler const global_handler = __crt_fast_decode_pointer(__acrt_invalid_parameter_handler.value(ptd));
+    if (global_handler)
+    {
+        global_handler(expression, function_name, file_name, line_number, reserved);
+        return;
+    }
+
+    _invoke_watson(expression, function_name, file_name, line_number, reserved);
+}
+
+extern "C" void __cdecl _invalid_parameter(
+    wchar_t const* const expression,
+    wchar_t const* const function_name,
+    wchar_t const* const file_name,
+    unsigned int   const line_number,
+    uintptr_t      const reserved
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _invalid_parameter_internal(expression, function_name, file_name, line_number, reserved, ptd);
+}
+
+extern "C" void __cdecl _invalid_parameter_noinfo()
+{
+    _invalid_parameter(nullptr, nullptr, nullptr, 0, 0);
+}
+
+// This is used by inline code in the C++ Standard Library and the SafeInt
+// library.  Because it is __declspec(noreturn), the compiler can better
+// optimize use of the invalid parameter handler for inline code.
+extern "C" __declspec(noreturn) void __cdecl _invalid_parameter_noinfo_noreturn()
+{
+    _invalid_parameter(nullptr, nullptr, nullptr, 0, 0);
+    _invoke_watson    (nullptr, nullptr, nullptr, 0, 0);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// _invoke_watson
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#if (defined _M_IX86 || defined _M_X64) && !defined _UCRT_ENCLAVE_BUILD
+
+    extern "C" void __cdecl __acrt_call_reportfault(
+        int   const debugger_hook_code,
+        DWORD const _exception_code,
+        DWORD const _exception_flags
+        )
+    {
+        // Notify the debugger if attached.
+        if (debugger_hook_code != _CRT_DEBUGGER_IGNORE)
+        {
+            _CRT_DEBUGGER_HOOK(debugger_hook_code);
+        }
+
+        // Fake an exception to call report fault:
+        EXCEPTION_RECORD   ExceptionRecord{};
+        CONTEXT            ContextRecord{};
+        EXCEPTION_POINTERS ExceptionPointers = {&ExceptionRecord, &ContextRecord};
+
+        #ifdef _M_IX86
+
+        __asm
+        {
+            mov dword ptr [ContextRecord.Eax  ], eax
+            mov dword ptr [ContextRecord.Ecx  ], ecx
+            mov dword ptr [ContextRecord.Edx  ], edx
+            mov dword ptr [ContextRecord.Ebx  ], ebx
+            mov dword ptr [ContextRecord.Esi  ], esi
+            mov dword ptr [ContextRecord.Edi  ], edi
+            mov word ptr  [ContextRecord.SegSs], ss
+            mov word ptr  [ContextRecord.SegCs], cs
+            mov word ptr  [ContextRecord.SegDs], ds
+            mov word ptr  [ContextRecord.SegEs], es
+            mov word ptr  [ContextRecord.SegFs], fs
+            mov word ptr  [ContextRecord.SegGs], gs
+            pushfd
+            pop [ContextRecord.EFlags]
+        }
+
+        ContextRecord.ContextFlags = CONTEXT_CONTROL;
+
+        ContextRecord.Eip = (ULONG)_ReturnAddress();
+        ContextRecord.Esp = (ULONG)_AddressOfReturnAddress();
+        ContextRecord.Ebp = *((ULONG *)_AddressOfReturnAddress()-1);
+
+        #else // ^^^ _M_IX86 ^^^ // vvv _M_X64 vvv //
+
+        capture_current_context(&ContextRecord);
+        ContextRecord.Rip = (ULONGLONG)_ReturnAddress();
+        ContextRecord.Rsp = (ULONGLONG)_AddressOfReturnAddress()+8;
+
+        #endif // _M_X64
+
+        ExceptionRecord.ExceptionCode    = _exception_code;
+        ExceptionRecord.ExceptionFlags   = _exception_flags;
+        ExceptionRecord.ExceptionAddress = _ReturnAddress();
+
+        BOOL const was_debugger_present = IsDebuggerPresent();
+
+        // Raises an exception that bypasses all exception handlers:
+#pragma warning(suppress:__WARNING_SETUNHANDLEDEXCEPTIONFILTER_USE) // 28725 Use Watson instead of this SetUnhandledExceptionFilter.
+        SetUnhandledExceptionFilter(nullptr);
+        DWORD const handler_result = UnhandledExceptionFilter(&ExceptionPointers);
+
+        // If no handler was found and no debugger was previously attached, then
+        // execution must stop into the debugger hook:
+        if (handler_result == EXCEPTION_CONTINUE_SEARCH && !was_debugger_present && debugger_hook_code != _CRT_DEBUGGER_IGNORE)
+        {
+            _CRT_DEBUGGER_HOOK(debugger_hook_code);
+        }
+    }
+
+    extern "C" __declspec(noreturn) void __cdecl _invoke_watson(
+        wchar_t const* const expression,
+        wchar_t const* const function_name,
+        wchar_t const* const file_name,
+        unsigned int   const line_number,
+        uintptr_t      const reserved
+        )
+    {
+        UNREFERENCED_PARAMETER(expression   );
+        UNREFERENCED_PARAMETER(function_name);
+        UNREFERENCED_PARAMETER(file_name    );
+        UNREFERENCED_PARAMETER(line_number  );
+        UNREFERENCED_PARAMETER(reserved     );
+
+        if (IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE))
+        {
+            __fastfail(FAST_FAIL_INVALID_ARG);
+        }
+
+        // Otherwise, raise a fast-fail exception and termintae the process:
+        __acrt_call_reportfault(
+            _CRT_DEBUGGER_INVALIDPARAMETER,
+            STATUS_INVALID_CRUNTIME_PARAMETER,
+            EXCEPTION_NONCONTINUABLE);
+
+        TerminateProcess(GetCurrentProcess(), STATUS_INVALID_CRUNTIME_PARAMETER);
+    }
+
+#else // ^^^ (_M_IX86 || _M_X64) && !_UCRT_ENCLAVE_BUILD ^^^ // vvv Newer Architectures vvv //
+
+    extern "C" __declspec(noreturn) void __cdecl _invoke_watson(
+        wchar_t const* const expression,
+        wchar_t const* const function_name,
+        wchar_t const* const file_name,
+        unsigned int   const line_number,
+        uintptr_t      const reserved
+        )
+    {
+        UNREFERENCED_PARAMETER(expression   );
+        UNREFERENCED_PARAMETER(function_name);
+        UNREFERENCED_PARAMETER(file_name    );
+        UNREFERENCED_PARAMETER(line_number  );
+        UNREFERENCED_PARAMETER(reserved     );
+
+        __fastfail(FAST_FAIL_INVALID_ARG);
+    }
+
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Handler Accessors
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" _invalid_parameter_handler __cdecl _set_invalid_parameter_handler(_invalid_parameter_handler const new_handler)
+{
+    _invalid_parameter_handler const old_handler = __crt_fast_decode_pointer(__acrt_invalid_parameter_handler.value());
+    __acrt_invalid_parameter_handler.value() = __crt_fast_encode_pointer(new_handler);
+    return old_handler;
+}
+
+extern "C" _invalid_parameter_handler __cdecl _get_invalid_parameter_handler()
+{
+    return __crt_fast_decode_pointer(__acrt_invalid_parameter_handler.value());
+}
+
+
+
+extern "C" _invalid_parameter_handler __cdecl _set_thread_local_invalid_parameter_handler(_invalid_parameter_handler const new_handler)
+{
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    _invalid_parameter_handler const old_handler = ptd->_thread_local_iph;
+    ptd->_thread_local_iph = new_handler;
+    return old_handler;
+}
+
+extern "C" _invalid_parameter_handler __cdecl _get_thread_local_invalid_parameter_handler()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (!ptd)
+    {
+        return nullptr;
+    }
+
+    return ptd->_thread_local_iph;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/is_wctype.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/is_wctype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..35fb6b8316abdddbad93b83b3e8549efff442232
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/is_wctype.cpp	
@@ -0,0 +1,39 @@
+/***
+*iswctype.c - support isw* wctype functions/macros for wide characters
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines iswctype - support isw* wctype functions/macros for
+*       wide characters (esp. > 255).
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+
+/***
+*is_wctype - support obsolete name
+*
+*Purpose:
+*       Name changed from is_wctype to iswctype. is_wctype must be supported.
+*
+*Entry:
+*       wchar_t c    - the wide character whose type is to be tested
+*       wchar_t mask - the mask used by the isw* functions/macros
+*                       corresponding to each character class property
+*
+*Exit:
+*       Returns non-zero if c is of the character class.
+*       Returns 0 if c is not of the character class.
+*
+*Exceptions:
+*       Returns 0 on any error.
+*
+*******************************************************************************/
+extern "C" int __cdecl is_wctype (
+        wint_t c,
+        wctype_t mask
+        )
+{
+    return iswctype(c, mask);
+}
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/perror.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/perror.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1a93e149703bbdce7d1a7ab5936c5316081395e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/perror.cpp	
@@ -0,0 +1,71 @@
+/***
+*perror.c - print system error message
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines perror() - print system error message
+*       System error message are indexed by errno; conforms to XENIX
+*       standard, with much compatability with 1983 uniforum draft standard.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_ptd_propagation.h>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_RETVAL_IGNORED_FUNC_COULD_FAIL) // 6031 return value ignored
+
+/***
+*void perror(message) - print system error message
+*
+*Purpose:
+*       prints user's error message, then follows it with ": ", then the system
+*       error message, then a newline.  All output goes to stderr.  If user's
+*       message is nullptr or a null string, only the system error message is
+*       printer.  If errno is weird, prints "Unknown error".
+*
+*Entry:
+*       const char *message - users message to prefix system error message
+*
+*Exit:
+*       Prints message; no return value.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static void __cdecl _perror_internal(char const* const user_prefix, __crt_cached_ptd_host& ptd)
+{
+    int const fh = 2;
+
+    __acrt_lowio_lock_fh(fh);
+    __try
+    {
+        if (user_prefix != nullptr && user_prefix[0] != '\0')
+        {
+            _write_nolock(fh, user_prefix, static_cast<unsigned>(strlen(user_prefix)), ptd);
+            _write_nolock(fh, ": ", 2, ptd);
+        }
+
+        // Use PTD directly to access previously set errno value.
+        char const* const system_message = _get_sys_err_msg(ptd.get_raw_ptd()->_terrno);
+
+        _write_nolock(fh, system_message, static_cast<unsigned>(strlen(system_message)), ptd);
+        _write_nolock(fh, "\n", 1, ptd);
+
+    }
+    __finally
+    {
+        __acrt_lowio_unlock_fh( fh );
+    }
+}
+
+extern "C" void __cdecl perror(char const* const user_prefix)
+{
+    __crt_cached_ptd_host ptd;
+    return _perror_internal(user_prefix, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/resetstk.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/resetstk.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48694cfd3523c5a44a16b234e4f7bc16beef1393
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/resetstk.cpp	
@@ -0,0 +1,111 @@
+/***
+*resetstk.c - Recover from Stack overflow.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines the _resetstkoflw() function.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <malloc.h>
+
+#define MIN_STACK_REQ_WINNT 2
+ 
+
+
+/***
+* void _resetstkoflw(void) - Recovers from Stack Overflow
+*
+* Purpose:
+*       Sets the guard page to its position before the stack overflow.
+*
+* Exit:
+*       Returns nonzero on success, zero on failure
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _resetstkoflw()
+{
+    LPBYTE pStack, pStackBase, pMaxGuard, pMinGuard;
+    MEMORY_BASIC_INFORMATION mbi;
+    SYSTEM_INFO si;
+    DWORD PageSize;
+    DWORD RegionSize;
+    DWORD flOldProtect;
+    ULONG StackSizeInBytes;
+
+    // Use _alloca() to get the current stack pointer
+#pragma warning(push)
+#pragma warning(disable:6255)
+    // prefast(6255): This alloca is safe and we do not want a __try here
+    pStack = (LPBYTE)_alloca(1);
+#pragma warning(pop)
+
+    // Find the base of the stack.
+
+    if (VirtualQuery(pStack, &mbi, sizeof mbi) == 0) {
+        return 0;
+    }
+
+    pStackBase = (LPBYTE)mbi.AllocationBase;
+
+    GetSystemInfo(&si);
+    PageSize = si.dwPageSize;
+    RegionSize = 0;
+    StackSizeInBytes = 0;               // Indicate just querying
+    if (__acrt_SetThreadStackGuarantee(&StackSizeInBytes) && StackSizeInBytes > 0) {
+        RegionSize = StackSizeInBytes;
+    }
+
+#pragma warning(push)
+#pragma warning(disable:6255)
+    // Silence prefast about overflow/underflow
+    RegionSize = (RegionSize + PageSize - 1) & ~(PageSize - 1);
+#pragma warning(pop)
+
+    //
+    // If there is a stack guarantee (RegionSize nonzero), then increase
+    // our guard page size by 1 so that even a subsequent fault that occurs
+    // midway (instead of at the beginning) through the first guard page
+    // will have the extra page to preserve the guarantee.
+    //
+
+    if (RegionSize != 0) {
+        RegionSize += PageSize;
+    }
+
+    if (RegionSize < MIN_STACK_REQ_WINNT * PageSize) {
+        RegionSize = MIN_STACK_REQ_WINNT * PageSize;
+    }
+
+    //
+    // Find the page(s) just below where the stack pointer currently points.
+    // This is the highest potential guard page.
+    //
+
+    pMaxGuard = (LPBYTE) (((DWORD_PTR)pStack & ~(DWORD_PTR)(PageSize - 1))
+                       - RegionSize);
+
+    //
+    // If the potential guard page is too close to the start of the stack
+    // region, abandon the reset effort for lack of space.  Win9x has a
+    // larger reserved stack requirement.
+    //
+
+    pMinGuard = pStackBase + PageSize;
+
+    if (pMaxGuard < pMinGuard) {
+        return 0;
+    }
+
+    // Set the new guard page just below the current stack page.
+
+    if (VirtualAlloc(pMaxGuard, RegionSize, MEM_COMMIT, PAGE_READWRITE) == nullptr ||
+        VirtualProtect(pMaxGuard, RegionSize, PAGE_READWRITE | PAGE_GUARD, &flOldProtect) == 0) {
+        return 0;
+    }
+
+    return 1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/set_error_mode.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/set_error_mode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a04f9acde2b002f0e64bd48e79b71087c0bd7180
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/set_error_mode.cpp	
@@ -0,0 +1,78 @@
+/***
+*errmode.c - modify __error_mode and __acrt_app_type
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines _set_error_mode() and _set_app_type(), the routines used
+*       to modify __error_mode and __acrt_app_type variables. Together, these
+*       two variables determine how/where the C runtime writes error
+*       messages.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+extern "C" {
+
+
+
+/*
+ * __error_mode, together with __acrt_app_type, determine how error messages
+ * are written out.
+ */
+static int __acrt_error_mode = _OUT_TO_DEFAULT;
+
+/***
+*int _set_error_mode(int modeval) - interface to change __error_mode
+*
+*Purpose:
+*       Control the error (output) sink by setting the value of __error_mode.
+*       Explicit controls are to direct output t o standard error (FILE * or
+*       C handle or NT HANDLE) or to use the MessageBox API. This routine is
+*       exposed and documented for the users.
+*
+*Entry:
+*       int modeval =   _OUT_TO_DEFAULT, error sink is determined by __acrt_app_type
+*                       _OUT_TO_STDERR,  error sink is standard error
+*                       _OUT_TO_MSGBOX,  error sink is a message box
+*                       _REPORT_ERRMODE, report the current __error_mode value
+*
+*Exit:
+*       Returns old setting or -1 if an error occurs.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl _set_error_mode(int const new_error_mode)
+{
+    switch (new_error_mode)
+    {
+    case _OUT_TO_DEFAULT:
+    case _OUT_TO_STDERR:
+    case _OUT_TO_MSGBOX:
+    {
+        int const old_error_mode = __acrt_error_mode;
+        __acrt_error_mode = new_error_mode;
+        return old_error_mode;
+    }
+
+    case _REPORT_ERRMODE:
+    {
+        return __acrt_error_mode;
+    }
+
+    default:
+    {
+        _VALIDATE_RETURN(("Invalid error_mode", 0), EINVAL, -1);
+    }
+    }
+
+    return 0;
+}
+
+
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/seterrm.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/seterrm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..94fc4c2a8c90e457ca4044a830999a4762c9e8b8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/seterrm.cpp	
@@ -0,0 +1,39 @@
+/***
+*seterrm.c - Set mode for handling critical errors
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines signal() and raise().
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+/***
+*void _seterrormode(mode) - set the critical error mode
+*
+*Purpose:
+*
+*Entry:
+*   int mode - error mode:
+*
+*               0 means system displays a prompt asking user how to
+*               respond to the error. Choices differ depending on the
+*               error but may include Abort, Retry, Ignore, and Fail.
+*
+*               1 means the call system call causing the error will fail
+*               and return an error indicating the cause.
+*
+*Exit:
+*   none
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl _seterrormode(int const mode)
+{
+    SetErrorMode(mode);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/signal.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/signal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e0d3db29b946c25fccc500acc43a55fb4f9ccbc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/signal.cpp	
@@ -0,0 +1,579 @@
+//
+// signal.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// signal(), raise(), and related functions
+//
+#include <corecrt_internal.h>
+#include <errno.h>
+#include <excpt.h>
+#include <float.h>
+#include <malloc.h>
+#include <signal.h>
+#include <stddef.h>
+#include <string.h>
+
+
+
+// Variables holding action codes (and code pointers) for SIGINT, SIGBRK,
+// SIGABRT and SIGTERM.
+//
+// note that the disposition (i.e., action to be taken upon receipt) of
+// these signals is defined on a per-process basis (not per-thread)!!
+static __crt_state_management::dual_state_global<__crt_signal_handler_t> ctrlc_action;     // SIGINT
+static __crt_state_management::dual_state_global<__crt_signal_handler_t> ctrlbreak_action; // SIGBREAK
+static __crt_state_management::dual_state_global<__crt_signal_handler_t> abort_action;     // SIGABRT
+static __crt_state_management::dual_state_global<__crt_signal_handler_t> term_action;      // SIGTERM
+
+/*
+ * flag indicated whether or not a handler has been installed to capture
+ * ^C and ^Break events.
+ */
+static bool console_ctrl_handler_installed = false;
+
+#define _SIGHUP_IGNORE 1
+#define _SIGQUIT_IGNORE 3
+#define _SIGPIPE_IGNORE 13
+#define _SIGIOINT_IGNORE 16
+#define _SIGSTOP_IGNORE 17
+
+
+
+// Initializes the signal handler pointers to the encoded nullptr value.
+extern "C" void __cdecl __acrt_initialize_signal_handlers(void* const encoded_nullptr)
+{
+    // The encoded nullptr is SIG_DFL
+    ctrlc_action.initialize    (reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
+    ctrlbreak_action.initialize(reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
+    abort_action.initialize    (reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
+    term_action.initialize     (reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
+}
+
+
+
+// Gets the address of the global action for one of the signals that has a
+// global action.  Returns nullptr if the given signal does not have a global
+// action.
+static __crt_signal_handler_t* __cdecl get_global_action_nolock(int const signum) throw()
+{
+    switch (signum)
+    {
+    // CRT_REFACTOR TODO: PERFORMANCE: for OS mode, these might be able to be in the const data section, instead of in writeable page data.
+    case SIGINT:         return &ctrlc_action.value();
+    case SIGBREAK:       return &ctrlbreak_action.value();
+    case SIGABRT:        return &abort_action.value();
+    case SIGABRT_COMPAT: return &abort_action.value();
+    case SIGTERM:        return &term_action.value();
+    }
+
+    return nullptr;
+}
+
+
+
+// Looks up the exception-action table entry for a signal.  This function finds
+// the first entry in the 'action_table' whose _signal_number field is 'signum'.
+// If no such entry is found, nullptr is returned.
+static __crt_signal_action_t* __cdecl siglookup(
+    int                    const signum,
+    __crt_signal_action_t* const action_table
+    ) throw()
+{
+    // Walk through the table looking for the proper entry.  Note that in the
+    // case where more than one exception corresponds to the same signal, the
+    // first such instance in the table is the one returned.
+    for (__crt_signal_action_t* p = action_table; p != action_table + __acrt_signal_action_table_count; ++p)
+        if (p->_signal_number == signum)
+            return p;
+
+    // If we reached the end of the table, return nullptr:
+    return nullptr;
+}
+
+
+
+// Handles failures for signal().
+static __crt_signal_handler_t __cdecl signal_failed(int const signum) throw()
+{
+    switch (signum)
+    {
+    case _SIGHUP_IGNORE:
+    case _SIGQUIT_IGNORE:
+    case _SIGPIPE_IGNORE:
+    case _SIGIOINT_IGNORE:
+    case _SIGSTOP_IGNORE:
+        return SIG_ERR;
+
+    default:
+        errno = EINVAL;
+        return SIG_ERR;
+    }
+}
+
+// Enclaves have no console, thus also no signals specific to consoles.
+#ifdef _UCRT_ENCLAVE_BUILD
+
+__inline static BOOL is_unsupported_signal(int const signum, __crt_signal_handler_t const sigact)
+{
+    return (sigact == SIG_ACK || sigact == SIG_SGE || signum == SIGINT || signum == SIGBREAK);
+}
+
+__inline static BOOL is_console_signal(int const)
+{
+    return FALSE;
+}
+
+#else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */
+
+__inline static BOOL is_unsupported_signal(int const, __crt_signal_handler_t const sigact)
+{
+    return (sigact == SIG_ACK || sigact == SIG_SGE);
+}
+
+__inline static BOOL is_console_signal(int const signum)
+{
+    return (signum == SIGINT || signum == SIGBREAK);
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+/***
+*static BOOL WINAPI ctrlevent_capture(DWORD ctrl_type) - capture ^C and ^Break events
+*
+*Purpose:
+*       Capture ^C and ^Break events from the console and dispose of them
+*       according the values in ctrlc_action and ctrlbreak_action, resp.
+*       This is the routine that evokes the user-defined action for SIGINT
+*       (^C) or SIGBREAK (^Break) installed by a call to signal().
+*
+*Entry:
+*       DWORD ctrl_type  - indicates type of event, two values:
+*                               CTRL_C_EVENT
+*                               CTRL_BREAK_EVENT
+*
+*Exit:
+*       Returns TRUE to indicate the event (signal) has been handled.
+*       Otherwise, returns FALSE.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static BOOL WINAPI ctrlevent_capture(DWORD const ctrl_type) throw()
+{
+    __crt_signal_handler_t ctrl_action = nullptr;
+    int signal_code = 0;
+
+    __acrt_lock(__acrt_signal_lock);
+    __try
+    {
+        __crt_signal_handler_t* pctrl_action;
+
+        // Identify the type of event and fetch the corresponding action
+        // description:
+        if (ctrl_type == CTRL_C_EVENT)
+        {
+            pctrl_action = &ctrlc_action.value();
+            ctrl_action = __crt_fast_decode_pointer(*pctrl_action);
+            signal_code = SIGINT;
+        }
+        else
+        {
+            pctrl_action = &ctrlbreak_action.value();
+            ctrl_action = __crt_fast_decode_pointer(*pctrl_action);
+            signal_code = SIGBREAK;
+        }
+
+        if (ctrl_action != SIG_DFL && ctrl_action != SIG_IGN)
+        {
+            // Reset the action to be SIG_DFL:
+            *pctrl_action = __crt_fast_encode_pointer(nullptr);
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_signal_lock);
+    }
+
+    // The default signal action leaves the event unhandled, so return false to
+    // indicate such:
+    if (ctrl_action == SIG_DFL)
+        return FALSE;
+
+    // If the action is not to ignore the signal, then invoke the action:
+    if (ctrl_action != SIG_IGN)
+        (*ctrl_action)(signal_code);
+
+    // Then return TRUE to indicate the event has been handled (this may mean
+    // that the even is being ignored):
+    return TRUE;
+}
+
+
+/***
+*__crt_signal_handler_t signal(signum, sigact) - Define a signal handler
+*
+*Purpose:
+*       The signal routine allows the user to define what action should
+*       be taken when various signals occur. The Win32/Dosx32 implementation
+*       supports seven signals, divided up into three general groups
+*
+*       1. Signals corresponding to OS exceptions. These are:
+*                       SIGFPE
+*                       SIGILL
+*                       SIGSEGV
+*          Signal actions for these signals are installed by altering the
+*          _action and SigAction fields for the appropriate entry in the
+*          exception-action table (XcptActTab[]).
+*
+*       2. Signals corresponding to ^C and ^Break. These are:
+*                       SIGINT
+*                       SIGBREAK
+*          Signal actions for these signals are installed by altering the
+*          _ctrlc_action and _ctrlbreak_action variables.
+*
+*       3. Signals which are implemented only in the runtime. That is, they
+*          occur only as the result of a call to raise().
+*                       SIGABRT
+*                       SIGTERM
+*
+*
+*Entry:
+*       int signum      signal type. recognized signal types are:
+*
+*                       SIGABRT         (ANSI)
+*                       SIGBREAK
+*                       SIGFPE          (ANSI)
+*                       SIGILL          (ANSI)
+*                       SIGINT          (ANSI)
+*                       SIGSEGV         (ANSI)
+*                       SIGTERM         (ANSI)
+*                       SIGABRT_COMPAT
+*
+*       __crt_signal_handler_t sigact  signal handling function or action code. the action
+*                       codes are:
+*
+*                       SIG_DFL - take the default action, whatever that may
+*                       be, upon receipt of this type type of signal.
+*
+*                       SIG_DIE - *** ILLEGAL ***
+*                       special code used in the _action field of an
+*                       XcptActTab[] entry to indicate that the runtime is
+*                       to terminate the process upon receipt of the exception.
+*                       not accepted as a value for sigact.
+*
+*                       SIG_IGN - ignore this type of signal
+*
+*                       [function address] - transfer control to this address
+*                       when a signal of this type occurs.
+*
+*Exit:
+*       Good return:
+*       Signal returns the previous value of the signal handling function
+*       (e.g., SIG_DFL, SIG_IGN, etc., or [function address]). This value is
+*       returned in DX:AX.
+*
+*       Error return:
+*       Signal returns -1 and errno is set to EINVAL. The error return is
+*       generally taken if the user submits bogus input values.
+*
+*Exceptions:
+*       None.
+*
+*******************************************************************************/
+
+extern "C" __crt_signal_handler_t __cdecl signal(int signum, __crt_signal_handler_t sigact)
+{
+    // Check for signal actions that are supported on other platforms but not on
+    // this one, and make sure the action is not SIG_DIE:
+    if (is_unsupported_signal(signum, sigact))
+        return signal_failed(signum);
+
+    // First, handle the case where the signal does not correspond to an
+    // exception in the host OS:
+    if (signum == SIGINT         ||
+        signum == SIGBREAK       ||
+        signum == SIGABRT        ||
+        signum == SIGABRT_COMPAT ||
+        signum == SIGTERM)
+    {
+        bool set_console_ctrl_error = false;
+        __crt_signal_handler_t old_action = nullptr;
+
+        __acrt_lock(__acrt_signal_lock);
+        __try
+        {
+            // If the signal is SIGINT or SIGBREAK make sure the handler is
+            // installed to capture ^C and ^Break events:
+            // C4127: conditional expression is constant
+#pragma warning( suppress: 4127 )
+            if (is_console_signal(signum) && !console_ctrl_handler_installed)
+            {
+                if (SetConsoleCtrlHandler(ctrlevent_capture, TRUE))
+                {
+                    console_ctrl_handler_installed = true;
+                }
+                else
+                {
+                    _doserrno = GetLastError();
+                    set_console_ctrl_error = true;
+                }
+            }
+
+            __crt_signal_handler_t* const action_pointer = get_global_action_nolock(signum);
+            if (action_pointer != nullptr)
+            {
+                old_action = __crt_fast_decode_pointer(*action_pointer);
+                if (sigact != SIG_GET)
+                    *action_pointer = __crt_fast_encode_pointer(sigact);
+            }
+        }
+        __finally
+        {
+            __acrt_unlock(__acrt_signal_lock);
+        }
+
+        if (set_console_ctrl_error)
+            return signal_failed(signum);
+
+        return old_action;
+    }
+
+
+    // If we reach here, signum is supposed to be one of the signals which
+    // correspond to exceptions on the host OS.  If it's not one of these,
+    // fail and return immediately:
+    if (signum != SIGFPE && signum != SIGILL && signum != SIGSEGV)
+        return signal_failed(signum);
+
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+        return signal_failed(signum);
+
+    // Check that there is a per-thread instance of the exception-action table
+    // for this thread.  If there isn't, create one:
+    if (ptd->_pxcptacttab == __acrt_exception_action_table)
+    {
+        // Allocate space for an exception-action table:
+        ptd->_pxcptacttab = static_cast<__crt_signal_action_t*>(_malloc_crt(__acrt_signal_action_table_size));
+        if (ptd->_pxcptacttab == nullptr)
+            return signal_failed(signum);
+
+        // Initialize the table by copying the contents of __acrt_exception_action_table:
+        memcpy(ptd->_pxcptacttab, __acrt_exception_action_table, __acrt_signal_action_table_size);
+    }
+
+    // Look up the proper entry in the exception-action table. Note that if
+    // several exceptions are mapped to the same signal, this returns the
+    // pointer to first such entry in the exception action table. It is assumed
+    // that the other entries immediately follow this one.
+    __crt_signal_action_t* const xcpt_action = siglookup(signum, ptd->_pxcptacttab);
+    if (xcpt_action == nullptr)
+        return signal_failed(signum);
+
+    // SIGSEGV, SIGILL and SIGFPE all have more than one exception mapped to
+    // them.  The code below depends on the exceptions corresponding to the same
+    // signal being grouped together in the exception-action table.
+
+    __crt_signal_handler_t const old_action = xcpt_action->_action;
+
+    // If we are not just getting the currently installed action, loop through
+    // all the entries corresponding to the given signal and update them as
+    // appropriate:
+    if (sigact != SIG_GET)
+    {
+        __crt_signal_action_t* const last = ptd->_pxcptacttab + __acrt_signal_action_table_count;
+
+        // Iterate until we reach the end of the table or we reach the end of
+        // the range of actions for this signal, whichever comes first:
+        for (__crt_signal_action_t* p = xcpt_action; p != last && p->_signal_number == signum; ++p)
+        {
+            p->_action = sigact;
+        }
+    }
+
+    return old_action;
+}
+
+
+
+/***
+*int raise(signum) - Raise a signal
+*
+*Purpose:
+*       This routine raises a signal (i.e., performs the action currently
+*       defined for this signal). The action associated with the signal is
+*       evoked directly without going through intermediate dispatching or
+*       handling.
+*
+*Entry:
+*       int signum - signal type (e.g., SIGINT)
+*
+*Exit:
+*       returns 0 on good return, -1 on bad return.
+*
+*Exceptions:
+*       May not return.  Raise has no control over the action
+*       routines defined for the various signals.  Those routines may
+*       abort, terminate, etc.  In particular, the default actions for
+*       certain signals will terminate the program.
+*
+*******************************************************************************/
+extern "C" int __cdecl raise(int const signum)
+{
+    __acrt_ptd* ptd = nullptr;
+    int old_fpecode = 0;
+
+    __crt_signal_handler_t* action_pointer = nullptr;
+    bool action_is_global = true;
+    switch (signum)
+    {
+    case SIGINT:
+    case SIGBREAK:
+    case SIGABRT:
+    case SIGABRT_COMPAT:
+    case SIGTERM:
+        action_pointer = get_global_action_nolock(signum);;
+        break;
+
+    case SIGFPE:
+    case SIGILL:
+    case SIGSEGV:
+    {
+        ptd = __acrt_getptd_noexit();
+        if (ptd == nullptr)
+            return -1;
+
+        __crt_signal_action_t* const local_action = siglookup(signum, ptd->_pxcptacttab);
+        _VALIDATE_RETURN(local_action != nullptr, EINVAL, -1);
+        action_pointer = &local_action->_action;
+        action_is_global = false;
+        break;
+    }
+    default:
+        // unsupported signal, return an error
+        _VALIDATE_RETURN(("Invalid signal or error", 0), EINVAL, -1);
+    }
+
+
+    PEXCEPTION_POINTERS old_pxcptinfoptrs = nullptr;
+
+    // If the action is global, we must acquire the lock before accessing it:
+    if (action_is_global)
+        __acrt_lock(__acrt_signal_lock);
+
+    __crt_signal_handler_t action = nullptr;
+    bool return0 = false;
+    __try
+    {
+        // Global function pointers are encoded; per-thread pointers are not:
+        action = action_is_global ? __crt_fast_decode_pointer(*action_pointer) : *action_pointer;
+
+        // If the current action is SIG_IGN, just return:
+        return0 = action == SIG_IGN;
+        if (return0)
+            __leave;
+
+        // If the current action is SIG_DFL, take the default action.  The current
+        // default action for all of the supported signals is to terminate with an
+        // exit code of 3:
+        if (action == SIG_DFL)
+        {
+            // Be sure to unlock before entering the exit code.  The exit function
+            // does not return.
+            if (action_is_global)
+                __acrt_unlock(__acrt_signal_lock);
+
+            _exit(3);
+        }
+
+        // For signals that correspond to exceptions, set the pointer to the
+        // EXCEPTION_POINTERS structure to nullptr:
+        if (signum == SIGFPE  || signum == SIGSEGV || signum == SIGILL)
+        {
+            old_pxcptinfoptrs = ptd->_tpxcptinfoptrs;
+            ptd->_tpxcptinfoptrs = nullptr;
+
+            // If the signal is SIGFPE, also set _fpecode to _FPE_EXPLICITGEN:
+            if ( signum == SIGFPE )
+            {
+                old_fpecode = _fpecode;
+                _fpecode = _FPE_EXPLICITGEN;
+            }
+        }
+
+        // Reset the action to SIG_DFL before calling the user-specified handler.
+        // For SIGFPE, we must reset the action for all of the FP exceptions:
+        if (signum == SIGFPE)
+        {
+            __crt_signal_action_t* const first = ptd->_pxcptacttab + __acrt_signal_action_first_fpe_index;
+            __crt_signal_action_t* const last = first + __acrt_signal_action_fpe_count;
+
+            for (__crt_signal_action_t* p = first; p != last; ++p)
+            {
+                p->_action = SIG_DFL;
+            }
+        }
+        else
+        {
+            *action_pointer = __crt_fast_encode_pointer(nullptr);
+        }
+    }
+    __finally
+    {
+        if (action_is_global)
+            __acrt_unlock(__acrt_signal_lock);
+    }
+
+    if (return0)
+        return 0;
+
+    // Call the user-specified handler routine.  For SIGFPE, we have special
+    // code to support old handlers which expect the value of _fpecode as the
+    // second argument:
+    if (signum == SIGFPE)
+    {
+        reinterpret_cast<void(__cdecl*)(int,int)>(action)(SIGFPE, _fpecode);
+    }
+    else
+    {
+        action(signum);
+    }
+
+
+    // For signals that correspond to exceptions, restore the pointer to the
+    // EXCEPTION_POINTERS structure:
+    if (signum == SIGFPE  ||  signum == SIGSEGV || signum == SIGILL)
+    {
+        ptd->_tpxcptinfoptrs = old_pxcptinfoptrs;
+
+        // If signum is SIGFPE, also restore _fpecode
+        if (signum == SIGFPE)
+            _fpecode = old_fpecode;
+    }
+
+    return 0;
+}
+
+
+// Gets the SIGABRT signal handling function
+extern "C" __crt_signal_handler_t __cdecl __acrt_get_sigabrt_handler()
+{
+    return __acrt_lock_and_call(__acrt_signal_lock, []
+    {
+        return __crt_fast_decode_pointer(abort_action.value());
+    });
+}
+
+// Gets the FPE code for the current thread
+extern "C" int* __cdecl __fpecode()
+{
+    return &__acrt_getptd()->_tfpecode;
+}
+
+// Returns a pointer to the signal handlers for the current thread
+extern "C" void** __cdecl __pxcptinfoptrs()
+{
+    return reinterpret_cast<void**>(&__acrt_getptd()->_tpxcptinfoptrs);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/slbeep.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/slbeep.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a3dd7c3178df6b5faf0299d02921eeefe9408c15
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/slbeep.cpp	
@@ -0,0 +1,60 @@
+/***
+*slbeep.c - Sleep and beep
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _sleep() and _beep()
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+/***
+*void _sleep(duration) - Length of sleep
+*
+*Purpose:
+*
+*Entry:
+*       unsigned long duration - length of sleep in milliseconds or
+*       one of the following special values:
+*
+*           _SLEEP_MINIMUM - Sends a yield message without any delay
+*           _SLEEP_FOREVER - Never return
+*
+*Exit:
+*       None
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl _sleep(unsigned long duration)
+{
+    if (duration == 0)
+        ++duration;
+    
+    Sleep(duration);
+}
+
+/***
+*void _beep(frequency, duration) - Length of sleep
+*
+*Purpose:
+*
+*Entry:
+*       unsigned frequency - frequency in hertz
+*       unsigned duration - length of beep in milliseconds
+*
+*Exit:
+*       None
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl _beep(unsigned const frequency, unsigned const duration)
+{
+    Beep(frequency, duration);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/strerror.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/strerror.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8fad84c4c0dd99626ac0a34e52b0d6d4ba3df67
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/strerror.cpp	
@@ -0,0 +1,146 @@
+//
+// strerror.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the strerror() family of functions, which convert an errno error code
+// to a string representation.  Note that there are legacy implementations of
+// these functions, prefixed with underscores, in _strerr.cpp.  The functions in
+// this file are implemented per the C Standard Library specification.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+// These functions return the error string to be used when we are unable to return
+// the actual error string.
+_Ret_z_
+static char* get_failure_string(char) throw()
+{
+    return const_cast<char*>("Visual C++ CRT: Not enough memory to complete call to strerror.");
+}
+
+_Ret_z_
+static wchar_t* get_failure_string(wchar_t) throw()
+{
+    return const_cast<wchar_t*>(L"Visual C++ CRT: Not enough memory to complete call to strerror.");
+}
+
+
+
+// These functions return a reference to the thread-local pointer to the buffer
+// to be used to store the error string.
+static char*& get_ptd_buffer(__acrt_ptd* const ptd, char) throw()
+{
+    return ptd->_strerror_buffer;
+}
+
+static wchar_t*& get_ptd_buffer(__acrt_ptd* const ptd, wchar_t) throw()
+{
+    return ptd->_wcserror_buffer;
+}
+
+
+
+// These functions copy the narrow string into the provided buffer.
+_Success_(return == 0)
+static errno_t copy_string_into_buffer(
+    _In_reads_or_z_(max_count)      char const* const   string,
+    _Out_writes_z_(buffer_count)    char*       const   buffer,
+                                    size_t      const   buffer_count,
+                                    size_t      const   max_count
+    ) throw()
+{
+    return strncpy_s(buffer, buffer_count, string, max_count);
+}
+
+_Success_(return == 0)
+static errno_t copy_string_into_buffer(
+    _In_reads_or_z_(max_count) char const* const string,
+    _Out_writes_z_(buffer_count) wchar_t* const buffer,
+    size_t      const buffer_count,
+    size_t      const max_count
+    ) throw()
+{
+    return mbstowcs_s(nullptr, buffer, buffer_count, string, max_count);
+}
+
+
+
+// Maps an error number to an error message string.  The error number should be
+// one of the errno values.  The string is valid until the next call (on this
+// thread) to one of the strerror functions.  The CRT owns the string.
+template <typename Character>
+_Ret_z_
+static Character* __cdecl common_strerror(int const error_number)
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (!ptd)
+        return get_failure_string(Character());
+
+    Character*& buffer = get_ptd_buffer(ptd, Character());
+    if (!buffer)
+        buffer = _calloc_crt_t(Character, strerror_buffer_count).detach();
+
+    if (!buffer)
+        return get_failure_string(Character());
+
+    _ERRCHECK(copy_string_into_buffer(_get_sys_err_msg(error_number), buffer, strerror_buffer_count, strerror_buffer_count - 1));
+    return buffer;
+}
+
+extern "C" char* __cdecl strerror(int const error_number)
+{
+    return common_strerror<char>(error_number);
+}
+
+extern "C" wchar_t* __cdecl _wcserror(int const error_number)
+{
+    return common_strerror<wchar_t>(error_number);
+}
+
+
+
+// Maps an error number to an error message string.  The error number should be
+// one of the errno values.  The string is copied into the provided buffer.  On
+// success or truncation, 0 is returned.  Otherwise, an error code is returned.
+template <typename Character>
+static errno_t __cdecl common_strerror_s(
+    _Out_writes_z_(buffer_count)    Character* const    buffer,
+                                    size_t     const    buffer_count,
+                                    int        const    error_number
+    )
+{
+    _VALIDATE_RETURN_ERRCODE(buffer != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(buffer_count > 0,  EINVAL);
+
+    errno_t const result = _ERRCHECK_EINVAL_ERANGE(copy_string_into_buffer(
+        _get_sys_err_msg(error_number),
+        buffer,
+        buffer_count,
+        _TRUNCATE));
+
+    return result == STRUNCATE ? 0 : result;
+}
+
+extern "C" errno_t __cdecl strerror_s(
+    char*  const buffer,
+    size_t const buffer_count,
+    int    const error_number
+    )
+{
+    return common_strerror_s(buffer, buffer_count, error_number);
+}
+
+extern "C" errno_t __cdecl _wcserror_s(
+    wchar_t* const buffer,
+    size_t   const buffer_count,
+    int      const error_number
+    )
+{
+    return common_strerror_s(buffer, buffer_count, error_number);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/syserr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/syserr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a31b48e92bd63a6dad8cfd127014cc86310b8f61
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/syserr.cpp	
@@ -0,0 +1,150 @@
+/***
+*syserr.c - system error list
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Defines the System Error List, containing the full messages for
+*       all errno values set by the library routines.
+*       Defines sys_errlist, sys_nerr.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+#undef _sys_nerr
+#undef _sys_errlist
+
+extern "C" char const* const _sys_errlist[] =
+{
+    /*  0                 */  "No error",
+    /*  1 EPERM           */  "Operation not permitted",
+    /*  2 ENOENT          */  "No such file or directory",
+    /*  3 ESRCH           */  "No such process",
+    /*  4 EINTR           */  "Interrupted function call",
+    /*  5 EIO             */  "Input/output error",
+    /*  6 ENXIO           */  "No such device or address",
+    /*  7 E2BIG           */  "Arg list too long",
+    /*  8 ENOEXEC         */  "Exec format error",
+    /*  9 EBADF           */  "Bad file descriptor",
+    /* 10 ECHILD          */  "No child processes",
+    /* 11 EAGAIN          */  "Resource temporarily unavailable",
+    /* 12 ENOMEM          */  "Not enough space",
+    /* 13 EACCES          */  "Permission denied",
+    /* 14 EFAULT          */  "Bad address",
+    /* 15 ENOTBLK         */  "Unknown error",                     /* not POSIX */
+    /* 16 EBUSY           */  "Resource device",
+    /* 17 EEXIST          */  "File exists",
+    /* 18 EXDEV           */  "Improper link",
+    /* 19 ENODEV          */  "No such device",
+    /* 20 ENOTDIR         */  "Not a directory",
+    /* 21 EISDIR          */  "Is a directory",
+    /* 22 EINVAL          */  "Invalid argument",
+    /* 23 ENFILE          */  "Too many open files in system",
+    /* 24 EMFILE          */  "Too many open files",
+    /* 25 ENOTTY          */  "Inappropriate I/O control operation",
+    /* 26 ETXTBSY         */  "Unknown error",                     /* not POSIX */
+    /* 27 EFBIG           */  "File too large",
+    /* 28 ENOSPC          */  "No space left on device",
+    /* 29 ESPIPE          */  "Invalid seek",
+    /* 30 EROFS           */  "Read-only file system",
+    /* 31 EMLINK          */  "Too many links",
+    /* 32 EPIPE           */  "Broken pipe",
+    /* 33 EDOM            */  "Domain error",
+    /* 34 ERANGE          */  "Result too large",
+    /* 35 EUCLEAN         */  "Unknown error",                     /* not POSIX */
+    /* 36 EDEADLK         */  "Resource deadlock avoided",
+    /* 37 UNKNOWN         */  "Unknown error",
+    /* 38 ENAMETOOLONG    */  "Filename too long",
+    /* 39 ENOLCK          */  "No locks available",
+    /* 40 ENOSYS          */  "Function not implemented",
+    /* 41 ENOTEMPTY       */  "Directory not empty",
+    /* 42 EILSEQ          */  "Illegal byte sequence",
+    /* 43                 */  "Unknown error"
+};
+
+extern "C" char const* const _sys_posix_errlist[] =
+{
+    /* 100 EADDRINUSE      */  "address in use",
+    /* 101 EADDRNOTAVAIL   */  "address not available",
+    /* 102 EAFNOSUPPORT    */  "address family not supported",
+    /* 103 EALREADY        */  "connection already in progress",
+    /* 104 EBADMSG         */  "bad message",
+    /* 105 ECANCELED       */  "operation canceled",
+    /* 106 ECONNABORTED    */  "connection aborted",
+    /* 107 ECONNREFUSED    */  "connection refused",
+    /* 108 ECONNRESET      */  "connection reset",
+    /* 109 EDESTADDRREQ    */  "destination address required",
+    /* 110 EHOSTUNREACH    */  "host unreachable",
+    /* 111 EIDRM           */  "identifier removed",
+    /* 112 EINPROGRESS     */  "operation in progress",
+    /* 113 EISCONN         */  "already connected",
+    /* 114 ELOOP           */  "too many symbolic link levels",
+    /* 115 EMSGSIZE        */  "message size",
+    /* 116 ENETDOWN        */  "network down",
+    /* 117 ENETRESET       */  "network reset",
+    /* 118 ENETUNREACH     */  "network unreachable",
+    /* 119 ENOBUFS         */  "no buffer space",
+    /* 120 ENODATA         */  "no message available",
+    /* 121 ENOLINK         */  "no link",
+    /* 122 ENOMSG          */  "no message",
+    /* 123 ENOPROTOOPT     */  "no protocol option",
+    /* 124 ENOSR           */  "no stream resources",
+    /* 125 ENOSTR          */  "not a stream",
+    /* 126 ENOTCONN        */  "not connected",
+    /* 127 ENOTRECOVERABLE */  "state not recoverable",
+    /* 128 ENOTSOCK        */  "not a socket",
+    /* 129 ENOTSUP         */  "not supported",
+    /* 130 EOPNOTSUPP      */  "operation not supported",
+    /* 131 EOTHER          */  "Unknown error",
+    /* 132 EOVERFLOW       */  "value too large",
+    /* 133 EOWNERDEAD      */  "owner dead",
+    /* 134 EPROTO          */  "protocol error",
+    /* 135 EPROTONOSUPPORT */  "protocol not supported",
+    /* 136 EPROTOTYPE      */  "wrong protocol type",
+    /* 137 ETIME           */  "stream timeout",
+    /* 138 ETIMEDOUT       */  "timed out",
+    /* 139 ETXTBSY         */  "text file busy",
+    /* 140 EWOULDBLOCK     */  "operation would block",
+    /* 141                 */  "Unknown error"
+};
+
+
+extern "C" size_t const _sys_first_posix_error = 100;
+extern "C" size_t const _sys_last_posix_error = _sys_first_posix_error + _countof(_sys_posix_errlist) - 1;
+extern "C" int const _sys_nerr = _countof(_sys_errlist) - 1;
+
+// The above array contains all the errors including unknown error
+
+
+/* ***NOTE: Global variable max_system_error_message_count (in file corecrt_internal.h)
+   indicates the length of the longest system error message in the above table.
+   When you add or modify a message, you must update the value
+   max_system_error_message_count, if appropriate. */
+
+/***
+*int * __sys_nerr();                                 - return pointer to thread's errno
+*const char * const * __cdecl __sys_errlist(void);   - return pointer to thread's _doserrno
+*
+*Purpose:
+*       Returns former global variables
+*
+*Entry:
+*       None.
+*
+*Exit:
+*       See above.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" int* __cdecl __sys_nerr()
+{
+    return const_cast<int*>(&_sys_nerr);
+}
+
+extern "C" char** __cdecl __sys_errlist()
+{
+    return const_cast<char**>(_sys_errlist);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/systime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/systime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..649de7d21745c2fccb92a19cc3bebcd1d902acbd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/systime.cpp	
@@ -0,0 +1,63 @@
+//
+// systime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _getsystime() and _setsystime() functions.
+//
+#include <corecrt_internal_time.h>
+
+
+
+// Gets the current system time and stores it in 'result'.  Returns the number
+// of milliseconds (the 'result' cannot store milliseconds).
+extern "C" unsigned __cdecl _getsystime(struct tm* const result)
+{
+    _VALIDATE_RETURN(result != nullptr, EINVAL, 0)
+
+    SYSTEMTIME local_time;
+    GetLocalTime(&local_time);
+
+    result->tm_isdst       = -1; // mktime() computes whether this is
+                              // during Standard or Daylight time.
+    result->tm_sec         = static_cast<int>(local_time.wSecond);
+    result->tm_min         = static_cast<int>(local_time.wMinute);
+    result->tm_hour        = static_cast<int>(local_time.wHour);
+    result->tm_mday        = static_cast<int>(local_time.wDay);
+    result->tm_mon         = static_cast<int>(local_time.wMonth - 1);
+    result->tm_year        = static_cast<int>(local_time.wYear - 1900);
+    result->tm_wday        = static_cast<int>(local_time.wDayOfWeek);
+
+    // Normalize uninitialized fields:
+    _mktime32(result);
+
+    return (local_time.wMilliseconds);
+}
+
+
+
+// Sets the system time to the time specified by 'source' and 'milliseconds.
+// Returns zero on success; returns a system error code on failure.
+extern "C" unsigned __cdecl _setsystime(struct tm* const source, unsigned const milliseconds)
+{
+    _ASSERTE(source != nullptr);
+    if (source == nullptr)
+        return ERROR_INVALID_PARAMETER;
+
+    // Normalize uninitialized fields:
+    _mktime32(source);
+
+    SYSTEMTIME local_time;
+    local_time.wYear         = static_cast<WORD>(source->tm_year + 1900);
+    local_time.wMonth        = static_cast<WORD>(source->tm_mon + 1);
+    local_time.wDay          = static_cast<WORD>(source->tm_mday);
+    local_time.wHour         = static_cast<WORD>(source->tm_hour);
+    local_time.wMinute       = static_cast<WORD>(source->tm_min);
+    local_time.wSecond       = static_cast<WORD>(source->tm_sec);
+    local_time.wMilliseconds = static_cast<WORD>(milliseconds);
+
+    if (!SetLocalTime(&local_time))
+        return static_cast<int>(GetLastError());
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/terminate.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/terminate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cc9bfb348f63241fa1358674ccd09141592da753
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/terminate.cpp	
@@ -0,0 +1,59 @@
+//
+// terminate.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The terminate handler
+//
+#include <corecrt_internal.h>
+#include <corecrt_terminate.h>
+
+
+
+static terminate_handler __cdecl get_terminate_or_default(
+    __acrt_ptd const* const ptd
+    ) throw()
+{
+    return ptd->_terminate ? ptd->_terminate : &abort;
+}
+
+extern "C" terminate_handler __cdecl _get_terminate()
+{
+    return get_terminate_or_default(__acrt_getptd());
+}
+
+extern "C" terminate_handler __cdecl set_terminate(
+    terminate_handler const new_handler
+    ) throw()
+{
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    terminate_handler const old_handler = get_terminate_or_default(ptd);
+
+    ptd->_terminate = new_handler;
+
+    return old_handler;
+}
+
+extern "C" void __cdecl terminate() throw()
+{
+    terminate_handler const handler = __acrt_getptd()->_terminate;
+    if (handler)
+    {
+        // Note:  We cannot allow any exceptions to propagate from a user-
+        // registered terminate handler, so if any structured exception escapes
+        // the user handler we abort.
+        __try
+        {
+            handler();
+        }
+        __except(EXCEPTION_EXECUTE_HANDLER)
+        {
+            ; // Deliberately do nothing
+        }
+    }
+
+    // If the terminate handler returned, faulted, or otherwise failed to end
+    // execution, we will do it:
+    abort();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/wperror.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/wperror.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2008602c3bbfaf908d8b89252ac179d9f0e04c98
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/misc/wperror.cpp	
@@ -0,0 +1,66 @@
+/***
+*wperror.c - print system error message (wchar_t version)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _wperror() - print wide system error message
+*       System error message are indexed by errno.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <corecrt_internal_lowio.h>
+#include <io.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/***
+*void _wperror(wmessage) - print system error message
+*
+*Purpose:
+*       prints user's error message, then follows it with ": ", then the system
+*       error message, then a newline.  All output goes to stderr.  If user's
+*       message is nullptr or a null string, only the system error message is
+*       printer.  If errno is weird, prints "Unknown error".
+*
+*Entry:
+*       const wchar_t *wmessage - users message to prefix system error message
+*
+*Exit:
+*       Prints message; no return value.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl _wperror(wchar_t const* const wide_user_prefix)
+{
+    // If the user did not provide a prefix, we can just call perror:
+    if (wide_user_prefix == nullptr || wide_user_prefix[0] == L'\0')
+        return perror(nullptr);
+
+    // Otherwise, we need to convert the prefix into a narrow string then pass
+    // it to perror:
+    size_t required_count = 0;
+    _ERRCHECK_EINVAL_ERANGE(wcstombs_s(&required_count, nullptr, 0, wide_user_prefix, INT_MAX));
+    if (required_count == 0)
+        return;
+
+    __crt_unique_heap_ptr<char> const narrow_user_prefix(_calloc_crt_t(char, required_count));
+    if (narrow_user_prefix.get() == nullptr)
+        return;
+
+    errno_t const conversion_result = _ERRCHECK_EINVAL_ERANGE(wcstombs_s(
+        nullptr,
+        narrow_user_prefix.get(),
+        required_count,
+        wide_user_prefix,
+        _TRUNCATE));
+
+    if (conversion_result != 0)
+        return;
+
+    return perror(narrow_user_prefix.get());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/abort.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/abort.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d99a21ddba4b6304e1bdef31d5348cc4ded56d50
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/abort.cpp	
@@ -0,0 +1,114 @@
+/***
+*abort.c - abort a program by raising SIGABRT
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines abort() - print a message and raise SIGABRT.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <signal.h>
+#include <stdlib.h>
+
+#ifdef _DEBUG
+    #define _INIT_ABORT_BEHAVIOR _WRITE_ABORT_MSG
+#else
+    #define _INIT_ABORT_BEHAVIOR _CALL_REPORTFAULT
+#endif
+
+extern "C" unsigned int __abort_behavior = _INIT_ABORT_BEHAVIOR;
+
+/***
+*void abort() - abort the current program by raising SIGABRT
+*
+*Purpose:
+*   print out an abort message and raise the SIGABRT signal.  If the user
+*   hasn't defined an abort handler routine, terminate the program
+*   with exit status of 3 without cleaning up.
+*
+*   Multi-thread version does not raise SIGABRT -- this isn't supported
+*   under multi-thread.
+*
+*Entry:
+*   None.
+*
+*Exit:
+*   Does not return.
+*
+*Uses:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+extern "C" void __cdecl abort()
+{
+    #ifdef _DEBUG
+    if (__abort_behavior & _WRITE_ABORT_MSG)
+    {
+        __acrt_report_runtime_error(L"abort() has been called");
+    }
+    #endif
+
+
+    /* Check if the user installed a handler for SIGABRT.
+     * We need to read the user handler atomically in the case
+     * another thread is aborting while we change the signal
+     * handler.
+     */
+    __crt_signal_handler_t const sigabrt_action = __acrt_get_sigabrt_handler();
+    if (sigabrt_action != SIG_DFL)
+    {
+        raise(SIGABRT);
+    }
+
+    /* If there is no user handler for SIGABRT or if the user
+     * handler returns, then exit from the program anyway
+     */
+
+    if (__abort_behavior & _CALL_REPORTFAULT)
+    {
+        #if defined _M_ARM || defined _M_ARM64 || defined _M_ARM64EC || defined _UCRT_ENCLAVE_BUILD
+        __fastfail(FAST_FAIL_FATAL_APP_EXIT);
+        #else
+        if (IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE))
+            __fastfail(FAST_FAIL_FATAL_APP_EXIT);
+
+        __acrt_call_reportfault(_CRT_DEBUGGER_ABORT, STATUS_FATAL_APP_EXIT, EXCEPTION_NONCONTINUABLE);
+        #endif
+    }
+
+
+    /* If we don't want to call ReportFault, then we call _exit(3), which is the
+     * same as invoking the default handler for SIGABRT
+     */
+
+
+    _exit(3);
+}
+
+/***
+*unsigned int _set_abort_behavior(unsigned int, unsigned int) - set the behavior on abort
+*
+*Purpose:
+*
+*Entry:
+*   unsigned int flags - the flags we want to set
+*   unsigned int mask - mask the flag values
+*
+*Exit:
+*   Return the old behavior flags
+*
+*Exceptions:
+*   None
+*
+*******************************************************************************/
+
+extern "C" unsigned int __cdecl _set_abort_behavior(unsigned int flags, unsigned int mask)
+{
+    unsigned int oldflags = __abort_behavior;
+    __abort_behavior = oldflags & (~mask) | flags & mask;
+    return oldflags;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_data.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..438fde1cd31c74f8409ead3d18855da2d7f7b5fe
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_data.cpp	
@@ -0,0 +1,75 @@
+//
+// argv_data.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This file defines the global data that stores the command line with which the
+// program was executed, along with the parsed arguments (if the arguments were
+// parsed), and the accessors for the global data.
+//
+#include <corecrt_internal.h>
+
+
+
+extern "C" {
+
+
+// Note:  In general, either the narrow or wide string variables will be set,
+// but not both.  These get initialized by the CRT startup sequence before any
+// user code is executed.  There are cases where any or all of the pointers may
+// be null during execution.  Do not assume that they are non-null.
+
+int       __argc   = 0;       // The number of arguments in __argv or __wargv
+char**    __argv   = nullptr; // The arguments as narrow strings
+wchar_t** __wargv  = nullptr; // The arguments as wide strings
+char*     _pgmptr  = nullptr; // The name of the program as a narrow string
+wchar_t*  _wpgmptr = nullptr; // The name of the program as a wide string
+char*     _acmdln  = nullptr; // The raw command line as a narrow string
+wchar_t*  _wcmdln  = nullptr; // The raw command line as a wide string
+
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+
+int*       __cdecl __p___argc()   { return &__argc;   }
+char***    __cdecl __p___argv()   { return &__argv;   }
+wchar_t*** __cdecl __p___wargv()  { return &__wargv;  }
+char**     __cdecl __p__pgmptr()  { return &_pgmptr;  }
+wchar_t**  __cdecl __p__wpgmptr() { return &_wpgmptr; }
+char**     __cdecl __p__acmdln()  { return &_acmdln;  }
+wchar_t**  __cdecl __p__wcmdln()  { return &_wcmdln;  }
+
+errno_t __cdecl _get_wpgmptr(wchar_t** const result)
+{
+    _VALIDATE_RETURN_ERRCODE(result   != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(_wpgmptr != nullptr, EINVAL);
+
+    *result = _wpgmptr;
+    return 0;
+}
+
+errno_t __cdecl _get_pgmptr(char** const result)
+{
+    _VALIDATE_RETURN_ERRCODE(result  != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(_pgmptr != nullptr, EINVAL);
+    *result = _pgmptr;
+    return 0;
+}
+
+_END_SECURE_CRT_DEPRECATION_DISABLE
+
+
+
+bool __cdecl __acrt_initialize_command_line()
+{
+    _acmdln = GetCommandLineA();
+    _wcmdln = GetCommandLineW();
+    return true;
+}
+
+bool __cdecl __acrt_uninitialize_command_line(bool const /* terminating */)
+{
+    return true;
+}
+
+
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_parsing.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_parsing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c08558423076207fd4e94f497319469780a94368
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_parsing.cpp	
@@ -0,0 +1,404 @@
+/***
+*stdargv.c - standard & wildcard _setargv routine
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       processes program command line, with or without wildcard expansion
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_traits.h>
+#include <limits.h>
+#include <mbstring.h>
+#include <stdlib.h>
+
+
+
+// In the function below, we need to ensure that we've initialized the mbc table
+// before we start performing character transformations.
+static void do_locale_initialization(char)    throw() { __acrt_initialize_multibyte(); }
+static void do_locale_initialization(wchar_t) throw() { /* no-op */                    }
+
+static char*    get_command_line(char)    throw() { return _acmdln; }
+static wchar_t* get_command_line(wchar_t) throw() { return _wcmdln; }
+
+static char**&    get_argv(char)    throw() { return __argv;  }
+static wchar_t**& get_argv(wchar_t) throw() { return __wargv; }
+
+static errno_t expand_argv_wildcards(
+    _In_z_               char**  const argv,
+    _Out_ _Deref_post_z_ char*** const expanded_argv) throw()
+{
+    return __acrt_expand_narrow_argv_wildcards(argv, expanded_argv);
+}
+
+static errno_t expand_argv_wildcards(
+    _In_z_               wchar_t**  const argv,
+    _Out_ _Deref_post_z_ wchar_t*** const expanded_argv) throw()
+{
+    return __acrt_expand_wide_argv_wildcards(argv, expanded_argv);
+}
+
+
+
+/***
+*static void parse_cmdline(cmdstart, argv, args, argument_count, character_count)
+*
+*Purpose:
+*       Parses the command line and sets up the argv[] array.
+*       On entry, cmdstart should point to the command line,
+*       argv should point to memory for the argv array, args
+*       points to memory to place the text of the arguments.
+*       If these are nullptr, then no storing (only counting)
+*       is done.  On exit, *argument_count has the number of
+*       arguments (plus one for a final nullptr argument),
+*       and *character_count has the number of bytes used in the buffer
+*       pointed to by args.
+*
+*Entry:
+*       Character *cmdstart - pointer to command line of the form
+*           <progname><nul><args><nul>
+*       Character **argv - where to build argv array; nullptr means don't
+*                       build array
+*       Character *args - where to place argument text; nullptr means don't
+*                       store text
+*
+*Exit:
+*       no return value
+*       int *argument_count - returns number of argv entries created
+*       int *character_count - number of characters used in args buffer
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+
+// should_copy_another_character helper functions
+// should_copy_another_character is *ONLY* checking for DBCS lead bytes to see if there
+// might be a following trail byte.  This works because the callers are only concerned
+// about escaped quote sequences and other codepages aren't using those quotes.
+static bool __cdecl should_copy_another_character(char const c) throw()
+{
+    // This is OK for UTF-8 as a quote is never a trail byte.
+    return _ismbblead(c) != 0;
+}
+
+static bool __cdecl should_copy_another_character(wchar_t) throw()
+{
+    // This is OK for UTF-16 as a quote is never part of a surrogate pair.
+    return false;
+}
+
+template <typename Character>
+static void __cdecl parse_command_line(
+    Character*  cmdstart,
+    Character** argv,
+    Character*  args,
+    size_t*     argument_count,
+    size_t*     character_count
+    ) throw()
+{
+    *character_count = 0;
+    *argument_count  = 1; // We'll have at least the program name
+
+    Character c;
+    int copy_character;                   /* 1 = copy char to *args */
+    unsigned numslash;              /* num of backslashes seen */
+
+    /* first scan the program name, copy it, and count the bytes */
+    Character* p = cmdstart;
+    if (argv)
+        *argv++ = args;
+
+    // A quoted program name is handled here. The handling is much
+    // simpler than for other arguments. Basically, whatever lies
+    // between the leading double-quote and next one, or a terminal null
+    // character is simply accepted. Fancier handling is not required
+    // because the program name must be a legal NTFS/HPFS file name.
+    // Note that the double-quote characters are not copied, nor do they
+    // contribute to character_count.
+    bool in_quotes = false;
+    do
+    {
+        if (*p == '"')
+        {
+            in_quotes = !in_quotes;
+            c = *p++;
+            continue;
+        }
+
+        ++*character_count;
+        if (args)
+            *args++ = *p;
+
+        c = *p++;
+
+        if (should_copy_another_character(c))
+        {
+            ++*character_count;
+            if (args)
+                *args++ = *p; // Copy 2nd byte too
+            ++p; // skip over trail byte
+        }
+    }
+    while (c != '\0' && (in_quotes || (c != ' ' && c != '\t')));
+
+    if (c == '\0')
+    {
+        p--;
+    }
+    else
+    {
+        if (args)
+            *(args - 1) = '\0';
+    }
+
+    in_quotes = false;
+
+    // Loop on each argument
+    for (;;)
+    {
+        if (*p)
+        {
+            while (*p == ' ' || *p == '\t')
+                ++p;
+        }
+
+        if (*p == '\0')
+            break; // End of arguments
+
+        // Scan an argument:
+        if (argv)
+            *argv++ = args;
+
+        ++*argument_count;
+
+        // Loop through scanning one argument:
+        for (;;)
+        {
+            copy_character = 1;
+
+            // Rules:
+            // 2N     backslashes   + " ==> N backslashes and begin/end quote
+            // 2N + 1 backslashes   + " ==> N backslashes + literal "
+            // N      backslashes       ==> N backslashes
+            numslash = 0;
+
+            while (*p == '\\')
+            {
+                // Count number of backslashes for use below
+                ++p;
+                ++numslash;
+            }
+
+            if (*p == '"')
+            {
+                // if 2N backslashes before, start/end quote, otherwise
+                // copy literally:
+                if (numslash % 2 == 0)
+                {
+                    if (in_quotes && p[1] == '"')
+                    {
+                        p++; // Double quote inside quoted string
+                    }
+                    else
+                    {
+                        // Skip first quote char and copy second:
+                        copy_character = 0; // Don't copy quote
+                        in_quotes = !in_quotes;
+                    }
+                }
+
+                numslash /= 2;
+            }
+
+            // Copy slashes:
+            while (numslash--)
+            {
+                if (args)
+                    *args++ = '\\';
+                ++*character_count;
+            }
+
+            // If at end of arg, break loop:
+            if (*p == '\0' || (!in_quotes && (*p == ' ' || *p == '\t')))
+                break;
+
+            // Copy character into argument:
+            if (copy_character)
+            {
+                if (args)
+                    *args++ = *p;
+
+                if (should_copy_another_character(*p))
+                {
+                    ++p;
+                    ++*character_count;
+
+                    if (args)
+                        *args++ = *p;
+                }
+
+                ++*character_count;
+            }
+
+            ++p;
+        }
+
+        // Null-terminate the argument:
+        if (args)
+            *args++ = '\0'; // Terminate the string
+
+        ++*character_count;
+    }
+
+    // We put one last argument in -- a null pointer:
+    if (argv)
+        *argv++ = nullptr;
+
+    ++*argument_count;
+}
+
+
+
+extern "C" unsigned char* __cdecl __acrt_allocate_buffer_for_argv(
+    size_t const argument_count,
+    size_t const character_count,
+    size_t const character_size
+    )
+{
+    if (argument_count >= SIZE_MAX / sizeof(void*))
+        return nullptr;
+
+    if (character_count >= SIZE_MAX / character_size)
+        return nullptr;
+
+    size_t const argument_array_size  = argument_count  * sizeof(void*);
+    size_t const character_array_size = character_count * character_size;
+
+    if (SIZE_MAX - argument_array_size <= character_array_size)
+        return nullptr;
+
+    size_t const total_size = argument_array_size + character_array_size;
+    __crt_unique_heap_ptr<unsigned char> buffer(_calloc_crt_t(unsigned char, total_size));
+    if (!buffer)
+        return nullptr;
+
+    return buffer.detach();
+}
+
+
+
+/***
+*_setargv, __setargv - set up "argc" and "argv" for C programs
+*
+*Purpose:
+*       Read the command line and create the argv array for C
+*       programs.
+*
+*Entry:
+*       Arguments are retrieved from the program command line,
+*       pointed to by _acmdln.
+*
+*Exit:
+*       Returns 0 if successful, -1 if memory allocation failed.
+*       "argv" points to a null-terminated list of pointers to ASCIZ
+*       strings, each of which is an argument from the command line.
+*       "argc" is the number of arguments.  The strings are copied from
+*       the environment segment into space allocated on the heap/stack.
+*       The list of pointers is also located on the heap or stack.
+*       _pgmptr points to the program name.
+*
+*Exceptions:
+*       Terminates with out of memory error if no memory to allocate.
+*
+*******************************************************************************/
+template <typename Character>
+static errno_t __cdecl common_configure_argv(_crt_argv_mode const mode) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    if (mode == _crt_argv_no_arguments)
+    {
+        return 0;
+    }
+
+    _VALIDATE_RETURN_ERRCODE(
+        mode == _crt_argv_expanded_arguments ||
+        mode == _crt_argv_unexpanded_arguments, EINVAL);
+
+    do_locale_initialization(Character());
+
+
+    static Character program_name[MAX_PATH + 1];
+    traits::get_module_file_name(nullptr, program_name, MAX_PATH);
+    traits::set_program_name(&program_name[0]);
+
+    // If there's no command line at all, then use the program name as the
+    // command line to parse, so that argv[0] is initialized with the program
+    // name.  (This won't happen when the program is run by cmd.exe, but it
+    // could happen if the program is spawned via some other means.)
+    Character* const raw_command_line = get_command_line(Character());
+    Character* const command_line = raw_command_line == nullptr || raw_command_line[0] == '\0'
+        ? program_name
+        : raw_command_line;
+
+    size_t argument_count  = 0;
+    size_t character_count = 0;
+    parse_command_line(
+        command_line,
+        static_cast<Character**>(nullptr),
+        static_cast<Character*>(nullptr),
+        &argument_count,
+        &character_count);
+
+    __crt_unique_heap_ptr<unsigned char> buffer(__acrt_allocate_buffer_for_argv(
+        argument_count,
+        character_count,
+        sizeof(Character)));
+
+    _VALIDATE_RETURN_ERRCODE_NOEXC(buffer, ENOMEM);
+
+    Character** const first_argument = reinterpret_cast<Character**>(buffer.get());
+    Character*  const first_string   = reinterpret_cast<Character*>(buffer.get() + argument_count * sizeof(Character*));
+
+    parse_command_line(command_line, first_argument, first_string, &argument_count, &character_count);
+
+    // If we are not expanding wildcards, then we are done...
+    if (mode == _crt_argv_unexpanded_arguments)
+    {
+        __argc = static_cast<int>(argument_count - 1);
+        get_argv(Character()) = reinterpret_cast<Character**>(buffer.detach());
+        return 0;
+    }
+
+    // ... otherwise, we try to do the wildcard expansion:
+    __crt_unique_heap_ptr<Character*> expanded_argv;
+    errno_t const argv_expansion_status = expand_argv_wildcards(first_argument, expanded_argv.get_address_of());
+    if (argv_expansion_status != 0)
+        return argv_expansion_status;
+
+    __argc = [&]()
+    {
+        size_t n = 0;
+        for (auto it = expanded_argv.get(); *it; ++it, ++n) { }
+        return static_cast<int>(n);
+    }();
+
+    get_argv(Character()) = expanded_argv.detach();
+    return 0;
+}
+
+
+
+extern "C" errno_t __cdecl _configure_narrow_argv(_crt_argv_mode const mode)
+{
+    return common_configure_argv<char>(mode);
+}
+
+extern "C" errno_t __cdecl _configure_wide_argv(_crt_argv_mode const mode)
+{
+    return common_configure_argv<wchar_t>(mode);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_wildcards.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_wildcards.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c0aef1ef592496551a292c059bc84600f21f2702
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_wildcards.cpp	
@@ -0,0 +1,391 @@
+/***
+*wild.c - wildcard expander
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*        expands wildcards in argv
+*
+*        handles '*' (none or more of any char) and '?' (exactly one char)
+*
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <corecrt_internal_traits.h>
+#include <limits.h>
+#include <mbstring.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wrl/wrappers/corewrappers.h>
+
+
+
+namespace
+{
+    template <typename Character>
+    class argument_list
+    {
+    public:
+
+        argument_list() throw() : _first(nullptr), _last(nullptr), _end(nullptr) { }
+
+        size_t      size()  const throw() { return _last - _first; }
+        Character** begin() const throw() { return _first;         }
+        Character** end()   const throw() { return _last;          }
+
+        errno_t append(Character* const element) throw()
+        {
+            errno_t const expand_status = expand_if_necessary();
+            if (expand_status != 0)
+            {
+                _free_crt(element);
+                return expand_status;
+            }
+
+            *_last++ = element;
+            return 0;
+        }
+
+        Character** detach() throw()
+        {
+            _last = nullptr;
+            _end  = nullptr;
+
+            Character** const first = _first;
+            _first = nullptr;
+            return first;
+        }
+
+        ~argument_list() throw()
+        {
+            for (auto it = _first; it != _last; ++it)
+                _free_crt(*it);
+
+            _free_crt(_first);
+        }
+
+    private:
+
+        argument_list(argument_list const&) throw();            // not implemented
+        argument_list& operator=(argument_list const&) throw(); // not implemented
+
+        errno_t expand_if_necessary() throw()
+        {
+            // If there is already room for more elements, just return:
+            if (_last != _end)
+            {
+                return 0;
+            }
+            // If the list has not yet had an array allocated for it, allocate one:
+            if (!_first)
+            {
+                size_t const initial_count = 4;
+
+                _first = _calloc_crt_t(Character*, initial_count).detach();
+                if (!_first)
+                    return ENOMEM;
+
+                _last = _first;
+                _end  = _first + initial_count;
+                return 0;
+            }
+            // Otherwise, double the size of the array:
+            else
+            {
+                size_t const old_count = _end - _first;
+                if (old_count > SIZE_MAX / 2)
+                    return ENOMEM;
+
+                size_t const new_count = old_count * 2;
+                __crt_unique_heap_ptr<Character*> new_array(_recalloc_crt_t(Character*, _first, new_count));
+                if (!new_array)
+                    return ENOMEM;
+
+                _first = new_array.detach();
+                _last = _first + old_count;
+                _end  = _first + new_count;
+                return 0;
+            }
+        }
+
+        Character** _first;
+        Character** _last;
+        Character** _end;
+    };
+}
+
+_Check_return_
+static char*
+previous_character(_In_reads_z_(current - first + 1) char* const first,
+                   _In_z_ char* const current) throw()
+{
+    return reinterpret_cast<char*>(_mbsdec(
+        reinterpret_cast<unsigned char*>(first),
+        reinterpret_cast<unsigned char*>(current)));
+}
+
+static wchar_t* previous_character(_In_reads_(0) wchar_t*, _In_reads_(0) wchar_t* const current) throw()
+{
+    return current - 1;
+}
+
+
+
+template <typename Character>
+static errno_t copy_and_add_argument_to_buffer(
+    _In_z_ Character const*    const file_name,
+    _In_z_ Character const*    const directory,
+               size_t          const directory_length,
+    argument_list<Character>&        buffer
+    ) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    size_t const file_name_count = traits::tcslen(file_name) + 1;
+    if (file_name_count > SIZE_MAX - directory_length)
+        return ENOMEM;
+
+    size_t const required_count = directory_length + file_name_count + 1;
+    __crt_unique_heap_ptr<Character> argument_buffer(_calloc_crt_t(Character, required_count));
+
+    if (directory_length > 0)
+    {
+        _ERRCHECK(traits::tcsncpy_s(argument_buffer.get(), required_count, directory, directory_length));
+    }
+
+    _ERRCHECK(traits::tcsncpy_s(
+        argument_buffer.get() + directory_length,
+        required_count        - directory_length,
+        file_name,
+        file_name_count));
+
+    return buffer.append(argument_buffer.detach());
+}
+
+
+static wchar_t * get_wide(__crt_internal_win32_buffer<wchar_t> * const dest, char * const source)
+{
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
+        source,
+        *dest,
+        __acrt_get_utf8_acp_compatibility_codepage()
+    );
+
+    if (cvt1 != 0)
+    {
+        return nullptr;
+    }
+
+    return dest->data();
+};
+
+static wchar_t * get_wide(__crt_internal_win32_buffer<wchar_t> *, wchar_t * const source)
+{
+    return source;
+}
+
+static char * get_file_name(__crt_internal_win32_buffer<char> * const dest, wchar_t * const source)
+{
+    errno_t const cvt = __acrt_wcs_to_mbs_cp(
+        source,
+        *dest,
+        __acrt_get_utf8_acp_compatibility_codepage()
+    );
+
+    if (cvt != 0)
+    {
+        return nullptr;
+    }
+
+    return dest->data();
+}
+
+static wchar_t * get_file_name(__crt_internal_win32_buffer<wchar_t> *, wchar_t * const source)
+{
+    return source;
+}
+
+template <typename Character>
+static errno_t expand_argument_wildcards(
+    Character*          const argument,
+    Character*          const wildcard,
+    argument_list<Character>& buffer
+    ) throw()
+{
+    typedef __crt_char_traits<Character>          traits;
+    typedef typename traits::win32_find_data_type find_data_type;
+
+    auto const is_directory_separator = [](Character const c) { return c == '/' || c == '\\' || c == ':'; };
+
+    // Find the first slash or colon before the wildcard:
+    Character* it = wildcard;
+    while (it != argument && !is_directory_separator(*it))
+    {
+        it = previous_character(argument, it);
+    }
+
+    // If we found a colon that can't form a drive name (e.g. it can't be 'D:'),
+    // then just add the argument as-is (we don't know how to expand it):
+    if (*it == ':' && it != argument + 1)
+    {
+        return copy_and_add_argument_to_buffer(argument, static_cast<Character*>(nullptr), 0, buffer);
+    }
+
+    size_t const directory_length = is_directory_separator(*it)
+        ? it - argument + 1 // it points to the separator, so add 1 to include it.
+        : 0;
+
+    // Try to begin the find operation:
+    WIN32_FIND_DATAW findFileDataW;
+    __crt_internal_win32_buffer<wchar_t> wide_file_name;
+
+    __crt_findfile_handle const find_handle(::FindFirstFileExW(
+        get_wide(&wide_file_name, argument),
+        FindExInfoStandard,
+        &findFileDataW,
+        FindExSearchNameMatch,
+        nullptr,
+        0));
+
+    // If the find operation failed, there was no match, so just add the argument:
+    if (find_handle.get() == INVALID_HANDLE_VALUE)
+    {
+        return copy_and_add_argument_to_buffer(argument, static_cast<Character*>(nullptr), 0, buffer);
+    }
+
+    size_t const old_argument_count = buffer.size();
+
+    do
+    {
+        __crt_internal_win32_buffer<Character> character_buffer;
+        Character* const file_name = get_file_name(&character_buffer, findFileDataW.cFileName);
+        // Skip . and ..:
+        if (file_name[0] == '.' && file_name[1] == '\0')
+        {
+            continue;
+        }
+
+        if (file_name[0] == '.' && file_name[1] == '.' && file_name[2] == '\0')
+        {
+            continue;
+        }
+
+        errno_t const add_status = copy_and_add_argument_to_buffer(file_name, argument, directory_length, buffer);
+        if (add_status != 0)
+        {
+            return add_status;
+        }
+    }
+    while (::FindNextFileW(find_handle.get(), &findFileDataW));
+
+    // If we didn't add any arguments to the buffer, then we're done:
+    size_t const new_argument_count = buffer.size();
+    if (old_argument_count == new_argument_count)
+    {
+        return 0;
+    }
+
+    // If we did add new arguments, let's helpfully sort them:
+    qsort(
+        buffer.begin()     + old_argument_count,
+        new_argument_count - old_argument_count,
+        sizeof(Character*),
+        [](void const* lhs, void const* rhs) -> int
+        {
+            if (lhs < rhs) { return -1; }
+            if (lhs > rhs) { return  1; }
+            return 0;
+        });
+
+    return 0;
+}
+
+
+template <typename Character>
+static errno_t common_expand_argv_wildcards(Character** const argv, Character*** const result) throw()
+{
+    typedef __crt_char_traits<Character> traits;
+
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+    *result = nullptr;
+
+    argument_list<Character> expansion_buffer;
+    for (Character** it = argv; *it != nullptr; ++it)
+    {
+        Character const wildcard_characters[] = { '*', '?', '\0' };
+        Character* const wildcard = traits::tcspbrk(*it, wildcard_characters);
+
+        // If no wildcard characters were found in the argument string, just
+        // append it to the list and continue on.  Otherwise, do the expansion:
+        if (!wildcard)
+        {
+            errno_t const append_status = copy_and_add_argument_to_buffer(
+                *it,
+                static_cast<Character*>(nullptr),
+                0,
+                expansion_buffer);
+
+            if (append_status != 0)
+                return append_status;
+        }
+        else
+        {
+            errno_t const expand_status = expand_argument_wildcards(*it, wildcard, expansion_buffer);
+            if (expand_status != 0)
+                return expand_status;
+        }
+    }
+
+    // Now that we've accumulated the expanded arguments into the expansion
+    // buffer, we want to re-pack them in the form used by the argv parser,
+    // in a single array, with everything "concatenated" together.
+    size_t const argument_count  = expansion_buffer.size() + 1;
+    size_t       character_count = 0;
+    for (auto it = expansion_buffer.begin(); it != expansion_buffer.end(); ++it)
+        character_count += traits::tcslen(*it) + 1;
+
+    __crt_unique_heap_ptr<unsigned char> expanded_argv(__acrt_allocate_buffer_for_argv(
+        argument_count,
+        character_count,
+        sizeof(Character)));
+
+    if (!expanded_argv)
+        return -1;
+
+    Character** const argument_first  = reinterpret_cast<Character**>(expanded_argv.get());
+    Character*  const character_first = reinterpret_cast<Character*>(
+        expanded_argv.get() +
+        argument_count * sizeof(Character*));
+
+    Character** argument_it  = argument_first;
+    Character*  character_it = character_first;
+    for (auto it = expansion_buffer.begin(); it != expansion_buffer.end(); ++it)
+    {
+        size_t const count = traits::tcslen(*it) + 1;
+
+        _ERRCHECK(traits::tcsncpy_s(
+            character_it,
+            character_count - (character_it - character_first),
+            *it,
+            count));
+
+        *argument_it++ = character_it;
+        character_it += count;
+    }
+
+    *result = reinterpret_cast<Character**>(expanded_argv.detach());
+    return 0;
+}
+
+extern "C" errno_t __acrt_expand_narrow_argv_wildcards(char** const argv, char*** const result)
+{
+    return common_expand_argv_wildcards(argv, result);
+}
+
+extern "C" errno_t __acrt_expand_wide_argv_wildcards(wchar_t** const argv, wchar_t*** const result)
+{
+    return common_expand_argv_wildcards(argv, result);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_winmain.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_winmain.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..178d009ec9e943b3569c1a11dabf2db04369c8aa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/argv_winmain.cpp	
@@ -0,0 +1,111 @@
+/***
+*wincmdln.c - process command line for WinMain
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Prepare command line to be passed to [w]WinMain.
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <mbstring.h>
+
+
+
+// In the function below, we need to ensure that we've initialized the mbc table
+// before we start performing character transformations.
+static void do_locale_initialization(unsigned char) throw() { __acrt_initialize_multibyte(); }
+static void do_locale_initialization(wchar_t)       throw() { /* no-op */                    }
+
+static unsigned char* get_command_line(unsigned char) throw()
+{
+    return reinterpret_cast<unsigned char *>(_acmdln);
+}
+
+static wchar_t* get_command_line(wchar_t) throw() { return _wcmdln; }
+
+
+// should_copy_another_character is *ONLY* checking for DBCS lead bytes to see if there
+// might be a following trail byte.  This works because the callers are only concerned
+// about escaped quote sequences and other codepages aren't using those quotes.
+static bool __cdecl should_copy_another_character(unsigned char const c) throw()
+{
+    // This is OK for UTF-8 as a quote is never a trail byte.
+    return _ismbblead(c) != 0;
+}
+
+static bool __cdecl should_copy_another_character(wchar_t) throw()
+{
+    // This is OK for UTF-16 as a quote is never part of a surrogate pair.
+    return false;
+}
+
+
+
+/***
+*_[w]wincmdln
+*
+*Purpose:
+*       Extract the command line tail to be passed to WinMain.
+*
+*       Be warned! This code was originally implemented by the NT group and
+*       has remained pretty much unchanged since 12-91. It should be changed
+*       only with extreme care since there are undoubtedly many apps which
+*       depend on its historical behavior.
+*
+*Entry:
+*       The global variable _[a|w]cmdln is set to point at the complete
+*       command line.
+*
+*Exit:
+*       Returns a pointer to the command line tail.
+*
+*Exceptions:
+*
+*******************************************************************************/
+template <typename Character>
+static Character* __cdecl common_wincmdln() throw()
+{
+    do_locale_initialization(Character());
+
+    static Character empty_string[] = { '\0' };
+
+    Character* command_line = get_command_line(Character()) == nullptr
+        ? empty_string
+        : get_command_line(Character());
+
+    // Skip past the program name (the first token in the command line) and
+    // check for and handle a quoted program name:
+    bool in_double_quotes = false;
+    while (*command_line > ' ' || (*command_line != '\0' && in_double_quotes))
+    {
+        // Toggle the in_double_quotes flag if the current character is '"'
+        if (*command_line == '"')
+            in_double_quotes = !in_double_quotes;
+
+        if (should_copy_another_character(*command_line))
+            ++command_line;
+
+        ++command_line;
+    }
+
+    // Skip past any whitespace preceding the next token:
+    while (*command_line != '\0' && *command_line <= ' ')
+        ++command_line;
+
+    return command_line;
+}
+
+
+
+extern "C" char* __cdecl _get_narrow_winmain_command_line()
+{   // Need to use unsigned char so that we correctly handle ASCII characters
+    // above 127, in particular the comparison to ' ' (space - 0x20).
+    return reinterpret_cast<char *>(common_wincmdln<unsigned char>());
+}
+
+extern "C" wchar_t* __cdecl _get_wide_winmain_command_line()
+{
+    return common_wincmdln<wchar_t>();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/assert.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/assert.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d828d61b64fb8425c480ac5d322063f362d15b2a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/assert.cpp	
@@ -0,0 +1,444 @@
+/***
+*assert.c - Display a message and abort
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*
+*******************************************************************************/
+
+#include <corecrt_internal.h>
+#include <corecrt_internal_stdio.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+
+#undef NDEBUG
+#define _ASSERT_OK
+#include <assert.h>
+
+// Assertion string components:
+#define MAXLINELEN  64 /* max length for line in message box */
+#define ASSERTBUFSZ (MAXLINELEN * 9) /* 9 lines in message box */
+
+// Format of stderr for assertions:
+//
+//      Assertion failed: <expression>, file c:\test\mytest\bar.c, line 69
+//
+
+
+
+_GENERATE_TCHAR_STRING_FUNCTIONS(assert_format, "Assertion failed: %Ts, file %Ts, line %d\n")
+
+// Enclaves only support assertions sent to the debugger.
+// This mode could also be enabled for normal apps as well.
+
+#ifdef _UCRT_ENCLAVE_BUILD
+
+template <typename Character>
+__declspec(noreturn) static void __cdecl common_assert_to_debug(
+    Character const* const expression,
+    Character const* const file_name,
+    unsigned         const line_number
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    Character assert_buffer[ASSERTBUFSZ];
+    if (traits::sntprintf_s(assert_buffer, _countof(assert_buffer), _countof(assert_buffer), get_assert_format(Character()), expression, file_name, line_number) < 0)
+    {
+        abort();
+    }
+    traits::output_debug_string(assert_buffer);
+    abort();
+}
+
+template <typename Character>
+static void __cdecl common_assert(
+    Character const* const expression,
+    Character const* const file_name,
+    unsigned         const line_number,
+    void*            const
+    ) throw()
+{
+    common_assert_to_debug(expression, file_name, line_number);
+}
+
+#else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */
+
+// Format of MessageBox for assertions:
+//
+//      ================= Microsft Visual C++ Debug Library ================
+//
+//      Assertion Failed!
+//
+//      Program: c:\test\mytest\foo.exe
+//      File: c:\test\mytest\bar.c
+//      Line: 69
+//
+//      Expression: <expression>
+//
+//      For information on how your program can cause an assertion
+//      failure, see the Visual C++ documentation on asserts
+//
+//      (Press Retry to debug the application - JIT must be enabled)
+//
+//      ===================================================================
+
+
+
+_GENERATE_TCHAR_STRING_FUNCTIONS(banner_text, "Microsoft Visual C++ Runtime Library")
+
+_GENERATE_TCHAR_STRING_FUNCTIONS(box_intro,        "Assertion failed!")
+_GENERATE_TCHAR_STRING_FUNCTIONS(program_intro,    "Program: ")
+_GENERATE_TCHAR_STRING_FUNCTIONS(file_intro,       "File: ")
+_GENERATE_TCHAR_STRING_FUNCTIONS(line_intro,       "Line: ")
+_GENERATE_TCHAR_STRING_FUNCTIONS(expression_intro, "Expression: ")
+_GENERATE_TCHAR_STRING_FUNCTIONS(info_intro,       "For information on how your program can cause an assertion\nfailure, see the Visual C++ documentation on asserts")
+_GENERATE_TCHAR_STRING_FUNCTIONS(help_intro,       "(Press Retry to debug the application - JIT must be enabled)")
+
+_GENERATE_TCHAR_STRING_FUNCTIONS(dot_dot_dot,      "...")
+_GENERATE_TCHAR_STRING_FUNCTIONS(newline,          "\n")
+_GENERATE_TCHAR_STRING_FUNCTIONS(double_newline,   "\n\n")
+
+_GENERATE_TCHAR_STRING_FUNCTIONS(program_name_unknown_text, "<program name unknown>")
+
+/***
+*_assert() - Display a message and abort
+*
+*Purpose:
+*       The assert macro calls this routine if the assert expression is
+*       true.  By placing the assert code in a subroutine instead of within
+*       the body of the macro, programs that call assert multiple times will
+*       save space.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+static void __cdecl common_assert_to_stderr_direct(char const*, char const*, unsigned) throw()
+{
+    // No action for narrow strings
+}
+
+static void __cdecl common_assert_to_stderr_direct(
+    wchar_t const* const expression,
+    wchar_t const* const file_name,
+    unsigned       const line_number
+    ) throw()
+{
+    HANDLE const stderr_handle = GetStdHandle(STD_ERROR_HANDLE);
+#pragma warning(suppress:__WARNING_REDUNDANT_POINTER_TEST) // 28922
+    if (stderr_handle == INVALID_HANDLE_VALUE || stderr_handle == nullptr)
+    {
+        return;
+    }
+
+    if (GetFileType(stderr_handle) != FILE_TYPE_CHAR)
+    {
+        return;
+    }
+
+    wchar_t assert_buffer[ASSERTBUFSZ];
+#pragma warning(suppress:__WARNING_BANNED_API_USAGE) // 28719
+    if (swprintf(assert_buffer, _countof(assert_buffer), get_assert_format(wchar_t()), expression, file_name, line_number) < 0)
+    {
+        return;
+    }
+
+    DWORD const assert_buffer_length = static_cast<DWORD>(wcslen(assert_buffer));
+    DWORD characters_written = 0;
+    if (WriteConsoleW(stderr_handle, assert_buffer, assert_buffer_length, &characters_written, nullptr) == 0)
+    {
+        return;
+    }
+
+    abort();
+}
+
+template <typename Character>
+__declspec(noreturn) static void __cdecl common_assert_to_stderr(
+    Character const* const expression,
+    Character const* const file_name,
+    unsigned         const line_number
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    // Try to write directly to the console.  This is only supported for wide
+    // character strings.  If we have a narrow character string or the write
+    // fails, we fall back to call through stdio.
+    common_assert_to_stderr_direct(expression, file_name, line_number);
+
+    // If stderr does not yet have a buffer, set it to use single character
+    // buffering to avoid dynamic allocation of a stream buffer:
+    if (!__crt_stdio_stream(stderr).has_any_buffer())
+    {
+        setvbuf(stderr, nullptr, _IONBF, 0);
+    }
+
+    traits::ftprintf(stderr, get_assert_format(Character()), expression, file_name, line_number);
+    fflush(stderr);
+    abort();
+}
+
+template <typename Character>
+static void __cdecl common_assert_to_message_box_build_string(
+    Character*       const assert_buffer,
+    size_t           const assert_buffer_count,
+    Character const* const expression,
+    Character const* const file_name,
+    unsigned         const line_number,
+    void*            const return_address
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    // Line 1: Box introduction line:
+    _ERRCHECK(traits::tcscpy_s(assert_buffer, assert_buffer_count, get_box_intro(Character())));
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character())));
+
+    // Line 2: Program line:
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_program_intro(Character())));
+
+    Character program_name[_MAX_PATH + 1]{};
+
+    HMODULE asserting_module = nullptr;
+    if (!GetModuleHandleExW(
+            GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+            static_cast<wchar_t const*>(return_address),
+            &asserting_module))
+    {
+        asserting_module = nullptr;
+    }
+
+    #ifdef CRTDLL
+    // If the assert came from within the CRT DLL, report it as having come
+    // from the EXE instead:
+    if (asserting_module == reinterpret_cast<HMODULE>(&__ImageBase))
+    {
+        asserting_module = nullptr;
+    }
+    #endif
+
+    if (!traits::get_module_file_name(asserting_module, program_name, static_cast<DWORD>(_countof(program_name))))
+    {
+        _ERRCHECK(traits::tcscpy_s(program_name, _countof(program_name), get_program_name_unknown_text(Character())));
+    }
+
+    Character* pchProg = program_name;
+    if (program_intro_count + traits::tcslen(program_name) + newline_length > MAXLINELEN)
+    {
+        pchProg += (program_intro_count + traits::tcslen(program_name) + newline_length) - MAXLINELEN;
+        // Only replace first (sizeof(Character) * dot_dot_dot_length) bytes to ellipsis:
+        _ERRCHECK(memcpy_s(
+            pchProg,
+            sizeof(Character) * ((MAX_PATH + 1) - (pchProg - program_name)),
+            get_dot_dot_dot(Character()),
+            sizeof(Character) * dot_dot_dot_length
+            ));
+    }
+
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, pchProg));
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_newline(Character())));
+
+    // Line 3:  File line
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_file_intro(Character())));
+
+    if (file_intro_count + traits::tcslen(file_name) + newline_length > MAXLINELEN)
+    {
+        size_t const ffn = MAXLINELEN - file_intro_count - newline_length;
+
+        size_t p   = 0;
+        size_t len = 0;
+        Character const* pch = file_name;
+        for (len = traits::tcslen(file_name), p = 1;
+             pch[len - p] != '\\' && pch[len - p] != '/' && p < len;
+             p++)
+        {
+        }
+
+        // Trim the path and file name so that they fit, using up to 2/3 of
+        // the maximum number of characters for the path and the remaining
+        // 1/3 for the file name:
+        if ((ffn - ffn / 3) < (len - p) && ffn / 3 > p)
+        {
+            // The path is too long.  Use the first part of the path and the
+            // full file name:
+            _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch, ffn - dot_dot_dot_length - p));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character())));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, pch + len - p));
+        }
+        else if (ffn - ffn / 3 > len - p)
+        {
+            // The file name is too long.  Use the full path and the first
+            // and last part of the file name, with a ... in between:
+            p = p / 2;
+            _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch, ffn - dot_dot_dot_length - p));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character())));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, pch + len - p));
+        }
+        else
+        {
+            // Both are too long.  Use the first part of the path and the
+            // first and last part of the file name, with ...s in between:
+            _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch, ffn - ffn / 3 - dot_dot_dot_length));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character())));
+            _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch + len - p, ffn / 6 - 1));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character())));
+            _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, pch + len - (ffn / 3 - ffn / 6 - 2)));
+        }
+    }
+    else
+    {
+        // Plenty of room on the line; just append the full path and file name:
+        _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, file_name));
+    }
+
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_newline(Character())));
+
+    // Line 4: Line Number line:
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_line_intro(Character())));
+    _ERRCHECK(traits::itot_s(
+        line_number,
+        assert_buffer           + traits::tcslen(assert_buffer),
+        assert_buffer_count - traits::tcslen(assert_buffer),
+        10));
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character())));
+
+    // Line 5: Message line:
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_expression_intro(Character())));
+
+    size_t const characters_used =
+        traits::tcslen(assert_buffer) +
+        2 * double_newline_length +
+        info_intro_length +
+        help_intro_count;
+
+    if (characters_used + traits::tcslen(expression) > assert_buffer_count)
+    {
+        size_t const characters_to_write = assert_buffer_count - (characters_used + dot_dot_dot_length);
+        _ERRCHECK(traits::tcsncat_s(
+            assert_buffer,
+            assert_buffer_count,
+            expression,
+            characters_to_write));
+        _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_dot_dot_dot(Character())));
+    }
+    else
+    {
+        _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, expression));
+    }
+
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character())));
+
+    // Info line:
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_info_intro(Character())));
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character())));
+
+    // Help line:
+    _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_help_intro(Character())));
+}
+
+
+
+template <typename Character>
+static void __cdecl common_assert_to_message_box(
+    Character const* const expression,
+    Character const* const file_name,
+    unsigned         const line_number,
+    void*            const return_address
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    Character assert_buffer[ASSERTBUFSZ]{};
+    common_assert_to_message_box_build_string(
+        assert_buffer,
+        _countof(assert_buffer),
+        expression,
+        file_name,
+        line_number,
+        return_address);
+
+    int const action = traits::show_message_box(
+        assert_buffer,
+        get_banner_text(Character()),
+        MB_TASKMODAL | MB_ICONHAND | MB_ABORTRETRYIGNORE | MB_SETFOREGROUND);
+
+    switch (action)
+    {
+    case IDABORT: // Abort the program:
+    {
+        raise(SIGABRT);
+
+        // We won't usually get here, but it's possible that a user-registered
+        // abort handler returns, so exit the program immediately.  Note that
+        // even though we are "aborting," we do not call abort() because we do
+        // not want to invoke Watson (the user has already had an opportunity
+        // to debug the error and chose not to).
+        _exit(3);
+    }
+    case IDRETRY: // Break into the debugger then return control to caller
+    {
+        __debugbreak();
+        return;
+    }
+    case IDIGNORE: // Return control to caller
+    {
+        return;
+    }
+    default: // This should not happen; treat as fatal error:
+    {
+        abort();
+    }
+    }
+}
+
+template <typename Character>
+static void __cdecl common_assert(
+    Character const* const expression,
+    Character const* const file_name,
+    unsigned         const line_number,
+    void*            const return_address
+    ) throw()
+{
+    using traits = __crt_char_traits<Character>;
+
+    int const current_error_mode = _set_error_mode(_REPORT_ERRMODE);
+    if (current_error_mode == _OUT_TO_STDERR)
+    {
+        return common_assert_to_stderr(expression, file_name, line_number);
+    }
+
+    if (current_error_mode == _OUT_TO_DEFAULT && _query_app_type() == _crt_console_app)
+    {
+        return common_assert_to_stderr(expression, file_name, line_number);
+    }
+
+    return common_assert_to_message_box(expression, file_name, line_number, return_address);
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+extern "C" void __cdecl _assert(
+    char const* const expression,
+    char const* const file_name,
+    unsigned    const line_number
+    ) throw()
+{
+    return common_assert(expression, file_name, line_number, _ReturnAddress());
+}
+
+extern "C" void __cdecl _wassert(
+    wchar_t const* const expression,
+    wchar_t const* const file_name,
+    unsigned       const line_number
+    ) 
+{
+    return common_assert(expression, file_name, line_number, _ReturnAddress());
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/exit.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/exit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..afe7852b514ceae4db51d2c7074aaf48b81bddb9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/exit.cpp	
@@ -0,0 +1,327 @@
+//
+// exit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The exit() implementation
+//
+#include <corecrt_internal.h>
+#include <eh.h>
+#include <process.h>
+
+static long c_termination_complete = FALSE;
+
+extern "C" extern _onexit_table_t __acrt_atexit_table;
+extern "C" extern _onexit_table_t __acrt_at_quick_exit_table;
+
+// thread_local atexit dtor handling. The APPCRT exports a function to set the
+// callback function. The exe main function will call this to set the callback
+// function so exit() can invoke destructors for thread-storage objects owned
+// by the main thread.
+static _tls_callback_type thread_local_exit_callback_func;
+
+
+// CRT_REFACTOR TODO This needs to be declared somewhere more accessible and we
+// need to clean up the static CRT exit coordination.
+#if !defined CRTDLL && defined _DEBUG
+    extern "C" bool __cdecl __scrt_uninitialize_crt(bool is_terminating, bool from_exit);
+#endif
+
+
+// Enclaves have no support for managed apps
+#ifdef _UCRT_ENCLAVE_BUILD
+
+static bool __cdecl is_managed_app() throw() { return false; }
+
+static void __cdecl try_cor_exit_process(UINT const) throw() { }
+
+// This function never returns.  It causes the process to exit.
+static void __cdecl exit_or_terminate_process(UINT const return_code, bool) throw()
+{
+    TerminateProcess(GetCurrentProcess(), return_code);
+}
+
+static bool __cdecl should_call_terminate_process() throw() { return true; }
+
+#else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */
+
+typedef void (WINAPI* exit_process_pft)(UINT);
+
+// CRT_REFACTOR TODO This is duplicated in the VCStartup utility_desktop.cpp.
+static bool __cdecl is_managed_app() throw()
+{
+    PIMAGE_DOS_HEADER const dos_header = reinterpret_cast<PIMAGE_DOS_HEADER>(GetModuleHandleW(nullptr));
+    if (dos_header == nullptr)
+        return false;
+
+    if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
+        return false;
+
+    PIMAGE_NT_HEADERS const pe_header = reinterpret_cast<PIMAGE_NT_HEADERS>(
+        reinterpret_cast<BYTE*>(dos_header) + dos_header->e_lfanew);
+
+    if (pe_header->Signature != IMAGE_NT_SIGNATURE)
+        return false;
+
+    if (pe_header->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
+        return false;
+
+    // prefast assumes we are overrunning __ImageBase
+    #pragma warning(push)
+    #pragma warning(disable: 26000)
+
+    if (pe_header->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR)
+        return false;
+
+    #pragma warning(pop)
+
+    if (pe_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress == 0)
+        return false;
+
+    return true;
+}
+
+static void __cdecl try_cor_exit_process(UINT const return_code) throw()
+{
+    __crt_unique_hmodule mscoree;
+    if (!GetModuleHandleExW(0, L"mscoree.dll", mscoree.get_address_of()))
+        return;
+
+    auto const cor_exit_process = __crt_get_proc_address<exit_process_pft>(mscoree.get(), "CorExitProcess");
+    if (!cor_exit_process)
+        return;
+
+    cor_exit_process(return_code);
+}
+
+
+
+// For Windows Store apps, starting in Windows 10, we use TerminateProcess
+// instead of ExitProcess.  ExitProcess will allow threads to run during
+// termination in an unordered fashion. This has lead to problems in various
+// apps.  TerminateProcess does not allow threads to run while the process is
+// being torn down.  See also CoreApplication::Run, which does the same.
+//
+// For non-Windows Store app processes, we continue to call ExitProcess, for
+// compatibility with the legacy runtimes.
+static bool __cdecl should_call_terminate_process() throw()
+{
+    if (__acrt_get_process_end_policy() == process_end_policy_exit_process)
+    {
+        return false;
+    }
+
+    // If application verifier is running, we still want to call ExitProcess,
+    // to enable tools that require DLLs to be unloaded cleanly at process exit
+    // to do their work.
+    if (__acrt_app_verifier_enabled())
+    {
+        return false;
+    }
+
+    return true;
+}
+
+
+
+// This function never returns.  It causes the process to exit.
+static void __cdecl exit_or_terminate_process(
+    UINT const return_code,
+    bool should_call_terminate_proc) throw()
+{
+    if (should_call_terminate_proc)
+    {
+        TerminateProcess(GetCurrentProcess(), return_code);
+    }
+
+    try_cor_exit_process(return_code);
+
+    // If that returned, then the exe for this process is not managed or we
+    // failed to exit via a call to CorExitProcess.  Exit the normal way:
+    ExitProcess(return_code);
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+
+static int __cdecl atexit_exception_filter(unsigned long const _exception_code) throw()
+{
+    if (_exception_code == ('msc' | 0xE0000000))
+    {
+        return EXCEPTION_EXECUTE_HANDLER;
+    }
+
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+
+
+extern "C" void __cdecl __acrt_initialize_thread_local_exit_callback(void * encoded_null)
+{
+    thread_local_exit_callback_func = reinterpret_cast<_tls_callback_type>(encoded_null);
+}
+
+// Register the dynamic TLS dtor callback. Called from the vcstartup library
+// as part of the EXE common_main to allow the acrt to call back into the scrt.
+extern "C" void __cdecl _register_thread_local_exe_atexit_callback(_In_ _tls_callback_type const _Callback)
+{
+    // Can only set the callback once.
+    if (thread_local_exit_callback_func != __crt_fast_encode_pointer(nullptr))
+    {
+        terminate();
+    }
+
+    thread_local_exit_callback_func = __crt_fast_encode_pointer(_Callback);
+}
+
+
+
+static void __cdecl common_exit(
+    int                    const return_code,
+    _crt_exit_cleanup_mode const cleanup_mode,
+    _crt_exit_return_mode  const return_mode
+    ) throw()
+{
+    // First, check to see if we're loaded in a managed app.  If we are, try to
+    // call CorExitProcess to let the CLR handle the process termination.  If
+    // the call to CorExitProcess is successful, then it will call back through
+    // this function with a return mode of _crt_exit_return_to_caller, at which
+    // point we will run the C termination routines.  It will then terminate the
+    // process itself and not return.
+    if (return_mode == _crt_exit_terminate_process && is_managed_app())
+    {
+        try_cor_exit_process(return_code);
+    }
+
+    // Run the C termination:
+    bool crt_uninitialization_required = false;
+
+    __acrt_lock_and_call(__acrt_select_exit_lock(), [&]
+    {
+        static bool c_exit_complete = false;
+        if (c_exit_complete)
+        {
+            return;
+        }
+
+        _InterlockedExchange(&c_termination_complete, TRUE);
+
+        __try
+        {
+            if (cleanup_mode == _crt_exit_full_cleanup)
+            {
+
+                // If this module has any dynamically initialized
+                // __declspec(thread) variables, then we invoke their
+                // destruction for the primary thread. All thread_local
+                // destructors are sequenced before any atexit calls or static
+                // object destructors (3.6.3/1)
+                if (thread_local_exit_callback_func != __crt_fast_encode_pointer(nullptr))
+                {
+                    (__crt_fast_decode_pointer(thread_local_exit_callback_func))(nullptr, DLL_PROCESS_DETACH, nullptr);
+                }
+
+                _execute_onexit_table(&__acrt_atexit_table);
+            }
+            else if (cleanup_mode == _crt_exit_quick_cleanup)
+            {
+                _execute_onexit_table(&__acrt_at_quick_exit_table);
+            }
+        }
+        __except (atexit_exception_filter(GetExceptionCode()))
+        {
+            terminate();
+        }
+
+        #ifndef CRTDLL
+        // When the CRT is statically linked, we are responsible for executing
+        // the terminators here, because the CRT code is present in this module.
+        // When the CRT DLLs are used, the terminators will be executed when
+        // the CRT DLLs are unloaded, after the call to ExitProcess.
+        if (cleanup_mode == _crt_exit_full_cleanup)
+        {
+            _initterm(__xp_a, __xp_z);
+        }
+
+        _initterm(__xt_a, __xt_z);
+        #endif // CRTDLL
+
+        if (return_mode == _crt_exit_terminate_process)
+        {
+            c_exit_complete = true;
+            crt_uninitialization_required = true;
+        }
+    });
+
+    // should_call_terminate_process ends up calling winapi thunks, which may
+    // grab a CRT lock, so call it before __scrt_uninitialize_crt that uninitializes
+    // all the locks.
+    bool should_call_terminate_proc = false;
+    if (return_mode == _crt_exit_terminate_process)
+    {
+        should_call_terminate_proc = should_call_terminate_process();
+    }
+
+    // Do NOT try to uninitialize the CRT while holding one of its locks (e.g.,
+    // call any functions that may end up calling winapi thunks).
+    if (crt_uninitialization_required)
+    {
+        // If we are about to terminate the process, if the debug CRT is linked
+        // statically into this module and this module is an EXE, we need to
+        // ensure that we fully and correctly uninitialize the CRT so that the
+        // debug on-exit() checks (e.g. debug heap leak detection) have a chance
+        // to run.
+        //
+        // We do not need to uninitialize the CRT when it is statically linked
+        // into a DLL because its DllMain will be called for DLL_PROCESS_DETACH
+        // and we can uninitialize the CRT there.
+        //
+        // We never need to uninitialize the retail CRT during exit() because
+        // the process is about to terminate.
+        #if !CRTDLL && _DEBUG
+        __scrt_uninitialize_crt(true, true);
+        #endif
+    }
+
+    if (return_mode == _crt_exit_terminate_process)
+    {
+        exit_or_terminate_process(return_code, should_call_terminate_proc);
+    }
+}
+
+extern "C" int __cdecl _is_c_termination_complete()
+{
+    return static_cast<int>(__crt_interlocked_read(&c_termination_complete));
+}
+
+
+
+extern "C" void __cdecl exit(int const return_code)
+{
+    common_exit(return_code, _crt_exit_full_cleanup, _crt_exit_terminate_process);
+}
+
+extern "C" void __cdecl _exit(int const return_code)
+{
+    common_exit(return_code, _crt_exit_no_cleanup, _crt_exit_terminate_process);
+}
+
+extern "C" void __cdecl _Exit(int const return_code)
+{
+    common_exit(return_code, _crt_exit_no_cleanup, _crt_exit_terminate_process);
+}
+
+extern "C" void __cdecl quick_exit(int const return_code)
+{
+    common_exit(return_code, _crt_exit_quick_cleanup, _crt_exit_terminate_process);
+}
+
+extern "C" void __cdecl _cexit()
+{
+    common_exit(0, _crt_exit_full_cleanup, _crt_exit_return_to_caller);
+}
+
+extern "C" void __cdecl _c_exit()
+{
+    common_exit(0, _crt_exit_no_cleanup, _crt_exit_return_to_caller);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/initterm.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/initterm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c40654e76ce775f5c90746468919e2ef45002c68
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/initterm.cpp	
@@ -0,0 +1,46 @@
+//
+// initterm.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// _initterm and _initterm_e functions used during dynamic initialization.
+//
+#include <corecrt_internal.h>
+
+
+
+// Calls each function in [first, last).  [first, last) must be a valid range of
+// function pointers.  Each function is called, in order.
+extern "C" void __cdecl _initterm(_PVFV* const first, _PVFV* const last)
+{
+    for (_PVFV* it = first; it != last; ++it)
+    {
+        if (*it == nullptr)
+            continue;
+
+        (**it)();
+    }
+}
+
+// Calls each function in [first, last).  [first, last) must be a valid range of
+// function pointers.  Each function must return zero on success, nonzero on
+// failure.  If any function returns nonzero, iteration stops immediately and
+// the nonzero value is returned.  Otherwise all functions are called and zero
+// is returned.
+//
+// If a nonzero value is returned, it is expected to be one of the runtime error
+// values (_RT_{NAME}, defined in the internal header files).
+extern "C" int __cdecl _initterm_e(_PIFV* const first, _PIFV* const last)
+{
+    for (_PIFV* it = first; it != last; ++it)
+    {
+        if (*it == nullptr)
+            continue;
+
+        int const result = (**it)();
+        if (result != 0)
+            return result;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/onexit.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/onexit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9433c25c4f3457c90e9c7245833a73830d6a322
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/onexit.cpp	
@@ -0,0 +1,231 @@
+//
+// onexit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _onexit registry, which stores pointers to functions to be called when
+// the program terminates or, when the CRT is statically linked into a DLL, when
+// the DLL is unloaded.
+//
+// When the CRT is statically linked into an EXE or a DLL, this registry is used
+// to hold the on-exit functions for the module (EXE or DLL) into which it is
+// linked.
+//
+// When the dynamic CRT is used, this object is part of the AppCRT DLL and this
+// registry stores the on-exit functions for the VCRuntime.  If the EXE for the
+// process uses this VCRuntime, then this registry also stores the on-exit
+// functions for that EXE.  If a DLL uses the dynamic CRT, then that DLL has its
+// own registry, defined in the statically-linked VCStartup library.
+//
+#include <corecrt_internal.h>
+
+
+
+// The global atexit and at_quick_exit registries
+extern "C" _onexit_table_t __acrt_atexit_table{};
+extern "C" _onexit_table_t __acrt_at_quick_exit_table{};
+
+
+
+enum : size_t
+{
+    initial_table_count     = 32,
+    minimum_table_increment = 4,
+    maximum_table_increment = 512
+};
+
+
+
+// Registers a function to be executed on exit.  This function modifies the global
+// onexit table.
+extern "C" int __cdecl _crt_atexit(_PVFV const function)
+{
+    return _register_onexit_function(&__acrt_atexit_table, reinterpret_cast<_onexit_t>(function));
+}
+
+extern "C" int __cdecl _crt_at_quick_exit(_PVFV const function)
+{
+    return _register_onexit_function(&__acrt_at_quick_exit_table, reinterpret_cast<_onexit_t>(function));
+}
+
+
+
+extern "C" int __cdecl _initialize_onexit_table(_onexit_table_t* const table)
+{
+    if (!table)
+    {
+        return -1;
+    }
+
+    // If the table has already been initialized, do not do anything.  Note that
+    // this handles both the case where the table was value initialized and where
+    // the table was initialized with encoded null pointers.
+    if (table->_first != table->_end)
+    {
+        return 0;
+    }
+
+    _PVFV* const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
+
+    table->_first = encoded_nullptr;
+    table->_last  = encoded_nullptr;
+    table->_end   = encoded_nullptr;
+
+    return 0;
+}
+
+
+
+// Appends the given 'function' to the given onexit 'table'.  Returns 0 on
+// success; returns -1 on failure.  In general, failures are considered fatal
+// in calling code.
+extern "C" int __cdecl _register_onexit_function(_onexit_table_t* const table, _onexit_t const function)
+{
+    return __acrt_lock_and_call(__acrt_select_exit_lock(), [&]
+    {
+        if (!table)
+        {
+            return -1;
+        }
+
+        _PVFV* first = __crt_fast_decode_pointer(table->_first);
+        _PVFV* last  = __crt_fast_decode_pointer(table->_last);
+        _PVFV* end   = __crt_fast_decode_pointer(table->_end);
+
+        // If there is no room for the new entry, reallocate a larger table:
+        if (last == end)
+        {
+            size_t const old_count = end - first;
+
+            size_t const increment = old_count > maximum_table_increment ? maximum_table_increment : old_count;
+
+            // First, try to double the capacity of the table:
+            size_t new_count = old_count + increment;
+            if (new_count == 0)
+            {
+                new_count = initial_table_count;
+            }
+
+            _PVFV* new_first = nullptr;
+            if (new_count >= old_count)
+            {
+                new_first = _recalloc_crt_t(_PVFV, first, new_count).detach();
+            }
+
+            // If that didn't work, try to allocate a smaller increment:
+            if (new_first == nullptr)
+            {
+                new_count = old_count + minimum_table_increment;
+                new_first = _recalloc_crt_t(_PVFV, first, new_count).detach();
+            }
+
+            if (new_first == nullptr)
+            {
+                return -1;
+            }
+
+            first = new_first;
+            last  = new_first + old_count;
+            end   = new_first + new_count;
+
+            // The "additional" storage obtained from recalloc is sero-initialized.
+            // The array holds encoded function pointers, so we need to fill the
+            // storage with encoded nullptrs:
+            _PVFV const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
+            for (auto it = last; it != end; ++it)
+            {
+                *it = encoded_nullptr;
+            }
+        }
+
+        *last++ = reinterpret_cast<_PVFV>(__crt_fast_encode_pointer(function));
+
+        table->_first = __crt_fast_encode_pointer(first);
+        table->_last  = __crt_fast_encode_pointer(last);
+        table->_end   = __crt_fast_encode_pointer(end);
+
+        return 0;
+    });
+}
+
+
+
+// This function executes a table of _onexit()/atexit() functions.  The
+// terminators are executed in reverse order, to give the required LIFO
+// execution order.  If the table is uninitialized, this function has no
+// effect.  After executing the terminators, this function resets the table
+// so that it is uninitialized.  Returns 0 on success; -1 on failure.
+extern "C" int __cdecl _execute_onexit_table(_onexit_table_t* const table)
+{
+    return __acrt_lock_and_call(__acrt_select_exit_lock(), [&]
+    {
+        if (!table)
+        {
+            return -1;
+        }
+
+        _PVFV* first = __crt_fast_decode_pointer(table->_first);
+        _PVFV* last  = __crt_fast_decode_pointer(table->_last);
+        if (!first || first == reinterpret_cast<_PVFV*>(-1))
+        {
+            return 0;
+        }
+
+        // This loop calls through caller-provided function pointers.  We must
+        // save and reset the global state mode before calling them, to maintain
+        // proper mode nesting.  (These calls to caller-provided function pointers
+        // are the only non-trivial calls, so we can do this once for the entire
+        // loop.)
+        {
+            __crt_state_management::scoped_global_state_reset saved_state;
+
+            _PVFV const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
+
+            _PVFV* saved_first = first;
+            _PVFV* saved_last  = last;
+            for (;;)
+            {
+                // Find the last valid function pointer to call:
+                while (--last >= first && *last == encoded_nullptr)
+                {
+                    // Keep going backwards
+                }
+
+                if (last < first)
+                {
+                    // There are no more valid entries in the list; we are done:
+                    break;
+                }
+
+                // Store the function pointer and mark it as visited in the list:
+                _PVFV const function = __crt_fast_decode_pointer(*last);
+                *last = encoded_nullptr;
+
+                function();
+
+                _PVFV* const new_first = __crt_fast_decode_pointer(table->_first);
+                _PVFV* const new_last  = __crt_fast_decode_pointer(table->_last);
+
+                // Reset iteration if either the begin or end pointer has changed:
+                if (new_first != saved_first || new_last != saved_last)
+                {
+                    first = saved_first = new_first;
+                    last  = saved_last  = new_last;
+                }
+            }
+        }
+
+        if (first != reinterpret_cast<_PVFV*>(-1))
+        {
+            _free_crt(first);
+        }
+
+        _PVFV* const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
+
+        table->_first = encoded_nullptr;
+        table->_last  = encoded_nullptr;
+        table->_end   = encoded_nullptr;
+
+        return 0;
+    });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/thread.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/thread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9e3a3500acde0610b6acf1f2961f316b832b8d1e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/startup/thread.cpp	
@@ -0,0 +1,278 @@
+//
+// thread.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The _beginthread(), _beginthreadex(), _endthread(), and _endthreadex().
+//
+// There are several key differences in behavior between _beginthread() and
+// _beginthreadex():
+//
+//  * _beginthreadex() takes three additional parameters, which are passed on to
+//    CreateThread():  a security descriptor for the new thread, the initial
+//    thread state (running or asleep), and an optional out parameter to which
+//    the thread id of the newly created thread will be stored.
+//
+//  * The procedure passed to _beginthread() must be __cdecl and has no return
+//    code.  The routine passed to _beginthreadex() must be __stdcall and must
+//    return a return code, which will be used as the thread exit code.
+//    Likewise, _endthread() takes no parameter and always returns a thread exit
+//    code of 0 if the thread exits without error, whereas _endthreadex() takes
+//    an exit code.
+//
+//  * _endthread() calls CloseHandle() on the handle returned from CreateThread().
+//    Note that this means that a caller should not use this handle, since it is
+//    possible that the thread will have terminated and the handle will have been
+//    closed by the time that _beginthread() returns.
+//
+//    _endthreadex() does not call CloseHandle() to close the handle:  the caller
+//    of _beginthreadex() is required to close the handle.
+//
+//  * _beginthread() returns -1 on failure.  _beginthreadex() returns zero on
+//    failure (just as CreateThread() does).
+//
+#include <corecrt_internal.h>
+#include <process.h>
+#include <roapi.h>
+
+// In some compilation models, the compiler is able to detect that the return
+// statement at the end of thread_start is unreachable.  We cannot suppress the
+// warning locally because it is a backend warning.
+#pragma warning(disable: 4702) // unreachable code
+#pragma warning(disable: 4984) // 'if constexpr' is a C++17 language extension
+
+
+namespace
+{
+    struct thread_parameter_free_policy
+    {
+        void operator()(__acrt_thread_parameter* const parameter) throw()
+        {
+            if (!parameter)
+            {
+                return;
+            }
+
+            if (parameter->_thread_handle)
+            {
+                CloseHandle(parameter->_thread_handle);
+            }
+
+            if (parameter->_module_handle)
+            {
+                FreeLibrary(parameter->_module_handle);
+            }
+
+            _free_crt(parameter);
+        }
+    };
+
+    using unique_thread_parameter = __crt_unique_heap_ptr<
+        __acrt_thread_parameter,
+        thread_parameter_free_policy>;
+}
+
+template <typename ThreadProcedure, bool Ex>
+static unsigned long WINAPI thread_start(void* const parameter) throw()
+{
+    if (!parameter)
+    {
+        ExitThread(GetLastError());
+    }
+
+    __acrt_thread_parameter* const context = static_cast<__acrt_thread_parameter*>(parameter);
+
+    __acrt_getptd()->_beginthread_context = context;
+
+    if (__acrt_get_begin_thread_init_policy() == begin_thread_init_policy_ro_initialize)
+    {
+        context->_initialized_apartment = __acrt_RoInitialize(RO_INIT_MULTITHREADED) == S_OK;
+    }
+
+    __try
+    {
+        ThreadProcedure const procedure = reinterpret_cast<ThreadProcedure>(context->_procedure);
+        if constexpr (Ex)
+        {
+            _endthreadex(procedure(context->_context));
+        }
+        else
+        {
+            procedure(context->_context);
+            _endthreadex(0);
+        }
+    }
+    __except (_seh_filter_exe(GetExceptionCode(), GetExceptionInformation()))
+    {
+        // Execution should never reach here:
+        _exit(GetExceptionCode());
+    }
+
+    // This return statement will never be reached.  All execution paths result
+    // in the thread or process exiting.
+    return 0;
+}
+
+
+
+static __acrt_thread_parameter* __cdecl create_thread_parameter(
+    void* const procedure,
+    void* const context
+    ) throw()
+{
+    unique_thread_parameter parameter(_calloc_crt_t(__acrt_thread_parameter, 1).detach());
+    if (!parameter)
+    {
+        return nullptr;
+    }
+
+    parameter.get()->_procedure = procedure;
+    parameter.get()->_context   = context;
+
+    // Attempt to bump the reference count of the module in which the user's
+    // thread procedure is defined, to ensure that the module will stay loaded
+    // as long as the thread is executing.  We will release this HMDOULE when
+    // the thread procedure returns or _endthreadex is called.
+    GetModuleHandleExW(
+        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+        reinterpret_cast<LPCWSTR>(procedure),
+        &parameter.get()->_module_handle);
+
+    return parameter.detach();
+}
+
+extern "C" uintptr_t __cdecl _beginthread(
+    _beginthread_proc_type const procedure,
+    unsigned int           const stack_size,
+    void*                  const context
+    )
+{
+    _VALIDATE_RETURN(procedure != nullptr, EINVAL, reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE));
+
+    unique_thread_parameter parameter(create_thread_parameter(procedure, context));
+    if (!parameter)
+    {
+        return reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE);
+    }
+
+    // We create the new thread in a suspended state so that we can update
+    // the parameter structure with the thread handle.  The newly created
+    // thread is responsible for closing this handle.
+    DWORD thread_id{};
+    HANDLE const thread_handle = CreateThread(
+        nullptr,
+        stack_size,
+        thread_start<_beginthread_proc_type, false>,
+        parameter.get(),
+        CREATE_SUSPENDED,
+        &thread_id);
+
+    if (!thread_handle)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE);
+    }
+
+    parameter.get()->_thread_handle = thread_handle;
+
+    // Now we can start the thread...
+    if (ResumeThread(thread_handle) == static_cast<DWORD>(-1))
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE);
+    }
+
+    // If we successfully created the thread, the thread now owns its parameter:
+    parameter.detach();
+
+    return reinterpret_cast<uintptr_t>(thread_handle);
+}
+
+extern "C" uintptr_t __cdecl _beginthreadex(
+    void*                    const security_descriptor,
+    unsigned int             const stack_size,
+    _beginthreadex_proc_type const procedure,
+    void*                    const context,
+    unsigned int             const creation_flags,
+    unsigned int*            const thread_id_result
+    )
+{
+    _VALIDATE_RETURN(procedure != nullptr, EINVAL, 0);
+
+    unique_thread_parameter parameter(create_thread_parameter(procedure, context));
+    if (!parameter)
+    {
+        return 0;
+    }
+
+    DWORD thread_id;
+    HANDLE const thread_handle = CreateThread(
+        reinterpret_cast<LPSECURITY_ATTRIBUTES>(security_descriptor),
+        stack_size,
+        thread_start<_beginthreadex_proc_type, true>,
+        parameter.get(),
+        creation_flags,
+        &thread_id);
+
+    if (!thread_handle)
+    {
+        __acrt_errno_map_os_error(GetLastError());
+        return 0;
+    }
+
+    if (thread_id_result)
+    {
+        *thread_id_result = thread_id;
+    }
+
+    // If we successfully created the thread, the thread now owns its parameter:
+    parameter.detach();
+
+    return reinterpret_cast<uintptr_t>(thread_handle);
+}
+
+
+
+static void __cdecl common_end_thread(unsigned int const return_code) throw()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (!ptd)
+    {
+        ExitThread(return_code);
+    }
+
+    __acrt_thread_parameter* const parameter = ptd->_beginthread_context;
+    if (!parameter)
+    {
+        ExitThread(return_code);
+    }
+
+    if (parameter->_initialized_apartment)
+    {
+        __acrt_RoUninitialize();
+    }
+
+    if (parameter->_thread_handle != INVALID_HANDLE_VALUE && parameter->_thread_handle != nullptr)
+    {
+        CloseHandle(parameter->_thread_handle);
+    }
+
+    if (parameter->_module_handle != INVALID_HANDLE_VALUE && parameter->_module_handle != nullptr)
+    {
+        FreeLibraryAndExitThread(parameter->_module_handle, return_code);
+    }
+    else
+    {
+        ExitThread(return_code);
+    }
+}
+
+extern "C" void __cdecl _endthread()
+{
+    return common_end_thread(0);
+}
+
+extern "C" void __cdecl _endthreadex(unsigned int const return_code)
+{
+    return common_end_thread(return_code);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_filbuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_filbuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89a339da02b2a397b417c086a615776a1478f24f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_filbuf.cpp	
@@ -0,0 +1,188 @@
+//
+// _filbuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that re-fill a stdio stream buffer and return the next character.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+namespace {
+
+    struct filwbuf_context
+    {
+        bool          _is_split_character;
+        unsigned char _leftover_low_order_byte;
+    };
+
+}
+
+
+
+// These functions store the pre-_read() state of the stream so that it can be
+// used later when we read a character from the newly-filled buffer.
+static int get_context_nolock(__crt_stdio_stream const, char) throw()
+{
+    return 0;
+}
+
+static filwbuf_context get_context_nolock(__crt_stdio_stream const stream, wchar_t) throw()
+{
+    // When reading wide character elements, we must handle the case where a two
+    // byte character straddles the buffer boundary, with the low order byte at
+    // the end of the old buffer and the high order byte at the start of the new
+    // buffer.
+    //
+    // We do this here:  if there is exactly one character left in the buffer, we
+    // store that and set a flag so we know to pick it up later.
+    filwbuf_context context;
+    if (stream->_cnt == 1)
+    {
+        context._is_split_character = true;
+        context._leftover_low_order_byte = static_cast<unsigned char>(*stream->_ptr);
+    }
+    else
+    {
+        context._is_split_character = false;
+        context._leftover_low_order_byte = 0;
+    }
+    return context;
+}
+
+
+// These functions test whether a buffer is valid following a call to _read().
+static bool is_buffer_valid_nolock(__crt_stdio_stream const stream, char) throw()
+{
+    return stream->_cnt !=  0
+        && stream->_cnt != -1;
+}
+
+static bool is_buffer_valid_nolock(__crt_stdio_stream const stream, wchar_t) throw()
+{
+    return stream->_cnt !=  0
+        && stream->_cnt !=  1
+        && stream->_cnt != -1;
+}
+
+
+
+// These functions read a character from the stream after the _read() has
+// completed successfully.
+static unsigned char read_character_nolock(__crt_stdio_stream const stream, int, char) throw()
+{
+    --stream->_cnt;
+    return static_cast<unsigned char>(*stream->_ptr++);
+}
+
+
+
+static wchar_t read_character_nolock(
+    __crt_stdio_stream const stream,
+    filwbuf_context    const context,
+    wchar_t
+    ) throw()
+{
+    if (context._is_split_character)
+    {
+        // If the character was split across buffers, we read only one byte
+        // from the new buffer and or it with the leftover byte from the old
+        // buffer.
+        unsigned char high_order_byte = static_cast<unsigned char>(*stream->_ptr);
+        wchar_t result = (high_order_byte << 8) | context._leftover_low_order_byte;
+
+        --stream->_cnt;
+        ++stream->_ptr;
+        return (result);
+    }
+    else
+    {
+        wchar_t const result = 0xffff & reinterpret_cast<wchar_t const&>(*stream->_ptr);
+
+        stream->_cnt -= sizeof(wchar_t);
+        stream->_ptr += sizeof(wchar_t);
+
+        return result;
+    }
+}
+
+
+
+// Fills a buffer and reads the first character.  Allocates a buffer for the
+// stream if the stream does not yet have one.  This function is intended for
+// internal usage only.  This function assumes that the caller has acquired
+// the lock for the stream.
+//
+// Returns the first character from the new buffer.  For the wide character
+// version, the case is handled where a character straddles the old and new
+// buffers.  Returns EOF if the file is string-backed or is not open for
+// reading, or if there are no more characters to be read.
+template <typename Character>
+static int __cdecl common_refill_and_read_nolock(__crt_stdio_stream const stream) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    _VALIDATE_RETURN(stream.valid(), EINVAL, stdio_traits::eof);
+
+    if (!stream.is_in_use() || stream.is_string_backed())
+        return stdio_traits::eof;
+
+    if (stream.has_all_of(_IOWRITE))
+    {
+        stream.set_flags(_IOERROR);
+        return stdio_traits::eof;
+    }
+
+    stream.set_flags(_IOREAD);
+
+    // Get a buffer, if necessary:
+    if (!stream.has_any_buffer())
+        __acrt_stdio_allocate_buffer_nolock(stream.public_stream());
+
+    auto const context = get_context_nolock(stream, Character());
+
+    stream->_ptr = stream->_base;
+    stream->_cnt = _read(_fileno(stream.public_stream()), stream->_base, stream->_bufsiz);
+
+    if (!is_buffer_valid_nolock(stream, Character()))
+    {
+        stream.set_flags(stream->_cnt != 0 ? _IOERROR : _IOEOF);
+        stream->_cnt = 0;
+        return stdio_traits::eof;
+    }
+
+    if (!stream.has_any_of(_IOWRITE | _IOUPDATE) &&
+        ((_osfile_safe(_fileno(stream.public_stream())) & (FTEXT | FEOFLAG)) == (FTEXT | FEOFLAG)))
+    {
+        stream.set_flags(_IOCTRLZ);
+    }
+
+    // Check for small _bufsiz (_SMALL_BUFSIZ). If it is small and if it is our
+    // buffer, then this must be the first call to this function after an fseek
+    // on a read-access-only stream. Restore _bufsiz to its larger value
+    // (_INTERNAL_BUFSIZ) so that the next call to this function, if one is made,
+    // will fill the whole buffer.
+    if (stream->_bufsiz == _SMALL_BUFSIZ &&
+        stream.has_crt_buffer() &&
+        !stream.has_all_of(_IOBUFFER_SETVBUF))
+    {
+        stream->_bufsiz = _INTERNAL_BUFSIZ;
+    }
+
+    return read_character_nolock(stream, context, Character());
+}
+
+
+
+extern "C" int __cdecl __acrt_stdio_refill_and_read_narrow_nolock(FILE* const stream)
+{
+    return common_refill_and_read_nolock<char>(__crt_stdio_stream(stream));
+}
+
+
+
+extern "C" int __cdecl __acrt_stdio_refill_and_read_wide_nolock(FILE* const stream)
+{
+    return common_refill_and_read_nolock<wchar_t>(__crt_stdio_stream(stream));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_file.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_file.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bba2e957552ad198905f51bb6e452625651ccc8d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_file.cpp	
@@ -0,0 +1,179 @@
+//
+// _file.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the _iob array, the global __piob pointer, the stdio initialization
+// and termination code, and the stream locking routines.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// FILE descriptors for stdin, stdout, and stderr
+extern "C" __crt_stdio_stream_data _iob[_IOB_ENTRIES] =
+{
+    // ptr      _base,   _cnt, _flag,                   _file, _charbuf, _bufsiz
+    {  nullptr, nullptr, 0,    _IOALLOCATED | _IOREAD,  0,     0,        0}, // stdin
+    {  nullptr, nullptr, 0,    _IOALLOCATED | _IOWRITE, 1,     0,        0}, // stdout
+    {  nullptr, nullptr, 0,    _IOALLOCATED | _IOWRITE, 2,     0,        0}, // stderr
+};
+
+extern "C" FILE* __cdecl __acrt_iob_func(unsigned const id)
+{
+    return &_iob[id]._public_file;
+}
+
+
+
+// Pointer to the array of FILE objects:
+__crt_stdio_stream_data** __piob;
+
+
+
+// Number of open streams (set to _NSTREAM by default):
+#ifdef CRTDLL
+    extern "C" { int _nstream = _NSTREAM_; }
+#else
+    extern "C" { int _nstream; }
+#endif
+
+
+
+// Initializer and terminator for the stdio library:
+_CRT_LINKER_FORCE_INCLUDE(__acrt_stdio_initializer);
+_CRT_LINKER_FORCE_INCLUDE(__acrt_stdio_terminator);
+
+
+
+#ifndef CRTDLL
+    // This variable is used by the statically linked CRT to ensure that if any
+    // stdio functionality is used, the terminate_stdio() function will be
+    // registered for call during CRT termination.
+    extern "C" int _cflush = 0;
+#endif
+
+
+
+// Initializes the stdio library.  Returns 0 on success; -1 on failure.
+extern "C" int __cdecl __acrt_initialize_stdio()
+{
+    #ifndef CRTDLL
+    // If the user has not supplied a definition of _nstream, set it to _NSTREAM_.
+    // If the user has supplied a value that is too small, set _nstream to the
+    // minimum acceptable value (_IOB_ENTRIES):
+    if (_nstream == 0)
+    {
+        _nstream = _NSTREAM_;
+    }
+    else if (_nstream < _IOB_ENTRIES)
+    {
+        _nstream = _IOB_ENTRIES;
+    }
+    #endif
+
+    // Allocate the __piob array.  Try for _nstream entries first.  If this
+    // fails, then reset _nstream to _IOB_ENTRIES an try again.  If it still
+    // fails, bail out and cause CRT initialization to fail:
+    __piob = _calloc_crt_t(__crt_stdio_stream_data*, _nstream).detach();
+    if (!__piob)
+    {
+        _nstream = _IOB_ENTRIES;
+
+        __piob = _calloc_crt_t(__crt_stdio_stream_data*, _nstream).detach();
+        if (!__piob)
+        {
+            return -1;
+        }
+    }
+
+    // Initialize the first _IOB_ENTRIES to point to the corresponding entries
+    // in _iob[]:
+    for (int i = 0; i != _IOB_ENTRIES; ++i)
+    {
+        __acrt_InitializeCriticalSectionEx(&_iob[i]._lock, _CORECRT_SPINCOUNT, 0);
+        __piob[i] = &_iob[i];
+
+        // For stdin, stdout, and stderr, we use _NO_CONSOLE_FILENO to allow
+        // callers to distinguish between failure to open a file (-1) and a
+        // program run without a console.
+        intptr_t const os_handle = _osfhnd(i);
+        bool const has_no_console =
+            os_handle == reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE) ||
+            os_handle == _NO_CONSOLE_FILENO ||
+            os_handle == 0;
+
+        if (has_no_console)
+        {
+            _iob[i]._file = _NO_CONSOLE_FILENO;
+        }
+    }
+
+    return 0;
+}
+
+
+
+// Terminates the stdio library.  All streams are flushed (this is done even if
+// we are going to close them since that stream won't do anything to the standard
+// streams) and closed.
+extern "C" void __cdecl __acrt_uninitialize_stdio()
+{
+    _flushall();
+    _fcloseall();
+
+    for (int i = 0; i != _IOB_ENTRIES; ++i)
+    {
+        __acrt_stdio_free_buffer_nolock(&__piob[i]->_public_file);
+        DeleteCriticalSection(&__piob[i]->_lock);
+    }
+
+    _free_crt(__piob);
+    __piob = nullptr;
+}
+
+
+
+// Locks a stdio stream.
+extern "C" void __cdecl _lock_file(FILE* const stream)
+{
+    EnterCriticalSection(&__crt_stdio_stream(stream)->_lock);
+}
+
+
+
+// Unlocks a stdio stream.
+extern "C" void __cdecl _unlock_file(FILE* const stream)
+{
+    LeaveCriticalSection(&__crt_stdio_stream(stream)->_lock);
+}
+
+
+
+extern "C" errno_t __cdecl _get_stream_buffer_pointers(
+    FILE*   const public_stream,
+    char*** const base,
+    char*** const ptr,
+    int**   const count
+    )
+{
+    _VALIDATE_RETURN_ERRCODE(public_stream != nullptr, EINVAL);
+
+    __crt_stdio_stream const stream(public_stream);
+    if (base)
+    {
+        *base = &stream->_base;
+    }
+
+    if (ptr)
+    {
+        *ptr = &stream->_ptr;
+    }
+
+    if (count)
+    {
+        *count = &stream->_cnt;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_flsbuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_flsbuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb23c20d2ec533e83fc51238a5e00a4580b5a84a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_flsbuf.cpp	
@@ -0,0 +1,213 @@
+//
+// _flsbuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that flush a stdio stream buffer and write a character.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+static bool __cdecl stream_is_at_end_of_file_nolock(
+    __crt_stdio_stream const stream
+    ) throw()
+{
+    if (stream.has_any_of(_IOEOF))
+    {
+        return true;
+    }
+
+    // If there is any data in the buffer, then we are not at the end of the file.
+    if (stream.has_big_buffer() && (stream->_ptr == stream->_base))
+    {
+        return false;
+    }
+
+    HANDLE const os_handle = reinterpret_cast<HANDLE>(_get_osfhandle(stream.lowio_handle()));
+
+    // If we fail at querying for the file size, proceed as though we cannot
+    // gather that information. For example, this will fail with pipes.
+    if (os_handle == INVALID_HANDLE_VALUE)
+    {
+        return false;
+    }
+
+    // Both SetFilePointerEx and GetFileSizeEx are valid ways to determine the
+    // length of a file. We can use that equivalence to check for end-of-file.
+
+    // This is a racy condition to check - a write or read from another process
+    // could interfere with the size reported from GetFileSizeEx.
+    // In that case, the write function looking to switch from read to write mode
+    // will fail in the usual manner when the write was not possible.
+    LARGE_INTEGER current_position;
+    if (!SetFilePointerEx(os_handle, {}, &current_position, FILE_CURRENT))
+    {
+        return false;
+    }
+
+    LARGE_INTEGER eof_position;
+    if (!GetFileSizeEx(os_handle, &eof_position))
+    {
+        return false;
+    }
+
+    return current_position.QuadPart == eof_position.QuadPart;
+}
+
+template <typename Character>
+static bool __cdecl write_buffer_nolock(
+    Character          const c,
+    __crt_stdio_stream const stream,
+    __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    int const fh = _fileno(stream.public_stream());
+
+    // If the stream is buffered, write the buffer if there are characters to
+    // be written, then push the character 'c' into the buffer:
+    if (stream.has_big_buffer())
+    {
+        _ASSERTE(("inconsistent IOB fields", stream->_ptr - stream->_base >= 0));
+
+        int const chars_to_write = static_cast<int>(stream->_ptr - stream->_base);
+        stream->_ptr = stream->_base   + sizeof(Character);
+        stream->_cnt = stream->_bufsiz - static_cast<int>(sizeof(Character));
+
+        int chars_written = 0;
+        if (chars_to_write > 0)
+        {
+            chars_written = _write_internal(fh, stream->_base, chars_to_write, ptd);
+        }
+        else
+        {
+            if (_osfile_safe(fh) & FAPPEND)
+            {
+                if (_lseeki64(fh, 0, SEEK_END) == -1)
+                {
+                    stream.set_flags(_IOERROR);
+                    return stdio_traits::eof;
+                }
+            }
+        }
+
+        *reinterpret_cast<Character*>(stream->_base) = c;
+        return chars_written == chars_to_write;
+    }
+    // Otherwise, perform a single character write (if we get here, either
+    // _IONBF is set or there is no buffering):
+    else
+    {
+        return _write_internal(fh, reinterpret_cast<char const*>(&c), sizeof(c), ptd) == sizeof(Character);
+    }
+}
+
+// Flushes the buffer of the given stream and writes the character.  If the stream
+// does not have a buffer, one is obtained for it.  The character 'c' is written
+// into the buffer after the buffer is flushed.  This function is only intended
+// to be called from within the library.  Returns (W)EOF on failure; otherwise
+// returns the character 'c' that was written to the file (note that 'c' may be
+// truncated if the int value cannot be represented by the Character type).
+template <typename Character>
+static int __cdecl common_flush_and_write_nolock(
+    int                const c,
+    __crt_stdio_stream const stream,
+    __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    unsigned const character_mask = (1 << (CHAR_BIT * sizeof(Character))) - 1;
+
+    _ASSERTE(stream.valid());
+
+    int const fh = _fileno(stream.public_stream());
+
+    if (!stream.has_any_of(_IOWRITE | _IOUPDATE))
+    {
+        ptd.get_errno().set(EBADF);
+        stream.set_flags(_IOERROR);
+        return stdio_traits::eof;
+    }
+    else if (stream.is_string_backed())
+    {
+        ptd.get_errno().set(ERANGE);
+        stream.set_flags(_IOERROR);
+        return stdio_traits::eof;
+    }
+
+    // Check that _IOREAD is not set or, if it is, then so is _IOEOF. Note
+    // that _IOREAD and IOEOF both being set implies switching from read to
+    // write at end-of-file, which is allowed by ANSI. Note that resetting
+    // the _cnt and _ptr fields amounts to doing an fflush() on the stream
+    // in this case. Note also that the _cnt field has to be reset to 0 for
+    // the error path as well (i.e., _IOREAD set but _IOEOF not set) as
+    // well as the non-error path.
+
+    if (stream.has_any_of(_IOREAD))
+    {
+        bool const switch_to_write_mode = stream_is_at_end_of_file_nolock(stream);
+        stream->_cnt = 0; // in either case, flush buffer
+
+        if (switch_to_write_mode)
+        {
+            stream->_ptr = stream->_base;
+            stream.unset_flags(_IOREAD);
+        }
+        else
+        {
+            stream.set_flags(_IOERROR);
+            return stdio_traits::eof;
+        }
+    }
+
+    stream.set_flags(_IOWRITE);
+    stream.unset_flags(_IOEOF);
+
+    stream->_cnt = 0;
+
+    // Get a buffer for this stream, if one is necessary:
+    if (!stream.has_any_buffer())
+    {
+        // If the stream uses temporary buffering, we do not set up a single character buffer;
+        // this is so that later temporary buffering will not be thwarted by
+        // the _IONBF flag being set. (See _stbuf() and _ftbuf() for more
+        //information on stdout and stderr buffering.)
+        if (!__acrt_should_use_temporary_buffer(stream.public_stream()))
+        {
+            __acrt_stdio_allocate_buffer_nolock(stream.public_stream());
+        }
+    }
+
+    // Write the character; return (W)EOF if it fails:
+    if (!write_buffer_nolock(static_cast<Character>(c & character_mask), stream, ptd))
+    {
+        stream.set_flags(_IOERROR);
+        return stdio_traits::eof;
+    }
+
+    return c & character_mask;
+}
+
+
+
+extern "C" int __cdecl __acrt_stdio_flush_and_write_narrow_nolock(
+    int                const c,
+    FILE*              const stream,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    return common_flush_and_write_nolock<char>(c, __crt_stdio_stream(stream), ptd);
+}
+
+
+
+extern "C" int __cdecl __acrt_stdio_flush_and_write_wide_nolock(
+    int                const c,
+    FILE*              const stream,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    return common_flush_and_write_nolock<wchar_t>(c, __crt_stdio_stream(stream), ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_freebuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_freebuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a3e19990f6796f4ce65344c7d689b9830b5ba099
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_freebuf.cpp	
@@ -0,0 +1,33 @@
+//
+// _freebuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines __acrt_stdio_free_buffer(), which releaes a buffer from a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Releases a buffer from a stream.  If the stream is buffered and the buffer
+// was allocated by the CRT, the space is freed.  If the buffer was provided by
+// the user, it is not freed (since we do not know how to free it).
+extern "C" void __cdecl __acrt_stdio_free_buffer_nolock(FILE* const public_stream)
+{
+    _ASSERTE(public_stream != nullptr);
+
+    __crt_stdio_stream const stream(public_stream);
+
+    if (!stream.is_in_use())
+        return;
+    
+    if (!stream.has_crt_buffer())
+        return;
+
+    _free_crt(stream->_base);
+
+    stream.unset_flags(_IOBUFFER_CRT | _IOBUFFER_SETVBUF);
+    stream->_base  = nullptr;
+    stream->_ptr   = nullptr;
+    stream->_cnt   = 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_getbuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_getbuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c206f9900c1b22d7c27f8d0ab1e712282b5d8baf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_getbuf.cpp	
@@ -0,0 +1,43 @@
+
+//
+// _getbuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines __acrt_stdio_allocate_buffer_nolock(), which allocates a buffer for a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Allocates a buffer for the provided stream.  This function assumes that the
+// caller has already checked to ensure that the stream does not already have a
+// buffer.
+extern "C" void __cdecl __acrt_stdio_allocate_buffer_nolock(FILE* const public_stream)
+{
+    _ASSERTE(public_stream != nullptr);
+
+    __crt_stdio_stream const stream(public_stream);
+
+    #ifndef CRTDLL
+    ++_cflush; // Force the library pre-termination procedure to run
+    #endif
+
+    // Try to get a big buffer:
+    stream->_base = _calloc_crt_t(char, _INTERNAL_BUFSIZ).detach();
+    if (stream->_base != nullptr)
+    {
+        stream.set_flags(_IOBUFFER_CRT);
+        stream->_bufsiz = _INTERNAL_BUFSIZ;
+    }
+    // If we couldn't get a big buffer, use single character buffering:
+    else
+    {
+        stream.set_flags(_IOBUFFER_NONE);
+        stream->_base = reinterpret_cast<char *>(&stream->_charbuf);
+        stream->_bufsiz = 2;
+    }
+
+    stream->_ptr = stream->_base;
+    stream->_cnt = 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_sftbuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_sftbuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f27adb26deab0fba830155d35307f09fe0ea7851
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/_sftbuf.cpp	
@@ -0,0 +1,146 @@
+//
+// _sftbuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines functions that enable and disable temporary buffering and flushing
+// for stdout and stderr.  When __acrt_stdio_begin_temporary_buffering_nolock()
+// is called for one of these streams, it tests whether the stream is buffered.
+// If the stream is not buffered, it gives it a temporary buffer, so that we can
+// avoid making sequences of one-character writes.
+//
+// __acrt_stdio_end_temporary_buffering_nolock() must be called to disable
+// temporary buffering when it is no longer needed.  This function flushes the
+// stream before tearing down the buffer.
+//
+// Note that these functions are only to be used for output streams--note that
+// __acrt_stdio_begin_temporary_buffering_nolock() sets the _IOWRITE flag.  These
+// functions are intended for internal library use only.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Buffer pointers for stdout and stderr
+extern "C" void* __acrt_stdout_buffer = nullptr;
+extern "C" void* __acrt_stderr_buffer = nullptr;
+
+// The temporary buffer has the data of one stdio call. Stderr and Stdout use a
+// temporary buffer for the duration of stdio output calls instead of having a
+// full buffer and write after flush. The temporary buffer prevents the stdio
+// functions from writing to the disk more than once per call when the stream is
+// unbuffered (except when _IONBF is specified).
+bool __acrt_should_use_temporary_buffer(FILE* const stream)
+{
+    if (stream == stderr)
+    {
+        return true;
+    }
+
+    if (stream == stdout && _isatty(_fileno(stream)))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+// Sets a temporary buffer if necessary (see __acrt_should_use_temporary_buffer).
+// On success, the buffer is initialized for the stream and 1 is returned. On
+// failure, 0 is returned. The temporary buffer ensures that only one write to
+// the disk occurs per stdio output call.
+extern "C" bool __cdecl __acrt_stdio_begin_temporary_buffering_nolock(
+    FILE* const public_stream
+    )
+{
+    _ASSERTE(public_stream != nullptr);
+
+    __crt_stdio_stream const stream(public_stream);
+
+    if (!__acrt_should_use_temporary_buffer(stream.public_stream()))
+    {
+        return false;
+    }
+
+    void** buffer;
+    if (stream.public_stream() == stdout)
+    {
+        buffer = &__acrt_stdout_buffer;
+    }
+    else if (stream.public_stream() == stderr)
+    {
+        buffer = &__acrt_stderr_buffer;
+    }
+    else
+    {
+        return false;
+    }
+
+    #ifndef CRTDLL
+    _cflush++; // Force library pre-termination procedure to run
+    #endif
+
+    // Make sure the stream is not already buffered:
+    if (stream.has_any_buffer())
+    {
+        return false;
+    }
+
+    stream.set_flags(_IOWRITE | _IOBUFFER_USER | _IOBUFFER_STBUF);
+    if (*buffer == nullptr)
+    {
+        *buffer = _malloc_crt_t(char, _INTERNAL_BUFSIZ).detach();
+    }
+
+    if (*buffer == nullptr)
+    {
+        // If we failed to allocate a buffer, use the small character buffer:
+        stream->_base   = reinterpret_cast<char*>(&stream->_charbuf);
+        stream->_ptr    = reinterpret_cast<char*>(&stream->_charbuf);
+        stream->_cnt    = 2;
+        stream->_bufsiz = 2;
+        return true;
+    }
+
+    // Otherwise, we have a new buffer, so set it up for use:
+    stream->_base   = reinterpret_cast<char*>(*buffer);
+    stream->_ptr    = reinterpret_cast<char*>(*buffer);
+    stream->_cnt    = _INTERNAL_BUFSIZ;
+    stream->_bufsiz = _INTERNAL_BUFSIZ;
+    return true;
+}
+
+
+
+// If the stream currently has a temporary buffer that was set via a call to
+// __acrt_stdio_begin_temporary_buffering_nolock(), and if the flag value is
+// 1, this function flushes the stream and disables buffering of the stream.
+extern "C" void __cdecl __acrt_stdio_end_temporary_buffering_nolock(
+    bool               const flag,
+    FILE*              const public_stream,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    if (!flag)
+        return;
+
+    if (stream.has_temporary_buffer())
+    {
+        // Flush the stream and tear down temporary buffering:
+        __acrt_stdio_flush_nolock(stream.public_stream(), ptd);
+        stream.unset_flags(_IOBUFFER_USER | _IOBUFFER_STBUF);
+        stream->_bufsiz = 0;
+        stream->_base   = nullptr;
+        stream->_ptr    = nullptr;
+    }
+
+    // Note: If we expand the functionality of the _IOBUFFER_STBUF bit to
+    // include other streams, we may want to clear that bit here under an
+    // 'else' clause (i.e., clear bit in the case that we leave the buffer
+    // permanently assigned.  Given our current use of the bit, the extra
+    // code is not needed.
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/clearerr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/clearerr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d448b115ca00fb5748e2c9225430f02dac0ae30
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/clearerr.cpp	
@@ -0,0 +1,37 @@
+//
+// clearerr.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines clearerr(), which clears error and EOF flags from a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+extern "C" errno_t __cdecl clearerr_s(FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _VALIDATE_RETURN_ERRCODE(stream.valid(), EINVAL);
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        stream.unset_flags(_IOERROR | _IOEOF);                               // Clear stdio flags
+        _osfile_safe(_fileno(stream.public_stream())) &= ~(FEOFLAG);         // Clear lowio flags
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return 0;
+}
+
+
+
+extern "C" void __cdecl clearerr(FILE* const stream)
+{
+    clearerr_s(stream);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/closeall.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/closeall.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b127c3c17d1610723cea9bf2958ddb00c415aa76
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/closeall.cpp	
@@ -0,0 +1,44 @@
+//
+// closeall.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _fcloseall(), which closes all opened files.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Closes all streams currently open except for stdin, stdout, and stderr.  All
+// tmpfile()-created streams are closed as well.  Returns EOF on failure; returns
+// the number of closed streams on success.
+extern "C" int __cdecl _fcloseall()
+{
+    int count = 0;
+
+    __acrt_lock(__acrt_stdio_index_lock);
+    __try
+    {
+        for (int i = _IOB_ENTRIES; i != _nstream; ++i)
+        {
+            if (__piob[i] == nullptr)
+                continue;
+
+            // If the stream is in use, close it:
+            if (__crt_stdio_stream(__piob[i]).is_in_use() && fclose(&__piob[i]->_public_file) != EOF)
+            {
+                ++count;
+            }
+
+            DeleteCriticalSection(&__piob[i]->_lock);
+            _free_crt(__piob[i]);
+            __piob[i] = nullptr;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_stdio_index_lock);
+    }
+
+    return count;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fclose.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fclose.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..efe790d154bf361bc2e09cd8fc5c20863c25b809
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fclose.cpp	
@@ -0,0 +1,86 @@
+//
+// fclose.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fclose(), which closes a stdio stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Closes a stdio stream after flushing the stream and freeing any buffer
+// associated with the stream (unless the buffer was set with setbuf).  Returns
+// zero on success; EOF on failure (e.g., if the flush fails, or it is not a
+// valid file or the file is not open, etc.).
+static int __cdecl _fclose_nolock_internal(FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _UCRT_VALIDATE_RETURN(ptd, stream.valid(), EINVAL, EOF);
+
+    int result = EOF;
+
+    if (stream.is_in_use())
+    {
+        result = __acrt_stdio_flush_nolock(stream.public_stream(), ptd);
+        __acrt_stdio_free_buffer_nolock(stream.public_stream());
+
+        if (_close_internal(_fileno(stream.public_stream()), ptd) < 0)
+        {
+            result = EOF;
+        }
+        else if (stream->_tmpfname != nullptr)
+        {
+            _free_crt(stream->_tmpfname);
+            stream->_tmpfname = nullptr;
+        }
+    }
+
+    __acrt_stdio_free_stream(stream);
+
+    return result;
+}
+
+extern "C" int __cdecl _fclose_nolock(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fclose_nolock_internal(public_stream, ptd);
+}
+
+static int __cdecl _fclose_internal(FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _UCRT_VALIDATE_RETURN(ptd, stream.valid(), EINVAL, EOF);
+
+    // If the stream is backed by a string, it requires no synchronization,
+    // flushing, etc., so we can simply free it, which resets all of its
+    // data to the defaults.
+    if (stream.is_string_backed())
+    {
+        __acrt_stdio_free_stream(stream);
+        return EOF;
+    }
+
+    int return_value = 0;
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        return_value = _fclose_nolock_internal(stream.public_stream(), ptd);
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return return_value;
+}
+
+extern "C" int __cdecl fclose(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fclose_internal(public_stream, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fdopen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fdopen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db5390775a35aa3036e16b8001b71a74db73f002
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fdopen.cpp	
@@ -0,0 +1,70 @@
+//
+// fdopen.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines functions that open a stdio stream over an existing lowio file handle.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Opens a lowio file handle as a stdio stream.  This associates a stream with
+// the specified file handle, thus allowing buffering and use with the stdio
+// functions.  The mode must be specified and must be compatible with the mode
+// with which the file was opened in lowio.
+//
+// Returns the new FILE* associated with the file handle on success; returns
+// nullptr on failure.
+template <typename Character>
+static FILE* __cdecl common_fdopen(
+    int              const fh,
+    Character const* const mode
+    ) throw()
+{
+    _VALIDATE_RETURN(mode != nullptr, EINVAL, nullptr);
+
+    _CHECK_FH_RETURN(fh, EBADF, nullptr);
+    _VALIDATE_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, nullptr);
+    _VALIDATE_RETURN(_osfile(fh) & FOPEN, EBADF, nullptr);
+
+    __acrt_stdio_stream_mode const parsed_mode = __acrt_stdio_parse_mode(mode);
+    if (!parsed_mode._success)
+        return nullptr;
+
+    __crt_stdio_stream stream = __acrt_stdio_allocate_stream();
+    if (!stream.valid())
+    {
+        errno = EMFILE;
+        return nullptr;
+    }
+
+    __try
+    {
+        // Ensure that streams get flushed during pre-termination:
+        #ifndef CRTDLL
+        ++_cflush;
+        #endif
+
+        stream.set_flags(parsed_mode._stdio_mode);
+        stream->_file = fh;
+    }
+    __finally
+    {
+        stream.unlock();
+    }
+
+    return stream.public_stream();
+}
+
+
+
+extern "C" FILE* __cdecl _fdopen(int const fh, char const* const mode)
+{
+    return common_fdopen(fh, mode);
+}
+
+extern "C" FILE* __cdecl _wfdopen(int const fh, wchar_t const* const mode)
+{
+    return common_fdopen(fh, mode);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/feoferr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/feoferr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..493103ab3f05ce0f2f95e6a716e37e10d2fbe1ea
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/feoferr.cpp	
@@ -0,0 +1,29 @@
+//
+// feoferr.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines feof() and ferror(), which test the end-of-file and error states of a
+// stream, respectively.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Tests the stream for the end-of-file condition.  Returns nonzero if and only
+// if the stream is at end-of-file.
+extern "C" int __cdecl feof(FILE* const public_stream)
+{
+    _VALIDATE_RETURN(public_stream != nullptr, EINVAL, 0);
+    return __crt_stdio_stream(public_stream).eof();
+}
+
+
+
+// Tests the stream error indicator.  Returns nonzero if and only if the error
+// indicator for the stream is set.
+extern "C" int __cdecl ferror(FILE* const public_stream)
+{
+    _VALIDATE_RETURN(public_stream != nullptr, EINVAL, 0);
+    return __crt_stdio_stream(public_stream).error();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fflush.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fflush.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..59c206c75473b71cbe846c4753e46ab51684cf40
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fflush.cpp	
@@ -0,0 +1,264 @@
+//
+// fflush.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fflush() and related functions, which flush stdio streams.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+static bool __cdecl is_stream_allocated(long const stream_flags) throw()
+{
+    return (stream_flags & _IOALLOCATED) != 0;
+}
+
+static bool __cdecl is_stream_flushable(long const stream_flags) throw()
+{
+    if ((stream_flags & (_IOREAD | _IOWRITE)) != _IOWRITE)
+    {
+        return false;
+    }
+
+    if ((stream_flags & (_IOBUFFER_CRT | _IOBUFFER_USER)) == 0)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+static bool __cdecl is_stream_flushable_or_commitable(long const stream_flags) throw()
+{
+    if (is_stream_flushable(stream_flags))
+    {
+        return true;
+    }
+
+    if (stream_flags & _IOCOMMIT)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+// Returns true if the common_flush_all function should attempt to flush the
+// stream; otherwise returns false.  This function returns false for streams
+// that are not in use (not allocated) and for streams for which the flush
+// operation will be a no-op.
+//
+// In the case where this function determines that the flush would be a no-op,
+// it increments the flushed_stream_count.  This allows common_flush_all to
+// keep track of the number of streams that it would have flushed.
+static bool __cdecl common_flush_all_should_try_to_flush_stream(
+    _In_    __crt_stdio_stream const stream,
+    _Inout_ int*               const flushed_stream_count
+    ) throw()
+{
+    if (!stream.valid())
+    {
+        return false;
+    }
+
+    long const stream_flags = stream.get_flags();
+    if (!is_stream_allocated(stream_flags))
+    {
+        return false;
+    }
+
+    if (!is_stream_flushable_or_commitable(stream_flags))
+    {
+        ++*flushed_stream_count;
+        return false;
+    }
+
+    return true;
+}
+
+
+
+// Internal implementation of the "flush all" functionality.  If the
+// flush_read_mode_streams argument is false, only write mode streams are
+// flushed and the return value is zero on success, EOF on failure.
+//
+// If the flush_read_mode_streams argument is true, this function flushes
+// all streams regardless of mode and returns the number of streams that it
+// flushed.
+//
+// Note that in both cases, if we can determine that a call to fflush for a
+// particular stream would be a no-op, then we will not call fflush for that
+// stream.  This allows us to avoid acquiring the stream lock unnecessarily,
+// which can help to avoid deadlock-like lock contention.
+//
+// Notably, by doing this, we can avoid attempting to acquire the stream lock
+// for most read mode streams.  Attempting to acquire the stream lock for a
+// read mode stream can be problematic beause another thread may hold the lock
+// and be blocked on an I/O operation (e.g., a call to fread on stdin may block
+// until the user types input into the console).
+static int __cdecl common_flush_all(bool const flush_read_mode_streams) throw()
+{
+    int count = 0;
+    int error = 0;
+
+    __acrt_lock_and_call(__acrt_stdio_index_lock, [&]
+    {
+        __crt_stdio_stream_data** const first_file = __piob;
+        __crt_stdio_stream_data** const last_file  = first_file + _nstream;
+
+        for (__crt_stdio_stream_data** it = first_file; it != last_file; ++it)
+        {
+            __crt_stdio_stream const stream(*it);
+
+            // Before we acquire the stream lock, check to see if flushing the
+            // stream would be a no-op.  If it would be, then skip this stream.
+            if (!common_flush_all_should_try_to_flush_stream(stream, &count))
+            {
+                continue;
+            }
+
+            __acrt_lock_stream_and_call(stream.public_stream(), [&]
+            {
+                // Re-verify the state of the stream.  Another thread may have
+                // closed the stream, reopened it into a different mode, or
+                // otherwise altered the state of the stream such that this
+                // flush would be a no-op.
+                if (!common_flush_all_should_try_to_flush_stream(stream, &count))
+                {
+                    return;
+                }
+
+                if (!flush_read_mode_streams && !stream.has_all_of(_IOWRITE))
+                {
+                    return;
+                }
+
+                if (_fflush_nolock(stream.public_stream()) != EOF)
+                {
+                    ++count;
+                }
+                else
+                {
+                    error = EOF;
+                }
+            });
+        }
+    });
+
+    return flush_read_mode_streams ? count : error;
+}
+
+
+
+// Flushes the buffer of the given stream.  If the file is open for writing and
+// is buffered, the buffer is flushed.  On success, returns 0.  On failure (e.g.
+// if there is an error writing the buffer), returns EOF and sets errno.
+extern "C" int __cdecl fflush(FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    // If the stream is null, flush all the streams:
+    if (!stream.valid())
+    {
+        return common_flush_all(false);
+    }
+
+    // Before acquiring the stream lock, inspect the stream to see if the flush
+    // is a no-op.  If it will be a no-op then we can return without attempting
+    // to acquire the lock (this can help prevent locking conflicts; see the
+    // common_flush_all implementation for more information).
+    if (!is_stream_flushable_or_commitable(stream.get_flags()))
+    {
+        return 0;
+    }
+
+    return __acrt_lock_stream_and_call(stream.public_stream(), [&]
+    {
+        return _fflush_nolock(stream.public_stream());
+    });
+}
+
+
+
+static int __cdecl _fflush_nolock_internal(FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    // If the stream is null, flush all the streams.
+    if (!stream.valid())
+    {
+        return common_flush_all(false);
+    }
+
+    if (__acrt_stdio_flush_nolock(stream.public_stream(), ptd) != 0)
+    {
+        // If the flush fails, do not attempt to commit:
+        return EOF;
+    }
+
+    // Perform the lowio commit to ensure data is written to disk:
+    if (stream.has_all_of(_IOCOMMIT))
+    {
+        if (_commit(_fileno(public_stream)))
+        {
+            return EOF;
+        }
+    }
+
+    return 0;
+}
+
+extern "C" int __cdecl _fflush_nolock(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fflush_nolock_internal(public_stream, ptd);
+}
+
+// Flushes the buffer of the given stream.  If the file is open for writing and
+// is buffered, the buffer is flushed.  On success, returns 0.  On failure (e.g.
+// if there is an error writing the buffer), returns EOF and sets errno.
+extern "C" int __cdecl __acrt_stdio_flush_nolock(FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    if (!is_stream_flushable(stream.get_flags()))
+    {
+        return 0;
+    }
+
+    int const bytes_to_write = static_cast<int>(stream->_ptr - stream->_base);
+
+    __acrt_stdio_reset_buffer(stream);
+
+    if (bytes_to_write <= 0)
+    {
+        return 0;
+    }
+
+    int const bytes_written = _write_internal(_fileno(stream.public_stream()), stream->_base, bytes_to_write, ptd);
+    if (bytes_to_write != bytes_written)
+    {
+        stream.set_flags(_IOERROR);
+        return EOF;
+    }
+
+    // If this is a read/write file, clear _IOWRITE so that the next operation can
+    // be a read:
+    if (stream.has_all_of(_IOUPDATE))
+    {
+        stream.unset_flags(_IOWRITE);
+    }
+
+    return 0;
+}
+
+
+
+// Flushes the buffers for all output streams and clears all input buffers.
+// Returns the number of open streams.
+extern "C" int __cdecl _flushall()
+{
+    return common_flush_all(true);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd947bb431425d17f4aace71afbdcf4f70313963
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetc.cpp	
@@ -0,0 +1,81 @@
+//
+// fgetc.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that read the next character from a stream and return it.  If the
+// read causes the stream to reach EOF, EOF is returned and the EOF bit is set
+// on the stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+extern "C" int __cdecl _fgetc_nolock(FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _VALIDATE_RETURN(stream.valid(), EINVAL, EOF);
+
+    --stream->_cnt;
+
+    if (stream->_cnt < 0)
+        return __acrt_stdio_refill_and_read_narrow_nolock(stream.public_stream());
+
+    char const c = *stream->_ptr;
+    ++stream->_ptr;
+    return c & 0xff;
+}
+
+
+
+extern "C" int __cdecl _getc_nolock(FILE* const stream)
+{
+    return _fgetc_nolock(stream);
+}
+
+
+
+extern "C" int __cdecl fgetc(FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _VALIDATE_RETURN(stream.valid(), EINVAL, EOF);
+
+    int return_value = 0;
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        _VALIDATE_STREAM_ANSI_RETURN(stream, EINVAL, EOF);
+        
+        return_value = _fgetc_nolock(stream.public_stream());
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" int __cdecl getc(FILE* const stream)
+{
+    return fgetc(stream);
+}
+
+
+
+extern "C" int __cdecl _fgetchar()
+{
+    return fgetc(stdin);
+}
+
+
+
+extern "C" int __cdecl getchar()
+{
+    return _fgetchar();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetpos.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetpos.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec516dcef3eeea031f1f0ca78bcc3e0c565de6f1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetpos.cpp	
@@ -0,0 +1,26 @@
+//
+// fgetpos.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fgetpos(), which gets the file position in an opaque internal format.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Gets the file position in the internal fpos_t format.  The returned value
+// should only be used in a call to fsetpos().  Our implementation happens to
+// just wrap _ftelli64() and _fseeki64().  Return zero on success; returns -1
+// and sets errno on failure.
+extern "C" int __cdecl fgetpos(FILE* const stream, fpos_t* const position)
+{
+    _VALIDATE_RETURN(stream   != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(position != nullptr, EINVAL, -1);
+
+    *position = _ftelli64(stream);
+    if (*position == -1)
+        return -1;
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgets.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgets.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..21abe78b8644c017d5689f90abdc63dc59851a75
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgets.cpp	
@@ -0,0 +1,100 @@
+//
+// fgets.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that read a string from a file.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Reads a string from a stream.  This function reads a string, up to 'count - 1'
+// characters in length, or until a '\n', whichever is reached first.  The string
+// is always null-terminated on return.  The '\n' _is_ written to the string if
+// it is encountered before space is exhausted.  If EOF is encountered immediately,
+// null is returned.  If EOF is encountered after some characters are read, EOF
+// terminates input just as '\n' would.
+//
+// Returns null if the count is nonpositive or if EOF is encountered immediately.
+// Otherwise, returns the string.
+template <typename Character>
+_Success_(return != 0)
+static Character* __cdecl common_fgets(
+    _Out_writes_z_(count) Character*    const string,
+    int                                 const count,
+    __crt_stdio_stream                  const stream
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    _VALIDATE_RETURN(string != nullptr || count == 0, EINVAL, nullptr);
+    _VALIDATE_RETURN(count >= 0,                      EINVAL, nullptr);
+    _VALIDATE_RETURN(stream.valid(),                  EINVAL, nullptr);
+
+    if (count == 0)
+        return nullptr;
+
+    Character* return_value = nullptr;
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        if (!stdio_traits::validate_stream_is_ansi_if_required(stream.public_stream()))
+            __leave;
+
+        // Note that we start iterating at 1, so we read at most 'count - 1'
+        // characters from the stream, leaving room for the null terminator:
+        Character* it = string;
+        for (int i = 1; i != count; ++i)
+        {
+            int const c = stdio_traits::getc_nolock(stream.public_stream());
+            if (c == stdio_traits::eof)
+            {
+                // If we immediately reach EOF before reading any characters,
+                // the C Language Standard mandates that the input buffer should
+                // be left unmodified, so we return immediately, without writing
+                // anything to the buffer:
+                if (it == string)
+                    __leave;
+
+                // Otherwise, when we reach EOF, we just need to stop iterating:
+                break;
+            }
+
+            // We stop reading when we reach a newline.  We do copy the newline:
+            *it++ = static_cast<Character>(c);
+            if (static_cast<Character>(c) == '\n')
+                break;
+        }
+
+        *it = '\0';
+        return_value = string;
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" char* __cdecl fgets(
+    char* const string,
+    int   const count,
+    FILE* const stream
+    )
+{
+    return common_fgets(string, count, __crt_stdio_stream(stream));
+}
+
+extern "C" wchar_t* __cdecl fgetws(
+    wchar_t* const string,
+    int      const count,
+    FILE*    const stream
+    )
+{
+    return common_fgets(string, count, __crt_stdio_stream(stream));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetwc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetwc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c1577ef21f45c3e8ce22a1dff14d6978af9cfbe
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fgetwc.cpp	
@@ -0,0 +1,136 @@
+//
+// fgetwc.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that read the next wide character from a stream and return it.  If
+// the read causes the stream to reach EOF, WEOF is returned and the EOF bit is
+// set on the stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+extern "C" wint_t __cdecl _fgetwc_nolock(FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    // If the stream is backed by a real file and is open in a Unicode text mode,
+    // we need to read two bytes (note that we read two bytes for both UTF-8 and
+    // UTF-16 backed streams, since lowio translates UTF-8 to UTF-16 when we read.
+    if (!stream.is_string_backed() &&
+        _textmode_safe(_fileno(stream.public_stream())) != __crt_lowio_text_mode::ansi)
+    {
+        wchar_t wc;
+
+        // Compose the wide character by reading byte-by-byte from the stream:
+        char* const wc_first = reinterpret_cast<char*>(&wc);
+        char* const wc_last  = wc_first + sizeof(wc);
+
+        for (char* it = wc_first; it != wc_last; ++it)
+        {
+            int const c = _getc_nolock(stream.public_stream());
+            if (c == EOF)
+                return WEOF;
+
+            *it = static_cast<char>(c);
+        }
+
+        return wc;
+    }
+
+    if (!stream.is_string_backed() &&
+        (_osfile_safe(_fileno(stream.public_stream())) & FTEXT))
+    {
+        int size = 1;
+        int ch;
+        char mbc[4];
+        wchar_t wch;
+
+        /* text (multi-byte) mode */
+        if ((ch = _getc_nolock(stream.public_stream())) == EOF)
+            return WEOF;
+
+        mbc[0] = static_cast<char>(ch);
+
+        if (isleadbyte(static_cast<unsigned char>(mbc[0])))
+        {
+            if ((ch = _getc_nolock(stream.public_stream())) == EOF)
+            {
+                ungetc(mbc[0], stream.public_stream());
+                return WEOF;
+            }
+            mbc[1] = static_cast<char>(ch);
+            size = 2;
+        }
+
+        if (mbtowc(&wch, mbc, size) == -1)
+        {
+            // Conversion failed! Set errno and return failure:
+            errno = EILSEQ;
+            return WEOF;
+        }
+
+        return wch;
+    }
+
+    // binary (Unicode) mode
+    if (stream->_cnt >= static_cast<int>(sizeof(wchar_t)))
+    {
+        stream->_cnt -= static_cast<int>(sizeof(wchar_t));
+        return *reinterpret_cast<wchar_t*&>(stream->_ptr)++;
+    }
+    else
+    {
+        return static_cast<wint_t>(__acrt_stdio_refill_and_read_wide_nolock(stream.public_stream()));
+    }
+}
+
+
+
+extern "C" wint_t __cdecl _getwc_nolock(FILE* const stream)
+{
+    return _fgetwc_nolock(stream);
+}
+
+
+
+extern "C" wint_t __cdecl fgetwc(FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, WEOF);
+
+    wint_t return_value = 0;
+
+    _lock_file(stream);
+    __try
+    {
+        return_value = _fgetwc_nolock(stream);
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" wint_t __cdecl getwc(FILE* const stream)
+{
+    return fgetwc(stream);
+}
+
+
+
+extern "C" wint_t __cdecl _fgetwchar()
+{
+    return fgetwc(stdin);
+}
+
+
+
+extern "C" wint_t __cdecl getwchar()
+{
+    return _fgetwchar();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fileno.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fileno.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d09c3990055cc500c1105fde3ce50fb7f3b8471c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fileno.cpp	
@@ -0,0 +1,19 @@
+//
+// fileno.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _fileno(), which returns the lowio file handle for the given stdio
+// stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+extern "C" int __cdecl _fileno(FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _VALIDATE_RETURN(stream.valid(), EINVAL, -1);
+    return stream.lowio_handle();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fopen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fopen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dd3763aea518f1d3c2a0de933a686e6c60bc020
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fopen.cpp	
@@ -0,0 +1,139 @@
+//
+// fopen.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that open a file as a stdio stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Opens the file named by 'file_name' as a stdio stream.  The 'mode' determines
+// the mode in which the file is opened and the 'share_flag' determines the
+// sharing mode.  Supported modes are "r" (read), "w" (write), "a" (append),
+// "r+" (read and write), "w+" (open empty for read and write), and "a+" (read
+// and append).  A "t" or "b" may be appended to the mode string to request text
+// or binary mode, respectively.
+//
+// Returns the FILE* for the newly opened stream on success; returns nullptr on
+// failure.
+template <typename Character>
+static FILE* __cdecl common_fsopen(
+    Character const* const file_name,
+    Character const* const mode,
+    int              const share_flag
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    _VALIDATE_RETURN(file_name != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(mode != nullptr,      EINVAL, nullptr);
+    _VALIDATE_RETURN(*mode != 0,           EINVAL, nullptr);
+
+    // We deliberately don't hard-validate for empty strings here. All other
+    // invalid path strings are treated as runtime errors by the inner code
+    // in _open and openfile.  This is also the appropriate treatment here.
+    // Since fopen is the primary access point for file strings it might be
+    // subjected to direct user input and thus must be robust to that rather
+    // than aborting. The CRT and OS do not provide any other path validator
+    // (because Win32 doesn't allow such things to exist in full generality).
+    _VALIDATE_RETURN_NOEXC(*file_name != 0, EINVAL, nullptr);
+
+    // Obtain a free stream.  Note that the stream is returned locked:
+    __crt_stdio_stream stream = __acrt_stdio_allocate_stream();
+    if (!stream.valid())
+    {
+        errno = EMFILE;
+        return nullptr;
+    }
+
+    FILE* return_value = nullptr;
+    __try
+    {
+        return_value = stdio_traits::open_file(file_name, mode, share_flag, stream.public_stream());
+    }
+    __finally
+    {
+        if (return_value == nullptr)
+            __acrt_stdio_free_stream(stream);
+
+        stream.unlock();
+    }
+
+    return return_value;
+}
+
+
+
+// A "secure" version of fsopen, which sets the result and returns zero on
+// success and an error code on failure.
+template <typename Character>
+static errno_t __cdecl common_fopen_s(
+    FILE**           const result,
+    Character const* const file_name,
+    Character const* const mode
+    ) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+
+    *result = common_fsopen(file_name, mode, _SH_SECURE);
+    if (*result == nullptr)
+        return errno;
+
+    return 0;
+}
+
+
+
+extern "C" FILE* __cdecl _fsopen(
+    char const* const file,
+    char const* const mode,
+    int         const share_flag
+    )
+{
+    return common_fsopen(file, mode, share_flag);
+}
+
+extern "C" FILE* __cdecl fopen(
+    char const* const file,
+    char const* const mode
+    )
+{
+    return common_fsopen(file, mode, _SH_DENYNO);
+}
+
+extern "C" errno_t __cdecl fopen_s(
+    FILE**      const result,
+    char const* const file,
+    char const* const mode
+    )
+{
+    return common_fopen_s(result, file, mode);
+}
+
+extern "C" FILE* __cdecl _wfsopen(
+    wchar_t const* const file,
+    wchar_t const* const mode,
+    int            const share_flag
+    )
+{
+    return common_fsopen(file, mode, share_flag);
+}
+
+extern "C" FILE* __cdecl _wfopen(
+    wchar_t const* const file,
+    wchar_t const* const mode
+    )
+{
+    return common_fsopen(file, mode, _SH_DENYNO);
+}
+
+extern "C" errno_t __cdecl _wfopen_s(
+    FILE**         const result,
+    wchar_t const* const file,
+    wchar_t const* const mode
+    )
+{
+    return common_fopen_s(result, file, mode);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba5282ca987b4e9c1393b84320602467fbe44b22
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputc.cpp	
@@ -0,0 +1,97 @@
+//
+// fputc.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the fputc() family of functions, which write a character to a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+extern "C" int __cdecl _fputc_nolock_internal(int const c, FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    --stream->_cnt;
+
+    // If there is no room for the character in the buffer, flush the buffer and
+    // write the character:
+    if (stream->_cnt < 0)
+    {
+        return __acrt_stdio_flush_and_write_narrow_nolock(c, stream.public_stream(), ptd);
+    }
+
+    // Otherwise, there is sufficient room, so we can write directly to the buffer:
+    char const char_value = static_cast<char>(c);
+    *stream->_ptr++ = char_value;
+    return char_value & 0xff;
+}
+
+extern "C" int __cdecl _fputc_nolock(int const c, FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fputc_nolock_internal(c, public_stream, ptd);
+}
+
+extern "C" int __cdecl _putc_nolock(int const c, FILE* const stream)
+{
+    return _fputc_nolock(c, stream);
+}
+
+
+
+// Writes a character to a stream.  Returns the character on success; returns
+// EOF on failure.
+static int __cdecl _fputc_internal(int const c, FILE* const stream, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_VALIDATE_RETURN(ptd, stream != nullptr, EINVAL, EOF);
+
+    int return_value = 0;
+
+    _lock_file(stream);
+    __try
+    {
+        _UCRT_VALIDATE_STREAM_ANSI_RETURN(ptd, stream, EINVAL, EOF);
+
+        return_value = _fputc_nolock_internal(c, stream, ptd);
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
+
+// Writes a character to a stream.  Returns the character on success; returns
+// EOF on failure.
+extern "C" int __cdecl fputc(int const c, FILE* const stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fputc_internal(c, stream, ptd);
+}
+
+
+
+// Writes a character to a stream.  See fputc() for details.
+extern "C" int __cdecl putc(int const c, FILE* const stream)
+{
+    return fputc(c, stream);
+}
+
+
+
+// Writes a character to stdout.  See fputc() for details.
+extern "C" int __cdecl _fputchar(int const c)
+{
+    return fputc(c, stdout);
+}
+
+
+
+// Writes a character to stdout.  See fputc() for details.
+extern "C" int __cdecl putchar(int const c)
+{
+    return _fputchar(c);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c00ec6eec13fc39ddab6e3dc46c77c26a338267b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputs.cpp	
@@ -0,0 +1,42 @@
+//
+// fputs.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fputs(), which writes a string to a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Writes the given string to the given stream.  Does not write the string's null
+// terminator, and does not append a '\n' to the file.  Returns a nonnegative
+// value on success; EOF on failure.
+static int __cdecl _fputs_internal(char const* const string, FILE* const stream, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_VALIDATE_RETURN(ptd, string != nullptr,  EINVAL, EOF);
+    _UCRT_VALIDATE_RETURN(ptd, stream != nullptr,  EINVAL, EOF);
+    _UCRT_VALIDATE_STREAM_ANSI_RETURN(ptd, stream, EINVAL, EOF);
+
+    size_t const length = strlen(string);
+
+    return __acrt_lock_stream_and_call(stream, [&]() -> int
+    {
+        __acrt_stdio_temporary_buffering_guard const buffering(stream, ptd);
+
+        size_t const bytes_written = _fwrite_nolock_internal(string, 1, length, stream, ptd);
+        if (bytes_written == length)
+        {
+            return 0;
+        }
+
+        return EOF;
+    });
+}
+
+extern "C" int __cdecl fputs(char const* const string, FILE* const stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fputs_internal(string, stream, ptd);
+}
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputwc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputwc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c34d5b695570bc480c8200c3d6f902527836e10a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputwc.cpp	
@@ -0,0 +1,145 @@
+//
+// fputwc.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the fputc() family of functions, which write a character to a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_mbstring.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+static wint_t __cdecl fputwc_binary_nolock(wchar_t const c, __crt_stdio_stream const stream, __crt_cached_ptd_host& ptd) throw()
+{
+    stream->_cnt -= sizeof(wchar_t);
+
+    // If there is no room for the character in the buffer, flush the buffer and
+    // write the character:
+    if (stream->_cnt < 0)
+    {
+        return static_cast<wint_t>(__acrt_stdio_flush_and_write_wide_nolock(c, stream.public_stream(), ptd));
+    }
+
+    // Otherwise, there is sufficient room, so we can write directly to the buffer:
+    wchar_t*& wide_stream_ptr = reinterpret_cast<wchar_t*&>(stream->_ptr);
+    *wide_stream_ptr++ = c;
+
+    return c;
+}
+
+
+
+extern "C" wint_t __cdecl _fputwc_nolock_internal(wchar_t const c, FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    // If this stream is not file-backed, we can write the character directly:
+    if (stream.is_string_backed())
+    {
+        return fputwc_binary_nolock(c, stream, ptd);
+    }
+
+    __crt_lowio_text_mode const text_mode = _textmode_safe(_fileno(stream.public_stream()));
+
+    // If the file is open in a Unicode text mode, we can write the character
+    // directly to the stream:
+    if (text_mode == __crt_lowio_text_mode::utf16le || text_mode == __crt_lowio_text_mode::utf8)
+    {
+        return fputwc_binary_nolock(c, stream, ptd);
+    }
+
+    // If the file is open in binary mode, we can write the character directly
+    // to the stream:
+    if ((_osfile_safe(_fileno(stream.public_stream())) & FTEXT) == 0)
+    {
+        return fputwc_binary_nolock(c, stream, ptd);
+    }
+
+    // Otherwise, the file is open in ANSI text mode, and we need to translate
+    // the wide character to multibyte before we can write it:
+    char mbc[MB_LEN_MAX];
+
+    int size;
+    if (_wctomb_internal(&size, mbc, MB_LEN_MAX, c, ptd) != 0)
+    {
+        // If conversion failed, errno is set by wctomb_s and we return WEOF:
+        return WEOF;
+    }
+
+    // Write the character, byte-by-byte:
+    for (int i = 0; i < size; ++i)
+    {
+        if (_fputc_nolock_internal(mbc[i], stream.public_stream(), ptd) == EOF)
+        {
+            return WEOF;
+        }
+    }
+
+    return c;
+}
+
+extern "C" wint_t __cdecl _fputwc_nolock(wchar_t const c, FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fputwc_nolock_internal(c, public_stream, ptd);
+}
+
+extern "C" wint_t __cdecl _putwc_nolock(wchar_t const c, FILE* const stream)
+{
+    return _fputwc_nolock(c, stream);
+}
+
+
+
+// Writes a wide character to a stream.  Returns the wide character on success;
+// WEOF on failure.
+static wint_t __cdecl _fputwc_internal(wchar_t const c, FILE* const stream, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_VALIDATE_RETURN(ptd, stream != nullptr, EINVAL, WEOF);
+
+    wint_t return_value = WEOF;
+
+    _lock_file(stream);
+    __try
+    {
+        return_value = _fputwc_nolock_internal(c, stream, ptd);
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
+
+extern "C" wint_t __cdecl fputwc(wchar_t const c, FILE* const stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fputwc_internal(c, stream, ptd);
+}
+
+
+
+// Writes a wide character to a stream.  See fputwc() for details.
+extern "C" wint_t __cdecl putwc(wchar_t const c, FILE* const stream)
+{
+    return fputwc(c, stream);
+}
+
+
+
+// Writes a wide character to stdout.  See fputwc() for details.
+extern "C" wint_t __cdecl _fputwchar(wchar_t const c)
+{
+    return fputwc(c, stdout);
+}
+
+
+
+// Writes a wide character to stdout.  See fputwc() for details.
+extern "C" wint_t __cdecl putwchar(wchar_t const c)
+{
+    return _fputwchar(c);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputws.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputws.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7468a653b5244dad61aa67a59c53717b9937b4c8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fputws.cpp	
@@ -0,0 +1,43 @@
+//
+// fputws.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fputws(), which writes a wide character string to a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Writes the given wide character string to the given stream.  Does not write
+// the string's null terminator, and does not append a '\n' to the file.  Returns
+// a nonnegative value on success; EOF on failure.  (Note well that we return EOF
+// and not WEOF on failure.  This is intentional, and is the correct behavior per
+// the C Language Standard).
+static int __cdecl _fputws_internal(wchar_t const* const string, FILE* const stream, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_VALIDATE_RETURN(ptd, string != nullptr, EINVAL, EOF);
+    _UCRT_VALIDATE_RETURN(ptd, stream != nullptr, EINVAL, EOF);
+
+    return __acrt_lock_stream_and_call(stream, [&]() -> int
+    {
+        __acrt_stdio_temporary_buffering_guard const buffering(stream, ptd);
+
+        for (wchar_t const* it = string; *it != L'\0'; ++it)
+        {
+            if (_fputwc_nolock_internal(*it, stream, ptd) == WEOF)
+            {
+                return EOF;
+            }
+        }
+
+        return 0;
+    });
+}
+
+extern "C" int __cdecl fputws(wchar_t const* const string, FILE* const stream)
+{
+    __crt_cached_ptd_host ptd;
+    return _fputws_internal(string, stream, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fread.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d6ab3652e62b9f2ba0c0e7658dddb3602a7f227
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fread.cpp	
@@ -0,0 +1,254 @@
+//
+// fread.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fread() and related functions, which read unformatted data from a
+// stdio stream.
+//
+#include <corecrt_internal_stdio.h>
+
+#ifdef _DEBUG
+    #define _BUFFER_FILL_PATTERN _SECURECRT_FILL_BUFFER_PATTERN
+#else
+    #define _BUFFER_FILL_PATTERN 0
+#endif
+
+
+
+// Reads data from a stream into the result buffer.  The function reads elements
+// of size 'element_size' until it has read 'element_count' elements, until the
+// buffer is full, or until EOF is reached.
+//
+// Returns the number of "whole" elements that were read into the buffer.  This
+// may be fewer than the requested number of elements if an error occurs or if
+// EOF is encountered.  In this case, ferror() or feof() should be used to
+// distinguish between the two conditions.
+//
+// If the result buffer becomes full before the requested number of elements are
+// read, the buffer is zero-filled, zero is returned, and errno is set to ERANGE.
+extern "C" size_t __cdecl fread_s(
+    void*  const buffer,
+    size_t const buffer_size,
+    size_t const element_size,
+    size_t const element_count,
+    FILE*  const stream
+    )
+{
+    if (element_size == 0 || element_count == 0)
+        return 0;
+
+    // The rest of the argument validation is done in the _nolock function.  Here
+    // we only need to validate that the stream is non-null before we lock it.
+    if (stream == nullptr)
+    {
+        if (buffer_size != _CRT_UNBOUNDED_BUFFER_SIZE)
+            memset(buffer, _BUFFER_FILL_PATTERN, buffer_size);
+
+        _VALIDATE_RETURN(stream != nullptr, EINVAL, 0);
+    }
+
+    size_t return_value = 0;
+
+    _lock_file(stream);
+    __try
+    {
+        return_value = _fread_nolock_s(buffer, buffer_size, element_size, element_count, stream);
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" size_t __cdecl _fread_nolock_s(
+    void*  const buffer,
+    size_t const buffer_size,
+    size_t const element_size,
+    size_t const element_count,
+    FILE*  const public_stream
+    )
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    if (element_size == 0 || element_count == 0)
+        return 0;
+
+    _VALIDATE_RETURN(buffer != nullptr, EINVAL, 0);
+    if (!stream.valid() || element_count > (SIZE_MAX / element_size))
+    {
+        if (buffer_size != _CRT_UNBOUNDED_BUFFER_SIZE)
+            memset(buffer, _BUFFER_FILL_PATTERN, buffer_size);
+
+        _VALIDATE_RETURN(stream.valid(),                             EINVAL, 0);
+        _VALIDATE_RETURN(element_count <= (SIZE_MAX / element_size), EINVAL, 0);
+    }
+
+    // Figure out how big the buffer is; if the stream doesn't currently have a
+    // buffer, we assume that we'll get one with the usual internal buffer size:
+    unsigned stream_buffer_size = stream.has_any_buffer()
+        ? stream->_bufsiz
+        : _INTERNAL_BUFSIZ;
+
+    // The total number of bytes to be read into the buffer:
+    size_t const total_bytes = element_size * element_count;
+
+    char* data = static_cast<char*>(buffer);
+
+    // Read blocks of data from the stream until we have read the requested
+    // number of elements or we fill the buffer.
+    size_t remaining_bytes = total_bytes;
+    size_t remaining_buffer = buffer_size;
+    while (remaining_bytes != 0)
+    {
+        // If the stream is buffered and has characters, copy them into the
+        // result buffer:
+        if (stream.has_any_buffer() && stream->_cnt != 0)
+        {
+            if(stream->_cnt < 0)
+            {
+                _ASSERTE(("Inconsistent Stream Count. Flush between consecutive read and write", stream->_cnt >= 0));
+                stream.set_flags(_IOERROR);
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            unsigned const bytes_to_read = remaining_bytes < static_cast<size_t>(stream->_cnt)
+                ? static_cast<unsigned>(remaining_bytes)
+                : static_cast<unsigned>(stream->_cnt);
+
+            if (bytes_to_read > remaining_buffer)
+            {
+                if (buffer_size != _CRT_UNBOUNDED_BUFFER_SIZE)
+                    memset(buffer, _BUFFER_FILL_PATTERN, buffer_size);
+
+                _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0)
+            }
+
+            memcpy_s(data, remaining_buffer, stream->_ptr, bytes_to_read);
+
+            // Update the stream and local tracking variables to account for the
+            // read.  Note that the number of bytes actually read is always equal
+            // to the number of bytes that we expected to read, because the data
+            // was already buffered in the stream.
+            remaining_bytes  -= bytes_to_read;
+            stream->_cnt     -= bytes_to_read;
+            stream->_ptr     += bytes_to_read;
+            data             += bytes_to_read;
+            remaining_buffer -= bytes_to_read;
+        }
+        // There is no data remaining in the stream buffer to be read, and we
+        // need to read more data than will fit in the buffer (or we need to read
+        // at least enough data to fill the buffer completely):
+        else if (remaining_bytes >= stream_buffer_size)
+        {
+            // We can read at most INT_MAX bytes at a time.  This is a hard limit
+            // of the lowio _read() function.
+            unsigned const maximum_bytes_to_read = remaining_bytes > INT_MAX
+                ? static_cast<unsigned>(INT_MAX)
+                : static_cast<unsigned>(remaining_bytes);
+
+            // If the stream has a buffer, we want to read the largest chunk that
+            // is a multiple of the buffer size, to keep the stream buffer state
+            // consistent.  If the stream is not buffered, we can read the maximum
+            // number of bytes that we can:
+            unsigned const bytes_to_read = stream_buffer_size != 0
+                ? static_cast<unsigned>(maximum_bytes_to_read - maximum_bytes_to_read % stream_buffer_size)
+                : maximum_bytes_to_read;
+
+            if (bytes_to_read > remaining_buffer)
+            {
+                if (buffer_size != _CRT_UNBOUNDED_BUFFER_SIZE)
+                    memset(buffer, _BUFFER_FILL_PATTERN, buffer_size);
+
+                _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0)
+            }
+
+            // We are about to read data directly from the underlying file
+            // descriptor, bypassing the stream buffer.  We reset the stream
+            // buffer state to ensure that future seeks do not incorrectly
+            // assume that the buffer contents are valid.
+            __acrt_stdio_reset_buffer(stream);
+
+            // Do the read.  Note that if the stream is open in text mode, the
+            // bytes_read may not be the same as the bytes_to_read, due to
+            // newline translation.
+            int const bytes_read = _read_nolock(_fileno(stream.public_stream()), data, bytes_to_read);
+            if (bytes_read == 0)
+            {
+                // We encountered EOF:
+                stream.set_flags(_IOEOF);
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+            else if (bytes_read < 0)
+            {
+                // The _read failed:
+                stream.set_flags(_IOERROR);
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            // Update the iteration state to reflect the read:
+            remaining_bytes  -= bytes_read;
+            data             += bytes_read;
+            remaining_buffer -= bytes_read;
+        }
+        // Otherwise, the stream does not have a buffer, or the stream buffer
+        // is full and there is insufficient space to do a direct read, so use
+        // __acrt_stdio_refill_and_read_narrow_nolock:
+        else
+        {
+            int const c = __acrt_stdio_refill_and_read_narrow_nolock(stream.public_stream());
+            if (c == EOF)
+                return (total_bytes - remaining_bytes) / element_size;
+
+            // If we have filled the result buffer before we have read the
+            // requested number of elements or reached EOF, it is an error:
+            if (remaining_buffer == 0)
+            {
+                if (buffer_size != _CRT_UNBOUNDED_BUFFER_SIZE)
+                    memset(buffer, _BUFFER_FILL_PATTERN, buffer_size);
+
+                _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0)
+            }
+
+            *data++ = static_cast<char>(c);
+            --remaining_bytes;
+            --remaining_buffer;
+
+            stream_buffer_size = stream->_bufsiz;
+        }
+    }
+
+    return element_count; // Success!
+}
+
+
+
+extern "C" size_t __cdecl fread(
+    void*  const buffer,
+    size_t const element_size,
+    size_t const element_count,
+    FILE*  const stream
+    )
+{
+    // Assume there is enough space in the destination buffer
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 26015 - fread is unsafe
+    return fread_s(buffer, _CRT_UNBOUNDED_BUFFER_SIZE, element_size, element_count, stream);
+}
+
+
+
+extern "C" size_t __cdecl _fread_nolock(
+    void*  const buffer,
+    size_t const element_size,
+    size_t const element_count,
+    FILE*  const stream
+    )
+{
+    // Assume there is enough space in the destination buffer
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 26015 - _fread_nolock is unsafe
+    return _fread_nolock_s(buffer, _CRT_UNBOUNDED_BUFFER_SIZE, element_size, element_count, stream);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/freopen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/freopen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4973adab682b28f6f3430b842cfafc3928a37f6f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/freopen.cpp	
@@ -0,0 +1,128 @@
+//
+// freopen.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the freopen() family of functions, which is used to close a stream
+// and associate it with a new file (typically used for redirecting the
+// standard streams).
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Reopens a stream to a new file.  If the 'stream' is open, it is closed.  The
+// new file, named by 'file_name', is then opened, and 'stream' is associated
+// with that file.  The provided 'mode' and 'share_flag' are used when opening
+// the new file.  The resulting FILE* is returned via 'result'.
+//
+// Returns 0 on success; returns an error code on failure.
+template <typename Character>
+static errno_t __cdecl common_freopen(
+    FILE**             const result,
+    Character const*   const file_name,
+    Character const*   const mode,
+    __crt_stdio_stream const stream,
+    int                const share_flag
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+    *result = nullptr;
+
+    // C11 7.21.5.4/3:  "If filename is a null pointer, the freopen function
+    // attempts to change the mode of the stream to that specified by mode, as
+    // if the name of the file currently associated with the stream had been
+    // used. It is implementation-defined which changes of mode are permitted
+    // (if any), and under what circumstances."
+    //
+    // In our implementation, we do not currently support changing the mode
+    // in this way.  In the future, we might consider use of ReOpenFile to
+    // implement support for changing the mode.
+    _VALIDATE_RETURN_ERRCODE_NOEXC(file_name != nullptr, EBADF);
+
+    _VALIDATE_RETURN_ERRCODE(mode      != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(stream.valid()      , EINVAL);
+
+    // Just as in the common_fsopen function, we do not hard-validate empty
+    // 'file_name' strings in this function:
+    _VALIDATE_RETURN_ERRCODE_NOEXC(*file_name != 0, EINVAL);
+
+    errno_t return_value = 0;
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        // If the stream is in use, try to close it, ignoring possible errors:
+        if (stream.is_in_use())
+            _fclose_nolock(stream.public_stream());
+
+        stream->_ptr  = nullptr;
+        stream->_base = nullptr;
+        stream->_cnt  = 0;
+        stream.unset_flags(-1);
+
+        // We may have called fclose above, which will deallocate the stream.
+        // We still hold the lock on the stream, though, so we can just reset
+        // the allocated flag to retain ownership.
+        stream.set_flags(_IOALLOCATED);
+
+        *result = stdio_traits::open_file(file_name, mode, share_flag, stream.public_stream());
+        if (*result == nullptr)
+        {
+            stream.unset_flags(_IOALLOCATED);
+            return_value = errno;
+        }
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" FILE* __cdecl freopen(
+    char const* const file_name,
+    char const* const mode,
+    FILE*       const public_stream
+    )
+{
+    FILE* result_stream = nullptr;
+    common_freopen(&result_stream, file_name, mode, __crt_stdio_stream(public_stream), _SH_DENYNO);
+    return result_stream;
+}
+
+extern "C" errno_t __cdecl freopen_s(
+    FILE**      const result,
+    char const* const file_name,
+    char const* const mode,
+    FILE*       const public_stream
+    )
+{
+    return common_freopen(result, file_name, mode, __crt_stdio_stream(public_stream), _SH_SECURE);
+}
+
+extern "C" FILE* __cdecl _wfreopen(
+    wchar_t const* const file_name,
+    wchar_t const* const mode,
+    FILE*          const public_stream
+    )
+{
+    FILE* result_stream = nullptr;
+    common_freopen(&result_stream, file_name, mode, __crt_stdio_stream(public_stream), _SH_DENYNO);
+    return result_stream;
+}
+
+extern "C" errno_t __cdecl _wfreopen_s(
+    FILE**         const result,
+    wchar_t const* const file_name,
+    wchar_t const* const mode,
+    FILE*          const public_stream
+    )
+{
+    return common_freopen(result, file_name, mode, __crt_stdio_stream(public_stream), _SH_SECURE);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fseek.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fseek.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28c344756f884abc06e69b3d539a14d2f3e0d486
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fseek.cpp	
@@ -0,0 +1,247 @@
+//
+// fseek.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the fseek() family of functions, which repositions a file pointer to
+// a new place in a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+#define ENABLE_INTSAFE_SIGNED_FUNCTIONS
+#include <intsafe.h>
+
+
+
+// If a binary mode stream is open for reading and the target of the requested
+// seek is within the stream buffer, we can simply adjust the buffer pointer to
+// the new location.  This allows us to avoid flushing the buffer.  If the user
+// has set a large buffer on the stream and performs frequent seeks that are
+// likely to result in targets within the buffer, this is a huge performance win.
+// This function handles the most common cases.
+static bool __cdecl common_fseek_binary_mode_read_only_fast_track_nolock(
+    __crt_stdio_stream const stream,
+    __int64                  offset,
+    int                      whence
+    ) throw()
+{
+    // This fast-track path does not handle the seek-from-end case (this is not
+    // nearly as commonly used as seeking from the beginning or from the current
+    // position).
+    if (whence == SEEK_END)
+    {
+        return false;
+    }
+
+    // This fast-track path is only useful if the stream is buffered.
+    if (!stream.has_any_buffer())
+    {
+        return false;
+    }
+
+    // This fast-track path requires a stream opened only for reading.  It may
+    // be possible to handle streams opened for writing or update similarly;
+    // further investigation would be required.
+    if (stream.has_any_of(_IOWRITE | _IOUPDATE))
+    {
+        return false;
+    }
+
+    // The ftell function handles a case where _cnt is negative.  It isn't clear
+    // why _cnt may be negative, so if _cnt is negative, fall back to the
+    // expensive path.  If the _cnt is zero, do not assume that the buffer
+    // contents contain the immediately preceding file content; data may have
+    // been read from the file bypassing the buffer.  Fall back to the expensive
+    // path to be sure.
+    if (stream->_cnt <= 0)
+    {
+        return false;
+    }
+
+    // This fast-track path requires a binary mode file handle.  When text mode
+    // or UTF transformations are enabled, the contents of the buffer do not
+    // exactly match the contents of the underlying file.
+    int const fh = stream.lowio_handle();
+    if ((_osfile(fh) & FTEXT) != 0 || _textmode(fh) != __crt_lowio_text_mode::ansi)
+    {
+        return false;
+    }
+
+    // Handle the SEEK_SET case by transforming the SEEK_SET offset into a
+    // SEEK_CUR offset:
+    if (whence == SEEK_SET)
+    {
+        __int64 const lowio_position = _lseeki64_nolock(fh, 0, SEEK_CUR);
+        if (lowio_position < 0)
+        {
+            return false;
+        }
+
+        __int64 const stdio_position = lowio_position - stream->_cnt;
+        if (FAILED(LongLongSub(offset, stdio_position, &offset)))
+        {
+            return false;
+        }
+        whence = SEEK_CUR;
+    }
+
+    // Compute the maximum number of bytes that we can seek in each direction
+    // within the buffer and verify that the requested offset is within that
+    // range.  Note that the minimum reverse seek is a negative value.
+    __int64 const minimum_reverse_seek = -(stream->_ptr - stream->_base);
+    __int64 const maximum_forward_seek = stream->_cnt;
+
+    bool const seek_is_within_buffer = minimum_reverse_seek <= offset && offset <= maximum_forward_seek;
+    if (!seek_is_within_buffer)
+    {
+        return false;
+    }
+
+    stream->_ptr += offset;
+
+    // Note that the cast here is safe:  The buffer will never be larger than
+    // INT_MAX bytes in size.  The setvbuf function validates this constraint.
+    stream->_cnt -= static_cast<int>(offset);
+    return true;
+}
+
+
+
+static int __cdecl common_fseek_nolock(
+    __crt_stdio_stream const stream,
+    __int64                  offset,
+    int                      whence,
+    __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    if (!stream.is_in_use())
+    {
+        ptd.get_errno().set(EINVAL);
+        return -1;
+    }
+
+    stream.unset_flags(_IOEOF);
+
+    if (common_fseek_binary_mode_read_only_fast_track_nolock(stream, offset, whence))
+    {
+        return 0;
+    }
+
+    // If seeking relative to the current location, then convert to a seek
+    // relative to the beginning of the file.  This accounts for buffering,
+    // etc., by letting fseek() tell us where we are:
+    if (whence == SEEK_CUR)
+    {
+        offset += _ftelli64_nolock_internal(stream.public_stream(), ptd);
+        whence = SEEK_SET;
+    }
+
+    __acrt_stdio_flush_nolock(stream.public_stream(), ptd);
+    // If the stream is opened in update mode and is currently in use for reading,
+    // the buffer must be abandoned to ensure consistency when transitioning from
+    // reading to writing.
+    // __acrt_stdio_flush_nolock will not reset the buffer when _IOWRITE flag
+    // is not set.
+    __acrt_stdio_reset_buffer(stream);
+
+    // If the file was opened for read/write, clear flags since we don't know
+    // what the user will do next with the file.  If the file was opened for
+    // read only access, decrease the _bufsiz so that the next call to
+    // __acrt_stdio_refill_and_read_{narrow,wide}_nolock won't cost quite so
+    // much:
+    if (stream.has_all_of(_IOUPDATE))
+    {
+        stream.unset_flags(_IOWRITE | _IOREAD);
+    }
+    else if (stream.has_all_of(_IOREAD | _IOBUFFER_CRT) && !stream.has_any_of(_IOBUFFER_SETVBUF))
+    {
+        stream->_bufsiz = _SMALL_BUFSIZ;
+    }
+
+    if (_lseeki64_nolock_internal(stream.lowio_handle(), offset, whence, ptd) == -1)
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+// Repositions the file pointer of a stream to the specified location, relative
+// to 'whence', which can be SEEK_SET (the beginning of the file), SEEK_CUR (the
+// current pointer position), or SEEK_END (the end of the file).  The offset may
+// be negative.  Returns 0 on success; returns -1 and sets errno on failure.
+static int __cdecl common_fseek(
+    __crt_stdio_stream const stream,
+    __int64            const offset,
+    int                const whence,
+    __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    _UCRT_VALIDATE_RETURN(ptd, stream.valid(), EINVAL, -1);
+    _UCRT_VALIDATE_RETURN(ptd, whence == SEEK_SET || whence == SEEK_CUR || whence == SEEK_END, EINVAL, -1);
+
+    int return_value = -1;
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        return_value = common_fseek_nolock(stream, offset, whence, ptd);
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" int __cdecl fseek(
+    FILE* const public_stream,
+    long  const offset,
+    int   const whence
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return common_fseek(__crt_stdio_stream(public_stream), offset, whence, ptd);
+}
+
+
+
+extern "C" int __cdecl _fseek_nolock(
+    FILE* const public_stream,
+    long  const offset,
+    int   const whence
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return common_fseek_nolock(__crt_stdio_stream(public_stream), offset, whence, ptd);
+}
+
+
+
+extern "C" int __cdecl _fseeki64(
+    FILE*   const public_stream,
+    __int64 const offset,
+    int     const whence
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return common_fseek(__crt_stdio_stream(public_stream), offset, whence, ptd);
+}
+
+
+
+extern "C" int __cdecl _fseeki64_nolock(
+    FILE*   const public_stream,
+    __int64 const offset,
+    int     const whence
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return common_fseek_nolock(__crt_stdio_stream(public_stream), offset, whence, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fsetpos.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fsetpos.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..854faa64ee68f28e3a353e997f07c3639d5c4e80
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fsetpos.cpp	
@@ -0,0 +1,22 @@
+//
+// fsetpos.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fsetpos(), which sets the file position using a position previously
+// returned by fgetpos().
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Sets the file position to the given position.  The position value must have
+// been returned by a prior call to fgetpos().  Returns 0 on success; returns
+// nonzero on failure.
+extern "C" int __cdecl fsetpos(FILE* const stream, fpos_t const* const position)
+{
+    _VALIDATE_RETURN(stream   != nullptr, EINVAL, -1);
+    _VALIDATE_RETURN(position != nullptr, EINVAL, -1);
+
+    return _fseeki64(stream, *position, SEEK_SET);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ftell.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ftell.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c84e3b523afcdc1a278266f2e332bb1885b4dccf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ftell.cpp	
@@ -0,0 +1,399 @@
+//
+// ftell.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the ftell() family of functions, which computes the current position
+// of the file pointer of a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+static bool __cdecl buffer_contains_wide_characters(__crt_lowio_text_mode const text_mode) throw()
+{
+    return text_mode == __crt_lowio_text_mode::utf8
+        || text_mode == __crt_lowio_text_mode::utf16le;
+}
+
+static size_t __cdecl buffer_character_size(__crt_lowio_text_mode const text_mode) throw()
+{
+    return buffer_contains_wide_characters(text_mode) ? sizeof(wchar_t) : sizeof(char);
+}
+
+// This function counts the number of newlines (LFs) in the buffer that contains
+// elements of type Character.  When sizeof(Character) != 1, the caller must
+// ensure that the buffer consists of a whole number of Character elements.
+template <typename Character>
+static __int64 __cdecl count_newlines_of_type(
+    _In_reads_(buffer_last - buffer_first) char const* const buffer_first,
+    _In_reads_(0)                          char const* const buffer_last
+    ) throw()
+{
+    // This invariant is maintained by the lowio library.  When Character==wchar_t,
+    // all writes to the buffer are in wide characters.
+    _ASSERTE((buffer_last - buffer_first) % sizeof(Character) == 0);
+
+    Character const* const typed_first = reinterpret_cast<Character const*>(buffer_first);
+    Character const* const typed_last  = reinterpret_cast<Character const*>(buffer_last);
+
+    __int64 newline_count = 0;
+    for (Character const* it = typed_first; it != typed_last; ++it)
+    {
+        if (*it == '\n')
+        {
+            ++newline_count;
+        }
+    }
+
+    return newline_count;
+}
+
+static __int64 __cdecl count_newline_bytes(
+    _In_reads_(buffer_last - buffer_first) char const*           const buffer_first,
+    _In_reads_(0)                          char const*           const buffer_last,
+    _In_                                   __crt_lowio_text_mode const text_mode
+    ) throw()
+{
+    if (buffer_contains_wide_characters(text_mode))
+    {
+        return count_newlines_of_type<wchar_t>(buffer_first, buffer_last) * sizeof(wchar_t);
+    }
+    else
+    {
+        return count_newlines_of_type<char>(buffer_first, buffer_last);
+    }
+}
+
+// This function handles the case where the file is open in UTF-8 text mode and
+// the translated UTF-16 form of the text has a different number of characters
+// than the original UTF-8 text (remember: when reading a file in UTF-8 mode, the
+// lowio library converts the UTF-8 to UTF-16).
+static __int64 __cdecl common_ftell_translated_utf8_nolock(
+    __crt_stdio_stream const stream,
+    __int64            const lowio_position,
+    __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    int const fh = _fileno(stream.public_stream());
+
+    // If the buffer has been exhausted, then the current lowio position is also
+    // the current stdio position:
+    if (stream->_cnt == 0)
+    {
+        return lowio_position;
+    }
+
+    __int64 const current_buffer_position = (stream->_ptr - stream->_base) / static_cast<__int64>(sizeof(wchar_t));
+
+    // Otherwise, we have to re-read the buffer, in binary mode, so that we can
+    // analyze the original UTF-8 text to compute the actual position in the
+    // file.  To do this, we seek the lowio pointer back to the beginning of
+    // the stdio buffer, re-read the buffer, then seek the lowio pointer back
+    // to its original location:
+    __int64 const base_buffer_position = _lseeki64_internal(fh, _startpos(fh), SEEK_SET, ptd);
+    if (base_buffer_position != _startpos(fh))
+    {
+        return -1;
+    }
+
+    DWORD bytes_read;
+    char  raw_buffer[_INTERNAL_BUFSIZ];
+    if (!ReadFile(reinterpret_cast<HANDLE>(_osfhnd(fh)), raw_buffer, _INTERNAL_BUFSIZ, &bytes_read, nullptr))
+        return -1;
+
+    // Seek back to where we were, to ensure the stdio stream is left in a
+    // consistent state (and "unmodified" from before the call):
+    if (_lseeki64_internal(fh, lowio_position, SEEK_SET, ptd) < 0)
+    {
+        return -1;
+    }
+
+    // This should not normally happen:  we should always read enough bytes:
+    if (current_buffer_position > static_cast<__int64>(bytes_read))
+    {
+        return -1;
+    }
+
+    // Scan the raw, untranslated buffer to find the current position, updating
+    // the file pointer to account for newline translation in the buffer:
+    char const* const raw_first = raw_buffer;
+#pragma warning(disable:__WARNING_UNUSED_POINTER_ASSIGNMENT) // 28930
+    char const* const raw_last = raw_buffer + bytes_read;
+
+    char const* raw_it = raw_first;
+    for (__int64 i = 0; i != current_buffer_position && raw_it < raw_last; ++i, ++raw_it)
+    {
+        if (*raw_it == CR)
+        {
+            if (raw_it < raw_last - 1 && *(raw_it + 1) == LF)
+                ++raw_it;
+        }
+        else
+        {
+            raw_it += _utf8_no_of_trailbytes(static_cast<const unsigned char>(*raw_it));
+        }
+    }
+
+    return base_buffer_position + (raw_it - raw_first);
+}
+
+
+
+// This function handles the extra adjustments that need to be made to the file
+// position returned by ftell when a stream is opened in read mode.
+static __int64 __cdecl common_ftell_read_mode_nolock(
+    __crt_stdio_stream const stream,
+    __int64            const lowio_position,
+    __int64            const buffer_offset,
+    __crt_cached_ptd_host&   ptd
+    ) throw()
+{
+    int const fh = _fileno(stream.public_stream());
+
+    // We will need to adjust the file position of UTF-8 files to account for
+    // UTF-8 to UTF-16 translation:
+    __crt_lowio_text_mode const text_mode = _textmode(fh);
+
+    __int64 const translation_factor = text_mode == __crt_lowio_text_mode::utf8
+        ? static_cast<__int64>(sizeof(wchar_t))
+        : static_cast<__int64>(sizeof(char));
+
+    // If the buffer has been exhausted, then the current lowio position is also
+    // the current stdio position:
+    if (stream->_cnt == 0)
+    {
+        return lowio_position;
+    }
+
+    // The lowio position points one-past-the-end of the current stdio buffer.
+    // We need to find the position of the beginning of the buffer.  To start,
+    // we compute the number of bytes in the buffer.  Note that we cannot just
+    // use the buffer size, because the buffer will not be full if EOF is
+    // readhed before the buffer is full.
+    __int64 bytes_read = stream->_cnt + static_cast<__int64>(stream->_ptr - stream->_base);
+
+    // If this is a binary mode stream, we can simply subtract this from the
+    // lowio position, and combine it with the buffer offset to get the stdio
+    // position:
+    if ((_osfile(fh) & FTEXT) == 0)
+    {
+        return lowio_position
+            - (bytes_read    / translation_factor)
+            + (buffer_offset / translation_factor);
+    }
+
+    // If this is a text mode stream, we need to adjust the number of bytes that
+    // were read into the buffer to account for newline translation.
+    //
+    // If we are _not_ at EOF, the number of untranslated characters read is the
+    // buffer size.  However, if we are not at EOF, the buffer may not be full,
+    // so we need to scan the buffer to count newline characters.  (Note:  we
+    // only count newline characters if the stream is at EOF, because doing so
+    // is more expensive than seeking to the end and seeking back).
+
+    // Seek to the end of the file.  If the current position is the end of the
+    // file, then scan the buffer for newlines and adjust bytes_read:
+    if (_lseeki64_internal(fh, 0, SEEK_END, ptd) == lowio_position)
+    {
+        bytes_read += count_newline_bytes(stream->_base, stream->_base + bytes_read, text_mode);
+
+        // If the last byte was a ^Z, that character will not be present in the
+        // buffer (it is omitted by lowio):
+        if (stream.ctrl_z())
+        {
+            bytes_read += buffer_character_size(text_mode);
+        }
+    }
+    // Otherwise, the current position is not at the end of the file; we need to
+    // seek back to the original position and compute the size of the buffer:
+    else
+    {
+        if (_lseeki64_internal(fh, lowio_position, SEEK_SET, ptd) == -1)
+            return -1;
+
+        // If the number of bytes read is smaller than the small buffer and was
+        // not user-provided, the buffer size was set to _SMALL_BUFSIZ during
+        // the last call to __acrt_stdio_refill_and_read_{narrow,wide}_nolock:
+        if (bytes_read <= _SMALL_BUFSIZ &&
+            stream.has_crt_buffer() &&
+            !stream.has_setvbuf_buffer())
+        {
+            bytes_read = _SMALL_BUFSIZ;
+        }
+        // Otherwise, the buffer size is what is stated in the stream object:
+        else
+        {
+            bytes_read = stream->_bufsiz;
+        }
+
+        // If the first byte in the untranslated buffer was a '\n', we assume it
+        // was preceded by a '\r', which was discarded by the previous read
+        // operation:
+        if (_osfile(fh) & FCRLF)
+        {
+            bytes_read += buffer_character_size(text_mode);
+        }
+    }
+
+    return lowio_position
+        - (bytes_read    / translation_factor)
+        + (buffer_offset / translation_factor);
+}
+
+
+
+template <typename Integer>
+static Integer __cdecl common_ftell_nolock(__crt_stdio_stream, __crt_cached_ptd_host& ptd) throw();
+
+template <>
+__int64 __cdecl common_ftell_nolock(__crt_stdio_stream const stream, __crt_cached_ptd_host& ptd) throw()
+{
+    _UCRT_VALIDATE_RETURN(ptd, stream.public_stream(), EINVAL, -1);
+
+    int const fh = _fileno(stream.public_stream());
+
+    if (stream->_cnt < 0)
+    {
+        stream->_cnt = 0;
+    }
+
+    // Get the current lowio file position.  If stdio is buffering the stream,
+    // this position will point one past the end of the current stdio buffer.
+    __int64 const lowio_position = _lseeki64_internal(fh, 0, SEEK_CUR, ptd);
+    if (lowio_position < 0)
+    {
+        return -1;
+    }
+
+    // If the stream is unbuffered or no buffering is designated, we can simply
+    // compute the stdio position via the remaining stdio stream count:
+    if (!stream.has_big_buffer())
+    {
+        return lowio_position - stream->_cnt;
+    }
+
+    // The above lseek validates the handle, so it's okay to get the text mode:
+    __crt_lowio_text_mode const text_mode = _textmode(fh);
+
+    // This is the current offset into the stdio buffer; we will adjust this to
+    // account for translation and updates as this function progresses:
+    __int64 buffer_offset = stream->_ptr - stream->_base;
+
+    // If the file is in read or write mode, we need special handling for UTF-8
+    // and text mode files, to account for newline translation and UTF-8 to
+    // UTF-16 conversion:
+    if (stream.has_any_of(_IOWRITE | _IOREAD))
+    {
+        if (text_mode == __crt_lowio_text_mode::utf8 && _utf8translations(fh))
+        {
+            return common_ftell_translated_utf8_nolock(stream, lowio_position, ptd);
+        }
+
+        // For text mode files, adjust the buffer offset to account for newline
+        // translation:
+        if (_osfile(fh) & FTEXT)
+        {
+            buffer_offset += count_newline_bytes(stream->_base, stream->_ptr, text_mode);
+        }
+    }
+    // Otherwise, if the file is not in read/write mode, ftell cannot proceed:
+    else if (!stream.has_all_of(_IOUPDATE))
+    {
+        ptd.get_errno().set(EINVAL);
+        return -1;
+    }
+
+    // If the current lowio position is at the beginning of the file, the stdio
+    // position is whatever the offset is:
+    if (lowio_position == 0)
+    {
+        return buffer_offset;
+    }
+
+    if (stream.has_all_of(_IOREAD))
+    {
+        return common_ftell_read_mode_nolock(stream, lowio_position, buffer_offset, ptd);
+    }
+
+    if (text_mode == __crt_lowio_text_mode::utf8)
+    {
+        buffer_offset /= sizeof(wchar_t);
+    }
+
+    return lowio_position + buffer_offset;
+}
+
+template <>
+long __cdecl common_ftell_nolock(__crt_stdio_stream const stream, __crt_cached_ptd_host& ptd) throw()
+{
+    __int64 const result = common_ftell_nolock<__int64>(stream, ptd);
+    if (result > LONG_MAX)
+    {
+        ptd.get_errno().set(EINVAL);
+        return -1;
+    }
+
+    return static_cast<long>(result);
+}
+
+
+
+// Queries the position of the file pointer of a stream.  This function computes
+// the position of the pointer, accounting for stdio buffering.  This is not the
+// same as fseek(stream, 0, SEEK_SET), because fseek will remove an ungetc and
+// may flush buffers.
+//
+// Returns the present file position on success; returns -1 and sets errno on
+// failure.
+template <typename Integer>
+static Integer __cdecl common_ftell(__crt_stdio_stream const stream, __crt_cached_ptd_host& ptd) throw()
+{
+    _UCRT_VALIDATE_RETURN(ptd, stream.valid(), EINVAL, -1);
+
+    Integer return_value = 0;
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        return_value = common_ftell_nolock<Integer>(stream, ptd);
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+
+    return return_value;
+}
+
+
+
+
+extern "C" long __cdecl ftell(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return common_ftell<long>(__crt_stdio_stream(public_stream), ptd);
+}
+
+extern "C" long __cdecl _ftell_nolock(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return common_ftell_nolock<long>(__crt_stdio_stream(public_stream), ptd);
+}
+
+extern "C" __int64 __cdecl _ftelli64(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return common_ftell<__int64>(__crt_stdio_stream(public_stream), ptd);
+}
+
+extern "C" __int64 __cdecl _ftelli64_nolock(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    return common_ftell_nolock<__int64>(__crt_stdio_stream(public_stream), ptd);
+}
+
+extern "C" __int64 __cdecl _ftelli64_nolock_internal(FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    return common_ftell_nolock<__int64>(__crt_stdio_stream(public_stream), ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fwrite.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fwrite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9146f0309ae32f6b5e1e42efe9572cde987231fd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/fwrite.cpp	
@@ -0,0 +1,196 @@
+//
+// fwrite.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines fwrite() and related functions, which write unformatted data to a
+// stdio stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+// Writes data from the provided buffer to the specified stream.  The function
+// writes 'count' elements of 'size' size to the stream, and returns when
+// either all of the elements have been written or no more data can be written
+// (e.g. if EOF is encountered or an error occurs).
+//
+// Returns the number of "whole" elements that were written to the stream.  This
+// may be fewer than the requested number of an error occurs or EOF is encountered.
+// In this case, ferror() or feof() should be used to distinguish between the two
+// conditions.
+extern "C" size_t __cdecl _fwrite_internal(
+    void const*        const buffer,
+    size_t             const size,
+    size_t             const count,
+    FILE*              const stream,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    if (size == 0 || count == 0)
+    {
+        return 0;
+    }
+
+    // The _nolock version will do the rest of the validation.
+    _UCRT_VALIDATE_RETURN(ptd, stream != nullptr, EINVAL, 0);
+
+    return __acrt_lock_stream_and_call(stream, [&]() -> size_t
+    {
+        __acrt_stdio_temporary_buffering_guard const buffering(stream, ptd);
+
+        return _fwrite_nolock_internal(buffer, size, count, stream, ptd);
+    });
+}
+
+extern "C" size_t __cdecl fwrite(
+    void const* const buffer,
+    size_t      const size,
+    size_t      const count,
+    FILE*       const stream
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _fwrite_internal(buffer, size, count, stream, ptd);
+}
+
+extern "C" size_t __cdecl _fwrite_nolock_internal(
+    void const*        const buffer,
+    size_t             const element_size,
+    size_t             const element_count,
+    FILE*              const public_stream,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    if (element_size == 0 || element_count == 0)
+    {
+        return 0;
+    }
+
+    __crt_stdio_stream const stream(public_stream);
+
+    _UCRT_VALIDATE_RETURN(ptd, stream.valid(),                             EINVAL, 0);
+    _UCRT_VALIDATE_RETURN(ptd, buffer != nullptr,                          EINVAL, 0);
+    _UCRT_VALIDATE_RETURN(ptd, element_count <= (SIZE_MAX / element_size), EINVAL, 0);
+
+    // Figure out how big the buffer is; if the stream doesn't currently have a
+    // buffer, we assume that we'll get one with the usual internal buffer size:
+    unsigned stream_buffer_size = stream.has_any_buffer()
+        ? stream->_bufsiz
+        : _INTERNAL_BUFSIZ;
+
+    // The total number of bytes to be written to the stream:
+    size_t const total_bytes = element_size * element_count;
+
+    char const* data = static_cast<char const*>(buffer);
+
+    // Write blocks of data from the buffer until there is no more data left:
+    size_t remaining_bytes = total_bytes;
+    while (remaining_bytes != 0)
+    {
+        // If the buffer is big and is not full, copy data into the buffer:
+        if (stream.has_big_buffer() && stream->_cnt != 0)
+        {
+            if (stream->_cnt < 0)
+            {
+                _ASSERTE(("Inconsistent Stream Count. Flush between consecutive read and write", stream->_cnt >= 0));
+                stream.set_flags(_IOERROR);
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            if (stream.has_any_of(_IOREAD))
+            {
+                _ASSERTE(("Flush between consecutive read and write.", !stream.has_any_of(_IOREAD)));
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            size_t const bytes_to_write = __min(remaining_bytes, static_cast<size_t>(stream->_cnt));
+
+            memcpy(stream->_ptr, data, bytes_to_write);
+
+            remaining_bytes -= bytes_to_write;
+            stream->_cnt    -= static_cast<int>(bytes_to_write);
+            stream->_ptr    += bytes_to_write;
+            data            += bytes_to_write;
+        }
+        // If we have more than stream_buffer_size bytes to write, write data by
+        // calling _write() with an integral number of stream_buffer_size blocks.
+        else if (remaining_bytes >= stream_buffer_size)
+        {
+            // If we reach here and we have a big buffer, it must be full, so
+            // flush it.  If the flush fails, there's nothing we can do to
+            // recover:
+            if (stream.has_big_buffer() && __acrt_stdio_flush_nolock(stream.public_stream(), ptd))
+            {
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            // Calculate the number of bytes to write.  The _write API takes a
+            // 32-bit unsigned byte count and returns -1 (UINT_MAX) on failure,
+            // so clamp the value to UINT_MAX - 1:
+            size_t const max_bytes_to_write = stream_buffer_size > 0
+                ? remaining_bytes - remaining_bytes % stream_buffer_size
+                : remaining_bytes;
+
+            unsigned const bytes_to_write = static_cast<unsigned>(__min(max_bytes_to_write, UINT_MAX - 1));
+
+            unsigned const bytes_actually_written = _write_internal(_fileno(stream.public_stream()), data, bytes_to_write, ptd);
+            if (bytes_actually_written == UINT_MAX) // UINT_MAX == -1
+            {
+                stream.set_flags(_IOERROR);
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            // VSWhidbey #326224:  _write can return more bytes than we requested
+            // due to Unicode conversions in text files.  We do not care how many
+            // bytes were written as long as the number is as least as large as we
+            // requested:
+            unsigned const bytes_written = bytes_actually_written > bytes_to_write
+                ? bytes_to_write
+                : bytes_actually_written;
+
+            // Update the remaining bytes and data to reflect the write:
+            remaining_bytes -= bytes_written;
+            data            += bytes_written;
+
+            if (bytes_actually_written < bytes_to_write)
+            {
+                stream.set_flags(_IOERROR);
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+        }
+        // Otherwise, the stream does not have a buffer, or the buffer is full
+        // and there are not enough characters to do a direct write, so use
+        // __acrt_stdio_flush_and_write_narrow_nolock:
+        else
+        {
+            // Write the first character.  If this fails, there is nothing we can
+            // do.  (Note that if this fails, it will update the stream error state.)
+            if (__acrt_stdio_flush_and_write_narrow_nolock(*data, stream.public_stream(), ptd) == EOF)
+            {
+                return (total_bytes - remaining_bytes) / element_size;
+            }
+
+            // Update the remaining bytes to account for the byte we just wrote:
+            ++data;
+            --remaining_bytes;
+
+            stream_buffer_size = stream->_bufsiz > 0
+                ? stream->_bufsiz
+                : 1;
+        }
+    }
+
+    return element_count; // Success!
+}
+
+extern "C" size_t __cdecl _fwrite_nolock(
+    void const* const buffer,
+    size_t      const element_size,
+    size_t      const element_count,
+    FILE*       const public_stream
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _fwrite_nolock_internal(buffer, element_size, element_count, public_stream, ptd);
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/gets.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/gets.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ecc92f6edfa7ffceda981b9a01aa9762b2e60434
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/gets.cpp	
@@ -0,0 +1,148 @@
+//
+// gets.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines gets() and gets_s(), which read a line from stdin.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_securecrt.h>
+
+
+
+// Reads a line of text from stdin, storing it in the 'result' buffer.  This
+// function supports two modes:
+//
+// [1] Insecure, which is used by the abominable gets() and _getws() functions.
+//     In this mode, the buffer is not bounds-checked; it is just assumed that
+//     the buffer is large enough.  Text is read until a newline is reached or
+//     EOF is reached.  This mode is enabled by passing _CRT_UNBOUNDED_BUFFER_SIZE
+//     as the buffer size.
+//
+// [2] Secure, which is used by the gets_s() and _getws_s() functions.  In this
+//     mode, the buffer is bound-checked.  If there is insufficient space in the
+//     buffer for the entire line of text, the line is read and discarded, the
+//     buffer is zero'ed, and nullptr is returned.  If the buffer is larger than
+//     is required, the remaining space of the buffer is zero-filled.
+//
+// On success, 'result' is returned.  On failure, nullptr is returned.  If the
+// 'return_early_if_eof_is_first' flag is true and the first read encounters EOF,
+// the buffer is left unchanged and nullptr is returned.
+template <typename Character>
+_Success_(return != nullptr)
+static Character* __cdecl common_gets(
+    _Out_writes_z_(result_size_in_characters) Character* const result,
+    _In_                                      size_t     const result_size_in_characters,
+    _In_                                      bool       const return_early_if_eof_is_first
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    _VALIDATE_RETURN(result != nullptr,             EINVAL, nullptr);
+    _VALIDATE_RETURN(result_size_in_characters > 0, EINVAL, nullptr);
+
+    Character* return_value = result;
+
+    _lock_file(stdin);
+    __try
+    {
+        if (!stdio_traits::validate_stream_is_ansi_if_required(stdin))
+        {
+            return_value = nullptr;
+            __leave;
+        }
+
+        // Special case:  if the first character is EOF, treat it specially if
+        // we were asked to do so:
+        typename stdio_traits::int_type c = stdio_traits::getc_nolock(stdin);
+        if (c == stdio_traits::eof)
+        {
+            return_value = nullptr;
+            if (return_early_if_eof_is_first)
+                __leave;
+        }
+
+        // For the insecure version, we do no buffer size check and no debug fill:
+        if (result_size_in_characters == _CRT_UNBOUNDED_BUFFER_SIZE)
+        {
+#pragma warning(push)
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 26015 - knowingly unsafe
+            Character* result_it = result;
+            while (c != '\n' && c != stdio_traits::eof)
+            {
+                *result_it++ = static_cast<Character>(c);
+                c = stdio_traits::getc_nolock(stdin);
+            }
+            *result_it = '\0';
+#pragma warning(pop)
+        }
+        // For the secure version, we track the buffer size.  If we run out of
+        // buffer space, we still read in the rest of the current line until we
+        // reach '\n' or EOF, but we discard the characters and reset the buffer
+        // to be zero-filled.
+        else
+        {
+            size_t available = result_size_in_characters;
+
+            Character* result_it = result;
+            while (c != '\n' && c != stdio_traits::eof)
+            {
+                if (available > 0)
+                {
+                    --available;
+                    *result_it++ = static_cast<Character>(c);
+                }
+
+                c = stdio_traits::getc_nolock(stdin);
+            }
+
+            // If we ran out of space, clear the buffer and return failure:
+            if (available == 0)
+            {
+                _RESET_STRING(result, result_size_in_characters);
+                _RETURN_BUFFER_TOO_SMALL_ERROR(result, result_size_in_characters, nullptr);
+            }
+
+            *result_it = '\0';
+            _FILL_STRING(result, result_size_in_characters, result_size_in_characters - available + 1);
+        }
+    }
+    __finally
+    {
+        _unlock_file(stdin);
+    }
+
+    return return_value;
+}
+
+
+
+// Reads a line of text from stdin and stores it in the result buffer.  If the
+// line is longer than will fit in the buffer, the line is discarded, the buffer
+// is reset, and nullptr is returned.
+extern "C" char* __cdecl gets_s(char* const result, size_t const result_size_in_characters)
+{
+    return common_gets(result, result_size_in_characters, false);
+}
+
+extern "C" wchar_t* __cdecl _getws_s(wchar_t* const result, size_t const result_size_in_characters)
+{
+    return common_gets(result, result_size_in_characters, false);
+}
+
+
+
+// Reads a line of text from stdin and stores it in the result buffer.  This
+// function assumes there is sufficient room in the buffer.  Do not use this
+// function; use gets_s(), fgets(), _getws_s(), or fgetws() instead.  If EOF
+// is encountered on the first read from the stream, the buffer is left
+// unmodified and nullptr is returned.
+extern "C" char* __cdecl gets(char* const result)
+{
+    return common_gets(result, _CRT_UNBOUNDED_BUFFER_SIZE, true);
+}
+
+extern "C" wchar_t* __cdecl _getws(wchar_t* const result)
+{
+    return common_gets(result, _CRT_UNBOUNDED_BUFFER_SIZE, true);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/gettemppath.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/gettemppath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22ff099b0eb9360205b41de7ce775be671eff296
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/gettemppath.cpp	
@@ -0,0 +1,39 @@
+//
+// gettemppath.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The __acrt_GetTempPath2A() function, which calls GetTempPathW and converts the string to multibyte.
+//
+#include <corecrt_internal.h>
+#include <io.h>
+
+
+
+// This function simply calls __acrt_GetTempPath2W() and converts the wide string to multibyte.
+// Note that GetTempPathA is not UTF-8 aware. This is because APIs using temporary paths
+// must not depend on the current locale setting and must use the ACP or OEMCP since
+// the returned data must be a static buffer and this behavior is guaranteed by MSDN documentation.
+extern "C" DWORD __cdecl __acrt_GetTempPath2A(DWORD nBufferLength, LPSTR lpBuffer)
+{
+    wchar_t wide_buffer[_MAX_PATH + 1] = {};
+
+    DWORD const get_temp_path_result = __acrt_GetTempPath2W(_countof(wide_buffer), wide_buffer);
+    if (get_temp_path_result == 0)
+    {
+        return 0;
+    }
+
+    bool const use_oem_code_page = !__acrt_AreFileApisANSI();
+    int const code_page = use_oem_code_page ? CP_OEMCP : CP_ACP;
+#pragma warning(suppress:__WARNING_W2A_BEST_FIT) // 38021 Prefast recommends WC_NO_BEST_FIT_CHARS.
+    int const wctmb_result = __acrt_WideCharToMultiByte(code_page, 0, wide_buffer, -1, lpBuffer, nBufferLength, nullptr, nullptr);
+    if (wctmb_result == 0)
+    {
+        return 0;
+    }
+
+    // The return value of WideCharToMultiByte includes the null terminator; the
+    // return value of GetTempPathA does not.
+    return wctmb_result - 1;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/getw.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/getw.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..958d179bf835d4152888b7871cb4cd81a374ed72
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/getw.cpp	
@@ -0,0 +1,48 @@
+//
+// getw.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _getw(), which reads a binary integer to a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Reads a binary int value from the stream, byte-by-byte.  On success, returns
+// the value written; on failure (error or eof), returns EOF.  Note, however,
+// that the value may be EOF--that is, after all, a valid integer--so be sure to
+// test ferror() and feof() to check for error conditions.
+extern "C" int __cdecl _getw(FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, EOF);
+
+    int return_value = EOF;
+
+    _lock_file(stream);
+    __try
+    {
+        int value = 0;
+        char* const first = reinterpret_cast<char*>(&value);
+        char* const last  = first + sizeof(value);
+
+        for (char* it = first; it != last; ++it)
+        {
+            *it = static_cast<char>(_getc_nolock(stream));
+        }
+
+        if (feof(stream))
+            __leave;
+
+        if (ferror(stream))
+            __leave;
+
+        return_value = value;
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/input.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/input.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..690731ecc96cc08267df8be54d250462b5378e28
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/input.cpp	
@@ -0,0 +1,135 @@
+//
+// input.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The core formatted input functions; all of the scanf-style functions call one
+// of these functions.
+//
+#define _ALLOW_OLD_VALIDATE_MACROS
+#include <corecrt_internal_stdio_input.h>
+
+using namespace __crt_stdio_input;
+
+
+// Enclaves do not have a file system, but they do allow in-memory operations
+// from stdio.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+template <typename Character>
+static int __cdecl common_vfscanf(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    Character const* const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    ) throw()
+{
+    typedef input_processor<
+        Character,
+        stream_input_adapter<Character>
+    > processor_type;
+
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, EOF);
+    _VALIDATE_RETURN(format != nullptr, EINVAL, EOF);
+
+    return __acrt_lock_stream_and_call(stream, [&]()
+    {
+        _LocaleUpdate locale_update(locale);
+
+        processor_type processor(
+            stream_input_adapter<Character>(stream),
+            options,
+            format,
+            locale_update.GetLocaleT(),
+            arglist);
+
+        return processor.process();
+    });
+}
+
+extern "C" int __cdecl __stdio_common_vfscanf(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_vfscanf(options, stream, format, locale, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vfwscanf(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_vfscanf(options, stream, format, locale, arglist);
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+
+template <typename Character>
+static int __cdecl common_vsscanf(
+    unsigned __int64 const options,
+    Character const* const buffer,
+    size_t           const buffer_count,
+    Character const* const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> char_traits;
+
+    typedef input_processor<
+        Character,
+        string_input_adapter<Character>
+    > processor_type;
+
+    _VALIDATE_RETURN(buffer != nullptr, EINVAL, EOF);
+    _VALIDATE_RETURN(format != nullptr, EINVAL, EOF);
+
+    // The number of elements to consider when scanning is the lesser of [1] the
+    // specified number of elements in the buffer or [2] the length of the string
+    // in the buffer.
+    size_t const buffer_count_for_stream = char_traits::tcsnlen(buffer, buffer_count);
+
+    _LocaleUpdate locale_update(locale);
+
+    processor_type processor(
+        string_input_adapter<Character>(buffer, buffer_count_for_stream),
+        options,
+        format,
+        locale_update.GetLocaleT(),
+        arglist);
+
+    return processor.process();
+}
+
+extern "C" int __cdecl __stdio_common_vsscanf(
+    unsigned __int64 const options,
+    char const*      const buffer,
+    size_t           const buffer_count,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_vsscanf(options, buffer, buffer_count, format, locale, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vswscanf(
+    unsigned __int64 const options,
+    wchar_t const*   const buffer,
+    size_t           const buffer_count,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    return common_vsscanf(options, buffer, buffer_count, format, locale, arglist);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ncommode.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ncommode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..391cad26550d72420f5126b47b23ebe37c0b6900
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ncommode.cpp	
@@ -0,0 +1,20 @@
+//
+// ncommode.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _commode, which sets the default file commit mode to nocommit.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Set default file commit mode to nocommit
+extern "C" int _commode = 0;
+
+
+
+extern "C" int* __cdecl __p__commode()
+{
+    return &_commode;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/openfile.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/openfile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a8a4f268ddbce8d5357f032e05ccd6823cb3347
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/openfile.cpp	
@@ -0,0 +1,77 @@
+//
+// openfile.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Functions that open a file as a stdio stream, with mode and share flag.
+//
+#include <corecrt_internal_stdio.h>
+#include <sys/stat.h>
+
+
+
+// Opens a file with a string mode and file sharing flag.  This function defines
+// the common logic shared by other stdio open functions.  It parses the mode
+// string, per the rules described in the above parser, then opens the file via
+// the lowio library.
+//
+// Returns the new FILE* on success; returns nullptr on failure.
+template <typename Character>
+static FILE* __cdecl common_openfile(
+    Character const*   const file_name,
+    Character const*   const mode,
+    int                const share_flag,
+    __crt_stdio_stream const stream
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    _ASSERTE(file_name != nullptr);
+    _ASSERTE(mode      != nullptr);
+    _ASSERTE(stream.valid());
+
+    __acrt_stdio_stream_mode const parsed_mode = __acrt_stdio_parse_mode(mode);
+    if (!parsed_mode._success)
+        return nullptr;
+
+    int fh;
+    if (stdio_traits::tsopen_s(&fh, file_name, parsed_mode._lowio_mode, share_flag, _S_IREAD | _S_IWRITE) != 0)
+        return nullptr;
+
+    // Ensure that streams get flushed during pre-termination:
+    #ifndef CRTDLL
+    _cflush++;
+    #endif
+
+    // Initialize the stream:
+    stream.set_flags(parsed_mode._stdio_mode);
+    stream->_cnt      = 0;
+    stream->_tmpfname = nullptr;
+    stream->_base     = nullptr;
+    stream->_ptr      = nullptr;
+    stream->_file     = fh;
+
+    return stream.public_stream();
+}
+
+
+
+extern "C" FILE* __cdecl _openfile(
+    char const* const file_name,
+    char const* const mode,
+    int         const share_flag,
+    FILE*       const public_stream
+    )
+{
+    return common_openfile(file_name, mode, share_flag, __crt_stdio_stream(public_stream));
+}
+
+extern "C" FILE* __cdecl _wopenfile(
+    wchar_t const* const file_name,
+    wchar_t const* const mode,
+    int            const share_flag,
+    FILE*          const public_stream
+    )
+{
+    return common_openfile(file_name, mode, share_flag, __crt_stdio_stream(public_stream));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/output.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/output.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11bd2f0a0b2d9c6005e763ff4fd9a75fa33adcff
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/output.cpp	
@@ -0,0 +1,445 @@
+//
+// output.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The standard _output functions, which perform formatted output to a stream.
+//
+#include <corecrt_internal_stdio_output.h>
+
+
+
+using namespace __crt_stdio_output;
+
+
+// Enclaves do not have a file system, but they do allow in-memory operations
+// from stdio.
+#ifndef _UCRT_ENCLAVE_BUILD
+
+template <template <typename, typename> class Base, typename Character>
+static int __cdecl common_vfprintf(
+    unsigned __int64   const options,
+    FILE*              const stream,
+    Character const*   const format,
+    __crt_cached_ptd_host&   ptd,
+    va_list            const arglist
+    ) throw()
+{
+    typedef output_processor<
+        Character,
+        stream_output_adapter<Character>,
+        Base<Character, stream_output_adapter<Character>>
+    > processor_type;
+
+    _UCRT_VALIDATE_RETURN(ptd, stream != nullptr, EINVAL, -1);
+    _UCRT_VALIDATE_RETURN(ptd, format != nullptr, EINVAL, -1);
+
+    return __acrt_lock_stream_and_call(stream, [&]() -> int
+    {
+        __acrt_stdio_temporary_buffering_guard const buffering(stream, ptd);
+
+        processor_type processor(
+            stream_output_adapter<Character>(stream),
+            options,
+            format,
+            ptd,
+            arglist);
+
+        return processor.process();
+    });
+}
+
+extern "C" int __cdecl __stdio_common_vfprintf(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vfprintf<standard_base>(options, stream, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vfwprintf(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vfprintf<standard_base>(options, stream, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vfprintf_s(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vfprintf<format_validation_base>(options, stream, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vfwprintf_s(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vfprintf<format_validation_base>(options, stream, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vfprintf_p(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vfprintf<positional_parameter_base>(options, stream, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vfwprintf_p(
+    unsigned __int64 const options,
+    FILE*            const stream,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vfprintf<positional_parameter_base>(options, stream, format, ptd, arglist);
+}
+
+#endif /* _UCRT_ENCLAVE_BUILD */
+
+
+template <template <typename, typename> class Base, typename Character>
+_Success_(return >= 0)
+static int __cdecl common_vsprintf(
+                                    unsigned __int64   const options,
+    _Out_writes_z_(buffer_count)    Character*         const buffer,
+                                    size_t             const buffer_count,
+                                    Character const*   const format,
+                                    __crt_cached_ptd_host&   ptd,
+                                    va_list            const arglist
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> char_traits;
+
+    typedef output_processor<
+        Character,
+        string_output_adapter<Character>,
+        Base<Character, string_output_adapter<Character>>
+    > processor_type;
+
+    _UCRT_VALIDATE_RETURN(ptd, format != nullptr,                      EINVAL, -1);
+    _UCRT_VALIDATE_RETURN(ptd, buffer_count == 0 || buffer != nullptr, EINVAL, -1);
+
+    string_output_adapter_context<Character> context{};
+    context._buffer         = buffer;
+    context._buffer_count   = buffer_count;
+    context._buffer_used    = 0;
+
+    // For the C Standard snprintf functions, we continue formatting even after
+    // the buffer is full so that we can return the number of characters that
+    // are required to complete the format operation.  For all other sprintf
+    // functions that have a buffer count, if no buffer was provided then we
+    // do the same.
+    context._continue_count =
+        (options & _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR) != 0 ||
+        buffer == nullptr;
+
+    processor_type processor(
+        string_output_adapter<Character>(&context),
+        options,
+        format,
+        ptd,
+        arglist);
+
+    int const result = processor.process();
+
+    if (buffer == nullptr)
+    {
+        return result;
+    }
+
+    // Otherwise, we formatted data into the buffer and need to terminate it:
+    if (options & _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION)
+    {
+        if (buffer_count == 0 && result != 0)
+        {
+            return -1;
+        }
+        else if (context._buffer_used != buffer_count)
+        {
+            buffer[context._buffer_used] = '\0';
+        }
+        else if (result >= 0 && static_cast<size_t>(result) > buffer_count)
+        {
+            return -1;
+        }
+    }
+    else if (options & _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR)
+    {
+        if (buffer_count == 0)
+        {
+            // No-op
+        }
+        else if (result < 0)
+        {
+            buffer[0] = '\0';
+        }
+        else if (context._buffer_used == buffer_count)
+        {
+            buffer[buffer_count - 1] = '\0';
+        }
+        else
+        {
+            buffer[context._buffer_used] = '\0';
+        }
+    }
+    else
+    {
+        if (buffer_count == 0)
+        {
+            return -1;
+        }
+        else if (context._buffer_used == buffer_count)
+        {
+            buffer[buffer_count - 1] = '\0';
+            return -2;
+        }
+        else
+        {
+            buffer[context._buffer_used] = '\0';
+        }
+    }
+
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036 needs work
+    return result;
+}
+
+extern "C" int __cdecl __stdio_common_vsprintf(
+    unsigned __int64 const options,
+    char*            const buffer,
+    size_t           const buffer_count,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsprintf<standard_base>(options, buffer, buffer_count, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vswprintf(
+    unsigned __int64 const options,
+    wchar_t*         const buffer,
+    size_t           const buffer_count,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsprintf<standard_base>(options, buffer, buffer_count, format, ptd, arglist);
+}
+
+template <typename Character>
+_Success_(return >= 0)
+static int __cdecl common_vsprintf_s(
+                                    unsigned __int64   const options,
+    _Out_writes_z_(buffer_count)    Character*         const buffer,
+                                    size_t             const buffer_count,
+                                    Character const*   const format,
+                                    __crt_cached_ptd_host&   ptd,
+                                    va_list            const arglist
+    ) throw()
+{
+    _UCRT_VALIDATE_RETURN(ptd, format != nullptr,                     EINVAL, -1);
+    _UCRT_VALIDATE_RETURN(ptd, buffer != nullptr && buffer_count > 0, EINVAL, -1);
+
+    int const result = common_vsprintf<format_validation_base>(options, buffer, buffer_count, format, ptd, arglist);
+    if (result < 0)
+    {
+        buffer[0] = 0;
+        _SECURECRT__FILL_STRING(buffer, buffer_count, 1);
+    }
+
+    if (result == -2)
+    {
+        _UCRT_VALIDATE_RETURN(ptd, ("Buffer too small", 0), ERANGE, -1);
+    }
+    else if (result >= 0)
+    {
+        _SECURECRT__FILL_STRING(buffer, buffer_count, result + 1);
+    }
+
+    return result;
+}
+
+extern "C" int __cdecl __stdio_common_vsprintf_s(
+    unsigned __int64 const options,
+    char*            const buffer,
+    size_t           const buffer_count,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsprintf_s(options, buffer, buffer_count, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vswprintf_s(
+    unsigned __int64 const options,
+    wchar_t*         const buffer,
+    size_t           const buffer_count,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsprintf_s(options, buffer, buffer_count, format, ptd, arglist);
+}
+
+template <typename Character>
+_Success_(return >= 0)
+static int __cdecl common_vsnprintf_s(
+                                    unsigned __int64   const options,
+    _Out_writes_z_(buffer_count)    Character*         const buffer,
+                                    size_t             const buffer_count,
+                                    size_t             const max_count,
+                                    Character const*   const format,
+                                    __crt_cached_ptd_host&   ptd,
+                                    va_list            const arglist
+    ) throw()
+{
+    _UCRT_VALIDATE_RETURN(ptd, format != nullptr, EINVAL, -1);
+
+    if (max_count == 0 && buffer == nullptr && buffer_count == 0)
+        return 0; // No work to do
+
+    _UCRT_VALIDATE_RETURN(ptd, buffer != nullptr && buffer_count > 0, EINVAL, -1);
+
+    int result = -1;
+    {
+        auto errno_restore_point = ptd.get_errno().create_guard();
+        errno_restore_point.disable();
+
+        if (buffer_count > max_count)
+        {
+            result = common_vsprintf<format_validation_base>(options, buffer, max_count + 1, format, ptd, arglist);
+
+            if (result == -2)
+            {
+                // The string has been truncated; return -1:
+                _SECURECRT__FILL_STRING(buffer, buffer_count, max_count + 1);
+                if (ptd.get_errno().check(ERANGE))
+                {
+                    errno_restore_point.enable();
+                }
+
+                return -1;
+            }
+        }
+        else
+        {
+            result = common_vsprintf<format_validation_base>(options, buffer, buffer_count, format, ptd, arglist);
+            buffer[buffer_count - 1] = 0;
+
+            // We allow truncation if count == _TRUNCATE
+            if (result == -2 && max_count == _TRUNCATE)
+            {
+                if (ptd.get_errno().check(ERANGE))
+                {
+                    errno_restore_point.enable();
+                }
+
+                return -1;
+            }
+        }
+    }
+
+    if (result < 0)
+    {
+        buffer[0] = 0;
+        _SECURECRT__FILL_STRING(buffer, buffer_count, 1);
+        if (result == -2)
+        {
+            _UCRT_VALIDATE_RETURN(ptd, ("Buffer too small", 0), ERANGE, -1);
+        }
+
+        return -1;
+    }
+
+    _SECURECRT__FILL_STRING(buffer, buffer_count, result + 1);
+
+    return result < 0 ? -1 : result;
+}
+
+extern "C" int __cdecl __stdio_common_vsnprintf_s(
+    unsigned __int64 const options,
+    char*            const buffer,
+    size_t           const buffer_count,
+    size_t           const max_count,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsnprintf_s(options, buffer, buffer_count, max_count, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vsnwprintf_s(
+    unsigned __int64 const options,
+    wchar_t*         const buffer,
+    size_t           const buffer_count,
+    size_t           const max_count,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsnprintf_s(options, buffer, buffer_count, max_count, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vsprintf_p(
+    unsigned __int64 const options,
+    char*            const buffer,
+    size_t           const buffer_count,
+    char const*      const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsprintf<positional_parameter_base>(options, buffer, buffer_count, format, ptd, arglist);
+}
+
+extern "C" int __cdecl __stdio_common_vswprintf_p(
+    unsigned __int64 const options,
+    wchar_t*         const buffer,
+    size_t           const buffer_count,
+    wchar_t const*   const format,
+    _locale_t        const locale,
+    va_list          const arglist
+    )
+{
+    __crt_cached_ptd_host ptd(locale);
+    return common_vsprintf<positional_parameter_base>(options, buffer, buffer_count, format, ptd, arglist);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/printf_count_output.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/printf_count_output.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5685dad5e2548c599dd2b1795a538e6ca05d4366
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/printf_count_output.cpp	
@@ -0,0 +1,35 @@
+//
+// printf_count_output.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the functions that control the enable state of %n.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+static UINT_PTR enable_percent_n = 0;
+
+
+
+// Enables or disables the %n format specifier for the printf family of functions.
+// Note the use of the __security_cookie:  if the static variable was set to a
+// known value, an attacker could potentially modify that value and then provide
+// a malicious %n specifier.  The cookie is or'ed with 1 becuase a cookie with a
+// value of zero is possible.
+extern "C" int __cdecl _set_printf_count_output(int const value)
+{
+    int const old = (enable_percent_n == (__security_cookie | 1));
+    enable_percent_n = (value ? (__security_cookie | 1) : 0);
+    return old;
+}
+
+
+
+// Tests whether the %n format specifier for the printf family of functions is
+// enabled.
+extern "C" int __cdecl _get_printf_count_output()
+{
+    return enable_percent_n == (__security_cookie | 1);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/puts.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/puts.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52092375d0fadbdbb6a8900e7010ce247715072b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/puts.cpp	
@@ -0,0 +1,45 @@
+//
+// puts.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines puts(), which writes a string to stdout.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Writes a string to stdout.  Does not write the string's null terminator, but
+// _does_ append a newline to the output.  Return 0 on success; EOF on failure.
+static int __cdecl _puts_internal(char const* const string, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_VALIDATE_RETURN(ptd, string != nullptr,  EINVAL, EOF);
+
+    FILE* const stream = stdout;
+    _UCRT_VALIDATE_STREAM_ANSI_RETURN(ptd, stream, EINVAL, EOF);
+
+    size_t const length = strlen(string);
+
+    return __acrt_lock_stream_and_call(stream, [&]() -> int
+    {
+        __acrt_stdio_temporary_buffering_guard const buffering(stream, ptd);
+
+        size_t const bytes_written = _fwrite_nolock_internal(string, 1, length, stream, ptd);
+
+        // If we failed to write the entire string, or if we fail to write the
+        // newline, reset the buffering and return failure:
+        if (bytes_written != length || _fputc_nolock_internal('\n', stream, ptd) == EOF)
+        {
+            return EOF;
+        }
+
+        return 0;
+    });
+}
+
+extern "C" int __cdecl puts(char const* const string)
+{
+    __crt_cached_ptd_host ptd;
+    return _puts_internal(string, ptd);
+}
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/putw.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/putw.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..770e65450254c52ecafd9ebd974e9d977beac54b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/putw.cpp	
@@ -0,0 +1,43 @@
+//
+// putw.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _putw(), which writes a binary integer to a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Writes the binary int value to the stream, byte-by-byte.  On success, returns
+// the value written; on failure, returns EOF.  Note, however, that the value may
+// be EOF--that is, after all, a valid integer--so be sure to test ferror() and
+// feof() to check for error conditions.
+extern "C" int __cdecl _putw(int const value, FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, EOF);
+
+    int return_value = EOF;
+
+    _lock_file(stream);
+    __try
+    {
+        char const* const first = reinterpret_cast<char const*>(&value);
+        char const* const last  = first + sizeof(value);
+        for (char const* it = first; it != last; ++it)
+        {
+            _fputc_nolock(*it, stream);
+        }
+
+        if (ferror(stream))
+            __leave;
+
+        return_value = value;
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/putws.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/putws.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..922b80041a47f9688afc6fc93911b42e3ac2da86
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/putws.cpp	
@@ -0,0 +1,48 @@
+//
+// putws.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _putws(), which writes a wide character string to stdout.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Writes a wide character string to stdout.  Does not write the string's null
+// terminator, but _does_ append a newline to the output.  Returns 0 on success;
+// returns WEOF on failure.
+static int __cdecl _putws_internal(wchar_t const* const string, __crt_cached_ptd_host& ptd)
+{
+    _UCRT_VALIDATE_RETURN(ptd, string != nullptr, EINVAL, WEOF);
+
+    FILE* const stream = stdout;
+
+    return __acrt_lock_stream_and_call(stream, [&]() -> int
+    {
+        __acrt_stdio_temporary_buffering_guard const buffering(stream, ptd);
+
+        // Write the string, character-by-character:
+        for (wchar_t const* it = string; *it; ++it)
+        {
+            if (_fputwc_nolock_internal(*it, stream, ptd) == WEOF)
+            {
+                return WEOF;
+            }
+        }
+
+        if (_fputwc_nolock_internal(L'\n', stream, ptd) == WEOF)
+        {
+            return WEOF;
+        }
+
+        return 0;
+    });
+}
+
+extern "C" int __cdecl _putws(wchar_t const* const string)
+{
+    __crt_cached_ptd_host ptd;
+    return _putws_internal(string, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/rewind.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/rewind.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e847dcc21d581846c7667ef2b5d2985a735fedd3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/rewind.cpp	
@@ -0,0 +1,60 @@
+//
+// rewind.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines rewind(), which rewinds a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Rewinds a stream back to the beginning, if the stream supports seeking.  The
+// stream is flushed and errors are cleared before the rewind.
+static void __cdecl _rewind_internal(FILE* const public_stream, __crt_cached_ptd_host& ptd)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _UCRT_VALIDATE_RETURN_VOID(ptd, stream.valid(), EINVAL);
+
+    int const fh = _fileno(stream.public_stream());
+
+    _lock_file(stream.public_stream());
+    __try
+    {
+        // Flush the streeam, reset the error state, and seek back to the
+        // beginning:
+        __acrt_stdio_flush_nolock(stream.public_stream(), ptd);
+        // If the stream is opened in update mode and is currently in use for reading,
+        // the buffer must be abandoned to ensure consistency when transitioning from
+        // reading to writing.
+        // __acrt_stdio_flush_nolock will not reset the buffer when _IOWRITE flag
+        // is not set.
+        __acrt_stdio_reset_buffer(stream);
+
+
+        stream.unset_flags(_IOERROR | _IOEOF);
+        _osfile_safe(fh) &= ~(FEOFLAG);
+
+       if (stream.has_all_of(_IOUPDATE))
+       {
+           stream.unset_flags(_IOREAD | _IOWRITE);
+       }
+
+        if (_lseek_internal(fh, 0, 0, ptd) == -1)
+        {
+            stream.set_flags(_IOERROR);
+        }
+    }
+    __finally
+    {
+        _unlock_file(stream.public_stream());
+    }
+}
+
+extern "C" void __cdecl rewind(FILE* const public_stream)
+{
+    __crt_cached_ptd_host ptd;
+    _rewind_internal(public_stream, ptd);
+}
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/rmtmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/rmtmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e18da0c4ab8ba3e977bf53df85133684056dc3c3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/rmtmp.cpp	
@@ -0,0 +1,75 @@
+//
+// rmtmp.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _rmtmp(), which closes and removes all temporary files created by
+// tmpfile()
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+_CRT_LINKER_FORCE_INCLUDE(__acrt_tmpfile_terminator);
+
+
+
+// These definitions will cause this object to be linked in whenever the
+// termination code requires it.
+#ifndef CRTDLL
+    extern "C" unsigned __acrt_tmpfile_used = 1;
+#endif
+
+extern "C" unsigned _tempoff = 1;
+extern "C" unsigned _old_pfxlen = 0;
+
+
+
+// Closes and removes all temporary files created by tmpfile().  Returns the
+// number of streams that were closed.
+extern "C" int __cdecl _rmtmp()
+{
+    int count = 0;
+
+    __acrt_lock(__acrt_stdio_index_lock);
+    __try
+    {
+        for (int i = 0; i != _nstream; ++i)
+        {
+            __crt_stdio_stream stream(__piob[i]);
+
+            if (!stream.valid())
+                continue;
+
+            _lock_file(stream.public_stream());
+            __try
+            {
+                if (!stream.is_in_use())
+                    __leave;
+
+                if (stream->_tmpfname == nullptr)
+                    __leave;
+
+                // The stream is still in use.  Close it:
+                _fclose_nolock(stream.public_stream());
+                ++count;
+            }
+            __finally
+            {
+                _unlock_file(stream.public_stream());
+            }
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_stdio_index_lock);
+    }
+
+    return count;
+}
+
+extern "C" void __cdecl __acrt_uninitialize_tmpfile()
+{
+    __acrt_stdio_free_tmpfile_name_buffers_nolock();
+    _rmtmp();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setbuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setbuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..46746910dcd75f35849375b66ce61e09318d9caf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setbuf.cpp	
@@ -0,0 +1,28 @@
+//
+// setbuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines setbuf(), which enables or disables buffering on a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// If the buffer is null, buffering is disabled for the stream.  If the buffer is
+// non-null, it must point to a buffer of BUFSIZ characters; the stream will be
+// configured to use that buffer.  The functionality of setbuf() is a strict
+// subset of the functionality of setvbuf().
+extern "C" void __cdecl setbuf(FILE* const stream, char* const buffer)
+{
+    _ASSERTE(stream != nullptr);
+
+    if (buffer == nullptr)
+    {
+        setvbuf(stream, nullptr, _IONBF, 0);
+    }
+    else
+    {
+        setvbuf(stream, buffer, _IOFBF, BUFSIZ);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setmaxf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setmaxf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f11dae72d91e808f948a662885d3b92579993687
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setmaxf.cpp	
@@ -0,0 +1,71 @@
+//
+// setmaxf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _setmaxstdio() and _getmaxstdio(), which control the maximum number
+// of stdio streams that may be open simultaneously.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Sets the maximum number of stdio streams that may be simultaneously open.
+// Note that the maximum must be at least _IOB_ENTRIES, and must be no larger
+// than _N_HANDLE_.  However, it may be either larger or smaller than the current
+// maximum.
+//
+// Returns the new maximum value on success; returns -1 on failure.
+extern "C" int __cdecl _setmaxstdio(int const new_maximum)
+{
+    // Make sure the request is reasonable:
+    _VALIDATE_RETURN(new_maximum >= _IOB_ENTRIES && new_maximum <= _NHANDLE_, EINVAL, -1);
+
+    return __acrt_lock_and_call(__acrt_stdio_index_lock, [&]
+    {
+        // If the new maximum is the same as our current maximum, no work to do:
+        if (new_maximum == _nstream)
+            return new_maximum;
+
+        // If the new maximum is smaller than the current maximum, attempt to
+        // free up any entries that are beyond the new maximum:
+        if (new_maximum < _nstream)
+        {
+            __crt_stdio_stream_data** const first_to_remove = __piob + new_maximum;
+            __crt_stdio_stream_data** const last_to_remove  = __piob + _nstream;
+            for (__crt_stdio_stream_data** rit = last_to_remove; rit != first_to_remove; --rit)
+            {
+                __crt_stdio_stream_data* const entry = *(rit - 1);
+                if (entry == nullptr)
+                    continue;
+
+                // If the entry is still in use, stop freeing entries and return
+                // failure to the caller:
+                if (__crt_stdio_stream(entry).is_in_use())
+                    return -1;
+
+                _free_crt(entry);
+            }
+        }
+
+        // Enlarge or shrink the array, as required:
+        __crt_stdio_stream_data** const new_piob = _recalloc_crt_t(__crt_stdio_stream_data*, __piob, new_maximum).detach();
+        if (new_piob == nullptr)
+            return -1;
+
+        _nstream = new_maximum;
+        __piob = new_piob;
+        return new_maximum;
+    });
+}
+
+
+
+// Gets the maximum number of stdio streams that may be open at any one time.
+extern "C" int __cdecl _getmaxstdio()
+{
+    return __acrt_lock_and_call(__acrt_stdio_index_lock, []
+    {
+        return _nstream;
+    });
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setvbuf.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setvbuf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33a608671465e3e34524b9da3907663310d5260b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/setvbuf.cpp	
@@ -0,0 +1,118 @@
+//
+// setvbuf.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines setvbuf(), which is used to set buffering mode for a stream.
+//
+#include <corecrt_internal_stdio.h>
+#include <corecrt_internal_ptd_propagation.h>
+
+
+
+// Helper for setvbuf() that sets various buffer properties and return zero.
+static int __cdecl set_buffer(
+                                            __crt_stdio_stream const stream,
+    _In_reads_opt_(buffer_size_in_bytes)    char*              const buffer,
+                                            size_t             const buffer_size_in_bytes,
+                                            int                const new_flag_bits
+    ) throw()
+{
+    stream.set_flags(new_flag_bits);
+    stream->_bufsiz = static_cast<int>(buffer_size_in_bytes);
+    stream->_ptr    = buffer;
+    stream->_base   = buffer;
+    stream->_cnt    = 0;
+
+    return 0;
+}
+
+
+
+// Controls buffering and buffer size for the specified stream.  The array
+// pointed to by 'buffer' is used as a buffer for the stream.  If 'buffer' is
+// null, the CRT allocates a buffer of the requested size.  The 'type' specifies
+// the type of buffering, which must be one of _IONBF (no buffering) or _IOLBF
+// or _IOFBF (both of which mean full buffering).
+//
+// Returns zero on success; nonzero on failure.
+static int __cdecl _setvbuf_internal(
+    FILE*              const public_stream,
+    char*              const buffer,
+    int                const type,
+    size_t             const buffer_size_in_bytes,
+    __crt_cached_ptd_host&   ptd
+    )
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _UCRT_VALIDATE_RETURN(ptd, stream.valid(), EINVAL, -1);
+
+    // Make sure 'type' is one of the three allowed values, and if we are
+    // buffering, make sure the size is between 2 and INT_MAX:
+    _UCRT_VALIDATE_RETURN(ptd, type == _IONBF || type == _IOFBF || type == _IOLBF, EINVAL, -1);
+
+    if (type == _IOFBF || type == _IOLBF)
+    {
+        _UCRT_VALIDATE_RETURN(ptd, 2 <= buffer_size_in_bytes && buffer_size_in_bytes <= INT_MAX, EINVAL, -1);
+    }
+
+    return __acrt_lock_stream_and_call(stream.public_stream(), [&]
+    {
+        // Force the buffer size to be even by masking the low order bit:
+        size_t const usable_buffer_size = buffer_size_in_bytes & ~static_cast<size_t>(1);
+
+        // Flush the current buffer and free it, if it is ours:
+        __acrt_stdio_flush_nolock(stream.public_stream(), ptd);
+        __acrt_stdio_free_buffer_nolock(stream.public_stream());
+
+        // Clear the stream state bits related to buffering.  Most of these
+        // should never be set when setvbuf() is called, but it doesn't cost
+        // anything to be safe.
+        stream.unset_flags(_IOBUFFER_CRT     | _IOBUFFER_USER  | _IOBUFFER_NONE |
+                           _IOBUFFER_SETVBUF | _IOBUFFER_STBUF | _IOCTRLZ);
+
+        // Case 1:  No buffering:
+        if (type & _IONBF)
+        {
+            return set_buffer(stream, reinterpret_cast<char*>(&stream->_charbuf), 2, _IOBUFFER_NONE);
+        }
+
+        // Cases 2 and 3 (below) cover the _IOFBF and _IOLBF types of buffering.
+        // Line buffering is treated the same as full buffering, so the _IOLBF
+        // bit in the flag is never set.  Finally, since _IOFBF is defined to
+        // be zero, full buffering is simply assumed whenever _IONBF is not set.
+
+        // Case 2:  Default buffering, CRT-allocated buffer:
+        if (buffer == nullptr)
+        {
+            char* const crt_buffer = _calloc_crt_t(char, usable_buffer_size).detach();
+            if (!crt_buffer)
+            {
+                #ifndef CRTDLL
+                // Force library pre-termination procedure (this is placed here
+                // because the code path should almost never be hit):
+                ++_cflush;
+                #endif
+
+                return -1;
+            }
+
+            return set_buffer(stream, crt_buffer, usable_buffer_size, _IOBUFFER_CRT | _IOBUFFER_SETVBUF);
+        }
+
+        // Case 3:  Default buffering, user-provided buffer:
+        return set_buffer(stream, buffer, usable_buffer_size, _IOBUFFER_USER | _IOBUFFER_SETVBUF);
+    });
+}
+
+extern "C" int __cdecl setvbuf(
+    FILE*  const public_stream,
+    char*  const buffer,
+    int    const type,
+    size_t const buffer_size_in_bytes
+    )
+{
+    __crt_cached_ptd_host ptd;
+    return _setvbuf_internal(public_stream, buffer, type, buffer_size_in_bytes, ptd);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/stream.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/stream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11882b1f1d4e911389adbe95700b327c5d6ea7d0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/stream.cpp	
@@ -0,0 +1,106 @@
+//
+// getstream.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _getstream(), which finds and locks a stream that is available for use.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+static __crt_stdio_stream __cdecl find_or_allocate_unused_stream_nolock() throw()
+{
+    __crt_stdio_stream_data** const first_stream = __piob + _IOB_ENTRIES;
+    __crt_stdio_stream_data** const last_stream  = first_stream + _nstream - _IOB_ENTRIES;
+
+    for (__crt_stdio_stream_data** it = first_stream; it != last_stream; ++it)
+    {
+        // First, check to see whether the stream is valid and free for use:
+        {
+            __crt_stdio_stream stream(*it);
+            if (stream.valid())
+            {
+                if (stream.is_in_use())
+                    continue;
+
+                stream.lock();
+                if (!stream.try_allocate())
+                {
+                    stream.unlock();
+                    continue;
+                }
+
+                return stream;
+            }
+        }
+
+        // Otherwise, there is no stream at this index yet, so we allocate one
+        // and return it:
+        {
+            *it = _calloc_crt_t(__crt_stdio_stream_data, 1).detach();
+            if (*it == nullptr)
+                break;
+
+            // Initialize the stream.  Everything requires zero-initialization
+            // (which we get from calloc), except the file handle and the lock:
+            (*it)->_file = -1;
+            __acrt_InitializeCriticalSectionEx(&(*it)->_lock, _CORECRT_SPINCOUNT, 0);
+
+            __crt_stdio_stream stream(*it);
+
+            // Note:  This attempt will always succeed, because we hold the only
+            // pointer to the stream object (since we just allocated it):
+            stream.try_allocate();
+            stream.lock();
+
+            return stream;
+        }
+    }
+
+    return __crt_stdio_stream();
+}
+
+
+
+// Finds a stream not in use and makes it available to the caller.  It is
+// intended for internal use inside the library only.  It returns a pointer to
+// a free stream, or nullptr if all are in use.  A stream becomes allocated
+// only if the caller decides to use it by setting a mode (r, w, or r/w).  The
+// stream is returned locked; the caller is responsible for unlocking the stream.
+__crt_stdio_stream __cdecl __acrt_stdio_allocate_stream() throw()
+{
+    __crt_stdio_stream stream;
+
+    __acrt_lock(__acrt_stdio_index_lock);
+    __try
+    {
+        stream = find_or_allocate_unused_stream_nolock();
+        if (!stream.valid())
+            __leave;
+
+        stream->_cnt = 0;
+        stream->_tmpfname = nullptr;
+        stream->_ptr = nullptr;
+        stream->_base = nullptr;
+        stream->_file = -1;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_stdio_index_lock);
+    }
+
+    return stream;
+}
+
+void __cdecl __acrt_stdio_free_stream(__crt_stdio_stream stream) throw()
+{
+    stream->_ptr      = nullptr;
+    stream->_base     = nullptr;
+    stream->_cnt      =  0;
+    stream->_file     = -1;
+    stream->_charbuf  =  0;
+    stream->_bufsiz   =  0;
+    stream->_tmpfname = nullptr;
+    stream.deallocate();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/tempnam.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/tempnam.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85e2d585a3e18db29eb9c35b450148986bdcc544
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/tempnam.cpp	
@@ -0,0 +1,294 @@
+//
+// tempnam.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _tempnam(), which generates temporary file names.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Strips quotes from a string.  If the source string contains no quotes, it is
+// returned.  If the source string contains quotes, a new string is allocated
+// and the string is copied into it, character by character, skipping "'s.  If
+// a non-null pointer is returned, the caller is responsible for freeing it.
+template <typename Character>
+static Character const* __cdecl strip_quotes(Character const* const source) throw()
+{
+    // Count the number of quotation marks in the string, and compute the length
+    // of the string, in case we need to allocate a new string:
+    size_t quote_count   = 0;
+    size_t source_length = 0;
+    for (Character const* it = source; *it; ++it)
+    {
+        if (*it == '\"')
+            ++quote_count;
+
+        ++source_length;
+    }
+
+    // No quotes?  No problem!
+    if (quote_count == 0)
+        return nullptr;
+
+    size_t const destination_length = source_length - quote_count + 1;
+    __crt_unique_heap_ptr<Character> destination(_calloc_crt_t(Character, destination_length));
+    if (destination.get() == nullptr)
+        return nullptr;
+
+    // Copy the string, stripping quotation marks:
+    Character* destination_it = destination.get();
+    for (Character const* source_it = source; *source_it; ++source_it)
+    {
+        if (*source_it == '\"')
+            continue;
+
+        *destination_it++ = *source_it;
+    }
+
+    *destination_it = '\0';
+    return destination.detach();
+}
+
+// Gets the path to the %TMP% directory
+template <typename Character>
+static Character const* __cdecl get_tmp_directory() throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    static Character const tmp_name[] = { 'T', 'M', 'P', '\0' };
+
+    Character* tmp_value = nullptr;
+    if (_ERRCHECK_EINVAL(stdio_traits::tdupenv_s_crt(&tmp_value, nullptr, tmp_name)) != 0)
+        return nullptr;
+
+    return tmp_value;
+}
+
+
+
+// Gets the directory relative to which the temporary name should be formed.
+// The directory to be used is returned via the 'result' out parameter.  The
+// '*result' pointer is never null on return.  If '*result' needs to be freed
+// by the caller, the function also returns the pointer; if null is returned,
+// no caller cleanup is required.
+template <typename Character>
+static Character const* __cdecl get_directory(
+    Character const*  const alternative,
+    Character const** const result
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    __crt_unique_heap_ptr<Character const> tmp(get_tmp_directory<Character>());
+    if (tmp.get() != nullptr)
+    {
+        if (stdio_traits::taccess_s(tmp.get(), 0) == 0)
+            return *result = tmp.detach();
+
+        // Otherwise, try stripping quotes out of the TMP path and check again:
+        __crt_unique_heap_ptr<Character const> unquoted_tmp(strip_quotes(tmp.get()));
+        if (unquoted_tmp.get() != nullptr && stdio_traits::taccess_s(unquoted_tmp.get(), 0) == 0)
+            return *result = unquoted_tmp.detach();
+    }
+
+    // Otherwise, the TMP path is not usable; use the alternative path if one
+    // was provided and is accessible:
+    if (alternative != nullptr && stdio_traits::taccess_s(alternative, 0) == 0)
+        return (*result = alternative), nullptr;
+
+    // Otherwise, fall back to \ or .:
+    static Character const root_fallback[] = { '\\', '\0' };
+    static Character const cwd_fallback [] = { '.',  '\0' };
+    
+    if (stdio_traits::taccess_s(root_fallback, 0) == 0)
+        return (*result = root_fallback), nullptr;
+
+    return (*result = cwd_fallback), nullptr;
+}
+
+
+
+// The path_buffer is a pointer to the beginning of the buffer into which we
+// are formatting the temporary path.  The suffix_pointer is a pointer into
+// that same buffer, to the position where the unique identifier is to be
+// written.  The suffix_count is the number of characters that can be written
+// to the suffix_pointer.  The prefix_length is the length of the prefix that
+// appears before the suffix in the path_buffer already.
+template <typename Character>
+static bool __cdecl compute_name(
+    Character const* const path_buffer,
+    Character*       const suffix_pointer,
+    size_t           const suffix_count,
+    size_t           const prefix_length
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    // Re-initialize _tempoff if necessary.  If we don't re-init _tempoff, we
+    // can get into an infinate loop (e.g., (a) _tempoff is a big number on
+    // entry, (b) prefix is a long string (e.g., 8 chars) and all tempfiles
+    // with that prefix exist, (c) _tempoff will never equal first and we'll
+    // loop forever).
+
+    // [NOTE: To avoid a conflict that causes the same bug as that discussed
+    // above, _tempnam() uses _tempoff; tmpnam() uses _tmpoff]
+
+    bool return_value = false;
+
+    __acrt_lock(__acrt_tempnam_lock);
+    __try
+    {
+        if (_old_pfxlen < prefix_length)
+            _tempoff = 1;
+
+        _old_pfxlen = static_cast<unsigned int>(prefix_length);
+
+        unsigned const first = _tempoff;
+
+        errno_t const saved_errno = errno;
+        do
+        {
+            ++_tempoff;
+            if (_tempoff - first > _TMP_MAX_S)
+            {
+                errno = saved_errno;
+                __leave;
+            }
+
+            // The maximum length string returned by the conversion is ten
+            // characters, assuming a 32-bit unsigned integer, so there is
+            // sufficient room in the result buffer for it.
+            _ERRCHECK(stdio_traits::ultot_s(_tempoff, suffix_pointer, suffix_count, 10));
+            errno = 0;
+        }
+        while (stdio_traits::taccess_s(path_buffer, 0) == 0 || errno == EACCES);
+
+        errno = saved_errno;
+        return_value = true;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_tempnam_lock);
+    }
+
+    return return_value;
+}
+
+
+
+// Generates a unique file name within the temporary directory.  If the TMP
+// environment variable is defined and is accessible, that directory is used.
+// Otherwise, the given 'alternative' directory is used, if that is non-null and
+// the path is accessible.  Otherwise, the root of the drive is used if it is
+// accessible; otherwise, the local directory is used.
+//
+// Returns a pointer to the resulting file name on success; returns nullptr on
+// failure.  If a non-null pointer is returned, the caller is responsible for
+// freeing it by calling 'free()'.
+template <typename Character>
+_Success_(return != 0)
+static Character* __cdecl common_tempnam(
+    Character const* const alternative,
+    Character const* const prefix,
+    int              const block_use,
+    char const*      const file_name,
+    int              const line_number
+    ) throw()
+{
+    // These are referenced only in the Debug CRT build
+    UNREFERENCED_PARAMETER(block_use);
+    UNREFERENCED_PARAMETER(file_name);
+    UNREFERENCED_PARAMETER(line_number);
+
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    Character const* directory = nullptr;
+    __crt_unique_heap_ptr<Character const> const directory_cleanup(get_directory(alternative, &directory));
+
+    unsigned const prefix_length = prefix != nullptr
+        ? static_cast<unsigned>(stdio_traits::tcslen(prefix))
+        : 0;
+
+    // The 12 allows for a backslash, a ten character temporary string, and a
+    // null terminator.
+    unsigned const buffer_size = static_cast<unsigned>(stdio_traits::tcslen(directory)) + prefix_length + 12;
+
+    __crt_unique_heap_ptr<Character, __crt_public_free_policy> result(
+            static_cast<Character*>(_calloc_dbg(
+                buffer_size,
+                sizeof(Character),
+                block_use,
+                file_name,
+                line_number)));
+
+    if (!result)
+        return nullptr;
+
+    *result.get() = 0;
+    _ERRCHECK(stdio_traits::tcscat_s(result.get(), buffer_size, directory));
+
+    if (__crt_stdio_path_requires_backslash(directory))
+    {
+        static Character const backslash[] = { '\\', '\0' };
+        _ERRCHECK(stdio_traits::tcscat_s(result.get(), buffer_size, backslash));
+    }
+
+    if (prefix != nullptr)
+    {
+        _ERRCHECK(stdio_traits::tcscat_s(result.get(), buffer_size, prefix));
+    }
+
+    Character* const ptr = result.get() + stdio_traits::tcslen(result.get());
+    size_t     const ptr_size = buffer_size - (ptr - result.get());
+
+    if (!compute_name(result.get(), ptr, ptr_size, prefix_length))
+        return nullptr;
+
+    return result.detach();
+}
+
+
+
+extern "C" char* __cdecl _tempnam(
+    char const* const alternative,
+    char const* const prefix
+    )
+{
+    return common_tempnam(alternative, prefix, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" wchar_t* __cdecl _wtempnam(
+    wchar_t const* const alternative,
+    wchar_t const* const prefix
+    )
+{
+    return common_tempnam(alternative, prefix, _NORMAL_BLOCK, nullptr, 0);
+}
+
+#ifdef _DEBUG
+
+extern "C" char* __cdecl _tempnam_dbg(
+    char const* const alternative,
+    char const* const prefix,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+{
+    return common_tempnam(alternative, prefix, block_use, file_name, line_number);
+}
+
+extern "C" wchar_t* __cdecl _wtempnam_dbg(
+    wchar_t const* const alternative,
+    wchar_t const* const prefix,
+    int            const block_use,
+    char const*    const file_name,
+    int            const line_number
+    )
+{
+    return common_tempnam(alternative, prefix, block_use, file_name, line_number);
+}
+
+#endif
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/tmpfile.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/tmpfile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7797a168561ddbf8e68862c97b1f916b12b58659
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/tmpfile.cpp	
@@ -0,0 +1,509 @@
+//
+// tmpfile.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines tmpfile() and tmpfile_s(), which create temporary files, and tmpnam()
+// and tmpnam_s(), which generate temporary file names (and are used by the
+// tmpfile() functions).
+//
+#include <corecrt_internal_stdio.h>
+#include <sys/stat.h>
+
+
+
+// These are static buffers used by tmpnam() and tmpfile() to build file names.
+// The sizes are computed as follows:  The tmpname string looks like so:
+//
+//     PrefixFirstPart.SecondPart
+//
+// Prefix is "s" (1 character in length).  FirstPart is generated by converting
+// the process identifier to a base 32 string.  The maximum process identifier
+// so converted is 7 characters in length.  The "." is one character in length.
+// This gives a total of 1 + 7 + 1 = 9 for the "PrefixFirstPart." part of the
+// file name.
+//
+// The SecondPart is generated by converting a number to a string.  In tmpnam,
+// the maximum number is SHRT_MAX, the maximum length of which is 3 characters.
+// In tmpnam_s, the maximum number is INT_MAX, which is 7 characters long.
+//
+// The tmpnam paths are generated relative to "\\", so the total lengths for the
+// two functions are the length of that string plus 12 or plus 16 characters.
+//
+// The tmpfile path is generated in a manner similar to tmpnam, but relative to
+// an arbitrary path, so MAX_PATH is used in lieu of _countof("\\").
+namespace {
+
+    enum class buffer_id
+    {
+        tmpnam,
+        tmpfile,
+        tmpnam_s,
+        count
+    };
+}
+
+static char*    narrow_tmpfile_buffer_pointers[static_cast<size_t>(buffer_id::count)];
+static wchar_t* wide_tmpfile_buffer_pointers  [static_cast<size_t>(buffer_id::count)];
+
+extern "C" void __cdecl __acrt_stdio_free_tmpfile_name_buffers_nolock()
+{
+    for (char*& p : narrow_tmpfile_buffer_pointers)
+    {
+        _free_crt(p);
+        p = nullptr;
+    }
+
+    for (wchar_t*& p : wide_tmpfile_buffer_pointers)
+    {
+        _free_crt(p);
+        p = nullptr;
+    }
+}
+
+static char*& __cdecl get_tmpfile_buffer_pointer_nolock(buffer_id const id, char) throw()
+{
+    return narrow_tmpfile_buffer_pointers[static_cast<size_t>(id)];
+}
+
+static wchar_t*& __cdecl get_tmpfile_buffer_pointer_nolock(buffer_id const id, wchar_t) throw()
+{
+    return wide_tmpfile_buffer_pointers[static_cast<size_t>(id)];
+}
+
+template <typename Character>
+_Success_(return != nullptr)
+static Character* __cdecl get_tmpfile_buffer_nolock(buffer_id const id) throw()
+{
+    Character*& buffer_pointer = get_tmpfile_buffer_pointer_nolock(id, Character());
+    if (!buffer_pointer)
+    {
+        buffer_pointer = _calloc_crt_t(Character, L_tmpnam).detach();
+    }
+
+    return buffer_pointer;
+}
+
+template <typename Character>
+_Success_(return == true)
+static bool __cdecl initialize_tmpfile_buffer_nolock(buffer_id const buffer_id) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    Character* const buffer       = get_tmpfile_buffer_nolock<Character>(buffer_id);
+    size_t     const buffer_count = L_tmpnam;
+
+    if (!buffer)
+    {
+        return false;
+    }
+
+    // The temporary path must be short enough so that we can append a file name
+    // of the form [buffer id][process id].[unique id], which is at most 21
+    // characters in length (plus we must leave room for the null terminator).
+    //    1 Buffer Id              ("s", "t", or "u")
+    //    7 Base-36 Process Id     (maximum: "1z141z3")
+    //   13 Base-36 Unique File Id (maximum: "3w5e11264sgsf")
+    DWORD const max_supported_temp_path_length = buffer_count - 22;
+  
+    // Generate the path prefix; make sure it ends with a slash or backslash:
+    // CRT_REFACTOR TODO We need to use the WinRT temp path logic here.
+    DWORD const temp_path_length = stdio_traits::get_temp_path(static_cast<DWORD>(buffer_count), buffer);
+    if (temp_path_length == 0 || temp_path_length > max_supported_temp_path_length)
+    {
+        buffer[0] = '\0';
+        return false;
+    }
+
+    Character* tail = buffer + temp_path_length;
+
+    auto tail_count = [&](){ return buffer_count - (tail - buffer); };
+
+    // Append the buffer identifier part of the file name:
+    switch (buffer_id)
+    {
+    case buffer_id::tmpnam:   *tail++ = sizeof(Character) == 1 ? 's' : 'v'; break;
+    case buffer_id::tmpfile:  *tail++ = sizeof(Character) == 1 ? 't' : 'w'; break;
+    case buffer_id::tmpnam_s: *tail++ = sizeof(Character) == 1 ? 'u' : 'x'; break;
+    }
+
+    // Append the process identifier part of the file name:
+    _ERRCHECK(stdio_traits::ulltot_s(GetCurrentProcessId(), tail, tail_count(), 36));
+    tail += stdio_traits::tcslen(tail);
+
+    // Append the dot part of the file name and the initial unique id:
+    *tail++ = '.';
+    *tail++ = '0';
+    *tail++ = '\0';
+
+    return true;
+}
+
+
+
+template <typename Character>
+_Success_(return == true)
+static bool __cdecl generate_tmpfile_file_name(
+    _Inout_updates_z_(file_name_count) Character* const file_name,
+    _In_ size_t                                   const file_name_count
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    Character* const dot = reinterpret_cast<Character*>(stdio_traits::tcsrchr(file_name, '.'));
+    _VALIDATE_RETURN_NOERRNO(dot != nullptr,                                         false);
+    _VALIDATE_RETURN_NOERRNO(dot >= file_name,                                       false);
+    _VALIDATE_RETURN_NOERRNO(file_name_count > static_cast<size_t>(dot - file_name), false);
+
+    Character* const unique_id = dot + 1;
+    size_t     const unique_id_count = file_name_count - (unique_id - file_name);
+
+    uint64_t const next_identifier = stdio_traits::tcstoull(unique_id, nullptr, 36) + 1;
+    if (next_identifier == 0)
+        return false;
+
+#pragma warning(disable:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036 Prefast doesn't understand perfect forwarding.
+    _ERRCHECK(stdio_traits::ulltot_s(next_identifier, unique_id, unique_id_count, 36));
+    return true;
+}
+
+
+
+static char** __cdecl get_tmpnam_ptd_buffer(char) throw()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+        return nullptr;
+
+    return &ptd->_tmpnam_narrow_buffer;
+}
+
+static wchar_t** __cdecl get_tmpnam_ptd_buffer(wchar_t) throw()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+        return nullptr;
+
+    return &ptd->_tmpnam_wide_buffer;
+}
+
+
+
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_tmpnam_nolock(
+    _Out_writes_opt_z_(result_buffer_count) Character* const result_buffer,
+    size_t                                             const result_buffer_count,
+    buffer_id                                          const buffer_id
+    ) throw()
+{
+    typedef __acrt_stdio_char_traits<Character> stdio_traits;
+
+    Character* const global_buffer       = get_tmpfile_buffer_nolock<Character>(buffer_id);
+    size_t     const global_buffer_count = L_tmpnam;
+
+    if (!global_buffer)
+    {
+        return ENOMEM;
+    }
+
+    // Initialize the tmpnam buffer if it has not yet been initialized.
+    // Otherwise, generate the next file name:
+    if (global_buffer[0] == 0)
+    {
+        initialize_tmpfile_buffer_nolock<Character>(buffer_id);
+    }
+    else if (!generate_tmpfile_file_name(global_buffer, global_buffer_count))
+    {
+        return ENOENT;
+    }
+
+    // Generate a file name that does not already exist:
+    while (stdio_traits::taccess_s(global_buffer, 0) == 0)
+    {
+        if (!generate_tmpfile_file_name(global_buffer, global_buffer_count))
+        {
+            return ENOENT;
+        }
+    }
+
+    // If the result buffer is non-null, copy the file name there, if it will fit:
+    if (result_buffer != nullptr)
+    {
+        if (buffer_id != buffer_id::tmpnam &&
+            stdio_traits::tcslen(global_buffer) >= result_buffer_count)
+        {
+            if (result_buffer_count != 0)
+            {
+                result_buffer[0] = 0;
+            }
+
+            return ERANGE;
+        }
+
+#pragma warning(suppress:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036 Prefast doesn't understand perfect forwarding.
+        _ERRCHECK(stdio_traits::tcscpy_s(result_buffer, result_buffer_count, global_buffer));
+
+        return 0;
+    }
+
+    // If the result buffer is null, use a buffer owned by the per-thread data:
+    _ASSERTE(buffer_id == buffer_id::tmpnam);
+
+    Character** const ptd_buffer = get_tmpnam_ptd_buffer(Character());
+    if (ptd_buffer == nullptr)
+    {
+        return ENOMEM;
+    }
+
+    if (*ptd_buffer == nullptr)
+    {
+        *ptd_buffer = _calloc_crt_t(Character, global_buffer_count).detach();
+        if (*ptd_buffer == nullptr)
+        {
+            return ENOMEM;
+        }
+    }
+
+    _ERRCHECK(stdio_traits::tcscpy_s(*ptd_buffer, global_buffer_count, global_buffer));
+    return 0;
+}
+
+
+
+// Generates a temporary file name that is unique in the directory specified by
+// the related macros in <stdio.h>.  Returns the file name in the result_buffer,
+// or in a per-thread buffer if the result_buffer is null.  Returns zero on
+// success; returns an error code and sets errno on failure.
+template <typename Character>
+_Success_(return == 0)
+static errno_t common_tmpnam(
+    _Out_writes_opt_z_(result_buffer_count) Character* const result_buffer,
+    _In_ size_t                                        const result_buffer_count,
+    _In_ buffer_id                                     const buffer_id,
+    _Outptr_result_z_                      Character** const result_pointer
+    ) throw()
+{
+    errno_t return_value = 0;
+
+    __acrt_lock(__acrt_tempnam_lock);
+    __try
+    {
+        errno_t const saved_errno = errno;
+
+        return_value = common_tmpnam_nolock(result_buffer, result_buffer_count, buffer_id);
+        if (return_value != 0)
+        {
+            *result_pointer = result_buffer;
+            errno = return_value;
+            __leave;
+        }
+
+        *result_pointer = result_buffer != nullptr
+            ? result_buffer
+            : *get_tmpnam_ptd_buffer(Character());
+
+        errno = saved_errno;
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_tempnam_lock);
+    }
+
+    return return_value;
+}
+
+
+
+_Success_(return == 0)
+static errno_t __cdecl common_tmpfile_nolock(_Out_ FILE** const stream, int const sh_flag) throw()
+{
+    char*  const global_buffer       = get_tmpfile_buffer_nolock<char>(buffer_id::tmpfile);
+    size_t const global_buffer_count = L_tmpnam;
+
+    if (!global_buffer)
+    {
+        return ENOMEM;
+    }
+
+    // Initialize the tmpfile buffer if it has not yet been initialized.
+    // Otherwise, generate the next file name:
+    if (*global_buffer == 0)
+    {
+        if (!initialize_tmpfile_buffer_nolock<char>(buffer_id::tmpfile))
+        {
+            return EINVAL; // REVIEW Which error?
+        }
+    }
+    else if (!generate_tmpfile_file_name(global_buffer, global_buffer_count))
+    {
+        return EINVAL; // REVIEW Which error?
+    }
+
+    __crt_stdio_stream const local_stream = __acrt_stdio_allocate_stream();
+    if (!local_stream.valid())
+    {
+        return EMFILE;
+    }
+
+    errno_t result = 0;
+
+    __try
+    {
+        errno_t const saved_errno = errno;
+        errno = 0;
+
+        // Create a temporary file.  Note that the loop below will only create a
+        // new file.  It will not open and truncate an existing behavior.  This
+        // behavior is permitted under ISO C.  The behavior implemented below is
+        // compatible with prior versions of the C Runtime and makes error
+        // checking easier.
+        int fh = 0;
+
+        int const open_flag       = _O_CREAT | _O_EXCL | _O_RDWR | _O_BINARY | _O_TEMPORARY;
+        int const permission_mode = _S_IREAD | _S_IWRITE;
+
+        while ((result = _sopen_s(&fh, global_buffer, open_flag, sh_flag, permission_mode)) == EEXIST)
+        {
+            if (!generate_tmpfile_file_name(global_buffer, global_buffer_count))
+            {
+                break;
+            }
+        }
+
+        if (errno == 0)
+        {
+            errno = saved_errno;
+        }
+
+        // Ensure that the loop above did indeed create the file:
+        if (fh == -1)
+        {
+            __leave;
+        }
+
+        // Initialize the stream:
+        local_stream->_tmpfname = _strdup_crt(global_buffer);
+        if (local_stream->_tmpfname == nullptr)
+        {
+            _close(fh);
+            result = ENOMEM;
+            __leave;
+        }
+
+        local_stream->_cnt  = 0;
+        local_stream->_base = nullptr;
+        local_stream->_ptr  = nullptr;
+        local_stream.set_flags(_commode | _IOUPDATE);
+        local_stream->_file = fh;
+        *stream = local_stream.public_stream();
+        result = 0;
+    }
+    __finally
+    {
+        // If we didn't complete initialization of the stream successfully, we
+        // must free the allocated stream:
+        if (local_stream->_file == -1)
+            __acrt_stdio_free_stream(local_stream);
+
+        local_stream.unlock();
+    }
+
+    return result;
+}
+
+
+
+_Success_(return == 0)
+static errno_t __cdecl common_tmpfile(_Out_ FILE** const stream, int const sh_flag) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(stream != nullptr, EINVAL);
+    *stream = nullptr;
+
+    errno_t return_value = 0;
+
+    __acrt_lock(__acrt_tempnam_lock);
+    __try
+    {
+        return_value = common_tmpfile_nolock(stream, sh_flag);
+        if (return_value != 0)
+        {
+            errno = return_value;
+        }
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_tempnam_lock);
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" errno_t __cdecl tmpnam_s(
+    char*  const result_buffer,
+    size_t const result_buffer_count
+    )
+{
+    char* result = nullptr;
+    _VALIDATE_RETURN_ERRCODE(result_buffer != nullptr, EINVAL);
+    return common_tmpnam(result_buffer, result_buffer_count, buffer_id::tmpnam_s, &result);
+}
+
+extern "C" errno_t __cdecl _wtmpnam_s(
+    wchar_t* const result_buffer,
+    size_t   const result_buffer_count
+    )
+{
+    wchar_t* result = nullptr;
+    _VALIDATE_RETURN_ERRCODE(result_buffer != nullptr, EINVAL);
+    return common_tmpnam(result_buffer, result_buffer_count, buffer_id::tmpnam_s, &result);
+}
+
+extern "C" char* __cdecl tmpnam(char* const result_buffer)
+{
+    char* result = nullptr;
+    common_tmpnam(result_buffer, L_tmpnam, buffer_id::tmpnam, &result);
+    return result;
+}
+
+extern "C" wchar_t* __cdecl _wtmpnam(wchar_t* const result_buffer)
+{
+    wchar_t* result = nullptr;
+    common_tmpnam(result_buffer, L_tmpnam, buffer_id::tmpnam, &result);
+    return result;
+}
+
+// Creates a temporary file with the file mode "w+b".  The file will be deleted
+// automatically when it is closed or when the program terminates normally.
+// On success, returns a stream; on failure, returns nullptr.
+extern "C" FILE* __cdecl tmpfile()
+{
+    FILE* stream = nullptr;
+    common_tmpfile(&stream, _SH_DENYNO);
+    return stream;
+}
+
+// Creates a temporary file with the file mode "w+b".  The file will be deleted
+// automatically when it is closed or when the program terminates normally.
+// On success, returns zero and '*stream' refers to the newly opened stream.
+// On failure, returns an error code and '*stream' is null.
+extern "C" errno_t __cdecl tmpfile_s(FILE** const stream)
+{
+    return common_tmpfile(stream, _SH_DENYRW);
+}
+
+
+
+// Ensure that _rmtmp is called during static CRT termination:
+#ifndef CRTDLL
+
+    extern "C" extern unsigned __acrt_tmpfile_used;
+
+    extern "C" void __acrt_force_use_of_tmpfile()
+    {
+        ++__acrt_tmpfile_used;
+    }
+
+#endif
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ungetc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ungetc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a11fa256f99bafc7eba771e6dc5b055708186d80
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ungetc.cpp	
@@ -0,0 +1,92 @@
+//
+// ungetc.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines ungetc(), which pushes a character back into a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Pushes a character ("ungets" it) back into a stream.  It is possible to push
+// back one character.  It may not be possible to push back more than one
+// character in a row.  Returns the pushed-back character on success; returns
+// EOF on failure.  Ungetting EOF is expressly forbidden.
+extern "C" int __cdecl ungetc(int const c, FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, EOF);
+
+    int return_value = EOF;
+
+    _lock_file(stream);
+    __try
+    {
+        return_value = _ungetc_nolock(c, stream);
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
+
+
+
+extern "C" int __cdecl _ungetc_nolock(int const c, FILE* public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    _VALIDATE_STREAM_ANSI_RETURN(stream, EINVAL, EOF);
+
+    // Ungetting EOF is expressly forbidden:
+    if (c == EOF)
+        return EOF;
+
+    // The stream must either be open in read-only mode, or must be open in
+    // read-write mode and must not currently be in write mode:
+    bool const is_in_read_only_mode = stream.has_all_of(_IOREAD);
+    bool const is_in_rw_write_mode =  stream.has_all_of(_IOUPDATE | _IOWRITE);
+
+    if (!is_in_read_only_mode && !is_in_rw_write_mode)
+        return EOF;
+
+    // If the stream is currently unbuffered, buffer it:
+    if (stream->_base == nullptr)
+        __acrt_stdio_allocate_buffer_nolock(stream.public_stream());
+
+    // At this point, we know that _base is not null, since the file is buffered.
+
+    if (stream->_ptr == stream->_base)
+    {
+        // If we've already buffered a pushed-back character, there's no room for
+        // another, and there's nothing we can do:
+        if (stream->_cnt)
+            return EOF;
+
+        ++stream->_ptr;
+    }
+
+    // If the stream is string-backed (and not file-backed), do not modify the buffer:
+    if (stream.is_string_backed())
+    {
+        --stream->_ptr;
+        if (*stream->_ptr != static_cast<char>(c))
+        {
+            ++stream->_ptr;
+            return EOF;
+        }
+    }
+    else
+    {
+        --stream->_ptr;
+        *stream->_ptr = static_cast<char>(c);
+    }
+
+    ++stream->_cnt;
+    stream.unset_flags(_IOEOF);
+    stream.set_flags(_IOREAD);
+
+    return c & 0xff;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ungetwc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ungetwc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..51cf71757fe288930b312ca9e2268248b0e9c0d1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdio/ungetwc.cpp	
@@ -0,0 +1,181 @@
+//
+// ungetwc.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines ungetwc(), which pushes a wide character back into a stream.
+//
+#include <corecrt_internal_stdio.h>
+
+
+
+// Pushes a character ("ungets" it) back into a stream.  It is possible to push
+// back one character.  It may not be possible to push back more than one
+// character in a row.  Returns the pushed-back character on success; returns
+// WEOF on failure.  Ungetting WEOF is expressly forbidden.
+extern "C" wint_t __cdecl ungetwc(wint_t const c, FILE* const stream)
+{
+    _VALIDATE_RETURN(stream != nullptr, EINVAL, WEOF);
+
+    wint_t return_value = WEOF;
+
+    _lock_file(stream);
+    __try
+    {
+        return_value = _ungetwc_nolock(c, stream);
+    }
+    __finally
+    {
+        _unlock_file(stream);
+    }
+
+    return return_value;
+}
+
+
+
+// Helper function for _ungetwc_nolock() that handles text mode ungetting.
+static wint_t __cdecl ungetwc_text_mode_nolock(wint_t const c, __crt_stdio_stream const stream) throw()
+{
+    // The stream is open in text mode, and we need to do the unget differently
+    // depending on whether the stream is open in ANSI or Unicode mode.
+    __crt_lowio_text_mode const text_mode = _textmode_safe(_fileno(stream.public_stream()));
+
+    int  count = 0;
+    char characters[MB_LEN_MAX] = { 0 };
+
+    // If the file is open in ANSI mode, we need to convert the wide character
+    // to multibyte so that we can unget the multibyte character back into the
+    // stream:
+    if (text_mode == __crt_lowio_text_mode::ansi)
+    {
+        // If conversion fails, errno is set by wctomb_s and we can just return:
+        if (wctomb_s(&count, characters, MB_LEN_MAX, c) != 0)
+            return WEOF;
+    }
+    // Otherwise, the file is open in Unicode mode.  This means the characters
+    // in the stream were originally Unicode (and not multibyte).  Hence, we
+    // do not need to translate back to multibyte.  This is true for both UTF-16
+    // and UTF-8, because the lowio read converts UTF-8 data to UTF-16.
+    else
+    {
+        char const* c_bytes = reinterpret_cast<char const*>(&c);
+        characters[0] = c_bytes[0];
+        characters[1] = c_bytes[1];
+        count = 2;
+    }
+
+    // At this point, the file must be buffered, so we know the base is non-null.
+    // First we need to ensure there is sufficient room in the buffer to store
+    // the translated data:
+    if (stream->_ptr < stream->_base + count)
+    {
+        if (stream->_cnt)
+            return WEOF;
+
+        if (count > stream->_bufsiz)
+            return WEOF;
+
+        stream->_ptr = count + stream->_base;
+    }
+
+    for (int i = count - 1; i >= 0; --i)
+    {
+        *--stream->_ptr = characters[i];
+    }
+
+    stream->_cnt += count;
+
+    stream.unset_flags(_IOEOF);
+    stream.set_flags(_IOREAD);
+    return static_cast<wint_t>(0xffff & c);
+}
+
+
+
+// Helper function for _ungetwc_nolock() that handles binary mode ungetting
+static wint_t __cdecl ungetwc_binary_mode_nolock(wint_t const c, __crt_stdio_stream const stream) throw()
+{
+    wchar_t const wide_c = static_cast<wchar_t>(c);
+
+    // At this point, the file must be buffered, so we know the base is non-null.
+    // First, we need to ensure there is sufficient room in the buffer to store
+    // the character:
+    if (stream->_ptr < stream->_base + sizeof(wchar_t))
+    {
+        // If we've already ungotten one character and it has not yet been read,
+        // there may not be room for this unget.  In this case, there's nothing
+        // we can do so we simply fail:
+        if (stream->_cnt)
+            return WEOF;
+
+        if (sizeof(wchar_t) > stream->_bufsiz)
+            return WEOF;
+
+        stream->_ptr = sizeof(wchar_t) + stream->_base;
+    }
+
+    wchar_t*& wide_stream_ptr = reinterpret_cast<wchar_t*&>(stream->_ptr);
+
+    // If the stream is string-backed, we cannot modify the buffer.  We retreat
+    // the stream pointer and test if the character being ungotten is the same
+    // as the character that was last read.  If they are the same, then we allow
+    // the unget (because we don't have to modify the buffer).  If they are not
+    // the same, then we re-advance the stream pointer and fail:
+    if (stream.is_string_backed())
+    {
+        if (*--wide_stream_ptr != wide_c)
+        {
+            ++wide_stream_ptr;
+            return WEOF;
+        }
+    }
+    // Otherwise, the stream is file-backed and open in binary mode, and we can
+    // just write the character to the front of the stream:
+    else
+    {
+        *--wide_stream_ptr = wide_c;
+    }
+
+    stream->_cnt += sizeof(wchar_t);
+
+    stream.unset_flags(_IOEOF);
+    stream.set_flags(_IOREAD);
+
+    return static_cast<wint_t>(wide_c);
+}
+
+
+
+extern "C" wint_t __cdecl _ungetwc_nolock(wint_t const c, FILE* const public_stream)
+{
+    __crt_stdio_stream const stream(public_stream);
+
+    // Ungetting WEOF is expressly forbidden:
+    if (c == WEOF)
+        return WEOF;
+
+    // To unget, the stream must currently be in read mode, _or_ it must be open
+    // for update (read and write) and must not _currently_ be in write mode:
+    bool const is_in_read_mode   = stream.has_all_of(_IOREAD);
+    bool const is_in_update_mode = stream.has_all_of(_IOUPDATE);
+    bool const is_in_write_mode  = stream.has_all_of(_IOWRITE);
+
+    if (!is_in_read_mode && !(is_in_update_mode && !is_in_write_mode))
+        return WEOF;
+
+    // If the stream is currently unbuffered, buffer it:
+    if (stream->_base == nullptr)
+        __acrt_stdio_allocate_buffer_nolock(stream.public_stream());
+
+    // If the stream is file-backed and is open in text mode, we need to perform
+    // text mode translations:
+    if (!stream.is_string_backed() && (_osfile_safe(_fileno(stream.public_stream())) & FTEXT) != 0)
+    {
+        return ungetwc_text_mode_nolock(c, stream);
+    }
+
+    // Otherwise, the stream is string-backed or is a file-backed file open in
+    // binary mode; we can simply push the character back into the stream:
+    return ungetwc_binary_mode_nolock(c, stream);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/abs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/abs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..21ba655a19f1eaafc86c7d85e6905a5746701bcd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/abs.cpp	
@@ -0,0 +1,24 @@
+//
+// abs.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines abs() and _abs64(), which compute the absolute value of a number.
+//
+#include <stdlib.h>
+
+
+
+#pragma function(abs, _abs64)
+
+
+
+extern "C" int __cdecl abs(int const number)
+{
+    return number >= 0 ? number : -number;
+}
+
+extern "C" __int64 __cdecl _abs64(__int64 const number)
+{
+    return number >= 0 ? number : -number;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/bsearch.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/bsearch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d75c282c8dc7d29c5f6b78e00d6ed98b018d9190
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/bsearch.cpp	
@@ -0,0 +1,130 @@
+//
+// bsearch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines bsearch(), which performs a binary search over an array.
+//
+#include <corecrt_internal.h>
+#include <search.h>
+#include <cfguard.h>
+
+#ifdef _M_CEE
+    #define __fileDECL __clrcall
+#else
+    #define __fileDECL __cdecl
+#endif
+
+/***
+*char *bsearch() - do a binary search on an array
+*
+*Purpose:
+*   Does a binary search of a sorted array for a key.
+*
+*Entry:
+*   const char *key    - key to search for
+*   const char *base   - base of sorted array to search
+*   unsigned int num   - number of elements in array
+*   unsigned int width - number of bytes per element
+*   int (*compare)()   - pointer to function that compares two array
+*           elements, returning neg when #1 < #2, pos when #1 > #2, and
+*           0 when they are equal. Function is passed pointers to two
+*           array elements.
+*
+*Exit:
+*   if key is found:
+*           returns pointer to occurrence of key in array
+*   if key is not found:
+*           returns nullptr
+*
+*Exceptions:
+*   Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+#ifdef __USE_CONTEXT
+    #define __COMPARE(context, p1, p2) (*compare)(context, p1, p2)
+#else
+    #define __COMPARE(context, p1, p2) (*compare)(p1, p2)
+#endif
+
+#ifndef _M_CEE
+extern "C"
+DECLSPEC_GUARDNOCF
+#endif
+
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+#ifdef __USE_CONTEXT
+void* __fileDECL bsearch_s(
+    void const* const key,
+    void const* const base,
+    size_t            num,
+    size_t      const width,
+    int (__fileDECL* const compare)(void*, void const*, void const*),
+    void*       const context
+    )
+#else // __USE_CONTEXT
+void* __fileDECL bsearch(
+    void const* const key,
+    void const* const base,
+    size_t            num,
+    size_t      const width,
+    int (__fileDECL* const compare)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+    _VALIDATE_RETURN(base != nullptr || num == 0, EINVAL, nullptr);
+    _VALIDATE_RETURN(width > 0, EINVAL, nullptr);
+    _VALIDATE_RETURN(compare != nullptr, EINVAL, nullptr);
+
+    _GUARD_CHECK_ICALL(compare);
+
+    char const* lo = reinterpret_cast<char const*>(base);
+    char const* hi = reinterpret_cast<char const*>(base) + (num - 1) * width;
+
+    // Reentrancy diligence: Save (and unset) global-state mode to the stack before making callout to 'compare'
+    __crt_state_management::scoped_global_state_reset saved_state;
+
+    // We allow a nullptr key here because it breaks some older code and because
+    // we do not dereference this ourselves so we can't be sure that it's a
+    // problem for the comparison function
+
+    while (lo <= hi)
+    {
+        size_t const half = num / 2;
+        if (half != 0)
+        {
+            char const* const mid = lo + (num & 1 ? half : (half - 1)) * width;
+
+            int const result = __COMPARE(context, key, mid);
+            if (result == 0)
+            {
+                return const_cast<void*>(static_cast<void const*>(mid));
+            }
+            else if (result < 0)
+            {
+                hi = mid - width;
+                num = num & 1 ? half : half - 1;
+            }
+            else
+            {
+                lo = mid + width;
+                num = half;
+            }
+        }
+        else if (num != 0)
+        {
+            return __COMPARE(context, key, lo)
+                ? nullptr
+                : const_cast<void*>(static_cast<void const*>(lo));
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return nullptr;
+}
+
+#undef __COMPARE
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/bsearch_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/bsearch_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f521794f18955729729a4bc9a648afae423b2778
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/bsearch_s.cpp	
@@ -0,0 +1,13 @@
+//
+// bsearch_s.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _bsearch_s(), which performs a binary search over an array.
+//
+#ifdef __USE_CONTEXT
+    #error __USE_CONTEXT should be undefined
+#endif
+
+#define __USE_CONTEXT
+#include "bsearch.cpp"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/byteswap.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/byteswap.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2609b30abe96ab363938bb3e7e73330bc25e1834
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/byteswap.cpp	
@@ -0,0 +1,62 @@
+//
+// byteswap.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines functions that swap the bytes of an unsigned integer.
+//
+#include <stdlib.h>
+
+
+
+#pragma function(_byteswap_ulong, _byteswap_uint64, _byteswap_ushort)
+
+/***
+*unsigned long _byteswap_ulong(i) - long byteswap
+*
+*Purpose:
+*       Performs a byte swap on an unsigned integer.
+*
+*Entry:
+*       unsigned long i:        value to swap
+*
+*Exit:
+*       returns swaped
+*
+*Exceptions:
+*       None.
+*
+*******************************************************************************/
+
+extern "C" unsigned long __cdecl _byteswap_ulong(unsigned long const i)
+{
+    unsigned int j;
+    j =  (i << 24);
+    j += (i <<  8) & 0x00FF0000;
+    j += (i >>  8) & 0x0000FF00;
+    j += (i >> 24);
+    return j;
+}
+
+extern "C" unsigned short __cdecl _byteswap_ushort(unsigned short const i)
+{
+    unsigned short j;
+    j =  (i << 8);
+    j += (i >> 8);
+    return j;
+}
+
+extern "C" unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64 const i)
+{
+    unsigned __int64 j;
+    j =  (i << 56);
+    j += (i << 40) & 0x00FF000000000000;
+    j += (i << 24) & 0x0000FF0000000000;
+    j += (i <<  8) & 0x000000FF00000000;
+    j += (i >>  8) & 0x00000000FF000000;
+    j += (i >> 24) & 0x0000000000FF0000;
+    j += (i >> 40) & 0x000000000000FF00;
+    j += (i >> 56);
+    return j;
+
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/div.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/div.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..077ac6355b6ce1e3ff1d3cdf60492d4e0f1ffdf9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/div.cpp	
@@ -0,0 +1,23 @@
+//
+// div.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines div(), which performs a signed divide and returns the quotient and
+// remainder.  No validation of the arguments is done.
+//
+#include <stdlib.h>
+
+
+#ifdef  _MSC_VER
+#pragma function(div)
+#endif
+extern "C" div_t __cdecl div(int const numerator, int const denominator)
+{
+    div_t result;
+
+    result.quot = numerator / denominator;
+    result.rem = numerator % denominator;
+
+    return result;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/imaxabs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/imaxabs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d548743000c298c92eae2261666e449529dec16
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/imaxabs.cpp	
@@ -0,0 +1,22 @@
+//
+// imaxabs.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines imaxabs(), which computes the absolute value of an intmax_t.
+//
+#include <inttypes.h>
+
+
+
+extern "C" intmax_t __cdecl imaxabs(intmax_t const number)
+{
+    return number < 0 ? -number : number;
+}
+
+
+
+/*
+ * Copyright (c) 1992-2010 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+V5.30:0009 */
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/imaxdiv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/imaxdiv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8b92bf82b42761b06f1d0e4fccf554b1a2e6a50
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/imaxdiv.cpp	
@@ -0,0 +1,40 @@
+//
+// imaxdiv.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines imaxdiv(), which performs a signed divide using intmax_t operands
+// and returns the quotient and remainder.  No validation of the arguments is
+// done.
+//
+#include <inttypes.h>
+
+
+
+extern "C" imaxdiv_t __cdecl imaxdiv(intmax_t const numerator, intmax_t const denominator)
+{
+    imaxdiv_t result;
+
+    result.quot = numerator / denominator;
+    result.rem = numerator - denominator * result.quot;
+
+    // Fix incorrect truncation:
+    #pragma warning(push)
+    #pragma warning(disable: 4127)
+    static bool const fix_required = (-1 / 2) < 0;
+    if (fix_required && result.quot < 0 && result.rem != 0)
+    {
+        result.quot += 1;
+        result.rem -= denominator;
+    }
+    #pragma warning(pop)
+
+    return result;
+}
+
+
+
+/*
+ * Copyright (c) 1992-2010 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+V5.30:0009 */
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/labs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/labs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e889cf38691f1bbfeea53330b89fa246e225bafc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/labs.cpp	
@@ -0,0 +1,25 @@
+//
+// labs.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines labs(), which computes the absolute value of a number.
+//
+#include <stdlib.h>
+
+extern "C" {
+
+
+
+#pragma function(labs)
+
+
+
+long __cdecl labs(long const number)
+{
+	return number >= 0 ? number : -number;
+}
+
+
+
+} // extern "C"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/ldiv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/ldiv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c034f602a1a3effdc535d24908e35b93f76b6752
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/ldiv.cpp	
@@ -0,0 +1,23 @@
+//
+// ldiv.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines ldiv(), which performs a signed divide and returns the quotient and
+// remainder.  No validation of the arguments is done.
+//
+#include <stdlib.h>
+
+
+#ifdef  _MSC_VER
+#pragma function(ldiv)
+#endif
+extern "C" ldiv_t __cdecl ldiv(long const numerator, long const denominator)
+{
+    ldiv_t result;
+
+    result.quot = numerator / denominator;
+    result.rem = numerator % denominator;
+
+    return result;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lfind.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lfind.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49946e7b801ee0427ec2e401cecb3dc527578ce5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lfind.cpp	
@@ -0,0 +1,84 @@
+//
+// lfind.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lfind(), which performs a linear search over an array.
+//
+#include <corecrt_internal.h>
+#include <search.h>
+#include <cfguard.h>
+
+#ifdef _M_CEE
+    #define __fileDECL __clrcall
+#else
+    #define __fileDECL __cdecl
+#endif
+
+
+
+#ifdef __USE_CONTEXT
+    #define __COMPARE(context, p1, p2) (*compare)(context, p1, p2)
+#else
+    #define __COMPARE(context, p1, p2) (*compare)(p1, p2)
+#endif
+
+// Performs a linear search over the array, looking for the value 'key' in an
+// array of 'num' elements of 'width' bytes in size.  Returns a pointer to the
+// matching element if found.  Otherwise, returns nullptr.
+//
+// Parameters:
+//  * key:   The key for which to search
+//  * base:  A pointer to the initial element of the array to be searched
+//  * num:   The number of elements in the array.
+//  * width: The size of each element, in bytes.
+//  * comp:  Pointer to a function returning analog of strcmp for strings, but
+//           supplied by the caller for comparing the array elements.  It
+//           accepts two pointers to elements; returns negative if 1 < 2;
+//           zero if 1 == 2, and positive if 1 > 2.
+#ifndef _M_CEE
+extern "C"
+DECLSPEC_GUARDNOCF
+#endif
+#ifdef __USE_CONTEXT
+void* __fileDECL _lfind_s(
+    void const*   const key,
+    void const*   const base,
+    unsigned int* const num,
+    size_t        const width,
+    int (__fileDECL* const compare)(void*, void const*, void const*),
+    void*         const context
+    )
+#else // __USE_CONTEXT
+void* __fileDECL _lfind(
+    void const*   const key,
+    void const*   const base,
+    unsigned int* const num,
+    unsigned int  const width,
+    int (__fileDECL* const compare)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+    _VALIDATE_RETURN(key != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(num != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(base != nullptr || *num == 0, EINVAL, nullptr);
+    _VALIDATE_RETURN(width > 0, EINVAL, nullptr);
+    _VALIDATE_RETURN(compare != nullptr, EINVAL, nullptr);
+
+    _GUARD_CHECK_ICALL(compare);
+
+    char const* const first = static_cast<char const*>(base);
+    char const* const last  = first + *num * width;
+
+    for (char const* p = first; p != last; p += width)
+    {
+        if (__COMPARE(context, key, const_cast<char*>(p)) == 0)
+        {
+            return const_cast<char*>(p);
+        }
+    }
+
+    return nullptr;
+}
+
+#undef __COMPARE
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lfind_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lfind_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4ae563b8a08294d51274384a66449fce8c27fa13
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lfind_s.cpp	
@@ -0,0 +1,13 @@
+//
+// lfind_s.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lfind_s(), which performs a linear search over an array.
+//
+#ifdef __USE_CONTEXT
+    #error __USE_CONTEXT should be undefined
+#endif
+
+#define __USE_CONTEXT
+#include "lfind.cpp"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/llabs.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/llabs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0f55700a768181ed90ee863de1fab83324f475a2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/llabs.cpp	
@@ -0,0 +1,19 @@
+//
+// llabs.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines llabs(), which computes the absolute value of a number.
+//
+#include <stdlib.h>
+
+
+
+#pragma function(llabs)
+
+
+
+extern "C" long long __cdecl llabs(long long const number)
+{
+	return number >= 0 ? number : -number;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lldiv.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lldiv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e282bc7eb5831d690ab01c9c26ae80f0fe9623d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lldiv.cpp	
@@ -0,0 +1,23 @@
+//
+// lldiv.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines lldiv(), which performs a signed divide and returns the quotient and
+// remainder.  No validation of the arguments is done.
+//
+#include <stdlib.h>
+
+
+#ifdef  _MSC_VER
+#pragma function(lldiv)
+#endif
+extern "C" lldiv_t __cdecl lldiv(long long const numerator, long long const denominator)
+{
+    lldiv_t result;
+
+    result.quot = numerator / denominator;
+    result.rem = numerator % denominator;
+
+    return result;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lsearch.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lsearch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53f213d3637d4d0bb122ffd6b567b37dd44f1160
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lsearch.cpp	
@@ -0,0 +1,95 @@
+//
+// lsearch.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lsearch(), which performs a linear search over an array, appending
+// the key to the end of the array if it is not found.
+//
+#include <corecrt_internal.h>
+#include <memory.h>
+#include <search.h>
+#include <cfguard.h>
+
+#ifdef _M_CEE
+    #define __fileDECL __clrcall
+#else
+    #define __fileDECL __cdecl
+#endif
+
+
+
+#ifdef __USE_CONTEXT
+    #define __COMPARE(context, p1, p2) (*compare)(context, p1, p2)
+#else
+    #define __COMPARE(context, p1, p2) (*compare)(p1, p2)
+#endif
+
+
+// Performs a linear search over the array, looking for the value 'key' in an
+// array of 'num' elements of 'width' bytes in size.  Returns a pointer to the
+// matching element if found.  Otherwise, adds a new element to the end of the
+// array, copied from 'key'.
+//
+// Parameters:
+//  * key:   The key for which to search
+//  * base:  A pointer to the initial element of the array to be searched
+//  * num:   A pointer to an integer containing the number of elements in the
+//           array.  If a new element is appended, this function increments the
+//           pointed-to value.
+//  * width: The size of each element, in bytes.
+//  * comp:  Pointer to a function returning analog of strcmp for strings, but
+//           supplied by the caller for comparing the array elements.  It
+//           accepts two pointers to elements; returns negative if 1 < 2;
+//           zero if 1 == 2, and positive if 1 > 2.
+#ifndef _M_CEE
+extern "C"
+DECLSPEC_GUARDNOCF
+#endif
+#ifdef __USE_CONTEXT
+void* __fileDECL _lsearch_s(
+    void const*   const key,
+    void*         const base,
+    unsigned int* const num,
+    size_t        const width,
+    int (__fileDECL* compare)(void*, void const*, void const*),
+    void*         const context
+    )
+#else // __USE_CONTEXT
+void* __fileDECL _lsearch(
+    const void*   const key,
+    void*         const base,
+    unsigned int* const num,
+    unsigned int  const width,
+    int (__fileDECL* compare)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+    _VALIDATE_RETURN(key != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(num != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(base != nullptr, EINVAL, nullptr);
+    _VALIDATE_RETURN(width > 0, EINVAL, nullptr);
+    _VALIDATE_RETURN(compare != nullptr, EINVAL, nullptr);
+
+    _GUARD_CHECK_ICALL(compare);
+
+    char* const first = static_cast<char*>(base);
+    char* const last  = first + *num * width;
+
+    // Reentrancy diligence: Save (and unset) global-state mode to the stack before making callout to 'compare'
+    __crt_state_management::scoped_global_state_reset saved_state;
+
+    for (char* p = first; p != last; p += width)
+    {
+        if (__COMPARE(context, key, p) == 0)
+        {
+            return p;
+        }
+    }
+
+    memcpy(last, key, width);
+    ++(*num);
+    return last;
+}
+
+#undef __COMPARE
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lsearch_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lsearch_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2312b053e3fddd3576bd2bd61c1a79bef0e399ca
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/lsearch_s.cpp	
@@ -0,0 +1,14 @@
+//
+// lsearch_s.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lsearch_s(), which performs a linear search over an array, appending
+// the key to the end of the array if it is not found.
+//
+#ifdef __USE_CONTEXT
+    #error __USE_CONTEXT should be undefined
+#endif
+
+#define __USE_CONTEXT
+#include "lsearch.cpp"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/qsort.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/qsort.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b9a0228fc2140bb645493dedb6982312184a9775
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/qsort.cpp	
@@ -0,0 +1,431 @@
+//
+// qsort.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines qsort(), a routine for sorting arrays.
+//
+#include <corecrt_internal.h>
+#include <search.h>
+#include <cfguard.h>
+
+
+/* Temporarily define optimization macros (to be removed by the build team: RsmqblCompiler alias) */
+#if !defined(BEGIN_PRAGMA_OPTIMIZE_DISABLE)
+#define BEGIN_PRAGMA_OPTIMIZE_DISABLE(flags, bug, reason) \
+    __pragma(optimize(flags, off))
+#define BEGIN_PRAGMA_OPTIMIZE_ENABLE(flags, bug, reason) \
+    __pragma(optimize(flags, on))
+#define END_PRAGMA_OPTIMIZE() \
+    __pragma(optimize("", on))
+#endif
+
+
+// Always compile this module for speed, not size
+BEGIN_PRAGMA_OPTIMIZE_ENABLE("t", MSFT:4499497, "This file is performance-critical and should always be optimized for speed")
+
+
+
+#ifdef _M_CEE
+    #define __fileDECL __clrcall
+#else
+    #define __fileDECL __cdecl
+#endif
+
+
+
+#ifdef __USE_CONTEXT
+    #define __COMPARE(context, p1, p2)                comp(context, p1, p2)
+    #define __SHORTSORT(lo, hi, width, comp, context) shortsort_s(lo, hi, width, comp, context);
+#else
+    #define __COMPARE(context, p1, p2)                comp(p1, p2)
+    #define __SHORTSORT(lo, hi, width, comp, context) shortsort(lo, hi, width, comp);
+#endif
+
+
+// Used when building x64 versions of a function for use in Arm64 (to avoid Arm64EC transitions)
+#if !defined(_CRT_ARM64X_X64_BUILD)
+#define CRT_ARM64X_X64_NAME(name) name
+#else
+#define CRT_ARM64X_X64_NAME(name) name##_x64
+#endif
+
+
+// Swaps the objects of size 'width' that are pointed to by 'a' and 'b'
+#ifndef _QSORT_SWAP_DEFINED
+#define _QSORT_SWAP_DEFINED
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+static void __fileDECL swap(_Inout_updates_(width) char* a, _Inout_updates_(width) char* b, size_t width)
+{
+    if (a != b)
+    {
+        // Do the swap one character at a time to avoid potential alignment
+        // problems:
+        while (width--)
+        {
+            char const tmp = *a;
+            *a++ = *b;
+            *b++ = tmp;
+        }
+    }
+}
+#endif // _QSORT_SWAP_DEFINED
+
+
+
+// An insertion sort for sorting short arrays.  Sorts the sub-array of elements
+// between lo and hi (inclusive).  Assumes lo < hi.  lo and hi are pointers to
+// the first and last elements in the range to be sorted (note:  hi does not
+// point one-past-the-end).  The comp is a comparer with the same behavior as
+// specified for qsort.
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+DECLSPEC_GUARDNOCF
+#ifdef __USE_CONTEXT
+static void __fileDECL shortsort_s(
+    _Inout_updates_(hi - lo + 1) char*        lo,
+    _Inout_updates_(width)       char*        hi,
+    size_t const width,
+    int (__fileDECL* comp)(void*, void const*, void const*),
+    void*  const context
+    )
+#else // __USE_CONTEXT
+static void __fileDECL shortsort(
+    _Inout_updates_(hi - lo + 1) char*        lo,
+    _Inout_updates_(width)       char*        hi,
+    size_t const width,
+    int (__fileDECL* comp)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+    // Note: in assertions below, i and j are alway inside original bound of
+    // array to sort.
+
+    // Reentrancy diligence: Save (and unset) global-state mode to the stack before making callout to 'compare'
+    __crt_state_management::scoped_global_state_reset saved_state;
+
+    while (hi > lo)
+    {
+        // A[i] <= A[j] for i <= j, j > hi
+        char* max = lo;
+        for (char* p = lo+width; p <= hi; p += width)
+        {
+            // A[i] <= A[max] for lo <= i < p
+            if (__COMPARE(context, p, max) > 0)
+            {
+                max = p;
+            }
+            // A[i] <= A[max] for lo <= i <= p
+        }
+
+        // A[i] <= A[max] for lo <= i <= hi
+
+        swap(max, hi, width);
+
+        // A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi
+
+        hi -= width;
+
+        // A[i] <= A[j] for i <= j, j > hi, loop top condition established
+    }
+
+    // A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
+    // so array is sorted
+}
+
+
+
+// This macro defines the cutoff between using QuickSort and insertion sort for
+// arrays; arrays with lengths shorter or equal to the below value use insertion
+// sort.
+#define CUTOFF 8 // Testing shows that this is a good value.
+
+// Note:  The theoretical number of stack entries required is no more than 1 +
+// log2(num).  But we switch to insertion sort for CUTOFF elements or less, so
+// we really only need 1 + log2(num) - log(CUTOFF) stack entries.  For a CUTOFF
+// of 8, that means we need no more than 30 stack entries for 32-bit platforms
+// and 62 for 64-bit platforms.
+#define STKSIZ (8 * sizeof(void*) - 2)
+
+
+extern "C"
+#ifdef __USE_CONTEXT
+void __fileDECL qsort_s_x64(
+    void* const base, size_t const num, size_t const width, int(__fileDECL* const comp)(void*, void const*, void const*), void* const context);
+#else
+    void __fileDECL qsort_x64(void* const base, size_t const num, size_t const width, int (__fileDECL* const comp)(void const*, void const*));
+#endif
+
+// QuickSort function for sorting arrays.  The array is sorted in place.
+// Parameters:
+//  * base:  Pointer to the initial element of the array
+//  * num:   Number of elements in the array
+//  * width: Width of each element in the array, in bytes
+//  * comp:  Pointer to a function returning analog of strcmp for strings, but
+//           supplied by the caller for comparing the array elements.  It
+//           accepts two pointers to elements; returns negative if 1 < 2;
+//           zero if 1 == 2, and positive if 1 > 2.
+#ifndef _M_CEE
+extern "C"
+DECLSPEC_GUARDNOCF
+#endif
+_CRT_SECURITYSAFECRITICAL_ATTRIBUTE
+#ifdef __USE_CONTEXT
+void __fileDECL CRT_ARM64X_X64_NAME(qsort_s) (
+    void*  const base,
+    size_t const num,
+    size_t const width,
+    int (__fileDECL* const comp)(void*, void const*, void const*),
+    void*  const context
+    )
+#else // __USE_CONTEXT
+void __fileDECL CRT_ARM64X_X64_NAME(qsort) (
+    void*  const base,
+    size_t const num,
+    size_t const width,
+    int (__fileDECL* const comp)(void const*, void const*)
+    )
+#endif // __USE_CONTEXT
+{
+#if defined(_M_ARM64EC) && _UCRT_DLL
+    // When ucrtbase.dll is Arm64EC and the caller is passing an x64 compare
+    // function, making an Arm64EC->x64 transition for each comparison incurs
+    // non-trivial overhead.  It is much more efficient to just call the pure
+    // x64 implementation instead.
+
+    if (!RtlIsEcCode((ULONG_PTR)comp))
+    {
+#ifdef __USE_CONTEXT
+        return qsort_s_x64(base, num, width, comp, context);
+#else
+        return qsort_x64(base, num, width, comp);
+#endif
+    }
+#endif // defined(_M_ARM64EC) && _UCRT_DLL
+
+    _VALIDATE_RETURN_VOID(base != nullptr || num == 0, EINVAL);
+    _VALIDATE_RETURN_VOID(width > 0, EINVAL);
+    _VALIDATE_RETURN_VOID(comp != nullptr, EINVAL);
+
+    _GUARD_CHECK_ICALL(comp);
+
+    // A stack for saving the sub-arrays yet to be processed:
+    char* lostk[STKSIZ];
+    char* histk[STKSIZ];
+    int stkptr = 0;
+
+    if (num < 2)
+        return; // Nothing to do:
+
+    // The ends of the sub-array currently being sorted (note that 'hi' points
+    // to the last element, not one-past-the-end):
+    char* lo = static_cast<char*>(base);
+    char* hi = static_cast<char*>(base) + width * (num-1);
+
+    // This entry point is for pseudo-recursion calling: setting
+    // lo and hi and jumping to here is like recursion, but stkptr is
+    // preserved, locals aren't, so we preserve stuff on the stack.
+recurse:
+
+    // The number of elements in the sub-array currently being sorted:
+    size_t const size = (hi - lo) / width + 1;
+
+    // Below a certain size, it is faster to use a O(n^2) sorting method:
+    if (size <= CUTOFF)
+    {
+        __SHORTSORT(lo, hi, width, comp, context);
+    }
+    else
+    {
+        // First we pick a partitioning element.  The efficiency of the
+        // algorithm demands that we find one that is approximately the median
+        // of the values, but also that we select one fast.  We choose the
+        // median of the first, middle, and last elements, to avoid bad
+        // performance in the face of already sorted data, or data that is made
+        // up of multiple sorted runs appended together.  Testing shows that a
+        // median-of-three algorithm provides better performance than simply
+        // picking the middle element for the latter case.
+
+        // Find the middle element:
+        char* mid = lo + (size / 2) * width;
+
+        // Sort the first, middle, last elements into order:
+        if (__COMPARE(context, lo, mid) > 0)
+            swap(lo, mid, width);
+
+        if (__COMPARE(context, lo, hi) > 0)
+            swap(lo, hi, width);
+
+        if (__COMPARE(context, mid, hi) > 0)
+            swap(mid, hi, width);
+
+        // We now wish to partition the array into three pieces, one consisting
+        // of elements <= partition element, one of elements equal to the
+        // partition element, and one of elements > than it.  This is done
+        // below; comments indicate conditions established at every step.
+
+        char* loguy = lo;
+        char* higuy = hi;
+
+        // Note that higuy decreases and loguy increases on every iteration,
+        // so loop must terminate.
+        for (;;)
+        {
+            // lo <= loguy < hi, lo < higuy <= hi,
+            // A[i] <= A[mid] for lo <= i <= loguy,
+            // A[i] > A[mid] for higuy <= i < hi,
+            // A[hi] >= A[mid]
+
+            // The doubled loop is to avoid calling comp(mid,mid), since some
+            // existing comparison funcs don't work when passed the same
+            // value for both pointers.
+
+            if (mid > loguy)
+            {
+                do
+                {
+                    loguy += width;
+                }
+                while (loguy < mid && __COMPARE(context, loguy, mid) <= 0);
+            }
+            if (mid <= loguy)
+            {
+                do
+                {
+                    loguy += width;
+                }
+                while (loguy <= hi && __COMPARE(context, loguy, mid) <= 0);
+            }
+
+            // lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
+            // either loguy > hi or A[loguy] > A[mid]
+
+            do
+            {
+                higuy -= width;
+            }
+            while (higuy > mid && __COMPARE(context, higuy, mid) > 0);
+
+            // lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
+            // either higuy == lo or A[higuy] <= A[mid]
+
+            if (higuy < loguy)
+                break;
+
+            // if loguy > hi or higuy == lo, then we would have exited, so
+            // A[loguy] > A[mid], A[higuy] <= A[mid],
+            // loguy <= hi, higuy > lo
+
+            swap(loguy, higuy, width);
+
+            // If the partition element was moved, follow it.  Only need
+            // to check for mid == higuy, since before the swap,
+            // A[loguy] > A[mid] implies loguy != mid.
+
+            if (mid == higuy)
+                mid = loguy;
+
+            // A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
+            // of loop is re-established
+        }
+
+        //     A[i] <= A[mid] for lo <= i < loguy,
+        //     A[i] > A[mid] for higuy < i < hi,
+        //     A[hi] >= A[mid]
+        //     higuy < loguy
+        // implying:
+        //     higuy == loguy-1
+        //     or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid]
+
+        // Find adjacent elements equal to the partition element.  The
+        // doubled loop is to avoid calling comp(mid,mid), since some
+        // existing comparison funcs don't work when passed the same value
+        // for both pointers.
+
+        higuy += width;
+        if (mid < higuy)
+        {
+            do
+            {
+                higuy -= width;
+            }
+            while (higuy > mid && __COMPARE(context, higuy, mid) == 0);
+        }
+        if (mid >= higuy)
+        {
+            do
+            {
+                higuy -= width;
+            }
+            while (higuy > lo && __COMPARE(context, higuy, mid) == 0);
+        }
+
+        // OK, now we have the following:
+        //    higuy < loguy
+        //    lo <= higuy <= hi
+        //    A[i]  <= A[mid] for lo <= i <= higuy
+        //    A[i]  == A[mid] for higuy < i < loguy
+        //    A[i]  >  A[mid] for loguy <= i < hi
+        //    A[hi] >= A[mid] */
+
+        // We've finished the partition, now we want to sort the subarrays
+        // [lo, higuy] and [loguy, hi].
+        // We do the smaller one first to minimize stack usage.
+        // We only sort arrays of length 2 or more.
+
+        if (higuy - lo >= hi - loguy)
+        {
+            if (lo < higuy)
+            {
+                // Save the big recursion for later:
+                lostk[stkptr] = lo;
+                histk[stkptr] = higuy;
+                ++stkptr;
+            }
+
+            if (loguy < hi)
+            {
+                // Do the small recursion:
+                lo = loguy;
+                goto recurse;
+            }
+        }
+        else
+        {
+            if (loguy < hi)
+            {
+                // Save the big recursion for later:
+                lostk[stkptr] = loguy;
+                histk[stkptr] = hi;
+                ++stkptr;
+            }
+
+            if (lo < higuy)
+            {
+                // Do the small recursion:
+                hi = higuy;
+                goto recurse;
+            }
+        }
+    }
+
+    // We have sorted the array, except for any pending sorts on the stack.
+    // Check if there are any, and sort them:
+    --stkptr;
+    if (stkptr >= 0)
+    {
+        // Pop sub-array from the stack:
+        lo = lostk[stkptr];
+        hi = histk[stkptr];
+        goto recurse;
+    }
+    else
+    {
+        // Otherwise, all sub-arrays have been sorted:
+        return;
+    }
+}
+
+#undef __COMPARE
+#undef __SHORTSORT
+
+END_PRAGMA_OPTIMIZE()
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/qsort_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/qsort_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a16145b6d258db0d8c7de8ca1b580a3dfb754f25
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/qsort_s.cpp	
@@ -0,0 +1,13 @@
+//
+// qsort_s.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _qsort_s(), a routine for sorting arrays.
+//
+#ifdef __USE_CONTEXT
+    #error __USE_CONTEXT should be undefined
+#endif
+
+#define __USE_CONTEXT
+#include "qsort.cpp"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rand.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rand.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..605a0659374e78b2d0c7484fecf884de2380b3e7
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rand.cpp	
@@ -0,0 +1,28 @@
+//
+// rand.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines rand(), which generates psuedorandom numbers.
+//
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+
+
+// Seeds the random number generator with the provided integer.
+extern "C" void __cdecl srand(unsigned int const seed)
+{
+    __acrt_getptd()->_rand_state = seed;
+}
+
+
+
+// Returns a pseudorandom number in the range [0,32767].
+extern "C" int __cdecl rand()
+{
+    __acrt_ptd* const ptd = __acrt_getptd();
+
+    ptd->_rand_state = ptd->_rand_state * 214013 + 2531011;
+    return (ptd->_rand_state >> 16) & RAND_MAX;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rand_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rand_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d22531e861dcade6f9b70338908d87e0939c23e5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rand_s.cpp	
@@ -0,0 +1,25 @@
+//
+// rand_s.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The implementation of the rand_s() function, which generates random numbers.
+//
+#include <corecrt_internal.h>
+#include <stdlib.h>
+
+
+
+extern "C" errno_t __cdecl rand_s(unsigned int* const result)
+{
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+    *result = 0;
+
+    if (!__acrt_RtlGenRandom(result, static_cast<ULONG>(sizeof(*result))))
+    {
+        errno = ENOMEM;
+        return errno;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rotl.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rotl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..25c0f74aa67299deaabb5dc3f686c52be25efe34
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rotl.cpp	
@@ -0,0 +1,45 @@
+//
+// rotl.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lrotl(), _rotl(), and _rotl64(), which perform a rotate-left on an
+// integer.
+//
+#include <stdlib.h>
+#include <limits.h>
+
+
+
+#pragma function(_lrotl, _rotl, _rotl64)
+
+#if UINT_MAX != 0xffffffff
+    #error This source file assumes 32-bit integers
+#endif
+
+#if UINT_MAX != ULONG_MAX
+    #error This source file assumes sizeof(int) == sizeof(long)
+#endif
+
+
+
+extern "C" unsigned long __cdecl _lrotl(unsigned long value, int shift)
+{
+    shift &= 0x1f;
+    value = (value >> (0x20 - shift)) | (value << shift);
+    return value;
+}
+
+extern "C" unsigned __cdecl _rotl(unsigned value, int shift)
+{
+    shift &= 0x1f;
+    value = (value >> (0x20 - shift)) | (value << shift);
+    return value;
+}
+
+extern "C" unsigned __int64 __cdecl _rotl64(unsigned __int64 value, int shift)
+{
+    shift &= 0x3f;
+    value = (value >> (0x40 - shift)) | (value << shift);
+    return value;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rotr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rotr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb9ddff7417c6cd1d5aa040964972193538f0f54
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/stdlib/rotr.cpp	
@@ -0,0 +1,45 @@
+//
+// rotr.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines _lrotl(), _rotl(), and _rotl64(), which perform a rotate-right on an
+// integer.
+//
+#include <stdlib.h>
+#include <limits.h>
+
+
+
+#pragma function(_lrotr, _rotr, _rotr64)
+
+#if UINT_MAX != 0xffffffff
+    #error This source file assumes 32-bit integers
+#endif
+
+#if UINT_MAX != ULONG_MAX
+    #error This source file assumes sizeof(int) == sizeof(long)
+#endif
+
+
+
+extern "C" unsigned long __cdecl _lrotr(unsigned long value, int shift)
+{
+    shift &= 0x1f;
+    value = (value << (0x20 - shift)) | (value >> shift);
+    return value;
+}
+
+extern "C" unsigned __cdecl _rotr(unsigned value, int shift)
+{
+    shift &= 0x1f;
+    value = (value << (0x20 - shift)) | (value >> shift);
+    return value;
+}
+
+extern "C" unsigned __int64 __cdecl _rotr64(unsigned __int64 value, int shift)
+{
+    shift &= 0x3f;
+    value = (value << (0x40 - shift)) | (value >> shift);
+    return value;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcat.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcat.asm
new file mode 100644
index 0000000000000000000000000000000000000000..bb226c18c9dfc293137b8c68effe610f6f8dc816
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcat.asm	
@@ -0,0 +1,237 @@
+        title   strcat - concatenate (append) one string to another
+;***
+;strcat.asm - contains strcat() and strcpy() routines
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       STRCAT concatenates (appends) a copy of the source string to the
+;       end of the destination string, returning the destination string.
+;
+;*******************************************************************************
+include ksamd64.inc
+        subttl  "strcat"
+;***
+;char *strcat(dst, src) - concatenate (append) one string to another
+;
+;Purpose:
+;       Concatenates src onto the end of dest.  Assumes enough
+;       space in dest.
+;
+;       Algorithm:
+;       char * strcat (char * dst, char * src)
+;       {
+;           char * cp = dst;
+;
+;           while( *cp )
+;                   ++cp;           /* Find end of dst */
+;           while( *cp++ = *src++ )
+;                   ;               /* Copy src to end of dst */
+;           return( dst );
+;       }
+;
+;Entry:
+;       char *dst - string to which "src" is to be appended
+;       const char *src - string to be appended to the end of "dst"
+;
+;Exit:
+;       The address of "dst" in EAX
+;
+;Uses:
+;       EAX, ECX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+;***
+;char *strcpy(dst, src) - copy one string over another
+;
+;Purpose:
+;       Copies the string src into the spot specified by
+;       dest; assumes enough room.
+;
+;       Algorithm:
+;       char * strcpy (char * dst, char * src)
+;       {
+;           char * cp = dst;
+;
+;           while( *cp++ = *src++ )
+;                   ;               /* Copy src over dst */
+;           return( dst );
+;       }
+;
+;Entry:
+;       char * dst - string over which "src" is to be copied
+;       const char * src - string to be copied over "dst"
+;
+;Exit:
+;       The address of "dst" in EAX
+;
+;Uses:
+;       EAX, ECX
+;
+;Exceptions:
+;*******************************************************************************
+
+public ___entry_from_strcat_in_strcpy
+
+ifdef _CRT_FFS_BUILD
+strcat_name     TEXTEQU <strcat_ffs>
+else
+strcat_name     TEXTEQU <strcat>
+endif
+
+LEAF_ENTRY_ARG2 strcat_name, _TEXT$21, dst:ptr byte, src:ptr byte
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+    mov     r11, rcx
+    test    cl, 7
+    jz      strcat_loop_begin
+
+strcat_copy_head_loop_begin:
+    mov     al, [rcx]
+    test    al, al
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    test    cl, 7
+    jnz     strcat_copy_head_loop_begin
+
+strcat_loop_begin:
+    mov     rax, [rcx]
+    mov     r10, rax
+    mov     r9, 7efefefefefefeffh
+    add     r9, r10
+    xor     r10, -1
+    xor     r10, r9
+    add     rcx, 8
+    mov     r9, 8101010101010100h
+    test    r10, r9
+    je      strcat_loop_begin
+    sub     rcx, 8
+
+strcat_loop_end:
+    test    al, al
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    test    ah, ah
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    shr     rax, 16
+    test    al, al
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    test    ah, ah
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    shr     rax, 16
+    test    al, al
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    test    ah, ah
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    shr     eax, 16
+    test    al, al
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    test    ah, ah
+    jz      ___entry_from_strcat_in_strcpy
+    inc     rcx
+    jmp     strcat_loop_begin
+
+LEAF_END strcat_name, _TEXT$21
+
+ifdef _CRT_FFS_BUILD
+strcpy_name      TEXTEQU <strcpy_ffs>
+else
+strcpy_name      TEXTEQU <strcpy>
+endif
+
+LEAF_ENTRY_ARG2 strcpy_name, _TEXT$21, dst:ptr byte, src:ptr byte
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+    mov     r11, rcx
+strcat_copy:
+___entry_from_strcat_in_strcpy=strcat_copy
+ ; align the SOURCE so we never page fault
+ ; dest pointer alignment not important
+    sub     rcx, rdx ; combine pointers
+    test    dl, 7
+    jz      qword_loop_entrance
+
+copy_head_loop_begin:
+    mov     al, [rdx]
+    mov     [rdx+rcx], al
+    test    al, al
+    jz      byte_exit
+    inc     rdx
+    test    dl, 7
+    jnz     copy_head_loop_begin
+    jmp     qword_loop_entrance
+
+byte_exit:
+    mov     rax, r11
+    ret
+
+qword_loop_begin:
+    mov     [rdx+rcx], rax
+    add     rdx, 8
+qword_loop_entrance:
+    mov     rax, [rdx]
+    mov     r9, 7efefefefefefeffh
+    add     r9, rax
+    mov     r10, rax
+    xor     r10, -1
+    xor     r10, r9
+    mov     r9, 8101010101010100h
+    test    r10, r9
+    jz      qword_loop_begin
+
+qword_loop_end:
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strcat_exit
+    inc     rdx
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strcat_exit
+    inc     rdx
+    shr     rax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strcat_exit
+    inc     rdx
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strcat_exit
+    inc     rdx
+    shr     rax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strcat_exit
+    inc     rdx
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strcat_exit
+    inc     rdx
+    shr     eax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strcat_exit
+    inc     rdx
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strcat_exit
+    inc     rdx
+    jmp     qword_loop_entrance
+
+strcat_exit:
+    mov     rax, r11
+    ret
+
+LEAF_END strcpy_name, _TEXT$21
+
+    end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..2e90cc41f6f4418bf2ecc28f674d130166bff149
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcmp.asm	
@@ -0,0 +1,136 @@
+        page    ,132
+        title   strcmp.asm - compare two strings
+;***
+;strcmp.asm - routine to compare two strings (for equal, less, or greater)
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       STRCMP compares two strings and returns an integer
+;       to indicate whether the first is less than the second, the two are
+;       equal, or whether the first is greater than the second, respectively.
+;       Comparison is done byte by byte on an UNSIGNED basis, which is to
+;       say that Null (0) is less than any other character (1-255).
+;
+;*******************************************************************************
+include ksamd64.inc
+        subttl  "strcmp"
+;***
+;strcmp - compare two strings, returning less than, equal to, or greater than
+;
+;Purpose:
+;       Compares two string, determining their ordinal order.  Unsigned
+;       comparison is used.
+;
+;       Algorithm:
+;          int strcmp ( src , dst )
+;                  unsigned char *src;
+;                  unsigned char *dst;
+;          {
+;                  int ret = 0 ;
+;
+;                  while( ! (ret = *src - *dst) && *dst)
+;                          ++src, ++dst;
+;
+;                  if ( ret < 0 )
+;                          ret = -1 ;
+;                  else if ( ret > 0 )
+;                          ret = 1 ;
+;
+;                  return( ret );
+;          }
+;
+;Entry:
+;       const char * src - string for left-hand side of comparison
+;       const char * dst - string for right-hand side of comparison
+;
+;Exit:
+;       AX < 0, 0, or >0, indicating whether the first string is
+;       Less than, Equal to, or Greater than the second string.
+;
+;Uses:
+;       CX, DX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+CHAR_TYPE EQU BYTE
+CHAR_PTR EQU BYTE PTR
+CHAR_SIZE = sizeof CHAR_TYPE
+
+BLK_TYPE EQU QWORD
+BLK_PTR EQU QWORD PTR
+BLK_SIZE = sizeof BLK_TYPE
+
+;PAGE_SIZE = 1000h
+PAGE_MASK = PAGE_SIZE - 1       ; mask for offset in MM page
+PAGE_SAFE_BLK = PAGE_SIZE - BLK_SIZE ; maximum offset for safe block compare
+
+ifdef _CRT_FFS_BUILD
+fname      TEXTEQU <strcmp_ffs>
+else
+fname      TEXTEQU <strcmp>
+endif
+
+LEAF_ENTRY_ARG2 fname, _TEXT$21, str1:ptr byte, str2:ptr byte
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+; rcx = src
+; rdx = dst
+
+    sub     rdx, rcx
+    test    cl, (BLK_SIZE - 1)
+    jz      qword_loop_enter
+
+comp_head_loop_begin:
+    movzx   eax, CHAR_PTR[rcx]
+    cmp     al, CHAR_PTR[rdx+rcx]
+    jnz     return_not_equal
+
+    inc     rcx
+
+    test    al, al
+    jz      return_equal
+
+    test    cl, (BLK_SIZE - 1)
+    jnz     comp_head_loop_begin
+
+qword_loop_enter:
+
+    mov     r11, 8080808080808080h
+    mov     r10, 0fefefefefefefeffh
+
+qword_loop_begin:
+    lea     eax, [edx+ecx]
+    and     eax, PAGE_MASK
+    cmp     eax, PAGE_SAFE_BLK
+    ja      comp_head_loop_begin
+
+    mov     rax, BLK_PTR[rcx]
+    cmp     rax, BLK_PTR[rdx+rcx]
+
+; mismatched string (or maybe null + garbage after)
+    jne     comp_head_loop_begin
+
+; look for null terminator
+    lea     r9, [rax + r10]
+    not     rax
+    add     rcx, BLK_SIZE
+    and     rax, r9
+
+    test    rax, r11       ; r11=8080808080808080h
+    jz      qword_loop_begin
+
+return_equal:
+    xor     eax, eax ; gets all 64 bits
+    ret
+
+return_not_equal:
+    sbb     rax, rax ; AX=-1, CY=1 AX=0, CY=0
+    or      rax, 1
+    ret
+
+LEAF_END fname, _TEXT$21
+end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcspn.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcspn.c
new file mode 100644
index 0000000000000000000000000000000000000000..f6b89ef9145b34c7b02d389db670320d5a110981
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strcspn.c	
@@ -0,0 +1,13 @@
+/***
+*strcspn.c - Defines the strcspn function.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       The function strcspn is mostly common code with strspn in strspn.c. 
+*
+*******************************************************************************/
+
+#define SSTRCSPN
+#define STRSPN_USE_SSE2
+#include "strspn.c"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strlen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strlen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..411d37b09512a83dcdb28e99e2c7cf5216ca69b3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strlen.asm	
@@ -0,0 +1,136 @@
+        page    ,132
+        title   strlen - return the length of a null-terminated string
+;***
+;strlen.asm - contains strlen() routine
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       strlen returns the length of a null-terminated string,
+;       not including the null byte itself.
+;
+;*******************************************************************************
+include ksamd64.inc
+        subttl  "strlen"
+;***
+;strlen - return the length of a null-terminated string
+;
+;Purpose:
+;       Finds the length in bytes of the given string, not including
+;       the final null character.
+;
+;       Algorithm:
+;       int strlen (const char * str)
+;       {
+;           int length = 0;
+;
+;           while( *str++ )
+;                   ++length;
+;
+;           return( length );
+;       }
+;
+;Entry:
+;       const char * str - string whose length is to be computed
+;
+;Exit:
+;       EAX = length of the string "str", exclusive of the final null byte
+;
+;Uses:
+;       EAX, ECX, EDX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+ifdef _CRT_FFS_BUILD
+fname      TEXTEQU <strlen_ffs>
+else
+fname      TEXTEQU <strlen>
+endif
+
+LEAF_ENTRY_ARG1 fname, _TEXT$21, buf:ptr byte
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+    mov   rax, rcx
+    neg   rcx          ; for later
+    test  rax, 7
+    jz    main_loop_entry
+
+byte 066h, 090h
+
+byte_loop_begin:
+    mov   dl, [rax]
+    inc   rax
+    test  dl, dl
+    jz    return_byte_7
+    test  al, 7
+    jnz   byte_loop_begin
+
+main_loop_entry:
+    mov   r8, 7efefefefefefeffh
+    mov   r11, 8101010101010100h
+
+main_loop_begin:
+    mov   rdx, [rax]
+
+    mov   r9,  r8
+    add   rax, 8
+    add   r9,  rdx
+    not   rdx
+    xor   rdx, r9
+    and   rdx, r11
+    je    main_loop_begin
+
+main_loop_end:
+
+    mov   rdx, [rax-8]
+
+    test  dl, dl
+    jz    return_byte_0
+    test  dh, dh
+    jz    return_byte_1
+    shr   rdx, 16
+    test  dl, dl
+    jz    return_byte_2
+    test  dh, dh
+    jz    return_byte_3
+    shr   rdx, 16
+    test  dl, dl
+    jz    return_byte_4
+    test  dh, dh
+    jz    return_byte_5
+    shr   edx, 16
+    test  dl, dl
+    jz    return_byte_6
+    test  dh, dh
+    jnz   main_loop_begin
+
+return_byte_7:
+    lea   rax, [rax+rcx-1]
+    ret
+return_byte_6:
+    lea   rax, [rax+rcx-2]
+    ret
+return_byte_5:
+    lea   rax, [rax+rcx-3]
+    ret
+return_byte_4:
+    lea   rax, [rax+rcx-4]
+    ret
+return_byte_3:
+    lea   rax, [rax+rcx-5]
+    ret
+return_byte_2:
+    lea   rax, [rax+rcx-6]
+    ret
+return_byte_1:
+    lea   rax, [rax+rcx-7]
+    ret
+return_byte_0:
+    lea   rax, [rax+rcx-8]
+    ret
+
+LEAF_END fname, _TEXT$21
+    end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncat.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncat.asm
new file mode 100644
index 0000000000000000000000000000000000000000..1712eb54a54ba1cdb8da10b40a47d07c199b2a78
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncat.asm	
@@ -0,0 +1,235 @@
+        page    ,132
+        title   strncat - append n chars of string1 to string2
+;***
+;strncat.asm - append n chars of string to new string
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines strncat() - appends n characters of string onto
+;       end of other string
+;
+;*******************************************************************************
+include ksamd64.inc
+        subttl  "strncat"
+;***
+;char *strncat(front, back, count) - append count chars of back onto front
+;
+;Purpose:
+;       Appends at most count characters of the string back onto the
+;       end of front, and ALWAYS terminates with a null character.
+;       If count is greater than the length of back, the length of back
+;       is used instead.  (Unlike strncpy, this routine does not pad out
+;       to count characters).
+;
+;       Algorithm:
+;       char *
+;       strncat (front, back, count)
+;           char *front, *back;
+;           unsigned count;
+;       {
+;           char *start = front;
+;
+;           while (*front++)
+;               ;
+;           front--;
+;           while (count--)
+;               if (!(*front++ = *back++))
+;                   return(start);
+;           *front = '\0';
+;           return(start);
+;       }
+;
+;Entry:
+;       char *   front - string to append onto
+;       char *   back  - string to append
+;       unsigned count - count of max characters to append
+;
+;Exit:
+;       returns a pointer to string appended onto (front).
+;
+;Uses:  ECX, EDX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+ifdef _CRT_FFS_BUILD
+fname      TEXTEQU <strncat_ffs>
+else
+fname      TEXTEQU <strncat>
+endif
+
+LEAF_ENTRY_ARG3 fname, _TEXT$21, front:ptr byte, back:ptr byte, count:dword
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+    mov     r11, rcx
+    or      r8, r8
+    jz      byte_exit
+    test    cl, 7
+    jz      strncat_loop_begin
+
+strncat_copy_head_loop_begin:
+    mov     al, [rcx]
+    test    al, al
+    jz      strncat_copy
+    inc     rcx
+    test    cl, 7
+    jnz     strncat_copy_head_loop_begin
+
+    nop
+
+strncat_loop_begin:
+    mov     rax, [rcx]
+    mov     r10, rax
+    mov     r9, 7efefefefefefeffh
+    add     r9, r10
+    xor     r10, -1
+    xor     r10, r9
+    add     rcx, 8
+    mov     r9, 8101010101010100h
+    test    r10, r9
+    je      strncat_loop_begin
+    sub     rcx, 8
+
+strncat_loop_end:
+    test    al, al
+    jz      strncat_copy
+    inc     rcx
+    test    ah, ah
+    jz      strncat_copy
+    inc     rcx
+    shr     rax, 16
+    test    al, al
+    jz      strncat_copy
+    inc     rcx
+    test    ah, ah
+    jz      strncat_copy
+    inc     rcx
+    shr     rax, 16
+    test    al, al
+    jz      strncat_copy
+    inc     rcx
+    test    ah, ah
+    jz      strncat_copy
+    inc     rcx
+    shr     eax, 16
+    test    al, al
+    jz      strncat_copy
+    inc     rcx
+    test    ah, ah
+    jz      strncat_copy
+    inc     rcx
+    jmp     strncat_loop_begin
+
+strncat_copy:
+; align the SOURCE so we never page fault
+; dest pointer alignment not important
+    sub     rcx, rdx ; combine pointers
+    test    dl, 7
+    jz      qword_loop_entrance
+
+copy_head_loop_begin:
+    mov     al, [rdx]
+    mov     [rdx+rcx], al
+    test    al, al
+    jz      byte_exit
+    inc     rdx
+    dec     r8
+    jz      byte_null_end
+    test    dl, 7
+    jnz     copy_head_loop_begin
+    jmp     qword_loop_entrance
+
+byte_null_end:
+    xor     al, al
+    mov     [rdx+rcx], al
+byte_exit:
+    mov     rax, r11
+    ret
+
+    nop
+
+qword_loop_begin:
+    mov     [rdx+rcx], rax
+    add     rdx, 8
+qword_loop_entrance:
+    mov     rax, [rdx]
+    sub     r8,  8
+    jbe     qword_loop_end
+    mov     r9, 7efefefefefefeffh
+    add     r9, rax
+    mov     r10, rax
+    xor     r10, -1
+    xor     r10, r9
+    mov     r9, 8101010101010100h
+    test    r10, r9
+    jz      qword_loop_begin
+
+qword_loop_end:
+    add     r8, 8
+    jz      strncat_exit_2
+
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    shr     rax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    shr     rax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    shr     eax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jz      strncat_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      strncat_exit
+    inc     rdx
+    dec     r8
+    jnz     qword_loop_entrance
+
+strncat_exit_2:
+    xor     al, al
+    mov     [rdx+rcx], al
+strncat_exit:
+    mov     rax, r11
+    ret
+
+LEAF_END fname, _TEXT$21
+
+    end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..80146e4f699dafefc4c1a1429b3fdd6368a5c8da
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncmp.asm	
@@ -0,0 +1,131 @@
+        page    ,132
+        title   strncmp - compare first n chars of two strings
+;***
+;strncmp.asm - compare first n characters of two strings
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines strncmp() - compare first n characters of two strings
+;       for ordinal order.
+;
+;*******************************************************************************
+include ksamd64.inc
+        subttl  "strncmp"
+;***
+;int strncmp(first, last, count) - compare first count chars of strings
+;
+;Purpose:
+;       Compares two strings for ordinal order.  The comparison stops
+;       after: (1) a difference between the strings is found, (2) the end
+;       of the strings is reached, or (3) count characters have been
+;       compared.
+;
+;       Algorithm:
+;       int
+;       strncmp (first, last, count)
+;             char *first, *last;
+;             unsigned count;
+;             {
+;             if (!count)
+;                     return(0);
+;             while (--count && *first && *first == *last)
+;                     {
+;                     first++;
+;                     last++;
+;                     }
+;             return(*first - *last);
+;             }
+;
+;Entry:
+;       char *first, *last - strings to compare
+;       unsigned count - maximum number of characters to compare
+;
+;Exit:
+;       returns <0 if first < last
+;       returns 0 if first == last
+;       returns >0 if first > last
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+ifdef _CRT_FFS_BUILD
+fname      TEXTEQU <strncmp_ffs>
+else
+fname      TEXTEQU <strncmp>
+endif
+
+LEAF_ENTRY_ARG3 fname, _TEXT$21, str1:ptr byte, str2:ptr byte, count:dword
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+; rcx = first
+; rdx = last
+; r8 = count
+
+    sub       rdx, rcx
+
+    test      r8, r8
+    jz        return_equal
+
+    test      ecx, 7
+    jz        qword_loop_enter
+
+comp_head_loop_begin:
+    movzx     eax, byte ptr[rcx]
+    cmp       al, byte ptr[rdx+rcx]
+    jne       return_not_equal
+
+    inc       rcx
+
+    dec       r8
+    jz        return_equal
+
+    test      al, al
+    jz        return_equal
+
+    test      rcx, 7
+    jnz       comp_head_loop_begin
+
+qword_loop_enter:
+    mov       r11, 08080808080808080h
+    mov       r10, 0fefefefefefefeffh
+
+qword_loop_begin:
+    lea       eax, [rdx+rcx]
+    and       eax, 0fffh
+    cmp       eax, 0ff8h
+    ja        comp_head_loop_begin
+
+    mov       rax, qword ptr[rcx]
+    cmp       rax, qword ptr[rdx+rcx]
+    jne       comp_head_loop_begin
+
+    add       rcx, 8
+
+    sub       r8, 8
+    jbe       return_equal
+
+    lea       r9, [r10+rax]
+    not       rax
+    and       rax, r9
+    test      rax, r11  ; 8080808080808080h
+
+    jz        qword_loop_begin
+
+return_equal:
+    xor       eax, eax
+    ret
+
+;    align     16
+
+return_not_equal:
+    sbb       rax, rax  ; AX=-1, CY=1 AX=0, CY=0
+    or        rax, 1
+    ret
+
+LEAF_END fname, _TEXT$21
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncpy.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncpy.asm
new file mode 100644
index 0000000000000000000000000000000000000000..a2c8969a9f4465417d3968a2744980af4c67fae2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strncpy.asm	
@@ -0,0 +1,176 @@
+        page    ,132
+        title   strncpy - copy at most n characters of string
+;***
+;strncpy.asm - copy at most n characters of string
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines strncpy() - copy at most n characters of string
+;
+;*******************************************************************************
+; Look at strncat.asm for this file
+include ksamd64.inc
+        subttl  "strncpy"
+
+ifdef _CRT_FFS_BUILD
+fname      TEXTEQU <strncpy_ffs>
+else
+fname      TEXTEQU <strncpy>
+endif
+
+LEAF_ENTRY_ARG3 fname, _TEXT$21, dst:ptr byte, src:ptr byte, count:dword
+
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+; align the SOURCE so we never page fault
+; dest pointer alignment not important
+
+    mov     r11, rcx
+    or      r8, r8
+    jz      strncpy_exit
+    sub     rcx, rdx ; combine pointers
+    test    dl, 7
+    jz      qword_loop_entrance
+
+copy_head_loop_begin:
+    mov     al, [rdx]
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit
+    test    dl, 7
+    jnz     copy_head_loop_begin
+    jmp     qword_loop_entrance
+
+strncpy_exit:
+    mov     rax, r11
+    ret
+
+qword_loop_begin:
+    mov     [rdx+rcx], rax
+    add     rdx, 8
+qword_loop_entrance:
+    mov     rax, [rdx]
+    sub     r8,  8
+    jbe     qword_loop_end
+    mov     r9, 7efefefefefefeffh
+    add     r9, rax
+    mov     r10, rax
+    xor     r10, -1
+    xor     r10, r9
+    mov     r9, 8101010101010100h
+    test    r10, r9
+    jz      qword_loop_begin
+
+qword_loop_end:
+    add     r8, 8
+    jz      strncpy_exit_2
+
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    shr     rax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    shr     rax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    shr     eax, 16
+    test    al, al
+    mov     [rdx+rcx], al
+    jz      filler
+    inc     rdx
+    dec     r8
+    jz      strncpy_exit_2
+    test    ah, ah
+    mov     [rdx+rcx], ah
+    jz      filler
+    inc     rdx
+    dec     r8
+    jnz     qword_loop_entrance
+
+strncpy_exit_2:
+    mov     rax, r11
+    ret
+
+;this is really just memset
+filler:
+    add     rcx, rdx
+    xor     rdx, rdx
+    cmp     r8, 16
+    jb      tail ; a quickie
+aligner1:
+    test    cl, 7
+    jz      aligned
+    inc     rcx
+    mov     [rcx], dl
+    dec     r8
+    jmp     aligner1
+aligned:
+    sub     r8, 32
+    jb      tail_8_enter
+loop32:
+    mov     [rcx], rdx
+    mov     [rcx+8], rdx
+    mov     [rcx+16], rdx
+    mov     [rcx+24], rdx
+    add     rcx, 32
+    sub     r8, 32
+    jae     loop32
+
+tail_8_enter:
+    add     r8, 32   ; get back the value
+tail_8_begin:
+    sub     r8, 8
+    jb      tail_enter
+    mov     [rcx], rdx
+    add     rcx, 8
+    jmp     tail_8_begin
+
+tail_enter:
+    add     r8, 8   ; get back the value
+tail:
+    sub     r8, 1
+    jb      tail_finish
+    mov     [rcx], dl
+    inc     rcx
+    jmp     tail
+tail_finish:
+    mov     rax, r11
+    ret
+
+LEAF_END fname, _TEXT$21
+
+    end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strpbrk.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strpbrk.c
new file mode 100644
index 0000000000000000000000000000000000000000..43631aa7bc2067214c5acff0bfa330240196a0ac
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strpbrk.c	
@@ -0,0 +1,13 @@
+/***
+*strpbrk.c - Defines the strpbrk function.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       The function strpbrk is mostly common code with strspn in strspn.c.
+*
+*******************************************************************************/
+
+#define SSTRPBRK
+#define STRSPN_USE_SSE2
+#include "strspn.c"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strspn.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strspn.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e7ee38e5894934ce4cd44ee606b0e955ff242b0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/amd64/strspn.c	
@@ -0,0 +1,543 @@
+/***
+*strspn.c - find length of initial substring of chars from a control string
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines strspn() - finds the length of the initial substring of
+*       a string consisting entirely of characters from a control string.
+*
+*       defines strcspn()- finds the length of the initial substring of
+*       a string consisting entirely of characters not in a control string.
+*
+*       defines strpbrk()- finds the index of the first character in a string
+*       that is not in a control string
+*
+*******************************************************************************/
+
+#include <string.h>
+
+/*
+ * This function is 3-4 times faster than the _bittest intrinsic on x86/x64, and generates
+ * similar code on Arm64 to the _bittest intrinsic.  The reason why _bittest is slow on x86/x64
+ * is that the bt instruction variant that loads memory is slow.  Once the _bittest intrinsic
+ * is fixed, we could remove this function.
+ */
+static __forceinline
+unsigned char _crt_bittest(
+    unsigned char * bitmap,
+    unsigned int bit
+    )
+{
+    return (unsigned char)((bitmap[bit >> 3] >> (bit & 7)) & 1);
+}
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 Prefast doesn't understand reading past buffer but staying on same page.
+#pragma warning(disable:__WARNING_RETURNING_BAD_RESULT) // 28196
+
+/* Determine which routine we're compiling for (default to STRSPN) */
+#define _STRSPN         1
+#define _STRCSPN        2
+#define _STRPBRK        3
+
+#if defined (SSTRCSPN)
+    #define ROUTINE _STRCSPN
+#elif defined (SSTRPBRK)
+    #define ROUTINE _STRPBRK
+#else
+    #define ROUTINE _STRSPN
+    #define STRSPN_USE_SSE2
+#endif
+
+/***
+*int strspn(string, control) - find init substring of control chars
+*
+*Purpose:
+*       Finds the index of the first character in string that does belong
+*       to the set of characters specified by control.  This is
+*       equivalent to the length of the initial substring of string that
+*       consists entirely of characters from control.  The '\0' character
+*       that terminates control is not considered in the matching process.
+*
+*Entry:
+*       char *string - string to search
+*       char *control - string containing characters not to search for
+*
+*Exit:
+*       returns index of first char in string not in control
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/***
+*int strcspn(string, control) - search for init substring w/o control chars
+*
+*Purpose:
+*       returns the index of the first character in string that belongs
+*       to the set of characters specified by control.  This is equivalent
+*       to the length of the length of the initial substring of string
+*       composed entirely of characters not in control.  Null chars not
+*       considered.
+*
+*Entry:
+*       char *string - string to search
+*       char *control - set of characters not allowed in init substring
+*
+*Exit:
+*       returns the index of the first char in string
+*       that is in the set of characters specified by control.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/***
+*char *strpbrk(string, control) - scans string for a character from control
+*
+*Purpose:
+*       Finds the first occurence in string of any character from
+*       the control string.
+*
+*Entry:
+*       char *string - string to search in
+*       char *control - string containing characters to search for
+*
+*Exit:
+*       returns a pointer to the first character from control found
+*       in string.
+*       returns NULL if string and control have no characters in common.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+
+
+/* Routine prototype */
+#if ROUTINE == _STRSPN
+#if defined(STRSPN_USE_SSE2)
+__declspec(noinline)
+static size_t __cdecl fallbackMethod(
+#else
+size_t __cdecl
+#ifdef _CRT_FFS_BUILD
+strspn_ffs (
+#else
+strspn (
+#endif
+#endif
+#elif ROUTINE == _STRCSPN
+#if defined(STRSPN_USE_SSE2)
+__declspec(noinline)
+static size_t __cdecl fallbackMethod(
+#else
+size_t __cdecl
+#ifdef _CRT_FFS_BUILD
+strcspn_ffs (
+#else
+strcspn (
+#endif
+#endif
+#else  /* ROUTINE == _STRCSPN */
+#if defined(STRSPN_USE_SSE2)
+__declspec(noinline)
+static char * __cdecl fallbackMethod(
+#else
+char * __cdecl
+#ifdef _CRT_FFS_BUILD
+strpbrk_ffs (
+#else
+strpbrk (
+#endif
+#endif
+#endif  /* ROUTINE == _STRCSPN */
+        const char * string,
+        const char * control
+        )
+{
+        const unsigned char *str = (unsigned char const*)string;
+        const unsigned char *ctrl = (unsigned char const*)control;
+
+        unsigned char map[32];
+        /* Clear out bit map */
+        memset(map, 0, sizeof(map));
+
+        /* Set bits in control map */
+        while (*ctrl)
+        {
+                _bittestandset(map, *ctrl);
+                ctrl++;
+        }
+
+#if ROUTINE == _STRSPN
+
+        /* 1st char NOT in control map stops search */
+        if (*str)
+        {
+                int count=0;
+                while (_crt_bittest(map, *str))
+                {
+                        count++;
+                        str++;
+                }
+                return(count);
+        }
+        return(0);
+
+#elif ROUTINE == _STRCSPN
+
+        /* 1st char in control map stops search */
+        int count=0;
+        map[0] |= 1;    /* null chars not considered */
+        while (!_crt_bittest(map, *str))
+        {
+                count++;
+                str++;
+        }
+        return(count);
+
+#else  /* ROUTINE == _STRCSPN */
+
+        /* 1st char in control map stops search */
+        while (*str)
+        {
+                if (_crt_bittest(map, *str))
+                        return((char *)str);
+                str++;
+        }
+        return(NULL);
+
+#endif  /* ROUTINE == _STRCSPN */
+
+}
+
+#if defined(STRSPN_USE_SSE2)
+#include <emmintrin.h>
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward)
+#pragma optimize("t", on)
+
+/* Routine prototype */
+#if ROUTINE == _STRSPN
+size_t __cdecl
+#ifdef _CRT_FFS_BUILD
+strspn_ffs (
+#else
+strspn (
+#endif
+#elif ROUTINE == _STRCSPN
+size_t __cdecl
+#ifdef _CRT_FFS_BUILD
+strcspn_ffs (
+#else
+strcspn (
+#endif
+#else  /* ROUTINE == _STRCSPN */
+char * __cdecl
+#ifdef _CRT_FFS_BUILD
+strpbrk_ffs (
+#else
+strpbrk (
+#endif
+#endif  /* ROUTINE == _STRCSPN */
+const char * string, const char * control)
+{
+    unsigned long long shift = (unsigned long long) control & 0xf;
+
+    // Mask off the lower bits of the address to get a 16-byte aligned pointer
+    char * alignedControl = (char *) control - shift;
+
+    // Load 16 bytes.  This will not cross a page boundary but will have spurious data
+    __m128i search = _mm_loadu_si128((__m128i *) alignedControl);
+    __m128i zero = _mm_xor_si128(zero, zero);
+    __m128i temp, tempMask, smearedChar;
+    unsigned int mask, terminatorSeen = 0;
+    unsigned long bitCount;
+
+    // Sse2 provides immediate shifts of the full 128 bit register.
+    // Shift out the spurious data on the right and shift in zeros.
+    switch (shift)
+    {
+        case 1:
+            search = _mm_srli_si128(search, 1);
+            break;
+        case 2:
+            search = _mm_srli_si128(search, 2);
+            break;
+        case 3:
+            search = _mm_srli_si128(search, 3);
+            break;
+        case 4:
+            search = _mm_srli_si128(search, 4);
+            break;
+        case 5:
+            search = _mm_srli_si128(search, 5);
+            break;
+        case 6:
+            search = _mm_srli_si128(search, 6);
+            break;
+        case 7:
+            search = _mm_srli_si128(search, 7);
+            break;
+        case 8:
+            search = _mm_srli_si128(search, 8);
+            break;
+        case 9:
+            search = _mm_srli_si128(search, 9);
+            break;
+        case 10:
+            search = _mm_srli_si128(search, 10);
+            break;
+        case 11:
+            search = _mm_srli_si128(search, 11);
+            break;
+        case 12:
+            search = _mm_srli_si128(search, 12);
+            break;
+        case 13:
+            search = _mm_srli_si128(search, 13);
+            break;
+        case 14:
+            search = _mm_srli_si128(search, 14);
+            break;
+        case 15:
+            search = _mm_srli_si128(search, 15);
+            break;
+        case 0:
+        default:
+            break;
+    }
+
+    // Search for zero bytes in this initial string
+    temp = _mm_cmpeq_epi8(search, zero);
+    mask = _mm_movemask_epi8(temp);
+
+    if (mask)
+    {
+        // We found zeros and now need to mask away the spurious data that may follow
+       (void) _BitScanForward(&bitCount, mask);
+
+        terminatorSeen = (shift == 0) ? 1 : (bitCount < (16 - shift));
+
+        switch (16 - bitCount)
+        {
+            case 1:
+               search = _mm_slli_si128(search, 1);
+               search = _mm_srli_si128(search, 1);
+               break;
+            case 2:
+               search = _mm_slli_si128(search, 2);
+               search = _mm_srli_si128(search, 2);
+               break;
+            case 3:
+               search = _mm_slli_si128(search, 3);
+               search = _mm_srli_si128(search, 3);
+               break;
+            case 4:
+               search = _mm_slli_si128(search, 4);
+               search = _mm_srli_si128(search, 4);
+               break;
+            case 5:
+               search = _mm_slli_si128(search, 5);
+               search = _mm_srli_si128(search, 5);
+               break;
+            case 6:
+               search = _mm_slli_si128(search, 6);
+               search = _mm_srli_si128(search, 6);
+               break;
+            case 7:
+               search = _mm_slli_si128(search, 7);
+               search = _mm_srli_si128(search, 7);
+               break;
+            case 8:
+               search = _mm_slli_si128(search, 8);
+               search = _mm_srli_si128(search, 8);
+               break;
+            case 9:
+               search = _mm_slli_si128(search, 9);
+               search = _mm_srli_si128(search, 9);
+               break;
+            case 10:
+               search = _mm_slli_si128(search, 10);
+               search = _mm_srli_si128(search, 10);
+               break;
+            case 11:
+               search = _mm_slli_si128(search, 11);
+               search = _mm_srli_si128(search, 11);
+               break;
+            case 12:
+               search = _mm_slli_si128(search, 12);
+               search = _mm_srli_si128(search, 12);
+               break;
+            case 13:
+               search = _mm_slli_si128(search, 13);
+               search = _mm_srli_si128(search, 13);
+               break;
+            case 14:
+               search = _mm_slli_si128(search, 14);
+               search = _mm_srli_si128(search, 14);
+               break;
+            case 15:
+               search = _mm_slli_si128(search, 15);
+               search = _mm_srli_si128(search, 15);
+               break;
+            case 16:
+                search = zero;
+                break;
+       }
+    }
+    else if (shift == 0)
+    {
+        // We loaded 16 bytes and found no zero.  Check if the first byte in
+        // the next 16-byte aligned block is zero.  This load will not page fault
+        // on a correct program since we have not see the terminator.
+        if (*(alignedControl + 1) == 0)
+        {
+            terminatorSeen = 1;
+        }
+        else
+        {
+            // We already have 16 bytes and have not seen the terminator.  Fallback to
+            // non-Sse2 version.
+            return fallbackMethod(string, control);
+        }
+    }
+
+    // If was have not seen the string terminator, attempt to piece-together a search
+    // mask of bytes from those in the next 16-byte aligned group that follows.
+    // We will allow at most 16 bytes in the search string.
+    if (!terminatorSeen)
+    {
+        // Go get the next 16 bytes, again this will not page fault.
+        alignedControl += 16;
+        temp = _mm_loadu_si128((__m128i *) alignedControl);
+
+        tempMask = _mm_cmpeq_epi8(temp, zero);
+        terminatorSeen = _mm_movemask_epi8(tempMask);
+
+        if (!terminatorSeen)
+        {
+            return fallbackMethod(string, control);
+        }
+
+        (void) _BitScanForward(&bitCount, terminatorSeen);
+
+        if ((16 - shift + bitCount) > 16)
+        {
+            return fallbackMethod(string, control);
+        }
+
+        // Shift the 2nd part of the search mask into place with the 16 bytes
+        switch (16 - bitCount)
+        {
+           case 1:
+              temp = _mm_slli_si128(temp, 1);
+              break;
+           case 2:
+              temp = _mm_slli_si128(temp, 2);
+              break;
+           case 3:
+              temp = _mm_slli_si128(temp, 3);
+              break;
+           case 4:
+              temp = _mm_slli_si128(temp, 4);
+              break;
+           case 5:
+              temp = _mm_slli_si128(temp, 5);
+              break;
+           case 6:
+              temp = _mm_slli_si128(temp, 6);
+              break;
+           case 7:
+              temp = _mm_slli_si128(temp, 7);
+              break;
+           case 8:
+              temp = _mm_slli_si128(temp, 8);
+              break;
+           case 9:
+              temp = _mm_slli_si128(temp, 9);
+              break;
+           case 10:
+              temp = _mm_slli_si128(temp, 10);
+              break;
+           case 11:
+              temp = _mm_slli_si128(temp, 11);
+              break;
+           case 12:
+              temp = _mm_slli_si128(temp, 12);
+              break;
+           case 13:
+              temp = _mm_slli_si128(temp, 13);
+              break;
+           case 14:
+              temp = _mm_slli_si128(temp, 14);
+              break;
+           case 15:
+              temp = _mm_slli_si128(temp, 15);
+              break;
+           case 16:
+              temp = zero;
+              break;
+      
+ }
+
+       // Or the two parts together to obtain a single up-to 16-byte search mask
+        search = _mm_or_si128(search, temp);
+    }
+
+    // Now loop through the string do a 16-compare with our search mask
+#if (ROUTINE == _STRSPN) || (ROUTINE == _STRCSPN)
+    size_t count = 0;
+#endif
+    while (*string)
+    {
+        int smear = (int) *string;
+        // Get the byte in a register
+        smearedChar = _mm_cvtsi32_si128(smear);
+
+        // The following 3 instructions smear this one character through each byte of the 16-byte register
+        smearedChar = _mm_unpacklo_epi8(smearedChar, smearedChar);
+        smearedChar = _mm_unpacklo_epi8(smearedChar, smearedChar);
+        smearedChar = _mm_shuffle_epi32(smearedChar, 0);
+
+        // Look for a match
+        temp = _mm_cmpeq_epi8(search, smearedChar);
+        mask = _mm_movemask_epi8(temp);
+
+#if (ROUTINE == _STRSPN)
+        // Break if no match
+        if (!mask)
+        {
+           break;
+        }
+
+        string++;
+        count++;
+#elif (ROUTINE == _STRCSPN)
+      // Break on first match
+      if (mask)
+      {
+         break;
+      }
+
+      string++;
+      count++;
+#else // strpbrk case
+        // Return current string location on a match
+        if (mask)
+        {
+            return (char *) string;
+        }
+     
+        string++;
+#endif
+    }
+
+#if (ROUTINE == _STRSPN) || (ROUTINE == _STRCSPN)
+    return count;
+#else
+    return NULL;
+#endif
+}
+#endif
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strcmp.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strcmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..78402c0ff08ecc1bb0b972d2981ad6a4fc8526bb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strcmp.c	
@@ -0,0 +1,52 @@
+/***
+*strcmp.c - routine to compare two strings (for equal, less, or greater)
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compares two string, determining their ordinal order.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#pragma function(strcmp)
+
+/***
+*strcmp - compare two strings, returning less than, equal to, or greater than
+*
+*Purpose:
+*       STRCMP compares two strings and returns an integer
+*       to indicate whether the first is less than the second, the two are
+*       equal, or whether the first is greater than the second.
+*
+*       Comparison is done byte by byte on an UNSIGNED basis, which is to
+*       say that Null (0) is less than any other character (1-255).
+*
+*Entry:
+*       const char * src - string for left-hand side of comparison
+*       const char * dst - string for right-hand side of comparison
+*
+*Exit:
+*       returns -1 if src <  dst
+*       returns  0 if src == dst
+*       returns +1 if src >  dst
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl strcmp (
+        const char * src,
+        const char * dst
+        )
+{
+        int ret = 0 ;
+
+        while((ret = *(unsigned char *)src - *(unsigned char *)dst) == 0 && *dst)
+                {
+                ++src, ++dst;
+                }
+
+        return ((-ret) < 0) - (ret < 0); // (if positive) - (if negative) generates branchless code
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strcpy.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strcpy.c
new file mode 100644
index 0000000000000000000000000000000000000000..45f92b4b4b1727649218ecc8fe825e1d98f278e0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strcpy.c	
@@ -0,0 +1,43 @@
+/***
+*strcat.c - contains strcat() and strcpy()
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Strcpy() copies one string onto another.
+*
+*       Strcat() concatenates (appends) a copy of the source string to the
+*       end of the destination string, returning the destination string.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#pragma function(strcpy)
+
+/***
+*char *strcpy(dst, src) - copy one string over another
+*
+*Purpose:
+*       Copies the string src into the spot specified by
+*       dest; assumes enough room.
+*
+*Entry:
+*       char * dst - string over which "src" is to be copied
+*       const char * src - string to be copied over "dst"
+*
+*Exit:
+*       The address of "dst"
+*
+*Exceptions:
+*******************************************************************************/
+
+char * __cdecl strcpy(char * dst, const char * src)
+{
+        char * cp = dst;
+
+        while((*cp++ = *src++) != '\0')
+                ;               /* Copy src over dst */
+
+        return( dst );
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strlen.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strlen.c
new file mode 100644
index 0000000000000000000000000000000000000000..239baa95d5d416242d9b12e185f105e09a8b06f8
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strlen.c	
@@ -0,0 +1,42 @@
+/***
+*strlen.c - contains strlen() routine
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       strlen returns the length of a null-terminated string,
+*       not including the null byte itself.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#pragma function(strlen)
+
+/***
+*strlen - return the length of a null-terminated string
+*
+*Purpose:
+*       Finds the length in bytes of the given string, not including
+*       the final null character.
+*
+*Entry:
+*       const char * str - string whose length is to be computed
+*
+*Exit:
+*       length of the string "str", exclusive of the final null byte
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+size_t __cdecl strlen (
+        const char * str
+        )
+{
+        const char *eos = str;
+
+        while( *eos++ ) ;
+
+        return( eos - str - 1 );
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strncmp.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strncmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..aafd4d0763e85152b614897c54c805b65ec82915
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm/strncmp.c	
@@ -0,0 +1,101 @@
+/***
+*strncmp.c - compare first n characters of two strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines strncmp() - compare first n characters of two strings
+*       for ordinal order.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#ifdef _M_ARM
+    #pragma function(strncmp)
+#endif
+
+/***
+*int strncmp(first, last, count) - compare first count chars of strings
+*
+*Purpose:
+*       Compares two strings for ordinal order.  The comparison stops
+*       after: (1) a difference between the strings is found, (2) the end
+*       of the strings is reached, or (3) count characters have been
+*       compared.
+*
+*Entry:
+*       char *first, *last - strings to compare
+*       unsigned count - maximum number of characters to compare
+*
+*Exit:
+*       returns <0 if first < last
+*       returns  0 if first == last
+*       returns >0 if first > last
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int __cdecl strncmp
+(
+    const char *first,
+    const char *last,
+    size_t      count
+)
+{
+    size_t x = 0;
+
+    if (!count)
+    {
+        return 0;
+    }
+
+    /*
+     * This explicit guard needed to deal correctly with boundary
+     * cases: strings shorter than 4 bytes and strings longer than
+     * UINT_MAX-4 bytes .
+     */
+    if( count >= 4 )
+    {
+        /* unroll by four */
+        for (; x < count-4; x+=4)
+        {
+            first+=4;
+            last +=4;
+
+            if (*(first-4) == 0 || *(first-4) != *(last-4))
+            {
+                return(*(unsigned char *)(first-4) - *(unsigned char *)(last-4));
+            }
+
+            if (*(first-3) == 0 || *(first-3) != *(last-3))
+            {
+                return(*(unsigned char *)(first-3) - *(unsigned char *)(last-3));
+            }
+
+            if (*(first-2) == 0 || *(first-2) != *(last-2))
+            {
+                return(*(unsigned char *)(first-2) - *(unsigned char *)(last-2));
+            }
+
+            if (*(first-1) == 0 || *(first-1) != *(last-1))
+            {
+                return(*(unsigned char *)(first-1) - *(unsigned char *)(last-1));
+            }
+        }
+    }
+
+    /* residual loop */
+    for (; x < count; x++)
+    {
+        if (*first == 0 || *first != *last)
+        {
+            return(*(unsigned char *)first - *(unsigned char *)last);
+        }
+        first+=1;
+        last+=1;
+    }
+
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strcmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strcmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..5ad543a8fb5e1e41d7c5c96f1fb8fe0a69cdb478
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strcmp.asm	
@@ -0,0 +1,178 @@
+/*
+Copyright (c) 1999-2022, Arm Limited.
+Licensed under the MIT license.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ksarm64.h"
+
+#if !defined(_M_ARM64EC)
+
+        EXPORT A64NAME(strcmp)    [FUNC]
+
+#endif
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+#define REP8_01    0x0101010101010101
+#define REP8_7f    0x7f7f7f7f7f7f7f7f
+
+#define src1       x0
+#define src2       x1
+#define result     x0
+
+#define data1      x2
+#define data1w     w2
+#define data2      x3
+#define data2w     w3
+#define has_nul    x4
+#define diff       x5
+#define off1       x5
+#define syndrome   x6
+#define tmp        x6
+#define data3      x7
+#define zeroones   x8
+#define shift      x9
+#define off2       x10
+
+; NUL detection works on the principle that (X - 1) & (~X) & 0x80
+; (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and
+; can be done in parallel across the entire word.
+
+        ARM64EC_ENTRY_THUNK A64NAME(strcmp),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(strcmp),|.text$$mn$$21|,5
+
+        sub    off2, src2, src1
+        mov    zeroones, REP8_01
+        and    tmp, src1, 7
+        tst    off2, 7
+        bne    misaligned8
+        cbnz   tmp, mutual_align
+
+loop_aligned
+        ldr    data2, [src1, off2]
+        ldr    data1, [src1], 8
+
+start_realigned
+        sub    has_nul, data1, zeroones
+        orr    tmp, data1, REP8_7f
+        bics   has_nul, has_nul, tmp    ; Non-zero if NUL terminator.
+        ccmp   data1, data2, 0, eq
+        beq    loop_aligned
+        eor    diff, data1, data2
+        orr    syndrome, diff, has_nul
+
+end
+        rev    syndrome, syndrome
+        rev    data1, data1
+        rev    data2, data2
+        clz    shift, syndrome
+        ; The most-significant-non-zero bit of the syndrome marks either the
+        ; first bit that is different, or the top bit of the first zero byte.
+        ; Shifting left now will bring the critical information into the
+        ; top bits.
+        lsl    data1, data1, shift
+        lsl    data2, data2, shift
+        ; But we need to zero-extend (char is unsigned) the value and then
+        ; perform a signed 32-bit subtraction.
+        lsr    data1, data1, 56
+        cmp    data1, data2, lsr 56
+
+        ; Although the C/C++ standard does not regulate the return value if
+        ; it is non-zero, MS strcmp implementation has been returning 1, 0,
+        ; -1 historically. To maximize compat, we normalize the result before
+        ; returning.
+normalize_result
+        csetm  tmp, lt
+        csinc  result, tmp, xzr, le
+        ret
+
+mutual_align
+        ; Sources are mutually aligned, but are not currently at an
+        ; alignment boundary.  Round down the addresses and then mask off
+        ; the bytes that precede the start point.
+        bic    src1, src1, 7
+        ldr    data2, [src1, off2]
+        ldr    data1, [src1], 8
+        neg    shift, src2, lsl 3    ; Bits to alignment -64.
+        mov    tmp, -1
+        lsr    tmp, tmp, shift
+        orr    data1, data1, tmp
+        orr    data2, data2, tmp
+        b      start_realigned
+
+misaligned8
+        ; Align SRC1 to 8 bytes and then compare 8 bytes at a time, always
+        ; checking to make sure that we don't access beyond the end of SRC2.
+        cbz    tmp, src1_aligned
+
+do_misaligned
+        ldrb   data1w, [src1], 1
+        ldrb   data2w, [src2], 1
+        cmp    data1w, 0
+        ccmp   data1w, data2w, 0, ne    ; NZCV = 0b0000.
+        bne    done
+        tst    src1, 7
+        bne    do_misaligned
+
+src1_aligned
+        neg    shift, src2, lsl 3
+        bic    src2, src2, 7
+        ldr    data3, [src2], 8
+        lsr    tmp, zeroones, shift
+        orr    data3, data3, tmp
+        sub    has_nul, data3, zeroones
+        orr    tmp, data3, REP8_7f
+        bics   has_nul, has_nul, tmp
+        bne    tail
+
+        sub    off1, src2, src1
+
+loop_unaligned
+        ldr    data3, [src1, off1]
+        ldr    data2, [src1, off2]
+        sub    has_nul, data3, zeroones
+        orr    tmp, data3, REP8_7f
+        ldr    data1, [src1], 8
+        bics   has_nul, has_nul, tmp
+        ccmp   data1, data2, 0, eq
+        beq    loop_unaligned
+
+        lsl    tmp, has_nul, shift
+        eor    diff, data1, data2
+        orr    syndrome, diff, tmp
+        cbnz   syndrome, end
+
+tail
+        ldr    data1, [src1]
+        neg    shift, shift
+        lsr    data2, data3, shift
+        lsr    has_nul, has_nul, shift
+        eor    diff, data1, data2
+        orr    syndrome, diff, has_nul
+        b      end
+
+done
+        cmp    data1, data2
+        b      normalize_result
+
+        LEAF_END
+
+        END
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strcpy.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strcpy.asm
new file mode 100644
index 0000000000000000000000000000000000000000..0e91a84b4ce61ff41bbce5a9c79b85285a514825
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strcpy.asm	
@@ -0,0 +1,156 @@
+/*
+Copyright (c) 1999-2022, Arm Limited.
+Licensed under the MIT license.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ksarm64.h"
+
+#if !defined(_M_ARM64EC)
+
+        EXPORT A64NAME(strcpy)    [FUNC]
+
+#endif
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+#define dstin      x0
+#define srcin      x1
+#define result     x0
+
+#define src        x2
+#define dst        x3
+#define len        x4
+#define synd       x4
+#define tmp        x5
+#define shift      x5
+#define data1      x6
+#define dataw1     w6
+#define data2      x7
+#define dataw2     w7
+
+#define dataq      q0
+#define vdata      v0
+#define vhas_nul   v1
+#define vend       v2
+#define dend       d2
+#define dataq2     q1
+
+/*
+   Core algorithm:
+   For each 16-byte chunk we calculate a 64-bit nibble mask value with four bits
+   per byte. We take 4 bits of every comparison byte with shift right and narrow
+   by 4 instruction. Since the bits in the nibble mask reflect the order in
+   which things occur in the original string, counting leading zeros identifies
+   exactly which byte matched.  */
+
+        ARM64EC_ENTRY_THUNK A64NAME(strcpy),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(strcpy),|.text$$mn$$21|,5
+
+        bic        src, srcin, 15
+        ld1        {vdata.16b}, [src]
+        cmeq       vhas_nul.16b, vdata.16b, 0
+        lsl        shift, srcin, 2
+        shrn       vend.8b, vhas_nul.8h, 4
+        fmov       synd, dend
+        lsr        synd, synd, shift
+        cbnz       synd, tail
+
+        ldr        dataq, [src, 16]!
+        cmeq       vhas_nul.16b, vdata.16b, 0
+        shrn       vend.8b, vhas_nul.8h, 4
+        fmov       synd, dend
+        cbz        synd, start_loop
+        rbit       synd, synd
+        sub        tmp, src, srcin
+        clz        len, synd
+        add        len, tmp, len, lsr 2
+        tbz        len, 4, less16
+        sub        tmp, len, 15
+        ldr        dataq, [srcin]
+        ldr        dataq2, [srcin, tmp]
+        str        dataq, [dstin]
+        str        dataq2, [dstin, tmp]
+        ret
+
+tail
+        rbit       synd, synd
+        clz        len, synd
+        lsr        len, len, 2
+less16
+        tbz        len, 3, less8
+        sub        tmp, len, 7
+        ldr        data1, [srcin]
+        ldr        data2, [srcin, tmp]
+        str        data1, [dstin]
+        str        data2, [dstin, tmp]
+        ret
+
+less8
+        subs       tmp, len, 3
+        blo        less4
+        ldr        dataw1, [srcin]
+        ldr        dataw2, [srcin, tmp]
+        str        dataw1, [dstin]
+        str        dataw2, [dstin, tmp]
+        ret
+
+less4
+        cbz        len, zerobyte
+        ldrh       dataw1, [srcin]
+        strh       dataw1, [dstin]
+zerobyte
+        strb       wzr, [dstin, len]
+        ret
+
+start_loop
+        sub        tmp, srcin, dstin
+        ldr        dataq2, [srcin]
+        sub        dst, src, tmp
+        str        dataq2, [dstin]
+loop
+        str        dataq, [dst], 32
+        ldr        dataq, [src, 16]
+        cmeq       vhas_nul.16b, vdata.16b, 0
+        umaxp      vend.16b, vhas_nul.16b, vhas_nul.16b
+        fmov       synd, dend
+        cbnz       synd, loopend
+        stur       dataq, [dst, -16]
+        ldr        dataq, [src, 32]!
+        cmeq       vhas_nul.16b, vdata.16b, 0
+        umaxp      vend.16b, vhas_nul.16b, vhas_nul.16b
+        fmov       synd, dend
+        cbz        synd, loop
+        add        dst, dst, 16
+loopend
+        shrn       vend.8b, vhas_nul.8h, 4                 ; 128->64
+        fmov       synd, dend
+        sub        dst, dst, 31
+        rbit       synd, synd
+        clz        len, synd
+        lsr        len, len, 2
+        add        dst, dst, len
+        ldr        dataq, [dst, tmp]
+        str        dataq, [dst]
+        ret
+
+        LEAF_END
+
+        END
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strlen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strlen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..cfd0ac16018a3297654ae794e4b018526318a8a9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strlen.asm	
@@ -0,0 +1,138 @@
+;
+; strlen.asm
+;
+;      Copyright (c) Microsoft Corporation.  All rights reserved.
+;
+; Optimized strlen and strnlen implementations for ARM64.
+;
+#include "ksarm64.h"
+
+        ; size_t strlen(const char *str);                                // AV's when str == NULL
+        ; size_t strnlen(const char *str, size_t numberOfElements);      // AV's when str == NULL
+
+        ; This file could also define strnlen_s. strnlen_s is currently defined in the header string.h in C
+        ; using a check for null and a call to strnlen. This avoids making the call in the case where the string is null,
+        ; which should be infrequent. However it makes code larger by inlining that check everywhere strnlen_s is called.
+        ; A better alternative would be to modify the standard headers and define strnlen_s here. It would be just one
+        ; instruction because the required return value in x0 is already 0 when null is passed for the first parameter.
+        ;
+        ; EXPORT strnlen_s [FUNC]
+        ; LEAF_ENTRY strnlen_s
+        ; cbz     x0, AnyRet         ; add the label AnyRet in front of any ret instruction you want
+        ;                            ; fallthrough into strnlen code
+        ; ALTERNATE_ENTRY strnlen    ; change LEAF_ENTRY for strnlen to ALTERNATE_ENTRY
+        ; ...                        ; current body of strnlen
+        ; LEAF_END                   ; change strnlen leaf_end to strnlen_s.
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+        ; With strlen we will usually read some bytes past the end of the string. To avoid getting an AV
+        ; when a byte-by-byte implementation would not, we must ensure that we never cross a page boundary with a
+        ; vector load, so we must align the vector loads to 16-byte-aligned boundaries.
+        ;
+        ; For strnlen we know the buffer length and so we won't read any bytes beyond the end of the buffer. This means
+        ; we have a choice whether to arrange our vector loads to be 16-byte aligned. (Note that on arm64 a vector load
+        ; only produces an alignment fault when the vector *elements* are misaligned, so a "16B" vector load will never
+        ; give an alignment fault for user memory). Aligning the vector loads on 16-byte boundaries saves one cycle
+        ; per vector load instruction. The cost of forcing 16-byte aligned loads is the 10 instructions preceding the
+        ; 'NoNeedToAlign' label below. On Cortex-A57, the execution latency of those 10 instructions is 27 cycles,
+        ; assuming no branch mispredict on the 'beq'. To account for the cost of an occasional mispredict we guess a
+        ; mispredict rate of 2% and a mispredict cost of 50 cycles, or 1 cycle per call amortized, 28 total. 28 * 16 = 448.
+        ; In this analysis we are ignoring the chance of extra cache misses due to loads crossing cache lines when
+        ; they are not 16-byte aligned. When the vector loads span cache line boundaries each cache line is referenced
+        ; one more time than it is when the loads are aligned. But we assume that the cache line stays loaded for the
+        ; short time we need to do all the references to it, and so one extra reference won't matter.
+        ; It is expected that the number of cycles (28) will stay about the same for future processor models. If it
+        ; changes radically, it will be worth converting the EQU to a global, using ldr to load it instead of a
+        ; mov-immediate, and dynamically setting the global during CRT startup based on processor model.
+
+__strnlen_forceAlignThreshold  EQU 448                     ; code below assumes must be >= 32
+
+        ; If a strlen is performed on an unterminated buffer, strlen may try to access an invalid address
+        ; and generate an access violation. The prime imperative is for us not to generate an AV by loading
+        ; characters beyond the end of a valid string. But also, in the case of an invalid string that should
+        ; generate an AV, we need to have the AV report the proper bad address. If we only perform 16-byte aligned
+        ; vector loads then the first time we touch an invalid page we will be loading from offset 0 in that
+        ; page, which is the correct address for the AV to report. Even though we will usually load some bytes
+        ; from beyond the end of the string, we won't load bytes beyond the end of the page unless the string
+        ; extends into the next page. This is the primary purpose for forcing the vector loads to be
+        ; 16-byte aligned.
+
+        ; There is a slight performance boost for using aligned vector loads vs. unaligned ones but
+        ; it is only worth the cost of aligning for longer strings (at least 512 chars).
+
+        ; For strings less than 16 characters long the byte-by-byte loop will be about as fast as the
+        ; compiler could produce, so we're not losing any performance vs. compiled C in any case.
+
+#if !defined(_UPLEVEL_BUILD_)
+        ARM64EC_ENTRY_THUNK A64NAME(strlen),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(strlen),|.text$$mn$$21|,5
+#else
+        LEAF_ENTRY_COMDAT A64NAME(_strlen_unused_),|.text$$mn$$21|,5
+#endif
+
+        ; check for empty string to avoid huge perf degradation in this case.
+        ldrb    w2, [x0], #0
+        cbz     w2, EmptyStr
+
+        mov     x5, x0                                      ; keep original x0 value for the final 'sub'
+        ; calculate number of bytes until first 16-byte alignment point
+
+        ands    x1, x5, #15                                 ; x1 = (addr mod 16)
+        beq     StrlenMainLoop                              ; no need to force alignment if already aligned
+
+        ; we need to align, check whether we are within 16 bytes of the end of the page
+
+        ands    x2, x5, #4095
+        cmp     x2, #4080
+        bgt     AlignByteByByte                             ; too close to end of page, must align byte-by-byte
+
+        ; safe to do one unaligned 16-byte vector load to force alignment
+
+        ld1     v0.16b, [x5]                                ; don't post-increment x5
+        uminv   b1, v0.16b
+        fmov    w2, s1                                      ; fmov is sometimes 1 cycle faster than 'umov w2, v1.b[0]'
+        cbz     w2, FindNullInVector                        ; jump when string <= 15 bytes long & not near end of page
+        add     x5, x5, #16                                 ; move x5 forward only to aligned address
+        and     x5, x5, 0xFFFFFFFFFFFFFFF0                  ; first iter of StrlenMainLoop will retest some bytes we already tested
+
+StrlenMainLoop                                              ; test 16 bytes at a time until we find it
+        ld1     v0.16b, [x5], #16
+        uminv   b1, v0.16b                                  ; use unsigned min to look for a zero byte; too bad it doesn't set CC
+        fmov    w2, s1                                      ; need to move min byte into gpr to test it
+        cbnz    w2, StrlenMainLoop                          ; fall through when any one of the bytes in v0 is zero
+
+        sub     x5, x5, #16                                 ; undo the last #16 post-increment of x5
+
+FindNullInVector                                            ; this label is also the target of a jump from strnlen
+        cmeq    v0.16b, v0.16b, #0                          ; compute a 128-bit mask of 0xFF or 0x00
+        shrn    v0.8b, v0.8h, #4                            ; narrow the 128-bit mask to a 64-bit mask of 0xF or 0x0
+        fmov    x2, d0                                      ;
+        rbit    x2, x2                                      ; reverse the bit order for clz
+        clz     x2, x2                                      ; count the leading number of zeroes until the first bit set
+        add     x5, x5, x2, LSR #2                          ; which is the offset we need to add to x5 to point at the null byte
+        sub     x0, x5, x0                                  ; subtract ptr to null char from ptr to first char to get the strlen
+        ret
+
+ByteByByteFoundIt                                           ; this label is also the target of a jump from strnlen
+        sub     x5, x5, #1                                  ; Undo the final post-increment that happened on the load of the null char.
+        sub     x0, x5, x0                                  ; With x5 pointing at the null char, x5-x0 is the strlen
+        ret
+
+AlignByteByByte
+        sub     x1, x1, #16                                 ; x1 = (addr mod 16) - 16
+        neg     x1, x1                                      ; x1 = 16 - (addr mod 16) = count for byte-by-byte loop
+ByteByByteLoop                                              ; test one byte at a time until we are 16-byte aligned
+        ldrb    w2, [x5], #1
+        cbz     w2, ByteByByteFoundIt                       ; branch if byte-at-a-time testing finds the null
+        subs    x1, x1, #1
+        bgt     ByteByByteLoop                              ; fall through when not found and 16-byte aligned
+        b       StrlenMainLoop
+
+EmptyStr
+        mov     x0, 0
+        ret
+
+        LEAF_END
+
+        END
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strlen_spec_unaligned.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strlen_spec_unaligned.asm
new file mode 100644
index 0000000000000000000000000000000000000000..b19fa4b9c45480cee532f73f8492cb3c333c0a88
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strlen_spec_unaligned.asm	
@@ -0,0 +1,196 @@
+/*
+Copyright (c) 1999-2022, Arm Limited.
+Licensed under the MIT license.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ksarm64.h"
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+#define srcin       x0
+#define len         x0
+
+#define src         x1
+#define data1       x2
+#define data2       x3
+#define has_nul1    x4
+#define has_nul2    x5
+#define tmp1        x4
+#define tmp2        x5
+#define tmp3        x6
+#define tmp4        x7
+#define zeroones    x8
+
+#define maskv       v0
+#define maskd       d0
+#define dataq1      q1
+#define dataq2      q2
+#define datav1      v1
+#define datav2      v2
+#define tmp         x2
+#define tmpw        w2
+#define synd        x3
+#define syndw       w3
+#define shift       x4
+
+/* For the first 32 bytes, NUL detection works on the principle that
+   (X - 1) & (~X) & 0x80 (=> (X - 1) & ~(X | 0x7f)) is non-zero if a
+   byte is zero, and can be done in parallel across the entire word.  */
+
+#define REP8_01 0x0101010101010101
+#define REP8_7f 0x7f7f7f7f7f7f7f7f
+#define MIN_PAGE_SIZE 4096
+
+
+        /* Core algorithm:
+
+        Since strings are short on average, we check the first 32 bytes of the
+        string for a NUL character without aligning the string.  In order to use
+        unaligned loads safely we must do a page cross check first.
+
+        If there is a NUL byte we calculate the length from the 2 8-byte words
+        using conditional select to reduce branch mispredictions (it is unlikely
+        strlen will be repeatedly called on strings with the same length).
+
+        If the string is longer than 32 bytes, align src so we don't need further
+        page cross checks, and process 32 bytes per iteration using a fast SIMD
+        loop.
+
+        If the page cross check fails, we read 32 bytes from an aligned address,
+        and ignore any characters before the string.  If it contains a NUL
+        character, return the length, if not, continue in the main loop.  */
+
+#if !defined(_UPLEVEL_BUILD_)
+        ARM64EC_ENTRY_THUNK A64NAME(__strlen_spec_unaligned),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(__strlen_spec_unaligned),|.text$$mn$$21|,5
+#else
+        ARM64EC_ENTRY_THUNK A64NAME(strlen),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(strlen),|.text$$mn$$21|,5
+#endif
+
+        and        tmp1, srcin, MIN_PAGE_SIZE - 1
+        cmp        tmp1, MIN_PAGE_SIZE - 32
+        b.hi       page_cross
+
+        /* Look for a NUL byte in the first 16 bytes.  */
+        ldp        data1, data2, [srcin]
+        mov        zeroones, REP8_01
+
+        sub        tmp1, data1, zeroones
+        orr        tmp2, data1, REP8_7f
+        sub        tmp3, data2, zeroones
+        orr        tmp4, data2, REP8_7f
+        bics       has_nul1, tmp1, tmp2
+        bic        has_nul2, tmp3, tmp4
+        ccmp       has_nul2, 0, 0, eq
+        b.eq       bytes16_31
+
+        /* Find the exact offset of the first NUL byte in the first 16 bytes
+           from the string start.  Enter with C = has_nul1 == 0.  */
+        csel       has_nul1, has_nul1, has_nul2, cc
+        mov        len, 8
+        rev        has_nul1, has_nul1
+        csel       len, xzr, len, cc
+        clz        tmp1, has_nul1
+        add        len, len, tmp1, lsr 3
+        ret
+
+        /* Look for a NUL byte at offset 16..31 in the string.  */
+bytes16_31
+        ldp        data1, data2, [srcin, 16]
+        sub        tmp1, data1, zeroones
+        orr        tmp2, data1, REP8_7f
+        sub        tmp3, data2, zeroones
+        orr        tmp4, data2, REP8_7f
+        bics       has_nul1, tmp1, tmp2
+        bic        has_nul2, tmp3, tmp4
+        ccmp       has_nul2, 0, 0, eq
+        b.eq       loop_entry
+
+        /* Find the exact offset of the first NUL byte at offset 16..31 from
+           the string start.  Enter with C = has_nul1 == 0.  */
+        csel       has_nul1, has_nul1, has_nul2, cc
+        mov        len, 24
+        rev        has_nul1, has_nul1
+        mov        tmp3, 16
+        clz        tmp1, has_nul1
+        csel       len, tmp3, len, cc
+        add        len, len, tmp1, lsr 3
+        ret
+
+        nop
+loop_entry
+        bic        src, srcin, 31
+        b          loop
+
+        ALIGN 32
+loop
+        ldp        dataq1, dataq2, [src, 32]!
+        uminp      maskv.16b, datav1.16b, datav2.16b
+        uminp      maskv.16b, maskv.16b, maskv.16b
+        cmeq       maskv.8b, maskv.8b, 0
+        fmov       synd, maskd
+        cbz        synd, loop
+
+        /* Low 32 bits of synd are non-zero if a NUL was found in datav1.  */
+        cmeq       maskv.16b, datav1.16b, 0
+        sub        len, src, srcin
+        cbnz       syndw, %F1
+        cmeq       maskv.16b, datav2.16b, 0
+        add        len, len, 16
+1
+        /* Generate a bitmask and compute correct byte offset.  */
+        shrn       maskv.8b, maskv.8h, 4
+        fmov       synd, maskd
+        rbit       synd, synd
+        clz        tmp, synd
+        add        len, len, tmp, lsr 2
+        ret
+
+page_cross
+        bic        src, srcin, 31
+        mov        tmpw, 0x0c03
+        movk       tmpw, 0xc030, lsl 16
+        ld1        {datav1.16b, datav2.16b}, [src]
+        dup        maskv.4s, tmpw
+        cmeq       datav1.16b, datav1.16b, 0
+        cmeq       datav2.16b, datav2.16b, 0
+        and        datav1.16b, datav1.16b, maskv.16b
+        and        datav2.16b, datav2.16b, maskv.16b
+        addp       maskv.16b, datav1.16b, datav2.16b
+        addp       maskv.16b, maskv.16b, maskv.16b
+        fmov       synd, maskd
+        lsl        shift, srcin, 1
+        lsr        synd, synd, shift
+        cbz        synd, loop
+
+        rbit       synd, synd
+        clz        len, synd
+        lsr        len, len, 1
+        ret
+
+empty_str
+        mov        len, 0
+        ret
+
+        LEAF_END
+
+        END
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strncmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strncmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..b3c1785ab2ae04ecd808d948a00f82235fd1fb59
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strncmp.asm	
@@ -0,0 +1,244 @@
+/*
+Copyright (c) 1999-2022, Arm Limited.
+Licensed under the MIT license.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ksarm64.h"
+
+#if !defined(_M_ARM64EC)
+
+        EXPORT A64NAME(strncmp)    [FUNC]
+
+#endif
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+#define REP8_01 0x0101010101010101
+#define REP8_7f 0x7f7f7f7f7f7f7f7f
+
+#define src1        x0
+#define src2        x1
+#define limit       x2
+#define result      x0
+
+#define data1       x3
+#define data1w      w3
+#define data2       x4
+#define data2w      w4
+#define has_nul     x5
+#define diff        x6
+#define syndrome    x7
+#define tmp1        x8
+#define tmp2        x9
+#define tmp3        x10
+#define zeroones    x11
+#define pos         x12
+#define mask        x16
+#define endloop     x17
+#define count       mask
+#define offset      pos
+#define neg_offset  x15
+
+; NUL detection works on the principle that (X - 1) & (~X) & 0x80
+; (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and
+; can be done in parallel across the entire word.
+
+        ARM64EC_ENTRY_THUNK A64NAME(strncmp),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(strncmp),|.text$$mn$$21|,5
+
+        cbz     limit, ret0
+        eor     tmp1, src1, src2
+        mov     zeroones, #REP8_01
+        tst     tmp1, #7
+        and     count, src1, #7
+        bne     misaligned8
+        cbnz    count, mutual_align
+
+loop_aligned
+        ldr     data1, [src1], #8
+        ldr     data2, [src2], #8
+start_realigned
+        subs    limit, limit, #8
+        sub     tmp1, data1, zeroones
+        orr     tmp2, data1, #REP8_7f
+        eor     diff, data1, data2          ; Non-zero if differences found.
+        csinv   endloop, diff, xzr, hi      ; Last Dword or differences.
+        bics    has_nul, tmp1, tmp2         ; Non-zero if NUL terminator.
+        ccmp    endloop, #0, #0, eq
+        beq     loop_aligned
+        ; End of main loop
+
+full_check
+        orr     syndrome, diff, has_nul
+        add     limit, limit, 8              ; Rewind limit to before last subs.
+syndrome_check
+        ; Limit was reached. Check if the NUL byte or the difference
+        ; is before the limit.
+        rev     syndrome, syndrome
+        rev     data1, data1
+        clz     pos, syndrome
+        rev     data2, data2
+        lsl     data1, data1, pos
+        cmp     limit, pos, lsr #3
+        lsl     data2, data2, pos
+        ; But we need to zero-extend (char is unsigned) the value and then
+        ; perform a signed 32-bit subtraction.
+        lsr     data1, data1, #56
+        sub     result, data1, data2, lsr #56
+        csel    result, result, xzr, hi
+        ret
+
+mutual_align
+        ; Sources are mutually aligned, but are not currently at an
+        ; alignment boundary.  Round down the addresses and then mask off
+        ; the bytes that precede the start point.
+        ; We also need to adjust the limit calculations, but without
+        ; overflowing if the limit is near ULONG_MAX.
+        bic     src1, src1, #7
+        bic     src2, src2, #7
+        ldr     data1, [src1], #8
+        neg     tmp3, count, lsl #3          ; 64 - bits(bytes beyond align).
+        ldr     data2, [src2], #8
+        mov     tmp2, #~0
+        lsr     tmp2, tmp2, tmp3             ; Shift (count & 63).
+
+        ; Adjust the limit and ensure it doesn't overflow.
+        adds    limit, limit, count
+        csinv   limit, limit, xzr, lo
+        orr     data1, data1, tmp2
+        orr     data2, data2, tmp2
+        b       start_realigned
+
+        ; Don't bother with dwords for up to 16 bytes.
+misaligned8
+        cmp     limit, #16
+        bhs     try_misaligned_words
+
+byte_loop
+        ; Perhaps we can do better than this.
+        ldrb    data1w, [src1], #1
+        ldrb    data2w, [src2], #1
+        subs    limit, limit, #1
+        ccmp    data1w, #1, #0, hi          ; NZCV = 0b0000.
+        ccmp    data1w, data2w, #0, cs      ; NZCV = 0b0000.
+        beq     byte_loop
+done
+        sub     result, data1, data2
+        ret
+
+        ; Align the SRC1 to a dword by doing a bytewise compare and then do
+        ; the dword loop.
+try_misaligned_words
+        cbz     count, src1_aligned
+
+        neg     count, count
+        and     count, count, #7
+        sub     limit, limit, count
+
+page_end_loop
+        ldrb    data1w, [src1], #1
+        ldrb    data2w, [src2], #1
+        cmp     data1w, #1
+        ccmp    data1w, data2w, #0, cs      ; NZCV = 0b0000.
+        bne     done
+        subs    count, count, #1
+        bhi     page_end_loop
+
+        ; The following diagram explains the comparison of misaligned strings.
+        ; The bytes are shown in natural order. For little-endian, it is
+        ; reversed in the registers. The "x" bytes are before the string.
+        ; The "|" separates data that is loaded at one time.
+        ; src1     | a a a a a a a a | b b b c c c c c | . . .
+        ; src2     | x x x x x a a a   a a a a a b b b | c c c c c . . .
+
+        ; After shifting in each step, the data looks like this:
+        ;          STEP_A        ;     STEP_B        ;     STEP_C
+        ; data1    a a a a a a a a     b b b c c c c c     b b b c c c c c
+        ; data2    a a a a a a a a     b b b 0 0 0 0 0     0 0 0 c c c c c
+
+        ; The bytes with "0" are eliminated from the syndrome via mask.
+
+        ; Align SRC2 down to 16 bytes. This way we can read 16 bytes at a
+        ; time from SRC2. The comparison happens in 3 steps. After each step
+        ; the loop can exit, or read from SRC1 or SRC2.
+src1_aligned
+        ; Calculate offset from 8 byte alignment to string start in bits. No
+        ; need to mask offset since shifts are ignoring upper bits.
+        lsl     offset, src2, #3
+        bic     src2, src2, #0xf
+        mov     mask, -1
+        neg     neg_offset, offset
+        ldr     data1, [src1], #8
+        ldp     tmp1, tmp2, [src2], #16
+        lsl     mask, mask, neg_offset
+        and     neg_offset, neg_offset, #63  ; Need actual value for cmp later.
+        ; Skip the first compare if data in tmp1 is irrelevant.
+        tbnz    offset, 6, misaligned_mid_loop
+
+loop_misaligned
+        ; STEP_A: Compare full 8 bytes when there is enough data from SRC2.
+        lsr     data2, tmp1, offset
+        lsl     tmp1, tmp2, neg_offset
+        subs    limit, limit, #8
+        orr     data2, data2, tmp1           ; 8 bytes from SRC2 combined from two regs.
+        sub     has_nul, data1, zeroones
+        eor     diff, data1, data2           ; Non-zero if differences found.
+        orr     tmp3, data1, #REP8_7f
+        csinv   endloop, diff, xzr, hi       ; If limit, set to all ones.
+        bic     has_nul, has_nul, tmp3       ; Non-zero if NUL byte found in SRC1.
+        orr     tmp3, endloop, has_nul
+        cbnz    tmp3, full_check
+
+        ldr     data1, [src1], #8
+misaligned_mid_loop
+        ; STEP_B: Compare first part of data1 to second part of tmp2.
+        lsr     data2, tmp2, offset
+        sub     has_nul, data1, zeroones
+        orr     tmp3, data1, #REP8_7f
+        eor     diff, data2, data1           ; Non-zero if differences found.
+        bic     has_nul, has_nul, tmp3       ; Non-zero if NUL terminator.
+        cmp     limit, neg_offset, lsr #3
+        orr     syndrome, diff, has_nul
+        bic     syndrome, syndrome, mask     ; Ignore later bytes.
+        csinv   tmp3, syndrome, xzr, hi      ; If limit, set to all ones.
+        cbnz    tmp3, syndrome_check
+
+        ; STEP_C: Compare second part of data1 to first part of tmp1.
+        ldp     tmp1, tmp2, [src2], #16
+        cmp     limit, #8
+        lsl     data2, tmp1, neg_offset
+        eor     diff, data2, data1           ; Non-zero if differences found.
+        orr     syndrome, diff, has_nul
+        and     syndrome, syndrome, mask     ; Ignore earlier bytes.
+        csinv   tmp3, syndrome, xzr, hi      ; If limit, set to all ones.
+        cbnz    tmp3, syndrome_check
+
+        ldr     data1, [src1], #8
+        sub     limit, limit, #8
+        b       loop_misaligned
+
+ret0
+        mov     result, #0
+        ret
+
+        LEAF_END
+
+        END
\ No newline at end of file
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strnlen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strnlen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..7e4e067749339be16847501b73b128a50f535d2d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/strnlen.asm	
@@ -0,0 +1,114 @@
+/*
+Copyright (c) 1999-2022, Arm Limited.
+Licensed under the MIT license.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ksarm64.h"
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+#define srcin          x0
+#define cntin          x1
+#define result         x0
+#define src            x2
+#define synd           x3
+#define shift          x4
+#define tmp            x4
+#define cntrem         x5
+
+#define qdata          q0
+#define vdata          v0
+#define vhas_chr       v1
+#define vend           v2
+#define dend           d2
+
+/*
+   Core algorithm:
+   Process the string in 16-byte aligned chunks. Compute a 64-bit mask with
+   four bits per byte using the shrn instruction. A count trailing zeros then
+   identifies the first zero byte.  */
+
+        ARM64EC_ENTRY_THUNK A64NAME(strnlen),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(strnlen),|.text$$mn$$21|,5
+
+        bic        src, srcin, 15
+        cbz        cntin, nomatch
+        ld1        {vdata.16b}, [src]
+        cmeq       vhas_chr.16b, vdata.16b, 0
+        lsl        shift, srcin, 2
+        shrn       vend.8b, vhas_chr.8h, 4                /* 128->64 */
+        fmov       synd, dend
+        lsr        synd, synd, shift
+        cbz        synd, start_loop
+finish
+        rbit       synd, synd
+        clz        synd, synd
+        lsr        result, synd, 2
+        cmp        cntin, result
+        csel       result, cntin, result, ls
+        ret
+
+nomatch
+        mov        result, cntin
+        ret
+
+start_loop
+        sub        tmp, src, srcin
+        add        tmp, tmp, 17
+        subs       cntrem, cntin, tmp
+        b.lo       nomatch
+
+        /* Make sure that it won't overread by a 16-byte chunk */
+        tbz        cntrem, 4, loop32_2
+        sub        src, src, 16
+        b          loop32
+
+        ALIGN 32
+loop32
+        ldr        qdata, [src, 32]!
+        cmeq       vhas_chr.16b, vdata.16b, 0
+        umaxp      vend.16b, vhas_chr.16b, vhas_chr.16b                /* 128->64 */
+        fmov       synd, dend
+        cbnz       synd, end
+loop32_2
+        ldr        qdata, [src, 16]
+        subs       cntrem, cntrem, 32
+        cmeq       vhas_chr.16b, vdata.16b, 0
+        b.lo       end_2
+        umaxp      vend.16b, vhas_chr.16b, vhas_chr.16b                /* 128->64 */
+        fmov       synd, dend
+        cbz        synd, loop32
+end_2
+        add        src, src, 16
+end
+        shrn       vend.8b, vhas_chr.8h, 4                             /* 128->64 */
+        sub        result, src, srcin
+        fmov       synd, dend
+        rbit       synd, synd
+        clz        synd, synd
+        add        result, result, synd, lsr 2
+        cmp        cntin, result
+        csel       result, cntin, result, ls
+        ret
+
+        LEAF_END
+
+        END
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/wcscmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/wcscmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..0667703877f717b6950bebe1a21834f9895697d4
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/wcscmp.asm	
@@ -0,0 +1,185 @@
+/*
+Copyright (c) 1999-2022, Arm Limited.
+Licensed under the MIT license.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "ksarm64.h"
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=5
+
+#define REP4_0001  0x0001000100010001
+#define REP4_7fff  0x7fff7fff7fff7fff
+
+#define src1       x0
+#define src2       x1
+#define result     x0
+
+#define data1      x2
+#define data1w     w2
+#define data2      x3
+#define data2w     w3
+#define has_nul    x4
+#define diff       x5
+#define off1       x5
+#define syndrome   x6
+#define tmp        x6
+#define data3      x7
+#define zeroones   x8
+#define shift      x9
+#define off2       x10
+#define tmp2       x11
+
+; NUL detection works on the principle that (X - 1) & (~X) & 0x8000
+; (=> (X - 1) & ~(X | 0x7fff)) is non-zero iff a byte is zero, and
+; can be done in parallel across the entire word.
+
+        ARM64EC_ENTRY_THUNK A64NAME(wcscmp),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(wcscmp),|.text$$mn$$21|,5
+
+        orr    tmp2, src2, src1          ; if src2 or src1 is an odd number
+        tbnz   tmp2, #0, odd_loop        ; fall back to wchar-by-wchar loop
+        sub    off2, src2, src1
+        mov    zeroones, REP4_0001
+        and    tmp, src1, 7
+        tst    off2, 7
+        bne    misaligned8
+        cbnz   tmp, mutual_align
+
+loop_aligned
+        ldr    data2, [src1, off2]
+        ldr    data1, [src1], 8
+
+start_realigned
+        sub    has_nul, data1, zeroones
+        orr    tmp, data1, REP4_7fff
+        bics   has_nul, has_nul, tmp    ; Non-zero if NUL terminator.
+        ccmp   data1, data2, 0, eq
+        beq    loop_aligned
+        eor    diff, data1, data2
+        orr    syndrome, diff, has_nul
+
+end
+        rev    syndrome, syndrome
+        rev16  syndrome, syndrome
+        rev    data1, data1
+        rev16  data1, data1
+        rev    data2, data2
+        rev16  data2, data2
+        clz    shift, syndrome
+        ; The most-significant-non-zero bit of the syndrome marks either the
+        ; first bit that is different, or the top bit of the first zero byte.
+        ; Shifting left now will bring the critical information into the
+        ; top bits.
+        lsl    data1, data1, shift
+        lsl    data2, data2, shift
+        ; But we need to zero-extend (char is unsigned) the value and then
+        ; perform a signed 32-bit subtraction.
+        lsr    data1, data1, 48
+        cmp    data1, data2, lsr 48
+
+        ; Although the C/C++ standard does not regulate the return value if
+        ; it is non-zero, MS strcmp implementation has been returning 1, 0,
+        ; -1 historically. To maximize compat, we normalize the result before
+        ; returning.
+normalize_result
+        csetm  tmp, lt
+        csinc  result, tmp, xzr, le
+        ret
+
+mutual_align
+        ; Sources are mutually aligned, but are not currently at an
+        ; alignment boundary.  Round down the addresses and then mask off
+        ; the bytes that precede the start point.
+        bic    src1, src1, 7
+        ldr    data2, [src1, off2]
+        ldr    data1, [src1], 8
+        neg    shift, src2, lsl 3    ; Bits to alignment -64.
+        mov    tmp, -1
+        lsr    tmp, tmp, shift
+        orr    data1, data1, tmp
+        orr    data2, data2, tmp
+        b      start_realigned
+
+misaligned8
+        ; Align SRC1 to 8 bytes and then compare 8 bytes at a time, always
+        ; checking to make sure that we don't access beyond the end of SRC2.
+        cbz    tmp, src1_aligned
+
+do_misaligned
+        ldrh   data1w, [src1], 2
+        ldrh   data2w, [src2], 2
+        cmp    data1w, 0
+        ccmp   data1w, data2w, 0, ne    ; NZCV = 0b0000.
+        bne    done
+        tst    src1, 7
+        bne    do_misaligned
+
+src1_aligned
+        neg    shift, src2, lsl 3
+        bic    src2, src2, 7
+        ldr    data3, [src2], 8
+        lsr    tmp, zeroones, shift
+        orr    data3, data3, tmp
+        sub    has_nul, data3, zeroones
+        orr    tmp, data3, REP4_7fff
+        bics   has_nul, has_nul, tmp
+        bne    tail
+
+        sub    off1, src2, src1
+
+loop_unaligned
+        ldr    data3, [src1, off1]
+        ldr    data2, [src1, off2]
+        sub    has_nul, data3, zeroones
+        orr    tmp, data3, REP4_7fff
+        ldr    data1, [src1], 8
+        bics   has_nul, has_nul, tmp
+        ccmp   data1, data2, 0, eq
+        beq    loop_unaligned
+
+        lsl    tmp, has_nul, shift
+        eor    diff, data1, data2
+        orr    syndrome, diff, tmp
+        cbnz   syndrome, end
+
+tail
+        ldr    data1, [src1]
+        neg    shift, shift
+        lsr    data2, data3, shift
+        lsr    has_nul, has_nul, shift
+        eor    diff, data1, data2
+        orr    syndrome, diff, has_nul
+        b      end
+
+odd_loop
+        ldrh   data1w, [src1], 2
+        ldrh   data2w, [src2], 2
+        cmp    data1w, 0
+        ccmp   data1w, data2w, 0, ne
+        beq    odd_loop
+
+done
+        cmp    data1, data2
+        b      normalize_result
+
+        LEAF_END
+
+        END
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/wcslen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/wcslen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..72becacb7acff7ef59f938e00243e14565d699b0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64/wcslen.asm	
@@ -0,0 +1,266 @@
+;
+; wcslen.asm
+;
+;      Copyright (c) Microsoft Corporation.  All rights reserved.
+;
+; Optimized wcslen and wcsnlen implementations for ARM64.
+;
+#include "ksarm64.h"
+
+        ; size_t wcslen(const wchar_t *str);
+        ; size_t wcsnlen(const wchar_t *str, size_t numberOfElements);
+
+        ; This file could also define wcsnlen_s. wcsnlen_s is currently defined in the headers (string.h & wchar.h) in C
+        ; using a check for null and a call to wcsnlen. This avoids making the call in the case where the string is null,
+        ; which should be infrequent. However it makes code larger by inlining that check everywhere wcsnlen_s is called.
+        ; An alternative would be to modify the standard headers and define wcsnlen_s here. It would be just one instruction:
+        ;
+        ; LEAF_ENTRY wcsnlen_s
+        ; cbz     x0, AnyRet         ; AnyRet would be a label in front of any ret instruction. Return value in x0 is already 0.
+        ;                            ; fallthrough into wcsnlen code
+        ; ALTERNATE_ENTRY wcsnlen    ; change LEAF_ENTRY for wcsnlen to ALTERNATE_ENTRY
+        ; ...
+
+        ; Note: this code assumes that the input parameter is always aligned to an even byte boundary.
+
+#if !defined(_M_ARM64EC)
+
+        EXPORT A64NAME(wcslen)    [FUNC]
+        EXPORT A64NAME(wcsnlen)   [FUNC]
+
+#endif
+
+        AREA |.text$mn$21|, CODE, READONLY, ALIGN=6
+
+        ; With wcslen we will usually read some chars past the end of the string. To avoid getting an AV
+        ; when a char-by-char implementation would not, we have to ensure that we never cross a page boundary with a
+        ; vector load, so we must align the vector loads to 16-byte-aligned boundaries.
+        ;
+        ; For wcsnlen we know the buffer length and so we won't read any chars beyond the end of the buffer. This means
+        ; we have a choice whether to arrange our vector loads to be 16-byte aligned. (Note that on arm64 a vector load
+        ; only produces an alignment fault when the vector *elements* are misaligned, so an "8H" vector load will never
+        ; give an alignment fault on any even address). Aligning the vector loads on 16-byte boundaries saves one cycle
+        ; per vector load instruction. The cost of forcing 16-byte aligned loads is the 10 instructions preceding the
+        ; 'NoNeedToAlign' label below. On Cortex-A57, the execution latency of those 10 instructions is 26 cycles,
+        ; (one less than the strnlen case because uminv is 1 cycle faster for halfwords than it is for bytes),
+        ; assuming no branch mispredict on the 'beq'. To account for the cost of an occasional mispredict we guess a
+        ; mispredict rate of 2% and a mispredict cost of 50 cycles, or 1 cycle per call amortized, 27 total. 27 * 8 = 216.
+        ; In this analysis we are ignoring the chance of extra cache misses due to loads crossing cache lines when
+        ; they are not 16-byte aligned. When the vector loads span cache line boundaries each cache line is referenced
+        ; one more time than it is when the loads are aligned. But we assume that the cache line stays loaded for the
+        ; short time we need to do all the references to it, and so one extra reference won't matter.
+        ; It is expected that the number of cycles (27) will stay about the same for future processor models. If it
+        ; changes radically, it will be worth converting the EQU to a global, using ldr to load it instead of a
+        ; mov-immediate, and dynamically setting the global during CRT startup based on processor model.
+
+__wcsnlen_forceAlignThreshold  EQU 216                      ; code logic below assumes >= 16
+
+        ARM64EC_ENTRY_THUNK A64NAME(wcslen),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(wcslen),|.text$$mn$$21|,6
+
+        ; check for empty string to avoid huge perf degradation in this case.
+        ldrh    w2, [x0], #0
+        cbz     w2, EmptyStr
+
+        mov     x5, x0                                      ; keep original x0 value for the final 'sub'
+        tbnz    x0, #0, WCharAtATime                        ; check for misaligned characters. Must go char-by-char when
+                                                            ; misaligned so that if there's an access violation it gets
+                                                            ; generated on the correct address (one byte into a new page
+                                                            ; instead of up to 15 bytes in if we had loaded a vector
+                                                            ; from the last byte of the previous page)
+
+        ; calculate number of bytes until first 16-byte alignment point
+
+        ands    x1, x5, #15                                 ; x1 = (addr mod 16)
+        beq     WcslenMainLoop                              ; no need to force alignment if already aligned
+
+        ; we need to align, check whether we are within 16 bytes of the end of the page.
+        ; branch if ((address mod PAGESIZE - 1) > (PAGESIZE - 16))
+
+        and     x2, x5, #4095                               ; x2 = address mod (PAGESIZE - 1)
+        cmp     x2, #4080                                   ; compare x2 to (PAGESIZE - 16)
+        bgt     AlignSlowly                                 ; too close to end of page, must align one wchar at a time
+
+        ; AlignFast: safe to do one 2-byte aligned vector load to force alignment to a 16-byte boundary
+
+        ld1     v0.8h, [x5]                                 ; don't post-increment x5
+        uminv   h1, v0.8h
+        fmov    w2, s1                                      ; fmov is sometimes 1 cycle faster than "umov w2, v1.h[0]"
+        cbz     w2, FindWideNullInVector                    ; jump when string < 15 bytes (<= 7 wchar_t's) long & not near end of page
+        add     x5, x5, #16                                 ; move x5 forward only to aligned address.  (Assumes even address)
+        and     x5, x5, 0xFFFFFFFFFFFFFFF0                  ; first iter of StrlenMainLoop will retest some bytes we already tested
+
+        ; The code at WcslenMainLoop should be 64-byte aligned for best performance.
+        ; Due to VSO#1106651, automatic padding with NOPs when in code areas is
+        ; broken. The workaround is to use -721215457.
+        ; MSFT:21876224 tracks removal of this workaround.
+        ALIGN 64,0,-721215457,4
+
+WcslenMainLoop                                              ; test 8 wchar_t's at a time until we find it
+        ld1     v0.8h, [x5], #16
+        uminv   h1, v0.8h                                   ; use unsigned min to look for a zero wchar_t; too bad it doesn't set CC
+        fmov    w2, s1                                      ; need to move min wchar_t into gpr to test it
+        cbnz    w2, WcslenMainLoop                          ; fall through when any one of the wchar_ts in v0 is zero
+
+        sub     x5, x5, #16                                 ; undo the last #16 post-increment of x5
+
+FindWideNullInVector
+        cmeq    v0.8h, v0.8h, #0                            ; compute a 128-bit mask of 0xFFFF or 0x0000
+        shrn    v0.8b, v0.8h, #4                            ; narrow the 128-bit mask to a 64-bit mask of 0xFF or 0x00
+        fmov    x2, d0                                      ;
+        rbit    x2, x2                                      ; reverse the bit order for clz
+        clz     x2, x2                                      ; count the leading number of zeroes until the first bit set
+        lsr     x2, x2, #3                                  ; right-shift x2 by 3 to calculate the byte position for zero wchar_t
+
+        sub     x0, x5, x0                                  ; subtract ptr to null char from ptr to first char to get the string length in bytes
+        add     x0, x2, x0, ASR #1                          ; divide x0 by 2 to get the number of wide chars and then add in the final vector char pos
+        ret
+
+AlignSlowly
+        sub     x1, x1, #16                                 ; x1 = (addr mod 16) - 16
+        sub     x1, xzr, x1, ASR #1                         ; x1 = -(((addr mod 16) - 16) / 2) = (16 - (addr mod 16)) / 2 = num wchar_ts
+
+AlignLoop                                                   ; test one wchar_t at a time until we are 16-byte aligned
+        ldrh    w2, [x5], #2
+        cbz     w2, OneByOneFoundIt                         ; branch if found the null
+        subs    x1, x1, #1
+        bgt     AlignLoop                                   ; fall through when not found and reached 16-byte alignment
+        b       WcslenMainLoop
+
+WCharAtATime
+        ldrh    w2, [x5], #2
+        cbnz    w2, WCharAtATime                            ; when found use same exit sequence as when found during slow alignment
+
+OneByOneFoundIt
+        sub     x5, x5, #2                                  ; Undo the final post-increment that happened on the load of the null wchar_t.
+        sub     x0, x5, x0                                  ; With x5 pointing at the null char, x5-x0 is the length in bytes
+        asr     x0, x0, #1                                  ; divide by 2 to get length in wchar_ts
+        ret
+
+EmptyStr
+        mov     x0, 0
+        ret
+
+        LEAF_END
+
+        ARM64EC_ENTRY_THUNK A64NAME(wcsnlen),1,0,|.text$$mn$$21|
+        LEAF_ENTRY A64NAME(wcsnlen),|.text$$mn$$21|,5
+
+        mov     x5, x0                                      ; keep original x0 value for the final 'sub'
+
+        tbnz    x0, #0, ShortWcsnlen                        ; check for misaligned characters; must go char-by-char if misaligned
+
+        cmp     x1, #8                                      ; x1 has length. When x1 < 8 we have to go char-by-char
+        blo     ShortWcsnlen                                ; only do char-by-char for 0 to 7 characters
+
+        ands    x3, x5, #15                                 ; x3 = start address mod 16
+        beq     NoNeedToAlign                               ; branch on x3 == 0 because it's already aligned
+
+        ; we need to align, check whether we are within 16 bytes of the end of the page.
+        ; branch if ((address mod PAGESIZE - 1) > (PAGESIZE - 16))
+
+        and     x2, x5, #4095                               ; x2 = address mod (PAGESIZE - 1)
+        cmp     x2, #4080                                   ; compare x2 to (PAGESIZE - 16)
+        bgt     AlignSlowly_Wcsnlen                         ; too close to end of page, must align one wchar at a time
+
+        ; force vector loads in the main loop to be 16-byte aligned
+        sub     x3, x3, #16                                 ; x3 = (start address mod 16) - 16
+        neg     x3, x3                                      ; x3 = 16 - (start address mod 16) = number of *bytes* to advance to get aligned
+        ld1     v0.8h, [x5]                                 ; don't post-increment x5
+        uminv   h1, v0.8h
+        fmov    w2, s1                                      ; fmov is sometimes 1 cycle faster than "umov w2, v1.h[0]"
+        cbz     w2, FindWideNullInVector_Wcsnlen            ; jump when found null within first 8 wchar_t's
+        sub     x1, x1, x3, ASR #1                          ; reduce elements remaining by number of wchar_t's needed to get aligned (bytes/2)
+        add     x5, x5, x3                                  ; move x5 forward by x3 bytes, so x5 is now a 16-byte aligned address
+ResumeAfterAlignSlowly
+        cmp     x1, #8                                      ; check for size < 8 after alignment adjustment
+        blo     ShortWcsnlen
+NoNeedToAlign
+        asr     x3, x1, #3                                  ; set up interations remaining after alignment point reached (8 wchar_t's per iteration)
+                                                            ; no need to check here for x3 == 0 because:
+                                                            ; - if we didn't align it, it is at least 16 bytes long
+                                                            ; - if we did align it, we checked for <16 before coming here
+WcsNlenMainLoop                                             ; test 8 wchar_t's at a time until we find it
+        ld1     v0.8h, [x5], #16
+        uminv   h1, v0.8h                                   ; use unsigned min to look for a zero wchar_t
+        fmov    w2, s1                                      ; need to move min wchar_t into gpr to test it
+        cbz     w2, UndoPI_FindNullInVector                 ; jump out and over into wcslen function when any one of the wchar_t's in v0 is zero
+        subs    x3, x3, #1
+        bne     WcsNlenMainLoop
+
+        ands    x1, x1, #7                                  ; check for remainder
+        beq     WcsNLenOverrun                              ; orig buffer size was multiple of 8 wchar_t's so no remainder; goto overrun case
+
+        ; We're less than 8 wchar_t's from the end of the buffer and haven't found a '\0\0' yet. We know we were originally longer than
+        ; 16 bytes so we can do a 2-byte aligned vector compare of the last 8 wchar_t's of the buffer, overlapping with some wchar_t's
+        ; we already know are non-zero, without fear of underrunning the original front of the buffer. This avoids a more costly
+        ; char-by-char comparison for the remainder (which would average 32 instructions executed and two branch mispredicts).
+        ; At this point:
+        ; x5 points at one of the last 7 wchar_t's of the buffer
+        ; x1 has the number of wchar_t's remaining in the buffer. 1 <= x1 <= 7
+        ; 8 - x1 is the number of wchar_t's we have to 'back up', LSL that by 1 to get bytes
+FastRemainderHandling
+        sub     x1, x1, #8
+        neg     x1, x1                                      ; x1 = (8 - number of chars remaining); the number of wchar_t's to back up.
+        sub     x5, x5, x1, LSL #1                          ; x5 = x5 - (2*x1); back up number of bytes equivalent to x1 wchar_t's
+        ld1     v0.8h, [x5], #16                            ; load all of remainder and some already-checked wchar_t's.
+        uminv   h1, v0.8h
+        fmov    w2, s1                                      ; fmov is sometimes 1 cycle faster than "umov w2, v1.h[0]"
+        cbz     w2, UndoPI_FindNullInVector                 ; found a '\0\0' within the last 8 elements of the buffer
+        b       WcsNLenOverrun                              ; else x5 points one past end of buffer, and we're all set for the overrun exit.
+
+ShortWcsnlen
+        cbz     x1, WcsNLenOverrun                          ; if original number of elements was zero, we must return 0 without touching the buffer
+
+ShortWcsNLenLoop
+        ldrh    w2, [x5], #2
+        cbz     w2, OneByOneFoundIt_Wcsnlen                 ; jump into other function to avoid code duplication of exit sequence
+        subs    x1, x1, #1
+        bhi     ShortWcsNLenLoop
+
+WcsNLenOverrun
+        sub     x0, x5, x0                                  ; x5 points one past the end of the buffer, x5-x0 is original buffer size in bytes
+        asr     x0, x0, #1                                  ; adjust return value from bytes to wchar_t elements
+                                                            ; as an alternative to the above two instructions, we could save the original x1 value
+                                                            ; and just move that to x0 here, but that would add an instruction to all paths in order
+                                                            ; to save one here that's only on the overrun path. So we reconstruct the value instead.
+        ret
+
+AlignSlowly_Wcsnlen
+        sub     x3, x3, #16                                 ; x3 = (addr mod 16) - 16
+        sub     x3, xzr, x3, ASR #1                         ; x3 = -(((addr mod 16) - 16) / 2) = (16 - (addr mod 16)) / 2 = num wchar_ts
+
+AlignLoop_Wcsnlen                                           ; test one wchar_t at a time until we are 16-byte aligned
+        ldrh    w2, [x5], #2
+        cbz     w2, OneByOneFoundIt_Wcsnlen                 ; branch if found the null
+        subs    x1, x1, #1
+        beq     OneByOneReachedMax_Wcsnlen                  ; branch if byte-at-a-time testing reached end of buffer count
+        subs    x3, x3, #1
+        bgt     AlignLoop_Wcsnlen                           ; fall through when not found and reached 16-byte alignment
+        b       ResumeAfterAlignSlowly
+
+OneByOneFoundIt_Wcsnlen
+        sub     x5, x5, #2                                  ; Undo the final post-increment that happened on the load of the null wchar_t.
+OneByOneReachedMax_Wcsnlen
+        sub     x0, x5, x0                                  ; With x5 pointing at the null char, x5-x0 is the length in bytes
+        asr     x0, x0, #1                                  ; divide by 2 to get length in wchar_ts
+        ret
+
+UndoPI_FindNullInVector
+        sub     x5, x5, #16                                 ; undo the last #16 post-increment of x5
+
+FindWideNullInVector_Wcsnlen
+        cmeq    v0.8h, v0.8h, #0                            ; compute a 128-bit mask of 0xFFFF or 0x0000
+        shrn    v0.8b, v0.8h, #4                            ; narrow the 128-bit mask to a 64-bit mask of 0xFF or 0x00
+        fmov    x2, d0                                      ;
+        rbit    x2, x2                                      ; reverse the bit order for clz
+        clz     x2, x2                                      ; count the leading number of zeroes until the first bit set
+        lsr     x2, x2, #3                                  ; right-shift x2 by 3 to calculate the byte position for zero wchar_t
+
+        sub     x0, x5, x0                                  ; subtract ptr to null char from ptr to first char to get the string length in bytes
+        add     x0, x2, x0, ASR #1                          ; divide x0 by 2 to get the number of wide chars and then add in the final vector char pos
+        ret
+
+        LEAF_END 
+
+        END
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strcmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strcmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..35a47873bb7d2daab6513be51c29d3ff0890f69b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strcmp.asm	
@@ -0,0 +1 @@
+#include "..\arm64\strcmp.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strcpy.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strcpy.asm
new file mode 100644
index 0000000000000000000000000000000000000000..4f881d966ec49617ea7f7978f56bb32b227fed9f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strcpy.asm	
@@ -0,0 +1 @@
+#include "..\arm64\strcpy.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strlen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strlen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..fbd20be27953127d5dea9905bff71993858ee627
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strlen.asm	
@@ -0,0 +1 @@
+#include "..\arm64\strlen.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strlen_spec_unaligned.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strlen_spec_unaligned.asm
new file mode 100644
index 0000000000000000000000000000000000000000..221a23115541147df849f40ca711324482226523
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strlen_spec_unaligned.asm	
@@ -0,0 +1 @@
+#include "..\arm64\strlen_spec_unaligned.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strncmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strncmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..fda9fc3ad459bca763758f118c6f9ad985b66eff
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strncmp.asm	
@@ -0,0 +1 @@
+#include "..\arm64\strncmp.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strnlen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strnlen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..b3bf3ac9ab21445b1ad2c5ee57f1191b5a1c9a38
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/strnlen.asm	
@@ -0,0 +1 @@
+#include "..\arm64\strnlen.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/wcscmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/wcscmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..64e994baf5497ea24b6604f453ab876b3a7e148e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/wcscmp.asm	
@@ -0,0 +1 @@
+#include "..\arm64\wcscmp.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/wcslen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/wcslen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..07d30610f8d1c6db36818f1affc8b3c57bd077e7
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/arm64ec/wcslen.asm	
@@ -0,0 +1 @@
+#include "..\arm64\wcslen.asm"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/_memicmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/_memicmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..4beccabd8cfc703c4ed20ad6d1d1278882ef1297
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/_memicmp.asm	
@@ -0,0 +1,130 @@
+        page        ,132
+        title        memicmp - compare blocks of memory, ignore case
+;***
+;memicmp.asm - compare memory, ignore case
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines __ascii_memicmp() - compare two blocks of memory for lexical
+;       order. Case is ignored in the comparison.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;int __ascii_memicmp(first, last, count) - compare two blocks of memory, ignore case
+;
+;Purpose:
+;       Compares count bytes of the two blocks of memory stored at first
+;       and last.  The characters are converted to lowercase before
+;       comparing (not permanently), so case is ignored in the search.
+;
+;       Algorithm:
+;       int
+;       _memicmp (first, last, count)
+;               char *first, *last;
+;               unsigned count;
+;               {
+;               if (!count)
+;                       return(0);
+;               while (--count && tolower(*first) == tolower(*last))
+;                       {
+;                       first++;
+;                       last++;
+;                       }
+;               return(tolower(*first) - tolower(*last));
+;               }
+;
+;Entry:
+;       char *first, *last - memory buffers to compare
+;       unsigned count - maximum length to compare
+;
+;Exit:
+;       returns <0 if first < last
+;       returns 0 if first == last
+;       returns >0 if first > last
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  __ascii_memicmp
+__ascii_memicmp proc \
+        uses edi esi ebx, \
+        first:ptr byte, \
+        last:ptr byte, \
+        count:IWORD
+
+        mov     ecx,[count]     ; cx = count
+        or      ecx,ecx
+        jz      short toend     ; if count=0, nothing to do
+
+        mov     esi,[first]     ; si = first
+        mov     edi,[last]      ; di = last
+
+        ; C locale
+
+        mov     bh,'A'
+        mov     bl,'Z'
+        mov     dh,'a'-'A'      ; add to cap to make lower
+
+        align   4
+
+lupe:
+        mov     ah,[esi]        ; ah = *first
+        add     esi,1           ; first++
+        mov     al,[edi]        ; al = *last
+        add     edi,1           ; last++
+
+        cmp     ah,al           ; test for equality BEFORE converting case
+        je      short dolupe
+
+        cmp     ah,bh           ; ah < 'A' ??
+        jb      short skip1
+
+        cmp     ah,bl           ; ah > 'Z' ??
+        ja      short skip1
+
+        add     ah,dh           ; make lower case
+
+skip1:
+        cmp     al,bh           ; al < 'A' ??
+        jb      short skip2
+
+        cmp     al,bl           ; al > 'Z' ??
+        ja      short skip2
+
+        add     al,dh           ; make lower case
+
+skip2:
+        cmp     ah,al           ; *first == *last ??
+        jne     short differ    ; nope, found mismatched chars
+
+dolupe:
+        sub     ecx,1
+        jnz     short lupe
+
+        jmp     short toend     ; cx = 0, return 0
+
+differ:
+        mov     ecx,-1          ; assume last is bigger
+                                ; *** can't use "or ecx,-1" due to flags ***
+        jb      short toend     ; last is, in fact, bigger (return -1)
+        neg     ecx             ; first is bigger (return 1)
+
+toend:
+        mov     eax,ecx         ; move return value to ax
+
+        ret                     ; _cdecl return
+
+__ascii_memicmp endp
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/_strnicm.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/_strnicm.asm
new file mode 100644
index 0000000000000000000000000000000000000000..312f49166dd855463a7af3d438a7f77f58f2f4a1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/_strnicm.asm	
@@ -0,0 +1,143 @@
+        page    ,132
+        title   strnicmp - compare n chars of strings, ignore case
+;***
+;strnicmp.asm - compare n chars of strings, ignoring case
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines __ascii_strnicmp() - Compares at most n characters of two
+;       strings, without regard to case.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;int __ascii_strnicmp(first, last, count) - compares count char of strings,
+;       ignore case
+;
+;Purpose:
+;       Compare the two strings for lexical order.  Stops the comparison
+;       when the following occurs: (1) strings differ, (2) the end of the
+;       strings is reached, or (3) count characters have been compared.
+;       For the purposes of the comparison, upper case characters are
+;       converted to lower case.
+;
+;       Algorithm:
+;       int
+;       _strncmpi (first, last, count)
+;             char *first, *last;
+;             unsigned int count;
+;             {
+;             int f,l;
+;             int result = 0;
+;
+;             if (count) {
+;                     do      {
+;                             f = tolower(*first);
+;                             l = tolower(*last);
+;                             first++;
+;                             last++;
+;                             } while (--count && f && l && f == l);
+;                     result = f - l;
+;                     }
+;             return(result);
+;             }
+;
+;Entry:
+;       char *first, *last - strings to compare
+;       unsigned count - maximum number of characters to compare
+;
+;Exit:
+;       returns <0 if first < last
+;       returns 0 if first == last
+;       returns >0 if first > last
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  __ascii_strnicmp
+__ascii_strnicmp proc \
+        uses edi esi ebx, \
+        first:ptr byte, \
+        last:ptr byte, \
+        count:IWORD
+
+        mov     ecx,[count]     ; cx = byte count
+        or      ecx,ecx
+        jz      toend           ; if count = 0, we are done
+
+        mov     esi,[first]     ; si = first string
+        mov     edi,[last]      ; di = last string
+
+        mov     bh,'A'
+        mov     bl,'Z'
+        mov     dh,'a'-'A'      ; add to cap to make lower
+
+        align   4
+
+lupe:
+        mov     ah,[esi]        ; *first
+
+        or      ah,ah           ; see if *first is null
+
+        mov     al,[edi]        ; *last
+
+        jz      short eject     ;   jump if *first is null
+
+        or      al,al           ; see if *last is null
+        jz      short eject     ;   jump if so
+
+        add     esi,1           ; first++
+        add     edi,1           ; last++
+
+        cmp     ah,bh           ; 'A'
+        jb      short skip1
+
+        cmp     ah,bl           ; 'Z'
+        ja      short skip1
+
+        add     ah,dh           ; make lower case
+
+skip1:
+        cmp     al,bh           ; 'A'
+        jb      short skip2
+
+        cmp     al,bl           ; 'Z'
+        ja      short skip2
+
+        add     al,dh           ; make lower case
+
+skip2:
+        cmp     ah,al           ; *first == *last ??
+        jne     short differ
+
+        sub     ecx,1
+        jnz     short lupe
+
+eject:
+        xor     ecx,ecx
+        cmp     ah,al           ; compare the (possibly) differing bytes
+        je      short toend     ; both zero; return 0
+
+differ:
+        mov     ecx,-1          ; assume last is bigger (* can't use 'or' *)
+        jb      short toend     ; last is, in fact, bigger (return -1)
+        neg     ecx             ; first is bigger (return 1)
+
+toend:
+        mov     eax,ecx
+
+        ret                     ; _cdecl return
+
+__ascii_strnicmp endp
+         end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/memccpy.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/memccpy.asm
new file mode 100644
index 0000000000000000000000000000000000000000..8b2df73a030bc8f6de38cd5c636b6f599aa7db58
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/memccpy.asm	
@@ -0,0 +1,135 @@
+        page    ,132
+        title   memccpy - copy bytes until character found
+;***
+;memccpy.asm - copy bytes until a character is found
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines _memccpy() - copies bytes until a specifed character
+;       is found, or a maximum number of characters have been copied.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;char *_memccpy(dest, src, _c, count) - copy bytes until character found
+;
+;Purpose:
+;       Copies bytes from src to dest until count bytes have been
+;       copied, or up to and including the character _c, whichever
+;       comes first.
+;
+;       Algorithm:
+;       char *
+;       _memccpy (dest, src, _c, count)
+;             char *dest, *src, _c;
+;             unsigned int count;
+;             {
+;             while (count && (*dest++ = *src++) != _c)
+;                     count--;
+;
+;             return(count ? dest : NULL);
+;             }
+;
+;Entry:
+;       char *dest - pointer to memory to receive copy
+;       char *src - source of bytes
+;       char _c - character to stop copy at
+;       int count - max number of bytes to copy
+;
+;Exit:
+;       returns pointer to byte immediately after _c in dest;
+;       returns NULL if _c was never found
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  _memccpy
+_memccpy proc \
+        dest:ptr byte, \
+        src:ptr byte, \
+        _c:byte, \
+        count:DWORD
+
+        OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+        .FPO    ( 0, 4, 0, 0, 0, 0 )
+
+        mov     ecx,[esp + 10h] ; ecx = max byte count
+        push    ebx             ; save ebx
+
+        test    ecx,ecx         ; if it's nothing to move
+        jz      ret_zero_len    ; restore ebx, and return NULL
+
+        mov     bh,[esp + 10h]  ; bh = byte to look for
+        push    esi             ; save esi
+
+        test    ecx,1           ; test if counter is odd or even
+
+        mov     eax,[esp + 0ch] ; eax = dest   , don't affect flags
+        mov     esi,[esp + 10h] ; esi = source , don't affect flags
+
+;       nop
+        jz      lupe2           ; if counter is even, do double loop
+                                ; else do one iteration, and drop into double loop
+        mov     bl,[esi]        ; get first byte into bl
+        add     esi,1           ; kick src (esi points to src)
+
+        mov     [eax],bl        ; store it in dest
+        add     eax,1           ; kick dest
+
+        cmp     bl,bh           ; see if we just moved the byte
+        je      short toend
+
+        sub     ecx,1           ; decrement counter
+        jz      retnull         ; drop into double loop if nonzero
+
+lupe2:
+        mov     bl,[esi]        ; get first byte into bl
+        add     esi,2           ; kick esi (src)
+
+        cmp     bl,bh           ; check if we just moved the byte (from bl)
+        je      toend_mov_inc   ; store bl & exit
+
+        mov     [eax],bl        ; store first byte from bl
+        mov     bl,[esi - 1]    ; get second byte  into bl
+
+        mov     [eax + 1],bl    ; store second byte from bl
+        add     eax,2           ; kick eax (dest)
+
+        cmp     bl,bh           ; see if we just moved the byte
+        je      short toend     ; end of string
+
+        sub     ecx,2           ; modify counter, and if nonzero continue
+        jnz     lupe2           ; else drop out & return NULL
+
+retnull:
+        pop     esi
+ret_zero_len:
+        xor     eax,eax         ; null pointer
+        pop     ebx
+
+        ret                     ; _cdecl return
+
+toend_mov_inc:
+        mov     [eax],bl        ; store first byte from bl
+        add     eax,1           ; eax points right after the value
+
+toend:  pop     esi
+        pop     ebx
+
+        ret                     ; _cdecl return
+
+_memccpy endp
+
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcat.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcat.asm
new file mode 100644
index 0000000000000000000000000000000000000000..15c4fffe36e00d41a6aa72c0fbc62990f2df8ef5
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcat.asm	
@@ -0,0 +1,231 @@
+        page    ,132
+        title   strcat - concatenate (append) one string to another
+;***
+;strcat.asm - contains strcat() and strcpy() routines
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       STRCAT concatenates (appends) a copy of the source string to the
+;       end of the destination string, returning the destination string.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+
+page
+;***
+;char *strcat(dst, src) - concatenate (append) one string to another
+;
+;Purpose:
+;       Concatenates src onto the end of dest.  Assumes enough
+;       space in dest.
+;
+;       Algorithm:
+;       char * strcat (char * dst, char * src)
+;       {
+;           char * cp = dst;
+;
+;           while( *cp )
+;                   ++cp;           /* Find end of dst */
+;           while( *cp++ = *src++ )
+;                   ;               /* Copy src to end of dst */
+;           return( dst );
+;       }
+;
+;Entry:
+;       char *dst - string to which "src" is to be appended
+;       const char *src - string to be appended to the end of "dst"
+;
+;Exit:
+;       The address of "dst" in EAX
+;
+;Uses:
+;       EAX, ECX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+page
+;***
+;char *strcpy(dst, src) - copy one string over another
+;
+;Purpose:
+;       Copies the string src into the spot specified by
+;       dest; assumes enough room.
+;
+;       Algorithm:
+;       char * strcpy (char * dst, char * src)
+;       {
+;           char * cp = dst;
+;
+;           while( *cp++ = *src++ )
+;                   ;               /* Copy src over dst */
+;           return( dst );
+;       }
+;
+;Entry:
+;       char * dst - string over which "src" is to be copied
+;       const char * src - string to be copied over "dst"
+;
+;Exit:
+;       The address of "dst" in EAX
+;
+;Uses:
+;       EAX, ECX
+;
+;Exceptions:
+;*******************************************************************************
+
+
+        CODESEG
+
+%       public  strcat, strcpy      ; make both functions available
+strcpy  proc \
+        dst:ptr byte, \
+        src:ptr byte
+
+        OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+        push    edi                 ; preserve edi
+        mov     edi,[esp+8]         ; edi points to dest string
+        jmp     short copy_start
+
+strcpy  endp
+
+        align   16
+
+strcat  proc \
+        dst:ptr byte, \
+        src:ptr byte
+
+        OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+        .FPO    ( 0, 2, 0, 0, 0, 0 )
+
+        mov     ecx,[esp+4]         ; ecx -> dest string
+        push    edi                 ; preserve edi
+        test    ecx,3               ; test if string is aligned on 32 bits
+        je      short find_end_of_dest_string_loop
+
+dest_misaligned:                    ; simple byte loop until string is aligned
+        mov     al,byte ptr [ecx]
+        add     ecx,1
+        test    al,al
+        je      short start_byte_3
+        test    ecx,3
+        jne     short dest_misaligned
+
+        align   4
+
+find_end_of_dest_string_loop:
+        mov     eax,dword ptr [ecx] ; read 4 bytes
+        mov     edx,7efefeffh
+        add     edx,eax
+        xor     eax,-1
+        xor     eax,edx
+        add     ecx,4
+        test    eax,81010100h
+        je      short find_end_of_dest_string_loop
+        ; found zero byte in the loop
+        mov     eax,[ecx - 4]
+        test    al,al               ; is it byte 0
+        je      short start_byte_0
+        test    ah,ah               ; is it byte 1
+        je      short start_byte_1
+        test    eax,00ff0000h       ; is it byte 2
+        je      short start_byte_2
+        test    eax,0ff000000h      ; is it byte 3
+        je      short start_byte_3
+        jmp     short find_end_of_dest_string_loop
+                                    ; taken if bits 24-30 are clear and bit
+                                    ; 31 is set
+start_byte_3:
+        lea     edi,[ecx - 1]
+        jmp     short copy_start
+start_byte_2:
+        lea     edi,[ecx - 2]
+        jmp     short copy_start
+start_byte_1:
+        lea     edi,[ecx - 3]
+        jmp     short copy_start
+start_byte_0:
+        lea     edi,[ecx - 4]
+;       jmp     short copy_start
+
+;       edi points to the end of dest string.
+copy_start::
+        mov     ecx,[esp+0ch]       ; ecx -> sorc string
+        test    ecx,3               ; test if string is aligned on 32 bits
+        je      short main_loop_entrance
+
+src_misaligned:                     ; simple byte loop until string is aligned
+        mov     dl,byte ptr [ecx]
+        add     ecx,1
+        test    dl,dl
+        je      short byte_0
+        mov     [edi],dl
+        add     edi,1
+        test    ecx,3
+        jne     short src_misaligned
+        jmp     short main_loop_entrance
+
+main_loop:                          ; edx contains first dword of sorc string
+        mov     [edi],edx           ; store one more dword
+        add     edi,4               ; kick dest pointer
+main_loop_entrance:
+        mov     edx,7efefeffh
+        mov     eax,dword ptr [ecx] ; read 4 bytes
+
+        add     edx,eax
+        xor     eax,-1
+
+        xor     eax,edx
+        mov     edx,[ecx]           ; it's in cache now
+
+        add     ecx,4               ; kick dest pointer
+        test    eax,81010100h
+
+        je      short main_loop
+        ; found zero byte in the loop
+; main_loop_end:
+        test    dl,dl               ; is it byte 0
+        je      short byte_0
+        test    dh,dh               ; is it byte 1
+        je      short byte_1
+        test    edx,00ff0000h       ; is it byte 2
+        je      short byte_2
+        test    edx,0ff000000h      ; is it byte 3
+        je      short byte_3
+        jmp     short main_loop     ; taken if bits 24-30 are clear and bit
+                                    ; 31 is set
+byte_3:
+        mov     [edi],edx
+        mov     eax,[esp+8]         ; return in eax pointer to dest string
+        pop     edi
+        ret
+byte_2:
+        mov     [edi],dx
+        mov     eax,[esp+8]         ; return in eax pointer to dest string
+        mov     byte ptr [edi+2],0
+        pop     edi
+        ret
+byte_1:
+        mov     [edi],dx
+        mov     eax,[esp+8]         ; return in eax pointer to dest string
+        pop     edi
+        ret
+byte_0:
+        mov     [edi],dl
+        mov     eax,[esp+8]         ; return in eax pointer to dest string
+        pop     edi
+        ret
+
+strcat  endp
+
+        end
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..3d7182da7fc67d1c9d7b0b237cc3a687425a11b9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcmp.asm	
@@ -0,0 +1,154 @@
+        page    ,132
+        title   strcmp.asm - compare two strings
+;***
+;strcmp.asm - routine to compare two strings (for equal, less, or greater)
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       STRCMP compares two strings and returns an integer
+;       to indicate whether the first is less than the second, the two are
+;       equal, or whether the first is greater than the second, respectively.
+;       Comparison is done byte by byte on an UNSIGNED basis, which is to
+;       say that Null (0) is less than any other character (1-255).
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;strcmp - compare two strings, returning less than, equal to, or greater than
+;
+;Purpose:
+;       Compares two string, determining their lexical order.  Unsigned
+;       comparison is used.
+;
+;       Base Algorithm:
+;          int strcmp ( const char *str1, const char *str2 )
+;          {
+;                  const unsigned char *src1 = (const unsigned char *)str1;
+;                  const unsigned char *src2 = (const unsigned char *)str2;
+;                  int ret = 0 ;
+;
+;                  while( ! (ret = *src1 - *src2) && *src2)
+;                          ++src1, ++src2;
+;
+;                  if ( ret < 0 )
+;                          ret = -1 ;
+;                  else if ( ret > 0 )
+;                          ret = 1 ;
+;
+;                  return( ret );
+;          }
+;
+;Entry:
+;       const char * src1 - string for left-hand side of comparison
+;       const char * src2 - string for right-hand side of comparison
+;
+;Exit:
+;       EAX < 0, 0, or >0, indicating whether the first string is
+;       Less than, Equal to, or Greater than the second string.
+;
+;Uses:
+;       ECX, EDX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  strcmp
+strcmp  proc \
+        str1:ptr byte, \
+        str2:ptr byte
+
+        OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+;       .FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame)
+        .FPO    ( 0, 2, 0, 0, 0, 0 )
+
+        mov     edx,[esp + 4]   ; edx = src
+        mov     ecx,[esp + 8]   ; ecx = dst
+
+        test    edx,3
+        jnz     short dopartial
+
+        align   4
+dodwords:
+        mov     eax,[edx]
+
+        cmp     al,[ecx]
+        jne     short donene
+        test    al,al
+        jz      short doneeq
+        cmp     ah,[ecx + 1]
+        jne     short donene
+        test    ah,ah
+        jz      short doneeq
+
+        shr     eax,16
+
+        cmp     al,[ecx + 2]
+        jne     short donene
+        test    al,al
+        jz      short doneeq
+        cmp     ah,[ecx + 3]
+        jne     short donene
+        add     ecx,4
+        add     edx,4
+        test    ah,ah
+        jnz     short dodwords
+
+        align   4
+doneeq:
+        xor     eax,eax
+        ret
+
+        align   8
+donene:
+        ; The instructions below should place -1 in eax if src < dst,
+        ; and 1 in eax if src > dst.
+
+        sbb     eax,eax
+        or      eax,1
+        ret
+
+        align   16
+dopartial:
+        test    edx,1
+        jz      short doword
+
+        mov     al,[edx]
+        add     edx,1
+        cmp     al,[ecx]
+        jne     short donene
+        add     ecx,1
+        test    al,al
+        jz      short doneeq
+
+        test    edx,2
+        jz      short dodwords
+
+
+        align   4
+doword:
+        mov     ax,[edx]
+        add     edx,2
+        cmp     al,[ecx]
+        jne     short donene
+        test    al,al
+        jz      short doneeq
+        cmp     ah,[ecx + 1]
+        jne     short donene
+        test    ah,ah
+        jz      short doneeq
+        add     ecx,2
+        jmp     short dodwords
+
+strcmp  endp
+
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcspn.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcspn.asm
new file mode 100644
index 0000000000000000000000000000000000000000..fedd116aafbd1bf9a03c9c47e0bcaf7e1b2c3869
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strcspn.asm	
@@ -0,0 +1,16 @@
+;***
+;strcspn.asm -
+;
+;       Copyright (c) Microsoft Corporation.  All rights reserved.
+;
+;Purpose:
+;       defines strcspn()- finds the length of the initial substring of
+;       a string consisting entirely of characters not in a control string.
+;
+;       NOTE:  This stub module scheme is compatible with NT build
+;       procedure.
+;
+;*******************************************************************************
+
+SSTRCSPN EQU 1
+INCLUDE STRSPN.ASM
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strlen.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strlen.asm
new file mode 100644
index 0000000000000000000000000000000000000000..b3391d9f485885a720d6de9126b57e40288e1535
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strlen.asm	
@@ -0,0 +1,125 @@
+        page    ,132
+        title   strlen - return the length of a null-terminated string
+;***
+;strlen.asm - contains strlen() routine
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       strlen returns the length of a null-terminated string,
+;       not including the null byte itself.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;strlen - return the length of a null-terminated string
+;
+;Purpose:
+;       Finds the length in bytes of the given string, not including
+;       the final null character.
+;
+;       Algorithm:
+;       int strlen (const char * str)
+;       {
+;           int length = 0;
+;
+;           while( *str++ )
+;                   ++length;
+;
+;           return( length );
+;       }
+;
+;Entry:
+;       const char * str - string whose length is to be computed
+;
+;Exit:
+;       EAX = length of the string "str", exclusive of the final null byte
+;
+;Uses:
+;       EAX, ECX, EDX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  strlen
+
+strlen  proc \
+        buf:ptr byte
+
+        OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+        .FPO    ( 0, 1, 0, 0, 0, 0 )
+
+string  equ     [esp + 4]
+
+        mov     ecx,string              ; ecx -> string
+        test    ecx,3                   ; test if string is aligned on 32 bits
+        je      short main_loop
+
+str_misaligned:
+        ; simple byte loop until string is aligned
+        mov     al,byte ptr [ecx]
+        add     ecx,1
+        test    al,al
+        je      short byte_3
+        test    ecx,3
+        jne     short str_misaligned
+
+        add     eax,dword ptr 0         ; 5 byte nop to align label below
+
+        align   16                      ; should be redundant
+
+main_loop:
+        mov     eax,dword ptr [ecx]     ; read 4 bytes
+        mov     edx,7efefeffh
+        add     edx,eax
+        xor     eax,-1
+        xor     eax,edx
+        add     ecx,4
+        test    eax,81010100h
+        je      short main_loop
+        ; found zero byte in the loop
+        mov     eax,[ecx - 4]
+        test    al,al                   ; is it byte 0
+        je      short byte_0
+        test    ah,ah                   ; is it byte 1
+        je      short byte_1
+        test    eax,00ff0000h           ; is it byte 2
+        je      short byte_2
+        test    eax,0ff000000h          ; is it byte 3
+        je      short byte_3
+        jmp     short main_loop         ; taken if bits 24-30 are clear and bit
+                                        ; 31 is set
+
+byte_3:
+        lea     eax,[ecx - 1]
+        mov     ecx,string
+        sub     eax,ecx
+        ret
+byte_2:
+        lea     eax,[ecx - 2]
+        mov     ecx,string
+        sub     eax,ecx
+        ret
+byte_1:
+        lea     eax,[ecx - 3]
+        mov     ecx,string
+        sub     eax,ecx
+        ret
+byte_0:
+        lea     eax,[ecx - 4]
+        mov     ecx,string
+        sub     eax,ecx
+        ret
+
+strlen  endp
+
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncat.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncat.asm
new file mode 100644
index 0000000000000000000000000000000000000000..f8217a73458e3b99ab17e8cc4c357617c9f9cf0f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncat.asm	
@@ -0,0 +1,252 @@
+        page    ,132
+        title   strncat - append n chars of string1 to string2
+;***
+;strncat.asm - append n chars of string to new string
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines strncat() - appends n characters of string onto
+;       end of other string
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;char *strncat(front, back, count) - append count chars of back onto front
+;
+;Purpose:
+;       Appends at most count characters of the string back onto the
+;       end of front, and ALWAYS terminates with a null character.
+;       If count is greater than the length of back, the length of back
+;       is used instead.  (Unlike strncpy, this routine does not pad out
+;       to count characters).
+;
+;       Algorithm:
+;       char *
+;       strncat (front, back, count)
+;           char *front, *back;
+;           unsigned count;
+;       {
+;           char *start = front;
+;
+;           while (*front++)
+;               ;
+;           front--;
+;           while (count--)
+;               if (!(*front++ = *back++))
+;                   return(start);
+;           *front = '\0';
+;           return(start);
+;       }
+;
+;Entry:
+;       char *   front - string to append onto
+;       char *   back  - string to append
+;       unsigned count - count of max characters to append
+;
+;Exit:
+;       returns a pointer to string appended onto (front).
+;
+;Uses:  ECX, EDX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+    CODESEG
+
+    public  strncat
+strncat proc
+;   front:ptr byte,
+;   back:ptr byte,
+;   count:IWORD
+
+        .FPO    ( 0, 3, 0, 0, 0, 0 )
+
+        mov     ecx,[esp + 0ch]     ; ecx = count
+        push    edi                 ; preserve edi
+        test    ecx,ecx
+        jz      finish              ; leave if count is zero
+
+        mov     edi,[esp + 8]       ; edi -> front string
+        push    esi                 ; preserve esi
+        test    edi,3               ; is string aligned on dword (4 bytes)
+        push    ebx                 ; preserve ebx
+        je      short find_end_of_front_string_loop
+
+        ; simple byte loop until string is aligned
+
+front_misaligned:
+        mov     al,byte ptr [edi]
+        add     edi,1
+        test    al,al
+        je      short start_byte_3
+        test    edi,3
+        jne     short front_misaligned
+
+find_end_of_front_string_loop:
+        mov     eax,dword ptr [edi] ; read dword (4 bytes)
+        mov     edx,7efefeffh
+        add     edx,eax
+        xor     eax,-1
+        xor     eax,edx
+        add     edi,4
+        test    eax,81010100h
+        je      short find_end_of_front_string_loop
+
+; found zero byte in the loop
+        mov     eax,[edi - 4]
+        test    al,al               ; is it byte 0
+        je      short start_byte_0
+        test    ah,ah               ; is it byte 1
+        je      short start_byte_1
+        test    eax,00ff0000h       ; is it byte 2
+        je      short start_byte_2
+        test    eax,0ff000000h      ; is it byte 3
+        jne     short find_end_of_front_string_loop
+                                    ; taken if bits 24-30 are clear and bit
+                                    ; 31 is set
+start_byte_3:
+        sub     edi,1
+        jmp     short copy_start
+start_byte_2:
+        sub     edi,2
+        jmp     short copy_start
+start_byte_1:
+        sub     edi,3
+        jmp     short copy_start
+start_byte_0:
+        sub     edi,4
+
+; edi now points to the end of front string.
+
+copy_start:
+        mov     esi,[esp + 14h]     ; esi -> back string
+        test    esi,3               ; is back string is dword aligned?
+        jnz     back_misaligned
+
+        mov     ebx,ecx             ; store count for tail loop
+
+        shr     ecx,2
+        jnz     short main_loop_entrance
+        jmp     short tail_loop_start   ; 0 < counter < 4
+
+; simple byte loop until back string is aligned
+
+back_misaligned:
+        mov     dl,byte ptr [esi]
+        add     esi,1
+        test    dl,dl
+        je      short byte_0
+        mov     [edi],dl
+        add     edi,1
+        sub     ecx,1
+        jz      empty_counter
+        test    esi,3
+        jne     short back_misaligned
+        mov     ebx,ecx             ; store count for tail loop
+        shr     ecx,2               ; convert ecx to dword count
+        jnz     short main_loop_entrance
+
+tail_loop_start:
+        mov     ecx,ebx
+        and     ecx,3               ; ecx = count of leftover bytes after the
+                                    ; dwords have been concatenated
+        jz      empty_counter
+
+tail_loop:
+        mov     dl,byte ptr [esi]
+        add     esi,1
+        mov     [edi],dl
+        add     edi,1
+        test    dl,dl
+        je      short finish1       ; '\0' was already copied
+        sub     ecx,1
+        jnz     tail_loop
+
+empty_counter:
+        mov     [edi],cl            ; cl=0;
+finish1:
+        pop     ebx
+        pop     esi
+finish:
+        mov     eax,[esp + 8]       ; return in eax pointer to front string
+        pop     edi
+        ret                         ; _cdecl return
+
+
+byte_0:
+        mov     [edi],dl
+        mov     eax,[esp + 10h]     ; return in eax pointer to front string
+        pop     ebx
+        pop     esi
+        pop     edi
+        ret                         ; _cdecl return
+
+
+main_loop:                          ; edx contains first dword of back string
+        mov     [edi],edx           ; store one more dword
+        add     edi,4               ; kick pointer to front string
+
+        sub     ecx,1
+        jz      tail_loop_start
+main_loop_entrance:
+        mov     edx,7efefeffh
+        mov     eax,dword ptr [esi] ; read 4 bytes
+
+        add     edx,eax
+        xor     eax,-1
+
+        xor     eax,edx
+        mov     edx,[esi]           ; it's in cache now
+
+        add     esi,4               ; kick pointer to back string
+        test    eax,81010100h
+
+        je      short main_loop
+
+; may be found zero byte in the loop
+        test    dl,dl               ; is it byte 0
+        je      short byte_0
+        test    dh,dh               ; is it byte 1
+        je      short byte_1
+        test    edx,00ff0000h       ; is it byte 2
+        je      short byte_2
+        test    edx,0ff000000h      ; is it byte 3
+        jne short main_loop         ; taken if bits 24-30 are clear and bit
+                                    ; 31 is set
+byte_3:
+        mov     [edi],edx
+        mov     eax,[esp + 10h]     ; return in eax pointer to front string
+        pop     ebx
+        pop     esi
+        pop     edi
+        ret                         ; _cdecl return
+
+byte_2:
+        mov     [edi],dx
+        xor     edx,edx
+        mov     eax,[esp + 10h]     ; return in eax pointer to front string
+        mov     [edi + 2],dl
+        pop     ebx
+        pop     esi
+        pop     edi
+        ret                         ; _cdecl return
+
+byte_1:
+        mov     [edi],dx
+        mov     eax,[esp + 10h]     ; return in eax pointer to front string
+        pop     ebx
+        pop     esi
+        pop     edi
+        ret                         ; _cdecl return
+
+strncat endp
+
+        end
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncmp.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncmp.asm
new file mode 100644
index 0000000000000000000000000000000000000000..a6bfd8acef5a8b0fe6250862ab7d37a7c4a2ce48
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncmp.asm	
@@ -0,0 +1,173 @@
+        page    ,132
+        title   strncmp.asm - compare two strings
+;***
+;strcmp.asm - routine to compare two strings (for equal, less, or greater)
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       strncmp compares two strings and returns an integer
+;       to indicate whether the first is less than the second, the two are
+;       equal, or whether the first is greater than the second, respectively.
+;       Comparison is done byte by byte on an UNSIGNED basis, which is to
+;       say that Null (0) is less than any other character (1-255).
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;strncmp - compare two strings, returning less than, equal to, or greater than
+;
+;Purpose:
+;       Compares two string, determining their lexical order.  Unsigned
+;       comparison is used.
+;
+;       Algorithm:
+;          int strncmp (
+;              const char *first,
+;              const char *last,
+;              size_t      count
+;          )
+;          {
+;              size_t x;
+;              int ret = 0 ;
+;
+;              for (x = 0; x < count; x++)
+;              {
+;                  if (*first == 0 || *first != *last)
+;                  {
+;                      int ret = (*(unsigned char *)first - *(unsigned char *)last);
+;                      if ( ret < 0 )
+;                          ret = -1 ;
+;                      else if ( ret > 0 )
+;                          ret = 1 ;
+;                      return ret;
+;                  }
+;                  ++first;
+;                  ++last;
+;              }
+;
+;              return 0;
+;          }
+;
+;Entry:
+;       const char * first - string for left-hand side of comparison
+;       const char * last  - string for right-hand side of comparison
+;       size_t count       - maximum number of characters to compare; if
+;                             strings equal to that point consider them equal
+;
+;Exit:
+;       EAX < 0, 0, or >0, indicating whether the first string is
+;       Less than, Equal to, or Greater than the second string.
+;
+;       Note: For compatibility with other versions of this routine
+;       the returned value is limited to {-1, 0, 1}.
+;
+;Uses:
+;       ECX, EDX
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+CHAR_TYPE EQU BYTE
+CHAR_PTR EQU BYTE PTR
+CHAR_SIZE = sizeof CHAR_TYPE
+
+BLK_TYPE EQU DWORD
+BLK_PTR EQU DWORD PTR
+BLK_SIZE = sizeof BLK_TYPE
+BLK_CHARS = BLK_SIZE / CHAR_SIZE
+
+PAGE_SIZE = 1000h
+PAGE_MASK = PAGE_SIZE - 1       ; mask for offset in MM page
+PAGE_SAFE_BLK = PAGE_SIZE - BLK_SIZE ; maximum offset for safe block compare
+
+    public  strncmp
+strncmp proc \
+        uses ebx esi, \
+        str1:ptr byte, \
+        str2:ptr byte, \
+        count:IWORD
+
+    OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+    push      ebx
+    push      esi
+
+;   .FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame)
+    .FPO      ( 0, 3, $ - strncmp, 2, 0, 0 )
+
+    mov       ecx,[esp + 12]   ; ecx = str1
+    mov       edx,[esp + 16]   ; edx = str2
+    mov       ebx,[esp + 20]   ; ebx = count
+
+; Check for a limit of zero characters.
+    test      ebx, 0FFFFFFFFh
+    jz        return_equal
+
+    sub       ecx, edx
+
+    test      edx, (BLK_SIZE - 1)
+    jz        dword_loop_begin
+
+comp_head_loop_begin:
+    movzx     eax, CHAR_PTR[ecx+edx]
+    cmp       al, CHAR_PTR[edx]
+    jnz       return_not_equal
+
+    test      eax, eax
+    jz        return_equal
+
+    inc       edx
+
+    sub       ebx, 1
+    jbe       return_equal
+
+    test      dl, (BLK_SIZE - 1)
+    jnz       comp_head_loop_begin
+
+dword_loop_begin:
+    lea       eax, [ecx+edx]
+    and       eax, PAGE_MASK
+    cmp       eax, PAGE_SAFE_BLK
+    ja        comp_head_loop_begin
+
+    mov       eax, BLK_PTR[ecx+edx]
+    cmp       eax, BLK_PTR[edx]
+    jne       comp_head_loop_begin
+
+    sub       ebx, BLK_CHARS
+    jbe       return_equal
+
+    lea       esi, [eax+0fefefeffh]
+    add       edx, BLK_SIZE
+    not       eax
+    and       eax, esi
+    test      eax, 80808080h
+    jz        dword_loop_begin
+
+return_equal:
+    xor       eax, eax
+    pop       esi
+    pop       ebx
+    ret
+
+    align     16
+
+return_not_equal:
+    sbb       eax, eax  ; AX=-1, CY=1 AX=0, CY=0
+    or        eax, 1
+    pop       esi
+    pop       ebx
+    ret
+
+strncmp endp
+
+    end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncpy.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncpy.asm
new file mode 100644
index 0000000000000000000000000000000000000000..d6580549cd47c6af6f053460f6d7c6130f76b0a6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strncpy.asm	
@@ -0,0 +1,239 @@
+        page    ,132
+        title   strncpy - copy at most n characters of string
+;***
+;strncpy.asm - copy at most n characters of string
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines strncpy() - copy at most n characters of string
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;char *strncpy(dest, source, count) - copy at most n characters
+;
+;Purpose:
+;       Copies count characters from the source string to the
+;       destination.  If count is less than the length of source,
+;       NO NULL CHARACTER is put onto the end of the copied string.
+;       If count is greater than the length of sources, dest is padded
+;       with null characters to length count.
+;
+;       Algorithm:
+;       char *
+;       strncpy (dest, source, count)
+;       char *dest, *source;
+;       unsigned count;
+;       {
+;         char *start = dest;
+;
+;         while (count && (*dest++ = *source++))
+;             count--;
+;         if (count)
+;             while (--count)
+;                 *dest++ = '\0';
+;         return(start);
+;       }
+;
+;Entry:
+;       char *dest     - pointer to spot to copy source, enough space
+;                        is assumed.
+;       char *source   - source string for copy
+;       unsigned count - characters to copy
+;
+;Exit:
+;       returns dest, with the character copied there.
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  strncpy
+strncpy proc \
+        dest:ptr byte, \
+        source:ptr byte, \
+        count:dword
+
+        OPTION PROLOGUE:NONE, EPILOGUE:NONE
+
+        .FPO    ( 0, 3, 0, 0, 0, 0 )
+
+        mov     ecx,[esp + 0ch]     ; ecx = count
+        push    edi                 ; preserve edi
+        test    ecx,ecx
+        jz      finish              ; leave if count is zero
+
+        push    esi                 ; preserve edi
+        push    ebx                 ; preserve ebx
+        mov     ebx,ecx             ; store count for tail loop
+        mov     esi,[esp + 14h]     ; esi -> source string
+        test    esi,3               ; test if source string is aligned on 32 bits
+        mov     edi,[esp + 10h]     ; edi -> dest string
+        jnz     short src_misaligned    ; (almost always source is aligned)
+
+        shr     ecx,2               ; convert ecx to dword count
+        jnz     main_loop_entrance
+        jmp     short copy_tail_loop    ; 0 < count < 4
+
+; simple byte loop until string is aligned
+
+src_misaligned:
+        mov     al,byte ptr [esi]   ; copy a byte from source to dest
+        add     esi,1
+        mov     [edi],al
+        add     edi,1
+        sub     ecx,1
+        jz      fill_tail_end1      ; if count == 0, leave
+        test    al,al               ; was last copied byte zero?
+        jz      short align_dest    ; if so, go align dest and pad it out
+                                    ; with zeros
+        test    esi,3               ; esi already aligned ?
+        jne     short src_misaligned
+        mov     ebx,ecx             ; store count for tail loop
+        shr     ecx,2
+        jnz     short main_loop_entrance
+
+tail_loop_start:
+        and     ebx,3               ; ebx = count_before_main_loop%4
+        jz      short fill_tail_end1    ; if ebx == 0 then leave without
+                                        ; appending a null byte
+
+; while ( EOS (end-of-string) not found and count > 0 ) copy bytes
+
+copy_tail_loop:
+        mov     al,byte ptr [esi]   ; load byte from source
+        add     esi,1
+        mov     [edi],al            ; store byte to dest
+        add     edi,1
+        test    al,al               ; EOS found?
+        je      short fill_tail_zero_bytes  ; '\0' was already copied
+        sub     ebx,1
+        jnz     copy_tail_loop
+fill_tail_end1:
+        mov     eax,[esp + 10h]     ; prepare return value
+        pop     ebx
+        pop     esi
+        pop     edi
+        ret
+
+; EOS found. Pad with null characters to length count
+
+align_dest:
+        test    edi,3               ; dest string aligned?
+        jz      dest_align_loop_end
+dest_align_loop:
+        mov     [edi],al
+        add     edi,1
+        sub     ecx,1               ; count == 0?
+        jz      fill_tail_end       ; if so, finished
+        test    edi,3               ; is edi aligned ?
+        jnz     dest_align_loop
+dest_align_loop_end:
+        mov     ebx,ecx             ; ebx > 0
+        shr     ecx,2               ; convert ecx to count of dwords
+        jnz     fill_dwords_with_EOS
+        ; pad tail bytes
+finish_loop:                        ; 0 < ebx < 4
+        mov     [edi],al
+        add     edi,1
+fill_tail_zero_bytes:
+        sub     ebx,1
+        jnz     finish_loop
+        pop     ebx
+        pop     esi
+finish:
+        mov     eax,[esp + 8]       ; return in eax pointer to dest string
+        pop     edi
+        ret
+
+; copy (source) string to (dest). Also look for end of (source) string
+
+main_loop:                          ; edx contains first dword of source string
+        mov     [edi],edx           ; store one more dword
+        add     edi,4               ; kick dest pointer
+        sub     ecx,1
+        jz      tail_loop_start
+
+main_loop_entrance:
+        mov     edx,7efefeffh
+        mov     eax,dword ptr [esi] ; read 4 bytes (dword)
+        add     edx,eax
+        xor     eax,-1
+        xor     eax,edx
+        mov     edx,[esi]           ; it's in cache now
+        add     esi,4               ; kick dest pointer
+        test    eax,81010100h
+        je      short main_loop
+
+        ; may have found zero byte in the dword
+
+        test    dl,dl               ; is it byte 0
+        je      short byte_0
+        test    dh,dh               ; is it byte 1
+        je      short byte_1
+        test    edx,00ff0000h       ; is it byte 2
+        je      short byte_2
+        test    edx,0ff000000h      ; is it byte 3
+        jne     short main_loop     ; taken if bits 24-30 are clear and bit
+                                    ; 31 is set
+
+; a null character was found, so dest needs to be padded out with null chars
+; to count length.
+
+        mov     [edi],edx
+        jmp     short fill_with_EOS_dwords
+
+byte_2:
+        and     edx,0ffffh          ; fill high 2 bytes with 0
+        mov     [edi],edx
+        jmp     short fill_with_EOS_dwords
+
+byte_1:
+        and     edx,0ffh            ; fill high 3 bytes with 0
+        mov     [edi],edx
+        jmp     short fill_with_EOS_dwords
+
+byte_0:
+        xor     edx,edx             ; fill whole dword with 0
+        mov     [edi],edx
+
+; End of string was found. Pad out dest string with dwords of 0
+
+fill_with_EOS_dwords:               ; ecx > 0   (ecx is dword counter)
+        add     edi,4
+        xor     eax,eax             ; it is instead of ???????????????????
+        sub     ecx,1
+        jz      fill_tail           ; we filled all dwords
+
+fill_dwords_with_EOS:
+        xor     eax,eax
+fill_with_EOS_loop:
+        mov     [edi],eax
+        add     edi,4
+        sub     ecx,1
+        jnz     short fill_with_EOS_loop
+fill_tail:                          ; let's pad tail bytes with zero
+        and     ebx,3               ; ebx = ebx % 4
+        jnz     finish_loop         ; taken, when there are some tail bytes
+fill_tail_end:
+        mov     eax,[esp + 10h]
+        pop     ebx
+        pop     esi
+        pop     edi
+        ret
+
+strncpy endp
+        end
+
+
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strnset.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strnset.asm
new file mode 100644
index 0000000000000000000000000000000000000000..89fc24367bca163901a020ffd5835744afa41d47
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strnset.asm	
@@ -0,0 +1,89 @@
+        page    ,132
+        title   strnset - set first n characters to one char.
+;***
+;strnset.asm - set first n characters to single character
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines _strnset() - sets at most the first n characters of a string
+;       to a given character.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;char *_strnset(string, val, count) - set at most count characters to val
+;
+;Purpose:
+;       Sets the first count characters of string the character value.
+;       If the length of string is less than count, the length of
+;       string is used in place of n.
+;
+;       Algorithm:
+;       char *
+;       _strnset (string, val, count)
+;             char *string,val;
+;             unsigned int count;
+;             {
+;             char *start = string;
+;
+;             while (count-- && *string)
+;                     *string++ = val;
+;             return(start);
+;             }
+;
+;Entry:
+;       char *string - string to set characters in
+;       char val - character to fill with
+;       unsigned count - count of characters to fill
+;
+;Exit:
+;       returns string, now filled with count copies of val.
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  _strnset
+_strnset proc \
+        uses edi ebx, \
+        string:ptr byte, \
+        val:byte, \
+        count:IWORD
+
+
+        mov     edi,[string]    ; di = string
+        mov     edx,edi         ; dx=string addr; save return value
+        mov     ebx,[count]     ; cx = max chars to set
+        xor     eax,eax         ; null byte
+        mov     ecx,ebx
+        jecxz   short done      ; zero length specified
+
+repne   scasb                   ; find null byte & count bytes in cx
+        jne     short nonull    ; null not found
+        add     ecx,1           ; don't want the null
+
+nonull:
+        sub     ebx,ecx         ; bx=strlen (not null)
+        mov     ecx,ebx         ; cx=strlen (not null)
+
+        mov     edi,edx         ; restore string pointer
+        mov     al,val          ; byte value
+rep     stosb                   ; fill 'er up
+
+done:
+        mov     eax,edx         ; return value: string addr
+
+        ret                     ; _cdecl return
+
+_strnset endp
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strpbrk.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strpbrk.asm
new file mode 100644
index 0000000000000000000000000000000000000000..48c7f1c469a98d0ea21971920ac35ed82a481a6c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strpbrk.asm	
@@ -0,0 +1,16 @@
+;***
+;strpbrk.asm -
+;
+;       Copyright (c) Microsoft Corporation.  All rights reserved.
+;
+;Purpose:
+;       defines strpbrk()- finds the index of the first character in a string
+;       that is not in a control string
+;
+;       NOTE:  This stub module scheme is compatible with NT build
+;       procedure.
+;
+;*******************************************************************************
+
+SSTRPBRK EQU 1
+INCLUDE STRSPN.ASM
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strrev.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strrev.asm
new file mode 100644
index 0000000000000000000000000000000000000000..038db8c431873610a7e9bab47d5adc3a8afbc549
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strrev.asm	
@@ -0,0 +1,105 @@
+        page    ,132
+        title   strrev - reverse a string in place
+;***
+;strrev.asm - reverse a string in place
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines _strrev() - reverse a string in place (not including
+;       '\0' character)
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;char *_strrev(string) - reverse a string in place
+;
+;Purpose:
+;       Reverses the order of characters in the string.  The terminating
+;       null character remains in place.
+;
+;       Algorithm:
+;       char *
+;       _strrev (string)
+;             char *string;
+;             {
+;             char *start = string;
+;             char *left = string;
+;             char ch;
+;
+;             while (*string++)
+;                     ;
+;             string -= 2;
+;             while (left < string)
+;                     {
+;                     ch = *left;
+;                     *left++ = *string;
+;                     *string-- = ch;
+;                     }
+;             return(start);
+;             }
+;
+;       NOTE: There is a check for an empty string in the following code.
+;       Normally, this would fall out of the "cmp si,di" instruction in the
+;       loop portion of the routine.  However, if the offset of the empty
+;       string is 0 (as it could be in large model), then the cmp does not
+;       catch the empty string and the routine essentially hangs (i.e., loops
+;       moving bytes one at a time FFFFh times).  An explicit empty string
+;       check corrects this.
+;
+;Entry:
+;       char *string - string to reverse
+;
+;Exit:
+;       returns string - now with reversed characters
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  _strrev
+_strrev proc \
+        uses edi esi, \
+        string:ptr byte
+
+        mov     edi,[string]    ; di = string
+        mov     edx,edi         ; dx=pointer to string; save return value
+
+        mov     esi,edi         ; si=pointer to string
+        xor     eax,eax         ; search value (null)
+        or      ecx,-1          ; cx = -1
+repne   scasb                   ; find null
+        cmp     ecx,-2          ; is string empty? (if offset value is 0, the
+        je      short done      ; cmp below will not catch it and we'll hang).
+
+        sub     edi,2           ; string is not empty, move di pointer back
+                                ; di points to last non-null byte
+
+lupe:
+        cmp     esi,edi         ; see if pointers have crossed yet
+        jae     short done      ; exit when pointers meet (or cross)
+
+        mov     ah,[esi]        ; get front byte...
+        mov     al,[edi]        ;   and end byte
+        mov     [esi],al        ; put end byte in front...
+        mov     [edi],ah        ;   and front byte at end
+        add     esi,1           ; front moves up...
+        sub     edi,1           ;   and end moves down
+        jmp     short lupe      ; keep switching bytes
+
+done:
+        mov     eax,edx         ; return value: string addr
+
+        ret                     ; _cdecl return
+
+_strrev endp
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strset.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strset.asm
new file mode 100644
index 0000000000000000000000000000000000000000..107fb9a10e4153e90aa73c8ca3ab56a8b9bf8b96
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strset.asm	
@@ -0,0 +1,78 @@
+        page    ,132
+        title   strset - set all characters of string to character
+;***
+;strset.asm - sets all charcaters of string to given character
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines _strset() - sets all of the characters in a string (except
+;       the '\0') equal to a given character.
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;char *_strset(string, val) - sets all of string to val
+;
+;Purpose:
+;       Sets all of characters in string (except the terminating '/0'
+;       character) equal to val.
+;
+;       Algorithm:
+;       char *
+;       _strset (string, val)
+;             char *string;
+;             char val;
+;             {
+;             char *start = string;
+;
+;             while (*string)
+;                     *string++ = val;
+;             return(start);
+;             }
+;
+;Entry:
+;       char *string - string to modify
+;       char val - value to fill string with
+;
+;Exit:
+;       returns string -- now filled with val's
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+        CODESEG
+
+        public  _strset
+_strset proc \
+        uses edi, \
+        string:ptr byte, \
+        val:byte
+
+
+        mov     edi,[string]    ; di = string
+        mov     edx,edi         ; dx=string addr; save return value
+
+        xor     eax,eax         ; ax = 0
+        or      ecx,-1          ; cx = -1
+repne   scasb                   ; scan string & count bytes
+        add     ecx,2           ; cx=-strlen
+        neg     ecx             ; cx=strlen
+        mov     al,[val]        ; al = byte value to store
+        mov     edi,edx         ; di=string addr
+rep     stosb
+
+        mov     eax,edx         ; return value: string addr
+
+        ret                     ; _cdecl return
+
+_strset endp
+        end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strspn.asm b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strspn.asm
new file mode 100644
index 0000000000000000000000000000000000000000..9d9a4405b179274beba05a3ca80c3f4f75e0f052
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/i386/strspn.asm	
@@ -0,0 +1,262 @@
+        page    ,132
+        title   strspn - search for init substring of chars from control str
+;***
+;strspn.asm - find length of initial substring of chars from a control string
+;
+;       Copyright (c) Microsoft Corporation. All rights reserved.
+;
+;Purpose:
+;       defines strspn() - finds the length of the initial substring of
+;       a string consisting entirely of characters from a control string.
+;
+;       defines strcspn()- finds the length of the initial substring of
+;       a string consisting entirely of characters not in a control string.
+;
+;       defines strpbrk()- finds the index of the first character in a string
+;       that is not in a control string
+;
+;*******************************************************************************
+
+        .xlist
+        include cruntime.inc
+        .list
+
+page
+;***
+;int strspn(string, control) - find init substring of control chars
+;
+;Purpose:
+;       Finds the index of the first character in string that does belong
+;       to the set of characters specified by control.  This is
+;       equivalent to the length of the initial substring of string that
+;       consists entirely of characters from control.  The '\0' character
+;       that terminates control is not considered in the matching process.
+;
+;       Algorithm:
+;       int
+;       strspn (string, control)
+;               unsigned char *string, *control;
+;       {
+;               unsigned char map[32];
+;               int count;
+;
+;               for (count = 0; count < 32; count++)
+;                       map[count] = 0;
+;               while (*control)
+;               {
+;                       map[*control >> 3] |= (1 << (*control & 7));
+;                       control++;
+;               }
+;               if (*string)
+;               {
+;                       while (map[*string >> 3] & (1 << (*string & 7)))
+;                       {
+;                               count++;
+;                               string++;
+;                       }
+;                       return(count);
+;               }
+;               return(0);
+;       }
+;
+;Entry:
+;       char *string - string to search
+;       char *control - string containing characters not to search for
+;
+;Exit:
+;       returns index of first char in string not in control
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+;***
+;int strcspn(string, control) - search for init substring w/o control chars
+;
+;Purpose:
+;       returns the index of the first character in string that belongs
+;       to the set of characters specified by control.  This is equivalent
+;       to the length of the length of the initial substring of string
+;       composed entirely of characters not in control.  Null chars not
+;       considered.
+;
+;       Algorithm:
+;       int
+;       strcspn (string, control)
+;               unsigned char *string, *control;
+;       {
+;               unsigned char map[32];
+;               int count;
+;
+;               for (count = 0; count < 32; count++)
+;                       map[count] = 0;
+;               while (*control)
+;               {
+;                       map[*control >> 3] |= (1 << (*control & 7));
+;                       control++;
+;               }
+;               map[0] |= 1;
+;               while (!(map[*string >> 3] & (1 << (*string & 7))))
+;               {
+;                       count++;
+;                       string++;
+;               }
+;               return(count);
+;       }
+;
+;Entry:
+;       char *string - string to search
+;       char *control - set of characters not allowed in init substring
+;
+;Exit:
+;       returns the index of the first char in string
+;       that is in the set of characters specified by control.
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+;***
+;char *strpbrk(string, control) - scans string for a character from control
+;
+;Purpose:
+;       Finds the first occurence in string of any character from
+;       the control string.
+;
+;       Algorithm:
+;       char *
+;       strpbrk (string, control)
+;               unsigned char *string, *control;
+;       {
+;               unsigned char map[32];
+;               int count;
+;
+;               for (count = 0; count < 32; count++)
+;                       map[count] = 0;
+;               while (*control)
+;               {
+;                       map[*control >> 3] |= (1 << (*control & 7));
+;                       control++;
+;               }
+;               while (*string)
+;               {
+;                       if (map[*string >> 3] & (1 << (*string & 7)))
+;                               return(string);
+;                       string++;
+;               }
+;               return(NULL);
+;       }
+;
+;Entry:
+;       char *string - string to search in
+;       char *control - string containing characters to search for
+;
+;Exit:
+;       returns a pointer to the first character from control found
+;       in string.
+;       returns NULL if string and control have no characters in common.
+;
+;Uses:
+;
+;Exceptions:
+;
+;*******************************************************************************
+
+
+ifdef SSTRCSPN
+
+    _STRSPN_ equ <strcspn>
+
+elseifdef SSTRPBRK
+
+    _STRSPN_ equ <strpbrk>
+
+else  ; SSTRCSPN
+
+; Default is to build strspn()
+
+    SSTRSPN equ 1
+    _STRSPN_ equ <strspn>
+
+endif  ; SSTRCSPN
+
+% public  _STRSPN_
+
+    CODESEG
+
+_STRSPN_ proc \
+        uses esi, \
+        string:ptr byte, \
+        control:ptr byte
+
+; create and zero out char bit map
+
+        xor     eax,eax
+        push    eax             ; 32
+        push    eax
+        push    eax
+        push    eax             ; 128
+        push    eax
+        push    eax
+        push    eax
+        push    eax             ; 256
+
+map     equ     [esp]
+
+; Set control char bits in map
+
+        mov     edx,control     ; si = control string
+
+        align   @WordSize
+lab listnext                    ; init char bit map
+        mov     al,[edx]
+        or      al,al
+        jz      short listdone
+        add     edx,1
+        bts     map,eax
+        jmp     short listnext
+
+lab listdone
+
+; Loop through comparing source string with control bits
+
+        mov     esi,string      ; si = string
+
+_ifnd   SSTRPBRK <or     ecx,-1> ; set ecx to -1
+
+        align   @WordSize
+lab dstnext
+
+_ifnd   SSTRPBRK <add    ecx,1>
+
+        mov     al,[esi]
+        or      al,al
+        jz      short dstdone
+        add     esi,1
+        bt      map, eax
+
+ifdef SSTRSPN
+        jc      short dstnext   ; strspn: found char, continue
+elseifdef SSTRCSPN
+        jnc     short dstnext   ; strcspn: did not find char, continue
+elseifdef SSTRPBRK
+        jnc     short dstnext   ; strpbrk: did not find char, continue
+        lea     eax,[esi - 1]   ; found char, return address of it
+endif  ; SSTRSPN
+
+; Return code
+
+lab dstdone
+
+_ifnd   SSTRPBRK <mov   eax,ecx> ; strspn/strcspn: return index
+
+        add     esp,32
+
+        ret                     ; _cdecl return
+
+_STRSPN_ endp
+         end
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memccpy.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memccpy.c
new file mode 100644
index 0000000000000000000000000000000000000000..35a0a9812a11c7f955b4f8e971ea11e028bc0184
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memccpy.c	
@@ -0,0 +1,48 @@
+/***
+*memccpy.c - copy bytes until a character is found
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _memccpy() - copies bytes until a specifed character
+*       is found, or a maximum number of characters have been copied.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+/***
+*char *_memccpy(dest, src, c, count) - copy bytes until character found
+*
+*Purpose:
+*       Copies bytes from src to dest until count bytes have been
+*       copied, or up to and including the character c, whichever
+*       comes first.
+*
+*Entry:
+*       void *dest - pointer to memory to receive copy
+*       void *src  - source of bytes
+*       int  c     - character to stop copy at
+*       size_t count - max number of bytes to copy
+*
+*Exit:
+*       returns pointer to byte immediately after c in dest
+*       returns NULL if c was never found
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void * __cdecl _memccpy (
+        void * dest,
+        const void * src,
+        int c,
+        size_t count
+        )
+{
+        while ( count && (*((char *)(dest = (char *)dest + 1) - 1) =
+        *((char *)(src = (char *)src + 1) - 1)) != (char)c )
+                count--;
+
+        return(count ? dest : NULL);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memcpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memcpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0fd24e28e2c9f2fc64a38c5adfe4d1e0bc4eb11
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memcpy_s.cpp	
@@ -0,0 +1,10 @@
+//
+// memcpy_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Provides external definitions of the inline functions memcpy_s and memmove_s
+// for use by objects compiled with older versions of the CRT headers.
+//
+#define _CRT_MEMCPY_S_INLINE extern __inline
+#include <corecrt_memcpy_s.h>
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memicmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memicmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6950424807b6194150639a4bb545286f7d28311
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/memicmp.cpp	
@@ -0,0 +1,120 @@
+/***
+*memicmp.cpp - compare memory, ignore case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _memicmp() - compare two blocks of memory for ordinal
+*       order.  Case is ignored in the comparison.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*int _memicmp(lhs, rhs, count) - compare two blocks of memory, ignore case
+*
+*Purpose:
+*       Compares count bytes of the two blocks of memory stored at lhs
+*       and rhs.  The characters are converted to lowercase before
+*       comparing (not permanently), so case is ignored in the search.
+*
+*Entry:
+*       char *lhs, *rhs - memory buffers to compare
+*       size_t count - maximum length to compare
+*
+*Exit:
+*       Returns < 0 if lhs < rhs
+*       Returns 0 if lhs == rhs
+*       Returns > 0 if lhs > rhs
+*       Returns _NLSCMPERROR if something went wrong
+*
+*Uses:
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _memicmp_l (
+        void const * const lhs,
+        void const * const rhs,
+        size_t       const count,
+        _locale_t    const plocinfo
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr || count == 0, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr || count == 0, EINVAL, _NLSCMPERROR);
+
+    if (count == 0)
+    {
+        return 0;
+    }
+
+    unsigned char const * lhs_ptr = static_cast<unsigned char const *>(lhs);
+    unsigned char const * rhs_ptr = static_cast<unsigned char const *>(rhs);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    int result;
+    size_t remaining = count;
+    do
+    {
+        result = _tolower_fast_internal(*lhs_ptr++, _loc_update.GetLocaleT())
+            - _tolower_fast_internal(*rhs_ptr++, _loc_update.GetLocaleT());
+    }
+    while (result == 0 && --remaining != 0);
+
+    return result;
+}
+
+
+#if !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64)
+
+extern "C" int __cdecl __ascii_memicmp (
+        void const * const lhs,
+        void const * const rhs,
+        size_t       const count
+        )
+{
+    if (count == 0)
+    {
+        return 0;
+    }
+
+    unsigned char const * lhs_ptr = static_cast<unsigned char const *>(lhs);
+    unsigned char const * rhs_ptr = static_cast<unsigned char const *>(rhs);
+
+    int result;
+    size_t remaining = count;
+    do
+    {
+        result = __ascii_tolower(*lhs_ptr++) - __ascii_tolower(*rhs_ptr++);
+    }
+    while (result == 0 && --remaining != 0);
+
+    return result;
+}
+
+#endif  /* !_M_IX86 || _M_HYBRID_X86_ARM64 */
+
+extern "C" int __cdecl _memicmp (
+        void const * const lhs,
+        void const * const rhs,
+        size_t       const count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        /* validation section */
+        _VALIDATE_RETURN(lhs != nullptr || count == 0, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(rhs != nullptr || count == 0, EINVAL, _NLSCMPERROR);
+
+        return __ascii_memicmp(lhs, rhs, count);
+    }
+
+    return _memicmp_l(lhs, rhs, count, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcat.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcat.c
new file mode 100644
index 0000000000000000000000000000000000000000..f68538a7544a76a125e9b181de453ac1b070ddcd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcat.c	
@@ -0,0 +1,46 @@
+/***
+*strcat.c - contains strcat() and strcpy()
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Strcpy() copies one string onto another.
+*
+*       Strcat() concatenates (appends) a copy of the source string to the
+*       end of the destination string, returning the destination string.
+*
+*******************************************************************************/
+#define _CRT_SECURE_NO_WARNINGS
+#include <string.h>
+
+#pragma function(strcat)
+#pragma function(strlen)
+#pragma function(strcpy)
+
+/***
+*char *strcat(dst, src) - concatenate (append) one string to another
+*
+*Purpose:
+*       Concatenates src onto the end of dest.  Assumes enough
+*       space in dest.
+*
+*Entry:
+*       char *dst - string to which "src" is to be appended
+*       const char *src - string to be appended to the end of "dst"
+*
+*Exit:
+*       The address of "dst"
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+char * __cdecl strcat (
+        char * dst,
+        const char * src
+        )
+{
+        strcpy(dst + strlen(dst), src);
+
+        return dst;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bf96d89cd7da211c134d09b624361aa3fffc0c14
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcat_s.cpp	
@@ -0,0 +1,21 @@
+//
+// strcat_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strcat_s(), which concatenates (appends) a copy of the source string
+// to the end of the destiation string.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl strcat_s(
+    char*       const destination,
+    size_t      const size_in_elements,
+    char const* const source
+    )
+{
+    return common_tcscat_s(destination, size_in_elements, source);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cfabb5fe9e4a911907c9add637160fb2a21bea29
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcoll.cpp	
@@ -0,0 +1,78 @@
+/***
+*strcoll.c - Collate locale strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*int strcoll() - Collate locale strings
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information.
+*       [ANSI].
+*
+*       Non-C locale support available under _INTL switch.
+*       In the C locale, strcoll() simply resolves to strcmp().
+*Entry:
+*       const char *s1 = pointer to the first string
+*       const char *s2 = pointer to the second string
+*
+*Exit:
+*       Less than 0    = first string less than second string
+*       0              = strings are equal
+*       Greater than 0 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _strcoll_l (
+        const char *_string1,
+        const char *_string2,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+            return strcmp(_string1, _string2);
+
+    if ( 0 == (ret = __acrt_CompareStringA(
+                    _loc_update.GetLocaleT(), _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                               SORT_STRINGSORT,
+                               _string1,
+                               -1,
+                               _string2,
+                               -1,
+                    _loc_update.GetLocaleT()->locinfo->lc_collate_cp )) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+
+}
+
+extern "C" int __cdecl strcoll (
+        const char *_string1,
+        const char *_string2
+        )
+{
+    return _strcoll_l(_string1, _string2, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae8fb2e9be29b84a0ea845bbb0cfc9f867de69cf
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcpy_s.cpp	
@@ -0,0 +1,20 @@
+//
+// strcpy_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strcpy_s(), which copies a string from one buffer to another.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl strcpy_s(
+    char*       const destination,
+    size_t      const size_in_elements,
+    char const* const source
+    )
+{
+    return common_tcscpy_s(destination, size_in_elements, source);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcspn.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcspn.c
new file mode 100644
index 0000000000000000000000000000000000000000..fae2d4be4d4b5db2a49a2ce4f3eac1c574b0a393
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strcspn.c	
@@ -0,0 +1,12 @@
+/***
+*strcspn.c - Defines the strcspn function.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       The function strcspn is mostly common code with strspn in strspn.c.
+*
+*******************************************************************************/
+
+#define SSTRCSPN
+#include "strspn.c"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strdup.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strdup.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba8f391d08d46c9764d6a65b64175ae93b88648b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strdup.cpp	
@@ -0,0 +1,61 @@
+//
+// strdup.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _strdup() and _strdup_dbg(), which dynamically allocate a buffer and
+// duplicate a string into it.
+//
+// These functions allocate storage via malloc() or _malloc_dbg().  The caller
+// is responsible for free()ing the returned array.  If the input string is null
+// or if sufficient memory could not be allocated, these functions return null.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <string.h>
+
+
+
+#ifdef _DEBUG
+
+extern "C" char* __cdecl _strdup(char const* const string)
+{
+    return _strdup_dbg(string, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" char* __cdecl _strdup_dbg(
+    char const* const string,
+    int         const block_use,
+    char const* const file_name,
+    int         const line_number
+    )
+
+#else // ^^^ _DEBUG ^^^ // vvv !_DEBUG vvv //
+
+extern "C" char* __cdecl _strdup(
+    char const* string
+    )
+
+#endif // !_DEBUG
+{
+    if (string == nullptr)
+        return nullptr;
+
+    size_t const size = strlen(string) + 1;
+
+#ifdef _DEBUG
+    char* const memory = static_cast<char*>(_malloc_dbg(
+        size,
+        block_use,
+        file_name,
+        line_number));
+#else
+    char* const memory = static_cast<char*>(malloc(size));
+#endif
+    
+    if (memory == nullptr)
+        return nullptr;
+
+    _ERRCHECK(strcpy_s(memory, size, string));
+    return memory;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/stricmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/stricmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad78f22550316037dd9c282839b6596445259303
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/stricmp.cpp	
@@ -0,0 +1,131 @@
+/***
+*stricmp.cpp - contains case-insensitive string comp routine _stricmp
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       contains _stricmp()
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+#include "strcompare.h"
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 Prefast can't see that we are checking for terminal nul.
+
+/***
+*int _stricmp(lhs, rhs) - compare strings, ignore case
+*
+*Purpose:
+*       _stricmp/_strcmpi perform a case-insensitive string comparision.
+*       For differences, upper case letters are mapped to lower case.
+*       Thus, "abc_" < "ABCD" since "_" < "d".
+*
+*Entry:
+*       char *lhs, *rhs - strings to compare
+*
+*Return:
+*       Returns <0 if lhs < rhs
+*       Returns 0 if lhs = rhs
+*       Returns >0 if lhs > rhs
+*       Returns _NLSCMPERROR if something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" DECLSPEC_NOINLINE int __cdecl _stricmp_l (
+        char const * const lhs,
+        char const * const rhs,
+        _locale_t    const plocinfo
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+
+    unsigned char const * lhs_ptr = reinterpret_cast<unsigned char const *>(lhs);
+    unsigned char const * rhs_ptr = reinterpret_cast<unsigned char const *>(rhs);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    do
+    {
+        lhs_value = _tolower_fast_internal(*lhs_ptr++, _loc_update.GetLocaleT());
+        rhs_value = _tolower_fast_internal(*rhs_ptr++, _loc_update.GetLocaleT());
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0);
+
+    return result;
+}
+
+extern "C" int __cdecl __ascii_stricmp (
+        char const * const lhs,
+        char const * const rhs
+        )
+{
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    return __ascii_stricmp_neon(lhs, rhs);
+#else
+    unsigned char const * lhs_ptr = reinterpret_cast<unsigned char const *>(lhs);
+    unsigned char const * rhs_ptr = reinterpret_cast<unsigned char const *>(rhs);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    do
+    {
+        lhs_value = *lhs_ptr++;
+        rhs_value = *rhs_ptr++;
+        if (lhs_value != rhs_value)
+        {
+            lhs_value = __ascii_tolower(lhs_value);
+            rhs_value = __ascii_tolower(rhs_value);
+        }
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0);
+
+    return result;
+#endif
+}
+
+//
+// Mark _stricmp_validate_param DECLSPEC_NOINLINE to make
+// _stricmp a leaf function for better performance.
+//
+static DECLSPEC_NOINLINE int _stricmp_validate_param (
+        char const * const lhs,
+        char const * const rhs
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+    return _NLSCMPERROR;
+}
+
+extern "C" int __cdecl _stricmp (
+        char const * const lhs,
+        char const * const rhs
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        if (lhs == nullptr || rhs == nullptr)
+        {
+            return _stricmp_validate_param(lhs, rhs);
+        }
+
+        return __ascii_stricmp(lhs, rhs);
+    }
+
+    return _stricmp_l(lhs, rhs, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/stricoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/stricoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9014eae071e91b89f1d46278e10a062e442c3263
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/stricoll.cpp	
@@ -0,0 +1,86 @@
+/***
+*stricoll.c - Collate locale strings without regard to case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*int _stricoll() - Collate locale strings without regard to case
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information
+*       without regard to case.
+*
+*Entry:
+*       const char *s1 = pointer to the first string
+*       const char *s2 = pointer to the second string
+*
+*Exit:
+*       Less than 0    = first string less than second string
+*       0              = strings are equal
+*       Greater than 0 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _stricoll_l (
+        const char *_string1,
+        const char *_string2,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+    {
+        return _stricmp(_string1, _string2);
+    }
+
+    if ( 0 == (ret = __acrt_CompareStringA(_loc_update.GetLocaleT(),
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    SORT_STRINGSORT | NORM_IGNORECASE,
+                    _string1,
+                    -1,
+                    _string2,
+                    -1,
+                    _loc_update.GetLocaleT()->locinfo->lc_collate_cp)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+
+}
+
+extern "C" int __cdecl _stricoll (
+        const char *_string1,
+        const char *_string2
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        return _stricmp(_string1, _string2);
+    }
+    else
+    {
+        return _stricoll_l(_string1, _string2, nullptr);
+    }
+
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strlwr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strlwr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7bdaa5979868f75a970642ac52f2f6b54a9e600d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strlwr.cpp	
@@ -0,0 +1,206 @@
+/***
+*strlwr.c - routine to map upper-case characters in a string to lower-case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Converts all the upper case characters in a string to lower case,
+*       in place.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <corecrt_internal_securecrt.h>
+#include <limits.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*char *_strlwr(string) - map upper-case characters in a string to lower-case
+*
+*Purpose:
+*       _strlwr() converts upper-case characters in a null-terminated string
+*       to their lower-case equivalents.  Conversion is done in place and
+*       characters other than upper-case letters are not modified.
+*
+*       In the C locale, this function modifies only 7-bit ASCII characters
+*       in the range 0x41 through 0x5A ('A' through 'Z').
+*
+*       If the locale is not the 'C' locale, LCMapString() is used to do
+*       the work.  Assumes enough space in the string to hold result.
+*
+*Entry:
+*       char *string - string to change to lower case
+*
+*Exit:
+*       input string address
+*
+*Exceptions:
+*       The original string is returned unchanged on any error, and errno is set.
+*
+*******************************************************************************/
+
+extern "C" char * __cdecl _strlwr_l (
+        char * string,
+        _locale_t plocinfo
+        )
+{
+    _strlwr_s_l(string, (size_t)(-1), plocinfo);
+    return string;
+}
+
+extern "C" char * __cdecl _strlwr (
+        char * string
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        char * cp;
+
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+
+        for (cp=string; *cp; ++cp)
+        {
+            if ('A' <= *cp && *cp <= 'Z')
+                *cp += 'a' - 'A';
+        }
+
+        return(string);
+    }
+    else
+    {
+        _strlwr_s_l(string, (size_t)(-1), nullptr);
+        return string;
+    }
+}
+
+/***
+*errno_t _strlwr_s(string, size_t) - map upper-case characters in a string to lower-case
+*
+*Purpose:
+*       _strlwr_s() converts upper-case characters in a null-terminated string
+*       to their lower-case equivalents.  Conversion is done in place and
+*       characters other than upper-case letters are not modified.
+*
+*       In the C locale, this function modifies only 7-bit ASCII characters
+*       in the range 0x41 through 0x5A ('A' through 'Z').
+*
+*       If the locale is not the 'C' locale, LCMapString() is used to do
+*       the work.  Assumes enough space in the string to hold result.
+*
+*Entry:
+*       char *string - string to change to lower case
+*       size_t sizeInBytes - size of the destination buffer
+*
+*Exit:
+*       the error code
+*
+*Exceptions:
+*       The original string is returned unchanged on any error, and errno is set.
+*
+*******************************************************************************/
+
+static
+errno_t __cdecl _strlwr_s_l_stat (
+        _Inout_updates_z_(sizeInBytes)  char *      const  string,
+                                        size_t      const  sizeInBytes,
+                                        _locale_t   const  plocinfo
+        ) throw()
+{
+
+    int dstsize;                /* size of dst string buffer (include null)  */
+    size_t stringlen;
+
+    /* validation section */
+    _VALIDATE_RETURN_ERRCODE(string != nullptr, EINVAL);
+    stringlen = strnlen(string, sizeInBytes);
+    if (stringlen >= sizeInBytes)
+    {
+        _RESET_STRING(string, sizeInBytes);
+        _RETURN_DEST_NOT_NULL_TERMINATED(string, sizeInBytes);
+    }
+    _FILL_STRING(string, sizeInBytes, stringlen + 1);
+
+    if ( plocinfo->locinfo->locale_name[LC_CTYPE] == nullptr ) {
+        char *cp;       /* traverses string for C locale conversion */
+
+        for ( cp = string ; *cp ; ++cp )
+            if ( ('A' <= *cp) && (*cp <= 'Z') )
+                *cp -= 'A' - 'a';
+
+        return 0;
+    }   /* C locale */
+
+    /* Inquire size of dst string */
+    if ( 0 == (dstsize = __acrt_LCMapStringA(
+                    plocinfo,
+                    plocinfo->locinfo->locale_name[LC_CTYPE],
+                    LCMAP_LOWERCASE,
+                    string,
+                    -1,
+                    nullptr,
+                    0,
+                    plocinfo->locinfo->_public._locale_lc_codepage,
+                    TRUE )) )
+    {
+        errno = EILSEQ;
+        return errno;
+    }
+
+    if (sizeInBytes < (size_t)dstsize)
+    {
+        _RESET_STRING(string, sizeInBytes);
+        _RETURN_BUFFER_TOO_SMALL(string, sizeInBytes);
+    }
+
+    /* Allocate space for dst */
+    __crt_scoped_stack_ptr<char> dst(_malloca_crt_t(char, dstsize));
+    if (!dst)
+    {
+        errno = ENOMEM;
+        return errno;
+    }
+
+    /* Map src string to dst string in alternate case */
+    if (__acrt_LCMapStringA(
+                plocinfo,
+                plocinfo->locinfo->locale_name[LC_CTYPE],
+                LCMAP_LOWERCASE,
+                string,
+                -1,
+                dst.get(),
+                dstsize,
+                plocinfo->locinfo->_public._locale_lc_codepage,
+                TRUE ) != 0)
+    {
+        /* copy dst string to return string */
+        return strcpy_s(string, sizeInBytes, dst.get());
+    }
+    else
+    {
+        return errno = EILSEQ;
+    }
+}
+
+extern "C" errno_t __cdecl _strlwr_s_l (
+        char * string,
+        size_t sizeInBytes,
+        _locale_t plocinfo
+        )
+{
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return _strlwr_s_l_stat(string, sizeInBytes, _loc_update.GetLocaleT());
+}
+
+extern "C" errno_t __cdecl _strlwr_s(
+        char * string,
+        size_t sizeInBytes
+        )
+{
+    return _strlwr_s_l(string, sizeInBytes, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncat.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncat.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c4fb7964e3affb07739e0b5a1f1a05d73070806
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncat.c	
@@ -0,0 +1,49 @@
+/***
+*strncat.c - append n chars of string to new string
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines strncat() - appends n characters of string onto
+*       end of other string
+*
+*******************************************************************************/
+
+#include <string.h>
+
+/***
+*char *strncat(front, back, count) - append count chars of back onto front
+*
+*Purpose:
+*       Appends at most count characters of the string back onto the
+*       end of front, and ALWAYS terminates with a null character.
+*       If count is greater than the length of back, the length of back
+*       is used instead.  (Unlike strncpy, this routine does not pad out
+*       to count characters).
+*
+*Entry:
+*       char *front - string to append onto
+*       char *back - string to append
+*       unsigned count - count of max characters to append
+*
+*Exit:
+*       returns a pointer to string appended onto (front).
+*
+*Uses:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+char * __cdecl strncat (
+        char * front,
+        const char * back,
+        size_t count
+        )
+{
+        char *start = front + strlen(front);
+        size_t backlen = strnlen(back, count);
+        memcpy(start, back, backlen);
+        start[backlen] = '\0';
+        return(front);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a6b90ac0d15471581abae918d92ba7e991aebe0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncat_s.cpp	
@@ -0,0 +1,22 @@
+//
+// strncat_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strncat_s(), which appends n characters of the source string onto the
+// end of the destination string.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl strncat_s(
+    char*       const destination,
+    size_t      const size_in_elements,
+    char const* const source,
+    size_t      const count
+    )
+{
+    return common_tcsncat_s(destination, size_in_elements, source, count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncnt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncnt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2fb639c99b24a655a3e5cc1b4cfaedd8b815c3b9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncnt.cpp	
@@ -0,0 +1,24 @@
+//
+// strncnt.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines __strncnt(), which returns the number of characters in a string.  If
+// the string is longer than the given 'count', 'count' is returned.
+//
+#include <string.h>
+
+
+
+extern "C" size_t __cdecl __strncnt(
+    char const* const string,
+    size_t      const count
+    )
+{
+    char const* it = string;
+    size_t n = 0;
+
+    for (; *it && n != count; ++it, ++n) { }
+
+    return n;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1154c427bc14b502051e99d866b1090c625a6ed4
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncoll.cpp	
@@ -0,0 +1,98 @@
+/***
+*strncoll.c - Collate locale strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information.
+*       Compares at most n characters of two strings.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*int _strncoll() - Collate locale strings
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information.
+*       Compares at most n characters of two strings.
+*
+*Entry:
+*       const char *s1 = pointer to the first string
+*       const char *s2 = pointer to the second string
+*       size_t count - maximum number of characters to compare
+*
+*Exit:
+*       Less than 0    = first string less than second string
+*       0              = strings are equal
+*       Greater than 0 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+extern "C" int __cdecl _strncoll_l (
+        const char *_string1,
+        const char *_string2,
+        size_t count,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+
+    if ( !count )
+        return 0;
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+    {
+        return strncmp(_string1, _string2, count);
+    }
+
+    if ( 0 == (ret = __acrt_CompareStringA(
+                    _loc_update.GetLocaleT(),
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    SORT_STRINGSORT,
+                    _string1,
+                    (int)count,
+                    _string2,
+                    (int)count,
+                    _loc_update.GetLocaleT()->locinfo->lc_collate_cp)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+}
+
+extern "C" int __cdecl _strncoll (
+        const char *_string1,
+        const char *_string2,
+        size_t count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        /* validation section */
+        _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+        return strncmp(_string1, _string2, count);
+    }
+    else
+    {
+        return _strncoll_l(_string1, _string2, count, nullptr);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncpy.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncpy.c
new file mode 100644
index 0000000000000000000000000000000000000000..4081bb83f51d607b0b691e93aa7cc9bb0c329199
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncpy.c	
@@ -0,0 +1,55 @@
+/***
+*strncpy.c - copy at most n characters of string
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines strncpy() - copy at most n characters of string
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#if defined _M_ARM
+    #pragma function(strncpy)
+#endif
+
+/***
+*char *strncpy(dest, source, count) - copy at most n characters
+*
+*Purpose:
+*       Copies count characters from the source string to the
+*       destination.  If count is less than the length of source,
+*       NO NULL CHARACTER is put onto the end of the copied string.
+*       If count is greater than the length of sources, dest is padded
+*       with null characters to length count.
+*
+*
+*Entry:
+*       char *dest - pointer to destination
+*       char *source - source string for copy
+*       unsigned count - max number of characters to copy
+*
+*Exit:
+*       returns dest
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+#pragma function(memcpy, memset)
+
+char * __cdecl strncpy (
+        char * dest,
+        const char * source,
+        size_t count
+        )
+{
+        size_t srclen = strnlen(source, count);
+        memcpy(dest, source, srclen);
+        if (srclen < count)
+        {
+                memset(dest + srclen, 0, count - srclen);
+        }
+        return(dest);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf69cc333129b0a736e74f459fffb02b03778cf6
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strncpy_s.cpp	
@@ -0,0 +1,22 @@
+//
+// strncpy_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strncpy_s(), which appends n characters of the source string onto the
+// end of the destination string.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl strncpy_s(
+    char*       const destination,
+    size_t      const size_in_elements,
+    char const* const source,
+    size_t      const count
+    )
+{
+    return common_tcsncpy_s(destination, size_in_elements, source, count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnicmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnicmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a175f3ff528daeaa805f8411eaf2341b69e3a31c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnicmp.cpp	
@@ -0,0 +1,156 @@
+/***
+*strnicmp.cpp - compare n chars of strings, ignoring case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _strnicmp() - Compares at most n characters of two strings,
+*       without regard to case.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+#define BOUNDED_CMP
+#include "strcompare.h"
+
+/***
+*int _strnicmp(lhs, rhs, count) - compares count char of strings, ignore case
+*
+*Purpose:
+*       Compare the two strings for ordinal order.  Stops the comparison
+*       when the following occurs: (1) strings differ, (2) the end of the
+*       strings is reached, or (3) count characters have been compared.
+*       For the purposes of the comparison, upper case characters are
+*       converted to lower case.
+*
+*Entry:
+*       char *lhs, *rhs - strings to compare
+*       size_t count - maximum number of characters to compare
+*
+*Exit:
+*       returns <0 if lhs < rhs
+*       returns 0 if lhs == rhs
+*       returns >0 if lhs > rhs
+*       Returns _NLSCMPERROR if something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" DECLSPEC_NOINLINE int __cdecl _strnicmp_l (
+        char const * const lhs,
+        char const * const rhs,
+        size_t       const count,
+        _locale_t    const plocinfo
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+    if (count == 0)
+    {
+        return 0;
+    }
+
+    unsigned char const * lhs_ptr = reinterpret_cast<unsigned char const *>(lhs);
+    unsigned char const * rhs_ptr = reinterpret_cast<unsigned char const *>(rhs);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    size_t remaining = count;
+    do
+    {
+        lhs_value = _tolower_fast_internal(*lhs_ptr++, _loc_update.GetLocaleT());
+        rhs_value = _tolower_fast_internal(*rhs_ptr++, _loc_update.GetLocaleT());
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0 && --remaining != 0);
+
+    return result;
+}
+
+#if !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64)
+
+extern "C" int __cdecl __ascii_strnicmp (
+        char const * const lhs,
+        char const * const rhs,
+        size_t       const count
+        )
+{
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    return __ascii_stricmp_neon(lhs, rhs, count);
+#else
+    if (count == 0)
+    {
+        return 0;
+    }
+
+    unsigned char const * lhs_ptr = reinterpret_cast<unsigned char const *>(lhs);
+    unsigned char const * rhs_ptr = reinterpret_cast<unsigned char const *>(rhs);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    size_t remaining = count;
+    do
+    {
+        lhs_value = *lhs_ptr++;
+        rhs_value = *rhs_ptr++;
+        if (lhs_value != rhs_value)
+        {
+            lhs_value = __ascii_tolower(lhs_value);
+            rhs_value = __ascii_tolower(rhs_value);
+        }
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0 && --remaining != 0);
+
+    return result;
+#endif
+}
+
+#endif  /* !_M_IX86 || _M_HYBRID_X86_ARM64 */
+
+//
+// Mark _strnicmp_validate_param DECLSPEC_NOINLINE to make
+// _strnicmp a leaf function for better performance.
+//
+static DECLSPEC_NOINLINE int _strnicmp_validate_param (
+        char const * const lhs,
+        char const * const rhs,
+        size_t       const count
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+    return _NLSCMPERROR;
+}
+
+extern "C" int __cdecl _strnicmp (
+        char const * const lhs,
+        char const * const rhs,
+        size_t       const count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        if (lhs == nullptr || rhs == nullptr || count > INT_MAX)
+        {
+            return _strnicmp_validate_param(lhs, rhs, count);
+        }
+
+        return __ascii_strnicmp(lhs, rhs, count);
+    }
+
+    return _strnicmp_l(lhs, rhs, count, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnicol.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnicol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9ad0308208fb7d029053dfb6dd5b7f1855732fcd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnicol.cpp	
@@ -0,0 +1,93 @@
+/***
+*strnicoll.c - Collate locale strings without regard to case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information.
+*       Compares at most n characters of two strings.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+*int _strnicoll() - Collate locale strings without regard to case
+*
+*Purpose:
+*       Compare two strings using the locale LC_COLLATE information
+*       without regard to case.
+*       Compares at most n characters of two strings.
+*
+*Entry:
+*       const char *s1 = pointer to the first string
+*       const char *s2 = pointer to the second string
+*       size_t count - maximum number of characters to compare
+*
+*Exit:
+*       Less than 0    = first string less than second string
+*       0              = strings are equal
+*       Greater than 0 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _strnicoll_l (
+        const char *_string1,
+        const char *_string2,
+        size_t count,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    if (!count)
+        return 0;
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+        return _strnicmp_l(_string1, _string2, count, _loc_update.GetLocaleT());
+
+    if ( 0 == (ret = __acrt_CompareStringA(
+                    _loc_update.GetLocaleT(),
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    SORT_STRINGSORT | NORM_IGNORECASE,
+                    _string1,
+                    (int)count,
+                    _string2,
+                    (int)count,
+                    _loc_update.GetLocaleT()->locinfo->lc_collate_cp)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+}
+
+extern "C" int __cdecl _strnicoll (
+        const char *_string1,
+        const char *_string2,
+        size_t count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        return _strnicmp(_string1, _string2, count);
+    }
+    else
+    {
+        return _strnicoll_l(_string1, _string2, count, nullptr);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnlen.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnlen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb3076aca785a81d8a73650a06f99efa3f59c472
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnlen.cpp	
@@ -0,0 +1,223 @@
+//
+// strnlen.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strnlen and wcsnlen, which return the length of a null-terminated
+// string, not including the null terminator itself, up to the specified maximum
+// number of characters.
+//
+#include <corecrt_internal.h>
+#include <corecrt_internal_simd.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+// Disable "warning C4752: found Intel(R) Advanced Vector Extensions; consider
+// using /arch:AVX."  We verify that we can use AVX2 before we execute those
+// instructions.
+#pragma warning(disable: 4752)
+
+
+
+namespace
+{
+    enum strnlen_mode
+    {
+        bounded,  // strnlen mode; maximum_count is respected
+        unbounded, // strlen mode; maximum_count is ignored
+    };
+}
+
+// This function returns true if we have reached the end of the range to be
+// searched for a terminator.  For the bounded strnlen functions, we must
+// test to see whether
+template <strnlen_mode Mode>
+static __forceinline bool __cdecl last_reached(
+    void const* const it,
+    void const* const last
+    ) throw()
+{
+    return it == last;
+}
+
+template <>
+__forceinline bool __cdecl last_reached<unbounded>(
+    void const* const it,
+    void const* const last
+    ) throw()
+{
+    UNREFERENCED_PARAMETER(it);
+    UNREFERENCED_PARAMETER(last);
+
+    return false;
+}
+
+
+
+// An implementation of strnlen using plain C, suitable for any architecture:
+template <strnlen_mode Mode, typename Element>
+_Check_return_
+_When_(maximum_count > _String_length_(string), _Post_satisfies_(return == _String_length_(string)))
+_When_(maximum_count <= _String_length_(string), _Post_satisfies_(return == maximum_count))
+static __forceinline size_t __cdecl common_strnlen_c(
+    Element const* const string,
+    size_t         const maximum_count
+    ) throw()
+{
+    Element const* const last = string + maximum_count;
+    Element const*       it   = string;
+
+    for (; !last_reached<Mode>(it, last) && *it != '\0'; ++it)
+    {
+    }
+
+    return static_cast<size_t>(it - string);
+}
+
+#ifdef _CRT_SIMD_SUPPORT_AVAILABLE
+
+    template <strnlen_mode Mode, __crt_simd_isa Isa, typename Element>
+    _Check_return_
+    _When_(maximum_count > _String_length_(string), _Post_satisfies_(return == _String_length_(string)))
+    _When_(maximum_count <= _String_length_(string), _Post_satisfies_(return == maximum_count))
+    static __forceinline size_t __cdecl common_strnlen_simd(
+        Element const* const string,
+        size_t         const maximum_count
+        ) throw()
+    {
+        using traits = __crt_simd_traits<Isa, Element>;
+
+        // For efficient SIMD processing of the string, we will use a typical three-
+        // -phase computation:
+        //
+        // [1] We compute the number of bytes from the start of the string to the
+        //     next element_size boundary and process these bytes individually.  If
+        //     we find a \0 we return immediately.
+        //
+        // [2] At this point, we now have a pointer to an aligned block of bytes.
+        //     We process bytes in element_size chunks until there are fewer than
+        //     element_size bytes remaining to be examined.  If we find a chunk
+        //     that contains a \0 we break out of the loop without advancing to
+        //     the next chunk, to let the phase 3 loop reexamine the chunk.
+        //
+        // [3] We process the remaining bytes individually.  If we find a \0 we
+        //     return immediately.
+        //
+        // Note that in phase [2] we may read bytes beyond the terminator (and thus
+        // beyond the end of the string).  This is okay, because we are reading
+        // aligned chunks, so a chunk will never straddle a page boundary and if we
+        // can read any byte from the chunk we can read all bytes from the chunk.
+        //
+        // Here we go...
+        uintptr_t const string_integer = reinterpret_cast<uintptr_t>(string);
+        if (string_integer % traits::element_size != 0)
+        {
+            // If the input string is itself unaligned (e.g. if it is a wchar_t*
+            // with an odd address), we can't align for vector processing.  Switch
+            // back to the slow implementation:
+            return common_strnlen_c<Mode>(string, maximum_count);
+        }
+
+        // [1] Alignment Loop (Prefix)
+        uintptr_t const prefix_forward_offset = string_integer % traits::pack_size;
+        uintptr_t const prefix_reverse_offset = prefix_forward_offset == 0
+            ? 0
+            : traits::pack_size - prefix_forward_offset;
+
+        size_t const prefix_count  = __min(maximum_count, prefix_reverse_offset / traits::element_size);
+        size_t const prefix_result = common_strnlen_c<bounded>(string, prefix_count);
+        if (prefix_result != prefix_count)
+        {
+            return prefix_result;
+        }
+
+        Element const* it = string + prefix_result;
+
+        // [2] Aligned Vector Loop (Middle)
+        __crt_simd_cleanup_guard<Isa> const simd_cleanup;
+
+        traits::pack_type const zero = traits::get_zero_pack();
+
+        size_t const middle_and_suffix_count = maximum_count - prefix_count;
+        size_t const suffix_count            = middle_and_suffix_count % traits::pack_size;
+        size_t const middle_count            = middle_and_suffix_count - suffix_count;
+
+        Element const* const middle_last = it + middle_count;
+        while (!last_reached<Mode>(it, middle_last))
+        {
+            auto const element_it = reinterpret_cast<traits::pack_type const*>(it);
+
+            bool const element_has_terminator = traits::compute_byte_mask(traits::compare_equals(*element_it, zero)) != 0;
+            if (element_has_terminator)
+            {
+                break;
+            }
+
+            it += traits::elements_per_pack;
+        }
+
+        // [3] Remainder Loop (Suffix)
+        Element const* const suffix_last = string + maximum_count;
+        for (; !last_reached<Mode>(it, suffix_last) && *it != '\0'; ++it)
+        {
+        }
+
+        // Either we have exhausted the buffer or we have found the terminator:
+        return static_cast<size_t>(it - string);
+    }
+
+#endif // _CRT_SIMD_SUPPORT_AVAILABLE
+
+template <strnlen_mode Mode, typename Element>
+_Check_return_
+_When_(maximum_count > _String_length_(string), _Post_satisfies_(return == _String_length_(string)))
+_When_(maximum_count <= _String_length_(string), _Post_satisfies_(return == maximum_count))
+static __forceinline size_t __cdecl common_strnlen(
+    Element const* const string,
+    size_t         const maximum_count
+    ) throw()
+{
+    #ifdef _CRT_SIMD_SUPPORT_AVAILABLE
+    if (__isa_available >= __ISA_AVAILABLE_AVX2)
+    {
+        return common_strnlen_simd<Mode, __crt_simd_isa::avx2>(string, maximum_count);
+    }
+    else if (__isa_available >= __ISA_AVAILABLE_SSE2)
+    {
+        return common_strnlen_simd<Mode, __crt_simd_isa::sse2>(string, maximum_count);
+    }
+    #endif
+
+    return common_strnlen_c<Mode>(string, maximum_count);
+}
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC) && !defined(_M_HYBRID_X86_ARM64)
+
+extern "C" size_t __cdecl strnlen(
+    char const* const string,
+    size_t      const maximum_count
+    )
+{
+    return common_strnlen<bounded>(reinterpret_cast<uint8_t const*>(string), maximum_count);
+}
+
+extern "C" size_t __cdecl wcsnlen(
+    wchar_t const* const string,
+    size_t         const maximum_count
+    )
+{
+    return common_strnlen<bounded>(reinterpret_cast<uint16_t const*>(string), maximum_count);
+}
+
+#pragma function(wcslen)
+
+extern "C" size_t __cdecl wcslen(
+    wchar_t const* const string
+    )
+{
+    return common_strnlen<unbounded>(reinterpret_cast<uint16_t const*>(string), _CRT_UNBOUNDED_BUFFER_SIZE);
+}
+
+#endif // !defined(_M_ARM64) && !defined(_M_ARM64EC) && !defined(_M_HYBRID_X86_ARM64)
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnset.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnset.c
new file mode 100644
index 0000000000000000000000000000000000000000..70a243f1f0cb8a26fc0da21d4f7e6679466b608e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnset.c	
@@ -0,0 +1,46 @@
+/***
+*strnset.c - set first n characters to single character
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _strnset() - sets at most the first n characters of a string
+*       to a given character.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+/***
+*char *_strnset(string, val, count) - set at most count characters to val
+*
+*Purpose:
+*       Sets the first count characters of string the character value.
+*       If the length of string is less than count, the length of
+*       string is used in place of n.
+*
+*Entry:
+*       char *string - string to set characters in
+*       char val - character to fill with
+*       unsigned count - count of characters to fill
+*
+*Exit:
+*       returns string, now filled with count copies of val.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+char * __cdecl _strnset (
+        char * string,
+        int val,
+        size_t count
+        )
+{
+        char *start = string;
+
+        while (count-- && *string)
+                *string++ = (char)val;
+
+        return(start);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8105448d2ea9897a81ce1695b1e7f280488e20a1
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strnset_s.cpp	
@@ -0,0 +1,23 @@
+//
+// strnset_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _strnset_s(), which sets at most the first 'count' characters of a
+// string to the given character and ensures that the resulting string is null-
+// terminated.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl _strnset_s(
+    char*  const destination,
+    size_t const size_in_elements,
+    int    const value,
+    size_t const count
+    )
+{
+    return common_tcsnset_s(destination, size_in_elements, static_cast<char>(value), count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strpbrk.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strpbrk.c
new file mode 100644
index 0000000000000000000000000000000000000000..373e1cb942fb6aa63b0d97042900ade47dc3ce02
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strpbrk.c	
@@ -0,0 +1,12 @@
+/***
+*strpbrk.c - Defines the strpbrk function.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       The function strpbrk is mostly common code with strspn in strspn.c.
+*
+*******************************************************************************/
+
+#define SSTRPBRK
+#include "strspn.c"
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strrev.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strrev.c
new file mode 100644
index 0000000000000000000000000000000000000000..4b8d6f9f0b9cbf41437b591bf8e42ce338fc3426
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strrev.c	
@@ -0,0 +1,51 @@
+/***
+*strrev.c - reverse a string in place
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _strrev() - reverse a string in place (not including
+*       '\0' character)
+*
+*******************************************************************************/
+
+#include <string.h>
+
+/***
+*char *_strrev(string) - reverse a string in place
+*
+*Purpose:
+*       Reverses the order of characters in the string.  The terminating
+*       null character remains in place.
+*
+*Entry:
+*       char *string - string to reverse
+*
+*Exit:
+*       returns string - now with reversed characters
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+char * __cdecl _strrev (
+        char * string
+        )
+{
+        char *start = string;
+        char *left = string;
+        char ch;
+
+        while (*string++)                 /* find end of string */
+                ;
+        string -= 2;
+
+        while (left < string)
+        {
+                ch = *left;
+                *left++ = *string;
+                *string-- = ch;
+        }
+
+        return(start);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strset.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strset.c
new file mode 100644
index 0000000000000000000000000000000000000000..52118a055b060cd4f7bb3fd7792ec17167469219
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strset.c	
@@ -0,0 +1,50 @@
+/***
+*strset.c - sets all characters of string to given character
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _strset() - sets all of the characters in a string (except
+*       the '\0') equal to a given character.
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#if defined _M_X64 || defined _M_ARM || defined _M_ARM64 || _M_HYBRID
+    #pragma function(_strset)
+#endif
+
+/***
+*char *_strset(string, val) - sets all of string to val
+*
+*Purpose:
+*       Sets all of characters in string (except the terminating '/0'
+*       character) equal to val.
+*
+*
+*Entry:
+*       char *string - string to modify
+*       char val - value to fill string with
+*
+*Exit:
+*       returns string -- now filled with val's
+*
+*Uses:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+char * __cdecl _strset (
+        char * string,
+        int val
+        )
+{
+        char *start = string;
+
+        while (*string)
+                *string++ = (char)val;
+
+        return(start);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..033df455231dabf8716bf3a009ae671cdea88f6a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strset_s.cpp	
@@ -0,0 +1,21 @@
+//
+// strset_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _strset_s(), which sets all of the characters of a null-terminated
+// string to the given character.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl _strset_s(
+    char*  const destination,
+    size_t const size_in_elements,
+    int    const value
+    )
+{
+    return common_tcsset_s(destination, size_in_elements, static_cast<char>(value));
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strspn.c b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strspn.c
new file mode 100644
index 0000000000000000000000000000000000000000..d0847c2125cd1bf26a8e5b9134092d1f96f2abbb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strspn.c	
@@ -0,0 +1,166 @@
+/***
+*strspn.c - find length of initial substring of chars from a control string
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines strspn() - finds the length of the initial substring of
+*       a string consisting entirely of characters from a control string.
+*
+*       defines strcspn()- finds the length of the initial substring of
+*       a string consisting entirely of characters not in a control string.
+*
+*       defines strpbrk()- finds the index of the first character in a string
+*       that is not in a control string
+*
+*******************************************************************************/
+
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 Prefast doesn't understand reading past buffer but staying on same page.
+#pragma warning(disable:__WARNING_RETURNING_BAD_RESULT) // 28196
+
+/* Determine which routine we're compiling for (default to STRSPN) */
+#define _STRSPN         1
+#define _STRCSPN        2
+#define _STRPBRK        3
+
+#if defined (SSTRCSPN)
+    #define ROUTINE _STRCSPN
+#elif defined (SSTRPBRK)
+    #define ROUTINE _STRPBRK
+#else
+    #define ROUTINE _STRSPN
+#endif
+
+/***
+*int strspn(string, control) - find init substring of control chars
+*
+*Purpose:
+*       Finds the index of the first character in string that does belong
+*       to the set of characters specified by control.  This is
+*       equivalent to the length of the initial substring of string that
+*       consists entirely of characters from control.  The '\0' character
+*       that terminates control is not considered in the matching process.
+*
+*Entry:
+*       char *string - string to search
+*       char *control - string containing characters not to search for
+*
+*Exit:
+*       returns index of first char in string not in control
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/***
+*int strcspn(string, control) - search for init substring w/o control chars
+*
+*Purpose:
+*       returns the index of the first character in string that belongs
+*       to the set of characters specified by control.  This is equivalent
+*       to the length of the length of the initial substring of string
+*       composed entirely of characters not in control.  Null chars not
+*       considered.
+*
+*Entry:
+*       char *string - string to search
+*       char *control - set of characters not allowed in init substring
+*
+*Exit:
+*       returns the index of the first char in string
+*       that is in the set of characters specified by control.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/***
+*char *strpbrk(string, control) - scans string for a character from control
+*
+*Purpose:
+*       Finds the first occurence in string of any character from
+*       the control string.
+*
+*Entry:
+*       char *string - string to search in
+*       char *control - string containing characters to search for
+*
+*Exit:
+*       returns a pointer to the first character from control found
+*       in string.
+*       returns NULL if string and control have no characters in common.
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+
+/* Routine prototype */
+#if ROUTINE == _STRSPN
+size_t __cdecl strspn (
+#elif ROUTINE == _STRCSPN
+size_t __cdecl strcspn (
+#else  /* ROUTINE == _STRCSPN */
+char * __cdecl strpbrk (
+#endif  /* ROUTINE == _STRCSPN */
+        const char * string,
+        const char * control
+        )
+{
+        const unsigned char *str = (unsigned char const*)string;
+        const unsigned char *ctrl = (unsigned char const*)control;
+
+        unsigned char map[32];
+        /* Clear out bit map */
+        memset(map, 0, sizeof(map));
+
+        /* Set bits in control map */
+        while (*ctrl)
+        {
+                _bittestandset64(map, *ctrl);
+                ctrl++;
+        }
+
+#if ROUTINE == _STRSPN
+
+        /* 1st char NOT in control map stops search */
+        if (*str)
+        {
+                int count=0;
+                while (_bittest64(map, *str))
+                {
+                        count++;
+                        str++;
+                }
+                return(count);
+        }
+        return(0);
+
+#elif ROUTINE == _STRCSPN
+
+        /* 1st char in control map stops search */
+        int count=0;
+        map[0] |= 1;    /* null chars not considered */
+        while (!_bittest64(map, *str))
+        {
+                count++;
+                str++;
+        }
+        return(count);
+
+#else  /* ROUTINE == _STRCSPN */
+
+        /* 1st char in control map stops search */
+        while (*str)
+        {
+                if (_bittest64(map, *str))
+                        return((char *)str);
+                str++;
+        }
+        return(NULL);
+
+#endif  /* ROUTINE == _STRCSPN */
+
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strtok.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strtok.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48ddbf5172f9a47f88e309843539be2b08bd9048
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strtok.cpp	
@@ -0,0 +1,33 @@
+//
+// strtok.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strtok(), which tokenizes a string via repeated calls.
+//
+// strtok() considers the string to consist of a sequence of zero or more text
+// tokens separated by spans of one or more control characters.  The first call,
+// with a string specified, returns a pointer to the first character of the
+// first token, and will write a null character into the string immediately
+// following the returned token.  Subsequent calls with a null string argument
+// will work through the string until no tokens remain.  The control string
+// may be different from call to call.  When no tokens remain in the string, a
+// null pointer is returned.  
+//
+#include <corecrt_internal.h>
+#include <string.h>
+
+
+
+extern "C" char* __cdecl __acrt_strtok_s_novalidation(
+    _Inout_opt_z_                 char*       string,
+    _In_z_                        char const* control,
+    _Inout_ _Deref_prepost_opt_z_ char**      context
+    );
+
+
+
+extern "C" char* __cdecl strtok(char* const string, char const* const control)
+{
+    return __acrt_strtok_s_novalidation(string, control, &__acrt_getptd()->_strtok_token);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strtok_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strtok_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..afc315c4373dd2662cbc96773ba0f6d72197a7d3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strtok_s.cpp	
@@ -0,0 +1,80 @@
+//
+// strtok_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines strtok_s(), which tokenizes a string via repeated calls.  See strtok()
+// for more details.  This more secure function uses a caller-provided context
+// instead of the thread-local tokenization state.
+//
+#include <string.h>
+#include <corecrt_internal_securecrt.h>
+
+
+
+// This common implementation is used by both strtok() and strtok_s()
+extern "C" char* __cdecl __acrt_strtok_s_novalidation(
+    _Inout_opt_z_                 char*       string,
+    _In_z_                        char const* control,
+    _Inout_ _Deref_prepost_opt_z_ char**      context
+    )
+{
+    // Clear control map.  The control characters are stored in a bitmap, one
+    // bit per character.  The null character is always a control character.
+    unsigned char map[32];
+    memset(map, 0, sizeof(map));
+
+    // Set bits in delimiter table
+    unsigned char const* unsigned_control = reinterpret_cast<unsigned char const*>(control);
+    while (*unsigned_control)
+    {
+        _bittestandset((long *)map, *unsigned_control);
+        unsigned_control++;
+    }
+
+    // If string is null, set the iterator to the saved pointer (i.e., continue
+    // breaking tokens out of the string from the last strtok call):
+    char* it = string != nullptr
+        ? string
+        : *context;
+
+    unsigned char*& unsigned_it = reinterpret_cast<unsigned char*&>(it);
+
+    // Find beginning of token (skip over leading delimiters). Note that
+    // there is no token iff this loop sets it to point to the terminal
+    // null (*it == '\0')
+    while (*it && _bittest((long *)map, *unsigned_it))
+    {
+        ++it;
+    }
+
+    char* const token_first = it;
+
+    // Find the end of the token. If it is not the end of the string,
+    // put a null there.
+    for (; *it; ++it)
+    {
+        if (_bittest((long *)map, *unsigned_it))
+        {
+            *it++ = '\0';
+            break;
+        }
+    }
+
+    // Update the saved pointer:
+    *context = it;
+
+    // Determine if a token has been found.
+    return it != token_first ? token_first : nullptr;
+}
+
+
+
+extern "C" char* __cdecl strtok_s(char* string, char const* control, char** context)
+{
+    _VALIDATE_POINTER_ERROR_RETURN(context, EINVAL, nullptr);
+    _VALIDATE_POINTER_ERROR_RETURN(control, EINVAL, nullptr);
+    _VALIDATE_CONDITION_ERROR_RETURN(string != nullptr || *context != nullptr, EINVAL, nullptr);
+
+    return __acrt_strtok_s_novalidation(string, control, context);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strupr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strupr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2fe2e1379c619f95d73c1fc20270aa073d7581c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strupr.cpp	
@@ -0,0 +1,206 @@
+/***
+*strupr.c - routine to map lower-case characters in a string to upper-case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Converts all the lower case characters in a string to upper case,
+*       in place.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <corecrt_internal_securecrt.h>
+#include <limits.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*char *_strupr(string) - map lower-case characters in a string to upper-case
+*
+*Purpose:
+*       _strupr() converts lower-case characters in a null-terminated string
+*       to their upper-case equivalents.  Conversion is done in place and
+*       characters other than lower-case letters are not modified.
+*
+*       In the C locale, this function modifies only 7-bit ASCII characters
+*       in the range 0x61 through 0x7A ('a' through 'z').
+*
+*       If the locale is not the 'C' locale, LCMapString() is used to do
+*       the work.  Assumes enough space in the string to hold result.
+*
+*Entry:
+*       char *string - string to change to upper case
+*
+*Exit:
+*       input string address
+*
+*Exceptions:
+*       The original string is returned unchanged on any error, and errno is set.
+*
+*******************************************************************************/
+
+extern "C" char * __cdecl _strupr_l (
+        char * string,
+        _locale_t plocinfo
+        )
+{
+    _strupr_s_l(string, (size_t)(-1), plocinfo);
+    return (string);
+}
+
+extern "C" char * __cdecl _strupr (
+        char * string
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        /* validation section */
+        _VALIDATE_RETURN(string != nullptr, EINVAL, nullptr);
+
+        char *cp;       /* traverses string for C locale conversion */
+
+        for ( cp = string ; *cp ; ++cp )
+            if ( ('a' <= *cp) && (*cp <= 'z') )
+                *cp -= 'a' - 'A';
+
+        return(string);
+    }
+    else
+    {
+        _strupr_s_l(string, (size_t)(-1), nullptr);
+        return (string);
+    }
+}
+
+/***
+*errno_t _strupr_s(string, size_t) - map lower-case characters in a string to upper-case
+*
+*Purpose:
+*       _strupr() converts lower-case characters in a null-terminated string
+*       to their upper-case equivalents.  Conversion is done in place and
+*       characters other than lower-case letters are not modified.
+*
+*       In the C locale, this function modifies only 7-bit ASCII characters
+*       in the range 0x61 through 0x7A ('a' through 'z').
+*
+*       If the locale is not the 'C' locale, LCMapString() is used to do
+*       the work.  Assumes enough space in the string to hold result.
+*
+*Entry:
+*       char *string - string to change to upper case
+*       size_t sizeInBytes - size of the destination buffer
+*
+*Exit:
+*       the error code
+*
+*Exceptions:
+*       The original string is returned unchanged on any error, and errno is set.
+*
+*******************************************************************************/
+
+static errno_t __cdecl _strupr_s_l_stat (
+        _Inout_updates_z_(sizeInBytes)  char *      const  string,
+                                        size_t      const  sizeInBytes,
+                                        _locale_t   const  plocinfo
+        ) throw()
+{
+    int dstsize;                /* size of dst string buffer (include null)  */
+    size_t stringlen;
+
+    /* validation section */
+    _VALIDATE_RETURN_ERRCODE(string != nullptr, EINVAL);
+    stringlen = strnlen(string, sizeInBytes);
+    if (stringlen >= sizeInBytes)
+    {
+        _RESET_STRING(string, sizeInBytes);
+        _RETURN_DEST_NOT_NULL_TERMINATED(string, sizeInBytes);
+    }
+    _FILL_STRING(string, sizeInBytes, stringlen + 1);
+
+    if ( plocinfo->locinfo->locale_name[LC_CTYPE] == nullptr )
+    {
+        char *cp=string;       /* traverses string for C locale conversion */
+
+        for ( ; *cp ; ++cp )
+        {
+            if ( ('a' <= *cp) && (*cp <= 'z') )
+            {
+                *cp -= 'a' - 'A';
+            }
+        }
+
+        return 0;
+    }   /* C locale */
+
+    /* Inquire size of dst string */
+    if ( 0 == (dstsize = __acrt_LCMapStringA(
+                    plocinfo,
+                    plocinfo->locinfo->locale_name[LC_CTYPE],
+                    LCMAP_UPPERCASE,
+                    string,
+                    -1,
+                    nullptr,
+                    0,
+                    plocinfo->locinfo->_public._locale_lc_codepage,
+                    TRUE )) )
+    {
+        errno = EILSEQ;
+        return errno;
+    }
+
+    if (sizeInBytes < (size_t)dstsize)
+    {
+        _RESET_STRING(string, sizeInBytes);
+        _RETURN_BUFFER_TOO_SMALL(string, sizeInBytes);
+    }
+
+    /* Allocate space for dst */
+    __crt_scoped_stack_ptr<char> const dst(_malloca_crt_t(char, dstsize));
+    if (!dst)
+    {
+        errno = ENOMEM;
+        return errno;
+    }
+
+    /* Map src string to dst string in alternate case */
+    if (__acrt_LCMapStringA(
+                plocinfo,
+                plocinfo->locinfo->locale_name[LC_CTYPE],
+                LCMAP_UPPERCASE,
+                string,
+                -1,
+                dst.get(),
+                dstsize,
+                plocinfo->locinfo->_public._locale_lc_codepage,
+                TRUE ) != 0)
+    {
+        /* copy dst string to return string */
+        return strcpy_s(string, sizeInBytes, dst.get());
+    }
+    else
+    {
+        return errno = EILSEQ;
+    }
+}
+
+extern "C" errno_t __cdecl _strupr_s_l (
+        char * string,
+        size_t sizeInBytes,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return _strupr_s_l_stat(string, sizeInBytes, _loc_update.GetLocaleT());
+}
+
+extern "C" errno_t __cdecl _strupr_s (
+        char * string,
+        size_t sizeInBytes
+        )
+{
+    return _strupr_s_l(string, sizeInBytes, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strxfrm.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strxfrm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..896c52bc15977a1077c7e87737f7dbbeb605d469
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/strxfrm.cpp	
@@ -0,0 +1,147 @@
+/***
+*strxfrm.c - Transform a string using locale information
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Transform a string using the locale information as set by
+*       LC_COLLATE.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*size_t strxfrm() - Transform a string using locale information
+*
+*Purpose:
+*       Transform the string pointed to by _string2 and place the
+*       resulting string into the array pointed to by _string1.
+*       No more than _count characters are place into the
+*       resulting string (including the null).
+*
+*       The transformation is such that if strcmp() is applied to
+*       the two transformed strings, the return value is equal to
+*       the result of strcoll() applied to the two original strings.
+*       Thus, the conversion must take the locale LC_COLLATE info
+*       into account.
+*       [ANSI]
+*
+*       The value of the following expression is the size of the array
+*       needed to hold the transformation of the source string:
+*
+*           1 + strxfrm(nullptr,string,0)
+*
+*Entry:
+*       char *_string1       = result string
+*       const char *_string2 = source string
+*       size_t _count        = max chars to move
+*
+*       [If _count is 0, _string1 is permitted to be nullptr.]
+*
+*Exit:
+*       Length of the transformed string (not including the terminating
+*       null).  If the value returned is >= _count, the contents of the
+*       _string1 array are indeterminate.
+*
+*Exceptions:
+*       Non-standard: if OM/API error, return INT_MAX.
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl _strxfrm_l (
+        char *_string1,
+        const char *_string2,
+        size_t _count,
+        _locale_t plocinfo
+        )
+{
+    int dstlen;
+    size_t retval = INT_MAX;   /* NON-ANSI: default if OM or API error */
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /* validation section */
+    _VALIDATE_RETURN(_count <= INT_MAX, EINVAL, INT_MAX);
+    _VALIDATE_RETURN(_string1 != nullptr || _count == 0, EINVAL, INT_MAX);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, INT_MAX);
+
+    /* pre-init output in case of error */
+    if(_string1!=nullptr && _count>0)
+    {
+        *_string1='\0';
+    }
+
+    if ( (_loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr) &&
+            (_loc_update.GetLocaleT()->locinfo->lc_collate_cp == CP_ACP) )
+    {
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        strncpy(_string1, _string2, _count);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+        return strlen(_string2);
+    }
+
+    /* Inquire size of dst string in BYTES */
+    if ( 0 == (dstlen = __acrt_LCMapStringA(
+                    _loc_update.GetLocaleT(),
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    LCMAP_SORTKEY,
+                    _string2,
+                    -1,
+                    nullptr,
+                    0,
+                    _loc_update.GetLocaleT()->locinfo->lc_collate_cp,
+                    TRUE )) )
+    {
+        errno = EILSEQ;
+        return INT_MAX;
+    }
+
+    retval = (size_t)dstlen;
+
+    /* if not enough room, return amount needed */
+    if ( retval > _count )
+    {
+        if (_string1 != nullptr && _count > 0)
+        {
+            *_string1 = '\0';
+            errno = ERANGE;
+        }
+        /* the return value is the string length (without the terminating 0) */
+        retval--;
+        return retval;
+    }
+
+    /* Map src string to dst string */
+    if ( 0 == __acrt_LCMapStringA(
+                _loc_update.GetLocaleT(),
+                _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                LCMAP_SORTKEY,
+                _string2,
+                -1,
+                _string1,
+                (int)_count,
+                _loc_update.GetLocaleT()->locinfo->lc_collate_cp,
+                TRUE ) )
+    {
+        errno = EILSEQ;
+        return INT_MAX;
+    }
+    /* the return value is the string length (without the terminating 0) */
+    retval--;
+
+    return retval;
+}
+
+extern "C" size_t __cdecl strxfrm (
+        char *_string1,
+        const char *_string2,
+        size_t _count
+        )
+{
+
+    return _strxfrm_l(_string1, _string2, _count, nullptr);
+
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscat.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4abc0af0861d0816e03b730fdc03869b25a16596
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscat.cpp	
@@ -0,0 +1,34 @@
+//
+// wcscat.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcscat(), which concatenates (appends) a copy of the source string to
+// the end of the destination string.
+//
+// This function assumes that the destination buffer is sufficiently large to
+// store the appended string.
+//
+#define _CRT_SECURE_NO_WARNINGS
+#include <string.h>
+
+
+
+#if defined _M_X64 || defined _M_IX86 || defined _M_ARM || defined _M_ARM64
+    #pragma warning(disable:4163)
+    #pragma function(wcscat)
+    #pragma function(wcslen)
+    #pragma function(wcscpy)
+#endif
+
+
+
+extern "C" wchar_t * __cdecl wcscat(
+    wchar_t*       const destination,
+    wchar_t const*       source
+    )
+
+{
+    wcscpy(destination + wcslen(destination), source);
+    return destination;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aae666a136d8ef11bb95c9f26ac6fe703a0a4a76
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscat_s.cpp	
@@ -0,0 +1,21 @@
+//
+// wcscat_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcscat_s(), which concatenates (appends) a copy of the source string
+// to the end of the destiation string.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+
+
+extern "C" errno_t __cdecl wcscat_s(
+    wchar_t*       const destination,
+    size_t         const size_in_elements,
+    wchar_t const* const source
+    )
+{
+    return common_tcscat_s(destination, size_in_elements, source);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscmpc.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscmpc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d589cf1bc1c2b9f73ff36966db541946ec9d5317
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscmpc.cpp	
@@ -0,0 +1,42 @@
+//
+// wcscmp.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcscmp(), which compares two wide character strings, determining
+// their ordinal order.
+//
+// Note that the comparison is performed with unsigned elements (wchar_t is
+// unsigned in this implementation), so the null character (0) is less than
+// all other characters.
+//
+// Returns:
+//  * -1 if a  < b
+//  *  0 if a == b
+//  *  1 if a  > b
+//
+#include <string.h>
+
+
+
+#if defined _M_X64 || defined _M_IX86 || defined _M_ARM || defined _M_ARM64
+    #pragma warning(disable: 4163)
+    #pragma function(wcscmp)
+#endif
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC) && !defined(_M_HYBRID_X86_ARM64)
+
+extern "C" int __cdecl wcscmp(wchar_t const* a, wchar_t const* b)
+{
+    int result = 0;
+#pragma warning(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+    while ((result = (int)(*a - *b)) == 0 && *b)
+    {
+        ++a;
+        ++b;
+    }
+
+    return ((-result) < 0) - (result < 0); // (if positive) - (if negative) generates branchless code
+}
+
+#endif
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aca0fe631779c11c18393b84a2723669af098c0b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscoll.cpp	
@@ -0,0 +1,88 @@
+/***
+*wcscoll.c - Collate wide-character locale strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+
+/***
+*int wcscoll() - Collate wide-character locale strings
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information.
+*       In the C locale, wcscmp() is used to make the comparison.
+*
+*Entry:
+*       const wchar_t *s1 = pointer to the first string
+*       const wchar_t *s2 = pointer to the second string
+*
+*Exit:
+*       -1 = first string less than second string
+*        0 = strings are equal
+*        1 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*       This range of return values may differ from other *cmp/*coll functions.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _wcscoll_l (
+        const wchar_t *_string1,
+        const wchar_t *_string2,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+        return (wcscmp(_string1, _string2));
+
+    if ( 0 == (ret = __acrt_CompareStringW(
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    SORT_STRINGSORT,
+                    _string1,
+                    -1,
+                    _string2,
+                    -1)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+
+}
+
+extern "C" int __cdecl wcscoll (
+        const wchar_t *_string1,
+        const wchar_t *_string2
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        /* validation section */
+        _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+
+        return (wcscmp(_string1, _string2));
+    }
+    else
+    {
+        return _wcscoll_l(_string1, _string2, nullptr);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscpy.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscpy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89f6825450d430837209f8efab46d87049793591
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscpy.cpp	
@@ -0,0 +1,25 @@
+//
+// wcscpy.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcscpy(), which copies a string from one buffer to another.
+//
+#include <string.h>
+
+
+
+#if defined _M_X64 || defined _M_IX86 || defined _M_ARM || defined _M_ARM64
+    #pragma warning(disable:4163)
+    #pragma function(wcscpy)
+#endif
+
+#pragma function(memcpy, wcslen)
+
+extern "C" wchar_t* __cdecl wcscpy(
+    wchar_t*       const destination,
+    wchar_t const*       source)
+{
+    memcpy(destination, source, (wcslen(source) + 1) * sizeof(wchar_t));
+    return destination;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2fbc170ac3078f409ebedbf550da0545bfca96f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscpy_s.cpp	
@@ -0,0 +1,18 @@
+//
+// wcscpy_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcscpy_s(), which copies a string from one buffer to another.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+extern "C" errno_t __cdecl wcscpy_s(
+    wchar_t*       const destination,
+    size_t         const size_in_elements,
+    wchar_t const* const source
+    )
+{
+    return common_tcscpy_s(destination, size_in_elements, source);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscspn.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscspn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..05744a3df8c39156c7ea03228b6539d33f868e23
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcscspn.cpp	
@@ -0,0 +1,34 @@
+//
+// wcscspn.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcscspn(), which searches a string for an initial substring that does
+// not contain any of the specified control characters.
+//
+// This function returns the index of the first character in the string that
+// belongs to the set of characters specified by 'control'.  This is equivalent
+// to the length of the initial substring of 'string' composed entirely of
+// characters that are not in 'control'.
+//
+#include <string.h>
+
+
+
+extern "C" size_t __cdecl wcscspn(
+    wchar_t const* const string,
+    wchar_t const* const control
+    )
+{
+    wchar_t const* string_it = string;
+    for (; *string_it; ++string_it)
+    {
+        wchar_t const* control_it = wcschr(control, *string_it);
+        if (control_it != nullptr)
+        {
+            return static_cast<size_t>(string_it - string);
+        }
+    }
+
+    return static_cast<size_t>(string_it - string);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsdup.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsdup.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53416aea3afe3423d3cc095d3ebe861d83932b94
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsdup.cpp	
@@ -0,0 +1,60 @@
+//
+// wcsdup.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _wcsdup() and _wcsdup_dbg(), which dynamically allocate a buffer and
+// duplicate a string into it.
+//
+// These functions allocate storage via malloc() or _malloc_dbg().  The caller
+// is responsible for free()ing the returned array.  If the input string is null
+// or if sufficient memory could not be allocated, these functions return null.
+//
+#include <corecrt_internal.h>
+#include <malloc.h>
+#include <string.h>
+
+#ifdef _DEBUG
+
+extern "C" wchar_t* __cdecl _wcsdup(wchar_t const* const string)
+{
+    return _wcsdup_dbg(string, _NORMAL_BLOCK, nullptr, 0);
+}
+
+extern "C" wchar_t* __cdecl _wcsdup_dbg(
+    wchar_t const* const string,
+    int            const block_use,
+    char const*    const file_name,
+    int            const line_number
+    )
+
+#else // ^^^ _DEBUG ^^^ // vvv !_DEBUG vvv //
+
+extern "C" wchar_t* __cdecl _wcsdup(
+    wchar_t const* string
+    )
+
+#endif // !_DEBUG
+{
+    if (string == nullptr)
+        return nullptr;
+
+    size_t const size_in_elements = wcslen(string) + 1;
+
+#ifdef _DEBUG
+    wchar_t* const memory = static_cast<wchar_t*>(_malloc_dbg(
+        size_in_elements * sizeof(wchar_t),
+        block_use,
+        file_name,
+        line_number));
+#else
+    wchar_t* const memory = static_cast<wchar_t*>(malloc(
+        size_in_elements * sizeof(wchar_t)));
+#endif
+
+    if (memory == nullptr)
+        return nullptr;
+
+    _ERRCHECK(wcscpy_s(memory, size_in_elements, string));
+    return memory;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsicmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsicmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..038d7bf72ffe2c5825b25d6d703b0450bf3091cd
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsicmp.cpp	
@@ -0,0 +1,149 @@
+/***
+*wcsicmp.cpp - contains case-insensitive wide string comp routine _wcsicmp
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       contains _wcsicmp()
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+#include "strcompare.h"
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 Prefast can't see that we are checking for terminal nul.
+
+/***
+*int _wcsicmp(lhs, rhs) - compare wide-character strings, ignore case
+*
+*Purpose:
+*       _wcsicmp performs a case-insensitive wchar_t string comparision.
+*       _wcsicmp is independent of locale.
+*
+*Entry:
+*       wchar_t *lhs, *rhs - strings to compare
+*
+*Return:
+*       Returns <0 if lhs < rhs
+*       Returns 0 if lhs = rhs
+*       Returns >0 if lhs > rhs
+*       Returns _NLSCMPERROR if something went wrong
+*       This range of return values may differ from other *cmp/*coll functions.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" DECLSPEC_NOINLINE int __cdecl _wcsicmp_l (
+        wchar_t const * const lhs,
+        wchar_t const * const rhs,
+        _locale_t       const plocinfo
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    // This check is still worth doing for wide but not narrow because
+    // we need to consult the UTF-16 ctype map for towlower operations.
+    if (_loc_update.GetLocaleT()->locinfo->locale_name[LC_CTYPE] == nullptr)
+    {
+        return __ascii_wcsicmp(lhs, rhs);
+    }
+
+    unsigned short const * lhs_ptr = reinterpret_cast<unsigned short const *>(lhs);
+    unsigned short const * rhs_ptr = reinterpret_cast<unsigned short const *>(rhs);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    do
+    {
+        lhs_value = *lhs_ptr++;
+        rhs_value = *rhs_ptr++;
+        if (lhs_value != rhs_value)
+        {
+            lhs_value = _towlower_internal(static_cast<unsigned short>(lhs_value), _loc_update.GetLocaleT());
+            if (lhs_value != rhs_value)
+            {
+                rhs_value = _towlower_internal(static_cast<unsigned short>(rhs_value), _loc_update.GetLocaleT());
+            }
+        }
+
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0);
+
+    return result;
+}
+
+extern "C" int __cdecl __ascii_wcsicmp(
+        wchar_t const * const lhs,
+        wchar_t const * const rhs
+        )
+{
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    return __ascii_wcsicmp_neon(lhs, rhs);
+#else
+    unsigned short const * lhs_ptr = reinterpret_cast<unsigned short const *>(lhs);
+    unsigned short const * rhs_ptr = reinterpret_cast<unsigned short const *>(rhs);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    do
+    {
+        lhs_value = *lhs_ptr++;
+        rhs_value = *rhs_ptr++;
+
+        if (lhs_value != rhs_value)
+        {
+            lhs_value = __ascii_towlower(lhs_value);
+            rhs_value = __ascii_towlower(rhs_value);
+        }
+
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0);
+
+    return result;
+#endif
+}
+
+//
+// Mark _wcsicmp_validate_param DECLSPEC_NOINLINE to make
+// _wcsicmp a leaf function for better performance.
+//
+static DECLSPEC_NOINLINE int _wcsicmp_validate_param (
+        wchar_t const * const lhs,
+        wchar_t const * const rhs
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+    return _NLSCMPERROR;
+}
+
+extern "C" int __cdecl _wcsicmp(
+        wchar_t const * const lhs,
+        wchar_t const * const rhs
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        if (lhs == nullptr || rhs == nullptr)
+        {
+            return _wcsicmp_validate_param(lhs, rhs);
+        }
+
+        return __ascii_wcsicmp(lhs, rhs);
+    }
+
+    return _wcsicmp_l(lhs, rhs, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsicoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsicoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15fe718ed8b7b92facff05a2011e8165e55b8582
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsicoll.cpp	
@@ -0,0 +1,93 @@
+/***
+*wcsicoll.c - Collate wide-character locale strings without regard to case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information
+*       without regard to case.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018 Prefast can't see that we are checking for terminal nul.
+
+/***
+*int _wcsicoll() - Collate wide-character locale strings without regard to case
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information
+*       without regard to case.
+*       In the C locale, _wcsicmp() is used to make the comparison.
+*
+*Entry:
+*       const wchar_t *s1 = pointer to the first string
+*       const wchar_t *s2 = pointer to the second string
+*
+*Exit:
+*       -1 = first string less than second string
+*        0 = strings are equal
+*        1 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*       This range of return values may differ from other *cmp/*coll functions.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _wcsicoll_l (
+        const wchar_t *_string1,
+        const wchar_t *_string2,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR );
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR );
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+    {
+        return __ascii_wcsicmp(_string1, _string2);
+    }
+
+    if ( 0 == (ret = __acrt_CompareStringW(
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    SORT_STRINGSORT | NORM_IGNORECASE,
+                    _string1,
+                    -1,
+                    _string2,
+                    -1)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+}
+
+extern "C" int __cdecl _wcsicoll (
+        const wchar_t *_string1,
+        const wchar_t *_string2
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        /* validation section */
+        _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR );
+        _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR );
+
+        return __ascii_wcsicmp(_string1, _string2);
+    }
+    else
+    {
+        return _wcsicoll_l(_string1, _string2, nullptr);
+    }
+
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcslwr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcslwr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe93912286ecc6e8177c89d6e5938b18a9868a9a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcslwr.cpp	
@@ -0,0 +1,192 @@
+/***
+*wcslwr.c - routine to map upper-case characters in a wchar_t string
+*       to lower-case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Converts all the upper case characters in a wchar_t string
+*       to lower case, in place.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <corecrt_internal_securecrt.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*wchar_t *_wcslwr(string) - map upper-case characters in a string to lower-case
+*
+*Purpose:
+*       wcslwr converts upper-case characters in a null-terminated wchar_t
+*       string to their lower-case equivalents.  The result may be longer or
+*       shorter than the original string.  Assumes enough space in string
+*       to hold the result.
+*
+*Entry:
+*       wchar_t *wsrc - wchar_t string to change to lower case
+*
+*Exit:
+*       input string address
+*
+*Exceptions:
+*       on an error, the original string is unaltered, and errno is set
+*
+*******************************************************************************/
+
+extern "C" wchar_t * __cdecl _wcslwr_l (
+        wchar_t * wsrc,
+        _locale_t plocinfo
+        )
+{
+    _wcslwr_s_l(wsrc, (size_t)(-1), plocinfo);
+    return wsrc;
+}
+
+extern "C" wchar_t * __cdecl _wcslwr (
+        wchar_t * wsrc
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        wchar_t * p;
+
+        /* validation section */
+        _VALIDATE_RETURN(wsrc != nullptr, EINVAL, nullptr);
+
+        for (p=wsrc; *p; ++p)
+        {
+            if (L'A' <= *p && *p <= L'Z')
+                *p += (wchar_t)L'a' - (wchar_t)L'A';
+        }
+    } else {
+        _wcslwr_s_l(wsrc, (size_t)(-1), nullptr);
+        return wsrc;
+    }
+
+    return(wsrc);
+}
+
+/***
+*errno_t _wcslwr_s(string, size_t) - map upper-case characters in a string to lower-case
+*
+*Purpose:
+*       wcslwr_s converts upper-case characters in a null-terminated wchar_t
+*       string to their lower-case equivalents.  The result may be longer or
+*       shorter than the original string.
+*
+*Entry:
+*       wchar_t *wsrc - wchar_t string to change to lower case
+*       size_t sizeInWords - size of the destination buffer
+*
+*Exit:
+*       the error code
+*
+*Exceptions:
+*       on an error, the original string is unaltered, and errno is set
+*
+*******************************************************************************/
+
+static errno_t __cdecl _wcslwr_s_l_stat (
+        _Inout_updates_z_(sizeInWords) wchar_t * wsrc,
+        size_t sizeInWords,
+        _locale_t plocinfo
+        )
+{
+
+    wchar_t *p;             /* traverses string for C locale conversion */
+    int dstsize;            /* size in wide chars of wdst string buffer (include null) */
+    size_t stringlen;
+
+    /* validation section */
+    _VALIDATE_RETURN_ERRCODE(wsrc != nullptr, EINVAL);
+    stringlen = wcsnlen(wsrc, sizeInWords);
+    if (stringlen >= sizeInWords)
+    {
+        _RESET_STRING(wsrc, sizeInWords);
+        _RETURN_DEST_NOT_NULL_TERMINATED(wsrc, sizeInWords);
+    }
+    _FILL_STRING(wsrc, sizeInWords, stringlen + 1);
+
+    if ( plocinfo->locinfo->locale_name[LC_CTYPE] == nullptr)
+    {
+        for ( p = wsrc ; *p ; p++ )
+        {
+            if ( (*p >= (wchar_t)L'A') && (*p <= (wchar_t)L'Z') )
+            {
+                *p -= static_cast<wchar_t>(L'A' - L'a');
+            }
+        }
+
+        return 0;
+    }   /* C locale */
+
+    /* Inquire size of wdst string */
+    if ( (dstsize = __acrt_LCMapStringW(
+                    plocinfo->locinfo->locale_name[LC_CTYPE],
+                    LCMAP_LOWERCASE,
+                    wsrc,
+                    -1,
+                    nullptr,
+                    0
+                    )) == 0 )
+    {
+        errno = EILSEQ;
+        return errno;
+    }
+
+    if (sizeInWords < (size_t)dstsize)
+    {
+        _RESET_STRING(wsrc, sizeInWords);
+        _RETURN_BUFFER_TOO_SMALL(wsrc, sizeInWords);
+    }
+
+    /* Allocate space for wdst */
+    __crt_scoped_stack_ptr<wchar_t> const wdst(_malloca_crt_t(wchar_t, dstsize));
+    if (!wdst)
+    {
+        errno = ENOMEM;
+        return errno;
+    }
+
+    /* Map wrc string to wide-character wdst string in alternate case */
+    if (__acrt_LCMapStringW(
+                plocinfo->locinfo->locale_name[LC_CTYPE],
+                LCMAP_LOWERCASE,
+                wsrc,
+                -1,
+                wdst.get(),
+                dstsize
+                ) != 0)
+    {
+        /* Copy wdst string to user string */
+        return wcscpy_s(wsrc, sizeInWords, wdst.get());
+    }
+    else
+    {
+        return errno = EILSEQ;
+    }
+}
+
+extern "C" errno_t __cdecl _wcslwr_s_l (
+        wchar_t * wsrc,
+        size_t sizeInWords,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return _wcslwr_s_l_stat(wsrc, sizeInWords, _loc_update.GetLocaleT());
+}
+
+
+extern "C" errno_t __cdecl _wcslwr_s (
+        wchar_t * wsrc,
+        size_t sizeInWords
+        )
+{
+    return _wcslwr_s_l(wsrc, sizeInWords, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncat.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a2d27a201c31ceedd7a5fdaedfc7519afd44a5c
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncat.cpp	
@@ -0,0 +1,29 @@
+//
+// wcsncat.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcsncat(), which appends n characters of the source string onto the
+// end of the destination string.  The destination string is always null
+// terminated.  Unlike wcsncpy, this function does not pad out to 'count'
+// characters.
+//
+#include <string.h>
+
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+#pragma function(memcpy, wcslen)
+
+extern "C" wchar_t* __cdecl wcsncat(
+    wchar_t*       const destination,
+    wchar_t const* const source,
+    size_t         const count
+    )
+{
+    wchar_t *start = destination + wcslen(destination);
+    size_t srclen = wcsnlen(source, count);
+    memcpy(start, source, srclen * sizeof(wchar_t));
+    start[srclen] = '\0';
+    return(destination);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncat_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncat_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2be0a6180afd68a48ee9c6b568aa7a1136d92e91
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncat_s.cpp	
@@ -0,0 +1,20 @@
+//
+// wcsncat_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcsncat_s(), which appends n characters of the source string onto the
+// end of the destination string.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+extern "C" errno_t __cdecl wcsncat_s(
+    wchar_t*       const destination,
+    size_t         const size_in_elements,
+    wchar_t const* const source,
+    size_t         const count
+    )
+{
+    return common_tcsncat_s(destination, size_in_elements, source, count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..944d6e4db186d6387f27fdafe1c416f44e4a8a2a
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncmp.cpp	
@@ -0,0 +1,50 @@
+//
+// wcsncmp.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcsncmp(), which compares two wide character strings, determining
+// their ordinal order.  The function tests at most 'count' characters.
+//
+// Note that the comparison is performed with unsigned elements (wchar_t is
+// unsigned in this implementation), so the null character (0) is less than
+// all other characters.
+//
+// Returns:
+//  * a negative value if a  < b
+//  * zero             if a == b
+//  * a positive value if a  > b
+//
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <string.h>
+#define CASE_SENSITIVE_CMP
+#define BOUNDED_CMP
+#include "strcompare.h"
+
+
+#ifdef _M_ARM
+    #pragma function(wcsncmp)
+#endif
+
+extern "C" int __cdecl wcsncmp(
+    wchar_t const* a,
+    wchar_t const* b,
+    size_t         count
+    )
+{
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    return __ascii_wcsicmp_neon(a, b, count);
+#else
+    if (count == 0)
+        return 0;
+
+    while (--count != 0 && *a && *a == *b)
+    {
+        ++a;
+        ++b;
+    }
+
+    return static_cast<int>(*a - *b);
+#endif
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncnt.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncnt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8b85dedc12cf129cc9ee61c9b54885bc4c028fb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncnt.cpp	
@@ -0,0 +1,24 @@
+//
+// wcsncnt.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines __wcsncnt(), which returns the number of characters in a string.  If
+// the string is longer than the given 'count', 'count' is returned.
+//
+#include <string.h>
+
+
+
+extern "C" size_t __cdecl __wcsncnt(
+    wchar_t const* const string,
+    size_t         const count
+    )
+{
+    wchar_t const* it = string;
+    size_t n = 0;
+
+    for (; *it && n != count; ++it, ++n) { }
+
+    return n;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncoll.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncoll.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed1a9d7b0f428b5ae986049ee4d6ec5179f5def3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncoll.cpp	
@@ -0,0 +1,104 @@
+/***
+*wcsncoll.c - Collate wide-character locale strings
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information.
+*       Compares at most n characters of two strings.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*int _wcsncoll() - Collate wide-character locale strings
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information
+*       Compares at most n characters of two strings.
+*       In the C locale, _wcsncmp() is used to make the comparison.
+*
+*Entry:
+*       const wchar_t *s1 = pointer to the first string
+*       const wchar_t *s2 = pointer to the second string
+*       size_t count - maximum number of characters to compare
+*
+*Exit:
+*       -1 = first string less than second string
+*        0 = strings are equal
+*        1 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*       This range of return values may differ from other *cmp/*coll functions.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _wcsncoll_l (
+        const wchar_t *_string1,
+        const wchar_t *_string2,
+        size_t count,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+
+    if (!count)
+    {
+        return 0;
+    }
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+    {
+        return wcsncmp(_string1, _string2, count);
+    }
+
+    if ( 0 == (ret = __acrt_CompareStringW(
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                               SORT_STRINGSORT,
+                               _string1,
+                               (int)count,
+                               _string2,
+                               (int)count)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+
+}
+
+extern "C" int __cdecl _wcsncoll (
+        const wchar_t *_string1,
+        const wchar_t *_string2,
+        size_t count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+    return wcsncmp(_string1, _string2, count);
+    }
+    else
+    {
+        return _wcsncoll_l(_string1, _string2, count, nullptr);
+    }
+
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncpy.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncpy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..717d41c5c10dd124933bb64480ab0631b16e8c76
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncpy.cpp	
@@ -0,0 +1,34 @@
+//
+// wcsncpy.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcsncpy(), which copies a string from one buffer to another.  This
+// function copies at most 'count' characters.  If fewer than 'count' characters
+// are copied, the rest of the buffer is padded with null characters.
+//
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POSTCONDITION_NULLTERMINATION_VIOLATION) // 26036
+
+
+#ifdef _M_ARM
+    #pragma function(wcsncpy)
+#endif
+
+#pragma function(memcpy, memset)
+
+extern "C" wchar_t * __cdecl wcsncpy(
+    wchar_t*       const destination,
+    wchar_t const* const source,
+    size_t         const count
+    )
+{
+    size_t srclen = wcsnlen(source, count);
+    memcpy(destination, source, srclen * sizeof(wchar_t));
+    if (srclen < count)
+    {
+        memset(destination + srclen, 0, (count - srclen) * sizeof(wchar_t));
+    }
+    return(destination);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..00e289daff435568ea5c3ba9eb12fb3824c0bd91
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsncpy_s.cpp	
@@ -0,0 +1,20 @@
+//
+// wcsncpy_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcsncpy_s(), which appends n characters of the source string onto the
+// end of the destination string.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+extern "C" errno_t __cdecl wcsncpy_s(
+    wchar_t*       const destination,
+    size_t         const size_in_elements,
+    wchar_t const* const source,
+    size_t         const count
+    )
+{
+    return common_tcsncpy_s(destination, size_in_elements, source, count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnicmp.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnicmp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef24e969fe3e39b37a4285fbdbabc26560de2e35
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnicmp.cpp	
@@ -0,0 +1,161 @@
+/***
+*wcsnicmp.cpp - compare n chars of wide-character strings, ignoring case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       defines _wcsnicmp() - Compares at most n characters of two wchar_t
+*       strings, without regard to case.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <corecrt_internal_securecrt.h>
+#include <locale.h>
+#include <string.h>
+#define BOUNDED_CMP
+#include "strcompare.h"
+
+/***
+*int _wcsnicmp(lhs, rhs, count) - compares count wchar_t of strings,
+*       ignore case
+*
+*Purpose:
+*       Compare the two strings for ordinal order.  Stops the comparison
+*       when the following occurs: (1) strings differ, (2) the end of the
+*       strings is reached, or (3) count characters have been compared.
+*       For the purposes of the comparison, upper case characters are
+*       converted to lower case (wide-characters).
+*
+*Entry:
+*       wchar_t *lhs, *rhs - strings to compare
+*       size_t count - maximum number of characters to compare
+*
+*Exit:
+*       Returns -1 if lhs < rhs
+*       Returns 0 if lhs == rhs
+*       Returns 1 if lhs > rhs
+*       Returns _NLSCMPERROR if something went wrong
+*       This range of return values may differ from other *cmp/*coll functions.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" DECLSPEC_NOINLINE int __cdecl _wcsnicmp_l (
+        wchar_t const * const lhs,
+        wchar_t const * const rhs,
+        size_t          const count,
+        _locale_t       const plocinfo
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+
+    if (count == 0)
+    {
+        return 0;
+    }
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    // This check is still worth doing for wide but not narrow because
+    // we need to consult the UTF-16 ctype map for towlower operations.
+    if (_loc_update.GetLocaleT()->locinfo->locale_name[LC_CTYPE] == nullptr)
+    {
+        return __ascii_wcsnicmp(lhs, rhs, count);
+    }
+
+    unsigned short const * lhs_ptr = reinterpret_cast<unsigned short const *>(lhs);
+    unsigned short const * rhs_ptr = reinterpret_cast<unsigned short const *>(rhs);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    size_t remaining = count;
+    do
+    {
+        lhs_value = _towlower_internal(*lhs_ptr++, _loc_update.GetLocaleT());
+        rhs_value = _towlower_internal(*rhs_ptr++, _loc_update.GetLocaleT());
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0 && --remaining != 0);
+
+    return result;
+}
+
+extern "C" int __cdecl __ascii_wcsnicmp(
+        wchar_t const * const lhs,
+        wchar_t const * const rhs,
+        size_t          const count
+        )
+{
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    return __ascii_wcsicmp_neon(lhs, rhs, count);
+#else
+    if (count == 0)
+    {
+        return 0;
+    }
+
+    unsigned short const * lhs_ptr = reinterpret_cast<unsigned short const *>(lhs);
+    unsigned short const * rhs_ptr = reinterpret_cast<unsigned short const *>(rhs);
+
+    int result;
+    int lhs_value;
+    int rhs_value;
+    size_t remaining = count;
+    do
+    {
+        lhs_value = *lhs_ptr++;
+        rhs_value = *rhs_ptr++;
+
+        if (lhs_value != rhs_value)
+        {
+            lhs_value = __ascii_towlower(lhs_value);
+            rhs_value = __ascii_towlower(rhs_value);
+        }
+
+        result = lhs_value - rhs_value;
+    }
+    while (result == 0 && lhs_value != 0 && --remaining != 0);
+
+    return result;
+#endif
+}
+
+//
+// Mark _wcsnicmp_validate_param DECLSPEC_NOINLINE to make
+// _wcsnicmp a leaf function for better performance.
+//
+static DECLSPEC_NOINLINE int _wcsnicmp_validate_param (
+        wchar_t const * const lhs,
+        wchar_t const * const rhs
+        )
+{
+    /* validation section */
+    _VALIDATE_RETURN(lhs != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(rhs != nullptr, EINVAL, _NLSCMPERROR);
+    return _NLSCMPERROR;
+}
+
+extern "C" int __cdecl _wcsnicmp (
+        wchar_t const * const lhs,
+        wchar_t const * const rhs,
+        size_t          const count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        if (lhs == nullptr || rhs == nullptr)
+        {
+            return _wcsnicmp_validate_param(lhs, rhs);
+        }
+
+        return __ascii_wcsnicmp(lhs, rhs, count);
+    }
+
+    return _wcsnicmp_l(lhs, rhs, count, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnicol.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnicol.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58e311c7e131139d2e037ae36f502ea4240e13f0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnicol.cpp	
@@ -0,0 +1,103 @@
+/***
+*wcsnicoll.c - Collate wide-character locale strings without regard to case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information
+*       without regard to case.
+*       Compares at most n characters of two strings.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*int _wcsnicoll() - Collate wide-character locale strings without regard to case
+*
+*Purpose:
+*       Compare two wchar_t strings using the locale LC_COLLATE information
+*       without regard to case.
+*       Compares at most n characters of two strings.
+*       In the C locale, _wcsicmp() is used to make the comparison.
+*
+*Entry:
+*       const wchar_t *s1 = pointer to the first string
+*       const wchar_t *s2 = pointer to the second string
+*       size_t count - maximum number of characters to compare
+*
+*Exit:
+*       -1 = first string less than second string
+*        0 = strings are equal
+*        1 = first string greater than second string
+*       Returns _NLSCMPERROR is something went wrong
+*       This range of return values may differ from other *cmp/*coll functions.
+*
+*Exceptions:
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" int __cdecl _wcsnicoll_l (
+        const wchar_t *_string1,
+        const wchar_t *_string2,
+        size_t count,
+        _locale_t plocinfo
+        )
+{
+    int ret;
+
+    if (!count)
+    {
+        return 0;
+    }
+
+    /* validation section */
+    _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+    _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+    {
+        return __ascii_wcsnicmp(_string1, _string2, count);
+    }
+
+    if ( 0 == (ret = __acrt_CompareStringW(
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                               SORT_STRINGSORT | NORM_IGNORECASE,
+                               _string1,
+                               (int)count,
+                               _string2,
+                               (int)count)) )
+    {
+        errno = EINVAL;
+        return _NLSCMPERROR;
+    }
+
+    return (ret - 2);
+}
+
+extern "C" int __cdecl _wcsnicoll (
+        const wchar_t *_string1,
+        const wchar_t *_string2,
+        size_t count
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        /* validation section */
+        _VALIDATE_RETURN(_string1 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(_string2 != nullptr, EINVAL, _NLSCMPERROR);
+        _VALIDATE_RETURN(count <= INT_MAX, EINVAL, _NLSCMPERROR);
+
+        return __ascii_wcsnicmp(_string1, _string2, count);
+    }
+    else
+    {
+        return _wcsnicoll_l(_string1, _string2, count, nullptr);
+    }
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6b916de48daf8a02356414130fd222c32d56bb69
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnset.cpp	
@@ -0,0 +1,26 @@
+//
+// wcsnset.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _wcsnset(), which sets all of the characters of a null-terminated
+// string to the given character.  This function sets at most 'count' characters.
+//
+#include <string.h>
+
+
+
+extern "C" wchar_t* __cdecl _wcsnset(
+    wchar_t* const string,
+    wchar_t  const value,
+    size_t   const count
+    )
+{
+    wchar_t* it = string;
+    for (size_t i = 0; i != count && *it; ++i, ++it)
+    {
+        *it = value;
+    }
+
+    return string;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2f9a149dfd0e341cd777ed03e4abaf8989c30f6e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsnset_s.cpp	
@@ -0,0 +1,21 @@
+//
+// wcsnset_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _wcsnset_s(), which sets at most the first 'count' characters of a
+// string to the given character and ensures that the resulting string is null-
+// terminated.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+extern "C" errno_t __cdecl _wcsnset_s(
+    wchar_t* const destination,
+    size_t   const size_in_elements,
+    wchar_t  const value,
+    size_t   const count
+    )
+{
+    return common_tcsnset_s(destination, size_in_elements, value, count);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcspbrk.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcspbrk.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8b5b2f7eecff1d70bad24b905c1d0d544e4048ff
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcspbrk.cpp	
@@ -0,0 +1,27 @@
+//
+// wcspbrk.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcspbrk(), which returns a pointer to the first wide character in
+// 'string' that is in the 'control'.
+//
+#include <string.h>
+
+
+
+extern "C" wchar_t const* __cdecl wcspbrk(
+    wchar_t const* const string,
+    wchar_t const* const control
+    )
+{
+    for (wchar_t const* string_it = string; *string_it; ++string_it)
+    {
+        if (wcschr(control, *string_it) != nullptr)
+        {
+            return string_it;
+        }
+    }
+
+    return nullptr;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsrev.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsrev.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b72b231e42122d8e86895c525eddcd186a619ea
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsrev.cpp	
@@ -0,0 +1,30 @@
+//
+// wcsrev.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _wcsrev(), which reverses a wide chraacter string in place.  The
+// pointer to the string is returned.
+//
+#include <string.h>
+
+
+
+extern "C" wchar_t* __cdecl _wcsrev(wchar_t* const string)
+{
+    // Find the end of the string:
+    wchar_t* right = string;
+    while (*right++) { }
+    right -= 2;
+
+    // Reverse the strong:
+    wchar_t* left = string;
+    while (left < right)
+    {
+        wchar_t const c = *left;
+        *left++  = *right;
+        *right-- = c;
+    }
+
+    return string;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b589a39ea80ab3b599bf75d84102c0cbc4e6d5fb
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsset.cpp	
@@ -0,0 +1,29 @@
+//
+// wcsset.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _wcsset(), which sets all of the characters in a wide character
+// string to the given value.
+//
+#include <string.h>
+
+
+
+#if defined _M_X64 || defined _M_IX86 || defined _M_ARM || defined _M_ARM64
+    #pragma warning(disable:4163)
+    #pragma function(_wcsset)
+#endif
+
+
+
+extern "C" wchar_t* __cdecl _wcsset(
+	wchar_t* const string,
+	wchar_t  const value
+	)
+{
+    for (wchar_t* p = string; *p; ++p)
+        *p = value;
+
+    return string;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsset_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsset_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a4e1bd021a7a38d8f434b49f2ecc731ac99329b9
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsset_s.cpp	
@@ -0,0 +1,19 @@
+//
+// wcsset_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines _wcsset_s(), which sets all of the characters of a null-terminated
+// string to the given character.
+//
+#include <corecrt_internal_string_templates.h>
+#include <string.h>
+
+extern "C" errno_t __cdecl _wcsset_s(
+    wchar_t* const destination,
+    size_t   const size_in_elements,
+    wchar_t  const value
+    )
+{
+    return common_tcsset_s(destination, size_in_elements, value);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsspn.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsspn.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..301012e210b66c33d02e54b7ac81759069b44771
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsspn.cpp	
@@ -0,0 +1,33 @@
+//
+// wcsspn.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcsspn(), which finds the length of the initial substring of 'string'
+// that consists entirely of characters in 'control'.  This function returns the
+// index of the first character in the string that does not belong to the set of
+// characters in the control string.  If there is no such character, the length
+// of the string is returned.
+//
+#include <string.h>
+
+
+
+extern "C" size_t __cdecl wcsspn(
+    wchar_t const* const string,
+    wchar_t const* const control
+    )
+{
+    wchar_t const* string_it = string;
+    for (; *string_it; ++string_it)
+    {
+        wchar_t const* control_it = wcschr(control, *string_it);
+        if (control_it == nullptr)
+        {
+            return static_cast<size_t>(string_it - string);
+        }
+    }
+
+    // The whole string consisted of characters from the control:
+    return static_cast<size_t>(string_it - string);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcstok.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcstok.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..66a72e5912cec41f97d27e53da5165bbb7731e5b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcstok.cpp	
@@ -0,0 +1,34 @@
+//
+// wcstok.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcstok(), which tokenizes a string via repeated calls.  See strtok()
+// for more details.
+//
+#include <corecrt_internal.h>
+#include <string.h>
+
+
+
+_Check_return_
+extern "C" wchar_t* __cdecl __acrt_wcstok_s_novalidation(
+    _Inout_opt_z_                 wchar_t*       string,
+    _In_z_                        wchar_t const* control,
+    _Inout_ _Deref_prepost_opt_z_ wchar_t**      context
+    );
+
+
+
+extern "C" wchar_t* __cdecl wcstok(
+    wchar_t*       const string,
+    wchar_t const* const control,
+    wchar_t**      const context
+    )
+{
+    wchar_t** const context_to_use = context != nullptr
+        ? context
+        : &__acrt_getptd()->_wcstok_token;
+
+    return __acrt_wcstok_s_novalidation(string, control, context_to_use);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcstok_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcstok_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0846af068428b8062c63722c23e988636e5ba0b0
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcstok_s.cpp	
@@ -0,0 +1,75 @@
+//
+// wcstok_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wcstok_s(), which tokenizes a string via repeated calls.  See strtok()
+// for more details.  This more secure function uses a caller-provided context
+// instead of the thread-local tokenization state.
+//
+#include <corecrt_internal_securecrt.h>
+#include <string.h>
+
+
+
+// This common implementation is used by both strtok() and strtok_s()
+extern "C" wchar_t* __cdecl __acrt_wcstok_s_novalidation(
+    _Inout_opt_z_                 wchar_t*       string,
+    _In_z_                        wchar_t const* control,
+    _Inout_ _Deref_prepost_opt_z_ wchar_t**      context
+    )
+{
+    // If string is null, set the iterator to the saved pointer (i.e., continue
+    // breaking tokens out of the string from the last strtok call):
+    wchar_t* string_it = string != nullptr
+        ? string
+        : *context;
+
+
+    // Find beginning of token (skip over leading delimiters). Note that
+    // there is no token iff this loop sets string to point to the terminal
+    // null (*string == '\0')
+    while (*string_it)
+    {
+        wchar_t const* control_it = wcschr(control, *string_it);
+        if (!control_it)
+            break;
+
+        ++string_it;
+    }
+
+    wchar_t* const token_first = string_it;
+
+    // Find the end of the token.  If it is not the end of the string, put a
+    // null character there:
+    for (; *string_it; ++string_it)
+    {
+        wchar_t const* control_it = wcschr(control, *string_it);
+        if (control_it)
+        {
+            *string_it++ = '\0';
+            break;
+        }
+    }
+
+    // Update the saved pointer:
+    *context = string_it;
+
+    // Determine if a token has been found.
+    return string_it != token_first ? token_first : nullptr;
+}
+
+
+
+extern "C" wchar_t* __cdecl wcstok_s(
+    wchar_t*       const string,
+    wchar_t const* const control,
+    wchar_t**      const context
+    )
+{
+    _VALIDATE_POINTER_ERROR_RETURN(context, EINVAL, nullptr);
+    _VALIDATE_POINTER_ERROR_RETURN(control, EINVAL, nullptr);
+    _VALIDATE_CONDITION_ERROR_RETURN(string != nullptr || *context != nullptr, EINVAL, nullptr);
+
+    return __acrt_wcstok_s_novalidation(string, control, context);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsupr.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsupr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15e9cd4beed22104bb61a27c23ccd4a7f4222b70
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsupr.cpp	
@@ -0,0 +1,189 @@
+/***
+*wcsupr.c - routine to map lower-case characters in a wchar_t string
+*       to upper-case
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Converts all the lower case characters in a wchar_t string
+*       to upper case, in place.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <corecrt_internal_securecrt.h>
+#include <locale.h>
+#include <string.h>
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_NULLTERMINATED) // 26018
+
+/***
+*wchar_t *_wcsupr(string) - map lower-case characters in a string to upper-case
+*
+*Purpose:
+*       wcsupr converts lower-case characters in a null-terminated wchar_t
+*       string to their upper-case equivalents.  The result may be longer or
+*       shorter than the original string.  Assumes enough space in string
+*       to hold the result.
+*
+*Entry:
+*       wchar_t *wsrc - wchar_t string to change to upper case
+*
+*Exit:
+*       input string address
+*
+*Exceptions:
+*       on an error, the original string is unaltered, and errno is set
+*
+*******************************************************************************/
+
+extern "C" wchar_t * __cdecl _wcsupr_l (
+        wchar_t * wsrc,
+        _locale_t plocinfo
+        )
+{
+    _wcsupr_s_l(wsrc, (size_t)(-1), plocinfo);
+    return wsrc;
+}
+
+extern "C" wchar_t * __cdecl _wcsupr (
+        wchar_t * wsrc
+        )
+{
+    if (!__acrt_locale_changed())
+    {
+        wchar_t * p;
+
+        /* validation section */
+        _VALIDATE_RETURN(wsrc != nullptr, EINVAL, nullptr);
+
+        for (p=wsrc; *p; ++p)
+        {
+                if (L'a' <= *p && *p <= L'z')
+                        *p += (wchar_t)(L'A' - L'a');
+        }
+
+        return wsrc;
+    }
+    else
+    {
+        _wcsupr_s_l(wsrc, (size_t)(-1), nullptr);
+        return wsrc;
+    }
+}
+
+/***
+*errno_t _wcsupr_s(string, size_t) - map lower-case characters in a string to upper-case
+*
+*Purpose:
+*       wcsupr converts lower-case characters in a null-terminated wchar_t
+*       string to their upper-case equivalents.  The result may be longer or
+*       shorter than the original string.
+*
+*Entry:
+*       wchar_t *wsrc - wchar_t string to change to upper case
+*       size_t sizeInWords - size of the destination buffer
+*
+*Exit:
+*       the error code
+*
+*Exceptions:
+*       on an error, the original string is unaltered, and errno is set
+*
+*******************************************************************************/
+
+static errno_t __cdecl _wcsupr_s_l_stat (
+        _Inout_updates_z_(sizeInWords)  wchar_t *   const  wsrc,
+                                        size_t      const  sizeInWords,
+                                        _locale_t   const  plocinfo
+        )
+{
+
+    wchar_t *p;             /* traverses string for C locale conversion */
+    int dstsize;            /* size in wide chars of wdst string buffer (include null) */
+
+    /* validation section */
+    _VALIDATE_RETURN_ERRCODE(wsrc != nullptr, EINVAL);
+    size_t const stringlen = wcsnlen(wsrc, sizeInWords);
+    if (stringlen >= sizeInWords)
+    {
+        _RESET_STRING(wsrc, sizeInWords);
+        _RETURN_DEST_NOT_NULL_TERMINATED(wsrc, sizeInWords);
+    }
+    _FILL_STRING(wsrc, sizeInWords, stringlen + 1);
+
+    if ( plocinfo->locinfo->locale_name[LC_CTYPE] == nullptr )
+    {
+        for ( p = wsrc ; *p ; p++ )
+        {
+            if ( (*p >= (wchar_t)L'a') && (*p <= (wchar_t)L'z') )
+                *p = *p - (L'a' - L'A');
+        }
+        return 0;
+    }   /* C locale */
+
+
+    /* Inquire size of wdst string */
+    if ( (dstsize = __acrt_LCMapStringW(
+                    plocinfo->locinfo->locale_name[LC_CTYPE],
+                    LCMAP_UPPERCASE,
+                    wsrc,
+                    -1,
+                    nullptr,
+                    0 )) == 0 )
+    {
+        errno = EILSEQ;
+        return errno;
+    }
+
+    if (sizeInWords < (size_t)dstsize)
+    {
+        _RESET_STRING(wsrc, sizeInWords);
+        _RETURN_BUFFER_TOO_SMALL(wsrc, sizeInWords);
+    }
+
+    /* Allocate space for wdst */
+    __crt_scoped_stack_ptr<wchar_t> const wdst(_malloca_crt_t(wchar_t, dstsize));
+    if (wdst.get() == nullptr)
+    {
+        errno = ENOMEM;
+        return errno;
+    }
+
+    /* Map wrc string to wide-character wdst string in alternate case */
+    if (__acrt_LCMapStringW(
+                plocinfo->locinfo->locale_name[LC_CTYPE],
+                LCMAP_UPPERCASE,
+                wsrc,
+                -1,
+                wdst.get(),
+                dstsize ) != 0)
+    {
+        /* Copy wdst string to user string */
+        return wcscpy_s(wsrc, sizeInWords, wdst.get());
+    }
+    else
+    {
+        return errno = EILSEQ;
+    }
+}
+
+extern "C" errno_t __cdecl _wcsupr_s_l (
+        wchar_t * wsrc,
+        size_t sizeInWords,
+        _locale_t plocinfo
+        )
+{
+    _LocaleUpdate _loc_update(plocinfo);
+
+    return _wcsupr_s_l_stat(wsrc, sizeInWords, _loc_update.GetLocaleT());
+}
+
+
+extern "C" errno_t __cdecl _wcsupr_s (
+        wchar_t * wsrc,
+        size_t sizeInWords
+        )
+{
+    return _wcsupr_s_l(wsrc, sizeInWords, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsxfrm.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsxfrm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d44b6c9daf99f64f008a77ec662f323020f679aa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wcsxfrm.cpp	
@@ -0,0 +1,135 @@
+/***
+*wcsxfrm.c - Transform a wide-character string using locale information
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       Transform a wide-character string using the locale information as set by
+*       LC_COLLATE.
+*
+*******************************************************************************/
+#include <corecrt_internal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+/***
+*size_t wcsxfrm() - Transform a string using locale information
+*
+*Purpose:
+*       Transform the wide string pointed to by _string2 and place the
+*       resulting wide string into the array pointed to by _string1.
+*       No more than _count wide characters are placed into the
+*       resulting string (including the null).
+*
+*       The transformation is such that if wcscmp() is applied to
+*       the two transformed strings, the return value is equal to
+*       the result of wcscoll() applied to the two original strings.
+*       Thus, the conversion must take the locale LC_COLLATE info
+*       into account.
+*
+*       In the C locale, wcsxfrm() simply resolves to wcsncpy()/wcslen().
+*
+*Entry:
+*       wchar_t *_string1       = result string
+*       const wchar_t *_string2 = source string
+*       size_t _count           = max wide chars to move
+*
+*       [If _count is 0, _string1 is permitted to be nullptr.]
+*
+*Exit:
+*       Length of the transformed string (not including the terminating
+*       null).  If the value returned is >= _count, the contents of the
+*       _string1 array are indeterminate.
+*
+*Exceptions:
+*       Non-standard: if OM/API error, return INT_MAX.
+*       Input parameters are validated. Refer to the validation section of the function.
+*
+*******************************************************************************/
+
+extern "C" size_t __cdecl _wcsxfrm_l (
+        wchar_t *_string1,
+        const wchar_t *_string2,
+        size_t _count,
+        _locale_t plocinfo
+        )
+{
+    int size = INT_MAX;
+
+    /* validation section */
+    _VALIDATE_RETURN(_count <= INT_MAX, EINVAL, INT_MAX);
+    _VALIDATE_RETURN(_string1 != nullptr || _count == 0, EINVAL, INT_MAX);
+    _VALIDATE_RETURN(_string2 != nullptr, EINVAL, INT_MAX);
+
+    _LocaleUpdate _loc_update(plocinfo);
+
+    if ( _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE] == nullptr )
+    {
+_BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+        wcsncpy(_string1, _string2, _count);
+_END_SECURE_CRT_DEPRECATION_DISABLE
+        return wcslen(_string2);
+    }
+
+    if ( 0 == (size = __acrt_LCMapStringW(
+                    _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                    LCMAP_SORTKEY,
+                    _string2,
+                    -1,
+                    nullptr,
+                    0 )) )
+    {
+        errno = EILSEQ;
+        size = INT_MAX;
+    } else
+    {
+        if ( size <= (int)_count)
+        {
+            if ( 0 == (size = __acrt_LCMapStringW(
+                            _loc_update.GetLocaleT()->locinfo->locale_name[LC_COLLATE],
+                            LCMAP_SORTKEY,
+                            _string2,
+                            -1,
+                            (wchar_t *)_string1,
+                            (int)_count )) )
+            {
+                errno = EILSEQ;
+                size = INT_MAX; /* default error */
+            } else
+            {
+                // Note that the size that LCMapStringW returns for
+                // LCMAP_SORTKEY is number of bytes needed. That's why it
+                // is safe to convert the buffer to wide char from end.
+                _count = size--;
+                for (;_count-- > 0;)
+                {
+#pragma warning(suppress:__WARNING_DEREF_NULL_PTR __WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 6011 Dereferencing NULL pointer '_string1' 26015 Potential overflow using expression '_string1[_count]'
+                    _string1[_count] = (wchar_t)((unsigned char *)_string1)[_count];
+                }
+            }
+        }
+        else
+        {
+            if (_string1 != nullptr && _count > 0)
+            {
+                *_string1 = '\0';
+                errno = ERANGE;
+            }
+            size--;
+        }
+    }
+
+    return (size_t)size;
+}
+
+extern "C" size_t __cdecl wcsxfrm (
+        wchar_t *_string1,
+        const wchar_t *_string2,
+        size_t _count
+        )
+{
+
+    return _wcsxfrm_l(_string1, _string2, _count, nullptr);
+}
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wmemcpy_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wmemcpy_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0e3fc39bd1f76c4ee1985b9f92d8af28c125fd9e
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wmemcpy_s.cpp	
@@ -0,0 +1,45 @@
+//
+// wmemcpy_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wmemcpy_s(), which copies wide characters from a source buffer to a
+// destination buffer.  Overlapping buffers are not treated specially, so
+// propagation may occur.  If propagation must be avoided, wmemmove_s() must be
+// used.
+//
+// Returns 0 if successful; an error code on failure.
+//
+#include <corecrt_internal.h>
+#include <wchar.h>
+
+
+
+extern "C" errno_t __cdecl wmemcpy_s(
+    wchar_t*       const destination,
+    size_t         const size_in_elements,
+    wchar_t const* const source,
+    size_t         const count
+    )
+{
+    if (count == 0)
+        return 0;
+
+    _VALIDATE_RETURN_ERRCODE(destination != nullptr, EINVAL);
+
+    if (source == nullptr || size_in_elements < count)
+    {
+        // Zero the destination buffer:
+        wmemset(destination, 0, size_in_elements);
+
+        _VALIDATE_RETURN_ERRCODE(source != nullptr, EINVAL);
+        _VALIDATE_RETURN_ERRCODE(size_in_elements >= count, ERANGE);
+        
+        // Useless, but prefast is confused:
+        return EINVAL;
+    }
+
+#pragma warning(suppress:__WARNING_BANNED_API_USAGEL2) /* 28726 */
+    wmemcpy(destination, source, count);
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wmemmove_s.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wmemmove_s.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..972eec18970b7e11ca2fe41ac41b7b021b625d25
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/string/wmemmove_s.cpp	
@@ -0,0 +1,35 @@
+//
+// wmemmove_s.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines wmemmove_s(), which copies wide characters from a source buffer to a
+// destination buffer.  Overlapping buffers are treated specially, to avoid
+// propagation.
+//
+// Returns 0 if successful; an error code on failure.
+//
+#include <corecrt_internal.h>
+#include <wchar.h>
+
+
+
+extern "C" errno_t __cdecl wmemmove_s(
+    wchar_t*       const destination,
+    size_t         const size_in_elements,
+    wchar_t const* const source,
+    size_t         const count
+    )
+{
+    if (count == 0)
+        return 0;
+
+#pragma warning(suppress:__WARNING_HIGH_PRIORITY_OVERFLOW_POSTCONDITION)
+    _VALIDATE_RETURN_ERRCODE(destination != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(source != nullptr, EINVAL);
+    _VALIDATE_RETURN_ERRCODE(size_in_elements >= count, ERANGE);
+
+#pragma warning(suppress:__WARNING_BANNED_API_USAGEL2) /* 28726 */
+    wmemmove(destination, source, count);
+    return 0;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/asctime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/asctime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..642546d3d99f54768bce8f1a9783fec79b2d799d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/asctime.cpp	
@@ -0,0 +1,197 @@
+//
+// asctime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The asctime() family of functions, which convert a tm struct into a string.
+//
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_internal_time.h>
+
+#define _ASCBUFSIZE 26
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// asctime_s and _wasctime_s
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+template <typename Character>
+static Character* __cdecl common_asctime_s_write_value(
+    _Out_writes_(2) Character* p,
+    int                  const value,
+    bool                 const zero_fill
+    ) throw()
+{
+    if (value >= 10 || zero_fill)
+    {
+        *p++ = static_cast<Character>('0' + value / 10);
+    }
+    else
+    {
+        *p++ = ' ';
+    }
+
+    *p++ = static_cast<Character>('0' + value % 10);
+    return p;
+}
+
+
+
+// Converts a time structure (tm) into an ASCII string.  The string is always
+// exactly 26 characters long, in the form Tue May  1 02:34:55 1984\n\0.  The
+// buffer 'size_in_chars' must be at least 26.  The string is generated into the
+// buffer.  On success, zero is returned and the buffer contains the time string;
+// on failure, an error code is returned and the contents of the buffer are
+// indeterminate.
+template <typename Character>
+_Success_(return == 0)
+static errno_t __cdecl common_asctime_s(
+    _Out_writes_z_(size_in_chars) _Post_readable_size_(_ASCBUFSIZE) Character* const buffer,
+    _In_range_(>=, _ASCBUFSIZE)   size_t                                       const size_in_chars,
+    tm const*                                                                  const tm_value
+    ) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(
+        buffer != nullptr && size_in_chars > 0,
+        EINVAL
+    )
+
+    _RESET_STRING(buffer, size_in_chars);
+
+    _VALIDATE_RETURN_ERRCODE(size_in_chars >= _ASCBUFSIZE, EINVAL)
+    _VALIDATE_RETURN_ERRCODE(tm_value != nullptr,          EINVAL)
+    _VALIDATE_RETURN_ERRCODE(tm_value->tm_year >= 0,       EINVAL)
+
+    // Month, hour, minute, and second are zero-based
+    _VALIDATE_RETURN_ERRCODE(tm_value->tm_mon  >= 0 && tm_value->tm_mon  <= 11, EINVAL)
+    _VALIDATE_RETURN_ERRCODE(tm_value->tm_hour >= 0 && tm_value->tm_hour <= 23, EINVAL)
+    _VALIDATE_RETURN_ERRCODE(tm_value->tm_min  >= 0 && tm_value->tm_min  <= 59, EINVAL)
+    _VALIDATE_RETURN_ERRCODE(tm_value->tm_sec  >= 0 && tm_value->tm_sec  <= 60, EINVAL) // including leap second
+    _VALIDATE_RETURN_ERRCODE(tm_value->tm_wday >= 0 && tm_value->tm_wday <=  6, EINVAL)
+
+    _VALIDATE_RETURN_ERRCODE(__crt_time_is_day_valid(tm_value->tm_year, tm_value->tm_mon, tm_value->tm_mday), EINVAL)
+
+    Character* buffer_it = buffer;
+
+    // Copy the day name into the buffer:
+    char const* const day_first = __dnames + tm_value->tm_wday * 3;
+    char const* const day_last  = day_first + 3;
+    for (char const* day_it = day_first; day_it != day_last; ++day_it)
+        *buffer_it++ = static_cast<Character>(*day_it);
+
+    *buffer_it++ = static_cast<Character>(' ');
+
+    // Copy the month name into the buffer:
+    char const* const month_first = __mnames + tm_value->tm_mon * 3;
+    char const* const month_last  = month_first + 3;
+    for (char const* month_it = month_first; month_it != month_last; ++month_it)
+        *buffer_it++ = static_cast<Character>(*month_it);
+
+    *buffer_it++ = static_cast<Character>(' ');
+
+    // Copy the day of the month (1 - 31) into the buffer:
+    buffer_it = common_asctime_s_write_value(buffer_it, tm_value->tm_mday, false);
+    *buffer_it++ = static_cast<Character>(' ');
+
+    // Copy the time into the buffer in HH:MM:SS form:
+    buffer_it = common_asctime_s_write_value(buffer_it, tm_value->tm_hour, true);
+    *buffer_it++ = static_cast<Character>(':');
+    buffer_it = common_asctime_s_write_value(buffer_it, tm_value->tm_min, true);
+    *buffer_it++ = static_cast<Character>(':');
+    buffer_it = common_asctime_s_write_value(buffer_it, tm_value->tm_sec, true);
+    *buffer_it++ = static_cast<Character>(' ');
+
+    // Copy the four-digit year into the buffer:
+    buffer_it = common_asctime_s_write_value(buffer_it, __crt_get_century(tm_value->tm_year), true);
+    buffer_it = common_asctime_s_write_value(buffer_it, __crt_get_2digit_year(tm_value->tm_year), true);
+
+    // And that's it...
+    *buffer_it++ = static_cast<Character>('\n');
+    *buffer_it++ = static_cast<Character>('\0');
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl asctime_s(
+    char*     const buffer,
+    size_t    const size_in_chars,
+    tm const* const tm_value
+    )
+{
+    return common_asctime_s(buffer, size_in_chars, tm_value);
+}
+
+extern "C" errno_t __cdecl _wasctime_s(
+    wchar_t*  const buffer,
+    size_t    const size_in_chars,
+    tm const* const tm_value
+    )
+{
+    return common_asctime_s(buffer, size_in_chars, tm_value);
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// asctime and _wasctime
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Utility functions used by common_asctime to get the per-thread actime buffer.
+static char** common_asctime_get_ptd_buffer(char) throw()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+        return nullptr;
+
+    return &ptd->_asctime_buffer;
+}
+
+static wchar_t** common_asctime_get_ptd_buffer(wchar_t) throw()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+        return nullptr;
+
+    return &ptd->_wasctime_buffer;
+}
+
+// Converts a time structure (tm) into an ASCII string.  The string is always
+// exactly 26 characters long, in the form Tue May  1 02:34:55 1984\n\0.
+// The return value is a pointer to a per-thread buffer containing the
+// generated time string.
+template <typename Character>
+_Success_(return != 0)
+_Ret_writes_z_(26)
+static Character* __cdecl common_asctime(tm const* const tm_value) throw()
+{
+    static Character static_buffer[_ASCBUFSIZE];
+
+    Character** ptd_buffer_address = common_asctime_get_ptd_buffer(Character());
+    if (ptd_buffer_address != nullptr && *ptd_buffer_address == nullptr)
+    {
+        *ptd_buffer_address = _calloc_crt_t(Character, _ASCBUFSIZE).detach();
+    }
+
+    Character* const buffer = ptd_buffer_address != nullptr && *ptd_buffer_address != nullptr
+        ? *ptd_buffer_address
+        : static_buffer;
+
+    errno_t const status = common_asctime_s(buffer, _ASCBUFSIZE, tm_value);
+    if (status != 0)
+        return nullptr;
+
+    return buffer;
+}
+
+extern "C" char* __cdecl asctime(tm const* const tm_value)
+{
+    return common_asctime<char>(tm_value);
+}
+
+extern "C" wchar_t* __cdecl _wasctime(tm const* const tm_value)
+{
+    return common_asctime<wchar_t>(tm_value);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/clock.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/clock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..baff7b87993944dcb486d984847fcef72b9973fa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/clock.cpp	
@@ -0,0 +1,95 @@
+//
+// clock.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The clock() function, which calculates the amount of elapsed time since the
+// process started execution.
+//
+#include <corecrt_internal_time.h>
+#include <sys\timeb.h>
+#include <sys\types.h>
+
+
+
+// The source frequency of the performance counter and the counter value at
+// process startup, in the source frequency.
+static long long source_frequency;
+static long long start_count;
+
+
+
+// Scales a 64-bit counter from the QueryPerformanceCounter frequency to the
+// clock() frequency defined by CLOCKS_PER_SEC.  This is the same algorithm as
+// is used internally by QueryPerformanceCounter to deal with frequency changes.
+static long long scale_count(long long count)
+{
+    // Convert the count to seconds and multiply this by the destination frequency:
+    long long scaled_count = (count / source_frequency) * CLOCKS_PER_SEC;
+
+    // To reduce error introduced by scaling using integer division, separately
+    // handle the remainder from the above division by multiplying the left-over
+    // counter by the destination frequency, then diviting by the input frequency:
+    count %= source_frequency;
+
+    scaled_count += (count * CLOCKS_PER_SEC) / source_frequency;
+
+    return scaled_count;
+}
+
+
+
+// This function initializes the global start_count variable when the CRT is
+// initialized.  This initializer always runs in the CRT DLL; it only runs in
+// the static CRT if this object file is linked into the module, which will only
+// happen if some user code calls clock().
+extern "C" int __cdecl __acrt_initialize_clock()
+{
+    LARGE_INTEGER local_frequency;
+    LARGE_INTEGER local_start_count;
+    if (!QueryPerformanceFrequency(&local_frequency) ||
+        !QueryPerformanceCounter(&local_start_count) ||
+        local_frequency.QuadPart == 0)
+    {
+        source_frequency = -1; 
+        start_count      = -1;
+        return 0;
+    }
+
+    source_frequency = local_frequency.QuadPart;
+    start_count      = local_start_count.QuadPart;
+
+    return 0;
+}
+
+_CRT_LINKER_FORCE_INCLUDE(__acrt_clock_initializer);
+
+// Calculates and returns the amount of elapsed time since the process started
+// execution.  During CRT initialization, the 'start_count' global variable is
+// initialized to the current tick count; subsequent calls to clock() get the
+// new tick count and subtract the 'start_count' from it.
+//
+// The return value is the number of CLK_TCKs that have elapsed (milliseconds).
+// On failure, -1 is returned.
+extern "C" clock_t __cdecl clock()
+{
+    if (start_count == -1)
+        return -1;
+
+    LARGE_INTEGER current_count;
+    if (!QueryPerformanceCounter(&current_count))
+        return -1;
+
+    long long const result = current_count.QuadPart - start_count;
+    if (result < 0)
+        return -1;
+
+    long long const scaled_result = scale_count(result);
+
+    // Per C11 7.27.2.1 ("The clock function")/3, "If the processor time used...
+    // cannot be represented, the function returns the value (clock_t)(-1)."
+    if (scaled_result > LONG_MAX)
+        return -1;
+
+    return static_cast<clock_t>(scaled_result);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/ctime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/ctime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c1326971d5f8513253963cb7d8475c00d856a28d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/ctime.cpp	
@@ -0,0 +1,124 @@
+//
+// ctime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The ctime() family of functions, which convert a time_t into a string.
+//
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_internal_time.h>
+
+
+
+// Converts a time stored as a time_t into a string of the form:
+//
+//     Tue May  1 14:25:03 1984
+//
+// Returns zero on success; returns an error code and sets errno on failure.  The
+// buffer is always null terminated as long as it is at least one character in
+// length.
+template <typename TimeType, typename Character>
+static errno_t __cdecl common_ctime_s(
+    _Out_writes_z_(size_in_chars) _Post_readable_size_(26)  Character*      const   buffer,
+    _In_range_(>=,26)                                       size_t          const   size_in_chars,
+                                                            TimeType const* const   time_t_value
+    ) throw()
+{
+    typedef __crt_time_traits<TimeType, Character> time_traits;
+
+    _VALIDATE_RETURN_ERRCODE(buffer != nullptr && size_in_chars > 0, EINVAL)
+
+    _RESET_STRING(buffer, size_in_chars);
+
+    _VALIDATE_RETURN_ERRCODE      (size_in_chars >= 26,     EINVAL)
+    _VALIDATE_RETURN_ERRCODE      (time_t_value != nullptr, EINVAL)
+    _VALIDATE_RETURN_ERRCODE_NOEXC(*time_t_value >= 0,      EINVAL)
+
+    tm tm_value;
+    errno_t const status = time_traits::localtime_s(&tm_value, time_t_value);
+    if (status != 0)
+        return status;
+
+    return time_traits::tasctime_s(buffer, size_in_chars, &tm_value);
+}
+
+extern "C" errno_t __cdecl _ctime32_s(
+    char*             const buffer,
+    size_t            const size_in_chars,
+    __time32_t const* const time_t_value
+    )
+{
+    return common_ctime_s(buffer, size_in_chars, time_t_value);
+}
+
+extern "C" errno_t __cdecl _wctime32_s(
+    wchar_t*          const buffer,
+    size_t            const size_in_chars,
+    __time32_t const* const time_t_value
+    )
+{
+    return common_ctime_s(buffer, size_in_chars, time_t_value);
+}
+
+extern "C" errno_t __cdecl _ctime64_s(
+    char*             const buffer,
+    size_t            const size_in_chars,
+    __time64_t const* const time_t_value
+    )
+{
+    return common_ctime_s(buffer, size_in_chars, time_t_value);
+}
+
+extern "C" errno_t __cdecl _wctime64_s(
+    wchar_t*          const buffer,
+    size_t            const size_in_chars,
+    __time64_t const* const time_t_value
+    )
+{
+    return common_ctime_s(buffer, size_in_chars, time_t_value);
+}
+
+
+
+// Converts a time stored as a time_t into a string of the form, just as the
+// secure _s version (defined above) does.  Returns a pointer to a thread-local
+// buffer containing the resulting time string.
+template <typename TimeType, typename Character>
+_Ret_writes_z_(26)
+_Success_(return != 0)
+static Character* __cdecl common_ctime(
+    TimeType const* const time_t_value
+    ) throw()
+{
+    typedef __crt_time_traits<TimeType, Character> time_traits;
+
+    _VALIDATE_RETURN      (time_t_value != nullptr, EINVAL, nullptr)
+    _VALIDATE_RETURN_NOEXC(*time_t_value >= 0,      EINVAL, nullptr)
+
+    tm tm_value;
+    errno_t const status = time_traits::localtime_s(&tm_value, time_t_value);
+    if (status != 0)
+        return nullptr;
+
+    return time_traits::tasctime(&tm_value);
+}
+
+extern "C" char* __cdecl _ctime32(__time32_t const* const time_t_value)
+{
+    return common_ctime<__time32_t, char>(time_t_value);
+}
+
+extern "C" wchar_t* __cdecl _wctime32(__time32_t const* const time_t_value)
+{
+    return common_ctime<__time32_t, wchar_t>(time_t_value);
+}
+
+extern "C" char* __cdecl _ctime64(__time64_t const* const time_t_value)
+{
+    return common_ctime<__time64_t, char>(time_t_value);
+}
+
+extern "C" wchar_t* __cdecl _wctime64(__time64_t const* const time_t_value)
+{
+    return common_ctime<__time64_t, wchar_t>(time_t_value);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/days.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/days.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49ad0a0219987895a059eefaaa93130f6cbb9b8b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/days.cpp	
@@ -0,0 +1,26 @@
+//
+// days.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The global _days and _lpdays arrays, which define the number of days that
+// contain the number of days from the beginning of the year to the beginning
+// of each month.
+//
+#include <corecrt_internal_time.h>
+
+
+
+extern "C" int const _days[] =
+{
+    -1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333, 364
+};
+
+
+
+extern "C" int const _lpdays[] =
+{
+    -1, 30, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
+};
+
+
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/difftime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/difftime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..157e72ba19f54ac06081a0e10cbc17669a65e9f3
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/difftime.cpp	
@@ -0,0 +1,32 @@
+//
+// difftime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The difftime() family of functions, which compute the difference between time
+// values.
+//
+#include <corecrt_internal_time.h>
+
+
+
+// Computes the difference between two times (b - a).  Returns a double with the
+// difference in seconds between the two times.  Returns zero if the input is
+// invalid.
+template <typename TimeType>
+static double __cdecl common_difftime(TimeType const b, TimeType const a) throw()
+{
+    _VALIDATE_RETURN_NOEXC(a >= 0 && b >= 0, EINVAL, 0);
+
+    return static_cast<double>(b - a);
+}
+
+extern "C" double __cdecl _difftime32(__time32_t const b, __time32_t const a)
+{
+    return common_difftime(b, a);
+}
+
+extern "C" double __cdecl _difftime64(__time64_t const b, __time64_t const a)
+{
+    return common_difftime(b, a);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/ftime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/ftime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e39c0fb913a90f07fe55bdb7eb6c98e8f626888b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/ftime.cpp	
@@ -0,0 +1,105 @@
+//
+// ftime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The ftime() family of functions, which return the system date and time in a
+// time structure.
+//
+#include <corecrt_internal_time.h>
+#include <sys/timeb.h>
+#include <sys/types.h>
+
+
+
+// Cache for the minutes count for with DST status was last assessed
+// CRT_REFACTOR TODO Check synchronization of access to this global variable.
+static __time64_t elapsed_minutes_cache = 0;
+
+
+
+// Three values of dstflag_cache
+#define DAYLIGHT_TIME   1
+#define STANDARD_TIME   0
+#define UNKNOWN_TIME   -1
+
+
+
+// Cache for the last determined DST status:
+static int dstflag_cache = UNKNOWN_TIME;
+
+
+
+// Returns the system time in a structure; returns zero on success; returns an
+// error code on failure.
+template <typename TimeType, typename TimeBType>
+static errno_t __cdecl common_ftime_s(TimeBType* const tp) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(tp != nullptr, EINVAL)
+
+    __tzset();
+
+    long timezone = 0;
+    _ERRCHECK(_get_timezone(&timezone));
+    tp->timezone = static_cast<short>(timezone / 60);
+
+    __crt_filetime_union system_time;
+    __acrt_GetSystemTimePreciseAsFileTime(&system_time._filetime);
+
+    // Obtain the current Daylight Savings Time status.  Note that the status is
+    // cached and only updated once per minute, if necessary.
+    TimeType const current_minutes_value = static_cast<TimeType>(system_time._scalar / 600000000i64);
+    if (static_cast<__time64_t>(current_minutes_value) != elapsed_minutes_cache)
+    {
+        TIME_ZONE_INFORMATION tz_info;
+        DWORD const tz_state = GetTimeZoneInformation(&tz_info);
+        if (tz_state == 0xFFFFFFFF)
+        {
+            dstflag_cache = UNKNOWN_TIME;
+        }
+        else
+        {
+            // Must be very careful when determining whether or not Daylight
+            // Savings Time is in effect:
+            if (tz_state == TIME_ZONE_ID_DAYLIGHT &&
+                tz_info.DaylightDate.wMonth != 0 &&
+                tz_info.DaylightBias != 0)
+            {
+                dstflag_cache = DAYLIGHT_TIME;
+            }
+            else
+            {
+                // Assume Standard Time:
+                dstflag_cache = STANDARD_TIME;
+            }
+        }
+
+        elapsed_minutes_cache = current_minutes_value;
+    }
+
+    tp->dstflag = static_cast<short>(dstflag_cache);
+    tp->millitm = static_cast<unsigned short>((system_time._scalar / 10000i64) % 1000i64);
+    tp->time    = static_cast<TimeType>((system_time._scalar - _EPOCH_BIAS) / 10000000i64);
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _ftime32_s(__timeb32* const tp)
+{
+    return common_ftime_s<__time32_t>(tp);
+}
+
+extern "C" void __cdecl _ftime32(__timeb32* const tp)
+{
+    _ftime32_s(tp);
+}
+
+extern "C" errno_t __cdecl _ftime64_s(__timeb64* const tp)
+{
+    return common_ftime_s<__time64_t>(tp);
+}
+
+extern "C" void __cdecl _ftime64(__timeb64* const tp)
+{
+    _ftime64_s(tp);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/gmtime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/gmtime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3455d629ca2e77d8cf893ff9f285481dd95ee7fc
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/gmtime.cpp	
@@ -0,0 +1,204 @@
+//
+// gmtime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The gmtime() family of functions, which converts a time_t value into a tm
+// structure in UTC.
+//
+#include <corecrt_internal_time.h>
+
+
+
+// This is a utility that allows us to compute the year value differently for
+// 32-bit and 64-bit time_t objects.
+static int __cdecl compute_year(__time32_t& caltim, bool& is_leap_year) throw()
+{
+    // Determine years since 1970. First, identify the four-year interval
+    // since this makes handling leap-years easy (note that 2000 IS a
+    // leap year and 2100 is out-of-range).
+    int tmptim = static_cast<int>(caltim / _FOUR_YEAR_SEC);
+    caltim -= static_cast<__time32_t>(tmptim) * _FOUR_YEAR_SEC;
+
+    // Determine which year of the interval
+    tmptim = (tmptim * 4) + 70;         // 1970, 1974, 1978,...,etc.
+
+    if (caltim >= _YEAR_SEC)
+    {
+        tmptim++;                       // 1971, 1975, 1979,...,etc.
+        caltim -= _YEAR_SEC;
+
+        if (caltim >= _YEAR_SEC)
+        {
+            tmptim++;                   // 1972, 1976, 1980,...,etc.
+            caltim -= _YEAR_SEC;
+
+            // Note, it takes 366 days-worth of seconds to get past a leap
+            // year.
+            if (caltim >= (_YEAR_SEC + _DAY_SEC))
+            {
+                tmptim++;               // 1973, 1977, 1981,...,etc.
+                caltim -= (_YEAR_SEC + _DAY_SEC);
+            }
+            else
+            {
+                // In a leap year after all, set the flag.
+                is_leap_year = true;
+            }
+        }
+    }
+
+    return tmptim;
+}
+
+static int __cdecl compute_year(__time64_t& caltim, bool& is_leap_year) throw()
+{
+    // Determine the years since 1900. Start by ignoring leap years:
+    int tmptim = static_cast<int>(caltim / _YEAR_SEC) + 70;
+    caltim -= static_cast<__time64_t>(tmptim - 70) * _YEAR_SEC;
+
+    // Correct for elapsed leap years:
+    caltim -= static_cast<__time64_t>(__crt_time_elapsed_leap_years(tmptim)) * _DAY_SEC;
+
+    // If we have underflowed the __time64_t range (i.e., if caltim < 0),
+    // back up one year, adjusting the correction if necessary.
+    if (caltim < 0)
+    {
+        caltim += static_cast<__time64_t>(_YEAR_SEC);
+        tmptim--;
+        if (__crt_time_is_leap_year(tmptim))
+        {
+            caltim += _DAY_SEC;
+            is_leap_year = true;
+        }
+    }
+    else if (__crt_time_is_leap_year(tmptim))
+    {
+        is_leap_year = true;
+    }
+
+    return tmptim;
+}
+
+// Converts a time_t value into a tm structure in UTC.  Stores the tm structure
+// into the '*ptm' buffer. Returns zero on success; returns an error code on
+// failure
+template <typename TimeType>
+static errno_t __cdecl common_gmtime_s(tm* const ptm, TimeType const* const timp) throw()
+{
+    typedef __crt_time_time_t_traits<__time64_t> time_traits;
+
+    _VALIDATE_RETURN_ERRCODE(ptm != nullptr, EINVAL)
+    memset(ptm, 0xff, sizeof(tm));
+
+    _VALIDATE_RETURN_ERRCODE(timp != nullptr, EINVAL);
+    TimeType caltim = *timp;
+
+    _VALIDATE_RETURN_ERRCODE_NOEXC(caltim >= _MIN_LOCAL_TIME, EINVAL)
+
+    // Upper bound check only necessary for _gmtime64_s (it's > LONG_MAX).
+    // For _gmtime32_s, any positive number is within range (<= LONG_MAX).
+    _VALIDATE_RETURN_ERRCODE_NOEXC(caltim <= time_traits::max_time_t + _MAX_LOCAL_TIME, EINVAL)
+
+    // tmptim now holds the value for tm_year. caltim now holds the
+    // number of elapsed seconds since the beginning of that year.
+    bool is_leap_year = false;
+    ptm->tm_year = compute_year(caltim, is_leap_year);
+
+    // Determine days since January 1 (0 - 365). This is the tm_yday value.
+    // Leave caltim with number of elapsed seconds in that day.
+    ptm->tm_yday = static_cast<int>(caltim / _DAY_SEC);
+    caltim -= static_cast<TimeType>(ptm->tm_yday) * _DAY_SEC;
+
+    // Determine months since January (0 - 11) and day of month (1 - 31):
+    int const* const mdays = is_leap_year ? _lpdays : _days;
+
+    int tmptim = 0;
+    for (tmptim = 1 ; mdays[tmptim] < ptm->tm_yday ; tmptim++)
+    {
+    }
+
+    ptm->tm_mon = --tmptim;
+
+    ptm->tm_mday = ptm->tm_yday - mdays[tmptim];
+
+    // Determine days since Sunday (0 - 6)
+    ptm->tm_wday = (static_cast<int>(*timp / _DAY_SEC) + _BASE_DOW) % 7;
+
+    // Determine hours since midnight (0 - 23), minutes after the hour
+    // (0 - 59), and seconds after the minute (0 - 59).
+    ptm->tm_hour = static_cast<int>(caltim / 3600);
+    caltim -= static_cast<TimeType>(ptm->tm_hour) * 3600L;
+
+    ptm->tm_min = static_cast<int>(caltim / 60);
+    ptm->tm_sec = static_cast<int>(caltim - (ptm->tm_min) * 60);
+
+    ptm->tm_isdst = 0;
+    return 0;
+}
+
+extern "C" errno_t __cdecl _gmtime32_s(tm* const result, __time32_t const* const time_value)
+{
+    return common_gmtime_s(result, time_value);
+}
+
+extern "C" errno_t __cdecl _gmtime64_s(tm* const result, __time64_t const* const time_value)
+{
+    return common_gmtime_s(result, time_value);
+}
+
+
+
+// Gets the thread-local buffer to be used by gmtime.  Returns a pointer to the
+// buffer on success; returns null and sets errno on failure.
+extern "C" tm* __cdecl __getgmtimebuf()
+{
+    __acrt_ptd* const ptd = __acrt_getptd_noexit();
+    if (ptd == nullptr)
+    {
+        errno = ENOMEM;
+        return nullptr;
+    }
+
+    if (ptd->_gmtime_buffer != nullptr)
+    {
+        return ptd->_gmtime_buffer;
+    }
+
+    ptd->_gmtime_buffer = _malloc_crt_t(tm, 1).detach();
+    if (ptd->_gmtime_buffer == nullptr)
+    {
+        errno = ENOMEM;
+        return nullptr;
+    }
+
+    return ptd->_gmtime_buffer;
+}
+
+
+// Converts a time_t value into a tm structure in UTC.  Returns a pointer to a
+// thread-local buffer containing the tm structure on success; returns null on
+// failure.
+template <typename TimeType>
+_Success_(return != 0)
+static tm* __cdecl common_gmtime(TimeType const* const time_value) throw()
+{
+    tm* const ptm = __getgmtimebuf();
+    if (ptm == nullptr)
+        return nullptr;
+
+    if (common_gmtime_s(ptm, time_value) != 0)
+        return nullptr;
+
+    return ptm;
+}
+
+extern "C" tm* __cdecl _gmtime32(__time32_t const* const time_value)
+{
+    return common_gmtime(time_value);
+}
+
+extern "C" tm* __cdecl _gmtime64(__time64_t const* const time_value)
+{
+    return common_gmtime(time_value);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/localtime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/localtime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4c170370787ae0a2f322a33c3044ff0ae2643e2
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/localtime.cpp	
@@ -0,0 +1,211 @@
+//
+// localtime.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the localtime family of functions, which convert a time_t to a tm
+// structure containing the local time.
+//
+#include <corecrt_internal_time.h>
+
+
+
+// Converts a time_t value to a tm value containing the corresponding local time.
+// Returns zero and updates the tm structure on success; returns nonzero and
+// leaves the tm structure in an indeterminate state on failure.
+//
+// Assumptions:
+//      (1) gmtime must be called before _isindst to ensure that the tb time
+//          structure is initialized.
+//      (2) gmtime, _gtime64, localtime and _localtime64() all use a single
+//          statically allocated buffer. Each call to one of these routines
+//          destroys the contents of the previous call.
+//      (3) It is assumed that __time64_t is a 64-bit integer representing
+//          the number of seconds since 00:00:00, 01-01-70 (UTC) (i.e., the
+//          Posix/Unix Epoch. Only non-negative values are supported.
+//      (4) It is assumed that the maximum adjustment for local time is
+//          less than three days (include Daylight Savings Time adjustment).
+//          This only a concern in Posix where the specification of the TZ
+//          environment restricts the combined offset for time zone and
+//          Daylight Savings Time to 2 * (24:59:59), just under 50 hours.
+// If any of these assumptions are violated, the behavior is undefined.
+template <typename TimeType>
+static errno_t __cdecl common_localtime_s(
+    tm*             const ptm,
+    TimeType const* const ptime
+    ) throw()
+{
+    typedef __crt_time_time_t_traits<TimeType> time_traits;
+
+    _VALIDATE_RETURN_ERRCODE(ptm != nullptr, EINVAL);
+    memset(ptm, 0xff, sizeof(tm));
+
+    _VALIDATE_RETURN_ERRCODE(ptime != nullptr, EINVAL);
+
+    // Check for illegal time_t value:
+    _VALIDATE_RETURN_ERRCODE_NOEXC(*ptime >= 0,                       EINVAL);
+    _VALIDATE_RETURN_ERRCODE_NOEXC(*ptime <= time_traits::max_time_t, EINVAL);
+
+    __tzset();
+
+    int  daylight = 0;
+    long dstbias  = 0;
+    long timezone = 0;
+    _ERRCHECK(_get_daylight(&daylight));
+    _ERRCHECK(_get_dstbias (&dstbias ));
+    _ERRCHECK(_get_timezone(&timezone));
+
+    if (*ptime > 3 * _DAY_SEC && *ptime < time_traits::max_time_t - 3 * _DAY_SEC)
+    {
+        // The date does not fall within the first three or last three representable
+        // days; therefore, there is no possibility of overflowing or underflowing
+        // the time_t representation as we compensate for time zone and daylight
+        // savings time.
+        TimeType ltime = *ptime - timezone;
+
+        errno_t status0 = time_traits::gmtime_s(ptm, &ltime);
+        if (status0 != 0)
+            return status0;
+
+        // Check and adjust for daylight savings time:
+        if (daylight && _isindst(ptm))
+        {
+            ltime -= dstbias;
+            
+            errno_t const status1 = time_traits::gmtime_s(ptm, &ltime);
+            if (status1 != 0)
+                return status1;
+
+            ptm->tm_isdst = 1;
+        }
+    }
+    else
+    {
+        // The date falls within the first three or last three representable days;
+        // therefore, it is possible that the time_t representation would overflow
+        // or underflow while compensating for time zone and daylight savings time.
+        // Therefore, we make the time zone and daylight savings time adjustments
+        // directly in the tm structure.
+        errno_t const status0 = time_traits::gmtime_s(ptm, ptime);
+        if (status0 != 0)
+            return status0;
+
+        TimeType ltime = static_cast<TimeType>(ptm->tm_sec);
+
+        // First, adjust for the time zone:
+        if (daylight && _isindst(ptm))
+        {
+            ltime -= (timezone + dstbias);
+            ptm->tm_isdst = 1;
+        }
+        else
+        {
+            ltime -= timezone;
+        }
+
+        ptm->tm_sec = static_cast<int>(ltime % 60);
+        if (ptm->tm_sec < 0)
+        {
+            ptm->tm_sec += 60;
+            ltime -= 60;
+        }
+
+        ltime = static_cast<TimeType>(ptm->tm_min) + ltime / 60;
+        ptm->tm_min = static_cast<int>(ltime % 60);
+        if (ptm->tm_min < 0)
+        {
+            ptm->tm_min += 60;
+            ltime -= 60;
+        }
+
+        ltime = static_cast<TimeType>(ptm->tm_hour) + ltime / 60;
+        ptm->tm_hour = static_cast<int>(ltime % 24);
+        if (ptm->tm_hour < 0)
+        {
+            ptm->tm_hour += 24;
+            ltime -=24;
+        }
+
+        ltime /= 24;
+
+        if (ltime > 0)
+        {
+            // There is no possibility of overflowing the tm_day and tm_yday
+            // members because the date can be no later than January 19.
+            ptm->tm_wday = (ptm->tm_wday + static_cast<int>(ltime)) % 7;
+            ptm->tm_mday += static_cast<int>(ltime);
+            ptm->tm_yday += static_cast<int>(ltime);
+        }
+        else if (ltime < 0)
+        {
+            // It is possible to underflow the tm_mday and tm_yday fields.  If
+            // this happens, then the adjusted date must lie in December 1969:
+            ptm->tm_wday = (ptm->tm_wday + 7 + static_cast<int>(ltime)) % 7;
+            ptm->tm_mday += static_cast<int>(ltime);
+            if (ptm->tm_mday <= 0)
+            {
+                ptm->tm_mday += 31;
+
+                // Per assumption #4 above, the time zone can cause the date to
+                // underflow the epoch by more than a day.
+                ptm->tm_yday = ptm->tm_yday + static_cast<int>(ltime) + 365;
+                ptm->tm_mon = 11;
+                ptm->tm_year--;
+            }
+            else
+            {
+                ptm->tm_yday += static_cast<int>(ltime);
+            }
+        }
+    }
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _localtime32_s(
+    tm*               const ptm,
+    __time32_t const* const ptime
+    )
+{
+    return common_localtime_s(ptm, ptime);
+}
+
+extern "C" errno_t __cdecl _localtime64_s(
+    tm*               const ptm,
+    __time64_t const* const ptime
+    )
+{
+    return common_localtime_s(ptm, ptime);
+}
+
+
+
+// Converts a time_t value to a tm value containing the corresponding local time.
+// Returns a pointer to the thread-local tm buffer containing the result on
+// success; returns nullptr on failure.
+template <typename TimeType>
+_Success_(return != 0)
+static tm* __cdecl common_localtime(TimeType const* const ptime) throw()
+{
+    typedef __crt_time_time_t_traits<TimeType> time_traits;
+
+    tm* const ptm = __getgmtimebuf();
+    if (ptm == nullptr)
+        return nullptr;
+
+    errno_t const status = time_traits::localtime_s(ptm, ptime);
+    if (status != 0)
+        return nullptr;
+
+    return ptm;
+}
+
+extern "C" tm* __cdecl _localtime32(__time32_t const* const ptime)
+{
+    return common_localtime(ptime);
+}
+
+extern "C" tm* __cdecl _localtime64(__time64_t const* const ptime)
+{
+    return common_localtime(ptime);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/loctotime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/loctotime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fafe18cf06bb219b699e258d90e6c6b066fd1a6f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/loctotime.cpp	
@@ -0,0 +1,117 @@
+//
+// loctotime.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the loctotime_t() family of functions, which convert a local time to
+// the internal time format (one of the time_t types).
+//
+#include <corecrt_internal_time.h>
+
+
+
+// Converts a local time to a time_t value.  Returns the time_t value on success;
+// returns a time_t with the value -1 and sets errno on failure.  The 'dstflag'
+// is 1 for Daylight Time, 0 for Standard Time, and -1 if not specified.
+template <typename TimeType>
+static TimeType __cdecl common_loctotime_t(
+    int       yr, // Zero-based
+    int const mo, // One-based
+    int const dy, // One-based
+    int const hr,
+    int const mn,
+    int const sc,
+    int const dstflag
+    ) throw()
+{
+    typedef __crt_time_time_t_traits<TimeType> time_traits;
+
+    static TimeType const invalid_time = static_cast<TimeType>(-1);
+
+    // Adjust the absolute year to be an offset from the year 1900:
+    yr -= 1900;
+
+    _VALIDATE_RETURN_NOEXC(yr >= _BASE_YEAR && yr <= time_traits::max_year, EINVAL, invalid_time)
+    _VALIDATE_RETURN_NOEXC(mo >= 1 && mo <= 12,                             EINVAL, invalid_time)
+    _VALIDATE_RETURN_NOEXC(__crt_time_is_day_valid(yr, mo - 1, dy),         EINVAL, invalid_time)
+    _VALIDATE_RETURN_NOEXC(hr >= 0 && hr <= 23,                             EINVAL, invalid_time)
+    _VALIDATE_RETURN_NOEXC(mn >= 0 && mn <= 59,                             EINVAL, invalid_time)
+    _VALIDATE_RETURN_NOEXC(sc >= 0 && sc <= 59,                             EINVAL, invalid_time)
+
+    // Compute the number of elapsed days in the current year:
+    int elapsed_days_this_year = dy + _days[mo - 1];
+    if (__crt_time_is_leap_year(yr) && mo > 2)
+        ++elapsed_days_this_year;
+
+    TimeType const elapsed_years = static_cast<TimeType>(yr) - _BASE_YEAR;
+    TimeType const elapsed_leap_years = static_cast<TimeType>(__crt_time_elapsed_leap_years(yr));
+
+    // The number of elapsed days is the number of days in each completed year
+    // since the epoch, plus one day per leap year, plus the number of days
+    // elapsed so far this year:
+    TimeType const elapsed_days = 
+        elapsed_years * 365 +
+        elapsed_leap_years +
+        elapsed_days_this_year;
+
+    TimeType const elapsed_hours   = elapsed_days    * 24 + hr;
+    TimeType const elapsed_minutes = elapsed_hours   * 60 + mn;
+    TimeType const elapsed_seconds = elapsed_minutes * 60 + sc;
+
+    // Account for the time zone:
+    __tzset();
+
+    int  daylight = 0;
+    long dstbias  = 0;
+    long timezone = 0;
+    _ERRCHECK(_get_daylight(&daylight));
+    _ERRCHECK(_get_dstbias (&dstbias ));
+    _ERRCHECK(_get_timezone(&timezone));
+
+    TimeType const timezone_adjusted_seconds = elapsed_seconds + timezone;
+
+    // Determine whether we are in Daylight Savings Time and adjust:
+    TimeType const dst_adjusted_seconds = timezone_adjusted_seconds + dstbias;
+
+    if (dstflag == 1)
+        return dst_adjusted_seconds;
+
+    tm tm_value;
+    tm_value.tm_yday = elapsed_days_this_year;
+    tm_value.tm_year = yr;
+    tm_value.tm_mon  = mo - 1;
+    tm_value.tm_hour = hr;
+    tm_value.tm_min  = mn;
+    tm_value.tm_sec  = sc;
+    if (dstflag == -1 && daylight != 0 && _isindst(&tm_value))
+        return dst_adjusted_seconds;
+
+    // Otherwise, we are not in Daylight Savings Time:
+    return timezone_adjusted_seconds;
+}
+
+extern "C" __time32_t __cdecl __loctotime32_t(
+    int const yr,
+    int const mo,
+    int const dy,
+    int const hr,
+    int const mn,
+    int const sc,
+    int const dstflag
+    )
+{
+    return common_loctotime_t<__time32_t>(yr, mo, dy, hr, mn, sc, dstflag);
+}
+
+extern "C" __time64_t __cdecl __loctotime64_t(
+    int const yr,
+    int const mo,
+    int const dy,
+    int const hr,
+    int const mn,
+    int const sc,
+    int const dstflag
+    )
+{
+    return common_loctotime_t<__time64_t>(yr, mo, dy, hr, mn, sc, dstflag);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/mktime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/mktime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..380908bc832ff725dcb51988c138ac16dca2518d
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/mktime.cpp	
@@ -0,0 +1,201 @@
+//
+// mktime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The mktime and mkgmtime families of functions, which convert a time value in
+// a (possibly incomplete) tm structure into a time_t value, then update all of
+// the tm structure fields with the "normalized" values.
+//
+#include <corecrt_internal_time.h>
+
+
+// ChkAdd evaluates to TRUE if dest = src1 + src2 has overflowed
+#define ChkAdd(dest, src1, src2)  \
+    (((src1 >= 0L) && (src2 >= 0L) && (dest <  0L)) || \
+     ((src1 <  0L) && (src2 <  0L) && (dest >= 0L)))
+
+// ChkMul evaluates to TRUE if dest = src1 * src2 has overflowed
+#define ChkMul(dest, src1, src2) ( src1 ? (dest / src1 != src2) : 0 )
+
+
+
+// The implementation of the _mktime and _mkgmtime functions.  If 'use_local_time'
+// is true, the time is assumed to be in local time; otherwise, the time is
+// assumed to be in UTC.
+template <typename TimeType>
+static TimeType __cdecl common_mktime(
+    tm*  const tb,
+    bool const use_local_time
+    ) throw()
+{
+    typedef __crt_time_time_t_traits<TimeType> time_traits;
+
+    TimeType const invalid_time = static_cast<TimeType>(-1);
+
+    _VALIDATE_RETURN(tb != nullptr, EINVAL, invalid_time)
+
+    TimeType tmptm1, tmptm2, tmptm3;
+
+    // First, make sure tm_year is reasonably close to being in range.
+    if ((tmptm1 = tb->tm_year) < _BASE_YEAR - 1 || tmptm1 > time_traits::max_year + 1)
+        return (errno = EINVAL), invalid_time;
+
+    // Adjust month value so it is in the range 0 - 11.  This is because
+    // we don't know how many days are in months 12, 13, 14, etc.
+    if (tb->tm_mon < 0 || tb->tm_mon > 11)
+    {
+        // No danger of overflow because the range check above.
+        tmptm1 += (tb->tm_mon / 12);
+
+        if ((tb->tm_mon %= 12) < 0)
+        {
+            tb->tm_mon += 12;
+            --tmptm1;
+        }
+
+        // Make sure year count is still in range.
+        if (tmptm1 < _BASE_YEAR - 1 || tmptm1 > time_traits::max_year + 1)
+            return (errno = EINVAL), invalid_time;
+    }
+
+    // HERE: tmptm1 holds number of elapsed years
+
+    // Calculate days elapsed minus one, in the given year, to the given
+    // month. Check for leap year and adjust if necessary.
+    tmptm2 = _days[tb->tm_mon];
+    if (__crt_time_is_leap_year(tmptm1) && tb->tm_mon > 1)
+        ++tmptm2;
+
+    // Calculate elapsed days since base date (midnight, 1/1/70, UTC)
+    //
+    // 365 days for each elapsed year since 1970, plus one more day for
+    // each elapsed leap year. no danger of overflow because of the range
+    // check (above) on tmptm1.
+    tmptm3 = (tmptm1 - _BASE_YEAR) * 365 + __crt_time_elapsed_leap_years(tmptm1);
+
+    // Elapsed days to current month (still no possible overflow)
+    tmptm3 += tmptm2;
+
+    // Elapsed days to current date. overflow is now possible.
+    tmptm1 = tmptm3 + (tmptm2 = static_cast<TimeType>(tb->tm_mday));
+    _VALIDATE_RETURN_NOEXC(!ChkAdd(tmptm1, tmptm3, tmptm2), EINVAL, invalid_time)
+
+    // HERE: tmptm1 holds number of elapsed days
+
+    // Calculate elapsed hours since base date
+    tmptm2 = tmptm1 * 24;
+    _VALIDATE_RETURN_NOEXC(!ChkMul(tmptm2, tmptm1, 24), EINVAL, invalid_time)
+
+
+    tmptm1 = tmptm2 + (tmptm3 = static_cast<TimeType>(tb->tm_hour));
+    _VALIDATE_RETURN_NOEXC(!ChkAdd(tmptm1, tmptm2, tmptm3), EINVAL, invalid_time)
+
+
+    // HERE: tmptm1 holds number of elapsed hours
+
+    // Calculate elapsed minutes since base date
+    tmptm2 = tmptm1 * 60;
+    _VALIDATE_RETURN_NOEXC(!ChkMul(tmptm2, tmptm1, 60), EINVAL, invalid_time)
+
+
+    tmptm1 = tmptm2 + (tmptm3 = static_cast<TimeType>(tb->tm_min));
+    _VALIDATE_RETURN_NOEXC(!ChkAdd(tmptm1, tmptm2, tmptm3), EINVAL, invalid_time)
+
+
+    // HERE: tmptm1 holds number of elapsed minutes
+
+    // Calculate elapsed seconds since base date
+    tmptm2 = tmptm1 * 60L;
+    _VALIDATE_RETURN_NOEXC(!ChkMul(tmptm2, tmptm1, 60L), EINVAL, invalid_time)
+
+
+    tmptm1 = tmptm2 + (tmptm3 = static_cast<TimeType>(tb->tm_sec));
+    _VALIDATE_RETURN_NOEXC(!ChkAdd(tmptm1, tmptm2, tmptm3), EINVAL, invalid_time)
+
+
+    // HERE: tmptm1 holds number of elapsed seconds
+
+    tm tbtemp;
+    if (use_local_time)
+    {
+        // Adjust for timezone. No need to check for overflow since
+        // localtime() will check its arg value
+        __tzset();
+
+        long dstbias = 0;
+        long timezone = 0;
+        _ERRCHECK(_get_dstbias(&dstbias));
+        _ERRCHECK(_get_timezone(&timezone));
+
+        tmptm1 += timezone;
+
+        // Convert this second count back into a time block structure.
+        // If localtime returns nullptr, return an error.
+        if (time_traits::localtime_s(&tbtemp, &tmptm1) != 0)
+            return (errno = EINVAL), invalid_time;
+
+        // Now must compensate for DST. The ANSI rules are to use the passed-in
+        // tm_isdst flag if it is non-negative. Otherwise, compute if DST
+        // applies. Recall that tbtemp has the time without DST compensation,
+        // but has set tm_isdst correctly.
+        if (tb->tm_isdst > 0 || (tb->tm_isdst < 0 && tbtemp.tm_isdst > 0))
+        {
+            tmptm1 += dstbias;
+            if (time_traits::localtime_s(&tbtemp, &tmptm1) != 0)
+                return (errno = EINVAL), invalid_time;
+        }
+
+    }
+    else
+    {
+        if (time_traits::gmtime_s(&tbtemp, &tmptm1) != 0)
+            return (errno = EINVAL), invalid_time;
+    }
+
+    // HERE: tmptm1 holds number of elapsed seconds, adjusted for local time if
+    // requested
+
+    *tb = tbtemp;
+    return tmptm1;
+}
+
+
+
+// Converts a tm structure value into a time_t value.  These functions also
+// update the tm structure to normalize it and populate any missing fields.
+// There are three practical uses for these functions:
+//
+// (1) To convert a broken-down time to the internal time format (time_t)
+// (2) To complete the tm value with the correct tm_wday, tm_yday, or tm_isdst
+//     values given the rest of the contents of the tm.
+// (3) To pass in a time structure with "out of range" values for some fields
+//     and get back a "normalized" tm structure (e.g., to pass in 1/35/1987
+//     and get back 2/4/1987).
+//
+// Returns the resulting time_t value on success; returns -1 on failure.
+extern "C" __time32_t __cdecl _mktime32(tm* const tb)
+{
+    return common_mktime<__time32_t>(tb, true);
+}
+
+extern "C" __time64_t __cdecl _mktime64(tm* const tb)
+{
+    return common_mktime<__time64_t>(tb, true);
+}
+
+
+
+// Converts a UTC time stored in a tm structure into a time_t value.  These
+// functions also update the tm structure to normalize it and populate any
+// missing fields.  Returns the resulting time_t value on success; returns
+// -1 on failure.
+extern "C"  __time32_t __cdecl _mkgmtime32(tm* const tb)
+{
+    return common_mktime<__time32_t>(tb, false);
+}
+
+extern "C"  __time64_t __cdecl _mkgmtime64(tm* const tb)
+{
+    return common_mktime<__time64_t>(tb, false);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strdate.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strdate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..881495a0eb9f3f2f7777c9510394513d78de3350
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strdate.cpp	
@@ -0,0 +1,84 @@
+//
+// strdate.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The strdate() family of functions, which return the current data as a string.
+//
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_internal_time.h>
+
+
+// Returns the current date as a string of the form "MM/DD/YY".  These functions
+// return an error code on failure, or zero on success.  The buffer must be at
+// least nine characters in size.
+template <typename Character>
+static errno_t __cdecl common_strdate_s(
+    _Out_writes_z_(size_in_chars)   Character*  const   buffer,
+    _In_  _In_range_(>=, 9)         size_t      const   size_in_chars
+    ) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(buffer != nullptr && size_in_chars > 0, EINVAL);
+    _RESET_STRING(buffer, size_in_chars);
+    _VALIDATE_RETURN_ERRCODE(size_in_chars >= 9, ERANGE);
+
+    SYSTEMTIME local_time;
+    GetLocalTime(&local_time);
+
+    int const month = local_time.wMonth;
+    int const day   = local_time.wDay;
+    int const year  = local_time.wYear % 100;
+
+    static Character const zero_char = static_cast<Character>('0');
+
+#pragma warning(disable:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY) // 26015
+
+    // Store the components of the date into the string in MM/DD/YY form:
+    buffer[0] = static_cast<Character>(month / 10 + zero_char); // Tens of month
+    buffer[1] = static_cast<Character>(month % 10 + zero_char); // Units of month
+    buffer[2] = static_cast<Character>('/');
+    buffer[3] = static_cast<Character>(day   / 10 + zero_char); // Tens of day
+    buffer[4] = static_cast<Character>(day   % 10 + zero_char); // Units of day
+    buffer[5] = static_cast<Character>('/');
+    buffer[6] = static_cast<Character>(year  / 10 + zero_char); // Tens of year
+    buffer[7] = static_cast<Character>(year  % 10 + zero_char); // Units of year
+    buffer[8] = static_cast<Character>('\0');
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _strdate_s(char* const buffer, size_t const size_in_chars)
+{
+    return common_strdate_s(buffer, size_in_chars);
+}
+
+extern "C" errno_t __cdecl _wstrdate_s(wchar_t* const buffer, size_t const size_in_chars)
+{
+    return common_strdate_s(buffer, size_in_chars);
+}
+
+
+
+// Returns the current date as a string of the form "MM/DD/YY".  These functions
+// assume that the provided result buffer is at least nine characters in length.
+// Each returns the buffer on success, or null on failure.
+template <typename Character>
+_Success_(return != 0)
+static Character* __cdecl common_strdate(_Out_writes_z_(9) Character* const buffer) throw()
+{
+    errno_t const status = common_strdate_s(buffer, 9);
+    if (status != 0)
+        return nullptr;
+
+    return buffer;
+}
+
+extern "C" char* __cdecl _strdate(char* const buffer)
+{
+    return common_strdate(buffer);
+}
+
+extern "C" wchar_t* __cdecl _wstrdate(wchar_t* const buffer)
+{
+    return common_strdate(buffer);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strftime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strftime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..88b2d5c3f285a3d8cc9e0cde69b39db94f27d712
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strftime.cpp	
@@ -0,0 +1,199 @@
+//
+// strftime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The strftime family of functions, which format time data into a string, and
+// related functionality.
+//
+#include <corecrt_internal_time.h>
+#include <locale.h>
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Day and Month Name and Time Locale Information Fetching Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" char* __cdecl _Getdays_l(_locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+    __crt_lc_time_data const* const time_data = locale_update.GetLocaleT()->locinfo->lc_time_curr;
+
+    size_t length = 0;
+    for (size_t n = 0; n < 7; ++n)
+    {
+        length += strlen(time_data->wday_abbr[n]) + strlen(time_data->wday[n]) + 2;
+    }
+
+    __crt_unique_heap_ptr<char> buffer(_malloc_crt_t(char, length + 1));
+    if (buffer.get() == nullptr)
+        return nullptr;
+
+
+    char* it = buffer.get();
+    for (size_t n = 0; n < 7; ++n)
+    {
+        *it++ = ':';
+        _ERRCHECK(strcpy_s(it, (length + 1) - (it - buffer.get()), time_data->wday_abbr[n]));
+        it += strlen(it);
+        *it++ = ':';
+        _ERRCHECK(strcpy_s(it, (length + 1) - (it - buffer.get()), time_data->wday[n]));
+        it += strlen(it);
+    }
+    *it++ = '\0';
+
+    return buffer.detach();
+}
+
+extern "C" char* __cdecl _Getdays()
+{
+    return _Getdays_l(nullptr);
+}
+
+
+
+extern "C" char* __cdecl _Getmonths_l(_locale_t const locale)
+{
+    _LocaleUpdate locale_update(locale);
+    __crt_lc_time_data const* time_data = locale_update.GetLocaleT()->locinfo->lc_time_curr;
+
+    size_t length = 0;
+    for (size_t n = 0; n < 12; ++n)
+    {
+        length += strlen(time_data->month_abbr[n]) + strlen(time_data->month[n]) + 2;
+    }
+
+    __crt_unique_heap_ptr<char> buffer(_malloc_crt_t(char, length + 1));
+    if (buffer.get() == nullptr)
+        return nullptr;
+
+    char* it = buffer.get();
+    for (size_t n = 0; n < 12; ++n)
+    {
+        *it++ = ':';
+        _ERRCHECK(strcpy_s(it, (length + 1) - (it - buffer.get()), time_data->month_abbr[n]));
+        it += strlen(it);
+        *it++ = ':';
+        _ERRCHECK(strcpy_s(it, (length + 1) - (it - buffer.get()), time_data->month[n]));
+        it += strlen(it);
+    }
+    *it++ = '\0';
+
+    return buffer.detach();
+}
+
+
+
+extern "C" char* __cdecl _Getmonths()
+{
+    return _Getmonths_l(nullptr);
+}
+
+extern "C" void* __cdecl _W_Gettnames();
+
+extern "C" void* __cdecl _Gettnames()
+{
+    return _W_Gettnames();
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The strftime family of functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions format a time as a string using a given locale.  They place
+// characters into the user's output buffer, expanding time format directives as
+// described in the provided control string.  The lc_time_arg and locale are
+// used for locale data.
+//
+// If the total number of characters that need to be written (including the null
+// terminator) is less than the max_size, then the number of characters written
+// (not including the null terminator) is returned.  Otherwise, zero is returned.
+//
+// These functions simply delegate to the corresponding wide string functions
+// (e.g. _wcsftime).
+_Success_(return > 0)
+extern "C" size_t __cdecl _Strftime_l (
+    _Out_writes_z_(maxsize) char * const string,
+    _In_ size_t                    const maxsize,
+    _In_z_ const char *            const format,
+    _In_ const tm *                const timeptr,
+    _In_ void *                    const lc_time_arg,
+    _In_opt_ _locale_t             const locale
+    )
+{
+    _LocaleUpdate locale_update(locale);
+    unsigned int const lc_time_cp = locale_update.GetLocaleT()->locinfo->lc_time_cp;
+
+    _VALIDATE_RETURN(string != nullptr, EINVAL, 0)
+    _VALIDATE_RETURN(maxsize != 0,      EINVAL, 0)
+    *string = '\0';
+
+    _VALIDATE_RETURN(format != nullptr,  EINVAL, 0)
+    _VALIDATE_RETURN(timeptr != nullptr, EINVAL, 0)
+
+    __crt_internal_win32_buffer<wchar_t> wformat;
+
+    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(format, wformat, lc_time_cp);
+
+    if (cvt1 != 0) {
+        return 0;
+    }
+
+    // Allocate a new wide-char output string with the same size as the char*
+    // string one passed in as argument
+    __crt_unique_heap_ptr<wchar_t> const wstring(_malloc_crt_t(wchar_t, maxsize));
+    if (wstring.get() == nullptr)
+    {
+        // malloc should set the errno, if any
+        return 0;
+    }
+
+    size_t const wcsftime_result = _Wcsftime_l(wstring.get(), maxsize, wformat.data(), timeptr, lc_time_arg, locale);
+    if (wcsftime_result == 0)
+    {
+        return 0;
+    }
+
+    __crt_no_alloc_win32_buffer<char> copy_back(string, maxsize);
+    errno_t const cvt2 = __acrt_wcs_to_mbs_cp(wstring.get(), copy_back, lc_time_cp);
+
+    if (cvt2 != 0) {
+        return 0;
+    }
+
+    return copy_back.size();
+}
+
+extern "C" size_t __cdecl _Strftime(
+    char*       const string,
+    size_t      const max_size,
+    char const* const format,
+    tm const*   const timeptr,
+    void*       const lc_time_arg
+    )
+{
+    return _Strftime_l(string, max_size, format, timeptr, lc_time_arg, nullptr);
+}
+
+extern "C" size_t __cdecl _strftime_l(
+    char*       const string,
+    size_t      const max_size,
+    char const* const format,
+    tm const*   const timeptr,
+    _locale_t   const locale
+    )
+{
+    return _Strftime_l(string, max_size, format, timeptr, nullptr, locale);
+}
+extern "C" size_t __cdecl strftime(
+    char*       const string,
+    size_t      const max_size,
+    char const* const format,
+    tm const*   const timeptr
+    )
+{
+    return _Strftime_l(string, max_size, format, timeptr, nullptr, nullptr);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strtime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strtime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ed514e95120d0e5ae7ac6edc09a52c3e825e71b
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/strtime.cpp	
@@ -0,0 +1,88 @@
+//
+// strtime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The strtime family of functions, which return the current time as a string.
+//
+#include <corecrt_internal_securecrt.h>
+#include <corecrt_internal_time.h>
+
+#pragma warning(disable:__WARNING_HIGH_PRIORITY_OVERFLOW_POSTCONDITION) // 26045 Potential postcondition violation that could result in overflow
+#pragma warning(disable:__WARNING_RETURNING_BAD_RESULT) // 28196 The requirement that 'return!=0' is not satisfied. (The expression does not evaluate to true.)
+
+// Returns the current time as a string of the form "HH:MM:SS".  These functions
+// return an error code on failure, or zero on success.  The buffer must be at
+// least nine characters in size.
+template <typename Character>
+_Success_(buffer != 0 && size_in_chars >= 9)
+static errno_t __cdecl common_strtime_s(
+    _Out_writes_z_(size_in_chars)   Character*  const   buffer,
+    _In_  _In_range_(>=, 9)         size_t      const   size_in_chars
+    ) throw()
+{
+    _VALIDATE_RETURN_ERRCODE(buffer != nullptr && size_in_chars > 0, EINVAL);
+    _RESET_STRING(buffer, size_in_chars);
+    _VALIDATE_RETURN_ERRCODE(size_in_chars >= 9, ERANGE);
+
+    SYSTEMTIME local_time;
+    GetLocalTime(&local_time);
+
+    int const hours   = local_time.wHour;
+    int const minutes = local_time.wMinute;
+    int const seconds = local_time.wSecond;
+
+    static Character const zero_char = static_cast<Character>('0');
+
+#pragma warning(disable:__WARNING_INCORRECT_VALIDATION) // 26014 Prefast doesn't notice the validation.
+
+    // Store the components of the date into the string in HH:MM:SS form:
+    buffer[0] = static_cast<Character>(hours   / 10 + zero_char); // Tens of hour
+    buffer[1] = static_cast<Character>(hours   % 10 + zero_char); // Units of hour
+    buffer[2] = static_cast<Character>(':');
+    buffer[3] = static_cast<Character>(minutes / 10 + zero_char); // Tens of minute
+    buffer[4] = static_cast<Character>(minutes % 10 + zero_char); // Units of minute
+    buffer[5] = static_cast<Character>(':');
+    buffer[6] = static_cast<Character>(seconds / 10 + zero_char); // Tens of second
+    buffer[7] = static_cast<Character>(seconds % 10 + zero_char); // Units of second
+    buffer[8] = static_cast<Character>('\0');
+
+    return 0;
+}
+
+extern "C" errno_t __cdecl _strtime_s(char* const buffer, size_t const size_in_chars)
+{
+    return common_strtime_s(buffer, size_in_chars);
+}
+
+extern "C" errno_t __cdecl _wstrtime_s(wchar_t* const buffer, size_t const size_in_chars)
+{
+    return common_strtime_s(buffer, size_in_chars);
+}
+
+
+
+// Returns the current time as a string of the form "HH:MM:SS".  These functions
+// assume that the provided result buffer is at least nine characters in length.
+// Each returns the buffer on success, or null on failure.
+template <typename Character>
+_Success_(buffer != 0)
+_Ret_z_
+static Character* __cdecl common_strtime(_Out_writes_z_(9) Character* const buffer) throw()
+{
+    errno_t const status = common_strtime_s(buffer, 9);
+    if (status != 0)
+        return nullptr;
+
+    return buffer;
+}
+
+extern "C" char* __cdecl _strtime(char* const buffer)
+{
+    return common_strtime(buffer);
+}
+
+extern "C" wchar_t* __cdecl _wstrtime(wchar_t* const buffer)
+{
+    return common_strtime(buffer);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/time.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/time.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4a12d2a98f71055000d1cdcb2398e899b7fbea10
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/time.cpp	
@@ -0,0 +1,102 @@
+//
+// time.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The timespec_get() and time() families of functions, which get the current
+// system time as a timespec and a time_t, respectively.
+//
+#include <corecrt_internal_time.h>
+
+
+using get_system_time_function_type = void(WINAPI *)(LPFILETIME);
+
+template <get_system_time_function_type GetSystemTimeFunction, typename TimeSpecType>
+_Success_(return != 0)
+static int __cdecl common_timespec_get(TimeSpecType* const ts, int const base) throw()
+{
+    typedef decltype(ts->tv_sec)                time_type;
+    typedef __crt_time_time_t_traits<time_type> time_traits;
+
+    _VALIDATE_RETURN(ts != nullptr, EINVAL, 0);
+
+    if (base != TIME_UTC)
+    {
+        return 0;
+    }
+
+    __crt_filetime_union system_time{};
+    GetSystemTimeFunction(&system_time._filetime);
+
+    __time64_t const filetime_scale{10 * 1000 * 1000}; // 100ns units
+
+    __time64_t const epoch_time{static_cast<__time64_t>(system_time._scalar) - _EPOCH_BIAS};
+
+    __time64_t const seconds    {epoch_time / filetime_scale};
+    __time64_t const nanoseconds{epoch_time % filetime_scale * 100};
+
+    if (seconds > static_cast<__time64_t>(time_traits::max_time_t))
+    {
+        return 0;
+    }
+
+    ts->tv_sec  = static_cast<time_type>(seconds);
+    ts->tv_nsec = static_cast<long>(nanoseconds);
+    return base;
+}
+
+extern "C" int __cdecl _timespec32_get(_timespec32* const ts, int const base)
+{
+    return common_timespec_get<__acrt_GetSystemTimePreciseAsFileTime>(ts, base);
+}
+
+extern "C" int __cdecl _timespec64_get(_timespec64* const ts, int const base)
+{
+    return common_timespec_get<__acrt_GetSystemTimePreciseAsFileTime>(ts, base);
+}
+
+
+
+// Gets the current system time and converts it to a time_t value. If 'result'
+// is non-null, the time is stored in '*result'.  The time is also returned
+// (even if 'result' is null).
+template <typename TimeType>
+static TimeType __cdecl common_time(TimeType* const result) throw()
+{
+    typedef __crt_time_time_t_traits<TimeType> time_traits;
+
+    typename time_traits::timespec_type ts{};
+
+    // The resolution of time() is in seconds, so we can afford to use
+    // a less precise, but faster method of getting the time.
+    // GetSystemTimePreciseAsFileTime uses QueryPerformanceCounter which
+    // needs to be virtualized on some systems in order to be accurate, which can
+    // be significantly slower than calling GetSystemTimeAsFileTime.
+    // For example, hypervisors will virtualize QPC calls in order to take into
+    // account virtual machine live migration.
+    // Note that calling the less precise API is still observable because the tick
+    // count may update +/- 15ms, but this should not affect common use of time().
+    // See https://docs.microsoft.com/en-us/windows/desktop/sysinfo/acquiring-high-resolution-time-stamps
+    // for more details.
+    if (common_timespec_get<GetSystemTimeAsFileTime>(&ts, TIME_UTC) != TIME_UTC)
+    {
+        ts.tv_sec = static_cast<TimeType>(-1);
+    }
+
+    if (result)
+    {
+        *result = ts.tv_sec;
+    }
+
+    return ts.tv_sec;
+}
+
+extern "C" __time32_t __cdecl _time32(__time32_t* const result)
+{
+    return common_time(result);
+}
+
+extern "C" __time64_t __cdecl _time64(__time64_t* const result)
+{
+    return common_time(result);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/timeset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/timeset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1868f65ef568f38e005b4094e5661d807de7adaa
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/timeset.cpp	
@@ -0,0 +1,188 @@
+//
+// timeset.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The time zone values for the default time zone, and other global time data.
+//
+#include <corecrt_internal_time.h>
+
+#undef _daylight
+#undef _dstbias
+#undef _timezone
+#undef _tzname
+
+
+
+__crt_state_management::dual_state_global<long> _timezone; // Pacific Time Zone
+__crt_state_management::dual_state_global<int>  _daylight; // Daylight Saving Time (DST) in timezone
+__crt_state_management::dual_state_global<long> _dstbias;  // DST offset in seconds
+
+// Note that NT POSIX's TZNAME_MAX is only 10.
+
+#define _PST_STRING "PST"
+#define _PDT_STRING "PDT"
+
+#define L_PST_STRING L"PST"
+#define L_PDT_STRING L"PDT"
+
+static char tzstd_program[_TZ_STRINGS_SIZE] = { _PST_STRING };
+static char tzdst_program[_TZ_STRINGS_SIZE] = { _PDT_STRING };
+
+static wchar_t w_tzstd_program[_TZ_STRINGS_SIZE] = { L_PST_STRING };
+static wchar_t w_tzdst_program[_TZ_STRINGS_SIZE] = { L_PDT_STRING };
+
+#ifdef _CRT_GLOBAL_STATE_ISOLATION
+    static char tzstd_os[_TZ_STRINGS_SIZE] = { _PST_STRING };
+    static char tzdst_os[_TZ_STRINGS_SIZE] = { _PDT_STRING };
+
+    static wchar_t w_tzstd_os[_TZ_STRINGS_SIZE] = { L_PST_STRING };
+    static wchar_t w_tzdst_os[_TZ_STRINGS_SIZE] = { L_PDT_STRING };
+#endif
+
+static char* tzname_states[__crt_state_management::state_index_count][2] =
+{
+    { tzstd_program, tzdst_program },
+    #ifdef _CRT_GLOBAL_STATE_ISOLATION
+    { tzstd_os,      tzdst_os      }
+    #endif
+};
+
+static wchar_t* w_tzname_states[__crt_state_management::state_index_count][2] =
+{
+    { w_tzstd_program, w_tzdst_program },
+    #ifdef _CRT_GLOBAL_STATE_ISOLATION
+    { w_tzstd_os,      w_tzdst_os      }
+    #endif
+};
+
+static __crt_state_management::dual_state_global<char **> _tzname;
+static __crt_state_management::dual_state_global<wchar_t **> w_tzname;
+
+// Initializer for the timeset globals:
+_CRT_LINKER_FORCE_INCLUDE(__acrt_timeset_initializer);
+
+extern "C" int __cdecl __acrt_initialize_timeset()
+{
+    _timezone.initialize(8 * 3600L);
+    _daylight.initialize(1);
+    _dstbias.initialize (-3600);
+
+    char*** const first_state = _tzname.dangerous_get_state_array();
+    for (unsigned i = 0; i != __crt_state_management::state_index_count; ++i)
+    {
+        first_state[i] = tzname_states[i];
+    }
+
+    wchar_t*** const w_first_state = w_tzname.dangerous_get_state_array();
+    for (unsigned i = 0; i != __crt_state_management::state_index_count; ++i)
+    {
+        w_first_state[i] = w_tzname_states[i];
+    }
+
+    return 0;
+}
+
+extern "C"  errno_t __cdecl _get_daylight(int* const result)
+{
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+
+    // This variable is correctly inited at startup, so no need to check if
+    // CRT init finished.
+    *result = _daylight.value();
+    return 0;
+}
+
+extern "C" errno_t __cdecl _get_dstbias(long* result)
+{
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+
+    // This variable is correctly inited at startup, so no need to check if
+    // CRT init finished.
+    *result = _dstbias.value();
+    return 0;
+}
+
+extern "C" errno_t __cdecl _get_timezone(long* result)
+{
+    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
+
+    // This variable is correctly inited at startup, so no need to check if
+    // CRT init finished.
+    *result = _timezone.value();
+    return 0;
+}
+
+extern "C" errno_t __cdecl _get_tzname(
+    size_t* const length,
+    char*   const buffer,
+    size_t  const size_in_bytes,
+    int     const index)
+{
+    _VALIDATE_RETURN_ERRCODE(
+        (buffer != nullptr && size_in_bytes > 0) ||
+        (buffer == nullptr && size_in_bytes == 0),
+        EINVAL);
+
+    if (buffer != nullptr)
+        buffer[0] = '\0';
+
+    _VALIDATE_RETURN_ERRCODE(length != nullptr,        EINVAL);
+    _VALIDATE_RETURN_ERRCODE(index == 0 || index == 1, EINVAL);
+
+    // _tzname is correctly inited at startup, so no need to check if
+    // CRT init finished.
+    *length = strlen(_tzname.value()[index]) + 1;
+
+    // If the buffer pointer is null, the caller is interested only in the size
+    // of the string, not in the actual value of the string:
+    if (buffer == nullptr)
+        return 0;
+
+    if (*length > size_in_bytes)
+        return ERANGE;
+
+    return strcpy_s(buffer, size_in_bytes, _tzname.value()[index]);
+}
+
+
+
+// Day names must be three character abbreviations strung together
+extern "C" const char __dnames[] =
+{
+    "SunMonTueWedThuFriSat"
+};
+
+// Month names must be three character abbreviations strung together
+extern "C" const char __mnames[] =
+{
+    "JanFebMarAprMayJunJulAugSepOctNovDec"
+};
+
+
+
+// Accessors for the global time data
+extern "C" int* __cdecl __daylight()
+{
+    return &_daylight.value();
+}
+
+extern "C" long* __cdecl __dstbias()
+{
+    return &_dstbias.value();
+}
+
+extern "C" long* __cdecl __timezone()
+{
+    return &_timezone.value();
+}
+
+extern "C" char** __cdecl __tzname()
+{
+    return _tzname.value();
+}
+
+extern "C" wchar_t** __cdecl __wide_tzname()
+{
+    return w_tzname.value();
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/tzset.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/tzset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..09cc9dc86b5dcc61ed939019fae52b7140fa2a7f
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/tzset.cpp	
@@ -0,0 +1,712 @@
+//
+// tzset.cpp
+//
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// Defines the _tzset() function which updates the global time zone state, and
+// the _isindst() function, which tests whether a time is in Daylight Savings
+// Time or not.
+//
+#include <corecrt_internal_time.h>
+#include <locale.h>
+
+
+
+_DEFINE_SET_FUNCTION(_set_daylight, int,  _daylight)
+_DEFINE_SET_FUNCTION(_set_dstbias,  long, _dstbias )
+_DEFINE_SET_FUNCTION(_set_timezone, long, _timezone)
+
+
+
+// Pointer to a saved copy of the TZ value obtained in the previous call to the
+// tzset functions, if one is available:
+static wchar_t* last_wide_tz = nullptr;
+
+// If the time zone was last updated by calling the system API, then the tz_info
+// variable contains the time zone information and tz_api_used is set to true.
+static int                   tz_api_used;
+static TIME_ZONE_INFORMATION tz_info;
+
+static __crt_state_management::dual_state_global<long> tzset_init_state;
+
+namespace
+{
+    // Structure used to represent DST transition date/times:
+    struct transitiondate
+    {
+        int  yr; // year of interest
+        int  yd; // day of year
+        int  ms; // milli-seconds in the day
+    };
+
+    enum class date_type
+    {
+        absolute_date,
+        day_in_month
+    };
+
+    enum class transition_type
+    {
+        start_of_dst,
+        end_of_dst
+    };
+
+    size_t const local_env_buffer_size = 256;
+    int    const milliseconds_per_day  = 24 * 60 * 60 * 1000;
+}
+
+// DST start and end structures:
+static transitiondate dststart = { -1, 0, 0 };
+static transitiondate dstend   = { -1, 0, 0 };
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The _tzset() family of functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Gets the value of the TZ environment variable.  If there is no TZ environment
+// variable or if we do not have access to the environment, nullptr is returned.
+// If the value of the TZ variable fits into the local_buffer, it is stored there
+// and a pointer to the local_buffer is returned.  Otherwise, a buffer is
+// dynamically allocated, the value is stored into that buffer, and a pointer to
+// that buffer is returned.  In this case, the caller is responsible for freeing
+// the buffer.
+static wchar_t* get_tz_environment_variable(wchar_t (&local_buffer)[local_env_buffer_size]) throw()
+{
+    size_t required_length;
+    errno_t const status = _wgetenv_s(&required_length, local_buffer, local_env_buffer_size, L"TZ");
+    if (status == 0)
+    {
+        return local_buffer;
+    }
+
+    if (status != ERANGE)
+    {
+        return nullptr;
+    }
+
+    __crt_unique_heap_ptr<wchar_t> dynamic_buffer(_malloc_crt_t(wchar_t, required_length));
+    if (dynamic_buffer.get() == nullptr)
+    {
+        return nullptr;
+    }
+
+    size_t actual_length;
+    if (_wgetenv_s(&actual_length, dynamic_buffer.get(), required_length, L"TZ") != 0)
+    {
+        return nullptr;
+    }
+
+    return dynamic_buffer.detach();
+}
+
+static void __cdecl tzset_os_copy_to_tzname(const wchar_t * const timezone_name, wchar_t * const wide_tzname, char * const narrow_tzname, unsigned int const code_page)
+{
+    // Maximum time zone name from OS is 32 characters long
+    // (see https://docs.microsoft.com/en-us/windows/desktop/api/timezoneapi/ns-timezoneapi-_time_zone_information)
+    _ERRCHECK(wcsncpy_s(wide_tzname, _TZ_STRINGS_SIZE, timezone_name, 32));
+
+    // Invalid characters are replaced by closest approximation or default character.
+    // On other failure, leave narrow tzname blank.
+    __acrt_WideCharToMultiByte(
+        code_page,
+        0,
+        timezone_name,
+        -1,
+        narrow_tzname,
+        _TZ_STRINGS_SIZE, // Passing -1 as source size, so null terminator included.
+        nullptr,
+        nullptr
+    );
+}
+
+// Handles the _tzset if and only if there is no TZ environment variable.  In
+// this case, we attempt to use the time zone information from the system.
+static void __cdecl tzset_from_system_nolock() throw()
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    char** tzname = _tzname;
+    wchar_t** wide_tzname = __wide_tzname();
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+
+    long timezone = 0;
+    int  daylight = 0;
+    long dstbias  = 0;
+    _ERRCHECK(_get_timezone(&timezone));
+    _ERRCHECK(_get_daylight(&daylight));
+    _ERRCHECK(_get_dstbias (&dstbias ));
+
+    // If there is a last_wide_tz already, discard it:
+    _free_crt(last_wide_tz);
+    last_wide_tz = nullptr;
+
+    if (GetTimeZoneInformation(&tz_info) != 0xFFFFFFFF)
+    {
+        // Record that the API was used:
+        tz_api_used = 1;
+
+        // Derive _timezone value from Bias and StandardBias fields.
+        timezone = tz_info.Bias * 60;
+
+        if (tz_info.StandardDate.wMonth != 0)
+            timezone += tz_info.StandardBias * 60;
+
+        // Check to see if there is a daylight time bias. Since the StandardBias
+        // has been added into _timezone, it must be compensated for in the
+        // value computed for _dstbias:
+        if (tz_info.DaylightDate.wMonth != 0 && tz_info.DaylightBias != 0)
+        {
+            daylight = 1;
+            dstbias = (tz_info.DaylightBias - tz_info.StandardBias) * 60;
+        }
+        else
+        {
+            daylight = 0;
+
+            // Set the bias to 0 because GetTimeZoneInformation may return
+            // TIME_ZONE_ID_DAYLIGHT even though there is no DST (e.g., in NT
+            // 3.51, this can happen if automatic DST adjustment is disabled
+            // in the Control Panel.
+            dstbias = 0;
+        }
+
+        memset(wide_tzname[0], 0, _TZ_STRINGS_SIZE * sizeof(wchar_t));
+        memset(wide_tzname[1], 0, _TZ_STRINGS_SIZE * sizeof(wchar_t));
+        memset(tzname[0], 0, _TZ_STRINGS_SIZE);
+        memset(tzname[1], 0, _TZ_STRINGS_SIZE);
+
+        // Try to grab the name strings for both the time zone and the daylight
+        // zone.  Note the wide character strings in tz_info must be converted
+        // to multibyte character strings.  The locale code page must be used
+        // for this.  Note that if setlocale() has not yet been called with
+        // LC_ALL or LC_CTYPE, then the code page will be 0, which is CP_ACP,
+        // so we will use the host's default ANSI code page.
+        //
+        // CRT_REFACTOR TODO We use the current locale for this transformation.
+        // If per-thread locale has been enabled for this thread, then we'll be
+        // using this thread's locale to update a global variable that is
+        // accessed from multiple threads.  Does the time zone information also
+        // need to be stored per-thread?
+        unsigned const code_page = ___lc_codepage_func();
+
+        tzset_os_copy_to_tzname(tz_info.StandardName, wide_tzname[0], tzname[0], code_page);
+        tzset_os_copy_to_tzname(tz_info.DaylightName, wide_tzname[1], tzname[1], code_page);
+    }
+
+    _set_timezone(timezone);
+    _set_daylight(daylight);
+    _set_dstbias(dstbias);
+}
+
+static void __cdecl tzset_env_copy_to_tzname(const wchar_t * const tz_env, wchar_t * const wide_tzname, char * const narrow_tzname, rsize_t const tzname_length)
+{
+    _ERRCHECK(wcsncpy_s(wide_tzname, _TZ_STRINGS_SIZE, tz_env, tzname_length));
+
+    // Historically when getting _tzname via TZ, the narrow environment was used to populate _tzname when getting _tzname.
+    // The narrow environment is always encoded in the ACP (so _tzname was encoded in the ACP when coming from TZ), but
+    // when getting _tzname from the OS, the current active code page (set via setlocale()) was used instead.
+    // To maintain behavior compatibility, we remain intentionally inconsistent with
+    // how _tzname is generated when getting time zone information from the OS by explicitly encoding with the ACP.
+    // UTF-8 mode is opt-in, so we can correct this inconsistency when the current code page is UTF-8.
+
+    // Invalid characters are replaced by closest approximation or default character.
+    // On other failure, simply leave _tzname blank.
+    __acrt_WideCharToMultiByte(
+        __acrt_get_utf8_acp_compatibility_codepage(),
+        0,
+        wide_tzname,
+        static_cast<int>(tzname_length),
+        narrow_tzname,
+        _TZ_STRINGS_SIZE - 1, // Leave room for null terminator
+        nullptr,
+        nullptr);
+}
+
+static void __cdecl tzset_from_environment_nolock(_In_z_ wchar_t* tz_env) throw()
+{
+    _BEGIN_SECURE_CRT_DEPRECATION_DISABLE
+    char** tzname = _tzname;
+    wchar_t** wide_tzname = __wide_tzname();
+    _END_SECURE_CRT_DEPRECATION_DISABLE
+
+    long timezone = 0;
+    int  daylight = 0;
+    _ERRCHECK(_get_timezone(&timezone));
+    _ERRCHECK(_get_daylight(&daylight));
+
+    // Check to see if the TZ value is unchanged from an earlier call to this
+    // function.  If it hasn't changed, we have no work to do:
+    if (last_wide_tz != nullptr && wcscmp(tz_env, last_wide_tz) == 0)
+    {
+        return;
+    }
+
+    // Update the global last_wide_tz variable:
+    auto new_wide_tz = _malloc_crt_t(wchar_t, wcslen(tz_env) + 1);
+    if (!new_wide_tz)
+    {
+        return;
+    }
+
+    _free_crt(last_wide_tz);
+    last_wide_tz = new_wide_tz.detach();
+
+    _ERRCHECK(wcscpy_s(last_wide_tz, wcslen(tz_env) + 1, tz_env));
+
+    // Process TZ value and update _tzname, _timezone and _daylight.
+    memset(wide_tzname[0], 0, _TZ_STRINGS_SIZE * sizeof(wchar_t));
+    memset(wide_tzname[1], 0, _TZ_STRINGS_SIZE * sizeof(wchar_t));
+    memset(tzname[0], 0, _TZ_STRINGS_SIZE);
+    memset(tzname[1], 0, _TZ_STRINGS_SIZE);
+
+    rsize_t const tzname_length = 3;
+
+    // Copy standard time zone name (index 0)
+    tzset_env_copy_to_tzname(tz_env, wide_tzname[0], tzname[0], tzname_length);
+
+    // Skip first few characters if present.
+    for (rsize_t i = 0; i < tzname_length; ++i)
+    {
+        if (*tz_env)
+        {
+            ++tz_env;
+        }
+    }
+
+    // The time difference is of the form:
+    //     [+|-]hh[:mm[:ss]]
+    // Check for the minus sign first:
+    bool const is_negative_difference = *tz_env == L'-';
+    if (is_negative_difference)
+    {
+        ++tz_env;
+    }
+
+    wchar_t * dummy;
+    int const decimal_base = 10;
+
+    // process, then skip over, the hours
+    timezone = wcstol(tz_env, &dummy, decimal_base) * 3600;
+    while (*tz_env == '+' || (*tz_env >= L'0' && *tz_env <= L'9'))
+    {
+        ++tz_env;
+    }
+
+
+    // Check if minutes were specified:
+    if (*tz_env == L':')
+    {
+        // Process, then skip over, the minutes
+        timezone += wcstol(++tz_env, &dummy, decimal_base) * 60;
+        while (*tz_env >= L'0' && *tz_env <= L'9')
+        {
+            ++tz_env;
+        }
+
+        // Check if seconds were specified:
+        if (*tz_env == L':')
+        {
+            // Process, then skip over, the seconds:
+            timezone += wcstol(++tz_env, &dummy, decimal_base);
+            while (*tz_env >= L'0' && *tz_env <= L'9')
+            {
+                ++tz_env;
+            }
+        }
+    }
+
+    if (is_negative_difference)
+    {
+        timezone = -timezone;
+    }
+
+    // Finally, check for a DST zone suffix:
+    daylight = *tz_env ? 1 : 0;
+
+    if (daylight)
+    {
+        // Copy daylight time zone name (index 1)
+        tzset_env_copy_to_tzname(tz_env, wide_tzname[1], tzname[1], tzname_length);
+    }
+
+    _set_timezone(timezone);
+    _set_daylight(daylight);
+}
+
+static void __cdecl tzset_nolock() throw()
+{
+    // Clear the flag indicated whether GetTimeZoneInformation was used.
+    tz_api_used = 0;
+
+    // Set year fields of dststart and dstend structures to -1 to ensure
+    // they are recomputed as after this
+    dststart.yr = dstend.yr = -1;
+
+    // Get the value of the TZ environment variable:
+    wchar_t local_env_buffer[local_env_buffer_size];
+    wchar_t* const tz_env = get_tz_environment_variable(local_env_buffer);
+
+    // If the buffer ended up being dynamically allocated, make sure we
+    // clean it up before we return:
+    __crt_unique_heap_ptr<wchar_t> tz_env_cleanup(tz_env == local_env_buffer
+        ? nullptr
+        : tz_env);
+
+    // If the environment variable is not available for whatever reason, update
+    // without using the environment (note that unless the Desktop CRT is loaded
+    // and we have access to non-MSDK APIs, we will always tak this path).
+    if (tz_env == nullptr || tz_env[0] == '\0')
+        return tzset_from_system_nolock();
+
+    return tzset_from_environment_nolock(tz_env);
+}
+
+
+
+// Sets the time zone information and calculates whether we are currently in
+// Daylight Savings Time.  This reads the TZ environment variable, if that
+// variable exists and can be read by the process; otherwise, the system is
+// queried for the current time zone state.  The _daylight, _timezone, and
+// _tzname global variables are updated accordingly.
+extern "C" void __cdecl _tzset()
+{
+    __acrt_lock(__acrt_time_lock);
+    __try
+    {
+        tzset_nolock();
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_time_lock);
+    }
+}
+
+
+
+// This function may be called to ensure that the time zone information ha sbeen
+// set at least once.  If the time zone information has not yet been set, this
+// function sets it.
+extern "C" void __cdecl __tzset()
+{
+    auto const first_time = tzset_init_state.dangerous_get_state_array() + __crt_state_management::get_current_state_index();
+
+    if (__crt_interlocked_read(first_time) != 0)
+    {
+        return;
+    }
+
+    __acrt_lock(__acrt_time_lock);
+    __try
+    {
+        if (__crt_interlocked_read(first_time) != 0)
+        {
+            __leave;
+        }
+
+        tzset_nolock();
+
+        _InterlockedIncrement(first_time);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_time_lock);
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The _isindst() family of functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Converts the format of a transition date specification to a value of a
+// transitiondate structure.  The dststart and dstend global variables are
+// filled in with the converted date.
+static void __cdecl cvtdate(
+    transition_type const trantype,  // start or end of DST
+    date_type       const datetype,  // Day-in-month or absolute date
+    int             const year,      // Year, as an offset from 1900
+    int             const month,     // Month, where 0 is January
+    int             const week,      // Week of month, if datetype is day-in-month
+    int             const dayofweek, // Day of week, if datetype is day-in-month
+    int             const date,      // Date of month (1 - 31)
+    int             const hour,      // Hours (0 - 23)
+    int             const min,       // Minutes (0 - 59)
+    int             const sec,       // Seconds (0 - 59)
+    int             const msec       // Milliseconds (0 - 999)
+    ) throw()
+{
+    int yearday;
+    int monthdow;
+    long dstbias = 0;
+
+    if (datetype == date_type::day_in_month)
+    {
+        // Figure out the year-day of the start of the month:
+        yearday = 1 + (__crt_time_is_leap_year(year)
+            ? _lpdays[month - 1]
+            : _days[month - 1]);
+
+        // Figureo ut the day of the week of the start of the month:
+        monthdow = (yearday + ((year - 70) * 365) +
+                    __crt_time_elapsed_leap_years(year) + _BASE_DOW) % 7;
+
+        // Figure out the year-day of the transition date:
+        if (monthdow <= dayofweek)
+            yearday += (dayofweek - monthdow) + (week - 1) * 7;
+        else
+            yearday += (dayofweek - monthdow) + week * 7;
+
+        // We may have to adjust the calculation above if week == 5 (meaning the
+        // last instance of the day in the month).  Check if the year falls
+        // beyond after month and adjust accordingly:
+        int const days_to_compare = __crt_time_is_leap_year(year)
+            ? _lpdays[month]
+            : _days[month];
+
+        if (week == 5 && yearday > days_to_compare)
+        {
+            yearday -= 7;
+        }
+    }
+    else
+    {
+        yearday = __crt_time_is_leap_year(year)
+            ? _lpdays[month - 1]
+            : _days[month - 1];
+
+        yearday += date;
+    }
+
+    if (trantype == transition_type::start_of_dst)
+    {
+        dststart.yd = yearday;
+        dststart.ms = msec + (1000 * (sec + 60 * (min + 60 * hour)));
+
+        // Set the year field of dststart so that unnecessary calls to cvtdate()
+        // may be avoided:
+        dststart.yr = year;
+    }
+    else // end_of_dst
+    {
+        dstend.yd = yearday;
+        dstend.ms = msec + (1000 * (sec + 60 * (min + 60 * hour)));
+
+        // The converted date is still a DST date.  We must convert to a standard
+        // (local) date while being careful the millisecond field does not
+        // overflow or underflow
+        _ERRCHECK(_get_dstbias(&dstbias));
+        dstend.ms += (dstbias * 1000);
+        if (dstend.ms < 0)
+        {
+            dstend.ms += milliseconds_per_day;
+            dstend.yd--;
+        }
+        else if (dstend.ms >= milliseconds_per_day)
+        {
+            dstend.ms -= milliseconds_per_day;
+            dstend.yd++;
+        }
+
+        // Set the year field of dstend so that unnecessary calls to cvtdate()
+        // may be avoided:
+        dstend.yr = year;
+    }
+
+    return;
+}
+
+
+
+// Implementation Details:  Note that there are two ways that the Daylight
+// Savings Time transition data may be returned by GetTimeZoneInformation.  The
+// first is a day-in-month format, which is similar to what is used in the USA.
+// The transition date is given as the n'th occurrence of a specified day of the
+// week in a specified month.  The second is as an absolute date.  The two cases
+// are distinguished by the value of the wYear field of the SYSTEMTIME structure
+// (zero denotes a day-in-month format).
+static int __cdecl _isindst_nolock(tm* const tb) throw()
+{
+    int daylight = 0;
+    _ERRCHECK(_get_daylight(&daylight));
+    if (daylight == 0)
+        return 0;
+
+    // Compute (or recompute) the transition dates for Daylight Savings Time
+    // if necessary.  The yr fields of dststart and dstend are compared to the
+    // year of interest to determine necessity.
+    if (tb->tm_year != dststart.yr || tb->tm_year != dstend.yr)
+    {
+        if (tz_api_used)
+        {
+            // Convert the start of daylight savings time to dststart:
+            if (tz_info.DaylightDate.wYear == 0)
+            {
+                cvtdate(
+                    transition_type::start_of_dst,
+                    date_type::day_in_month,
+                    tb->tm_year,
+                    tz_info.DaylightDate.wMonth,
+                    tz_info.DaylightDate.wDay,
+                    tz_info.DaylightDate.wDayOfWeek,
+                    0,
+                    tz_info.DaylightDate.wHour,
+                    tz_info.DaylightDate.wMinute,
+                    tz_info.DaylightDate.wSecond,
+                    tz_info.DaylightDate.wMilliseconds);
+            }
+            else
+            {
+                cvtdate(
+                    transition_type::start_of_dst,
+                    date_type::absolute_date,
+                    tb->tm_year,
+                    tz_info.DaylightDate.wMonth,
+                    0,
+                    0,
+                    tz_info.DaylightDate.wDay,
+                    tz_info.DaylightDate.wHour,
+                    tz_info.DaylightDate.wMinute,
+                    tz_info.DaylightDate.wSecond,
+                    tz_info.DaylightDate.wMilliseconds);
+            }
+
+            // Convert start of standard time to dstend:
+            if (tz_info.StandardDate.wYear == 0)
+            {
+                cvtdate(
+                    transition_type::end_of_dst,
+                    date_type::day_in_month,
+                    tb->tm_year,
+                    tz_info.StandardDate.wMonth,
+                    tz_info.StandardDate.wDay,
+                    tz_info.StandardDate.wDayOfWeek,
+                    0,
+                    tz_info.StandardDate.wHour,
+                    tz_info.StandardDate.wMinute,
+                    tz_info.StandardDate.wSecond,
+                    tz_info.StandardDate.wMilliseconds);
+            }
+            else
+            {
+                cvtdate(
+                    transition_type::end_of_dst,
+                    date_type::absolute_date,
+                    tb->tm_year,
+                    tz_info.StandardDate.wMonth,
+                    0,
+                    0,
+                    tz_info.StandardDate.wDay,
+                    tz_info.StandardDate.wHour,
+                    tz_info.StandardDate.wMinute,
+                    tz_info.StandardDate.wSecond,
+                    tz_info.StandardDate.wMilliseconds);
+            }
+        }
+        else
+        {
+            // The GetTimeZoneInformation API was not used, or failed.  We use
+            // the USA Daylight Savings Time rules as a fallback.
+            int startmonth = 3; // March
+            int startweek  = 2; // Second week
+            int endmonth   = 11;// November
+            int endweek    = 1; // First week
+
+            // The rules changed in 2007:
+            if (107 > tb->tm_year)
+            {
+                startmonth = 4; // April
+                startweek  = 1; // first week
+                endmonth   = 10;// October
+                endweek    = 5; // last week
+            }
+
+            cvtdate(
+                transition_type::start_of_dst,
+                date_type::day_in_month,
+                tb->tm_year,
+                startmonth,
+                startweek,
+                0, // Sunday
+                0,
+                2, // 02:00 (2 AM)
+                0,
+                0,
+                0);
+
+            cvtdate(
+                transition_type::end_of_dst,
+                date_type::day_in_month,
+                tb->tm_year,
+                endmonth,
+                endweek,
+                0, // Sunday
+                0,
+                2, // 02:00 (2 AM)
+                0,
+                0,
+                0);
+        }
+    }
+
+    // Handle simple cases first:
+    if (dststart.yd < dstend.yd)
+    {
+        // Northern hemisphere ordering:
+        if (tb->tm_yday < dststart.yd || tb->tm_yday > dstend.yd)
+            return 0;
+
+        if (tb->tm_yday > dststart.yd && tb->tm_yday < dstend.yd)
+            return 1;
+    }
+    else
+    {
+        // Southern hemisphere ordering:
+        if (tb->tm_yday < dstend.yd || tb->tm_yday > dststart.yd)
+            return 1;
+
+        if (tb->tm_yday > dstend.yd && tb->tm_yday < dststart.yd)
+            return 0;
+    }
+
+    long const ms = 1000 * (tb->tm_sec + 60 * tb->tm_min + 3600 * tb->tm_hour);
+
+    if (tb->tm_yday == dststart.yd)
+    {
+
+        return ms >= dststart.ms ? 1 : 0;
+    }
+    else
+    {
+        return ms < dstend.ms ? 1 : 0;
+    }
+}
+
+
+
+// Tests if the time represented by the tm structure falls in Daylight Savings
+// Time or not.  The Daylight Savings Time rules are obtained from the operating
+// system if GetTimeZoneInformation was used by _tzset() to obtain the time zone
+// information; otherwise, the USA Daylight Savings Time rules (post-1986) are
+// used.
+//
+// Returns 1 if the time is in Daylight Savings Time; returns 0 otherwise.
+extern "C" int __cdecl _isindst(tm* const tb)
+{
+    int retval = 0;
+
+    __acrt_lock(__acrt_time_lock);
+    __try
+    {
+        retval = _isindst_nolock(tb);
+    }
+    __finally
+    {
+        __acrt_unlock(__acrt_time_lock);
+    }
+
+    return retval;
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/utime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/utime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef8ea71e408a4b130fc64798fb881465c1189d30
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/utime.cpp	
@@ -0,0 +1,157 @@
+//
+// utime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The utime and futime families of functions, which set the modification time
+// for a file.
+//
+#include <corecrt_internal_lowio.h>
+#include <corecrt_internal_time.h>
+
+
+
+// Sets the modification time for a file, where 'file_name' is the name of the
+// file.  Returns zero on success; returns -1 and sets errno on failure.
+template <typename TimeType, typename Character, typename TimeBufferType>
+static int __cdecl common_utime(
+    Character const* const file_name,
+    TimeBufferType*  const times
+    ) throw()
+{
+    typedef __crt_time_traits<TimeType, Character> time_traits;
+
+    _VALIDATE_RETURN(file_name != nullptr, EINVAL, -1)
+
+    // Open the file, since the underlying system call needs a handle.  Note
+    // that the _utime definition says you must have write permission for the
+    // file to change its time, so we open the file for write only.  Also, we
+    // must force it to open in binary mode so that we don't remove ^Z's from
+    // binary files.
+    int fh;
+    if (time_traits::tsopen_s(&fh, file_name, _O_RDWR | _O_BINARY, _SH_DENYNO, 0) != 0)
+        return -1;
+
+    int const result = time_traits::futime(fh, times);
+
+    errno_t stored_errno = 0;
+    if (result == -1)
+        stored_errno = errno;
+
+    _close(fh);
+
+    if (result == -1)
+        errno = stored_errno;
+
+    return result;
+}
+
+extern "C" int __cdecl _utime32(char const* const file_name, __utimbuf32* const times)
+{
+    return common_utime<__time32_t>(file_name, times);
+}
+
+extern "C" int __cdecl _wutime32(wchar_t const* const file_name, __utimbuf32* const times)
+{
+    return common_utime<__time32_t>(file_name, times);
+}
+
+extern "C" int __cdecl _utime64(char const* const file_name, __utimbuf64* const times)
+{
+    return common_utime<__time64_t>(file_name, times);
+}
+
+extern "C" int __cdecl _wutime64(wchar_t const* const file_name, __utimbuf64* const times)
+{
+    return common_utime<__time64_t>(file_name, times);
+}
+
+
+
+// Sets the modification time for an open file, where the 'fh' is the lowio file
+// handle of the open file.  Returns zero on success; returns -1 and sets errno
+// on failure.
+template <typename TimeType, typename TimeBufferType>
+static int __cdecl common_futime(int const fh, TimeBufferType* times) throw()
+{
+    typedef __crt_time_time_t_traits<TimeType> time_traits;
+
+    _CHECK_FH_RETURN(fh, EBADF, -1);
+
+    _VALIDATE_RETURN(fh >= 0 && static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle), EBADF, -1);
+    _VALIDATE_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
+
+    TimeBufferType default_times;
+
+    if (times == nullptr)
+    {
+        time_traits::time(&default_times.modtime);
+        default_times.actime = default_times.modtime;
+        times = &default_times;
+    }
+
+    tm tm_value;
+    if (time_traits::localtime_s(&tm_value, &times->modtime) != 0)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    SYSTEMTIME local_time;
+    local_time.wYear   = static_cast<WORD>(tm_value.tm_year + 1900);
+    local_time.wMonth  = static_cast<WORD>(tm_value.tm_mon + 1);
+    local_time.wDay    = static_cast<WORD>(tm_value.tm_mday);
+    local_time.wHour   = static_cast<WORD>(tm_value.tm_hour);
+    local_time.wMinute = static_cast<WORD>(tm_value.tm_min);
+    local_time.wSecond = static_cast<WORD>(tm_value.tm_sec);
+    local_time.wMilliseconds = 0;
+
+    SYSTEMTIME system_time;
+    FILETIME last_write_time;
+    if (!TzSpecificLocalTimeToSystemTime(nullptr, &local_time, &system_time) ||
+        !SystemTimeToFileTime(&system_time, &last_write_time))
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (time_traits::localtime_s(&tm_value, &times->actime) != 0)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    local_time.wYear   = static_cast<WORD>(tm_value.tm_year + 1900);
+    local_time.wMonth  = static_cast<WORD>(tm_value.tm_mon + 1);
+    local_time.wDay    = static_cast<WORD>(tm_value.tm_mday);
+    local_time.wHour   = static_cast<WORD>(tm_value.tm_hour);
+    local_time.wMinute = static_cast<WORD>(tm_value.tm_min);
+    local_time.wSecond = static_cast<WORD>(tm_value.tm_sec);
+    local_time.wMilliseconds = 0;
+
+    FILETIME last_access_time;
+    if (!TzSpecificLocalTimeToSystemTime(nullptr, &local_time, &system_time) ||
+        !SystemTimeToFileTime(&system_time, &last_access_time))
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (!SetFileTime(reinterpret_cast<HANDLE>(_get_osfhandle(fh)), nullptr, &last_access_time, &last_write_time))
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    return 0;
+}
+
+extern "C" int __cdecl _futime32(int const fh, __utimbuf32* const times)
+{
+    return common_futime<__time32_t>(fh, times);
+}
+
+extern "C" int __cdecl _futime64(int const fh, __utimbuf64* const times)
+{
+    return common_futime<__time64_t>(fh, times);
+}
diff --git a/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/wcsftime.cpp b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/wcsftime.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..059692b2ef024b7088e568dbf05f84cfe77cee87
--- /dev/null
+++ b/msvc/Windows Kits/10/Source/10.0.26100.0/ucrt/time/wcsftime.cpp	
@@ -0,0 +1,1207 @@
+//
+// wcsftime.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The wcsftime family of functions, which format time data into a wide string,
+// and related functionality.
+//
+#include <corecrt_internal_time.h>
+#include <stdlib.h>
+#include <locale.h>
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Day and Month Name and Time Locale Information Fetching Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+extern "C" wchar_t* __cdecl _W_Getdays()
+{
+    _LocaleUpdate locale_update(nullptr);
+    __crt_lc_time_data const* const time_data = locale_update.GetLocaleT()->locinfo->lc_time_curr;
+
+    size_t length = 0;
+    for (size_t n = 0; n < 7; ++n)
+    {
+        length += wcslen(time_data->_W_wday_abbr[n]) + wcslen(time_data->_W_wday[n]) + 2;
+    }
+
+    __crt_unique_heap_ptr<wchar_t> buffer(_malloc_crt_t(wchar_t, length + 1));
+    if (buffer.get() == nullptr)
+        return nullptr;
+
+    wchar_t* it = buffer.get();
+    for (size_t n = 0; n < 7; ++n)
+    {
+        *it++ = L':';
+        _ERRCHECK(wcscpy_s(it, (length + 1) - (it - buffer.get()), time_data->_W_wday_abbr[n]));
+        it += wcslen(it);
+        *it++ = L':';
+        _ERRCHECK(wcscpy_s(it, (length + 1) - (it - buffer.get()), time_data->_W_wday[n]));
+        it += wcslen(it);
+    }
+    *it++ = L'\0';
+
+    return buffer.detach();
+}
+
+
+
+extern "C" wchar_t* __cdecl _W_Getmonths()
+{
+    _LocaleUpdate locale_update(nullptr);
+    __crt_lc_time_data const* const time_data = locale_update.GetLocaleT()->locinfo->lc_time_curr;
+
+    size_t length = 0;
+    for (size_t n = 0; n < 12; ++n)
+    {
+        length += wcslen(time_data->_W_month_abbr[n]) + wcslen(time_data->_W_month[n]) + 2;
+    }
+
+    __crt_unique_heap_ptr<wchar_t> buffer(_malloc_crt_t(wchar_t, length + 1));
+    if (buffer.get() == nullptr)
+        return nullptr;
+
+    wchar_t* it = buffer.get();
+    for (size_t n = 0; n < 12; ++n)
+    {
+        *it++ = L':';
+        _ERRCHECK(wcscpy_s(it, (length + 1) - (it - buffer.get()), time_data->_W_month_abbr[n]));
+        it += wcslen(it);
+        *it++ = L':';
+        _ERRCHECK(wcscpy_s(it, (length + 1) - (it - buffer.get()), time_data->_W_month[n]));
+        it += wcslen(it);
+    }
+    *it++ = L'\0';
+
+    return buffer.detach();
+}
+
+
+
+extern "C" void* __cdecl _W_Gettnames()
+{
+    _LocaleUpdate locale_update(nullptr);
+    __crt_lc_time_data const* const src = locale_update.GetLocaleT()->locinfo->lc_time_curr;
+
+
+
+    #define PROCESS_STRING(STR, CHAR, CPY, LEN)                                        \
+        while (bytes % sizeof(CHAR) != 0)                                              \
+        {                                                                              \
+            ++bytes;                                                                   \
+        }                                                                              \
+        if (phase == 1)                                                                \
+        {                                                                              \
+            dest->STR = ((CHAR *) dest) + bytes / sizeof(CHAR);                        \
+            _ERRCHECK(CPY(dest->STR, (total_bytes - bytes) / sizeof(CHAR), src->STR)); \
+        }                                                                              \
+        bytes += (LEN(src->STR) + 1) * sizeof(CHAR);
+
+    #define PROCESS_NARROW_STRING(STR) \
+        PROCESS_STRING(STR, char, strcpy_s, strlen)
+
+    #define PROCESS_WIDE_STRING(STR) \
+        PROCESS_STRING(STR, wchar_t, wcscpy_s, wcslen)
+
+    #define PROCESS_NARROW_ARRAY(ARR)                           \
+        for (size_t idx = 0; idx < _countof(src->ARR); ++idx)   \
+        {                                                       \
+            PROCESS_NARROW_STRING(ARR[idx])                     \
+        }
+
+    #define PROCESS_WIDE_ARRAY(ARR)                             \
+        for (size_t idx = 0; idx < _countof(src->ARR); ++idx)   \
+        {                                                       \
+            PROCESS_WIDE_STRING(ARR[idx])                       \
+        }
+
+
+    size_t total_bytes = 0;
+    size_t bytes       = sizeof(__crt_lc_time_data);
+
+    __crt_lc_time_data* dest  = nullptr;
+    for (int phase = 0; phase < 2; ++phase)
+    {
+        if (phase == 1)
+        {
+            dest = static_cast<__crt_lc_time_data*>(_malloc_crt(bytes));
+
+            if (!dest) {
+                return nullptr;
+            }
+
+            memset(dest, 0, bytes);
+
+            total_bytes = bytes;
+
+            bytes = sizeof(__crt_lc_time_data);
+        }
+
+        PROCESS_NARROW_ARRAY(wday_abbr)
+        PROCESS_NARROW_ARRAY(wday)
+        PROCESS_NARROW_ARRAY(month_abbr)
+        PROCESS_NARROW_ARRAY(month)
+        PROCESS_NARROW_ARRAY(ampm)
+        PROCESS_NARROW_STRING(ww_sdatefmt)
+        PROCESS_NARROW_STRING(ww_ldatefmt)
+        PROCESS_NARROW_STRING(ww_timefmt)
+
+        if (phase == 1)
+        {
+            dest->ww_caltype = src->ww_caltype;
+            dest->refcount = 0;
+        }
+
+        PROCESS_WIDE_ARRAY(_W_wday_abbr)
+        PROCESS_WIDE_ARRAY(_W_wday)
+        PROCESS_WIDE_ARRAY(_W_month_abbr)
+        PROCESS_WIDE_ARRAY(_W_month)
+        PROCESS_WIDE_ARRAY(_W_ampm)
+        PROCESS_WIDE_STRING(_W_ww_sdatefmt)
+        PROCESS_WIDE_STRING(_W_ww_ldatefmt)
+        PROCESS_WIDE_STRING(_W_ww_timefmt)
+        PROCESS_WIDE_STRING(_W_ww_locale_name)
+    }
+
+    return dest;
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Local Functions Used In Time String Formatting
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Values for __crt_lc_time_data ww_* fields for store_winword:
+#define WW_SDATEFMT 0
+#define WW_LDATEFMT 1
+#define WW_TIMEFMT  2
+
+// Note: annotation does not account for fact < *count bytes may be written if null terminator hit
+#define _CrtWcstime_Writes_and_advances_ptr_(count) \
+    _Outptr_result_buffer_(count)
+
+
+// Copies the supplied time string 'in' into the output buffer 'out' until either
+// (a) the end of the time string is reached or (b) '*count' becomes zero (and we
+// run out of buffer space).  The '*out' pointer is updated to point to the next
+// character in the buffer (one-past-the-end of the insertion), and the '*count'
+// value is updated to reflect the number of characters written.
+static void __cdecl store_string(
+    _In_reads_or_z_(*count)                      wchar_t const*       in,
+    _CrtWcstime_Writes_and_advances_ptr_(*count) wchar_t**      const out,
+    _Inout_                                      size_t*        const count
+    ) throw()
+{
+    while (*count != 0 && *in != L'\0')
+    {
+        *(*out)++ = *in++;
+        --*count;
+    }
+}
+
+
+
+// Converts a positive integer ('value') into a string and stores it in the
+// 'output' buffer.  It stops writing when either (a) the full value has been
+// printed, or (b) '*count' becomes zero (and we run out of buffer space).   The
+// '*out' pointer is updated to point to the next character in the buffer (one-
+// past-the-end of the insertion), and the '*count' value is updated to reflect
+// the number of characters written.
+static void __cdecl store_number_without_lead_zeroes(
+                                                 int             value,
+    _CrtWcstime_Writes_and_advances_ptr_(*count) wchar_t** const out,
+    _Inout_                                      size_t*   const count
+    ) throw()
+{
+    // Put the digits in the buffer in reverse order:
+    wchar_t* out_it = *out;
+    if (*count > 1)
+    {
+        do
+        {
+            *out_it++ = static_cast<wchar_t>(value % 10 + L'0');
+
+            value /= 10;
+            --*count;
+        }
+        while (value > 0 && *count > 1);
+    }
+    else
+    {
+        // Indicate buffer too small.
+        *out -= *count;
+        *count = 0;
+        return;
+    }
+
+    wchar_t* left  = *out;
+    wchar_t* right = out_it - 1;
+
+    // Update the output iterator to point to the next space:
+    *out = out_it;
+
+    // Reverse the buffer:
+    while (left < right)
+    {
+        wchar_t const x = *right;
+        *right-- = *left;
+        *left++  = x;
+    }
+}
+
+
+
+// Converts a positive integer ('value') into a string and stores it in the
+// 'output' buffer.  Both '*out' and '*count' are updated to reflect the
+// write.
+static void __cdecl store_number(
+                                                 int             value,
+                                                 int             digits,
+    _CrtWcstime_Writes_and_advances_ptr_(*count) wchar_t** const out,
+    _Inout_                                      size_t*   const count,
+                                                 wchar_t   const pad_character
+    ) throw()
+{
+    if (pad_character == '\0')
+    {
+        store_number_without_lead_zeroes(value, out, count);
+        return;
+    }
+
+    if (static_cast<size_t>(digits) < *count)
+    {
+        int temp = 0;
+        for (digits--; digits + 1 != 0; --digits)
+        {
+            if (value != 0)
+            {
+                (*out)[digits] = static_cast<wchar_t>(L'0' + value % 10);
+            }
+            else
+            {
+                (*out)[digits] = pad_character;
+            }
+
+            value /= 10;
+            temp++;
+        }
+
+        *out   += temp;
+        *count -= temp;
+    }
+    else
+    {
+        *count = 0;
+    }
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Local Functions Used for ISO Week-Based Year Computations
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+enum
+{
+    sunday    = 0,
+    monday    = 1,
+    tuesday   = 2,
+    wednesday = 3,
+    thursday  = 4,
+    friday    = 5,
+    saturday  = 6
+};
+
+static int compute_week_of_year(int const wstart, int const wday, int const yday) throw()
+{
+    int const adjusted_wday{(wday + 7 - wstart) % 7};
+    return (yday + 7 - adjusted_wday) / 7;
+}
+
+static int __cdecl compute_iso_week_internal(int year, int wday, int yday) throw()
+{
+    int  const week_number{compute_week_of_year(monday, wday, yday)};
+    bool const is_leap_year{__crt_time_is_leap_year(year)};
+
+    int const yunleap{yday - is_leap_year};
+    int const jan1{(371 - yday + wday) % 7};
+    int const dec32{(jan1 + is_leap_year + 365) % 7};
+
+    if ((364 <= yunleap && dec32 == tuesday  ) ||
+        (363 <= yunleap && dec32 == wednesday) ||
+        (362 <= yunleap && dec32 == thursday ))
+    {
+        return -1; // Push into the next year
+    }
+    else if (jan1 == tuesday || jan1 == wednesday || jan1 == thursday)
+    {
+        return week_number + 1;
+    }
+
+    return week_number;
+}
+
+static int __cdecl compute_iso_week(int const year, int const wday, int const yday) throw()
+{
+    int const week_number{compute_iso_week_internal(year, wday, yday)};
+
+    if (week_number == 0)
+        return compute_iso_week_internal(year - 1, wday + 7 - yday, __crt_time_is_leap_year(year - 1) ? 366 : 365);
+
+    if (0 < week_number)
+        return week_number;
+
+    return 1;
+}
+
+static int __cdecl compute_iso_year(int const year, int const wday, int const yday) throw()
+{
+    int const week_number{compute_iso_week_internal(year, wday, yday)};
+
+    if (week_number == 0)
+        return year - 1;
+
+    if (0 < week_number)
+        return year;
+
+    return year + 1;
+}
+
+
+
+// store_winword and expand_time are mutually recursive
+_Success_(return)
+static bool __cdecl expand_time(
+                                                 _locale_t                 locale,
+                                                 wchar_t                   specifier,
+                                                 tm const*                 tmptr,
+    _CrtWcstime_Writes_and_advances_ptr_(*count) wchar_t**                 out,
+    _Inout_                                      size_t*                   count,
+                                                 __crt_lc_time_data const* lc_time,
+                                                 bool                      alternate_form
+    ) throw();
+
+
+
+// Formats the date and time in the supplied WinWord format and stores the
+// formatted result in the supplied buffer.  For simple localized Gregorian
+// calendars (calendar type 1), the WinWord format is converted token-by-token
+// to wcsftime conversion specifiers.  expand_time is then called to do the
+// heavy lifting.  For other calendar types, the Windows APIs GetDateFormatEx
+// and GetTimeFormatEx are instead used to do all the formatting, so this
+// function does not need to know about era and period strings, year offsets,
+// etc.  Returns true on success; false on failure.
+_Success_(return)
+static bool __cdecl store_winword(
+                                                 _locale_t                 const locale,
+                                                 int                       const field_code,
+                                                 tm const*                 const tmptr,
+    _CrtWcstime_Writes_and_advances_ptr_(*count) wchar_t**                 const out,
+    _Inout_                                      size_t*                   const count,
+                                                 __crt_lc_time_data const* const lc_time
+    ) throw()
+{
+    wchar_t const* format;
+    switch (field_code)
+    {
+    case WW_SDATEFMT:
+        format = lc_time->_W_ww_sdatefmt;
+        break;
+
+    case WW_LDATEFMT:
+        format = lc_time->_W_ww_ldatefmt;
+        break;
+
+    case WW_TIMEFMT:
+    default:
+        format = lc_time->_W_ww_timefmt;
+        break;
+    }
+
+    if (lc_time->ww_caltype != 1)
+    {
+        // We have something other than the basic Gregorian calendar
+        bool const is_time_format = field_code == WW_TIMEFMT;
+
+        // We leave the verification of the SYSTEMTIME up to the Windows API
+        // that we call; if one of those functions returns zero to indicate
+        // failure, we fall through and call expand_time() again.
+        SYSTEMTIME system_time;
+        system_time.wYear   = static_cast<WORD>(tmptr->tm_year + 1900);
+        system_time.wMonth  = static_cast<WORD>(tmptr->tm_mon + 1);
+        system_time.wDay    = static_cast<WORD>(tmptr->tm_mday);
+        system_time.wHour   = static_cast<WORD>(tmptr->tm_hour);
+        system_time.wMinute = static_cast<WORD>(tmptr->tm_min);
+        system_time.wSecond = static_cast<WORD>(tmptr->tm_sec);
+        system_time.wMilliseconds = 0;
+
+        // Find buffer size required:
+        int cch;
+        if (is_time_format)
+            cch = __acrt_GetTimeFormatEx(lc_time->_W_ww_locale_name, 0, &system_time, format, nullptr, 0);
+        else
+            cch = __acrt_GetDateFormatEx(lc_time->_W_ww_locale_name, 0, &system_time, format, nullptr, 0, nullptr);
+
+        if (cch != 0)
+        {
+            __crt_scoped_stack_ptr<wchar_t> const buffer(_malloca_crt_t(wchar_t, cch));
+            if (buffer.get() != nullptr)
+            {
+                // Do actual date/time formatting:
+                if (is_time_format)
+                    cch = __acrt_GetTimeFormatEx(lc_time->_W_ww_locale_name, 0, &system_time, format, buffer.get(), cch);
+                else
+                    cch = __acrt_GetDateFormatEx(lc_time->_W_ww_locale_name, 0, &system_time, format, buffer.get(), cch, nullptr);
+
+                // Copy to output buffer:
+                wchar_t const* buffer_it = buffer.get();
+                while (--cch > 0 && *count > 0)
+                {
+                    *(*out)++ = *buffer_it++;
+                    (*count)--;
+                }
+
+                return true;
+            }
+        }
+
+        // If an error occurs, just fall through to localized Gregorian...
+    }
+
+    while (*format && *count != 0)
+    {
+        wchar_t specifier = 0;
+        bool no_lead_zeros = false;
+
+        // Count the number of repetitions of this character
+        int repeat = 0;
+        wchar_t const* p = format;
+        for (; *p++ == *format; ++repeat);
+            // Leave p pointing to the beginning of the next token
+            p--;
+
+        // Switch on ASCII format character and determine specifier:
+        switch (*format)
+        {
+        case L'M':
+        {
+            switch (repeat)
+            {
+            case 1: no_lead_zeros = true; // fall through
+            case 2: specifier = L'm'; break;
+            case 3: specifier = L'b'; break;
+            case 4: specifier = L'B'; break;
+            }
+            break;
+        }
+
+        case L'd':
+        {
+            switch (repeat)
+            {
+            case 1: no_lead_zeros = true; // fall through
+            case 2: specifier = L'd'; break;
+            case 3: specifier = L'a'; break;
+            case 4: specifier = L'A'; break;
+            }
+            break;
+        }
+
+        case L'y':
+        {
+            switch (repeat)
+            {
+            case 2: specifier = L'y'; break;
+            case 4: specifier = L'Y'; break;
+            }
+            break;
+        }
+
+        case L'h':
+        {
+            switch (repeat)
+            {
+            case 1: no_lead_zeros = true; // fall through
+            case 2: specifier = L'I'; break;
+            }
+            break;
+        }
+
+        case L'H':
+        {
+            switch (repeat)
+            {
+            case 1: no_lead_zeros = true; // fall through
+            case 2: specifier = L'H'; break;
+            }
+            break;
+        }
+
+        case L'm':
+        {
+            switch (repeat)
+            {
+            case 1: no_lead_zeros = true; // fall through
+            case 2: specifier = L'M'; break;
+            }
+            break;
+        }
+
+        case L's': // for compatibility; not strictly WinWord
+        {
+            switch (repeat)
+            {
+            case 1: no_lead_zeros = true; // fall through
+            case 2: specifier = L'S'; break;
+            }
+            break;
+        }
+
+        case L'A':
+        case L'a':
+        {
+            if (!_wcsicmp(format, L"am/pm"))
+            {
+                p = format + 5;
+            }
+            else if (!_wcsicmp(format, L"a/p"))
+            {
+                p = format + 3;
+            }
+
+            specifier = L'p';
+            break;
+        }
+
+        case L't': // t or tt time marker suffix
+        {
+            wchar_t* ampmstr = tmptr->tm_hour <= 11
+                ? lc_time->_W_ampm[0]
+                : lc_time->_W_ampm[1];
+
+            if (repeat == 1 && *count > 0)
+            {
+                *(*out)++ = *ampmstr++;
+                (*count)--;
+            }
+            else
+            {
+                while (*ampmstr != 0 && *count > 0)
+                {
+                    *(*out)++ = *ampmstr++;
+                    --*count;
+                }
+            }
+            format = p;
+            continue;
+        }
+
+        case L'\'': // literal string
+        {
+            if (repeat % 2 == 0) // even number
+            {
+                format += repeat;
+            }
+            else // odd number
+            {
+                format += repeat;
+                while (*format && *count != 0)
+                {
+                    if (*format == L'\'')
+                    {
+                        format++;
+                        break;
+                    }
+
+                    *(*out)++ = *format++;
+                    --*count;
+                }
+            }
+
+            continue;
+        }
+
+        default: // non-control char, print it
+        {
+            break;
+        }
+        }
+
+        // expand specifier, or copy literal if specifier not found
+        if (specifier)
+        {
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, specifier, tmptr, out, count, lc_time, no_lead_zeros), EINVAL, false);
+
+            format = p; // bump format up to the next token
+        }
+        else
+        {
+            *(*out)++ = *format++;
+            --*count;
+        }
+    }
+
+    return true;
+}
+
+
+
+// Expands the conversion specifier using the time struct and stores the result
+// into the supplied buffer.  The expansion is locale-dependent.  Returns true
+// on success; false on failure.
+static bool __cdecl expand_time(
+    _locale_t                 const locale,
+    wchar_t                   const specifier,
+    tm const*                 const timeptr,
+    wchar_t**                 const string,
+    size_t*                   const left,
+    __crt_lc_time_data const* const lc_time,
+    bool                      const alternate_form
+    ) throw()
+{
+    switch (specifier)
+    {
+    case L'a': // abbreviated weekday name
+    {
+        _VALIDATE_RETURN(timeptr->tm_wday >= 0 && timeptr->tm_wday <= 6, EINVAL, false);
+        store_string(lc_time->_W_wday_abbr[timeptr->tm_wday], string, left);
+        return true;
+    }
+
+    case L'A': // full weekday name
+    {
+        _VALIDATE_RETURN(timeptr->tm_wday >= 0 && timeptr->tm_wday <= 6, EINVAL, false);
+        store_string(lc_time->_W_wday[timeptr->tm_wday], string, left);
+        return true;
+    }
+
+    case L'b': // abbreviated month name
+    {
+        _VALIDATE_RETURN(timeptr->tm_mon >= 0 && timeptr->tm_mon <= 11, EINVAL, false);
+        store_string(lc_time->_W_month_abbr[timeptr->tm_mon], string, left);
+        return true;
+    }
+
+    case L'B': // full month name
+    {
+        _VALIDATE_RETURN(timeptr->tm_mon >= 0 && timeptr->tm_mon <= 11, EINVAL, false);
+        store_string(lc_time->_W_month[timeptr->tm_mon], string, left);
+        return true;
+    }
+
+    case L'c': // appropriate date and time representation
+    {
+        // In the C locale, %c is equivalent to "%a %b %e %T %Y".  This format
+        // is not achievable using the Windows API date and time format APIs
+        // (it's hard to interleave date and time together, and there's no way
+        // to format %e).  Therefore, we special case this specifier for the C
+        // locale.
+        if (lc_time == &__lc_time_c && !alternate_form)
+        {
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, L'a', timeptr, string, left, lc_time, false), EINVAL, false);
+            store_string(L" ", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, L'b', timeptr, string, left, lc_time, false), EINVAL, false);
+            store_string(L" ", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, L'e', timeptr, string, left, lc_time, false), EINVAL, false);
+            store_string(L" ", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, L'T', timeptr, string, left, lc_time, false), EINVAL, false);
+            store_string(L" ", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, L'Y', timeptr, string, left, lc_time, false), EINVAL, false);
+        }
+        // Otherwise, if we're not in the C locale, use the locale-provided
+        // format strings:
+        else
+        {
+            int const field_code = alternate_form ? WW_LDATEFMT : WW_SDATEFMT;
+
+            _VALIDATE_RETURN_NOEXC(store_winword(locale, field_code, timeptr, string, left, lc_time), EINVAL, false);
+            store_string(L" ", string, left);
+            _VALIDATE_RETURN_NOEXC(store_winword(locale, WW_TIMEFMT, timeptr, string, left, lc_time), EINVAL, false);
+        }
+
+        return true;
+    }
+
+    case L'C': // century in decimal (00-99)
+    {
+        _VALIDATE_RETURN(timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099, EINVAL, false);
+        store_number(__crt_get_century(timeptr->tm_year), 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'd': // day of the month in decimal (01-31)
+    {
+        _VALIDATE_RETURN(timeptr->tm_mday >= 1 && timeptr->tm_mday <= 31, EINVAL, false);
+        store_number(timeptr->tm_mday, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'D': // equivalent to "%m/%d/%y"
+    {
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, L'm', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L"/", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, L'd', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L"/", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, L'y', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        return true;
+    }
+
+    case L'e': // day of month as a decimal number (1-31); space padded:
+    {
+        _VALIDATE_RETURN(timeptr->tm_mday >= 1 && timeptr->tm_mday <= 31, EINVAL, false);
+        store_number(timeptr->tm_mday, 2, string, left, alternate_form ? '\0' : ' ');
+        return true;
+    }
+
+    case L'F': // equivalent to "%Y-%m-%d" (ISO 8601):
+    {
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, L'Y', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L"-", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, L'm', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L"-", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, L'd', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        return true;
+    }
+
+    case L'g': // last two digits of the week-based year:
+    {
+        _VALIDATE_RETURN(timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099, EINVAL, false);
+        int const iso_year{compute_iso_year(timeptr->tm_year, timeptr->tm_wday, timeptr->tm_yday) + 1900};
+        store_number(iso_year % 100, 2, string, left, '0');
+        return true;
+    }
+
+    case L'G': // week-based year:
+    {
+        _VALIDATE_RETURN(timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099, EINVAL, false);
+        int const iso_year{compute_iso_year(timeptr->tm_year, timeptr->tm_wday, timeptr->tm_yday) + 1900};
+        store_number(iso_year, 4, string, left, '0');
+        return true;
+    }
+
+    case L'h': // equivalent to "%b":
+    {
+        return expand_time(locale, L'b', timeptr, string, left, lc_time, alternate_form);
+    }
+
+    case L'H': // 24-hour decimal (00-23)
+    {
+        _VALIDATE_RETURN(timeptr->tm_hour >= 0 && timeptr->tm_hour <= 23, EINVAL, false);
+        store_number(timeptr->tm_hour, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'I': // 12-hour decimal (01-12)
+    {
+        _VALIDATE_RETURN(timeptr->tm_hour >= 0 && timeptr->tm_hour <= 23, EINVAL, false);
+        unsigned hour = timeptr->tm_hour % 12;
+        if (hour == 0)
+            hour = 12;
+
+        store_number(hour, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'j': // yday in decimal (001-366)
+    {
+        _VALIDATE_RETURN(timeptr->tm_yday >= 0 && timeptr->tm_yday <= 365, EINVAL, false);
+        store_number(timeptr->tm_yday + 1, 3, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'm': // month in decimal (01-12)
+    {
+        _VALIDATE_RETURN(timeptr->tm_mon >= 0 && timeptr->tm_mon <= 11, EINVAL, false);
+        store_number(timeptr->tm_mon + 1, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'M': // minute in decimal (00-59)
+    {
+        _VALIDATE_RETURN(timeptr->tm_min >= 0 && timeptr->tm_min <= 59, EINVAL, false);
+        store_number(timeptr->tm_min, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'n': // newline character
+    {
+        store_string(L"\n", string, left);
+        return true;
+    }
+
+    case L'p': // AM/PM designation
+    {
+        _VALIDATE_RETURN(timeptr->tm_hour >= 0 && timeptr->tm_hour <= 23, EINVAL, false);
+        wchar_t const* const ampm_string = timeptr->tm_hour <= 11
+            ? lc_time->_W_ampm[0]
+            : lc_time->_W_ampm[1];
+
+        store_string(ampm_string, string, left);
+        return true;
+    }
+
+    case L'r': // Locale-specific 12-hour clock time
+    {
+        // In the C locale, %r is equivalent to "%I:%M:%S %p".  This is the only
+        // locale in which we guarantee that %r is a 12-hour time; in all other
+        // locales we only have one time format which may or may not be a 12-hour
+        // format.
+        if (lc_time == &__lc_time_c)
+        {
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, 'I', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+            store_string(L":", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, 'M', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+            store_string(L":", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, 'S', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+            store_string(L" ", string, left);
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, 'p', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        }
+        else
+        {
+            _VALIDATE_RETURN_NOEXC(expand_time(locale, 'X', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        }
+
+        return true;
+    }
+
+    case L'R': // Equivalent to "%H:%M"
+    {
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, 'H', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L":", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, 'M', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        return true;
+    }
+
+    case L'S': // seconds in decimal (00-60) allowing for a leap second
+    {
+        _VALIDATE_RETURN(timeptr->tm_sec >= 0 && timeptr->tm_sec <= 60, EINVAL, false);
+        store_number(timeptr->tm_sec, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L't': // tab character
+    {
+        store_string(L"\t", string, left);
+        return true;
+    }
+
+    case L'T': // Equivalent to "%H:%M:%S" (ISO 8601)
+    {
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, 'H', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L":", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, 'M', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        store_string(L":", string, left);
+        _VALIDATE_RETURN_NOEXC(expand_time(locale, 'S', timeptr, string, left, lc_time, alternate_form), EINVAL, false);
+        return true;
+    }
+
+    case L'u': // week day in decimal (1-7)
+    case L'w': // week day in decimal (0-6)
+    {
+        _VALIDATE_RETURN(timeptr->tm_wday >= 0 && timeptr->tm_wday <= 6, EINVAL, false);
+
+        int const weekday_number = timeptr->tm_wday == 0 && specifier == L'u'
+            ? 7
+            : timeptr->tm_wday;
+
+        store_number(weekday_number, 1, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'U': // sunday week number (00-53)
+    case L'W': // monday week number (00-53)
+    {
+        _VALIDATE_RETURN(timeptr->tm_wday >= 0 && timeptr->tm_wday <= 6, EINVAL, false);
+        int wdaytemp = timeptr->tm_wday;
+        if (specifier == L'W')
+        {
+            if (timeptr->tm_wday == 0) // Monday-based
+                wdaytemp = 6;
+            else
+                wdaytemp = timeptr->tm_wday - 1;
+        }
+
+        _VALIDATE_RETURN(timeptr->tm_yday >= 0 && timeptr->tm_yday <= 365, EINVAL, false);
+        unsigned week_number = 0;
+        if (timeptr->tm_yday >= wdaytemp)
+        {
+            week_number = timeptr->tm_yday / 7;
+            if (timeptr->tm_yday % 7 >= wdaytemp)
+                ++week_number;
+        }
+
+        store_number(week_number, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'V': // ISO 8601 week number (01-53):
+    {
+        int const iso_week{compute_iso_week(timeptr->tm_year, timeptr->tm_wday, timeptr->tm_yday)};
+        store_number(iso_week, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'x': // date display
+    {
+        int const field_code = alternate_form ? WW_LDATEFMT : WW_SDATEFMT;
+        _VALIDATE_RETURN_NOEXC(store_winword(locale, field_code, timeptr, string, left, lc_time), EINVAL, false);
+        return true;
+    }
+    case L'X': // time display
+    {
+        _VALIDATE_RETURN_NOEXC(store_winword(locale, WW_TIMEFMT, timeptr, string, left, lc_time), EINVAL, false);
+        return true;
+    }
+
+    case L'y': // year without century (00-99)
+    {
+        _VALIDATE_RETURN(timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099, EINVAL, false);
+        unsigned const two_digit_year = __crt_get_2digit_year(timeptr->tm_year);
+        store_number(two_digit_year, 2, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'Y': // year with century
+    {
+        _VALIDATE_RETURN(timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099, EINVAL, false);
+        unsigned const full_year = timeptr->tm_year + 1900;
+
+        store_number(full_year, 4, string, left, alternate_form ? '\0' : '0');
+        return true;
+    }
+
+    case L'z': // time zone in ISO 8601 form ("-0430" = 4 hours 30 minutes)
+    {
+        __tzset();
+
+        // Get the current time zone offset from UTC and, if we are currently in
+        // daylight savings time, adjust appropriately:
+        long offset{};
+        _VALIDATE_RETURN(_get_timezone(&offset) == 0, EINVAL, false);
+
+        if (timeptr->tm_isdst)
+        {
+            long dst_bias{};
+            _VALIDATE_RETURN(_get_dstbias(&dst_bias) == 0, EINVAL, false);
+
+            offset += dst_bias;
+        }
+
+        long const positive_offset{offset < 0 ? -offset : offset};
+        long const hours_offset  {(positive_offset / 60) / 60};
+        long const minutes_offset{(positive_offset / 60) % 60};
+
+        // This looks wrong, but it is correct:  The offset is the difference
+        // between UTC and the local time zone, so it is a positive value if
+        // the local time zone is behind UTC.
+        wchar_t const* const sign_string{offset <= 0 ? L"+" : L"-"};
+
+        store_string(sign_string, string, left);
+        store_number(hours_offset,   2, string, left, '0');
+        store_number(minutes_offset, 2, string, left, '0');
+        return true;
+    }
+
+    case L'Z': // time zone name, if any
+    {
+        __tzset();
+        store_string(__wide_tzname()[timeptr->tm_isdst ? 1 : 0], string, left);
+        return true;
+    }
+
+    case L'%': // percent sign
+    {
+        store_string(L"%", string, left);
+        return true;
+    }
+
+    default: // unknown format directive
+    {
+        // We do not raise the invalid parameter handler here.  Our caller will
+        // raise the invalid parameter handler when we return failure.
+        return false;
+    }
+    }
+
+    // Unreachable.  All switch case statements return.
+}
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The _wcsftime family of functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// These functions format a time as a string using a given locale.  They place
+// characters into the user's output buffer, expanding time format directives as
+// described in the provided control string.  The lc_time_arg and locale are
+// used for locale data.
+//
+// If the total number of characters that need to be written (including the null
+// terminator) is less than the max_size, then the number of characters written
+// (not including the null terminator) is returned.  Otherwise, zero is returned.
+extern "C" size_t __cdecl _Wcsftime_l(
+    wchar_t*       const string,
+    size_t         const max_size,
+    wchar_t const* const format,
+    tm const*      const timeptr,
+    void*          const lc_time_arg,
+    _locale_t      const locale
+    )
+{
+    _VALIDATE_RETURN(string != nullptr, EINVAL, 0)
+    _VALIDATE_RETURN(max_size != 0,     EINVAL, 0)
+    *string = L'\0';
+
+    _VALIDATE_RETURN(format != nullptr, EINVAL, 0)
+
+    _LocaleUpdate locale_update(locale);
+
+    __crt_lc_time_data const* const lc_time = lc_time_arg == 0
+        ? locale_update.GetLocaleT()->locinfo->lc_time_curr
+        : static_cast<__crt_lc_time_data*>(lc_time_arg);
+
+    // Copy the input string to the output string expanding the format
+    // designations appropriately.  Stop copying when one of the following
+    // is true: (1) we hit a null char in the input stream, or (2) there's
+    // no room left in the output stream.
+
+    wchar_t*       string_it = string;
+    wchar_t const* format_it = format;
+
+    bool failed = false;
+    size_t remaining = max_size;
+
+    while (remaining > 0)
+    {
+        switch (*format_it)
+        {
+        case L'\0':
+        {
+            // End of format input string
+            goto done;
+        }
+
+        case L'%':
+        {
+            // Format directive.  Take appropriate action based on format control character.
+            _VALIDATE_RETURN(timeptr != nullptr, EINVAL, 0);
+
+            ++format_it; // Skip '%'
+
+            // Process flags:
+            bool alternate_form = false;
+            if (*format_it == L'#')
+            {
+                alternate_form = true;
+                ++format_it;
+            }
+
+            // Skip ISO E and O alternative representation format modifiers.  We
+            // do not support alternative formats in any locale.
+            if (*format_it == L'E' || *format_it == L'O')
+            {
+                ++format_it;
+            }
+
+            if (!expand_time(locale_update.GetLocaleT(), *format_it, timeptr, &string_it, &remaining, lc_time, alternate_form))
+            {
+                // if we don't have any space left, do not set the failure flag:
+                // we will simply return ERANGE and do not call the invalid
+                // parameter handler (see below)
+                if (remaining > 0)
+                    failed = true;
+
+                goto done;
+            }
+
+            ++format_it; // Skip format char
+            break;
+        }
+
+        default:
+        {
+            // store character, bump pointers, decrement the char count:
+            *string_it++ = *format_it++;
+            --remaining;
+            break;
+        }
+        }
+    }
+
+
+    // All done.  See if we terminated because we hit a null char or because
+    // we ran out of space:
+    done:
+
+    if (!failed && remaining > 0)
+    {
+        // Store a terminating null char and return the number of chars we
+        // stored in the output string:
+        *string_it = L'\0';
+        return max_size - remaining;
+    }
+    else
+    {
+        // Error:  return an empty string:
+        *string = L'\0';
+
+        // Now return our error/insufficient buffer indication:
+        if (!failed && remaining <= 0)
+        {
+            // Do not report this as an error to allow the caller to resize:
+            errno = ERANGE;
+        }
+        else
+        {
+            _VALIDATE_RETURN(false, EINVAL, 0);
+        }
+
+        return 0;
+    }
+}
+
+extern "C" size_t __cdecl _Wcsftime(
+    wchar_t*       const buffer,
+    size_t         const max_size,
+    wchar_t const* const format,
+    tm const*      const timeptr,
+    void*          const lc_time_arg
+    )
+{
+    return _Wcsftime_l(buffer, max_size, format, timeptr, lc_time_arg, nullptr);
+}
+
+extern "C" size_t __cdecl _wcsftime_l(
+    wchar_t*       const buffer,
+    size_t         const max_size,
+    wchar_t const* const format,
+    tm const*      const timeptr,
+    _locale_t      const locale
+    )
+{
+    return _Wcsftime_l(buffer, max_size, format, timeptr, nullptr, locale);
+}
+
+extern "C" size_t __cdecl wcsftime(
+    wchar_t*       const buffer,
+    size_t         const max_size,
+    wchar_t const* const format,
+    tm const*      const timeptr
+    )
+{
+    return _Wcsftime_l(buffer, max_size, format, timeptr, nullptr, nullptr);
+}
+
+
+
+/*
+ * Copyright (c) 1992-2013 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+V6.40:0009 */
diff --git a/node/node_modules/npm/bin/node-gyp-bin/node-gyp b/node/node_modules/npm/bin/node-gyp-bin/node-gyp
new file mode 100644
index 0000000000000000000000000000000000000000..640ac1a85ad19b6ca2b187a2490be56e9aa96f90
--- /dev/null
+++ b/node/node_modules/npm/bin/node-gyp-bin/node-gyp
@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+if [ "x$npm_config_node_gyp" = "x" ]; then
+  node "`dirname "$0"`/../../node_modules/node-gyp/bin/node-gyp.js" "$@"
+else
+  "$npm_config_node_gyp" "$@"
+fi
diff --git a/node/node_modules/npm/bin/node-gyp-bin/node-gyp.cmd b/node/node_modules/npm/bin/node-gyp-bin/node-gyp.cmd
new file mode 100644
index 0000000000000000000000000000000000000000..6816e5bfe44324c3defca536f01b6e8aa3052473
--- /dev/null
+++ b/node/node_modules/npm/bin/node-gyp-bin/node-gyp.cmd
@@ -0,0 +1,5 @@
+if not defined npm_config_node_gyp (
+  node "%~dp0\..\..\node_modules\node-gyp\bin\node-gyp.js" %*
+) else (
+  node "%npm_config_node_gyp%" %*
+)
diff --git a/node/node_modules/npm/docs/content/commands/npm-access.md b/node/node_modules/npm/docs/content/commands/npm-access.md
new file mode 100644
index 0000000000000000000000000000000000000000..08baad7c24a90d3dbd69e11cbd4bcbfc79558ca8
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-access.md
@@ -0,0 +1,95 @@
+---
+title: npm-access
+section: 1
+description: Set access level on published packages
+---
+
+### Synopsis
+
+```bash
+npm access list packages [<user>|<scope>|<scope:team>] [<package>]
+npm access list collaborators [<package> [<user>]]
+npm access get status [<package>]
+npm access set status=public|private [<package>]
+npm access set mfa=none|publish|automation [<package>]
+npm access grant <read-only|read-write> <scope:team> [<package>]
+npm access revoke <scope:team> [<package>]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Used to set access controls on private packages.
+
+For all of the subcommands, `npm access` will perform actions on the packages in the current working directory if no package name is passed to the subcommand.
+
+* grant / revoke:
+  Add or remove the ability of users and teams to have read-only or read-write access to a package.
+
+### Details
+
+`npm access` always operates directly on the current registry, configurable from the command line using `--registry=<registry url>`.
+
+Unscoped packages are *always public*.
+
+Scoped packages *default to restricted*, but you can either publish them as public using `npm publish --access=public`, or set their access as public using `npm access set status=public` after the initial publish.
+
+You must have privileges to set the access of a package:
+
+* You are an owner of an unscoped or scoped package.
+* You are a member of the team that owns a scope.
+* You have been given read-write privileges for a package, either as a member of a team or directly as an owner.
+
+If you have two-factor authentication enabled then you'll be prompted to provide a second factor, or may use the `--otp=...` option to specify it on the command line.
+
+If your account is not paid, then attempts to publish scoped packages will fail with an HTTP 402 status code (logically enough), unless you use
+`--access=public`.
+
+Management of teams and team memberships is done with the `npm team` command.
+
+### Configuration
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+### See Also
+
+* [`libnpmaccess`](https://npm.im/libnpmaccess)
+* [npm team](/commands/npm-team)
+* [npm publish](/commands/npm-publish)
+* [npm config](/commands/npm-config)
+* [npm registry](/using-npm/registry)
diff --git a/node/node_modules/npm/docs/content/commands/npm-adduser.md b/node/node_modules/npm/docs/content/commands/npm-adduser.md
new file mode 100644
index 0000000000000000000000000000000000000000..158406fd6149270d99642a8a41b59f6221c22ac9
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-adduser.md
@@ -0,0 +1,87 @@
+---
+title: npm-adduser
+section: 1
+description: Add a registry user account
+---
+
+### Synopsis
+
+```bash
+npm adduser
+
+alias: add-user
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Create a new user in the specified registry, and save the credentials to the `.npmrc` file.
+If no registry is specified, the default registry will be used (see [`registry`](/using-npm/registry)).
+
+When you run `npm adduser`, the CLI automatically generates a legacy token of `publish` type.
+For more information, see [About legacy tokens](/about-access-tokens#about-legacy-tokens).
+
+When using `legacy` for your `auth-type`, the username, password, and email are read in from prompts.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `scope`
+
+* Default: the scope of the current project, if any, or ""
+* Type: String
+
+Associate an operation with a scope for a scoped registry.
+
+Useful when logging in to or out of a private registry:
+
+```
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+```
+
+This will cause `@mycorp` to be mapped to the registry for future
+installation of packages specified according to the pattern
+`@mycorp/package`.
+
+This will also cause `npm init` to create a scoped package.
+
+```
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+```
+
+
+
+#### `auth-type`
+
+* Default: "web"
+* Type: "legacy" or "web"
+
+What authentication strategy to use with `login`. Note that if an `otp`
+config is given, this value will always be set to `legacy`.
+
+
+
+### See Also
+
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm owner](/commands/npm-owner)
+* [npm whoami](/commands/npm-whoami)
+* [npm token](/commands/npm-token)
+* [npm profile](/commands/npm-profile)
diff --git a/node/node_modules/npm/docs/content/commands/npm-audit.md b/node/node_modules/npm/docs/content/commands/npm-audit.md
new file mode 100644
index 0000000000000000000000000000000000000000..431d12af861c26d544d8418b68b806deca4b8e80
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-audit.md
@@ -0,0 +1,449 @@
+---
+title: npm-audit
+section: 1
+description: Run a security audit
+---
+
+### Synopsis
+
+```bash
+npm audit [fix|signatures]
+```
+
+### Description
+
+The audit command submits a description of the dependencies configured in your project to your default registry and asks for a report of known vulnerabilities.
+If any vulnerabilities are found, then the impact and appropriate remediation will be calculated.
+If the `fix` argument is provided, then remediations will be applied to the package tree.
+
+The command will exit with a 0 exit code if no vulnerabilities were found.
+
+Note that some vulnerabilities cannot be fixed automatically and will require manual intervention or review.
+Also note that since `npm audit fix` runs a full-fledged `npm install` under the hood, all configs that apply to the installer will also apply to `npm install` -- so things like `npm audit fix --package-lock-only` will work as expected.
+
+By default, the audit command will exit with a non-zero code if any vulnerability is found.
+It may be useful in CI environments to include the `--audit-level` parameter to specify the minimum vulnerability level that will cause the command to fail.
+This option does not filter the report output, it simply changes the command's failure threshold.
+
+### Package lock
+
+By default npm requires a package-lock or shrinkwrap in order to run the audit.
+You can bypass the package lock with `--no-package-lock` but be aware the results may be different with every run, since npm will re-build the dependency tree each time.
+
+### Audit Signatures
+
+To ensure the integrity of packages you download from the public npm registry, or any registry that supports signatures, you can verify the registry signatures of downloaded packages using the npm CLI.
+
+Registry signatures can be verified using the following `audit` command:
+
+```bash
+$ npm audit signatures
+```
+
+The `audit signatures` command will also verify the provenance attestations of downloaded packages.
+Because provenance attestations are such a new feature, security features may be added to (or changed in) the attestation format over time.
+To ensure that you're always able to verify attestation signatures check that you're running the latest version of the npm CLI. Please note this often means updating npm beyond the version that ships with Node.js.
+
+To include the full sigstore attestation bundles in JSON output, use:
+
+```bash
+$ npm audit signatures --json --include-attestations
+```
+
+This adds a `verified` array to the JSON output containing the attestation
+bundles (DSSE envelopes, verification material, and transparency log entries)
+for each verified package.
+
+The npm CLI supports registry signatures and signing keys provided by any registry if the following conventions are followed:
+
+1. Signatures are provided in the package's `packument` in each published version within the `dist` object:
+
+```json
+"dist":{
+  "..omitted..": "..omitted..",
+  "signatures": [{
+    "keyid": "SHA256:{{SHA256_PUBLIC_KEY}}",
+    "sig": "a312b9c3cb4a1b693e8ebac5ee1ca9cc01f2661c14391917dcb111517f72370809..."
+  }]
+}
+```
+
+See this [example](https://registry.npmjs.org/light-cycle/1.4.3) of a signed package from the public npm registry.
+
+The `sig` is generated using the following template: `${package.name}@${package.version}:${package.dist.integrity}` and the `keyid` has to match one of the public signing keys below.
+
+2. Public signing keys are provided at `registry-host.tld/-/npm/v1/keys` in the following format:
+
+```
+{
+  "keys": [{
+    "expires": null,
+    "keyid": "SHA256:{{SHA256_PUBLIC_KEY}}",
+    "keytype": "ecdsa-sha2-nistp256",
+    "scheme": "ecdsa-sha2-nistp256",
+    "key": "{{B64_PUBLIC_KEY}}"
+  }]
+}
+```
+
+Keys response:
+
+- `expires`: null or a simplified extended [ISO 8601 format](https://en.wikipedia.org/wiki/ISO_8601): `YYYY-MM-DDTHH:mm:ss.sssZ`
+- `keyid`: sha256 fingerprint of the public key
+- `keytype`: only `ecdsa-sha2-nistp256` is currently supported by the npm CLI
+- `scheme`: only `ecdsa-sha2-nistp256` is currently supported by the npm CLI
+- `key`: base64 encoded public key
+
+See this [example key's response from the public npm registry](https://registry.npmjs.org/-/npm/v1/keys).
+
+### Audit Endpoints
+
+There are two audit endpoints that npm may use to fetch vulnerability information: the `Bulk Advisory` endpoint and the `Quick Audit` endpoint.
+
+#### Bulk Advisory Endpoint
+
+As of version 7, npm uses the much faster `Bulk Advisory` endpoint to optimize the speed of calculating audit results.
+
+npm will generate a JSON payload with the name and list of versions of each package in the tree, and POST it to the default configured registry at the path `/-/npm/v1/security/advisories/bulk`.
+
+Any packages in the tree that do not have a `version` field in their package.json file will be ignored.
+If any `--omit` options are specified (either via the [`--omit` config](/using-npm/config#omit), or one of the shorthands such as `--production`, `--only=dev`, and so on), then packages will be omitted from the submitted payload as appropriate.
+
+If the registry responds with an error, or with an invalid response, then npm will attempt to load advisory data from the `Quick Audit` endpoint.
+
+The expected result will contain a set of advisory objects for each dependency that matches the advisory range.
+Each advisory object contains a `name`, `url`, `id`, `severity`, `vulnerable_versions`, and `title`.
+
+npm then uses these advisory objects to calculate vulnerabilities and meta-vulnerabilities of the dependencies within the tree.
+
+#### Quick Audit Endpoint
+
+If the `Bulk Advisory` endpoint returns an error, or invalid data, npm will attempt to load advisory data from the `Quick Audit` endpoint, which is considerably slower in most cases.
+
+The full package tree as found in `package-lock.json` is submitted, along with the following pieces of additional metadata:
+
+* `npm_version`
+* `node_version`
+* `platform`
+* `arch`
+* `node_env`
+
+All packages in the tree are submitted to the Quick Audit endpoint.
+Omitted dependency types are skipped when generating the report.
+
+#### Scrubbing
+
+Out of an abundance of caution, npm versions 5 and 6 would "scrub" any packages from the submitted report if their name contained a `/` character, so as to avoid leaking the names of potentially private packages or git URLs.
+
+However, in practice, this resulted in audits often failing to properly detect meta-vulnerabilities, because the tree would appear to be invalid due to missing dependencies, and prevented the detection of vulnerabilities in package trees that used git dependencies or private modules.
+
+This scrubbing has been removed from npm as of version 7.
+
+#### Calculating Meta-Vulnerabilities and Remediations
+
+npm uses the [`@npmcli/metavuln-calculator`](http://npm.im/@npmcli/metavuln-calculator) module to turn a set of security advisories into a set of "vulnerability" objects.
+A "meta-vulnerability" is a dependency that is vulnerable by virtue of dependence on vulnerable versions of a vulnerable package.
+
+For example, if the package `foo` is vulnerable in the range `>=1.0.2 <2.0.0`, and the package `bar` depends on `foo@^1.1.0`, then that version of `bar` can only be installed by installing a vulnerable version of `foo`.
+In this case, `bar` is a "metavulnerability".
+
+Once metavulnerabilities for a given package are calculated, they are cached in the `~/.npm` folder and only re-evaluated if the advisory range changes, or a new version of the package is published (in which case, the new version is checked for metavulnerable status as well).
+
+If the chain of metavulnerabilities extends all the way to the root project, and it cannot be updated without changing its dependency ranges, then `npm audit fix` will require the `--force` option to apply the remediation.
+If remediations do not require changes to the dependency ranges, then all vulnerable packages will be updated to a version that does not have an advisory or metavulnerability posted against it.
+
+### Exit Code
+
+The `npm audit` command will exit with a 0 exit code if no vulnerabilities were found.
+The `npm audit fix` command will exit with 0 exit code if no vulnerabilities are found _or_ if the remediation is able to successfully fix all vulnerabilities.
+
+If vulnerabilities were found the exit code will depend on the [`audit-level` config](/using-npm/config#audit-level).
+
+### Examples
+
+Scan your project for vulnerabilities and automatically install any compatible updates to vulnerable dependencies:
+
+```bash
+$ npm audit fix
+```
+
+Run `audit fix` without modifying `node_modules`, but still updating the pkglock:
+
+```bash
+$ npm audit fix --package-lock-only
+```
+
+Skip updating `devDependencies`:
+
+```bash
+$ npm audit fix --only=prod
+```
+
+Have `audit fix` install SemVer-major updates to toplevel dependencies, not just SemVer-compatible ones:
+
+```bash
+$ npm audit fix --force
+```
+
+Do a dry run to get an idea of what `audit fix` will do, and _also_ output install information in JSON format:
+
+```bash
+$ npm audit fix --dry-run --json
+```
+
+Scan your project for vulnerabilities and just show the details, without fixing anything:
+
+```bash
+$ npm audit
+```
+
+Get the detailed audit report in JSON format:
+
+```bash
+$ npm audit --json
+```
+
+Fail an audit only if the results include a vulnerability with a level of moderate or higher:
+
+```bash
+$ npm audit --audit-level=moderate
+```
+
+### Configuration
+
+#### `audit-level`
+
+* Default: null
+* Type: null, "info", "low", "moderate", "high", "critical", or "none"
+
+The minimum level of vulnerability for `npm audit` to exit with a non-zero
+exit code.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `force`
+
+* Default: false
+* Type: Boolean
+
+Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.
+
+* Allow clobbering non-npm files in global installs.
+* Allow the `npm version` command to work on an unclean git repository.
+* Allow deleting the cache folder with `npm cache clean`.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of npm.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of `node`, even if `--engine-strict` is enabled.
+* Allow `npm audit fix` to install modules outside your stated dependency
+  range (including SemVer-major changes).
+* Allow unpublishing all versions of a published package.
+* Allow conflicting peerDependencies to be installed in the root project.
+* Implicitly set `--yes` during `npm init`.
+* Allow clobbering existing values in `npm pkg`
+* Allow unpublishing of entire packages (not just a single version).
+
+If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `include-attestations`
+
+* Default: false
+* Type: Boolean
+
+When used with `npm audit signatures --json`, includes the full sigstore
+attestation bundles in the JSON output for each verified package. The
+bundles contain DSSE envelopes, verification material, and transparency log
+entries.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm install](/commands/npm-install)
+* [config](/using-npm/config)
diff --git a/node/node_modules/npm/docs/content/commands/npm-bugs.md b/node/node_modules/npm/docs/content/commands/npm-bugs.md
new file mode 100644
index 0000000000000000000000000000000000000000..e93f5c0c4950108566effef17920b3ba6d10a709
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-bugs.md
@@ -0,0 +1,106 @@
+---
+title: npm-bugs
+section: 1
+description: Report bugs for a package in a web browser
+---
+
+### Synopsis
+
+```bash
+npm bugs [<pkgname> [<pkgname> ...]]
+
+alias: issues
+```
+
+### Description
+
+This command tries to guess at the likely location of a package's bug tracker URL or the `mailto` URL of the support email, and then tries to open it using the [`--browser` config](/using-npm/config#browser) param.
+If no package name is provided, it will search for a `package.json` in the current folder and use the `name` property.
+
+### Configuration
+
+#### `browser`
+
+* Default: macOS: `"open"`, Windows: `"start"`, Others: `"xdg-open"`
+* Type: null, Boolean, or String
+
+The browser that is called by npm commands to open websites.
+
+Set to `false` to suppress browser behavior and instead print urls to
+terminal.
+
+Set to `true` to use default system URL opener.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [npm docs](/commands/npm-docs)
+* [npm view](/commands/npm-view)
+* [npm publish](/commands/npm-publish)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [package.json](/configuring-npm/package-json)
diff --git a/node/node_modules/npm/docs/content/commands/npm-cache.md b/node/node_modules/npm/docs/content/commands/npm-cache.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb30012b5a7a92ce7b29ae94f55783e6d91f0017
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-cache.md
@@ -0,0 +1,100 @@
+---
+title: npm-cache
+section: 1
+description: Manipulates packages cache
+---
+
+### Synopsis
+
+```bash
+npm cache add <package-spec>
+npm cache clean [<key>]
+npm cache ls [<name>@<version>]
+npm cache verify
+npm cache npx ls
+npm cache npx rm [<key>...]
+npm cache npx info <key>...
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Used to add, list, or clean the `npm cache` folder.
+Also used to view info about entries in the `npm exec` (aka `npx`) cache folder.
+
+#### `npm cache`
+
+* add:
+  Add the specified packages to the local cache.
+  This command is primarily intended to be used internally by npm, but it can provide a way to add data to the local installation cache explicitly.
+
+* clean:
+  Delete a single entry or all entries out of the cache folder.
+  Note that this is typically unnecessary, as npm's cache is self-healing and resistant to data corruption issues.
+
+* ls:
+  List given entries or all entries in the local cache.
+
+* verify:
+  Verify the contents of the cache folder, garbage collecting any unneeded data, and verifying the integrity of the cache index and all cached data.
+
+#### `npm cache npx`
+
+* ls:
+  List all entries in the npx cache.
+
+* rm:
+  Remove given entries or all entries from the npx cache.
+
+* info:
+  Get detailed information about given entries in the npx cache.
+
+### Details
+
+npm stores cache data in an opaque directory within the configured `cache`, named `_cacache`.
+This directory is a [`cacache`](http://npm.im/cacache)-based content-addressable cache that stores all http request data as well as other package-related data.
+This directory is primarily accessed through `pacote`, the library responsible for all package fetching as of npm@5.
+
+All data that passes through the cache is fully verified for integrity on both insertion and extraction.
+Cache corruption will either trigger an error, or signal to `pacote` that the data must be refetched, which it will do automatically.
+For this reason, it should never be necessary to clear the cache for any reason other than reclaiming disk space, thus why `clean` now requires `--force` to run.
+
+There is currently no method exposed through npm to inspect or directly manage the contents of this cache.
+In order to access it, `cacache` must be used directly.
+
+npm will not remove data by itself: the cache will grow as new packages are installed.
+
+### A note about the cache's design
+
+The npm cache is strictly a cache: it should not be relied upon as a persistent and reliable data store for package data.
+npm makes no guarantee that a previously-cached piece of data will be available later, and will automatically delete corrupted contents.
+The primary guarantee that the cache makes is that, if it does return data, that data will be exactly the data that was inserted.
+
+To run an offline verification of existing cache contents, use `npm cache verify`.
+
+### Configuration
+
+#### `cache`
+
+* Default: Windows: `%LocalAppData%\npm-cache`, Posix: `~/.npm`
+* Type: Path
+
+The location of npm's cache directory.
+
+
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm install](/commands/npm-install)
+* [npm publish](/commands/npm-publish)
+* [npm pack](/commands/npm-pack)
+* [npm exec](/commands/npm-exec)
+* https://npm.im/cacache
+* https://npm.im/pacote
+* https://npm.im/@npmcli/arborist
+* https://npm.im/make-fetch-happen
diff --git a/node/node_modules/npm/docs/content/commands/npm-ci.md b/node/node_modules/npm/docs/content/commands/npm-ci.md
new file mode 100644
index 0000000000000000000000000000000000000000..3ffeea3e14f32343d746e19d2cf538ff9f1e329f
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-ci.md
@@ -0,0 +1,329 @@
+---
+title: npm-ci
+section: 1
+description: Clean install a project
+---
+
+### Synopsis
+
+```bash
+npm ci
+
+aliases: clean-install, ic, install-clean, isntall-clean
+```
+
+### Description
+
+This command is similar to [`npm install`](/commands/npm-install), except it's meant to be used in automated environments such as test platforms, continuous integration, and deployment -- or any situation where you want to make sure you're doing a clean install of your dependencies.
+
+The main differences between using `npm install` and `npm ci` are:
+
+* The project **must** have an existing `package-lock.json` or
+  `npm-shrinkwrap.json`.
+* If dependencies in the package lock do not match those in `package.json`,
+  `npm ci` will exit with an error, instead of updating the package lock.
+* `npm ci` can only install entire projects at a time: individual dependencies cannot be added with this command.
+* If a `node_modules` is already present, it will be automatically removed before `npm ci` begins its install.
+* It will never write to `package.json` or any of the package-locks:
+  installs are essentially frozen.
+
+NOTE: If you create your `package-lock.json` file by running `npm install` with flags that can affect the shape of your dependency tree, such as
+`--legacy-peer-deps` or `--install-links`, you _must_ provide the same flags to `npm ci` or you are likely to encounter errors.
+An easy way to do this is to run, for example,
+`npm config set legacy-peer-deps=true --location=project` and commit the
+`.npmrc` file to your repo.
+
+### Example
+
+Make sure you have a package-lock and an up-to-date install:
+
+```bash
+$ cd ./my/npm/project
+$ npm install
+added 154 packages in 10s
+$ ls | grep package-lock
+```
+
+Run `npm ci` in that project
+
+```bash
+$ npm ci
+added 154 packages in 5s
+```
+
+Configure Travis CI to build using `npm ci` instead of `npm install`:
+
+```bash
+# .travis.yml
+install:
+- npm ci
+# keep the npm cache around to speed up installs
+cache:
+  directories:
+  - "$HOME/.npm"
+```
+
+### Configuration
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm install](/commands/npm-install)
+* [package-lock.json](/configuring-npm/package-lock-json)
diff --git a/node/node_modules/npm/docs/content/commands/npm-completion.md b/node/node_modules/npm/docs/content/commands/npm-completion.md
new file mode 100644
index 0000000000000000000000000000000000000000..a2643dd40f90ecea2e97ba052204f2625f756780
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-completion.md
@@ -0,0 +1,36 @@
+---
+title: npm-completion
+section: 1
+description: Tab Completion for npm
+---
+
+### Synopsis
+
+```bash
+npm completion
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Enables tab-completion in all npm commands.
+
+The synopsis above loads the completions into your current shell.
+Adding it to your ~/.bashrc or ~/.zshrc will make the completions available everywhere:
+
+```bash
+npm completion >> ~/.bashrc
+npm completion >> ~/.zshrc
+```
+
+You may of course also pipe the output of `npm completion` to a file such as `/usr/local/etc/bash_completion.d/npm` or
+`/etc/bash_completion.d/npm` if you have a system that will read 
+that file for you.
+
+When `COMP_CWORD`, `COMP_LINE`, and `COMP_POINT` are defined in the environment, `npm completion` acts in "plumbing mode", and outputs completions based on the arguments.
+
+### See Also
+
+* [npm developers](/using-npm/developers)
+* [npm](/commands/npm)
diff --git a/node/node_modules/npm/docs/content/commands/npm-config.md b/node/node_modules/npm/docs/content/commands/npm-config.md
new file mode 100644
index 0000000000000000000000000000000000000000..a036a41eb94c9d343da53e1aead5c1d26fef8bb8
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-config.md
@@ -0,0 +1,176 @@
+---
+title: npm-config
+section: 1
+description: Manage the npm configuration files
+---
+
+### Synopsis
+
+```bash
+npm config set <key>=<value> [<key>=<value> ...]
+npm config get [<key> [<key> ...]]
+npm config delete <key> [<key> ...]
+npm config list [--json]
+npm config edit
+npm config fix
+
+alias: c
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+npm gets its config settings from the command line, environment variables, `npmrc` files, and in some cases, the `package.json` file.
+
+See [npmrc](/configuring-npm/npmrc) for more information about the npmrc files.
+
+See [config](/using-npm/config) for a more thorough explanation of the mechanisms involved, and a full list of config options available.
+
+The `npm config` command can be used to update and edit the contents of the user and global npmrc files.
+
+### Sub-commands
+
+Config supports the following sub-commands:
+
+#### set
+
+```bash
+npm config set key=value [key=value...]
+npm set key=value [key=value...]
+```
+
+Sets each of the config keys to the value provided.
+Modifies the user configuration file unless [`location`](/commands/npm-config#location) is passed.
+
+If value is omitted, the key will be removed from your config file entirely.
+
+Note: for backwards compatibility, `npm config set key value` is supported as an alias for `npm config set key=value`.
+
+#### get
+
+```bash
+npm config get [key ...]
+npm get [key ...]
+```
+
+Echo the config value(s) to stdout.
+
+If multiple keys are provided, then the values will be prefixed with the key names.
+
+If no keys are provided, then this command behaves the same as `npm config list`.
+
+#### list
+
+```bash
+npm config list
+```
+
+Show all the config settings.
+Use `-l` to also show defaults.
+Use `--json` to show the settings in json format.
+
+#### delete
+
+```bash
+npm config delete key [key ...]
+```
+
+Deletes the specified keys from all configuration files.
+
+#### edit
+
+```bash
+npm config edit
+```
+
+Opens the config file in an editor.
+Use the `--global` flag to edit the global config.
+
+#### fix
+
+```bash
+npm config fix
+```
+
+Attempts to repair invalid configuration items.
+Usually this means attaching authentication config (i.e.
+`_auth`, `_authToken`) to the configured `registry`.
+
+### Configuration
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `editor`
+
+* Default: The EDITOR or VISUAL environment variables, or
+  '%SYSTEMROOT%\notepad.exe' on Windows, or 'vi' on Unix systems
+* Type: String
+
+The command to run for `npm edit` and `npm config edit`.
+
+
+
+#### `location`
+
+* Default: "user" unless `--global` is passed, which will also set this value
+  to "global"
+* Type: "global", "user", or "project"
+
+When passed to `npm config` this refers to which config file to use.
+
+When set to "global" mode, packages are installed into the `prefix` folder
+instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+### See Also
+
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [package.json](/configuring-npm/package-json)
+* [npmrc](/configuring-npm/npmrc)
+* [npm](/commands/npm)
diff --git a/node/node_modules/npm/docs/content/commands/npm-dedupe.md b/node/node_modules/npm/docs/content/commands/npm-dedupe.md
new file mode 100644
index 0000000000000000000000000000000000000000..90e4b6ef7a897975bcc1d410db72ec1906da133b
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-dedupe.md
@@ -0,0 +1,326 @@
+---
+title: npm-dedupe
+section: 1
+description: Reduce duplication in the package tree
+---
+
+### Synopsis
+
+```bash
+npm dedupe
+
+alias: ddp
+```
+
+### Description
+
+Searches the local package tree and attempts to simplify the overall structure by moving dependencies further up the tree, where they can be more effectively shared by multiple dependent packages.
+
+For example, consider this dependency graph:
+
+```
+a
++-- b <-- depends on c@1.0.x
+|   `-- c@1.0.3
+`-- d <-- depends on c@~1.0.9
+    `-- c@1.0.10
+```
+
+In this case, `npm dedupe` will transform the tree to:
+
+```bash
+a
++-- b
++-- d
+`-- c@1.0.10
+```
+
+Because of the hierarchical nature of node's module lookup, b and d will both get their dependency met by the single c package at the root level of the tree.
+
+In some cases, you may have a dependency graph like this:
+
+```
+a
++-- b <-- depends on c@1.0.x
++-- c@1.0.3
+`-- d <-- depends on c@1.x
+    `-- c@1.9.9
+```
+
+During the installation process, the `c@1.0.3` dependency for `b` was placed in the root of the tree.
+Though `d`'s dependency on `c@1.x` could have been satisfied by `c@1.0.3`, the newer `c@1.9.9` dependency was used, because npm favors updates by default, even when doing so causes duplication.
+
+Running `npm dedupe` will cause npm to note the duplication and re-evaluate, deleting the nested `c` module, because the one in the root is sufficient.
+
+To prefer deduplication over novelty during the installation process, run `npm install --prefer-dedupe` or `npm config set prefer-dedupe true`.
+
+Arguments are ignored.
+Dedupe always acts on the entire tree.
+
+Note that this operation transforms the dependency tree, but will never result in new modules being installed.
+
+Using `npm find-dupes` will run the command in `--dry-run` mode.
+
+Note: `npm dedupe` will never update the semver values of direct dependencies in your project `package.json`, if you want to update values in `package.json` you can run: `npm update --save` instead.
+
+### Configuration
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm find-dupes](/commands/npm-find-dupes)
+* [npm ls](/commands/npm-ls)
+* [npm update](/commands/npm-update)
+* [npm install](/commands/npm-install)
diff --git a/node/node_modules/npm/docs/content/commands/npm-deprecate.md b/node/node_modules/npm/docs/content/commands/npm-deprecate.md
new file mode 100644
index 0000000000000000000000000000000000000000..22762144be98ef5b5a4be231e0c142e5490f3ffe
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-deprecate.md
@@ -0,0 +1,85 @@
+---
+title: npm-deprecate
+section: 1
+description: Deprecate a version of a package
+---
+
+### Synopsis
+
+```bash
+npm deprecate <package-spec> <message>
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+This command will update the npm registry entry for a package, providing a deprecation warning to all who attempt to install it.
+
+It works on [version ranges](https://semver.npmjs.com/) as well as specific versions, so you can do something like this:
+
+```bash
+npm deprecate my-thing@"< 0.2.3" "critical bug fixed in v0.2.3"
+```
+
+SemVer ranges passed to this command are interpreted such that they *do* include prerelease versions.
+For example:
+
+```bash
+npm deprecate my-thing@1.x "1.x is no longer supported"
+```
+
+In this case, a version `my-thing@1.0.0-beta.0` will also be deprecated.
+
+You must be the package owner to deprecate something.
+See the `owner` and `adduser` help topics.
+
+To un-deprecate a package, specify an empty string (`""`) for the `message` argument.
+Note that you must use double quotes with no space between them to format an empty string.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm publish](/commands/npm-publish)
+* [npm registry](/using-npm/registry)
+* [npm owner](/commands/npm-owner)
+* [npm adduser](/commands/npm-adduser)
diff --git a/node/node_modules/npm/docs/content/commands/npm-diff.md b/node/node_modules/npm/docs/content/commands/npm-diff.md
new file mode 100644
index 0000000000000000000000000000000000000000..2ef0245c91c040bb3a034b68b74ba834f6254dbf
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-diff.md
@@ -0,0 +1,282 @@
+---
+title: npm-diff
+section: 1
+description: The registry diff command
+---
+
+### Synopsis
+
+```bash
+npm diff [...<paths>]
+```
+
+### Description
+
+Similar to its `git diff` counterpart, this command will print diff patches of files for packages published to the npm registry.
+
+* `npm diff --diff=<spec-a> --diff=<spec-b>`
+
+    Compares two package versions using their registry specifiers, e.g: `npm diff --diff=pkg@1.0.0 --diff=pkg@^2.0.0`.
+    It's also possible to compare across forks of any package, e.g: `npm diff --diff=pkg@1.0.0 --diff=pkg-fork@1.0.0`.
+
+    Any valid spec can be used, so that it's also possible to compare directories or git repositories, e.g: `npm diff --diff=pkg@latest --diff=./packages/pkg`
+
+    Here's an example comparing two different versions of a package named `abbrev` from the registry:
+
+    ```bash
+    npm diff --diff=abbrev@1.1.0 --diff=abbrev@1.1.1
+    ```
+
+    On success, output looks like:
+
+    ```bash
+    diff --git a/package.json b/package.json
+    index v1.1.0..v1.1.1 100644
+    --- a/package.json
+    +++ b/package.json
+    @@ -1,6 +1,6 @@
+     {
+       "name": "abbrev",
+    -  "version": "1.1.0",
+    +  "version": "1.1.1",
+       "description": "Like ruby's abbrev module, but in js",
+       "author": "Isaac Z. Schlueter <i@izs.me>",
+       "main": "abbrev.js",
+    ```
+
+    Given the flexible nature of npm specs, you can also target local directories or git repos just like when using `npm install`:
+
+    ```bash
+    npm diff --diff=https://github.com/npm/libnpmdiff --diff=./local-path
+    ```
+
+    In the example above we can compare the contents from the package installed from the git repo at `github.com/npm/libnpmdiff` with the contents of the `./local-path` that contains a valid package, such as a modified copy of the original.
+
+* `npm diff` (in a package directory, no arguments):
+
+    If the package is published to the registry, `npm diff` will fetch the tarball version tagged as `latest` (this value can be configured using the `tag` option) and proceed to compare the contents of files present in that tarball, with the current files in your local file system.
+
+    This workflow provides a handy way for package authors to see what package-tracked files have been changed in comparison with the latest published version of that package.
+
+* `npm diff --diff=<pkg-name>` (in a package directory):
+
+    When using a single package name (with no version or tag specifier) as an argument, `npm diff` will work in a similar way to [`npm-outdated`](npm-outdated) and reach for the registry to figure out what current published version of the package named `<pkg-name>` will satisfy its dependent declared semver-range.
+    Once that specific version is known `npm diff` will print diff patches comparing the current version of `<pkg-name>` found in the local file system with that specific version returned by the registry.
+
+    Given a package named `abbrev` that is currently installed:
+
+    ```bash
+    npm diff --diff=abbrev
+    ```
+
+    That will request from the registry its most up to date version and will print a diff output comparing the currently installed version to this newer one if the version numbers are not the same.
+
+* `npm diff --diff=<spec-a>` (in a package directory):
+
+    Similar to using only a single package name, it's also possible to declare a full registry specifier version if you wish to compare the local version of an installed package with the specific version/tag/semver-range provided in `<spec-a>`.
+
+    An example: assuming `pkg@1.0.0` is installed in the current `node_modules` folder, running:
+
+    ```bash
+    npm diff --diff=pkg@2.0.0
+    ```
+
+    It will effectively be an alias to
+    `npm diff --diff=pkg@1.0.0 --diff=pkg@2.0.0`.
+
+* `npm diff --diff=<semver-a> [--diff=<semver-b>]` (in a package directory):
+
+    Using `npm diff` along with semver-valid version numbers is a shorthand to compare different versions of the current package.
+
+    It needs to be run from a package directory, such that for a package named `pkg` running `npm diff --diff=1.0.0 --diff=1.0.1` is the same as running `npm diff --diff=pkg@1.0.0 --diff=pkg@1.0.1`.
+
+    If only a single argument `<version-a>` is provided, then the current local file system is going to be compared against that version.
+
+    Here's an example comparing two specific versions (published to the configured registry) of the current project directory:
+
+    ```bash
+    npm diff --diff=1.0.0 --diff=1.1.0
+    ```
+
+Note that tag names are not valid `--diff` argument values, if you wish to compare to a published tag, you must use the `pkg@tagname` syntax.
+
+#### Filtering files
+
+It's possible to also specify positional arguments using file names or globs pattern matching in order to limit the result of diff patches to only a subset of files for a given package, e.g:
+
+  ```bash
+  npm diff --diff=pkg@2 ./lib/ CHANGELOG.md
+  ```
+
+In the example above the diff output is only going to print contents of files located within the folder `./lib/` and changed lines of code within the `CHANGELOG.md` file.
+
+### Configuration
+
+#### `diff`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Define arguments to compare in `npm diff`.
+
+
+
+#### `diff-name-only`
+
+* Default: false
+* Type: Boolean
+
+Prints only filenames when using `npm diff`.
+
+
+
+#### `diff-unified`
+
+* Default: 3
+* Type: Number
+
+The number of lines of context to print in `npm diff`.
+
+
+
+#### `diff-ignore-all-space`
+
+* Default: false
+* Type: Boolean
+
+Ignore whitespace when comparing lines in `npm diff`.
+
+
+
+#### `diff-no-prefix`
+
+* Default: false
+* Type: Boolean
+
+Do not show any source or destination prefix in `npm diff` output.
+
+Note: this causes `npm diff` to ignore the `--diff-src-prefix` and
+`--diff-dst-prefix` configs.
+
+
+
+#### `diff-src-prefix`
+
+* Default: "a/"
+* Type: String
+
+Source prefix to be used in `npm diff` output.
+
+
+
+#### `diff-dst-prefix`
+
+* Default: "b/"
+* Type: String
+
+Destination prefix to be used in `npm diff` output.
+
+
+
+#### `diff-text`
+
+* Default: false
+* Type: Boolean
+
+Treat all files as text in `npm diff`.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `tag`
+
+* Default: "latest"
+* Type: String
+
+If you ask npm to install a package and don't tell it a specific version,
+then it will install the specified tag.
+
+It is the tag added to the package@version specified in the `npm dist-tag
+add` command, if no explicit tag is given.
+
+When used by the `npm diff` command, this is the tag used to fetch the
+tarball that will be compared with the local files by default.
+
+If used in the `npm publish` command, this is the tag that will be added to
+the package submitted to the registry.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+## See Also
+
+* [npm outdated](/commands/npm-outdated)
+* [npm install](/commands/npm-install)
+* [npm config](/commands/npm-config)
+* [npm registry](/using-npm/registry)
diff --git a/node/node_modules/npm/docs/content/commands/npm-dist-tag.md b/node/node_modules/npm/docs/content/commands/npm-dist-tag.md
new file mode 100644
index 0000000000000000000000000000000000000000..c6b9b517a7d2873c844c08662b362fab43334d8e
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-dist-tag.md
@@ -0,0 +1,138 @@
+---
+title: npm-dist-tag
+section: 1
+description: Modify package distribution tags
+---
+
+### Synopsis
+
+```bash
+npm dist-tag add <package-spec (with version)> [<tag>]
+npm dist-tag rm <package-spec> <tag>
+npm dist-tag ls [<package-spec>]
+
+alias: dist-tags
+```
+
+### Description
+
+Add, remove, and enumerate distribution tags on a package:
+
+* add: Tags the specified version of the package with the specified tag, or the [`--tag` config](/using-npm/config#tag) if not specified.
+  If you have two-factor authentication on auth-and-writes then you’ll need to include a one-time password on the command line with `--otp <one-time password>`, or go through a second factor flow based on your `authtype`.
+
+* rm: Clear a tag that is no longer in use from the package.
+  If you have two-factor authentication on auth-and-writes then you’ll need to include a one-time password on the command line with `--otp <one-time password>`, or go through a second factor flow based on your `authtype`
+
+* ls: Show all of the dist-tags for a package, defaulting to the package in the current prefix.
+  This is the default action if none is specified.
+
+A tag can be used when installing packages as a reference to a version instead of using a specific version number:
+
+```bash
+npm install <name>@<tag>
+```
+
+When installing dependencies, a preferred tagged version may be specified:
+
+```bash
+npm install --tag <tag>
+```
+
+(This also applies to any other commands that resolve and install dependencies, such as `npm dedupe`, `npm update`, and `npm audit fix`.)
+
+Publishing a package sets the `latest` tag to the published version unless the `--tag` option is used.
+For example, `npm publish --tag=beta`.
+
+By default, `npm install <pkg>` (without any `@<version>` or `@<tag>` specifier) installs the `latest` tag.
+
+### Purpose
+
+Tags can be used to provide an alias instead of version numbers.
+
+For example, a project might choose to have multiple streams of development and use a different tag for each stream, e.g., `stable`, `beta`, `dev`,
+`canary`.
+
+By default, the `latest` tag is used by npm to identify the current version of a package, and `npm install <pkg>` (without any `@<version>` or `@<tag>` specifier) installs the `latest` tag.
+Typically, projects only use the `latest` tag for stable release versions, and use other tags for unstable versions such as prereleases.
+
+The `next` tag is used by some projects to identify the upcoming version.
+
+Other than `latest`, no tag has any special significance to npm itself.
+
+### Caveats
+
+This command used to be known as `npm tag`, which only created new tags, and so had a different syntax.
+
+Tags must share a namespace with version numbers, because they are specified in the same slot: `npm install <pkg>@<version>` vs `npm install <pkg>@<tag>`.
+
+Tags that can be interpreted as valid semver ranges will be rejected.
+For example, `v1.4` cannot be used as a tag, because it is interpreted by semver as `>=1.4.0 <1.5.0`.
+See <https://github.com/npm/npm/issues/6082>.
+
+The simplest way to avoid semver problems with tags is to use tags that do not begin with a number or the letter `v`.
+
+### Configuration
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm publish](/commands/npm-publish)
+* [npm install](/commands/npm-install)
+* [npm dedupe](/commands/npm-dedupe)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-docs.md b/node/node_modules/npm/docs/content/commands/npm-docs.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d5d0f476da10d3ec5c2abc262266b4fcb8d39fc
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-docs.md
@@ -0,0 +1,106 @@
+---
+title: npm-docs
+section: 1
+description: Open documentation for a package in a web browser
+---
+
+### Synopsis
+
+```bash
+npm docs [<pkgname> [<pkgname> ...]]
+
+alias: home
+```
+
+### Description
+
+This command tries to guess at the likely location of a package's documentation URL, and then tries to open it using the [`--browser` config](/using-npm/config#browser) param.
+You can pass multiple package names at once.
+If no package name is provided, it will search for a `package.json` in the current folder and use the `name` property.
+
+### Configuration
+
+#### `browser`
+
+* Default: macOS: `"open"`, Windows: `"start"`, Others: `"xdg-open"`
+* Type: null, Boolean, or String
+
+The browser that is called by npm commands to open websites.
+
+Set to `false` to suppress browser behavior and instead print urls to
+terminal.
+
+Set to `true` to use default system URL opener.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [npm view](/commands/npm-view)
+* [npm publish](/commands/npm-publish)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [package.json](/configuring-npm/package-json)
diff --git a/node/node_modules/npm/docs/content/commands/npm-doctor.md b/node/node_modules/npm/docs/content/commands/npm-doctor.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb46ab220e86cec625c69e1000f779e33d6cdc77
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-doctor.md
@@ -0,0 +1,98 @@
+---
+title: npm-doctor
+section: 1
+description: Check the health of your npm environment
+---
+
+### Synopsis
+
+```bash
+npm doctor [connection] [registry] [versions] [environment] [permissions] [cache]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+`npm doctor` runs a set of checks to ensure that your npm installation has what it needs to manage your JavaScript packages.
+npm is mostly a standalone tool, but it does have some basic requirements that must be met:
+
++ Node.js and git must be executable by npm.
++ The primary npm registry, `registry.npmjs.com`, or another service that uses the registry API, is available.
++ The directories that npm uses, `node_modules` (both locally and globally), exist and can be written by the current user.
++ The npm cache exists, and the package tarballs within it aren't corrupt.
+
+Without all of these working properly, npm may not work properly.
+Many issues are often attributable to things that are outside npm's code base, so `npm doctor` confirms that the npm installation is in a good state.
+
+Also, in addition to this, there are also very many issue reports due to using old versions of npm.
+Since npm is constantly improving, running `npm@latest` is better than an old version.
+
+`npm doctor` verifies the following items in your environment, and if there are any recommended changes, it will display them.
+By default npm runs all of these checks.
+You can limit what checks are ran by specifying them as extra arguments.
+
+#### `Connecting to the registry`
+
+By default, npm installs from the primary npm registry,
+`registry.npmjs.org`.
+`npm doctor` hits a special connection testing endpoint within the registry.
+This can also be checked with `npm ping`.
+If this check fails, you may be using a proxy that needs to be configured, or may need to talk to your IT staff to get access over HTTPS to `registry.npmjs.org`.
+
+This check is done against whichever registry you've configured (you can see what that is by running `npm config get registry`), and if you're using a private registry that doesn't support the `/whoami` endpoint supported by the primary registry, this check may fail.
+
+#### `Checking npm version`
+
+While Node.js may come bundled with a particular version of npm, it's the policy of the CLI team that we recommend all users run `npm@latest` if they can.
+As the CLI is maintained by a small team of contributors, there are only resources for a single line of development, so npm's own long-term support releases typically only receive critical security and regression fixes.
+The team believes that the latest tested version of npm is almost always likely to be the most functional and defect-free version of npm.
+
+#### `Checking node version`
+
+For most users, in most circumstances, the best version of Node will be the latest long-term support (LTS) release.
+Those of you who want access to new ECMAscript features or bleeding-edge changes to Node's standard library may be running a newer version, and some may be required to run an older version of Node because of enterprise change control policies.
+That's OK!
+But in general, the npm team recommends that most users run Node.js LTS.
+
+#### `Checking configured npm registry`
+
+You may be installing from private package registries for your project or company.
+That's great! Others may be following tutorials or StackOverflow questions in an effort to troubleshoot problems you may be having.
+Sometimes, this may entail changing the registry you're pointing at.
+This part of `npm doctor` just lets you, and maybe whoever's helping you with support, know that you're not using the default registry.
+
+#### `Checking for git executable in PATH`
+
+While it's documented in the README, it may not be obvious that npm needs Git installed to do many of the things that it does.
+Also, in some cases – especially on Windows – you may have Git set up in such a way that it's not accessible via your `PATH` so that npm can find it.
+This check ensures that Git is available.
+
+#### Permissions checks
+
+* Your cache must be readable and writable by the user running npm.
+* Global package binaries must be writable by the user running npm.
+* Your local `node_modules` path, if you're running `npm doctor` with a project directory, must be readable and writable by the user running npm.
+
+#### Validate the checksums of cached packages
+
+When an npm package is published, the publishing process generates a checksum that npm uses at install time to verify that the package didn't get corrupted in transit.
+`npm doctor` uses these checksums to validate the package tarballs in your local cache (you can see where that cache is located with `npm config get cache`).
+In the event that there are corrupt packages in your cache, you should probably run `npm cache clean -f` and reset the cache.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+### See Also
+
+* [npm bugs](/commands/npm-bugs)
+* [npm help](/commands/npm-help)
+* [npm ping](/commands/npm-ping)
diff --git a/node/node_modules/npm/docs/content/commands/npm-edit.md b/node/node_modules/npm/docs/content/commands/npm-edit.md
new file mode 100644
index 0000000000000000000000000000000000000000..eea56da85bf8bc200748e208de2fd440c0147e7d
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-edit.md
@@ -0,0 +1,41 @@
+---
+title: npm-edit
+section: 1
+description: Edit an installed package
+---
+
+### Synopsis
+
+```bash
+npm edit <pkg>[/<subpkg>...]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Selects a dependency in the current project and opens the package folder in the default editor (or whatever you've configured as the npm `editor` config -- see [`npm-config`](npm-config).)
+
+After it has been edited, the package is rebuilt so as to pick up any changes in compiled packages.
+
+For instance, you can do `npm install connect` to install connect into your package, and then `npm edit connect` to make a few changes to your locally installed copy.
+
+### Configuration
+
+#### `editor`
+
+* Default: The EDITOR or VISUAL environment variables, or
+  '%SYSTEMROOT%\notepad.exe' on Windows, or 'vi' on Unix systems
+* Type: String
+
+The command to run for `npm edit` and `npm config edit`.
+
+
+
+### See Also
+
+* [npm folders](/configuring-npm/folders)
+* [npm explore](/commands/npm-explore)
+* [npm install](/commands/npm-install)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-exec.md b/node/node_modules/npm/docs/content/commands/npm-exec.md
new file mode 100644
index 0000000000000000000000000000000000000000..51a31f23aa62f0364cd2b5b1dc05accf8cd881a1
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-exec.md
@@ -0,0 +1,314 @@
+---
+title: npm-exec
+section: 1
+description: Run a command from a local or remote npm package
+---
+
+### Synopsis
+
+```bash
+npm exec -- <pkg>[@<version>] [args...]
+npm exec --package=<pkg>[@<version>] -- <cmd> [args...]
+npm exec -c '<cmd> [args...]'
+npm exec --package=foo -c '<cmd> [args...]'
+
+alias: x
+```
+
+### Description
+
+This command allows you to run an arbitrary command from an npm package (either one installed locally, or fetched remotely), in a similar context as running it via `npm run`.
+
+Run without positional arguments or `--call`, this allows you to interactively run commands in the same sort of shell environment that `package.json` scripts are run.
+Interactive mode is not supported in CI environments when standard input is a TTY, to prevent hangs.
+
+Whatever packages are specified by the `--package` option will be provided in the `PATH` of the executed command, along with any locally installed package executables.
+The `--package` option may be specified multiple times, to execute the supplied command in an environment where all specified packages are available.
+
+If any requested packages are not present in the local project dependencies, then a prompt is printed, which can be suppressed by providing either `--yes` or `--no`.
+When standard input is not a TTY or a CI environment is detected, `--yes` is assumed.
+The requested packages are installed to a folder in the npm cache, which is added to the `PATH` environment variable in the executed process.
+
+Package names provided without a specifier will be matched with whatever version exists in the local project.
+Package names with a specifier will only be considered a match if they have the exact same name and version as the local dependency.
+
+If no `-c` or `--call` option is provided, then the positional arguments are used to generate the command string.
+If no `--package` options are provided, then npm will attempt to determine the executable name from the package specifier provided as the first positional argument according to the following heuristic:
+
+- If the package has a single entry in its `bin` field in `package.json`, or if all entries are aliases of the same command, then that command will be used.
+- If the package has multiple `bin` entries, and one of them matches the unscoped portion of the `name` field, then that command will be used.
+- If this does not result in exactly one option (either because there are no bin entries, or none of them match the `name` of the package), then `npm exec` exits with an error.
+
+To run a binary _other than_ the named binary, specify one or more `--package` options, which will prevent npm from inferring the package from the first command argument.
+
+### `npx` vs `npm exec`
+
+When run via the `npx` binary, all flags and options *must* be set prior to any positional arguments.
+When run via `npm exec`, a double-hyphen `--` flag can be used to suppress npm's parsing of switches and options that should be sent to the executed command.
+
+For example:
+
+```
+$ npx foo@latest bar --package=@npmcli/foo
+```
+
+In this case, npm will resolve the `foo` package name, and run the following command:
+
+```
+$ foo bar --package=@npmcli/foo
+```
+
+Since the `--package` option comes _after_ the positional arguments, it is treated as an argument to the executed command.
+
+In contrast, due to npm's argument parsing logic, running this command is different:
+
+```
+$ npm exec foo@latest bar --package=@npmcli/foo
+```
+
+In this case, npm will parse the `--package` option first, resolving the `@npmcli/foo` package.
+Then, it will execute the following command in that context:
+
+```
+$ foo@latest bar
+```
+
+The double-hyphen character is recommended to explicitly tell npm to stop parsing command line options and switches.
+The following command would thus be equivalent to the `npx` command above:
+
+```
+$ npm exec -- foo@latest bar --package=@npmcli/foo
+```
+
+### Configuration
+
+#### `package`
+
+* Default:
+* Type: String (can be set multiple times)
+
+The package or packages to install for [`npm exec`](/commands/npm-exec)
+
+
+
+#### `call`
+
+* Default: ""
+* Type: String
+
+Optional companion option for `npm exec`, `npx` that allows for specifying a
+custom command to be run along with the installed packages.
+
+```bash
+npm exec --package yo --package generator-node --call "yo node"
+```
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### Examples
+
+Run the version of `tap` in the local dependencies, with the provided arguments:
+
+```
+$ npm exec -- tap --bail test/foo.js
+$ npx tap --bail test/foo.js
+```
+
+Run a command _other than_ the command whose name matches the package name by specifying a `--package` option:
+
+```
+$ npm exec --package=foo -- bar --bar-argument
+# ~ or ~
+$ npx --package=foo bar --bar-argument
+```
+
+Run an arbitrary shell script, in the context of the current project:
+
+```
+$ npm x -c 'eslint && say "hooray, lint passed"'
+$ npx -c 'eslint && say "hooray, lint passed"'
+```
+
+### Workspaces support
+
+You may use the [`workspace`](/using-npm/config#workspace) or [`workspaces`](/using-npm/config#workspaces) configs in order to run an arbitrary command from an npm package (either one installed locally, or fetched remotely) in the context of the specified workspaces.
+If no positional argument or `--call` option is provided, it will open an interactive subshell in the context of each of these configured workspaces one at a time.
+
+Given a project with configured workspaces, e.g:
+
+```
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   +-- b
+   |   `-- package.json
+   `-- c
+       `-- package.json
+```
+
+Assuming the workspace configuration is properly set up at the root level `package.json` file.
+e.g:
+
+```
+{
+    "workspaces": [ "./packages/*" ]
+}
+```
+
+You can execute an arbitrary command from a package in the context of each of the configured workspaces when using the [`workspaces` config options](/using-npm/config#workspace), in this example we're using **eslint** to lint any js file found within each workspace folder:
+
+```
+npm exec --ws -- eslint ./*.js
+```
+
+#### Filtering workspaces
+
+It's also possible to execute a command in a single workspace using the `workspace` config along with a name or directory path:
+
+```
+npm exec --workspace=a -- eslint ./*.js
+```
+
+The `workspace` config can also be specified multiple times in order to run a specific script in the context of multiple workspaces.
+When defining values for the `workspace` config in the command line, it also possible to use `-w` as a shorthand, e.g:
+
+```
+npm exec -w a -w b -- eslint ./*.js
+```
+
+This last command will run the `eslint` command in both `./packages/a` and
+`./packages/b` folders.
+
+### Compatibility with Older npx Versions
+
+The `npx` binary was rewritten in npm v7.0.0, and the standalone `npx` package deprecated at that time.
+`npx` uses the `npm exec` command instead of a separate argument parser and install process, with some affordances to maintain backwards compatibility with the arguments it accepted in previous versions.
+
+This resulted in some shifts in its functionality:
+
+- Any `npm` config value may be provided.
+- To prevent security and user-experience problems from mistyping package
+  names, `npx` prompts before installing anything.
+  Suppress this prompt with the `-y` or `--yes` option.
+- The `--no-install` option is deprecated, and will be converted to `--no`.
+- Shell fallback functionality is removed, as it is not advisable.
+- The `-p` argument is a shorthand for `--parseable` in npm, but shorthand for `--package` in npx.
+  This is maintained, but only for the `npx` executable.
+- The `--ignore-existing` option is removed.
+  Locally installed bins are always present in the executed process `PATH`.
+- The `--npm` option is removed.
+  `npx` will always use the `npm` it ships with.
+- The `--node-arg` and `-n` options are removed.
+- The `--always-spawn` option is redundant, and thus removed.
+- The `--shell` option is replaced with `--script-shell`, but maintained in the `npx` executable for backwards compatibility.
+
+### A note on caching
+
+The npm cli utilizes its internal package cache when using the package name specified.
+You can use the following to change how and when the cli uses this cache.
+See [`npm cache`](/commands/npm-cache) for more on how the cache works.
+
+#### prefer-online
+
+Forces staleness checks for packages, making the cli look for updates immediately even if the package is already in the cache.
+
+#### prefer-offline
+
+Bypasses staleness checks for packages.
+Missing data will still be requested from the server.
+To force full offline mode, use `offline`.
+
+#### offline
+
+Forces full offline mode.
+Any packages not locally cached will result in an error.
+
+#### workspace
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result to selecting all of the nested workspaces)
+
+This value is not exported to the environment for child processes.
+
+#### workspaces
+
+* Alias: `--ws`
+* Type: Boolean
+* Default: `false`
+
+Run scripts in the context of all configured workspaces for the current project.
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [npm test](/commands/npm-test)
+* [npm start](/commands/npm-start)
+* [npm restart](/commands/npm-restart)
+* [npm stop](/commands/npm-stop)
+* [npm config](/commands/npm-config)
+* [npm workspaces](/using-npm/workspaces)
+* [npx](/commands/npx)
diff --git a/node/node_modules/npm/docs/content/commands/npm-explain.md b/node/node_modules/npm/docs/content/commands/npm-explain.md
new file mode 100644
index 0000000000000000000000000000000000000000..059926529a826eac2ca355646704037f32153adf
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-explain.md
@@ -0,0 +1,101 @@
+---
+title: npm-explain
+section: 1
+description: Explain installed packages
+---
+
+### Synopsis
+
+```bash
+npm explain <package-spec>
+
+alias: why
+```
+
+### Description
+
+This command will print the chain of dependencies causing a given package to be installed in the current project.
+
+If one or more package specs are provided, then only packages matching one of the specifiers will have their relationships explained.
+
+The package spec can also refer to a folder within `./node_modules`
+
+For example, running `npm explain glob` within npm's source tree will show:
+
+```bash
+glob@7.1.6
+node_modules/glob
+  glob@"^7.1.4" from the root project
+
+glob@7.1.1 dev
+node_modules/tacks/node_modules/glob
+  glob@"^7.0.5" from rimraf@2.6.2
+  node_modules/tacks/node_modules/rimraf
+    rimraf@"^2.6.2" from tacks@1.3.0
+    node_modules/tacks
+      dev tacks@"^1.3.0" from the root project
+```
+
+To explain just the package residing at a specific folder, pass that as the argument to the command.
+This can be useful when trying to figure out exactly why a given dependency is being duplicated to satisfy conflicting version requirements within the project.
+
+```bash
+$ npm explain node_modules/nyc/node_modules/find-up
+find-up@3.0.0 dev
+node_modules/nyc/node_modules/find-up
+  find-up@"^3.0.0" from nyc@14.1.1
+  node_modules/nyc
+    nyc@"^14.1.1" from tap@14.10.8
+    node_modules/tap
+      dev tap@"^14.10.8" from the root project
+```
+
+### Configuration
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm folders](/configuring-npm/folders)
+* [npm ls](/commands/npm-ls)
+* [npm install](/commands/npm-install)
+* [npm link](/commands/npm-link)
+* [npm prune](/commands/npm-prune)
+* [npm outdated](/commands/npm-outdated)
+* [npm update](/commands/npm-update)
diff --git a/node/node_modules/npm/docs/content/commands/npm-explore.md b/node/node_modules/npm/docs/content/commands/npm-explore.md
new file mode 100644
index 0000000000000000000000000000000000000000..ee86308c6bab1aa4edec0436d2136190c1e322c2
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-explore.md
@@ -0,0 +1,46 @@
+---
+title: npm-explore
+section: 1
+description: Browse an installed package
+---
+
+### Synopsis
+
+```bash
+npm explore <pkg> [ -- <command>]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Spawn a subshell in the directory of the installed package specified.
+
+If a command is specified, then it is run in the subshell, which then immediately terminates.
+
+This is particularly handy in the case of git submodules in the `node_modules` folder:
+
+```bash
+npm explore some-dependency -- git pull origin master
+```
+
+Note that the package is *not* automatically rebuilt afterwards, so be sure to use `npm rebuild <pkg>` if you make any changes.
+
+### Configuration
+
+#### `shell`
+
+* Default: SHELL environment variable, or "bash" on Posix, or "cmd.exe" on
+  Windows
+* Type: String
+
+The shell to run for the `npm explore` command.
+
+
+
+### See Also
+
+* [npm folders](/configuring-npm/folders)
+* [npm edit](/commands/npm-edit)
+* [npm rebuild](/commands/npm-rebuild)
+* [npm install](/commands/npm-install)
diff --git a/node/node_modules/npm/docs/content/commands/npm-find-dupes.md b/node/node_modules/npm/docs/content/commands/npm-find-dupes.md
new file mode 100644
index 0000000000000000000000000000000000000000..5f43ebc1340adcabff81a7bd885e6d0b76119b13
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-find-dupes.md
@@ -0,0 +1,245 @@
+---
+title: npm-find-dupes
+section: 1
+description: Find duplication in the package tree
+---
+
+### Synopsis
+
+```bash
+npm find-dupes
+```
+
+### Description
+
+Runs `npm dedupe` in `--dry-run` mode, making npm only output the duplications, without actually changing the package tree.
+
+### Configuration
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm dedupe](/commands/npm-dedupe)
+* [npm ls](/commands/npm-ls)
+* [npm update](/commands/npm-update)
+* [npm install](/commands/npm-install)
+
diff --git a/node/node_modules/npm/docs/content/commands/npm-fund.md b/node/node_modules/npm/docs/content/commands/npm-fund.md
new file mode 100644
index 0000000000000000000000000000000000000000..90cb37226a24a9aeb34f5dac7ee9e4bafcb304cf
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-fund.md
@@ -0,0 +1,136 @@
+---
+title: npm-fund
+section: 1
+description: Retrieve funding information
+---
+
+### Synopsis
+
+```bash
+npm fund [<package-spec>]
+```
+
+### Description
+
+This command retrieves information on how to fund the dependencies of a given project.
+If no package name is provided, it will list all dependencies that are looking for funding in a tree structure, listing the type of funding and the url to visit.
+If a package name is provided then it tries to open its funding url using the [`--browser` config](/using-npm/config#browser) param; if there are multiple funding sources for the package, the user will be instructed to pass the
+`--which` option to disambiguate.
+
+The list will avoid duplicated entries and will stack all packages that share the same url as a single entry.
+Thus, the list does not have the same shape of the output from `npm ls`.
+
+#### Example
+
+### Workspaces support
+
+It's possible to filter the results to only include a single workspace and its dependencies using the [`workspace` config](/using-npm/config#workspace) option.
+
+#### Example:
+
+Here's an example running `npm fund` in a project with a configured workspace `a`:
+
+```bash
+$ npm fund
+test-workspaces-fund@1.0.0
++-- https://example.com/a
+| | `-- a@1.0.0
+| `-- https://example.com/maintainer
+|     `-- foo@1.0.0
++-- https://example.com/npmcli-funding
+|   `-- @npmcli/test-funding
+`-- https://example.com/org
+    `-- bar@2.0.0
+```
+
+And here is an example of the expected result when filtering only by a specific workspace `a` in the same project:
+
+```bash
+$ npm fund -w a
+test-workspaces-fund@1.0.0
+`-- https://example.com/a
+  | `-- a@1.0.0
+  `-- https://example.com/maintainer
+      `-- foo@2.0.0
+```
+
+### Configuration
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `browser`
+
+* Default: macOS: `"open"`, Windows: `"start"`, Others: `"xdg-open"`
+* Type: null, Boolean, or String
+
+The browser that is called by npm commands to open websites.
+
+Set to `false` to suppress browser behavior and instead print urls to
+terminal.
+
+Set to `true` to use default system URL opener.
+
+
+
+#### `unicode`
+
+* Default: false on windows, true on mac/unix systems with a unicode locale,
+  as defined by the `LC_ALL`, `LC_CTYPE`, or `LANG` environment variables.
+* Type: Boolean
+
+When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `which`
+
+* Default: null
+* Type: null or Number
+
+If there are multiple funding sources, which 1-indexed source URL to open.
+
+
+
+## See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm install](/commands/npm-install)
+* [npm docs](/commands/npm-docs)
+* [npm ls](/commands/npm-ls)
+* [npm config](/commands/npm-config)
+* [npm workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-get.md b/node/node_modules/npm/docs/content/commands/npm-get.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa96795dd85ac0f9191ace2b4478596b6960ce03
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-get.md
@@ -0,0 +1,32 @@
+---
+title: npm-get
+section: 1
+description: Get a value from the npm configuration
+---
+
+### Synopsis
+
+```bash
+npm get [<key> ...] (See `npm config`)
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Get a value from the npm configuration
+
+### Configuration
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+### See Also
+
+* [npm help config](/commands/npm-config)
diff --git a/node/node_modules/npm/docs/content/commands/npm-help-search.md b/node/node_modules/npm/docs/content/commands/npm-help-search.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa47fcbebcd78e8e90bac181a8c4165ca65ed047
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-help-search.md
@@ -0,0 +1,38 @@
+---
+title: npm-help-search
+section: 1
+description: Search npm help documentation
+---
+
+### Synopsis
+
+```bash
+npm help-search <text>
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+This command will search the npm markdown documentation files for the terms provided, and then list the results, sorted by relevance.
+
+If only one result is found, then it will show that help topic.
+
+If the argument to `npm help` is not a known help topic, then it will call `help-search`.
+It is rarely if ever necessary to call this command directly.
+
+### Configuration
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+### See Also
+
+* [npm](/commands/npm)
+* [npm help](/commands/npm-help)
diff --git a/node/node_modules/npm/docs/content/commands/npm-help.md b/node/node_modules/npm/docs/content/commands/npm-help.md
new file mode 100644
index 0000000000000000000000000000000000000000..82f6b862a42369158b1fe752f1646c1bea3d040a
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-help.md
@@ -0,0 +1,44 @@
+---
+title: npm-help
+section: 1
+description: Get help on npm
+---
+
+### Synopsis
+
+```bash
+npm help <term> [<terms..>]
+
+alias: hlep
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+If supplied a topic, then show the appropriate documentation page.
+
+If the topic does not exist, or if multiple terms are provided, then npm will run the `help-search` command to find a match.
+Note that, if `help-search` finds a single subject, then it will run `help` on that topic, so unique matches are equivalent to specifying a topic name.
+
+### Configuration
+
+#### `viewer`
+
+* Default: "man" on Posix, "browser" on Windows
+* Type: String
+
+The program to use to view help content.
+
+Set to `"browser"` to view html help content in the default web browser.
+
+
+
+### See Also
+
+* [npm](/commands/npm)
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [package.json](/configuring-npm/package-json)
+* [npm help-search](/commands/npm-help-search)
diff --git a/node/node_modules/npm/docs/content/commands/npm-init.md b/node/node_modules/npm/docs/content/commands/npm-init.md
new file mode 100644
index 0000000000000000000000000000000000000000..ed8877cc881bbf673aa46fc7c9080cc3a26c39bd
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-init.md
@@ -0,0 +1,348 @@
+---
+title: npm-init
+section: 1
+description: Create a package.json file
+---
+
+### Synopsis
+
+```bash
+npm init <package-spec> (same as `npx create-<package-spec>`)
+npm init <@scope> (same as `npx <@scope>/create`)
+
+aliases: create, innit
+```
+
+### Description
+
+`npm init <initializer>` can be used to set up a new or existing npm package.
+
+`initializer` in this case is an npm package named `create-<initializer>`,
+which will be installed by [`npm-exec`](/commands/npm-exec), and then have its main bin executed -- presumably creating or updating `package.json` and running any other initialization-related operations.
+
+The init command is transformed to a corresponding `npm exec` operation as follows:
+
+* `npm init foo` -> `npm exec create-foo`
+* `npm init @usr/foo` -> `npm exec @usr/create-foo`
+* `npm init @usr` -> `npm exec @usr/create`
+* `npm init @usr@2.0.0` -> `npm exec @usr/create@2.0.0`
+* `npm init @usr/foo@2.0.0` -> `npm exec @usr/create-foo@2.0.0`
+
+If the initializer is omitted (by just calling `npm init`), init will fall back to legacy init behavior.
+It will ask you a bunch of questions, and then write a package.json for you.
+It will attempt to make reasonable guesses based on existing fields, dependencies, and options selected.
+It is strictly additive, so it will keep any fields and values that were already set.
+You can also use `-y`/`--yes` to skip the questionnaire altogether.
+If you pass `--scope`, it will create a scoped package.
+
+*Note:* if a user already has the `create-<initializer>` package globally installed, that will be what `npm init` uses.
+If you want npm to use the latest version, or another specific version you must specify it:
+
+* `npm init foo@latest` # fetches and runs the latest `create-foo` from the registry
+* `npm init foo@1.2.3` #  runs `create-foo@1.2.3` specifically
+
+#### Forwarding additional options
+
+Any additional options will be passed directly to the command, so `npm init foo -- --hello` will map to `npm exec -- create-foo --hello`.
+
+To better illustrate how options are forwarded, here's a more evolved example showing options passed to both the **npm cli** and a create package, both following commands are equivalent:
+
+- `npm init foo -y --registry=<url> -- --hello -a`
+- `npm exec -y --registry=<url> -- create-foo --hello -a`
+
+### Examples
+
+Create a new React-based project using [`create-react-app`](https://npm.im/create-react-app):
+
+```bash
+$ npm init react-app ./my-react-app
+```
+
+Create a new `esm`-compatible package using [`create-esm`](https://npm.im/create-esm):
+
+```bash
+$ mkdir my-esm-lib && cd my-esm-lib
+$ npm init esm --yes
+```
+
+Generate a plain old package.json using legacy init:
+
+```bash
+$ mkdir my-npm-pkg && cd my-npm-pkg
+$ git init
+$ npm init
+```
+
+Generate it without having it ask any questions:
+
+```bash
+$ npm init -y
+```
+
+Set the private flag to `true` in package.json:
+```bash
+$ npm init --init-private -y
+```
+
+### Workspaces support
+
+It's possible to create a new workspace within your project by using the `workspace` config option.
+When using `npm init -w <dir>` the cli will create the folders and boilerplate expected while also adding a reference to your project `package.json` `"workspaces": []` property in order to make sure that new generated **workspace** is properly set up as such.
+
+Given a project with no workspaces, e.g:
+
+```
+.
++-- package.json
+```
+
+You may generate a new workspace using the legacy init:
+
+```bash
+$ npm init -w packages/a
+```
+
+That will generate a new folder and `package.json` file, while also updating your top-level `package.json` to add the reference to this new workspace:
+
+```
+.
++-- package.json
+`-- packages
+   `-- a
+       `-- package.json
+```
+
+The workspaces init also supports the `npm init <initializer> -w <dir>` syntax, following the same set of rules explained earlier in the initial
+**Description** section of this page.
+Similar to the previous example of creating a new React-based project using [`create-react-app`](https://npm.im/create-react-app), the following syntax will make sure to create the new react app as a nested **workspace** within your project and configure your `package.json` to recognize it as such:
+
+```bash
+npm init -w packages/my-react-app react-app .
+```
+
+This will make sure to generate your react app as expected, one important consideration to have in mind is that `npm exec` is going to be run in the context of the newly created folder for that workspace, and that's the reason why in this example the initializer uses the initializer name followed with a dot to represent the current directory in that context, e.g: `react-app .`:
+
+```
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- my-react-app
+       +-- README
+       +-- package.json
+       `-- ...
+```
+
+### Configuration
+
+#### `init-author-name`
+
+* Default: ""
+* Type: String
+
+The value `npm init` should use by default for the package author's name.
+
+
+
+#### `init-author-url`
+
+* Default: ""
+* Type: "" or URL
+
+The value `npm init` should use by default for the package author's
+homepage.
+
+
+
+#### `init-license`
+
+* Default: "ISC"
+* Type: String
+
+The value `npm init` should use by default for the package license.
+
+
+
+#### `init-module`
+
+* Default: "~/.npm-init.js"
+* Type: Path
+
+A module that will be loaded by the `npm init` command. See the
+documentation for the
+[init-package-json](https://github.com/npm/init-package-json) module for
+more information, or [npm init](/commands/npm-init).
+
+
+
+#### `init-type`
+
+* Default: "commonjs"
+* Type: String
+
+The value that `npm init` should use by default for the package.json type
+field.
+
+
+
+#### `init-version`
+
+* Default: "1.0.0"
+* Type: SemVer string
+
+The value that `npm init` should use by default for the package version
+number, if not already set in package.json.
+
+
+
+#### `init-private`
+
+* Default: false
+* Type: Boolean
+
+The value `npm init` should use by default for the package's private flag.
+
+
+
+#### `yes`
+
+* Default: null
+* Type: null or Boolean
+
+Automatically answer "yes" to any prompts that npm might print on the
+command line.
+
+
+
+#### `force`
+
+* Default: false
+* Type: Boolean
+
+Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.
+
+* Allow clobbering non-npm files in global installs.
+* Allow the `npm version` command to work on an unclean git repository.
+* Allow deleting the cache folder with `npm cache clean`.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of npm.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of `node`, even if `--engine-strict` is enabled.
+* Allow `npm audit fix` to install modules outside your stated dependency
+  range (including SemVer-major changes).
+* Allow unpublishing all versions of a published package.
+* Allow conflicting peerDependencies to be installed in the root project.
+* Implicitly set `--yes` during `npm init`.
+* Allow clobbering existing values in `npm pkg`
+* Allow unpublishing of entire packages (not just a single version).
+
+If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!
+
+
+
+#### `scope`
+
+* Default: the scope of the current project, if any, or ""
+* Type: String
+
+Associate an operation with a scope for a scoped registry.
+
+Useful when logging in to or out of a private registry:
+
+```
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+```
+
+This will cause `@mycorp` to be mapped to the registry for future
+installation of packages specified according to the pattern
+`@mycorp/package`.
+
+This will also cause `npm init` to create a scoped package.
+
+```
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+```
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces-update`
+
+* Default: true
+* Type: Boolean
+
+If set to true, the npm cli will run an update after operations that may
+possibly change the workspaces installed to the `node_modules` folder.
+
+
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [init-package-json module](http://npm.im/init-package-json)
+* [package.json](/configuring-npm/package-json)
+* [npm version](/commands/npm-version)
+* [npm scope](/using-npm/scope)
+* [npm exec](/commands/npm-exec)
+* [npm workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-install-ci-test.md b/node/node_modules/npm/docs/content/commands/npm-install-ci-test.md
new file mode 100644
index 0000000000000000000000000000000000000000..0e8b04c26634df13d8054e897936a2e32874da6b
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-install-ci-test.md
@@ -0,0 +1,283 @@
+---
+title: npm-install-ci-test
+section: 1
+description: Install a project with a clean slate and run tests
+---
+
+### Synopsis
+
+```bash
+npm install-ci-test
+
+aliases: cit, clean-install-test, sit
+```
+
+### Description
+
+This command runs `npm ci` followed immediately by `npm test`.
+
+### Configuration
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm install-test](/commands/npm-install-test)
+* [npm ci](/commands/npm-ci)
+* [npm test](/commands/npm-test)
diff --git a/node/node_modules/npm/docs/content/commands/npm-install-test.md b/node/node_modules/npm/docs/content/commands/npm-install-test.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d688974bf1cab6fd975507d738f4ba2ece30a4c
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-install-test.md
@@ -0,0 +1,424 @@
+---
+title: npm-install-test
+section: 1
+description: Install package(s) and run tests
+---
+
+### Synopsis
+
+```bash
+npm install-test [<package-spec> ...]
+
+alias: it
+```
+
+### Description
+
+This command runs an `npm install` followed immediately by an `npm test`.
+It takes exactly the same arguments as `npm install`.
+
+### Configuration
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `save-exact`
+
+* Default: false
+* Type: Boolean
+
+Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `prefer-dedupe`
+
+* Default: false
+* Type: Boolean
+
+Prefer to deduplicate packages if possible, rather than choosing a newer
+version of a dependency.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `before`
+
+* Default: null
+* Type: null or Date
+
+If passed to `npm install`, will rebuild the npm tree such that only
+versions that were available **on or before** the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.
+
+If the requested version is a `dist-tag` and the given tag does not pass the
+`--before` filter, the most recent version less than or equal to that tag
+will be used. For example, `foo@latest` might install `foo@1.2` even though
+`latest` is `2.0`.
+
+This config cannot be used with: `min-release-age`
+
+#### `min-release-age`
+
+* Default: null
+* Type: null or Number
+
+If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.
+
+This flag is a complement to `before`, which accepts an exact date instead
+of a relative number of days.
+
+This config cannot be used with: `before`
+
+This value is not exported to the environment for child processes.
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `cpu`
+
+* Default: null
+* Type: null or String
+
+Override CPU architecture of native modules to install. Acceptable values
+are same as `cpu` field of package.json, which comes from `process.arch`.
+
+
+
+#### `os`
+
+* Default: null
+* Type: null or String
+
+Override OS of native modules to install. Acceptable values are same as `os`
+field of package.json, which comes from `process.platform`.
+
+
+
+#### `libc`
+
+* Default: null
+* Type: null or String
+
+Override libc of native modules to install. Acceptable values are same as
+`libc` field of package.json
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm install](/commands/npm-install)
+* [npm install-ci-test](/commands/npm-install-ci-test)
+* [npm test](/commands/npm-test)
diff --git a/node/node_modules/npm/docs/content/commands/npm-install.md b/node/node_modules/npm/docs/content/commands/npm-install.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d5cf2a6e9b558bd07fe94ef539687f71aa4c165
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-install.md
@@ -0,0 +1,807 @@
+---
+title: npm-install
+section: 1
+description: Install a package
+---
+
+### Synopsis
+
+```bash
+npm install [<package-spec> ...]
+
+aliases: add, i, in, ins, inst, insta, instal, isnt, isnta, isntal, isntall
+```
+
+### Description
+
+This command installs a package and any packages that it depends on.
+If the package has a package-lock, or an npm shrinkwrap file, or a yarn lock file, the installation of dependencies will be driven by that, respecting the following order of precedence:
+
+* `npm-shrinkwrap.json`
+* `package-lock.json`
+* `yarn.lock`
+
+See [package-lock.json](/configuring-npm/package-lock-json) and [`npm shrinkwrap`](/commands/npm-shrinkwrap).
+
+#### How `npm install` uses `package-lock.json`
+
+When you run `npm install` without arguments, npm compares `package.json` and `package-lock.json`:
+
+* **If the lockfile's resolved versions satisfy the `package.json` ranges:** npm uses the exact versions from `package-lock.json` to ensure reproducible builds across environments.
+
+* **If the ranges don't match:** npm resolves new versions that satisfy the `package.json` ranges and updates `package-lock.json` accordingly. This happens when you modify version ranges in `package.json` (e.g., changing `^7.0.0` to `^8.0.0`). Note that changing a range within the same major version (e.g., `^7.0.0` to `^7.1.0`) will only update the metadata in the lockfile if the currently installed version still satisfies the new range.
+
+In essence, `package-lock.json` locks your dependencies to specific versions, but `package.json` is the source of truth for acceptable version ranges. When the lockfile's versions satisfy the `package.json` ranges, the lockfile wins. When they conflict, `package.json` wins and the lockfile is updated.
+
+If you want to install packages while ensuring that `package.json` is not modified and that both files are strictly in sync, use [`npm ci`](/commands/npm-ci) instead.
+
+A `package` is:
+
+* a) a folder containing a program described by a [`package.json`](/configuring-npm/package-json) file
+* b) a gzipped tarball containing (a)
+* c) a url that resolves to (b)
+* d) a `<name>@<version>` that is published on the registry (see [`registry`](/using-npm/registry)) with (c)
+* e) a `<name>@<tag>` (see [`npm dist-tag`](/commands/npm-dist-tag)) that points to (d)
+* f) a `<name>` that has a "latest" tag satisfying (e)
+* g) a `<git remote url>` that resolves to (a)
+
+Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).
+
+
+* `npm install` (in a package directory, no arguments):
+
+    Install the dependencies to the local `node_modules` folder.
+
+    In global mode (ie, with `-g` or `--global` appended to the command), it installs the current package context (ie, the current working directory) as a global package.
+
+    By default, `npm install` will install all modules listed as dependencies in [`package.json`](/configuring-npm/package-json).
+
+    With the `--production` flag (or when the `NODE_ENV` environment variable is set to `production`), npm will not install modules listed in `devDependencies`.
+    To install all modules listed in both `dependencies` and `devDependencies` when `NODE_ENV` environment variable is set to `production`, you can use `--production=false`.
+
+    > NOTE: The `--production` flag has no particular meaning when adding a dependency to a project.
+
+* `npm install <folder>`:
+
+    If `<folder>` sits inside the root of your project, its dependencies will be installed and may be hoisted to the top-level `node_modules` as they would for other types of dependencies.
+    If `<folder>` sits outside the root of your project, *npm will not install the package dependencies* in the directory `<folder>`, but it will create a symlink to `<folder>`.
+
+    > NOTE: If you want to install the content of a directory like a package from the registry instead of creating a link, you would need to use the `--install-links` option.
+
+    Example:
+
+    ```bash
+    npm install ../../other-package --install-links
+    npm install ./sub-package
+    ```
+
+* `npm install <tarball file>`:
+
+    Install a package that is sitting on the filesystem.
+    Note: if you just want to link a dev directory into your npm root, you can do this more easily by using [`npm link`](/commands/npm-link).
+
+    Tarball requirements:
+    * The filename *must* use `.tar`, `.tar.gz`, or `.tgz` as the extension.
+    * The package contents should reside in a subfolder inside the tarball (usually it is called `package/`).
+      npm strips one directory layer when installing the package (an equivalent of `tar x --strip-components=1` is run).
+    * The package must contain a `package.json` file with `name` and `version` properties.
+
+    Example:
+
+    ```bash
+    npm install ./package.tgz
+    ```
+
+* `npm install <tarball url>`:
+
+    Fetch the tarball url, and then install it.
+    In order to distinguish between this and other options, the argument must start with "http://" or "https://"
+
+    Example:
+
+    ```bash
+    npm install https://github.com/indexzero/forever/tarball/v0.5.6
+    ```
+
+* `npm install [<@scope>/]<name>`:
+
+    Do a `<name>@<tag>` install, where `<tag>` is the "tag" config.
+    (See [`config`](/using-npm/config#tag).
+    The config's default value is `latest`.)
+
+    In most cases, this will install the version of the modules tagged as `latest` on the npm registry.
+
+    **Note:** When installing by name without specifying a version or tag, npm prioritizes versions that match the current Node.js version based on the package's `engines` field. If the `latest` tag points to a version incompatible with your current Node.js version, npm will install the newest compatible version instead. To install a specific version regardless of `engines` compatibility, explicitly specify the version or tag: `npm install <name>@latest`.
+
+    Example:
+
+    ```bash
+    npm install sax
+    ```
+
+    `npm install` saves any specified packages into `dependencies` by default.
+    Additionally, you can control where and how they get saved with some additional flags:
+
+    * `-P, --save-prod`: Package will appear in your `dependencies`.
+      This is the default unless `-D` or `-O` are present.
+
+    * `-D, --save-dev`: Package will appear in your `devDependencies`.
+
+    * `--save-peer`: Package will appear in your `peerDependencies`.
+
+    * `-O, --save-optional`: Package will appear in your
+      `optionalDependencies`.
+
+    * `--no-save`: Prevents saving to `dependencies`.
+
+    When using any of the above options to save dependencies to your package.json, there are two additional, optional flags:
+
+    * `-E, --save-exact`: Saved dependencies will be configured with an exact version rather than using npm's default semver range operator.
+
+    * `-B, --save-bundle`: Saved dependencies will also be added to your `bundleDependencies` list.
+
+    Further, if you have an `npm-shrinkwrap.json` or `package-lock.json` then it will be updated as well.
+
+    `<scope>` is optional.
+    The package will be downloaded from the registry associated with the specified scope.
+    If no registry is associated with the given scope the default registry is assumed.
+    See [`scope`](/using-npm/scope).
+
+    Note: if you do not include the @-symbol on your scope name, npm will interpret this as a GitHub repository instead, see below.
+    Scopes names must also be followed by a slash.
+
+    Examples:
+
+    ```bash
+    npm install sax
+    npm install githubname/reponame
+    npm install @myorg/privatepackage
+    npm install node-tap --save-dev
+    npm install dtrace-provider --save-optional
+    npm install readable-stream --save-exact
+    npm install ansi-regex --save-bundle
+    ```
+
+* `npm install <alias>@npm:<name>`:
+
+    Install a package under a custom alias.
+    Allows multiple versions of a same-name package side-by-side, more convenient import names for packages with otherwise long ones, and using git forks replacements or forked npm packages as replacements.
+    Aliasing works only on your project and does not rename packages in transitive dependencies.
+    Aliases should follow the naming conventions stated in [`validate-npm-package-name`](https://www.npmjs.com/package/validate-npm-package-name#naming-rules).
+
+    Examples:
+
+    ```bash
+    npm install my-react@npm:react
+    npm install jquery2@npm:jquery@2
+    npm install jquery3@npm:jquery@3
+    npm install npa@npm:npm-package-arg
+    ```
+
+* `npm install [<@scope>/]<name>@<tag>`:
+
+    Install the version of the package that is referenced by the specified tag.
+    If the tag does not exist in the registry data for that package, then this will fail.
+
+    Example:
+
+    ```bash
+    npm install sax@latest
+    npm install @myorg/mypackage@latest
+    ```
+
+* `npm install [<@scope>/]<name>@<version>`:
+
+    Install the specified version of the package.
+    This will fail if the version has not been published to the registry.
+
+    Example:
+
+    ```bash
+    npm install sax@0.1.1
+    npm install @myorg/privatepackage@1.5.0
+    ```
+
+* `npm install [<@scope>/]<name>@<version range>`:
+
+    Install a version of the package matching the specified version range.
+    This will follow the same rules for resolving dependencies described in [`package.json`](/configuring-npm/package-json).
+
+    Note that most version ranges must be put in quotes so that your shell will treat it as a single argument.
+
+    Example:
+
+    ```bash
+    npm install sax@">=0.1.0 <0.2.0"
+    npm install @myorg/privatepackage@"16 - 17"
+    ```
+
+    **Prerelease versions:** By default, version ranges only match stable versions. To include prerelease versions, they must be explicitly specified in the range. Prerelease versions are tied to a specific version triple (major.minor.patch). For example, `^1.2.3-beta.1` will only match prereleases for `1.2.x`, not `1.3.x`. To match all prereleases for a major version, use a range like `^1.0.0-0`, which will include all `1.x.x` prereleases.
+
+    Example:
+
+    ```bash
+    npm install package@^1.2.3-beta.1  # Matches 1.2.3-beta.1, 1.2.3-beta.2, 1.2.4-beta.1, etc.
+    npm install package@^1.0.0-0       # Matches all 1.x.x prereleases and stable versions
+    ```
+
+* `npm install <git remote url>`:
+
+    Installs the package from the hosted git provider, cloning it with `git`.
+    For a full git remote url, only that URL will be attempted.
+
+    ```bash
+    <protocol>://[<user>[:<password>]@]<hostname>[:<port>][:][/]<path>[#<commit-ish> | #semver:<semver>]
+    ```
+
+    `<protocol>` is one of `git`, `git+ssh`, `git+http`, `git+https`, or
+    `git+file`.
+
+    If `#<commit-ish>` is provided, it will be used to clone exactly that commit.
+    If the commit-ish has the format `#semver:<semver>`, `<semver>` can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+    If neither `#<commit-ish>` or `#semver:<semver>` is specified, then the default branch of the repository is used.
+
+    If the repository makes use of submodules, those submodules will be cloned as well.
+
+    If the package being installed contains a `prepare` script, its `dependencies` and `devDependencies` will be installed, and the prepare script will be run, before the package is packaged and installed.
+
+    The following git environment variables are recognized by npm and will be added to the environment when running git:
+
+    * `GIT_ASKPASS`
+    * `GIT_EXEC_PATH`
+    * `GIT_PROXY_COMMAND`
+    * `GIT_SSH`
+    * `GIT_SSH_COMMAND`
+    * `GIT_SSL_CAINFO`
+    * `GIT_SSL_NO_VERIFY`
+
+    See the git man page for details.
+
+    Examples:
+
+    ```bash
+    npm install git+ssh://git@github.com:npm/cli.git#v1.0.27
+    npm install git+ssh://git@github.com:npm/cli#pull/273
+    npm install git+ssh://git@github.com:npm/cli#semver:^5.0
+    npm install git+https://isaacs@github.com/npm/cli.git
+    npm install git://github.com/npm/cli.git#v1.0.27
+    GIT_SSH_COMMAND='ssh -i ~/.ssh/custom_ident' npm install git+ssh://git@github.com:npm/cli.git
+    ```
+
+* `npm install <githubname>/<githubrepo>[#<commit-ish>]`:
+* `npm install github:<githubname>/<githubrepo>[#<commit-ish>]`:
+
+    Install the package at `https://github.com/githubname/githubrepo` by attempting to clone it using `git`.
+
+    If `#<commit-ish>` is provided, it will be used to clone exactly that commit.
+    If the commit-ish has the format `#semver:<semver>`, `<semver>` can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+    If neither `#<commit-ish>` or `#semver:<semver>` is specified, then the default branch is used.
+
+    As with regular git dependencies, `dependencies` and `devDependencies` will be installed if the package has a `prepare` script before the package is done installing.
+
+    Examples:
+
+    ```bash
+    npm install mygithubuser/myproject
+    npm install github:mygithubuser/myproject
+   ```
+
+* `npm install gist:[<githubname>/]<gistID>[#<commit-ish>|#semver:<semver>]`:
+
+    Install the package at `https://gist.github.com/gistID` by attempting to clone it using `git`.
+    The GitHub username associated with the gist is optional and will not be saved in `package.json`.
+
+    As with regular git dependencies, `dependencies` and `devDependencies` will be installed if the package has a `prepare` script before the package is done installing.
+
+    Example:
+
+    ```bash
+    npm install gist:101a11beef
+    ```
+
+* `npm install bitbucket:<bitbucketname>/<bitbucketrepo>[#<commit-ish>]`:
+
+    Install the package at `https://bitbucket.org/bitbucketname/bitbucketrepo` by attempting to clone it using `git`.
+
+    If `#<commit-ish>` is provided, it will be used to clone exactly that commit.
+    If the commit-ish has the format `#semver:<semver>`, `<semver>` can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+    If neither `#<commit-ish>` or `#semver:<semver>` is specified, then `master` is used.
+
+    As with regular git dependencies, `dependencies` and `devDependencies` will be installed if the package has a `prepare` script before the package is done installing.
+
+    Example:
+
+    ```bash
+    npm install bitbucket:mybitbucketuser/myproject
+    ```
+
+* `npm install gitlab:<gitlabname>/<gitlabrepo>[#<commit-ish>]`:
+
+    Install the package at `https://gitlab.com/gitlabname/gitlabrepo` by attempting to clone it using `git`.
+
+    If `#<commit-ish>` is provided, it will be used to clone exactly that commit.
+    If the commit-ish has the format `#semver:<semver>`, `<semver>` can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+    If neither `#<commit-ish>` or `#semver:<semver>` is specified, then `master` is used.
+
+    As with regular git dependencies, `dependencies` and `devDependencies` will be installed if the package has a `prepare` script before the package is done installing.
+
+    Example:
+
+    ```bash
+    npm install gitlab:mygitlabuser/myproject
+    npm install gitlab:myusr/myproj#semver:^5.0
+    ```
+
+You may combine multiple arguments and even multiple types of arguments.
+For example:
+
+```bash
+npm install sax@">=0.1.0 <0.2.0" bench supervisor
+```
+
+The `--tag` argument will apply to all of the specified install targets.
+If a tag with the given name exists, the tagged version is preferred over newer versions.
+
+**Note:** The `--tag` option only affects packages specified on the command line. It does not override version ranges specified in `package.json`. For example, if `package.json` specifies `"foo": "^1.0.0"` and you run `npm install --tag beta`, npm will still install a version matching `^1.0.0` even if the `beta` tag points to a different version. To install a tagged version, specify the package explicitly: `npm install foo@beta`.
+
+The `--dry-run` argument will report in the usual way what the install would have done without actually installing anything.
+
+The `--package-lock-only` argument will only update the `package-lock.json`, instead of checking `node_modules` and downloading dependencies.
+
+The `-f` or `--force` argument will force npm to fetch remote resources even if a local copy exists on disk.
+
+```bash
+npm install sax --force
+```
+
+### Configuration
+
+See the [`config`](/using-npm/config) help doc.
+Many of the configuration params have some effect on installation, since that's most of what npm does.
+
+These are some of the most common options related to installation.
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `save-exact`
+
+* Default: false
+* Type: Boolean
+
+Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `prefer-dedupe`
+
+* Default: false
+* Type: Boolean
+
+Prefer to deduplicate packages if possible, rather than choosing a newer
+version of a dependency.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `before`
+
+* Default: null
+* Type: null or Date
+
+If passed to `npm install`, will rebuild the npm tree such that only
+versions that were available **on or before** the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.
+
+If the requested version is a `dist-tag` and the given tag does not pass the
+`--before` filter, the most recent version less than or equal to that tag
+will be used. For example, `foo@latest` might install `foo@1.2` even though
+`latest` is `2.0`.
+
+This config cannot be used with: `min-release-age`
+
+#### `min-release-age`
+
+* Default: null
+* Type: null or Number
+
+If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.
+
+This flag is a complement to `before`, which accepts an exact date instead
+of a relative number of days.
+
+This config cannot be used with: `before`
+
+This value is not exported to the environment for child processes.
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `cpu`
+
+* Default: null
+* Type: null or String
+
+Override CPU architecture of native modules to install. Acceptable values
+are same as `cpu` field of package.json, which comes from `process.arch`.
+
+
+
+#### `os`
+
+* Default: null
+* Type: null or String
+
+Override OS of native modules to install. Acceptable values are same as `os`
+field of package.json, which comes from `process.platform`.
+
+
+
+#### `libc`
+
+* Default: null
+* Type: null or String
+
+Override libc of native modules to install. Acceptable values are same as
+`libc` field of package.json
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### Algorithm
+
+Given a `package{dep}` structure: `A{B,C}, B{C}, C{D}`, the npm install algorithm produces:
+
+```bash
+A
++-- B
++-- C
++-- D
+```
+
+That is, the dependency from B to C is satisfied by the fact that A already caused C to be installed at a higher level.
+D is still installed at the top level because nothing conflicts with it.
+
+For `A{B,C}, B{C,D@1}, C{D@2}`, this algorithm produces:
+
+```bash
+A
++-- B
++-- C
+   `-- D@2
++-- D@1
+```
+
+Because B's D@1 will be installed in the top-level, C now has to install D@2 privately for itself.
+This algorithm is deterministic, but different trees may be produced if two dependencies are requested for installation in a different order.
+
+See [folders](/configuring-npm/folders) for a more detailed description of the specific folder structures that npm creates.
+
+### See Also
+
+* [npm folders](/configuring-npm/folders)
+* [npm update](/commands/npm-update)
+* [npm audit](/commands/npm-audit)
+* [npm fund](/commands/npm-fund)
+* [npm link](/commands/npm-link)
+* [npm rebuild](/commands/npm-rebuild)
+* [npm scripts](/using-npm/scripts)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm registry](/using-npm/registry)
+* [npm dist-tag](/commands/npm-dist-tag)
+* [npm uninstall](/commands/npm-uninstall)
+* [npm shrinkwrap](/commands/npm-shrinkwrap)
+* [package.json](/configuring-npm/package-json)
+* [workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-link.md b/node/node_modules/npm/docs/content/commands/npm-link.md
new file mode 100644
index 0000000000000000000000000000000000000000..574be114dbf5f53859cb44796c64219ba2cdcb6d
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-link.md
@@ -0,0 +1,393 @@
+---
+title: npm-link
+section: 1
+description: Symlink a package folder
+---
+
+### Synopsis
+
+```bash
+npm link [<package-spec>]
+
+alias: ln
+```
+
+### Description
+
+This is handy for installing your own stuff, so that you can work on it and test iteratively without having to continually rebuild.
+
+Package linking is a two-step process.
+
+First, `npm link` in a package folder with no arguments will create a symlink in the global folder `{prefix}/lib/node_modules/<package>` that links to the package where the `npm link` command was executed.
+It will also link any bins in the package to `{prefix}/bin/{name}`.
+Note that `npm link` uses the global prefix (see `npm prefix -g` for its value).
+
+Next, in some other location, `npm link package-name` will create a symbolic link from globally-installed `package-name` to `node_modules/` of the current folder.
+
+Note that `package-name` is taken from `package.json`, _not_ from the directory name.
+
+The package name can be optionally prefixed with a scope.
+See [`scope`](/using-npm/scope).
+The scope must be preceded by an @-symbol and followed by a slash.
+
+When creating tarballs for `npm publish`, the linked packages are "snapshotted" to their current state by resolving the symbolic links, if they are included in `bundleDependencies`.
+
+For example:
+
+```bash
+cd ~/projects/node-redis    # go into the package directory
+npm link                    # creates global link
+cd ~/projects/node-bloggy   # go into some other package directory.
+npm link redis              # link-install the package
+```
+
+Now, any changes to `~/projects/node-redis` will be reflected in
+`~/projects/node-bloggy/node_modules/node-redis/`.
+Note that the link should be to the package name, not the directory name for that package.
+
+You may also shortcut the two steps in one.
+For example, to do the above use-case in a shorter way:
+
+```bash
+cd ~/projects/node-bloggy  # go into the dir of your main project
+npm link ../node-redis     # link the dir of your dependency
+```
+
+The second line is the equivalent of doing:
+
+```bash
+(cd ../node-redis; npm link)
+npm link redis
+```
+
+That is, it first creates a global link, and then links the global installation target into your project's `node_modules` folder.
+
+Note that in this case, you are referring to the directory name,
+`node-redis`, rather than the package name `redis`.
+
+If your linked package is scoped (see [`scope`](/using-npm/scope)) your link command must include that scope, e.g.
+
+```bash
+npm link @myorg/privatepackage
+```
+
+### Caveat
+
+Note that package dependencies linked in this way are _not_ saved to `package.json` by default, on the assumption that the intention is to have a link stand in for a regular non-link dependency.
+Otherwise, for example, if you depend on `redis@^3.0.1`, and ran `npm link redis`, it would replace the `^3.0.1` dependency with `file:../path/to/node-redis`, which you probably don't want!  Additionally, other users or developers on your project would run into issues if they do not have their folders set up exactly the same as yours.
+
+If you are adding a _new_ dependency as a link, you should add it to the relevant metadata by running `npm install <dep> --package-lock-only`.
+
+If you _want_ to save the `file:` reference in your `package.json` and `package-lock.json` files, you can use `npm link <dep> --save` to do so.
+
+### Workspace Usage
+
+`npm link <pkg> --workspace <name>` will link the relevant package as a dependency of the specified workspace(s).
+Note that It may actually be linked into the parent project's `node_modules` folder, if there are no conflicting dependencies.
+
+`npm link --workspace <name>` will create a global link to the specified workspace(s).
+
+### Configuration
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `save-exact`
+
+* Default: false
+* Type: Boolean
+
+Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm developers](/using-npm/developers)
+* [package.json](/configuring-npm/package-json)
+* [npm install](/commands/npm-install)
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-ll.md b/node/node_modules/npm/docs/content/commands/npm-ll.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9509c963574caf1db89f8f7eab2cbc11d458c60
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-ll.md
@@ -0,0 +1,229 @@
+---
+title: npm-ll
+section: 1
+description: List installed packages
+---
+
+### Synopsis
+
+```bash
+npm ll [[<@scope>/]<pkg> ...]
+
+alias: la
+```
+
+### Description
+
+List installed packages
+
+### Configuration
+
+#### `all`
+
+* Default: false
+* Type: Boolean
+
+When running `npm outdated` and `npm ls`, setting `--all` will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `depth`
+
+* Default: `Infinity` if `--all` is set; otherwise, `0`
+* Type: null or Number
+
+The depth to go when recursing packages for `npm ls`.
+
+If not set, `npm ls` will show only the immediate dependencies of the root
+project. If `--all` is set, then npm will show all dependencies by default.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `link`
+
+* Default: false
+* Type: Boolean
+
+Used with `npm ls`, limiting output to only those packages that are linked.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `unicode`
+
+* Default: false on windows, true on mac/unix systems with a unicode locale,
+  as defined by the `LC_ALL`, `LC_CTYPE`, or `LANG` environment variables.
+* Type: Boolean
+
+When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm help config](/commands/npm-config)
diff --git a/node/node_modules/npm/docs/content/commands/npm-login.md b/node/node_modules/npm/docs/content/commands/npm-login.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea0150ec523e5b7c7682d6c51a21b0bc179b3b0a
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-login.md
@@ -0,0 +1,93 @@
+---
+title: npm-login
+section: 1
+description: Login to a registry user account
+---
+
+### Synopsis
+
+```bash
+npm login
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Verify a user in the specified registry, and save the credentials to the
+`.npmrc` file.
+If no registry is specified, the default registry will be used (see [`config`](/using-npm/config)).
+
+When you run `npm login`, the CLI automatically generates a legacy token of `publish` type.
+For more information, see [About legacy tokens](/about-access-tokens#about-legacy-tokens).
+
+When using `legacy` for your `auth-type`, the username and password, are read in from prompts.
+
+To reset your password, go to <https://www.npmjs.com/forgot>
+
+To change your email address, go to <https://www.npmjs.com/email-edit>
+
+You may use this command multiple times with the same user account to authorize on a new machine.
+When authenticating on a new machine, the username, password and email address must all match with your existing record.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `scope`
+
+* Default: the scope of the current project, if any, or ""
+* Type: String
+
+Associate an operation with a scope for a scoped registry.
+
+Useful when logging in to or out of a private registry:
+
+```
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+```
+
+This will cause `@mycorp` to be mapped to the registry for future
+installation of packages specified according to the pattern
+`@mycorp/package`.
+
+This will also cause `npm init` to create a scoped package.
+
+```
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+```
+
+
+
+#### `auth-type`
+
+* Default: "web"
+* Type: "legacy" or "web"
+
+What authentication strategy to use with `login`. Note that if an `otp`
+config is given, this value will always be set to `legacy`.
+
+
+
+### See Also
+
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm owner](/commands/npm-owner)
+* [npm whoami](/commands/npm-whoami)
+* [npm token](/commands/npm-token)
+* [npm profile](/commands/npm-profile)
diff --git a/node/node_modules/npm/docs/content/commands/npm-logout.md b/node/node_modules/npm/docs/content/commands/npm-logout.md
new file mode 100644
index 0000000000000000000000000000000000000000..e26badb465e44e30ea48410fc707a8b7c0fa4e4d
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-logout.md
@@ -0,0 +1,72 @@
+---
+title: npm-logout
+section: 1
+description: Log out of the registry
+---
+
+### Synopsis
+
+```bash
+npm logout
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+When logged into a registry that supports token-based authentication, tell the server to end this token's session.
+This will invalidate the token everywhere you're using it, not just for the current environment.
+
+When logged into a legacy registry that uses username and password authentication, this will clear the credentials in your user configuration.
+In this case, it will _only_ affect the current environment.
+
+If `--scope` is provided, this will find the credentials for the registry connected to that scope, if set.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `scope`
+
+* Default: the scope of the current project, if any, or ""
+* Type: String
+
+Associate an operation with a scope for a scoped registry.
+
+Useful when logging in to or out of a private registry:
+
+```
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+```
+
+This will cause `@mycorp` to be mapped to the registry for future
+installation of packages specified according to the pattern
+`@mycorp/package`.
+
+This will also cause `npm init` to create a scoped package.
+
+```
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+```
+
+
+
+### See Also
+
+* [npm adduser](/commands/npm-adduser)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npm whoami](/commands/npm-whoami)
diff --git a/node/node_modules/npm/docs/content/commands/npm-ls.md b/node/node_modules/npm/docs/content/commands/npm-ls.md
new file mode 100644
index 0000000000000000000000000000000000000000..19f024593f3a8258f368b3fc0072fe7407c89228
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-ls.md
@@ -0,0 +1,259 @@
+---
+title: npm-ls
+section: 1
+description: List installed packages
+---
+
+### Synopsis
+
+```bash
+npm ls <package-spec>
+
+alias: list
+```
+
+### Description
+
+This command will print to stdout all the versions of packages that are installed, as well as their dependencies when `--all` is specified, in a tree structure.
+
+Note: to get a "bottoms up" view of why a given package is included in the tree at all, use [`npm explain`](/commands/npm-explain).
+
+Positional arguments are `name@version-range` identifiers, which will limit the results to only the paths to the packages named.
+Note that nested packages will *also* show the paths to the specified packages.
+For example, running `npm ls promzard` in npm's source tree will show:
+
+```bash
+npm@11.13.0 /path/to/npm
+└─┬ init-package-json@0.0.4
+  └── promzard@0.1.5
+```
+
+It will print out extraneous, missing, and invalid packages.
+
+If a project specifies git urls for dependencies these are shown in parentheses after the `name@version` to make it easier for users to recognize potential forks of a project.
+
+The tree shown is the logical dependency tree, based on package dependencies, not the physical layout of your `node_modules` folder.
+
+When run as `ll` or `la`, it shows extended information by default.
+
+### Configuration
+
+#### `all`
+
+* Default: false
+* Type: Boolean
+
+When running `npm outdated` and `npm ls`, setting `--all` will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `depth`
+
+* Default: `Infinity` if `--all` is set; otherwise, `0`
+* Type: null or Number
+
+The depth to go when recursing packages for `npm ls`.
+
+If not set, `npm ls` will show only the immediate dependencies of the root
+project. If `--all` is set, then npm will show all dependencies by default.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `link`
+
+* Default: false
+* Type: Boolean
+
+Used with `npm ls`, limiting output to only those packages that are linked.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `unicode`
+
+* Default: false on windows, true on mac/unix systems with a unicode locale,
+  as defined by the `LC_ALL`, `LC_CTYPE`, or `LANG` environment variables.
+* Type: Boolean
+
+When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm explain](/commands/npm-explain)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm folders](/configuring-npm/folders)
+* [npm explain](/commands/npm-explain)
+* [npm install](/commands/npm-install)
+* [npm link](/commands/npm-link)
+* [npm prune](/commands/npm-prune)
+* [npm outdated](/commands/npm-outdated)
+* [npm update](/commands/npm-update)
diff --git a/node/node_modules/npm/docs/content/commands/npm-org.md b/node/node_modules/npm/docs/content/commands/npm-org.md
new file mode 100644
index 0000000000000000000000000000000000000000..04c617f15b06d2fb6112fc5d605f182fa9947835
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-org.md
@@ -0,0 +1,113 @@
+---
+title: npm-org
+section: 1
+description: Manage orgs
+---
+
+### Synopsis
+
+```bash
+npm org set orgname username [developer | admin | owner]
+npm org rm orgname username
+npm org ls orgname [<username>]
+
+alias: ogr
+```
+
+Note: This command is unaware of workspaces.
+
+### Example
+
+Add a new developer to an org:
+
+```bash
+$ npm org set my-org @mx-smith
+```
+
+Add a new admin to an org (or change a developer to an admin):
+
+```bash
+$ npm org set my-org @mx-santos admin
+```
+
+Remove a user from an org:
+
+```bash
+$ npm org rm my-org mx-santos
+```
+
+List all users in an org:
+
+```bash
+$ npm org ls my-org
+```
+
+List all users in JSON format:
+
+```bash
+$ npm org ls my-org --json
+```
+
+See what role a user has in an org:
+
+```bash
+$ npm org ls my-org @mx-santos
+```
+
+### Description
+
+You can use the `npm org` commands to manage and view users of an organization.
+It supports adding and removing users, changing their roles, listing them, and finding specific ones and their roles.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+### See Also
+
+* [using orgs](/using-npm/orgs)
+* [Documentation on npm Orgs](https://docs.npmjs.com/orgs/)
diff --git a/node/node_modules/npm/docs/content/commands/npm-outdated.md b/node/node_modules/npm/docs/content/commands/npm-outdated.md
new file mode 100644
index 0000000000000000000000000000000000000000..4881ce3c2db261440b821f1246108bacc2062170
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-outdated.md
@@ -0,0 +1,194 @@
+---
+title: npm-outdated
+section: 1
+description: Check for outdated packages
+---
+
+### Synopsis
+
+```bash
+npm outdated [<package-spec> ...]
+```
+
+### Description
+
+This command will check the registry to see if any (or, specific) installed packages are currently outdated.
+
+By default, only the direct dependencies of the root project and direct dependencies of your configured *workspaces* are shown.
+Use `--all` to find all outdated meta-dependencies as well.
+
+In the output:
+
+* `wanted` is the maximum version of the package that satisfies the semver range specified in `package.json`.
+  If there's no available semver range (i.e. you're running `npm outdated --global`, or the package isn't included in `package.json`), then `wanted` shows the currently-installed version.
+* `latest` is the version of the package tagged as latest in the registry.
+  Running `npm publish` with no special configuration will publish the package with a dist-tag of `latest`.
+  This may or may not be the maximum version of the package, or the most-recently published version of the package, depending on how the package's developer manages the latest [dist-tag](/commands/npm-dist-tag).
+* `location` is where in the physical tree the package is located.
+* `depended by` shows which package depends on the displayed dependency
+* `package type` (when using `--long` / `-l`) tells you whether this package is a `dependency` or a dev/peer/optional dependency.
+  Packages not included in `package.json` are always marked `dependencies`.
+* `homepage` (when using `--long` / `-l`) is the `homepage` value contained in the package's packument
+* `depended by location` (when using `--long` / `-l`) shows location of the package that depends on the displayed dependency
+* Red means there's a newer version matching your semver requirements, so you should update now.
+* Yellow indicates that there's a newer version _above_ your semver requirements (usually new major, or new 0.x minor) so proceed with caution.
+
+### An example
+
+```bash
+$ npm outdated
+Package      Current   Wanted   Latest  Location                  Depended by
+glob          5.0.15   5.0.15    6.0.1  node_modules/glob         dependent-package-name
+nothingness    0.0.3      git      git  node_modules/nothingness  dependent-package-name
+npm            3.5.1    3.5.2    3.5.1  node_modules/npm          dependent-package-name
+local-dev      0.0.3   linked   linked  local-dev                 dependent-package-name
+once           1.3.2    1.3.3    1.3.3  node_modules/once         dependent-package-name
+```
+
+With these `dependencies`:
+```json
+{
+  "glob": "^5.0.15",
+  "nothingness": "github:othiym23/nothingness#master",
+  "npm": "^3.5.1",
+  "once": "^1.3.1"
+}
+```
+
+A few things to note:
+
+* `glob` requires `^5`, which prevents npm from installing `glob@6`, which is outside the semver range.
+* Git dependencies will always be reinstalled, because of how they're specified.
+  The installed committish might satisfy the dependency specifier (if it's something immutable, like a commit SHA), or it might not, so `npm outdated` and `npm update` have to fetch Git repos to check.
+  This is why currently doing a reinstall of a Git dependency always forces a new clone and install.
+* `npm@3.5.2` is marked as "wanted", but "latest" is `npm@3.5.1` because npm uses dist-tags to manage its `latest` and `next` release channels.
+  `npm update` will install the _newest_ version, but `npm install npm` (with no semver range) will install whatever's tagged as `latest`.
+* `once` is just plain out of date.
+  Reinstalling `node_modules` from scratch or running `npm update` will bring it up to spec.
+
+### Configuration
+
+#### `all`
+
+* Default: false
+* Type: Boolean
+
+When running `npm outdated` and `npm ls`, setting `--all` will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `before`
+
+* Default: null
+* Type: null or Date
+
+If passed to `npm install`, will rebuild the npm tree such that only
+versions that were available **on or before** the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.
+
+If the requested version is a `dist-tag` and the given tag does not pass the
+`--before` filter, the most recent version less than or equal to that tag
+will be used. For example, `foo@latest` might install `foo@1.2` even though
+`latest` is `2.0`.
+
+This config cannot be used with: `min-release-age`
+
+#### `min-release-age`
+
+* Default: null
+* Type: null or Number
+
+If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.
+
+This flag is a complement to `before`, which accepts an exact date instead
+of a relative number of days.
+
+This config cannot be used with: `before`
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm update](/commands/npm-update)
+* [npm dist-tag](/commands/npm-dist-tag)
+* [npm registry](/using-npm/registry)
+* [npm folders](/configuring-npm/folders)
+* [npm workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-owner.md b/node/node_modules/npm/docs/content/commands/npm-owner.md
new file mode 100644
index 0000000000000000000000000000000000000000..212b84e451a7b7a579aa5985d9c386c6fa0cb21e
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-owner.md
@@ -0,0 +1,104 @@
+---
+title: npm-owner
+section: 1
+description: Manage package owners
+---
+
+### Synopsis
+
+```bash
+npm owner add <user> <package-spec>
+npm owner rm <user> <package-spec>
+npm owner ls <package-spec>
+
+alias: author
+```
+
+### Description
+
+Manage ownership of published packages.
+
+* ls: List all the users who have access to modify a package and push new versions.
+Handy when you need to know who to bug for help.
+* add: Add a new user as a maintainer of a package.
+This user is enabled to modify metadata, publish new versions, and add other owners.
+* rm: Remove a user from the package owner list.
+This immediately revokes their privileges.
+
+Note that there is only one level of access.
+Either you can modify a package, or you can't.
+Future versions may contain more fine-grained access levels, but that is not implemented at this time.
+
+If you have two-factor authentication enabled with `auth-and-writes` (see [`npm-profile`](/commands/npm-profile)) then you'll need to go through a second factor flow when changing ownership or include an otp on the command line with `--otp`.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm profile](/commands/npm-profile)
+* [npm publish](/commands/npm-publish)
+* [npm registry](/using-npm/registry)
+* [npm adduser](/commands/npm-adduser)
diff --git a/node/node_modules/npm/docs/content/commands/npm-pack.md b/node/node_modules/npm/docs/content/commands/npm-pack.md
new file mode 100644
index 0000000000000000000000000000000000000000..ecbdc5d8042febf93eec56e36b866a6a6ba67ef4
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-pack.md
@@ -0,0 +1,135 @@
+---
+title: npm-pack
+section: 1
+description: Create a tarball from a package
+---
+
+### Synopsis
+
+```bash
+npm pack <package-spec>
+```
+
+### Configuration
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `pack-destination`
+
+* Default: "."
+* Type: String
+
+Directory in which `npm pack` will save tarballs.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+### Description
+
+For anything that's installable (that is, a package folder, tarball, tarball url, git url, name@tag, name@version, name, or scoped name), this command will fetch it to the cache, copy the tarball to the current working directory as `<name>-<version>.tgz`, and then write the filenames out to stdout.
+
+If the same package is specified multiple times, then the file will be overwritten the second time.
+
+If no arguments are supplied, then npm packs the current package folder.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm-packlist package](http://npm.im/npm-packlist)
+* [npm cache](/commands/npm-cache)
+* [npm publish](/commands/npm-publish)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-ping.md b/node/node_modules/npm/docs/content/commands/npm-ping.md
new file mode 100644
index 0000000000000000000000000000000000000000..31e4badd565a90c843e8a88231dee51052f143a0
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-ping.md
@@ -0,0 +1,46 @@
+---
+title: npm-ping
+section: 1
+description: Ping npm registry
+---
+
+### Synopsis
+
+```bash
+npm ping
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Ping the configured or given npm registry and verify authentication.
+If it works it will output something like:
+
+```bash
+npm notice PING https://registry.npmjs.org/
+npm notice PONG 255ms
+```
+otherwise you will get an error:
+```bash
+npm notice PING http://foo.com/
+npm ERR! code E404
+npm ERR! 404 Not Found - GET http://www.foo.com/-/ping?write=true
+```
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+### See Also
+
+* [npm doctor](/commands/npm-doctor)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-pkg.md b/node/node_modules/npm/docs/content/commands/npm-pkg.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef84b2e9f3e0d48ebab210beb1435ff0aaba84d6
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-pkg.md
@@ -0,0 +1,244 @@
+---
+title: npm-pkg
+section: 1
+description: Manages your package.json
+---
+
+### Synopsis
+
+```bash
+npm pkg set <key>=<value> [<key>=<value> ...]
+npm pkg get [<key> [<key> ...]]
+npm pkg delete <key> [<key> ...]
+npm pkg set [<array>[<index>].<key>=<value> ...]
+npm pkg set [<array>[].<key>=<value> ...]
+npm pkg fix
+```
+
+### Description
+
+A command that automates the management of `package.json` files.
+`npm pkg` provide 3 different sub commands that allow you to modify or retrieve values for given object keys in your `package.json`.
+
+The syntax to retrieve and set fields is a dot separated representation of the nested object properties to be found within your `package.json`, it's the same notation used in [`npm view`](/commands/npm-view) to retrieve information from the registry manifest, below you can find more examples on how to use it.
+
+Returned values are always in **json** format.
+
+* `npm pkg get <field>`
+
+    Retrieves a value `key`, defined in your `package.json` file.
+
+    For example, in order to retrieve the name of the current package, you can run:
+
+    ```bash
+    npm pkg get name
+    ```
+
+    It's also possible to retrieve multiple values at once:
+
+    ```bash
+    npm pkg get name version
+    ```
+
+    You can view child fields by separating them with a period.
+    To retrieve the value of a test `script` value, you would run the following command:
+
+    ```bash
+    npm pkg get scripts.test
+    ```
+
+    For fields that are arrays, requesting a non-numeric field will return all of the values from the objects in the list.
+    For example, to get all the contributor emails for a package, you would run:
+
+    ```bash
+    npm pkg get contributors.email
+    ```
+
+    You may also use numeric indices in square braces to specifically select an item in an array field.
+    To just get the email address of the first contributor in the list, you can run:
+
+    ```bash
+    npm pkg get contributors[0].email
+    ```
+
+    For complex fields you can also name a property in square brackets to specifically select a child field.
+    This is especially helpful with the exports object:
+
+    ```bash
+    npm pkg get "exports[.].require"
+    ```
+
+* `npm pkg set <field>=<value>`
+
+    Sets a `value` in your `package.json` based on the `field` value.
+    When saving to your `package.json` file the same set of rules used during `npm install` and other cli commands that touches the `package.json` file are used, making sure to respect the existing indentation and possibly applying some validation prior to saving values to the file.
+
+    The same syntax used to retrieve values from your package can also be used to define new properties or overriding existing ones, below are some examples of how the dot separated syntax can be used to edit your `package.json` file.
+
+    Defining a new bin named `mynewcommand` in your `package.json` that points to a file `cli.js`:
+
+    ```bash
+    npm pkg set bin.mynewcommand=cli.js
+    ```
+
+    Setting multiple fields at once is also possible:
+
+    ```bash
+    npm pkg set description='Awesome package' engines.node='>=10'
+    ```
+
+    It's also possible to add to array values, for example to add a new contributor entry:
+
+    ```bash
+    npm pkg set contributors[0].name='Foo' contributors[0].email='foo@bar.ca'
+    ```
+
+    You may also append items to the end of an array using the special empty bracket notation:
+
+    ```bash
+    npm pkg set contributors[].name='Foo' contributors[].name='Bar'
+    ```
+
+    It's also possible to parse values as json prior to saving them to your `package.json` file, for example in order to set a `"private": true` property:
+
+    ```bash
+    npm pkg set private=true --json
+    ```
+
+    It also enables saving values as numbers:
+
+    ```bash
+    npm pkg set tap.timeout=60 --json
+    ```
+
+* `npm pkg delete <key>`
+
+    Deletes a `key` from your `package.json`
+
+    The same syntax used to set values from your package can also be used to remove existing ones.
+    For example, in order to remove a script named build:
+
+    ```bash
+    npm pkg delete scripts.build
+    ```
+
+* `npm pkg fix`
+
+    Auto corrects common errors in your `package.json`.
+    npm already does this during `publish`, which leads to subtle (mostly harmless) differences between the contents of your `package.json` file and the manifest that npm uses during installation.
+
+### Workspaces support
+
+You can set/get/delete items across your configured workspaces by using the [`workspace`](/using-npm/config#workspace) or [`workspaces`](/using-npm/config#workspaces) config options.
+
+For example, setting a `funding` value across all configured workspaces of a project:
+
+```bash
+npm pkg set funding=https://example.com --ws
+```
+
+When using `npm pkg get` to retrieve info from your configured workspaces, the returned result will be in a json format in which top level keys are the names of each workspace, the values of these keys will be the result values returned from each of the configured workspaces, e.g:
+
+```
+npm pkg get name version --ws
+{
+  "a": {
+    "name": "a",
+    "version": "1.0.0"
+  },
+  "b": {
+    "name": "b",
+    "version": "1.0.0"
+  }
+}
+```
+
+### Configuration
+
+#### `force`
+
+* Default: false
+* Type: Boolean
+
+Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.
+
+* Allow clobbering non-npm files in global installs.
+* Allow the `npm version` command to work on an unclean git repository.
+* Allow deleting the cache folder with `npm cache clean`.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of npm.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of `node`, even if `--engine-strict` is enabled.
+* Allow `npm audit fix` to install modules outside your stated dependency
+  range (including SemVer-major changes).
+* Allow unpublishing all versions of a published package.
+* Allow conflicting peerDependencies to be installed in the root project.
+* Implicitly set `--yes` during `npm init`.
+* Allow clobbering existing values in `npm pkg`
+* Allow unpublishing of entire packages (not just a single version).
+
+If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+## See Also
+
+* [npm install](/commands/npm-install)
+* [npm init](/commands/npm-init)
+* [npm config](/commands/npm-config)
+* [workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-prefix.md b/node/node_modules/npm/docs/content/commands/npm-prefix.md
new file mode 100644
index 0000000000000000000000000000000000000000..85994cba1bbab614820ca1ba5283b0be0a2eb441
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-prefix.md
@@ -0,0 +1,58 @@
+---
+title: npm-prefix
+section: 1
+description: Display prefix
+---
+
+### Synopsis
+
+```bash
+npm prefix
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Print the local prefix to standard output.
+This is the closest parent directory to contain a `package.json` file or `node_modules` directory, unless `-g` is also specified.
+
+If `-g` is specified, this will be the value of the global prefix.
+See [`npm config`](/commands/npm-config) for more detail.
+
+### Example
+
+```bash
+npm prefix
+/usr/local/projects/foo
+```
+
+```bash
+npm prefix -g
+/usr/local
+```
+
+### Configuration
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+### See Also
+
+* [npm root](/commands/npm-root)
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-profile.md b/node/node_modules/npm/docs/content/commands/npm-profile.md
new file mode 100644
index 0000000000000000000000000000000000000000..d57739f0877fc2e02a84cd696c17b26a05362df3
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-profile.md
@@ -0,0 +1,115 @@
+---
+title: npm-profile
+section: 1
+description: Change settings on your registry profile
+---
+
+### Synopsis
+
+```bash
+npm profile enable-2fa [auth-only|auth-and-writes]
+npm profile disable-2fa
+npm profile get [<key>]
+npm profile set <key> <value>
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Change your profile information on the registry.
+Note that this command depends on the registry implementation, so third-party registries may not support this interface.
+
+* `npm profile get [<property>]`: Display all of the properties of your profile, or one or more specific properties.
+It looks like:
+
+```
+name: example
+email: e@example.com (verified)
+two-factor auth: auth-and-writes
+fullname: Example User
+homepage:
+freenode:
+twitter:
+github:
+created: 2015-02-26T01:38:35.892Z
+updated: 2017-10-02T21:29:45.922Z
+```
+
+* `npm profile set <property> <value>`: Set the value of a profile property.
+You can set the following properties this way: email, fullname, homepage, freenode, twitter, github
+
+* `npm profile set password`: Change your password.
+This is interactive, you'll be prompted for your current password and a new password.
+You'll also be prompted for an OTP if you have two-factor authentication enabled.
+
+* `npm profile enable-2fa [auth-and-writes|auth-only]`: Enables two-factor authentication.
+Defaults to `auth-and-writes` mode.
+Modes are:
+  * `auth-only`: Require an OTP when logging in or making changes to your account's authentication.
+The OTP will be required on both the website and the command line.
+  * `auth-and-writes`: Requires an OTP at all the times `auth-only` does, and also requires one when publishing a module, setting the `latest` dist-tag, or changing access via `npm access` and `npm owner`.
+
+* `npm profile disable-2fa`: Disables two-factor authentication.
+
+### Details
+
+Some of these commands may not be available on non npmjs.com registries.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+### See Also
+
+* [npm adduser](/commands/npm-adduser)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm owner](/commands/npm-owner)
+* [npm whoami](/commands/npm-whoami)
+* [npm token](/commands/npm-token)
diff --git a/node/node_modules/npm/docs/content/commands/npm-prune.md b/node/node_modules/npm/docs/content/commands/npm-prune.md
new file mode 100644
index 0000000000000000000000000000000000000000..d1f909defe5970dc563bc6a94cfcb076342117d3
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-prune.md
@@ -0,0 +1,191 @@
+---
+title: npm-prune
+section: 1
+description: Remove extraneous packages
+---
+
+### Synopsis
+
+```bash
+npm prune [[<@scope>/]<pkg>...]
+```
+
+### Description
+
+This command removes "extraneous" packages.
+If a package name is provided, then only packages matching one of the supplied names are removed.
+
+Extraneous packages are those present in the `node_modules` folder that are not listed as any package's dependency list.
+
+If the `--omit=dev` flag is specified or the `NODE_ENV` environment variable is set to `production`, this command will remove the packages specified in your `devDependencies`.
+
+If the `--dry-run` flag is used then no changes will actually be made.
+
+If the `--json` flag is used, then the changes `npm prune` made (or would have made with `--dry-run`) are printed as a JSON object.
+
+In normal operation, extraneous modules are pruned automatically, so you'll only need this command with the `--production` flag.
+However, in the real world, operation is not always "normal".  When crashes or mistakes happen, this command can help clean up any resulting garbage.
+
+### Configuration
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm uninstall](/commands/npm-uninstall)
+* [npm folders](/configuring-npm/folders)
+* [npm ls](/commands/npm-ls)
diff --git a/node/node_modules/npm/docs/content/commands/npm-publish.md b/node/node_modules/npm/docs/content/commands/npm-publish.md
new file mode 100644
index 0000000000000000000000000000000000000000..52897726f5c9070ab7fb12781c868274a9e851c4
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-publish.md
@@ -0,0 +1,245 @@
+---
+title: npm-publish
+section: 1
+description: Publish a package
+---
+
+### Synopsis
+
+```bash
+npm publish <package-spec>
+```
+
+### Description
+
+Publishes a package to the registry so that it can be installed by name.
+
+### Examples
+
+Publish the package in the current directory:
+
+```bash
+npm publish
+```
+
+Publish a specific workspace:
+
+```bash
+npm publish --workspace=<workspace-name>
+```
+
+Publish multiple workspaces:
+
+```bash
+npm publish --workspace=workspace-a --workspace=workspace-b
+```
+
+Publish all workspaces:
+
+```bash
+npm publish --workspaces
+```
+
+By default npm will publish to the public registry.
+This can be overridden by specifying a different default registry or using a [`scope`](/using-npm/scope) in the name, combined with a scope-configured registry (see [`package.json`](/configuring-npm/package-json)).
+
+
+A `package` is interpreted the same way as other commands (like `npm install`) and can be:
+
+* a) a folder containing a program described by a [`package.json`](/configuring-npm/package-json) file
+* b) a gzipped tarball containing (a)
+* c) a url that resolves to (b)
+* d) a `<name>@<version>` that is published on the registry (see [`registry`](/using-npm/registry)) with (c)
+* e) a `<name>@<tag>` (see [`npm dist-tag`](/commands/npm-dist-tag)) that points to (d)
+* f) a `<name>` that has a "latest" tag satisfying (e)
+* g) a `<git remote url>` that resolves to (a)
+
+If either (a) or (b) is specified as a relative path, it should begin with an explicit `./` prefix.
+
+The publish will fail if the package name and version combination already exists in the specified registry.
+
+Once a package is published with a given name and version, that specific name and version combination can never be used again, even if it is removed with [`npm unpublish`](/commands/npm-unpublish).
+
+As of `npm@5`, both a sha1sum and an integrity field with a sha512sum of the tarball will be submitted to the registry during publication.
+Subsequent installs will use the strongest supported algorithm to verify downloads.
+
+Similar to `--dry-run` see [`npm pack`](/commands/npm-pack), which figures out the files to be included and packs them into a tarball to be uploaded to the registry.
+
+### Files included in package
+
+To see what will be included in your package, run `npm pack --dry-run`.
+All files are included by default, with the following exceptions:
+
+- Certain files that are relevant to package installation and distribution are always included.
+For example, `package.json`, `README.md`,
+  `LICENSE`, and so on.
+
+- If there is a "files" list in [`package.json`](/configuring-npm/package-json), then only the files specified will be included.
+ (If directories are specified, then they will be walked recursively and their contents included, subject to the same ignore rules.)
+
+- If there is a `.gitignore` or `.npmignore` file, then ignored files in that and all child directories will be excluded from the package.
+  If _both_ files exist, then the `.gitignore` is ignored, and only the
+  `.npmignore` is used.
+
+  `.npmignore` files follow the [same pattern rules](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring) as `.gitignore` files
+
+- If the file matches certain patterns, then it will _never_ be included, unless explicitly added to the `"files"` list in `package.json`, or un-ignored with a `!` rule in a `.npmignore` or `.gitignore` file.
+
+- Symbolic links are never included in npm packages.
+
+
+See [`developers`](/using-npm/developers) for full details on what's included in the published package, as well as details on how the package is built.
+
+See [`package.json`](/configuring-npm/package-json) for more info on what can and can't be ignored.
+
+### Configuration
+
+#### `tag`
+
+* Default: "latest"
+* Type: String
+
+If you ask npm to install a package and don't tell it a specific version,
+then it will install the specified tag.
+
+It is the tag added to the package@version specified in the `npm dist-tag
+add` command, if no explicit tag is given.
+
+When used by the `npm diff` command, this is the tag used to fetch the
+tarball that will be compared with the local files by default.
+
+If used in the `npm publish` command, this is the tag that will be added to
+the package submitted to the registry.
+
+
+
+#### `access`
+
+* Default: 'public' for new packages, existing packages it will not change the
+  current level
+* Type: null, "restricted", or "public"
+
+If you do not want your scoped package to be publicly viewable (and
+installable) set `--access=restricted`.
+
+Unscoped packages cannot be set to `restricted`.
+
+Note: This defaults to not changing the current access level for existing
+packages. Specifying a value of `restricted` or `public` during publish will
+change the access for an existing package the same way that `npm access set
+status` would.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `provenance`
+
+* Default: false
+* Type: Boolean
+
+When publishing from a supported cloud CI/CD system, the package will be
+publicly linked to where it was built and published from.
+
+This config cannot be used with: `provenance-file`
+
+#### `provenance-file`
+
+* Default: null
+* Type: Path
+
+When publishing, the provenance bundle at the given path will be used.
+
+This config cannot be used with: `provenance`
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm-packlist package](http://npm.im/npm-packlist)
+* [npm registry](/using-npm/registry)
+* [npm scope](/using-npm/scope)
+* [npm adduser](/commands/npm-adduser)
+* [npm owner](/commands/npm-owner)
+* [npm deprecate](/commands/npm-deprecate)
+* [npm dist-tag](/commands/npm-dist-tag)
+* [npm pack](/commands/npm-pack)
+* [npm profile](/commands/npm-profile)
diff --git a/node/node_modules/npm/docs/content/commands/npm-query.md b/node/node_modules/npm/docs/content/commands/npm-query.md
new file mode 100644
index 0000000000000000000000000000000000000000..d1e37f4cba211d4336171bacbcf2c3cf642eec05
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-query.md
@@ -0,0 +1,267 @@
+---
+title: npm-query
+section: 1
+description: Dependency selector query
+---
+
+### Synopsis
+
+```bash
+npm query <selector>
+```
+
+### Description
+
+The `npm query` command allows for usage of css selectors in order to retrieve an array of dependency objects.
+
+### Piping npm query to other commands
+
+```bash
+# find all dependencies with postinstall scripts & uninstall them
+npm query ":attr(scripts, [postinstall])" | jq 'map(.name)|join("\n")' -r | xargs -I {} npm uninstall {}
+
+# find all git dependencies & explain who requires them
+npm query ":type(git)" | jq 'map(.name)' | xargs -I {} npm why {}
+```
+
+### Extended Use Cases & Queries
+
+```stylus
+// all deps
+*
+
+// all direct deps
+:root > *
+
+// direct production deps
+:root > .prod
+
+// direct development deps
+:root > .dev
+
+// any peer dep of a direct deps
+:root > * > .peer
+
+// any workspace dep
+.workspace
+
+// all workspaces that depend on another workspace
+.workspace > .workspace
+
+// all workspaces that have peer deps
+.workspace:has(.peer)
+
+// any dep named "lodash"
+// equivalent to [name="lodash"]
+#lodash
+
+// any deps named "lodash" & within semver range ^"1.2.3"
+#lodash@^1.2.3
+// equivalent to...
+[name="lodash"]:semver(^1.2.3)
+
+// get the hoisted node for a given semver range
+#lodash@^1.2.3:not(:deduped)
+
+// querying deps with a specific version
+#lodash@2.1.5
+// equivalent to...
+[name="lodash"][version="2.1.5"]
+
+// has any deps
+:has(*)
+
+// deps with no other deps (ie. "leaf" nodes)
+:empty
+
+// manually querying git dependencies
+[repository^=github:],
+[repository^=git:],
+[repository^=https://github.com],
+[repository^=http://github.com],
+[repository^=https://github.com],
+[repository^=+git:...]
+
+// querying for all git dependencies
+:type(git)
+
+// get production dependencies that aren't also dev deps
+.prod:not(.dev)
+
+// get dependencies with specific licenses
+[license=MIT], [license=ISC]
+
+// find all packages that have @ruyadorno as a contributor
+:attr(contributors, [email=ruyadorno@github.com])
+```
+
+### Example Response Output
+
+- an array of dependency objects is returned which can contain multiple copies of the same package which may or may not have been linked or deduped
+
+```json
+[
+  {
+    "name": "",
+    "version": "",
+    "description": "",
+    "homepage": "",
+    "bugs": {},
+    "author": {},
+    "license": {},
+    "funding": {},
+    "files": [],
+    "main": "",
+    "browser": "",
+    "bin": {},
+    "man": [],
+    "directories": {},
+    "repository": {},
+    "scripts": {},
+    "config": {},
+    "dependencies": {},
+    "devDependencies": {},
+    "optionalDependencies": {},
+    "bundledDependencies": {},
+    "peerDependencies": {},
+    "peerDependenciesMeta": {},
+    "engines": {},
+    "os": [],
+    "cpu": [],
+    "workspaces": {},
+    "keywords": [],
+    ...
+  },
+  ...
+```
+
+### Expecting a certain number of results
+
+One common use of `npm query` is to make sure there is only one version of a certain dependency in your tree.
+This is especially common for ecosystems like that rely on `typescript` where having state split across two different but identically-named packages causes bugs.
+You can use the `--expect-results` or `--expect-result-count` in your setup to ensure that npm will exit with an exit code if your tree doesn't look like you want it to.
+
+
+```sh
+$ npm query '#react' --expect-result-count=1
+```
+
+Perhaps you want to quickly check if there are any production dependencies that could be updated:
+
+```sh
+$ npm query ':root>:outdated(in-range).prod' --no-expect-results
+```
+
+### Package lock only mode
+
+If package-lock-only is enabled, only the information in the package lock (or shrinkwrap) is loaded.
+This means that information from the package.json files of your dependencies will not be included in the result set (e.g. description, homepage, engines).
+
+### Configuration
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `expect-results`
+
+* Default: null
+* Type: null or Boolean
+
+Tells npm whether or not to expect results from the command. Can be either
+true (expect some results) or false (expect no results).
+
+This config cannot be used with: `expect-result-count`
+
+#### `expect-result-count`
+
+* Default: null
+* Type: null or Number
+
+Tells to expect a specific number of results from the command.
+
+This config cannot be used with: `expect-results`
+## See Also
+
+* [dependency selectors](/using-npm/dependency-selectors)
diff --git a/node/node_modules/npm/docs/content/commands/npm-rebuild.md b/node/node_modules/npm/docs/content/commands/npm-rebuild.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a073872a4fe91350cf55e524745a177ce519201
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-rebuild.md
@@ -0,0 +1,170 @@
+---
+title: npm-rebuild
+section: 1
+description: Rebuild a package
+---
+
+### Synopsis
+
+```bash
+npm rebuild [<package-spec>] ...]
+
+alias: rb
+```
+
+### Description
+
+This command does the following:
+
+1. Execute lifecycle scripts (`preinstall`, `install`, `postinstall`, `prepare`)
+2. Links bins depending on whether bin links are enabled
+
+This command is particularly useful in scenarios including but not limited to:
+
+1. Installing a new version of **node.js**, where you need to recompile all your C++ add-ons with the updated binary.
+2. Installing with `--ignore-scripts` and `--no-bin-links`, to explicitly choose which packages to build and/or link bins.
+
+If one or more package specs are provided, then only packages with a name and version matching one of the specifiers will be rebuilt.
+
+Usually, you should not need to run `npm rebuild` as it is already done for you as part of npm install (unless you suppressed these steps with `--ignore-scripts` or `--no-bin-links`).
+
+If there is a `binding.gyp` file in the root of your package, then npm will use a default install hook:
+
+```
+"scripts": {
+    "install": "node-gyp rebuild"
+}
+```
+
+This default behavior is suppressed if the `package.json` has its own `install` or `preinstall` scripts.
+It is also suppressed if the package specifies `"gypfile": false`
+
+### Configuration
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm install](/commands/npm-install)
diff --git a/node/node_modules/npm/docs/content/commands/npm-repo.md b/node/node_modules/npm/docs/content/commands/npm-repo.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb238c81c1bb06b37d57ccc8c7012c001542e613
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-repo.md
@@ -0,0 +1,99 @@
+---
+title: npm-repo
+section: 1
+description: Open package repository page in the browser
+---
+
+### Synopsis
+
+```bash
+npm repo [<pkgname> [<pkgname> ...]]
+```
+
+### Description
+
+This command tries to guess at the likely location of a package's repository URL, and then tries to open it using the [`--browser` config](/using-npm/config#browser) param.
+If no package name is provided, it will search for a `package.json` in the current folder and use the `repository` property.
+
+### Configuration
+
+#### `browser`
+
+* Default: macOS: `"open"`, Windows: `"start"`, Others: `"xdg-open"`
+* Type: null, Boolean, or String
+
+The browser that is called by npm commands to open websites.
+
+Set to `false` to suppress browser behavior and instead print urls to
+terminal.
+
+Set to `true` to use default system URL opener.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [npm docs](/commands/npm-docs)
+* [npm config](/commands/npm-config)
diff --git a/node/node_modules/npm/docs/content/commands/npm-restart.md b/node/node_modules/npm/docs/content/commands/npm-restart.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd2567abd7ec730b5bef64d51db024f1dc09ccf0
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-restart.md
@@ -0,0 +1,68 @@
+---
+title: npm-restart
+section: 1
+description: Restart a package
+---
+
+### Synopsis
+
+```bash
+npm restart [-- <args>]
+```
+
+### Description
+
+This restarts a project.
+It is equivalent to running `npm run restart`.
+
+If the current project has a `"restart"` script specified in `package.json`, then the following scripts will be run:
+
+1. prerestart
+2. restart
+3. postrestart
+
+If it does _not_ have a `"restart"` script specified, but it does have `stop` and/or `start` scripts, then the following scripts will be run:
+
+1. prerestart
+2. prestop
+3. stop
+4. poststop
+6. prestart
+7. start
+8. poststart
+9. postrestart
+
+### Configuration
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `script-shell`
+
+* Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+* Type: null or String
+
+The shell to use for scripts run with the `npm exec`, `npm run` and `npm
+init <package-spec>` commands.
+
+
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [npm test](/commands/npm-test)
+* [npm start](/commands/npm-start)
+* [npm stop](/commands/npm-stop)
+* [npm restart](/commands/npm-restart)
diff --git a/node/node_modules/npm/docs/content/commands/npm-root.md b/node/node_modules/npm/docs/content/commands/npm-root.md
new file mode 100644
index 0000000000000000000000000000000000000000..4bf2d90aad5fafa4ad18db7de9e2c30f999ac7f6
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-root.md
@@ -0,0 +1,51 @@
+---
+title: npm-root
+section: 1
+description: Display npm root
+---
+
+### Synopsis
+
+```bash
+npm root
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Print the effective `node_modules` folder to standard out.
+
+Useful for using npm in shell scripts that do things with the `node_modules` folder.
+For example:
+
+```bash
+#!/bin/bash
+global_node_modules="$(npm root --global)"
+echo "Global packages installed in: ${global_node_modules}"
+```
+
+### Configuration
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+### See Also
+
+* [npm prefix](/commands/npm-prefix)
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-run.md b/node/node_modules/npm/docs/content/commands/npm-run.md
new file mode 100644
index 0000000000000000000000000000000000000000..10d804c821bca98016dbabfb9545dbe636c495a8
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-run.md
@@ -0,0 +1,231 @@
+---
+title: npm-run
+section: 1
+description: Run arbitrary package scripts
+---
+
+### Synopsis
+
+```bash
+npm run <command> [-- <args>]
+
+aliases: run-script, rum, urn
+```
+
+### Description
+
+This runs an arbitrary command from a package's `"scripts"` object.
+If no
+`"command"` is provided, it will list the available scripts.
+
+`run[-script]` is used by the test, start, restart, and stop commands, but can be called directly, as well.
+When the scripts in the package are printed out, they're separated into lifecycle (test, start, restart) and directly-run scripts.
+
+Any positional arguments are passed to the specified script.
+Use `--` to pass `-`-prefixed flags and options which would otherwise be parsed by npm.
+
+For example:
+
+```bash
+npm run test -- --grep="pattern"
+```
+
+The arguments will only be passed to the script specified after `npm run` and not to any `pre` or `post` script.
+
+The `env` script is a special built-in command that can be used to list environment variables that will be available to the script at runtime.
+If an "env" command is defined in your package, it will take precedence over the built-in.
+
+In addition to the shell's pre-existing `PATH`, `npm run` adds `node_modules/.bin` to the `PATH` provided to scripts.
+Any binaries provided by locally-installed dependencies can be used without the `node_modules/.bin` prefix.
+For example, if there is a `devDependency` on `tap` in your package, you should write:
+
+```bash
+"scripts": {"test": "tap test/*.js"}
+```
+
+instead of
+
+```bash
+"scripts": {"test": "node_modules/.bin/tap test/*.js"}
+```
+
+The actual shell your script is run within is platform dependent.
+By default, on Unix-like systems it is the `/bin/sh` command, on Windows it is `cmd.exe`.
+The actual shell referred to by `/bin/sh` also depends on the system.
+You can customize the shell with the [`script-shell` config](/using-npm/config#script-shell).
+
+Scripts are run from the root of the package folder, regardless of what the current working directory is when `npm run` is called.
+If you want your script to use different behavior based on what subdirectory you're in, you can use the `INIT_CWD` environment variable, which holds the full path you were in when you ran `npm run`.
+
+`npm run` sets the `NODE` environment variable to the `node` executable with which `npm` is executed.
+
+If you try to run a script without having a `node_modules` directory and it fails, you will be given a warning to run `npm install`, just in case you've forgotten.
+
+### Workspaces support
+
+You may use the [`workspace`](/using-npm/config#workspace) or [`workspaces`](/using-npm/config#workspaces) configs in order to run an arbitrary command from a package's `"scripts"` object in the context of the specified workspaces.
+If no `"command"` is provided, it will list the available scripts for each of these configured workspaces.
+
+Given a project with configured workspaces, e.g:
+
+```
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   +-- b
+   |   `-- package.json
+   `-- c
+       `-- package.json
+```
+
+Assuming the workspace configuration is properly set up at the root level `package.json` file.
+e.g:
+
+```
+{
+    "workspaces": [ "./packages/*" ]
+}
+```
+
+And that each of the configured workspaces has a configured `test` script, we can run tests in all of them using the [`workspaces` config](/using-npm/config#workspaces):
+
+```
+npm test --workspaces
+```
+
+#### Filtering workspaces
+
+It's also possible to run a script in a single workspace using the `workspace` config along with a name or directory path:
+
+```
+npm test --workspace=a
+```
+
+The `workspace` config can also be specified multiple times in order to run a specific script in the context of multiple workspaces.
+When defining values for the `workspace` config in the command line, it also possible to use `-w` as a shorthand, e.g:
+
+```
+npm test -w a -w b
+```
+
+This last command will run `test` in both `./packages/a` and `./packages/b` packages.
+
+### Configuration
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `if-present`
+
+* Default: false
+* Type: Boolean
+
+If true, npm will not exit with an error code when `run` is invoked for a
+script that isn't defined in the `scripts` section of `package.json`. This
+option can be used when it's desirable to optionally run a script when it's
+present and fail if the script fails. This is useful, for example, when
+running scripts that may only apply for some builds in an otherwise generic
+CI setup.
+
+This value is not exported to the environment for child processes.
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `script-shell`
+
+* Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+* Type: null or String
+
+The shell to use for scripts run with the `npm exec`, `npm run` and `npm
+init <package-spec>` commands.
+
+
+
+### See Also
+
+* [npm scripts](/using-npm/scripts)
+* [npm test](/commands/npm-test)
+* [npm start](/commands/npm-start)
+* [npm restart](/commands/npm-restart)
+* [npm stop](/commands/npm-stop)
+* [npm config](/commands/npm-config)
+* [npm workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-sbom.md b/node/node_modules/npm/docs/content/commands/npm-sbom.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ed6cd1908d32a137cd2c99816f1db900afc7e66
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-sbom.md
@@ -0,0 +1,316 @@
+---
+title: npm-sbom
+section: 1
+description: Generate a Software Bill of Materials (SBOM)
+---
+
+### Synopsis
+
+```bash
+npm sbom
+```
+
+### Description
+
+The `npm sbom` command generates a Software Bill of Materials (SBOM) listing the dependencies for the current project.
+SBOMs can be generated in either [SPDX](https://spdx.dev/) or [CycloneDX](https://cyclonedx.org/) format.
+
+### Example CycloneDX SBOM
+
+```json
+{
+  "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "serialNumber": "urn:uuid:09f55116-97e1-49cf-b3b8-44d0207e7730",
+  "version": 1,
+  "metadata": {
+    "timestamp": "2023-09-01T00:00:00.001Z",
+    "lifecycles": [
+      {
+        "phase": "build"
+      }
+    ],
+    "tools": [
+      {
+        "vendor": "npm",
+        "name": "cli",
+        "version": "10.1.0"
+      }
+    ],
+    "component": {
+      "bom-ref": "simple@1.0.0",
+      "type": "library",
+      "name": "simple",
+      "version": "1.0.0",
+      "scope": "required",
+      "author": "John Doe",
+      "description": "simple react app",
+      "purl": "pkg:npm/simple@1.0.0",
+      "properties": [
+        {
+          "name": "cdx:npm:package:path",
+          "value": ""
+        }
+      ],
+      "externalReferences": [],
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    }
+  },
+  "components": [
+    {
+      "bom-ref": "lodash@4.17.21",
+      "type": "library",
+      "name": "lodash",
+      "version": "4.17.21",
+      "scope": "required",
+      "author": "John-David Dalton",
+      "description": "Lodash modular utilities.",
+      "purl": "pkg:npm/lodash@4.17.21",
+      "properties": [
+        {
+          "name": "cdx:npm:package:path",
+          "value": "node_modules/lodash"
+        }
+      ],
+      "externalReferences": [
+        {
+          "type": "distribution",
+          "url": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
+        },
+        {
+          "type": "vcs",
+          "url": "git+https://github.com/lodash/lodash.git"
+        },
+        {
+          "type": "website",
+          "url": "https://lodash.com/"
+        },
+        {
+          "type": "issue-tracker",
+          "url": "https://github.com/lodash/lodash/issues"
+        }
+      ],
+      "hashes": [
+        {
+          "alg": "SHA-512",
+          "content": "bf690311ee7b95e713ba568322e3533f2dd1cb880b189e99d4edef13592b81764daec43e2c54c61d5c558dc5cfb35ecb85b65519e74026ff17675b6f8f916f4a"
+        }
+      ],
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "simple@1.0.0",
+      "dependsOn": [
+        "lodash@4.17.21"
+      ]
+    },
+    {
+      "ref": "lodash@4.17.21",
+      "dependsOn": []
+    }
+  ]
+}
+```
+
+### Example SPDX SBOM
+
+```json
+{
+  "spdxVersion": "SPDX-2.3",
+  "dataLicense": "CC0-1.0",
+  "SPDXID": "SPDXRef-DOCUMENT",
+  "name": "simple@1.0.0",
+  "documentNamespace": "http://spdx.org/spdxdocs/simple-1.0.0-bf81090e-8bbc-459d-bec9-abeb794e096a",
+  "creationInfo": {
+    "created": "2023-09-01T00:00:00.001Z",
+    "creators": [
+      "Tool: npm/cli-10.1.0"
+    ]
+  },
+  "documentDescribes": [
+    "SPDXRef-Package-simple-1.0.0"
+  ],
+  "packages": [
+    {
+      "name": "simple",
+      "SPDXID": "SPDXRef-Package-simple-1.0.0",
+      "versionInfo": "1.0.0",
+      "packageFileName": "",
+      "description": "simple react app",
+      "primaryPackagePurpose": "LIBRARY",
+      "downloadLocation": "NOASSERTION",
+      "filesAnalyzed": false,
+      "homepage": "NOASSERTION",
+      "licenseDeclared": "MIT",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/simple@1.0.0"
+        }
+      ]
+    },
+    {
+      "name": "lodash",
+      "SPDXID": "SPDXRef-Package-lodash-4.17.21",
+      "versionInfo": "4.17.21",
+      "packageFileName": "node_modules/lodash",
+      "description": "Lodash modular utilities.",
+      "downloadLocation": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "filesAnalyzed": false,
+      "homepage": "https://lodash.com/",
+      "licenseDeclared": "MIT",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/lodash@4.17.21"
+        }
+      ],
+      "checksums": [
+        {
+          "algorithm": "SHA512",
+          "checksumValue": "bf690311ee7b95e713ba568322e3533f2dd1cb880b189e99d4edef13592b81764daec43e2c54c61d5c558dc5cfb35ecb85b65519e74026ff17675b6f8f916f4a"
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "spdxElementId": "SPDXRef-DOCUMENT",
+      "relatedSpdxElement": "SPDXRef-Package-simple-1.0.0",
+      "relationshipType": "DESCRIBES"
+    },
+    {
+      "spdxElementId": "SPDXRef-Package-simple-1.0.0",
+      "relatedSpdxElement": "SPDXRef-Package-lodash-4.17.21",
+      "relationshipType": "DEPENDS_ON"
+    }
+  ]
+}
+```
+
+### Package lock only mode
+
+If package-lock-only is enabled, only the information in the package lock (or shrinkwrap) is loaded.
+This means that information from the package.json files of your dependencies will not be included in the result set (e.g.
+description, homepage, engines).
+
+### Configuration
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `sbom-format`
+
+* Default: null
+* Type: "cyclonedx" or "spdx"
+
+SBOM format to use when generating SBOMs.
+
+
+
+#### `sbom-type`
+
+* Default: "library"
+* Type: "library", "application", or "framework"
+
+The type of package described by the generated SBOM. For SPDX, this is the
+value for the `primaryPackagePurpose` field. For CycloneDX, this is the
+value for the `type` field.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+## See Also
+
+* [package spec](/using-npm/package-spec)
+* [dependency selectors](/using-npm/dependency-selectors)
+* [package.json](/configuring-npm/package-json)
+* [workspaces](/using-npm/workspaces)
diff --git a/node/node_modules/npm/docs/content/commands/npm-search.md b/node/node_modules/npm/docs/content/commands/npm-search.md
new file mode 100644
index 0000000000000000000000000000000000000000..24b89775af7925bdd9b467040cd4352ecd7cff2b
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-search.md
@@ -0,0 +1,154 @@
+---
+title: npm-search
+section: 1
+description: Search for packages
+---
+
+### Synopsis
+
+```bash
+npm search <search term> [<search term> ...]
+
+aliases: find, s, se
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Search the registry for packages matching the search terms.
+`npm search`
+performs a linear, incremental, lexically-ordered search through package metadata for all files in the registry.
+If your terminal has color support, it will further highlight the matches in the results.
+This can be disabled with the config item `color`
+
+Additionally, using the `--searchopts` and `--searchexclude` options paired with more search terms will include and exclude further patterns.
+The main difference between `--searchopts` and the standard search terms is that the former does not highlight results in the output and you can use them more fine-grained filtering.
+Additionally, you can add both of these to your config to change default search filtering behavior.
+
+Search also allows targeting of maintainers in search results, by prefixing their npm username with `=`.
+
+If a term starts with `/`, then it's interpreted as a regular expression and supports standard JavaScript RegExp syntax.
+In this case search will ignore a trailing `/` .  (Note you must escape or quote many regular expression characters in most shells.)
+
+### Configuration
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `color`
+
+* Default: true unless the NO_COLOR environ is set to something other than '0'
+* Type: "always" or Boolean
+
+If false, never shows colors. If `"always"` then always shows colors. If
+true, then only prints color codes for tty file descriptors.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `description`
+
+* Default: true
+* Type: Boolean
+
+Show the description in `npm search`
+
+
+
+#### `searchlimit`
+
+* Default: 20
+* Type: Number
+
+Number of items to limit search results to. Will not apply at all to legacy
+searches.
+
+
+
+#### `searchopts`
+
+* Default: ""
+* Type: String
+
+Space-separated options that are always passed to search.
+
+
+
+#### `searchexclude`
+
+* Default: ""
+* Type: String
+
+Space-separated options that limit the results from search.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `prefer-online`
+
+* Default: false
+* Type: Boolean
+
+If true, staleness checks for cached data will be forced, making the CLI
+look for updates immediately even for fresh package data.
+
+
+
+#### `prefer-offline`
+
+* Default: false
+* Type: Boolean
+
+If true, staleness checks for cached data will be bypassed, but missing data
+will be requested from the server. To force full offline mode, use
+`--offline`.
+
+
+
+#### `offline`
+
+* Default: false
+* Type: Boolean
+
+Force offline mode: no network requests will be done during install. To
+allow the CLI to fill in missing cache data, see `--prefer-offline`.
+
+
+
+### See Also
+
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm view](/commands/npm-view)
+* [npm cache](/commands/npm-cache)
+* https://npm.im/npm-registry-fetch
diff --git a/node/node_modules/npm/docs/content/commands/npm-set.md b/node/node_modules/npm/docs/content/commands/npm-set.md
new file mode 100644
index 0000000000000000000000000000000000000000..184a35a94db350ea86cd49d3a986ec23870205fd
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-set.md
@@ -0,0 +1,58 @@
+---
+title: npm-set
+section: 1
+description: Set a value in the npm configuration
+---
+
+### Synopsis
+
+```bash
+npm set <key>=<value> [<key>=<value> ...] (See `npm config`)
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Set a value in the npm configuration
+
+### Configuration
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `location`
+
+* Default: "user" unless `--global` is passed, which will also set this value
+  to "global"
+* Type: "global", "user", or "project"
+
+When passed to `npm config` this refers to which config file to use.
+
+When set to "global" mode, packages are installed into the `prefix` folder
+instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+### See Also
+
+* [npm help config](/commands/npm-config)
diff --git a/node/node_modules/npm/docs/content/commands/npm-shrinkwrap.md b/node/node_modules/npm/docs/content/commands/npm-shrinkwrap.md
new file mode 100644
index 0000000000000000000000000000000000000000..36f37c9a05a9110bec324db92f615c89081e0ffa
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-shrinkwrap.md
@@ -0,0 +1,29 @@
+---
+title: npm-shrinkwrap
+section: 1
+description: Lock down dependency versions for publication
+---
+
+### Synopsis
+
+```bash
+npm shrinkwrap
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+This command repurposes `package-lock.json` into a publishable `npm-shrinkwrap.json` or simply creates a new one.
+The file created and updated by this command will then take precedence over any other existing or future `package-lock.json` files.
+For a detailed explanation of the design and purpose of package locks in npm, see [package-lock-json](/configuring-npm/package-lock-json).
+
+### See Also
+
+* [npm install](/commands/npm-install)
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [package.json](/configuring-npm/package-json)
+* [package-lock.json](/configuring-npm/package-lock-json)
+* [npm-shrinkwrap.json](/configuring-npm/npm-shrinkwrap-json)
+* [npm ls](/commands/npm-ls)
diff --git a/node/node_modules/npm/docs/content/commands/npm-star.md b/node/node_modules/npm/docs/content/commands/npm-star.md
new file mode 100644
index 0000000000000000000000000000000000000000..0eb11615485e2d360b96d34504039972ec46fb1f
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-star.md
@@ -0,0 +1,79 @@
+---
+title: npm-star
+section: 1
+description: Mark your favorite packages
+---
+
+### Synopsis
+
+```bash
+npm star [<package-spec>...]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+"Starring" a package means that you have some interest in it.
+It's a vaguely positive way to show that you care.
+
+It's a boolean thing.
+Starring repeatedly has no additional effect.
+
+### More
+
+There's also these extra commands to help you manage your favorite packages:
+
+#### Unstar
+
+You can also "unstar" a package using [`npm unstar`](/commands/npm-unstar)
+
+"Unstarring" is the same thing, but in reverse.
+
+#### Listing stars
+
+You can see all your starred packages using [`npm stars`](/commands/npm-stars)
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `unicode`
+
+* Default: false on windows, true on mac/unix systems with a unicode locale,
+  as defined by the `LC_ALL`, `LC_CTYPE`, or `LANG` environment variables.
+* Type: Boolean
+
+When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm unstar](/commands/npm-unstar)
+* [npm stars](/commands/npm-stars)
+* [npm view](/commands/npm-view)
+* [npm whoami](/commands/npm-whoami)
+* [npm adduser](/commands/npm-adduser)
diff --git a/node/node_modules/npm/docs/content/commands/npm-stars.md b/node/node_modules/npm/docs/content/commands/npm-stars.md
new file mode 100644
index 0000000000000000000000000000000000000000..5cc69526983543194ea0a4e10d69fb8e2fdd708a
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-stars.md
@@ -0,0 +1,38 @@
+---
+title: npm-stars
+section: 1
+description: View packages marked as favorites
+---
+
+### Synopsis
+
+```bash
+npm stars [<user>]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+If you have starred a lot of neat things and want to find them again quickly this command lets you do just that.
+
+You may also want to see your friend's favorite packages, in this case you will most certainly enjoy this command.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+### See Also
+
+* [npm star](/commands/npm-star)
+* [npm unstar](/commands/npm-unstar)
+* [npm view](/commands/npm-view)
+* [npm whoami](/commands/npm-whoami)
+* [npm adduser](/commands/npm-adduser)
diff --git a/node/node_modules/npm/docs/content/commands/npm-start.md b/node/node_modules/npm/docs/content/commands/npm-start.md
new file mode 100644
index 0000000000000000000000000000000000000000..80361e5e567bf46d75111dabdc645cea241c23b9
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-start.md
@@ -0,0 +1,76 @@
+---
+title: npm-start
+section: 1
+description: Start a package
+---
+
+### Synopsis
+
+```bash
+npm start [-- <args>]
+```
+
+### Description
+
+This runs a predefined command specified in the `"start"` property of a package's `"scripts"` object.
+
+If the `"scripts"` object does not define a  `"start"` property, npm will run `node server.js`.
+
+Note that this is different from the default node behavior of running the file specified in a package's `"main"` attribute when evoking with `node .`
+
+As of [`npm@2.0.0`](https://blog.npmjs.org/post/98131109725/npm-2-0-0), you can use custom arguments when executing scripts.
+Refer to [`npm run`](/commands/npm-run) for more details.
+
+### Example
+
+```json
+{
+  "scripts": {
+    "start": "node foo.js"
+  }
+}
+```
+
+```bash
+npm start
+
+> npm@x.x.x start
+> node foo.js
+
+(foo.js output would be here)
+
+```
+
+### Configuration
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `script-shell`
+
+* Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+* Type: null or String
+
+The shell to use for scripts run with the `npm exec`, `npm run` and `npm
+init <package-spec>` commands.
+
+
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [npm test](/commands/npm-test)
+* [npm restart](/commands/npm-restart)
+* [npm stop](/commands/npm-stop)
diff --git a/node/node_modules/npm/docs/content/commands/npm-stop.md b/node/node_modules/npm/docs/content/commands/npm-stop.md
new file mode 100644
index 0000000000000000000000000000000000000000..1359b6c58aa50254efd5d781b1446da7eb68d5cb
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-stop.md
@@ -0,0 +1,71 @@
+---
+title: npm-stop
+section: 1
+description: Stop a package
+---
+
+### Synopsis
+
+```bash
+npm stop [-- <args>]
+```
+
+### Description
+
+This runs a predefined command specified in the "stop" property of a package's "scripts" object.
+
+Unlike with [npm start](/commands/npm-start), there is no default script that will run if the `"stop"` property is not defined.
+
+### Example
+
+```json
+{
+  "scripts": {
+    "stop": "node bar.js"
+  }
+}
+```
+
+```bash
+npm stop
+
+> npm@x.x.x stop
+> node bar.js
+
+(bar.js output would be here)
+
+```
+
+### Configuration
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `script-shell`
+
+* Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+* Type: null or String
+
+The shell to use for scripts run with the `npm exec`, `npm run` and `npm
+init <package-spec>` commands.
+
+
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [npm test](/commands/npm-test)
+* [npm start](/commands/npm-start)
+* [npm restart](/commands/npm-restart)
diff --git a/node/node_modules/npm/docs/content/commands/npm-team.md b/node/node_modules/npm/docs/content/commands/npm-team.md
new file mode 100644
index 0000000000000000000000000000000000000000..44f882a362dfd7b23d18e1857cabe68cb0910569
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-team.md
@@ -0,0 +1,144 @@
+---
+title: npm-team
+section: 1
+description: Manage organization teams and team memberships
+---
+
+### Synopsis
+
+```bash
+npm team create <scope:team> [--otp <otpcode>]
+npm team destroy <scope:team> [--otp <otpcode>]
+npm team add <scope:team> <user> [--otp <otpcode>]
+npm team rm <scope:team> <user> [--otp <otpcode>]
+npm team ls <scope>|<scope:team>
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Used to manage teams in organizations, and change team memberships.
+Does not handle permissions for packages.
+
+Teams must always be fully qualified with the organization/scope they belong to when operating on them, separated by a colon (`:`).
+That is, if you have a `newteam` team in an `org` organization, you must always refer to that team as `@org:newteam` in these commands.
+
+If you have two-factor authentication enabled in `auth-and-writes` mode, then you can provide a code from your authenticator with `[--otp <otpcode>]`.
+If you don't include this then you will be taken through a second factor flow based on your `authtype`.
+
+* create / destroy:
+  Create a new team, or destroy an existing one.
+  Note: You cannot remove the `developers` team, [learn more.](https://docs.npmjs.com/about-developers-team)
+
+  Here's how to create a new team `newteam` under the `org` org:
+
+  ```bash
+  npm team create @org:newteam
+  ```
+
+  You should see a confirming message such as: `+@org:newteam` once the new team has been created.
+
+* add:
+  Add a user to an existing team.
+
+  Adding a new user `username` to a team named `newteam` under the `org` org:
+
+  ```bash
+  npm team add @org:newteam username
+  ```
+
+  On success, you should see a message: `username added to @org:newteam`
+
+* rm:
+  Using `npm team rm` you can also remove users from a team they belong to.
+
+  Here's an example removing user `username` from `newteam` team in `org` organization:
+
+  ```bash
+  npm team rm @org:newteam username
+  ```
+
+  Once the user is removed a confirmation message is displayed:
+  `username removed from @org:newteam`
+
+* ls:
+  If performed on an organization name, will return a list of existing teams under that organization.
+  If performed on a team, it will instead return a list of all users belonging to that particular team.
+
+  Here's an example of how to list all teams from an org named `org`:
+
+  ```bash
+  npm team ls @org
+  ```
+
+  Example listing all members of a team named `newteam`:
+
+  ```bash
+  npm team ls @org:newteam
+  ```
+
+### Details
+
+`npm team` always operates directly on the current registry, configurable from the command line using `--registry=<registry url>`.
+
+You must be a *team admin* to create teams and manage team membership, under the given organization.
+Listing teams and team memberships may be done by any member of the organization.
+
+Organization creation and management of team admins and *organization* members is done through the website, not the npm CLI.
+
+To use teams to manage permissions on packages belonging to your organization, use the `npm access` command to grant or revoke the appropriate permissions.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+### See Also
+
+* [npm access](/commands/npm-access)
+* [npm config](/commands/npm-config)
+* [npm registry](/using-npm/registry)
diff --git a/node/node_modules/npm/docs/content/commands/npm-test.md b/node/node_modules/npm/docs/content/commands/npm-test.md
new file mode 100644
index 0000000000000000000000000000000000000000..77526728e8cf6351cdf3219fac8b74569287cbb5
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-test.md
@@ -0,0 +1,69 @@
+---
+title: npm-test
+section: 1
+description: Test a package
+---
+
+### Synopsis
+
+```bash
+npm test [-- <args>]
+
+aliases: tst, t
+```
+
+### Description
+
+This runs a predefined command specified in the `"test"` property of a package's `"scripts"` object.
+
+### Example
+
+```json
+{
+  "scripts": {
+    "test": "node test.js"
+  }
+}
+```
+
+```bash
+npm test
+> npm@x.x.x test
+> node test.js
+
+(test.js output would be here)
+```
+
+### Configuration
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `script-shell`
+
+* Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+* Type: null or String
+
+The shell to use for scripts run with the `npm exec`, `npm run` and `npm
+init <package-spec>` commands.
+
+
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [npm start](/commands/npm-start)
+* [npm restart](/commands/npm-restart)
+* [npm stop](/commands/npm-stop)
diff --git a/node/node_modules/npm/docs/content/commands/npm-token.md b/node/node_modules/npm/docs/content/commands/npm-token.md
new file mode 100644
index 0000000000000000000000000000000000000000..48bc0a831448c7a14be5feb65d513392e16b38ac
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-token.md
@@ -0,0 +1,203 @@
+---
+title: npm-token
+section: 1
+description: Manage your authentication tokens
+---
+
+### Synopsis
+
+```bash
+npm token list
+npm token revoke <id|token>
+npm token create
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+This lets you list, create and revoke authentication tokens.
+
+#### Listing tokens
+
+When listing tokens, an abbreviated token will be displayed.  For security purposes the full token is not displayed.
+
+#### Generating tokens
+
+When generating tokens, you will be prompted you for your password and, if you have two-factor authentication enabled, an otp.
+
+Please refer to the [docs website](https://docs.npmjs.com/creating-and-viewing-access-tokens) for more information on generating tokens for CI/CD.
+
+#### Revoking tokens
+
+When revoking a token, you can use the full token (e.g. what you get back from `npm token create`, or as can be found in an `.npmrc` file), or a truncated id.  If the given truncated id is not distinct enough to differentiate between multiple existing tokens, you will need to use enough of the id to allow npm to distinguish between them.  Full token ids can be found on the [npm website](https://www.npmjs.com), or in the `--parseable` or `--json` output of `npm token list`.  This command will NOT accept the truncated token found in the normal `npm token list` output.
+
+A revoked token will immediately be removed from the registry and you will no longer be able to use it.
+
+### Configuration
+
+#### `name`
+
+* Default: null
+* Type: null or String
+
+When creating a Granular Access Token with `npm token create`, this sets the
+name/description for the token.
+
+
+
+#### `token-description`
+
+* Default: null
+* Type: null or String
+
+Description text for the token when using `npm token create`.
+
+
+
+#### `expires`
+
+* Default: null
+* Type: null or Number
+
+When creating a Granular Access Token with `npm token create`, this sets the
+expiration in days. If not specified, the server will determine the default
+expiration.
+
+
+
+#### `packages`
+
+* Default:
+* Type: null or String (can be set multiple times)
+
+When creating a Granular Access Token with `npm token create`, this limits
+the token access to specific packages.
+
+
+
+#### `packages-all`
+
+* Default: false
+* Type: Boolean
+
+When creating a Granular Access Token with `npm token create`, grants the
+token access to all packages instead of limiting to specific packages.
+
+
+
+#### `scopes`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+When creating a Granular Access Token with `npm token create`, this limits
+the token access to specific scopes. Provide a scope name (with or without @
+prefix).
+
+
+
+#### `orgs`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+When creating a Granular Access Token with `npm token create`, this limits
+the token access to specific organizations.
+
+
+
+#### `packages-and-scopes-permission`
+
+* Default: null
+* Type: null, "read-only", "read-write", or "no-access"
+
+When creating a Granular Access Token with `npm token create`, sets the
+permission level for packages and scopes. Options are "read-only",
+"read-write", or "no-access".
+
+
+
+#### `orgs-permission`
+
+* Default: null
+* Type: null, "read-only", "read-write", or "no-access"
+
+When creating a Granular Access Token with `npm token create`, sets the
+permission level for organizations. Options are "read-only", "read-write",
+or "no-access".
+
+
+
+#### `cidr`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+This is a list of CIDR address to be used when configuring limited access
+tokens with the `npm token create` command.
+
+
+
+#### `bypass-2fa`
+
+* Default: false
+* Type: Boolean
+
+When creating a Granular Access Token with `npm token create`, setting this
+to true will allow the token to bypass two-factor authentication. This is
+useful for automation and CI/CD workflows.
+
+
+
+#### `password`
+
+* Default: null
+* Type: null or String
+
+Password for authentication. Can be provided via command line when creating
+tokens, though it's generally safer to be prompted for it.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `read-only`
+
+* Default: false
+* Type: Boolean
+
+This is used to mark a token as unable to publish when configuring limited
+access tokens with the `npm token create` command.
+
+
+
+### See Also
+
+* [npm adduser](/commands/npm-adduser)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm owner](/commands/npm-owner)
+* [npm whoami](/commands/npm-whoami)
+* [npm profile](/commands/npm-profile)
diff --git a/node/node_modules/npm/docs/content/commands/npm-trust.md b/node/node_modules/npm/docs/content/commands/npm-trust.md
new file mode 100644
index 0000000000000000000000000000000000000000..5adf63d3470565086095d2f85f4a03adbf035afd
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-trust.md
@@ -0,0 +1,159 @@
+---
+title: npm-trust
+section: 1
+description: Manage trusted publishing relationships between packages and CI/CD providers
+---
+
+### Synopsis
+
+Note: This command is unaware of workspaces.
+
+### Prerequisites
+
+Before using npm trust commands, ensure the following requirements are met:
+
+* **npm version**: `npm@11.10.0` or above is required. Use `npm install -g npm@^11.10.0` to update if needed.
+* **Write permissions on the package**: You must have write access to the package you're configuring.
+* **2FA enabled on account**: Two-factor authentication must be enabled at the account level. Even if it's not currently enabled, you must enable it to use trust commands.
+* **Supported authentication methods**: Granular Access Tokens (GAT) with the bypass 2FA option are not supported. Legacy basic auth (username and password) credentials will not work for trust commands or endpoints.
+* **Package must exist**: The package you're configuring must already exist on the npm registry.
+
+### Description
+
+Configure trust relationships between npm packages and CI/CD providers using OpenID Connect (OIDC). This is the command-line equivalent of managing trusted publisher configurations on the npm website.
+
+For a comprehensive overview of trusted publishing, see the [npm trusted publishers documentation](https://docs.npmjs.com/trusted-publishers).
+
+The `[package]` argument specifies the package name. If omitted, npm will use the name from the `package.json` in the current directory.
+
+Each trust relationship has its own set of configuration options and flags based on the OIDC claims provided by that provider. OIDC claims come from the CI/CD provider and include information such as repository name, workflow file, or environment. Since each provider's claims differ, the available flags and configuration keys are not universal—npm matches the claims supported by each provider's OIDC configuration. For specific details on which claims and flags are supported for a given provider, use `npm trust <provider> --help`.
+
+The required options depend on the CI/CD provider you're configuring. Detailed information about each option is available in the [managing trusted publisher configurations](https://docs.npmjs.com/trusted-publishers#managing-trusted-publisher-configurations) section of the npm documentation. If a provider is repository-based and the option is not provided, npm will use the `repository.url` field from your `package.json`, if available.
+
+Currently, the registry only supports one configuration per package. If you attempt to create a new trust relationship when one already exists, it will result in an error. To replace an existing configuration:
+
+1. Use `npm trust list [package]` to view the ID of the existing trusted publisher
+2. Use `npm trust revoke --id <id> [package]` to remove the existing configuration
+3. Then create your new trust relationship
+
+### Bulk Usage
+
+For maintainers managing a large number of packages, you can configure trusted publishing in bulk using bash scripting. Create a loop that iterates through package names and their corresponding configuration details, executing the `npm trust <provider>` command with the `--yes` flag for each package.
+
+The first request will require two-factor authentication. During two-factor authentication, you'll see an option on the npm website to skip two-factor authentication for the next 5 minutes. Enabling this option will allow subsequent `npm trust <provider>` commands to proceed without two-factor authentication, streamlining the bulk configuration process.
+
+We recommend adding a 2-second sleep between each call to avoid rate limiting. With this approach, you can configure approximately 80 packages within the 5-minute two-factor authentication skip window.
+
+### Configuration
+
+### `npm trust github`
+
+Create a trusted relationship between a package and GitHub Actions
+
+#### Synopsis
+
+```bash
+npm trust github [package] --file [--repo|--repository] [--env|--environment] [-y|--yes]
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--file` | null | String (required) | Name of workflow file within a repositories .GitHub folder (must end in yaml, yml) |
+| `--repository`, `--repo` | null | String | Name of the repository in the format owner/repo |
+| `--environment`, `--env` | null | String | CI environment name |
+| `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+| `--yes`, `-y` | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on       the command line. |
+
+### `npm trust gitlab`
+
+Create a trusted relationship between a package and GitLab CI/CD
+
+#### Synopsis
+
+```bash
+npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--file` | null | String (required) | Name of pipeline file (e.g., .gitlab-ci.yml) |
+| `--project` | null | String | Name of the project in the format group/project or group/subgroup/project |
+| `--environment`, `--env` | null | String | CI environment name |
+| `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+| `--yes`, `-y` | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on       the command line. |
+
+### `npm trust circleci`
+
+Create a trusted relationship between a package and CircleCI
+
+#### Synopsis
+
+```bash
+npm trust circleci [package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [-y|--yes]
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--org-id` | null | String (required) | CircleCI organization UUID |
+| `--project-id` | null | String (required) | CircleCI project UUID |
+| `--pipeline-definition-id` | null | String (required) | CircleCI pipeline definition UUID |
+| `--vcs-origin` | null | String (required) | CircleCI repository origin in format 'provider/owner/repo' |
+| `--context-id` | null | null or String (can be set multiple times) | CircleCI context UUID to match |
+| `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+| `--yes`, `-y` | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on       the command line. |
+
+### `npm trust list`
+
+List trusted relationships for a package
+
+#### Synopsis
+
+```bash
+npm trust list [package]
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+### `npm trust revoke`
+
+Revoke a trusted relationship for a package
+
+#### Synopsis
+
+```bash
+npm trust revoke [package] --id=<trust-id>
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--id` | null | String (required) | ID of the trusted relationship to revoke |
+| `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+
+### See Also
+
+* [npm publish](/commands/npm-publish)
+* [npm token](/commands/npm-token)
+* [npm access](/commands/npm-access)
+* [npm config](/commands/npm-config)
+* [npm registry](/using-npm/registry)
diff --git a/node/node_modules/npm/docs/content/commands/npm-undeprecate.md b/node/node_modules/npm/docs/content/commands/npm-undeprecate.md
new file mode 100644
index 0000000000000000000000000000000000000000..972fde4c656b6130ff4bba52276ce43b81ac1bc2
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-undeprecate.md
@@ -0,0 +1,61 @@
+---
+title: npm-undeprecate
+section: 1
+description: Undeprecate a version of a package
+---
+
+### Synopsis
+
+```bash
+npm undeprecate <package-spec>
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+This command will update the npm registry entry for a package, removing any deprecation warnings that currently exist.
+
+It works in the same way as [npm deprecate](/commands/npm-deprecate), except that this command removes deprecation warnings instead of adding them.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+### See Also
+
+* [npm deprecate](/commands/npm-deprecate)
diff --git a/node/node_modules/npm/docs/content/commands/npm-uninstall.md b/node/node_modules/npm/docs/content/commands/npm-uninstall.md
new file mode 100644
index 0000000000000000000000000000000000000000..d239a29acad5bfb521122480b2f960de0afeca6d
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-uninstall.md
@@ -0,0 +1,151 @@
+---
+title: npm-uninstall
+section: 1
+description: Remove a package
+---
+
+### Synopsis
+
+```bash
+npm uninstall [<@scope>/]<pkg>...
+
+aliases: unlink, remove, rm, r, un
+```
+
+### Description
+
+This uninstalls a package, completely removing everything npm installed on its behalf.
+
+It also removes the package from the `dependencies`, `devDependencies`,
+`optionalDependencies`, and `peerDependencies` objects in your `package.json`.
+
+Further, if you have an `npm-shrinkwrap.json` or `package-lock.json`, npm will update those files as well.
+
+`--no-save` will tell npm not to remove the package from your `package.json`, `npm-shrinkwrap.json`, or `package-lock.json` files.
+
+`--save` or `-S` will tell npm to remove the package from your `package.json`, `npm-shrinkwrap.json`, and `package-lock.json` files.
+This is the default, but you may need to use this if you have for instance `save=false` in your `npmrc` file
+
+In global mode (ie, with `-g` or `--global` appended to the command), it uninstalls the current package context as a global package.
+`--no-save` is ignored in this case.
+
+Scope is optional and follows the usual rules for [`scope`](/using-npm/scope).
+
+### Examples
+
+```bash
+npm uninstall sax
+```
+
+`sax` will no longer be in your `package.json`, `npm-shrinkwrap.json`, or `package-lock.json` files.
+
+```bash
+npm uninstall lodash --no-save
+```
+
+`lodash` will not be removed from your `package.json`,
+`npm-shrinkwrap.json`, or `package-lock.json` files.
+
+### Configuration
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm prune](/commands/npm-prune)
+* [npm install](/commands/npm-install)
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
diff --git a/node/node_modules/npm/docs/content/commands/npm-unpublish.md b/node/node_modules/npm/docs/content/commands/npm-unpublish.md
new file mode 100644
index 0000000000000000000000000000000000000000..1de08f23ebcc52791d5b66163e961af316f463e7
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-unpublish.md
@@ -0,0 +1,126 @@
+---
+title: npm-unpublish
+section: 1
+description: Remove a package from the registry
+---
+
+### Synopsis
+
+```bash
+npm unpublish [<package-spec>]
+```
+
+To learn more about how the npm registry treats unpublish, see our [unpublish policies](https://docs.npmjs.com/policies/unpublish).
+
+### Warning
+
+Consider using the [`deprecate`](/commands/npm-deprecate) command instead, if your intent is to encourage users to upgrade, or if you no longer want to maintain a package.
+
+### Description
+
+This removes a package version from the registry, deleting its entry and removing the tarball.
+
+The npm registry will return an error if you are not [logged in](/commands/npm-adduser).
+
+If you do not specify a package name at all, the name and version to be unpublished will be pulled from the project in the current directory.
+
+If you specify a package name but do not specify a version or if you remove all of a package's versions then the registry will remove the root package entry entirely.
+
+Even if you unpublish a package version, that specific name and version combination can never be reused.
+In order to publish the package again, you must use a new version number.
+If you unpublish the entire package, you may not publish any new versions of that package until 24 hours have passed.
+
+### Configuration
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `force`
+
+* Default: false
+* Type: Boolean
+
+Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.
+
+* Allow clobbering non-npm files in global installs.
+* Allow the `npm version` command to work on an unclean git repository.
+* Allow deleting the cache folder with `npm cache clean`.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of npm.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of `node`, even if `--engine-strict` is enabled.
+* Allow `npm audit fix` to install modules outside your stated dependency
+  range (including SemVer-major changes).
+* Allow unpublishing all versions of a published package.
+* Allow conflicting peerDependencies to be installed in the root project.
+* Implicitly set `--yes` during `npm init`.
+* Allow clobbering existing values in `npm pkg`
+* Allow unpublishing of entire packages (not just a single version).
+
+If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm deprecate](/commands/npm-deprecate)
+* [npm publish](/commands/npm-publish)
+* [npm registry](/using-npm/registry)
+* [npm adduser](/commands/npm-adduser)
+* [npm owner](/commands/npm-owner)
+* [npm login](/commands/npm-adduser)
diff --git a/node/node_modules/npm/docs/content/commands/npm-unstar.md b/node/node_modules/npm/docs/content/commands/npm-unstar.md
new file mode 100644
index 0000000000000000000000000000000000000000..92505c3a5fa2963f334af59f98d60a4fc56e291b
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-unstar.md
@@ -0,0 +1,73 @@
+---
+title: npm-unstar
+section: 1
+description: Remove an item from your favorite packages
+---
+
+### Synopsis
+
+```bash
+npm unstar [<package-spec>...]
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+"Unstarring" a package is the opposite of [`npm star`](/commands/npm-star), it removes an item from your list of favorite packages.
+
+### More
+
+There's also these extra commands to help you manage your favorite packages:
+
+#### Star
+
+You can "star" a package using [`npm star`](/commands/npm-star)
+
+#### Listing stars
+
+You can see all your starred packages using [`npm stars`](/commands/npm-stars)
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `unicode`
+
+* Default: false on windows, true on mac/unix systems with a unicode locale,
+  as defined by the `LC_ALL`, `LC_CTYPE`, or `LANG` environment variables.
+* Type: Boolean
+
+When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+### See Also
+
+* [npm star](/commands/npm-star)
+* [npm stars](/commands/npm-stars)
+* [npm view](/commands/npm-view)
+* [npm whoami](/commands/npm-whoami)
+* [npm adduser](/commands/npm-adduser)
+
diff --git a/node/node_modules/npm/docs/content/commands/npm-update.md b/node/node_modules/npm/docs/content/commands/npm-update.md
new file mode 100644
index 0000000000000000000000000000000000000000..57b70e521380ba42d7f97ba4b7a69b9808f26f09
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-update.md
@@ -0,0 +1,463 @@
+---
+title: npm-update
+section: 1
+description: Update packages
+---
+
+### Synopsis
+
+```bash
+npm update [<pkg>...]
+
+aliases: u, up, upgrade, udpate
+```
+
+### Description
+
+This command will update all the packages listed to the latest version (specified by the [`tag` config](/using-npm/config#tag)), respecting the semver constraints of both your package and its dependencies (if they also require the same package).
+
+It will also install missing packages.
+
+If the `-g` flag is specified, this command will update globally installed packages.
+
+If no package name is specified, all packages in the specified location (global or local) will be updated.
+
+Note that by default `npm update` will not update the semver values of direct dependencies in your project `package.json`.
+If you want to also update values in `package.json` you can run: `npm update --save` (or add the `save=true` option to a [configuration file](/configuring-npm/npmrc) to make that the default behavior).
+
+### Example
+
+For the examples below, assume that the current package is `app` and it depends on dependencies, `dep1` (`dep2`, .. etc.).
+The published versions of `dep1` are:
+
+```json
+{
+  "dist-tags": { "latest": "1.2.2" },
+  "versions": [
+    "1.2.2",
+    "1.2.1",
+    "1.2.0",
+    "1.1.2",
+    "1.1.1",
+    "1.0.0",
+    "0.4.1",
+    "0.4.0",
+    "0.2.0"
+  ]
+}
+```
+
+#### Caret Dependencies
+
+If `app`'s `package.json` contains:
+
+```json
+"dependencies": {
+  "dep1": "^1.1.1"
+}
+```
+
+Then `npm update` will install `dep1@1.2.2`, because `1.2.2` is `latest` and
+`1.2.2` satisfies `^1.1.1`.
+
+#### Tilde Dependencies
+
+However, if `app`'s `package.json` contains:
+
+```json
+"dependencies": {
+  "dep1": "~1.1.1"
+}
+```
+
+In this case, running `npm update` will install `dep1@1.1.2`.
+Even though the `latest` tag points to `1.2.2`, this version does not satisfy `~1.1.1`, which is equivalent to `>=1.1.1 <1.2.0`.
+So the highest-sorting version that satisfies
+`~1.1.1` is used, which is `1.1.2`.
+
+#### Caret Dependencies below 1.0.0
+
+Suppose `app` has a caret dependency on a version below `1.0.0`, for example:
+
+```json
+"dependencies": {
+  "dep1": "^0.2.0"
+}
+```
+
+`npm update` will install `dep1@0.2.0`.
+
+If the dependence were on `^0.4.0`:
+
+```json
+"dependencies": {
+  "dep1": "^0.4.0"
+}
+```
+
+Then `npm update` will install `dep1@0.4.1`, because that is the highest-sorting version that satisfies `^0.4.0` (`>= 0.4.0 <0.5.0`)
+
+
+#### Subdependencies
+
+Suppose your app now also has a dependency on `dep2`
+
+```json
+{
+  "name": "my-app",
+  "dependencies": {
+      "dep1": "^1.0.0",
+      "dep2": "1.0.0"
+  }
+}
+```
+
+and `dep2` itself depends on this limited range of `dep1`
+
+```json
+{
+"name": "dep2",
+  "dependencies": {
+    "dep1": "~1.1.1"
+  }
+}
+```
+
+Then `npm update` will install `dep1@1.1.2` because that is the highest version that `dep2` allows.
+ npm will prioritize having a single version of `dep1` in your tree rather than two when that single version can satisfy the semver requirements of multiple dependencies in your tree.
+In this case if you really did need your package to use a newer version you would need to use `npm install`.
+
+
+#### Updating Globally-Installed Packages
+
+`npm update -g` will apply the `update` action to each globally installed package that is `outdated` -- that is, has a version that is different from `wanted`.
+
+Note: Globally installed packages are treated as if they are installed with a caret semver range specified.
+So if you require to update to `latest` you may need to run `npm install -g [<pkg>...]`
+
+NOTE: If a package has been upgraded to a version newer than `latest`, it will be _downgraded_.
+
+### Configuration
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `before`
+
+* Default: null
+* Type: null or Date
+
+If passed to `npm install`, will rebuild the npm tree such that only
+versions that were available **on or before** the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.
+
+If the requested version is a `dist-tag` and the given tag does not pass the
+`--before` filter, the most recent version less than or equal to that tag
+will be used. For example, `foo@latest` might install `foo@1.2` even though
+`latest` is `2.0`.
+
+This config cannot be used with: `min-release-age`
+
+#### `min-release-age`
+
+* Default: null
+* Type: null or Number
+
+If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.
+
+This flag is a complement to `before`, which accepts an exact date instead
+of a relative number of days.
+
+This config cannot be used with: `before`
+
+This value is not exported to the environment for child processes.
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+### See Also
+
+* [npm install](/commands/npm-install)
+* [npm outdated](/commands/npm-outdated)
+* [npm shrinkwrap](/commands/npm-shrinkwrap)
+* [npm registry](/using-npm/registry)
+* [npm folders](/configuring-npm/folders)
+* [npm ls](/commands/npm-ls)
diff --git a/node/node_modules/npm/docs/content/commands/npm-version.md b/node/node_modules/npm/docs/content/commands/npm-version.md
new file mode 100644
index 0000000000000000000000000000000000000000..e40c6e1b03510ff3ad9b7909573e57246ace633c
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-version.md
@@ -0,0 +1,254 @@
+---
+title: npm-version
+section: 1
+description: Bump a package version
+---
+
+### Synopsis
+
+```bash
+npm version [<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease | from-git]
+
+alias: verison
+```
+
+### Configuration
+
+#### `allow-same-version`
+
+* Default: false
+* Type: Boolean
+
+Prevents throwing an error when `npm version` is used to set the new version
+to the same value as the current version.
+
+
+
+#### `commit-hooks`
+
+* Default: true
+* Type: Boolean
+
+Run git commit hooks when using the `npm version` command.
+
+
+
+#### `git-tag-version`
+
+* Default: true
+* Type: Boolean
+
+Tag the commit when using the `npm version` command. Setting this to false
+results in no commit being made at all.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `preid`
+
+* Default: ""
+* Type: String
+
+The "prerelease identifier" to use as a prefix for the "prerelease" part of
+a semver. Like the `rc` in `1.2.0-rc.8`.
+
+
+
+#### `sign-git-tag`
+
+* Default: false
+* Type: Boolean
+
+If set to true, then the `npm version` command will tag the version using
+`-s` to add a signature.
+
+Note that git requires you to have set up GPG keys in your git configs for
+this to work properly.
+
+
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces-update`
+
+* Default: true
+* Type: Boolean
+
+If set to true, the npm cli will run an update after operations that may
+possibly change the workspaces installed to the `node_modules` folder.
+
+
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+### Description
+
+Run this in a package directory to bump the version and write the new data back to `package.json`, `package-lock.json`, and, if present,
+`npm-shrinkwrap.json`.
+
+The `newversion` argument should be a valid semver string, a valid second argument to [semver.inc](https://github.com/npm/node-semver#functions) (one of `patch`, `minor`, `major`, `prepatch`, `preminor`, `premajor`, `prerelease`), or `from-git`.
+In the second case, the existing version will be incremented by 1 in the specified field.
+`from-git` will try to read the latest git tag, and use that as the new npm version.
+
+**Note:** If the current version is a prerelease version, `patch` will simply remove the prerelease suffix without incrementing the patch version number. For example, `1.2.0-5` becomes `1.2.0` with `npm version patch`, not `1.2.1`.
+
+If run in a git repo, it will also create a version commit and tag.
+This behavior is controlled by `git-tag-version` (see below), and can be disabled on the command line by running `npm --no-git-tag-version version`.
+It will fail if the working directory is not clean, unless the `-f` or `--force` flag is set.
+
+**Note:** Git integration requires a reasonably recent version of git (2.0.0 or later is recommended). If you encounter issues with git commands, ensure your git installation is up to date.
+
+If supplied with `-m` or [`--message` config](/using-npm/config#message) option, npm will use it as a commit message when creating a version commit.
+If the `message` config contains `%s` then that will be replaced with the resulting version number.
+For example:
+
+```bash
+npm version patch -m "Upgrade to %s for reasons"
+```
+
+If the [`sign-git-tag` config](/using-npm/config#sign-git-tag) is set, then the tag will be signed using the `-s` flag to git.
+Note that you must have a default GPG key set up in your git config for this to work properly.
+For example:
+
+```bash
+$ npm config set sign-git-tag true
+$ npm version patch
+
+You need a passphrase to unlock the secret key for user: "isaacs (http://blog.izs.me/) <i@izs.me>"
+2048-bit RSA key, ID 6C481CF6, created 2010-08-31
+
+Enter passphrase:
+```
+
+If `preversion`, `version`, or `postversion` are in the `scripts` property of the package.json, they will be executed as part of running `npm version`.
+
+The exact order of execution is as follows:
+
+1. Check to make sure the git working directory is clean before we get started.
+   Your scripts may add files to the commit in future steps.
+   This step is skipped if the `--force` flag is set.
+2. Run the `preversion` script.
+   These scripts have access to the old `version` in package.json.
+   A typical use would be running your full test suite before deploying.
+   Any files you want added to the commit should be explicitly added using `git add`.
+3. Bump `version` in `package.json` as requested (`patch`, `minor`, `major`, etc).
+4. Run the `version` script.
+   These scripts have access to the new `version` in package.json (so they can incorporate it into file headers in generated files for example).
+   Again, scripts should explicitly add generated files to the commit using `git add`.
+5. Commit and tag.
+6. Run the `postversion` script.
+   Use it to clean up the file system or automatically push the commit and/or tag.
+
+Take the following example:
+
+```json
+{
+  "scripts": {
+    "preversion": "npm test",
+    "version": "npm run build && git add -A dist",
+    "postversion": "git push && git push --tags && rm -rf build/temp"
+  }
+}
+```
+
+This runs all your tests and proceeds only if they pass.
+Then runs your `build` script, and adds everything in the `dist` directory to the commit.
+After the commit, it pushes the new commit and tag up to the server, and deletes the `build/temp` directory.
+
+### See Also
+
+* [npm init](/commands/npm-init)
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [package.json](/configuring-npm/package-json)
+* [config](/using-npm/config)
diff --git a/node/node_modules/npm/docs/content/commands/npm-view.md b/node/node_modules/npm/docs/content/commands/npm-view.md
new file mode 100644
index 0000000000000000000000000000000000000000..2c04dfd84031a933275676f694d182a882944dd3
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-view.md
@@ -0,0 +1,258 @@
+---
+title: npm-view
+section: 1
+description: View registry info
+---
+
+### Synopsis
+
+```bash
+npm view [<package-spec>] [<field>[.subfield]...]
+
+aliases: info, show, v
+```
+
+### Description
+
+This command shows data about a package and prints it to stdout.
+
+As an example, to view information about the `connect` package from the registry, you would run:
+
+```bash
+npm view connect
+```
+
+The default version is `"latest"` if unspecified.
+
+Field names can be specified after the package descriptor.
+For example, to show the dependencies of the `ronn` package at version
+`0.3.5`, you could do the following:
+
+```bash
+npm view ronn@0.3.5 dependencies
+```
+
+By default, `npm view` shows data about the current project context (by looking for a `package.json`).
+To show field data for the current project use a file path (i.e.
+`.`):
+
+```bash
+npm view . dependencies
+```
+
+You can view child fields by separating them with a period.
+To view the git repository URL for the latest version of `npm`, you would run the following command:
+
+```bash
+npm view npm repository.url
+```
+
+This makes it easy to view information about a dependency with a bit of shell scripting.
+For example, to view all the data about the version of `opts` that `ronn` depends on, you could write the following:
+
+```bash
+npm view opts@$(npm view ronn dependencies.opts)
+```
+
+For fields that are arrays, requesting a non-numeric field will return all of the values from the objects in the list.
+For example, to get all the contributor email addresses for the `express` package, you would run:
+
+```bash
+npm view express contributors.email
+```
+
+You may also use numeric indices in square braces to specifically select an item in an array field.
+To just get the email address of the first contributor in the list, you can run:
+
+```bash
+npm view express contributors[0].email
+```
+
+If the field value you are querying for is a property of an object, you should run:
+
+```bash
+npm view express time'[4.8.0]'
+```
+
+Note: When accessing object properties that contain special characters or numeric keys, you need to use quotes around the key name.
+For example, to get the publish time of a specific version:
+
+```bash
+npm view express "time[4.17.1]"
+```
+
+Without quotes, the shell may interpret the square brackets as glob patterns, causing the command to fail.
+You can also access the time field for a specific version by specifying the version in the package descriptor:
+
+```bash
+npm view express@4.17.1 time
+```
+
+This will return all version-time pairs, but the context will be for that specific version.
+
+Multiple fields may be specified, and will be printed one after another.
+For example, to get all the contributor names and email addresses, you can do this:
+
+```bash
+npm view express contributors.name contributors.email
+```
+
+"Person" fields are shown as a string if they would be shown as an object.
+So, for example, this will show the list of `npm` contributors in the shortened string format.
+ (See [`package.json`](/configuring-npm/package-json) for more on this.)
+
+```bash
+npm view npm contributors
+```
+
+If a version range is provided, then data will be printed for every matching version of the package.
+This will show which version of `jsdom` was required by each matching version of `yui3`:
+
+```bash
+npm view yui3@'>0.5.4' dependencies.jsdom
+```
+
+To show the `connect` package version history, you can do this:
+
+```bash
+npm view connect versions
+```
+
+### Field Access Patterns
+
+The `npm view` command supports different ways to access nested fields and array elements in package metadata. Understanding these patterns makes it easier to extract specific information.
+
+#### Nested Object Fields
+
+Use dot notation to access nested object fields:
+
+```bash
+# Access nested properties
+npm view npm repository.url
+npm view express bugs.url
+```
+
+#### Array Element Access
+
+For arrays, use numeric indices in square brackets to access specific elements:
+
+```bash
+# Get the first contributor's email
+npm view express contributors[0].email
+
+# Get the second maintainer's name
+npm view express maintainers[1].name
+```
+
+#### Object Property Access
+
+For object properties (like accessing specific versions in the `time` field), use bracket notation with the property name in quotes:
+
+```bash
+# Get publish time for a specific version
+npm view express "time[4.17.1]"
+
+# Get dist-tags
+npm view express "dist-tags.latest"
+```
+
+#### Extracting Fields from Arrays
+
+Request a non-numeric field on an array to get all values from objects in the list:
+
+```bash
+# Get all contributor emails
+npm view express contributors.email
+
+# Get all contributor names
+npm view express contributors.name
+```
+
+### Configuration
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+### Output
+
+If only a single string field for a single version is output, then it will not be colorized or quoted, to enable piping the output to another command.
+If the field is an object, it will be output as a JavaScript object literal.
+
+If the `--json` flag is given, the outputted fields will be JSON.
+
+If the version range matches multiple versions then each printed value will be prefixed with the version it applies to.
+
+If multiple fields are requested, then each of them is prefixed with the field name.
+
+### See Also
+
+* [package spec](/using-npm/package-spec)
+* [npm search](/commands/npm-search)
+* [npm registry](/using-npm/registry)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm docs](/commands/npm-docs)
diff --git a/node/node_modules/npm/docs/content/commands/npm-whoami.md b/node/node_modules/npm/docs/content/commands/npm-whoami.md
new file mode 100644
index 0000000000000000000000000000000000000000..718e30cfc5aa1064fad896607a610a0d31c25a2c
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm-whoami.md
@@ -0,0 +1,38 @@
+---
+title: npm-whoami
+section: 1
+description: Display npm username
+---
+
+### Synopsis
+
+```bash
+npm whoami
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Display the npm username of the currently logged-in user.
+
+If logged into a registry that provides token-based authentication, then connect to the `/-/whoami` registry endpoint to find the username associated with the token, and print to standard output.
+
+If logged into a registry that uses Basic Auth, then simply print the `username` portion of the authentication string.
+
+### Configuration
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+### See Also
+
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm adduser](/commands/npm-adduser)
diff --git a/node/node_modules/npm/docs/content/commands/npm.md b/node/node_modules/npm/docs/content/commands/npm.md
new file mode 100644
index 0000000000000000000000000000000000000000..72ed61e392d5312074f1833f9e249b71a79c2b20
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npm.md
@@ -0,0 +1,148 @@
+---
+title: npm
+section: 1
+description: javascript package manager
+---
+
+### Synopsis
+
+```bash
+npm
+```
+
+Note: This command is unaware of workspaces.
+
+### Version
+
+11.13.0
+
+### Description
+
+npm is the package manager for the Node JavaScript platform.
+It puts modules in place so that node can find them, and manages dependency conflicts intelligently.
+
+It is extremely configurable to support a variety of use cases.
+Most commonly, you use it to publish, discover, install, and develop node programs.
+
+Run `npm help` to get a list of available commands.
+
+### Important
+
+npm comes preconfigured to use npm's public registry at https://registry.npmjs.org by default.
+Use of the npm public registry is subject to terms of use available at https://docs.npmjs.com/policies/terms.
+
+You can configure npm to use any compatible registry you like, and even run your own registry.
+Use of someone else's registry is governed by their terms of use.
+
+### Introduction
+
+You probably got npm because you want to install stuff.
+
+The very first thing you will most likely want to run in any node program is `npm install` to install its dependencies.
+
+You can also run `npm install blerg` to install the latest version of "blerg".  Check out [`npm install`](/commands/npm-install) for more info.
+It can do a lot of stuff.
+
+Use the `npm search` command to show everything that's available in the public registry.
+Use `npm ls` to show everything you've installed.
+
+### Dependencies
+
+If a package lists a dependency using a git URL, npm will install that dependency using the [`git`](https://github.com/git-guides/install-git) command and will generate an error if it is not installed.
+
+If one of the packages npm tries to install is a native node module and requires compiling of C++ Code, npm will use [node-gyp](https://github.com/nodejs/node-gyp) for that task.
+For a Unix system, [node-gyp](https://github.com/nodejs/node-gyp) needs Python, make and a buildchain like GCC. On Windows, Python and Microsoft Visual Studio C++ are needed.
+For more information visit [the node-gyp repository](https://github.com/nodejs/node-gyp) and the [node-gyp Wiki](https://github.com/nodejs/node-gyp/wiki).
+
+### Directories
+
+See [`folders`](/configuring-npm/folders) to learn about where npm puts stuff.
+
+In particular, npm has two modes of operation:
+
+* local mode:
+  npm installs packages into the current project directory, which defaults to the current working directory.
+  Packages install to `./node_modules`, and bins to `./node_modules/.bin`.
+* global mode:
+  npm installs packages into the install prefix at `$NPM_CONFIG_PREFIX/lib/node_modules` and bins to `$NPM_CONFIG_PREFIX/bin`.
+
+Local mode is the default.
+Use `-g` or `--global` on any command to run in global mode instead.
+
+### Developer Usage
+
+If you're using npm to develop and publish your code, check out the following help topics:
+
+* json:
+  Make a package.json file.
+  See [`package.json`](/configuring-npm/package-json).
+* link:
+  Links your current working code into Node's path, so that you don't have to reinstall every time you make a change.
+  Use [`npm link`](/commands/npm-link) to do this.
+* install:
+  It's a good idea to install things if you don't need the symbolic link.
+  Especially, installing other peoples code from the registry is done via [`npm install`](/commands/npm-install)
+* adduser:
+  Create an account or log in.
+  When you do this, npm will store credentials in the user config file.
+* publish:
+  Use the [`npm publish`](/commands/npm-publish) command to upload your code to the registry.
+
+#### Configuration
+
+npm is extremely configurable.
+It reads its configuration options from 5 places.
+
+* Command line switches:
+  Set a config with `--key val`.
+  All keys take a value, even if they are booleans (the config parser doesn't know what the options are at the time of parsing).
+  If you do not provide a value (`--key`) then the option is set to boolean `true`.
+* Environment Variables:
+  Set any config by prefixing the name in an environment variable with `NPM_CONFIG_`.
+  For example, `export NPM_CONFIG_KEY=val`.
+* User Configs:
+  The file at `$HOME/.npmrc` is an ini-formatted list of configs.
+  If present, it is parsed.
+  If the `userconfig` option is set in the cli or env, that file will be used instead.
+* Global Configs:
+  The file found at `./etc/npmrc` (relative to the global prefix will be parsed if it is found.
+  See [`npm prefix`](/commands/npm-prefix) for more info on the global prefix.
+  If the `globalconfig` option is set in the cli, env, or user config, then that file is parsed instead.
+* Defaults:
+  npm's default configuration options are defined in `lib/utils/config/definitions.js`.
+  These must not be changed.
+
+See [`config`](/using-npm/config) for much, much, more information.
+
+### Contributions
+
+Patches welcome!
+
+If you would like to help, but don't know what to work on, read the [contributing guidelines](https://github.com/npm/cli/blob/latest/CONTRIBUTING.md) and check the issues list.
+
+### Bugs
+
+When you find issues, please report them:
+<https://github.com/npm/cli/issues>
+
+Please be sure to follow the template and bug reporting guidelines.
+
+### Feature Requests
+
+Discuss new feature ideas on our discussion forum:
+
+* <https://github.com/orgs/community/discussions/categories/npm>
+
+Or suggest formal RFC proposals:
+
+* <https://github.com/npm/rfcs>
+
+### See Also
+
+* [npm help](/commands/npm-help)
+* [package.json](/configuring-npm/package-json)
+* [npmrc](/configuring-npm/npmrc)
+* [npm config](/commands/npm-config)
+* [npm install](/commands/npm-install)
+* [npm prefix](/commands/npm-prefix)
+* [npm publish](/commands/npm-publish)
diff --git a/node/node_modules/npm/docs/content/commands/npx.md b/node/node_modules/npm/docs/content/commands/npx.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b8536f119d2a5c7154f46cf809a37a969bd2b47
--- /dev/null
+++ b/node/node_modules/npm/docs/content/commands/npx.md
@@ -0,0 +1,139 @@
+---
+title: npx
+section: 1
+description: Run a command from a local or remote npm package
+---
+
+### Synopsis
+
+```bash
+npx -- <pkg>[@<version>] [args...]
+npx --package=<pkg>[@<version>] -- <cmd> [args...]
+npx -c '<cmd> [args...]'
+npx --package=foo -c '<cmd> [args...]'
+```
+
+### Description
+
+This command allows you to run an arbitrary command from an npm package (either one installed locally, or fetched remotely), in a similar context as running it via `npm run`.
+
+Run this command to execute a package's binary. Any options and arguments after the package name are passed directly to the executed command, not to npx itself. For example, `npx create-react-app my-app --template typescript` will pass `my-app` and `--template typescript` to the `create-react-app` command. To see what options a specific package accepts, consult that package's documentation (e.g., at npmjs.com or in its repository).
+
+Whatever packages are specified by the `--package` option will be provided in the `PATH` of the executed command, along with any locally installed package executables.
+The `--package` option may be specified multiple times, to execute the supplied command in an environment where all specified packages are available.
+
+If any requested packages are not present in the local project dependencies, then they are installed to a folder in the npm cache, which is added to the `PATH` environment variable in the executed process.
+A prompt is printed (which can be suppressed by providing either `--yes` or `--no`).
+
+Package names provided without a specifier will be matched with whatever version exists in the local project.
+Package names with a specifier will only be considered a match if they have the exact same name and version as the local dependency.
+
+If no `-c` or `--call` option is provided, then the positional arguments are used to generate the command string.
+If no `--package` options are provided, then npm will attempt to determine the executable name from the package specifier provided as the first positional argument according to the following heuristic:
+
+- If the package has a single entry in its `bin` field in `package.json`, or if all entries are aliases of the same command, then that command will be used.
+- If the package has multiple `bin` entries, and one of them matches the unscoped portion of the `name` field, then that command will be used.
+- If this does not result in exactly one option (either because there are no bin entries, or none of them match the `name` of the package), then
+  `npm exec` exits with an error.
+
+To run a binary _other than_ the named binary, specify one or more
+`--package` options, which will prevent npm from inferring the package from the first command argument.
+
+### `npx` vs `npm exec`
+
+When run via the `npx` binary, all flags and options *must* be set prior to any positional arguments.
+When run via `npm exec`, a double-hyphen `--` flag can be used to suppress npm's parsing of switches and options that should be sent to the executed command.
+
+For example:
+
+```
+$ npx foo@latest bar --package=@npmcli/foo
+```
+
+In this case, npm will resolve the `foo` package name, and run the following command:
+
+```
+$ foo bar --package=@npmcli/foo
+```
+
+Since the `--package` option comes _after_ the positional arguments, it is treated as an argument to the executed command.
+
+In contrast, due to npm's argument parsing logic, running this command is different:
+
+```
+$ npm exec foo@latest bar --package=@npmcli/foo
+```
+
+In this case, npm will parse the `--package` option first, resolving the
+`@npmcli/foo` package.
+Then, it will execute the following command in that context:
+
+```
+$ foo@latest bar
+```
+
+The double-hyphen character is recommended to explicitly tell npm to stop parsing command line options and switches.
+The following command would thus be equivalent to the `npx` command above:
+
+```
+$ npm exec -- foo@latest bar --package=@npmcli/foo
+```
+
+### Examples
+
+Run the version of `tap` in the local dependencies, with the provided arguments:
+
+```
+$ npm exec -- tap --bail test/foo.js
+$ npx tap --bail test/foo.js
+```
+
+Run a command _other than_ the command whose name matches the package name by specifying a `--package` option:
+
+```
+$ npm exec --package=foo -- bar --bar-argument
+# ~ or ~
+$ npx --package=foo bar --bar-argument
+```
+
+Run an arbitrary shell script, in the context of the current project:
+
+```
+$ npm x -c 'eslint && say "hooray, lint passed"'
+$ npx -c 'eslint && say "hooray, lint passed"'
+```
+
+### Compatibility with Older npx Versions
+
+The `npx` binary was rewritten in npm v7.0.0, and the standalone `npx` package deprecated at that time.
+ `npx` uses the `npm exec` command instead of a separate argument parser and install process, with some affordances to maintain backwards compatibility with the arguments it accepted in previous versions.
+
+This resulted in some shifts in its functionality:
+
+- Any `npm` config value may be provided.
+- To prevent security and user-experience problems from mistyping package names, `npx` prompts before installing anything.
+Suppress this prompt with the `-y` or `--yes` option.
+- The `--no-install` option is deprecated, and will be converted to `--no`.
+- Shell fallback functionality is removed, as it is not advisable.
+- The `-p` argument is a shorthand for `--parseable` in npm, but shorthand for `--package` in npx.
+This is maintained, but only for the `npx` executable.
+- The `--ignore-existing` option is removed.
+Locally installed bins are always present in the executed process `PATH`.
+- The `--npm` option is removed.
+ `npx` will always use the `npm` it ships with.
+- The `--node-arg` and `-n` options have been removed.
+Use [`NODE_OPTIONS`](https://nodejs.org/api/cli.html#node_optionsoptions) instead: e.g.,
+ `NODE_OPTIONS="--trace-warnings --trace-exit" npx foo --random=true`
+- The `--always-spawn` option is redundant, and thus removed.
+- The `--shell` option is replaced with `--script-shell`, but maintained in the `npx` executable for backwards compatibility.
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [npm scripts](/using-npm/scripts)
+* [npm test](/commands/npm-test)
+* [npm start](/commands/npm-start)
+* [npm restart](/commands/npm-restart)
+* [npm stop](/commands/npm-stop)
+* [npm config](/commands/npm-config)
+* [npm exec](/commands/npm-exec)
diff --git a/node/node_modules/npm/docs/content/configuring-npm/folders.md b/node/node_modules/npm/docs/content/configuring-npm/folders.md
new file mode 100644
index 0000000000000000000000000000000000000000..8491238c768c20223187037115bcdefc803f783a
--- /dev/null
+++ b/node/node_modules/npm/docs/content/configuring-npm/folders.md
@@ -0,0 +1,172 @@
+---
+title: Folders
+section: 5
+description: Folder structures used by npm
+---
+
+### Description
+
+npm puts various things on your computer.
+That's its job.
+
+This document will tell you what it puts where.
+
+#### tl;dr
+
+* Local install (default): puts stuff in `./node_modules` of the current package root.
+* Global install (with `-g`): puts stuff in /usr/local or wherever node is installed.
+* Install it **locally** if you're going to `require()` it.
+* Install it **globally** if you're going to run it on the command line.
+* If you need both, then install it in both places, or use `npm link`.
+
+#### prefix Configuration
+
+The [`prefix` config](/using-npm/config#prefix) defaults to the location where node is installed.
+On most systems, this is `/usr/local`.
+On Windows, it's `%AppData%\npm`.
+On Unix systems, it's one level up, since node is typically installed at `{prefix}/bin/node` rather than `{prefix}/node.exe`.
+
+When the `global` flag is set, npm installs things into this prefix.
+When it is not set, it uses the root of the current package, or the current working directory if not in a package already.
+
+#### Node Modules
+
+Packages are dropped into the `node_modules` folder under the `prefix`.
+When installing locally, this means that you can `require("packagename")` to load its main module, or `require("packagename/lib/path/to/sub/module")` to load other modules.
+
+Global installs on Unix systems go to `{prefix}/lib/node_modules`.
+Global installs on Windows go to `{prefix}/node_modules` (that is, no `lib` folder.)
+
+Scoped packages are installed the same way, except they are grouped together in a sub-folder of the relevant `node_modules` folder with the name of that scope prefix by the @ symbol, e.g. `npm install @myorg/package` would place the package in `{prefix}/node_modules/@myorg/package`.
+See [`scope`](/using-npm/scope) for more details.
+
+If you wish to `require()` a package, then install it locally.
+
+#### Executables
+
+When in global mode, executables are linked into `{prefix}/bin` on Unix, or directly into `{prefix}` on Windows.
+Ensure that path is in your terminal's `PATH` environment to run them.
+
+When in local mode, executables are linked into `./node_modules/.bin` so that they can be made available to scripts run through npm.
+(For example, so that a test runner will be in the path when you run `npm test`.)
+
+#### Man Pages
+
+When in global mode, man pages are linked into `{prefix}/share/man`.
+
+When in local mode, man pages are not installed.
+
+Man pages are not installed on Windows systems.
+
+#### Cache
+
+See [`npm cache`](/commands/npm-cache).
+Cache files are stored in `~/.npm` on Posix, or `%LocalAppData%/npm-cache` on Windows.
+
+This is controlled by the [`cache` config](/using-npm/config#cache) param.
+
+### More Information
+
+When installing locally, npm first tries to find an appropriate `prefix` folder.
+This is so that `npm install foo@1.2.3` will install to the sensible root of your package, even if you happen to have `cd`ed into some other folder.
+
+Starting at the $PWD, npm will walk up the folder tree checking for a folder that contains either a `package.json` file, or a `node_modules` folder.
+If such a thing is found, then that is treated as the effective "current directory" for the purpose of running npm commands.
+(This behavior is inspired by and similar to git's .git-folder seeking logic when running git commands in a working dir.)
+
+If no package root is found, then the current folder is used.
+
+When you run `npm install foo@1.2.3`, then the package is loaded into the cache, and then unpacked into `./node_modules/foo`.
+Then, any of foo's dependencies are similarly unpacked into `./node_modules/foo/node_modules/...`.
+
+Any bin files are symlinked to `./node_modules/.bin/`, so that they may be found by npm scripts when necessary.
+
+#### Global Installation
+
+If the [`global` config](/using-npm/config#global) is set to true, then npm will install packages "globally".
+
+For global installation, packages are installed roughly the same way, but using the folders described above.
+
+#### Cycles, Conflicts, and Folder Parsimony
+
+Cycles are handled using the property of node's module system that it walks up the directories looking for `node_modules` folders.
+So, at every stage, if a package is already installed in an ancestor `node_modules` folder, then it is not installed at the current location.
+
+Consider the case above, where `foo -> bar -> baz`.
+Imagine if, in addition to that, baz depended on bar, so you'd have:
+`foo -> bar -> baz -> bar -> baz ...`.
+However, since the folder structure is: `foo/node_modules/bar/node_modules/baz`, there's no need to put another copy of bar into `.../baz/node_modules`, since when baz calls `require("bar")`, it will get the copy that is installed in `foo/node_modules/bar`.
+
+This shortcut is only used if the exact same version would be installed in multiple nested `node_modules` folders.
+It is still possible to have `a/node_modules/b/node_modules/a` if the two "a" packages are different versions.
+However, without repeating the exact same package multiple times, an infinite regress will always be prevented.
+
+Another optimization can be made by installing dependencies at the highest level possible, below the localized "target" folder (hoisting).
+Since version 3, npm hoists dependencies by default.
+
+#### Example
+
+Consider this dependency graph:
+
+```bash
+foo
++-- blerg@1.2.5
++-- bar@1.2.3
+|   +-- blerg@1.x (latest=1.3.7)
+|   +-- baz@2.x
+|   |   `-- quux@3.x
+|   |       `-- bar@1.2.3 (cycle)
+|   `-- asdf@*
+`-- baz@1.2.3
+    `-- quux@3.x
+        `-- bar
+```
+
+In this case, we might expect a folder structure like this (with all dependencies hoisted to the highest level possible):
+
+```bash
+foo
++-- node_modules
+    +-- blerg (1.2.5) <---[A]
+    +-- bar (1.2.3) <---[B]
+    |   +-- node_modules
+    |       +-- baz (2.0.2) <---[C]
+    +-- asdf (2.3.4)
+    +-- baz (1.2.3) <---[D]
+    +-- quux (3.2.0) <---[E]
+```
+
+Since foo depends directly on `bar@1.2.3` and `baz@1.2.3`, those are installed in foo's `node_modules` folder.
+
+Even though the latest copy of blerg is 1.3.7, foo has a specific dependency on version 1.2.5.
+So, that gets installed at [A].
+Since the parent installation of blerg satisfies bar's dependency on `blerg@1.x`, it does not install another copy under [B].
+
+Bar [B] also has dependencies on baz and asdf.
+Because it depends on `baz@2.x`, it cannot re-use the `baz@1.2.3` installed in the parent `node_modules` folder [D], and must install its own copy [C].
+In order to minimize duplication, npm hoists dependencies to the top level by default, so asdf is installed under [A].
+
+Underneath bar, the `baz -> quux -> bar` dependency creates a cycle.
+However, because bar is already in quux's ancestry [B], it does not unpack another copy of bar into that folder.
+Likewise, quux's [E] folder tree is empty, because its dependency on bar is satisfied by the parent folder copy installed at [B].
+
+For a graphical breakdown of what is installed where, use `npm ls`.
+
+#### Publishing
+
+Upon publishing, npm will look in the `node_modules` folder.
+If any of the items there are not in the `bundleDependencies` array, then they will not be included in the package tarball.
+
+This allows a package maintainer to install all of their dependencies (and dev dependencies) locally, but only re-publish those items that cannot be found elsewhere.
+See [`package.json`](/configuring-npm/package-json) for more information.
+
+### See also
+
+* [package.json](/configuring-npm/package-json)
+* [npm install](/commands/npm-install)
+* [npm pack](/commands/npm-pack)
+* [npm cache](/commands/npm-cache)
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [config](/using-npm/config)
+* [npm publish](/commands/npm-publish)
diff --git a/node/node_modules/npm/docs/content/configuring-npm/install.md b/node/node_modules/npm/docs/content/configuring-npm/install.md
new file mode 100644
index 0000000000000000000000000000000000000000..d1842b87d50c054301f776a96cf796d9c3037ffd
--- /dev/null
+++ b/node/node_modules/npm/docs/content/configuring-npm/install.md
@@ -0,0 +1,53 @@
+---
+title: Install
+section: 5
+description: Download and install node and npm
+---
+
+### Description
+
+To publish and install packages to and from the public npm registry, you must install Node.js and the npm command line interface using either a Node version manager or a Node installer.
+**We strongly recommend using a Node version manager to install Node.js and npm.** We do not recommend using a
+Node installer, since the Node installation process installs npm in a directory with local permissions and can cause permissions errors when you run npm packages globally.
+
+### Overview
+
+- [Checking your version of npm and Node.js](#checking-your-version-of-npm-and-nodejs)
+- [Using a Node version manager to install Node.js and npm](#using-a-node-version-manager-to-install-nodejs-and-npm)
+- [Using a Node installer to install Node.js and npm](#using-a-node-installer-to-install-nodejs-and-npm)
+
+### Checking your version of npm and Node.js
+
+To see if you already have Node.js and npm installed and check the installed version, run the following commands:
+
+```
+node -v
+npm -v
+```
+
+### Using a Node version manager to install Node.js and npm
+
+Node version managers allow you to install and switch between multiple versions of Node.js and npm on your system so you can test your applications on multiple versions of npm to ensure they work for users on different versions.
+You can [search for them on GitHub](https://github.com/search?q=node+version+manager+archived%3Afalse&type=repositories&ref=advsearch).
+
+### Using a Node installer to install Node.js and npm
+
+If you are unable to use a Node version manager, you can use a Node installer to install both Node.js and npm on your system.
+
+* [Node.js installer](https://nodejs.org/en/download/)
+* [NodeSource installer](https://github.com/nodesource/distributions).
+If you use Linux, we recommend that you use a NodeSource installer.
+
+#### macOS or Windows Node installers
+
+If you're using macOS or Windows, use one of the installers from the [Node.js download page](https://nodejs.org/en/download/).
+Be sure to install the version labeled **LTS**. Other versions have not yet been tested with npm.
+
+#### Linux or other operating systems Node installers
+
+If you're using Linux or another operating system, use one of the following installers:
+
+- [NodeSource installer](https://github.com/nodesource/distributions) (recommended)
+- One of the installers on the [Node.js download page](https://nodejs.org/en/download/)
+
+Or see [this page](https://nodejs.org/en/download/package-manager/) to install npm for Linux in the way many Linux developers prefer.
diff --git a/node/node_modules/npm/docs/content/configuring-npm/npm-shrinkwrap-json.md b/node/node_modules/npm/docs/content/configuring-npm/npm-shrinkwrap-json.md
new file mode 100644
index 0000000000000000000000000000000000000000..a50a1ecd73ee870ed68c08f6fa9f0eb8fb3a08d7
--- /dev/null
+++ b/node/node_modules/npm/docs/content/configuring-npm/npm-shrinkwrap-json.md
@@ -0,0 +1,25 @@
+---
+title: npm-shrinkwrap.json
+section: 5
+description: A publishable lockfile
+---
+
+### Description
+
+`npm-shrinkwrap.json` is a file created by [`npm shrinkwrap`](/commands/npm-shrinkwrap).
+It is identical to `package-lock.json`, with one major caveat: Unlike `package-lock.json`,
+`npm-shrinkwrap.json` may be included when publishing a package.
+
+The recommended use-case for `npm-shrinkwrap.json` is applications deployed through the publishing process on the registry: for example, daemons and command-line tools intended as global installs or `devDependencies`.
+It's strongly discouraged for library authors to publish this file, since that would prevent end users from having control over transitive dependency updates.
+
+If both `package-lock.json` and `npm-shrinkwrap.json` are present in a package root, `npm-shrinkwrap.json` will be preferred over the `package-lock.json` file.
+
+For full details and description of the `npm-shrinkwrap.json` file format, refer to the manual page for [package-lock.json](/configuring-npm/package-lock-json).
+
+### See also
+
+* [npm shrinkwrap](/commands/npm-shrinkwrap)
+* [package-lock.json](/configuring-npm/package-lock-json)
+* [package.json](/configuring-npm/package-json)
+* [npm install](/commands/npm-install)
diff --git a/node/node_modules/npm/docs/content/configuring-npm/npmrc.md b/node/node_modules/npm/docs/content/configuring-npm/npmrc.md
new file mode 100644
index 0000000000000000000000000000000000000000..e7b62c91b09753defae368e52959065d89a50d07
--- /dev/null
+++ b/node/node_modules/npm/docs/content/configuring-npm/npmrc.md
@@ -0,0 +1,193 @@
+---
+title: .npmrc
+section: 5
+description: The npm config files
+---
+
+### Description
+
+npm gets its config settings from the command line, environment variables, and `npmrc` files.
+
+The `npm config` command can be used to update and edit the contents of the user and global npmrc files.
+
+For a list of available configuration options, see [config](/using-npm/config).
+
+### Files
+
+The four relevant files are:
+
+* per-project config file (`/path/to/my/project/.npmrc`)
+* per-user config file (`~/.npmrc`)
+* global config file (`$PREFIX/etc/npmrc`)
+* npm builtin config file (`/path/to/npm/npmrc`)
+
+All npm config files are an ini-formatted list of `key = value` parameters.
+Environment variables can be replaced using `${VARIABLE_NAME}`.
+By default if the variable is not defined, it is left unreplaced.
+By adding `?` after variable name they can be forced to evaluate to an empty string instead.
+For example:
+
+```bash
+cache = ${HOME}/.npm-packages
+node-options = "${NODE_OPTIONS?} --use-system-ca"
+```
+
+Each of these files is loaded, and config options are resolved in priority order.
+For example, a setting in the userconfig file would override the setting in the globalconfig file.
+
+Array values are specified by adding "[]" after the key name.
+For example:
+
+```bash
+key[] = "first value"
+key[] = "second value"
+```
+
+#### Comments
+
+Lines in `.npmrc` files are interpreted as comments when they begin with a
+`;` or `#` character.
+`.npmrc` files are parsed by
+[npm/ini](https://github.com/npm/ini), which specifies this comment syntax.
+
+For example:
+
+```bash
+# last modified: 01 Jan 2016
+; Set a new registry for a scoped package
+@myscope:registry=https://mycustomregistry.example.org
+```
+
+#### Per-project config file
+
+When working locally in a project, a `.npmrc` file in the root of the project (ie, a sibling of `node_modules` and `package.json`) will set config values specific to this project.
+
+Note that this only applies to the root of the project that you're running npm in.
+It has no effect when your module is published.
+For example, you can't publish a module that forces itself to install globally, or in a different location.
+
+Additionally, this file is not read in global mode, such as when running `npm install -g`.
+
+#### Per-user config file
+
+`$HOME/.npmrc` (or the `userconfig` param, if set in the environment or on the command line)
+
+#### Global config file
+
+`$PREFIX/etc/npmrc` (or the `globalconfig` param, if set above): This file is an ini-file formatted list of `key = value` parameters.
+Environment variables can be replaced as above.
+
+#### Built-in config file
+
+`path/to/npm/itself/npmrc`
+
+This is an unchangeable "builtin" configuration file that npm keeps consistent across updates.
+Set fields in here using the `./configure` script that comes with npm.
+This is primarily for distribution maintainers to override default configs in a standard and consistent manner.
+
+### Auth related configuration
+
+The settings `_auth`, `_authToken`, `username`, `_password`, `certfile`, and `keyfile` must all be scoped to a specific registry.
+This ensures that `npm` will never send credentials to the wrong host.
+
+The full list is:
+ - `_auth` (base64 authentication string)
+ - `_authToken` (authentication token)
+ - `username`
+ - `_password`
+ - `email`
+ - `cafile` (path to certificate authority file)
+ - `certfile` (path to certificate file)
+ - `keyfile` (path to key file)
+
+In order to scope these values, they must be prefixed by a URI fragment.
+If the credential is meant for any request to a registry on a single host, the scope may look like `//registry.npmjs.org/:`.
+If it must be scoped to a specific path on the host that path may also be provided, such as
+`//my-custom-registry.org/unique/path:`.
+
+### Unsupported Custom Configuration Keys
+
+Starting in npm v11.2.0, npm warns when unknown configuration keys are defined in `.npmrc`. In a future major version of npm, these unknown keys may no longer be accepted.
+
+Only configuration keys that npm officially supports are recognized. Custom keys intended for third-party tools (for example, `electron-builder`) should not be placed in `.npmrc`.
+
+If you need package-level configuration for use in scripts, use the `config` field in your `package.json` instead:
+
+```json
+{
+  "name": "my-package",
+  "config": {
+    "mirror": "https://example.com/"
+  }
+}
+
+```
+
+Values defined in `package.json#config` are exposed to scripts as environment variables prefixed with `npm_package_config_`. For example:
+
+```
+npm_package_config_mirror
+```
+
+If you need to pass arguments to a script command, use `--` to separate npm arguments from script arguments:
+
+```
+npm run build -- --customFlag
+```
+
+Using environment variables is also recommended for cross-platform configuration instead of defining unsupported keys in `.npmrc`.
+
+
+```
+; bad config
+_authToken=MYTOKEN
+
+; good config
+@myorg:registry=https://somewhere-else.com/myorg
+@another:registry=https://somewhere-else.com/another
+//registry.npmjs.org/:_authToken=MYTOKEN
+
+; would apply to both @myorg and @another
+//somewhere-else.com/:_authToken=MYTOKEN
+
+; would apply only to @myorg
+//somewhere-else.com/myorg/:_authToken=MYTOKEN1
+
+; would apply only to @another
+//somewhere-else.com/another/:_authToken=MYTOKEN2
+```
+
+### Custom / third-party config keys
+
+npm only recognizes its own [configuration options](/using-npm/config).
+If your `.npmrc` contains keys that are not part of npm's config definitions
+(for example, `electron_mirror` or `sass_binary_site`), npm will emit a
+warning:
+
+```
+warn Unknown user config "electron_mirror".
+This will stop working in the next major version of npm.
+```
+
+These keys were historically tolerated but are not officially supported.
+A future major version of npm will treat unknown top-level keys as errors.
+
+Some tools (such as `@electron/get` or `node-sass`) read their own
+configuration from environment variables or from `.npmrc` by convention.
+You can set these values as environment variables instead:
+
+```bash
+export ELECTRON_MIRROR="https://mirrorexample.npmjs.org/mirrors/electron/"
+export ELECTRON_CUSTOM_DIR="{{ version }}"
+```
+
+Environment variables are the most portable approach and work regardless
+of `.npmrc` format.
+
+### See also
+
+* [npm folders](/configuring-npm/folders)
+* [npm config](/commands/npm-config)
+* [config](/using-npm/config)
+* [package.json](/configuring-npm/package-json)
+* [npm](/commands/npm)
diff --git a/node/node_modules/npm/docs/content/configuring-npm/package-json.md b/node/node_modules/npm/docs/content/configuring-npm/package-json.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0939d0e613a7fddc116f53dfda6addfc56ece0b
--- /dev/null
+++ b/node/node_modules/npm/docs/content/configuring-npm/package-json.md
@@ -0,0 +1,1195 @@
+---
+title: package.json
+section: 5
+description: Specifics of npm's package.json handling
+---
+
+### Description
+
+This document is all you need to know about what's required in your package.json file.
+It must be actual JSON, not just a JavaScript object literal.
+
+A lot of the behavior described in this document is affected by the config settings described in [`config`](/using-npm/config).
+
+### name
+
+If you plan to publish your package, the *most* important things in your package.json are the name and version fields as they will be required.
+The name and version together form an identifier that is assumed to be completely unique.
+Changes to the package should come along with changes to the version.
+If you don't plan to publish your package, the name and version fields are optional.
+
+The name is what your thing is called.
+
+Some rules:
+
+* The name must be less than or equal to 214 characters.
+  This includes the scope for scoped packages.
+* The names of scoped packages can begin with a dot or an underscore.
+  This is not permitted without a scope.
+* New packages must not have uppercase letters in the name.
+* The name ends up being part of a URL, an argument on the command line, and a folder name.
+  Therefore, the name can't contain any non-URL-safe characters.
+
+Some tips:
+
+* Don't use the same name as a core Node module.
+* Don't put "js" or "node" in the name.
+  It's assumed that it's js, since you're writing a package.json file, and you can specify the engine using the "[engines](#engines)" field.
+  (See below.)
+* The name will probably be passed as an argument to require(), so it should be something short, but also reasonably descriptive.
+* You may want to check the npm registry to see if there's something by that name already, before you get too attached to it.
+  <https://www.npmjs.com/>
+
+A name can be optionally prefixed by a scope, e.g. `@npm/example`.
+See [`scope`](/using-npm/scope) for more detail.
+
+### version
+
+If you plan to publish your package, the *most* important things in your package.json are the name and version fields as they will be required.
+The name and version together form an identifier that is assumed to be completely unique.
+Changes to the package should come along with changes to the version.
+If you don't plan to publish your package, the name and version fields are optional.
+
+Version must be parseable by [node-semver](https://github.com/npm/node-semver), which is bundled with npm as a dependency.
+(`npm install semver` to use it yourself.)
+
+### description
+
+Put a description in it.
+It's a string.
+This helps people discover your package, as it's listed in `npm search`.
+
+### keywords
+
+Put keywords in it.
+It's an array of strings.
+This helps people discover your package as it's listed in `npm search`.
+
+Example:
+
+```json
+"keywords": [
+  "node",
+  "javascript",
+  "npm"
+]
+```
+
+### homepage
+
+The URL to the project homepage.
+
+Example:
+
+```json
+"homepage": "https://github.com/npm/example#readme"
+```
+
+### bugs
+
+The URL to your project's issue tracker and / or the email address to which issues should be reported.
+These are helpful for people who encounter issues with your package.
+
+It should look like this:
+
+```json
+{
+  "bugs": {
+    "url": "https://github.com/npm/example/issues",
+    "email": "example@npmjs.com"
+  }
+}
+```
+
+You can specify either one or both values.
+If you want to provide only a URL, you can specify the value for "bugs" as a simple string instead of an object.
+
+If a URL is provided, it will be used by the `npm bugs` command.
+
+### license
+
+You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
+
+If you're using a common license such as BSD-2-Clause or MIT, add a current SPDX license identifier for the license you're using, like this:
+
+```json
+{
+  "license" : "BSD-3-Clause"
+}
+```
+
+You can check [the full list of SPDX license IDs](https://spdx.org/licenses/).
+Ideally, you should pick one that is [OSI](https://opensource.org/licenses/) approved.
+
+If your package is licensed under multiple common licenses, use an [SPDX license expression syntax version 2.0 string](https://spdx.dev/specifications/), like this:
+
+```json
+{
+  "license" : "(ISC OR GPL-3.0)"
+}
+```
+If you are using a license that hasn't been assigned an SPDX identifier, or if you are using a custom license, use a string value like this one:
+
+```json
+{
+  "license" : "SEE LICENSE IN <filename>"
+}
+```
+Then include a file named `<filename>` at the top level of the package.
+
+Some old packages used license objects or a "licenses" property containing an array of license objects:
+
+```json
+// Not valid metadata
+{
+  "license" : {
+    "type" : "ISC",
+    "url" : "https://opensource.org/licenses/ISC"
+  }
+}
+
+// Not valid metadata
+{
+  "licenses" : [
+    {
+      "type": "MIT",
+      "url": "https://www.opensource.org/licenses/mit-license.php"
+    },
+    {
+      "type": "Apache-2.0",
+      "url": "https://opensource.org/licenses/apache2.0.php"
+    }
+  ]
+}
+```
+
+Those styles are now deprecated.
+Instead, use SPDX expressions, like this:
+
+```json
+{
+  "license": "ISC"
+}
+```
+
+```json
+{
+  "license": "(MIT OR Apache-2.0)"
+}
+```
+
+Finally, if you do not wish to grant others the right to use a private or unpublished package under any terms:
+
+```json
+{
+  "license": "UNLICENSED"
+}
+```
+
+Consider also setting `"private": true` to prevent accidental publication.
+
+### people fields: author, contributors
+
+The "author" is one person.
+"contributors" is an array of people.
+A "person" is an object with a "name" field and optionally "url" and "email", like this:
+
+```json
+{
+  "name" : "Barney Rubble",
+  "email" : "barney@npmjs.com",
+  "url" : "http://barnyrubble.npmjs.com/"
+}
+```
+
+Or you can shorten that all into a single string, and npm will parse it for you:
+
+```json
+{
+  "author": "Barney Rubble <barney@npmjs.com> (http://barnyrubble.npmjs.com/)"
+}
+```
+
+Both email and url are optional either way.
+
+npm also sets a top-level "maintainers" field with your npm user info.
+
+### funding
+
+You can specify an object containing a URL that provides up-to-date information about ways to help fund development of your package, a string URL, or an array of objects and string URLs:
+
+```json
+{
+  "funding": {
+    "type" : "individual",
+    "url" : "http://npmjs.com/donate"
+  }
+}
+```
+
+```json
+{
+  "funding": {
+    "type" : "patreon",
+    "url" : "https://www.patreon.com/user"
+  }
+}
+```
+
+```json
+{
+  "funding": "http://npmjs.com/donate"
+}
+```
+
+```json
+{
+  "funding": [
+    {
+      "type" : "individual",
+      "url" : "http://npmjs.com/donate"
+    },
+    "http://npmjs.com/donate-also",
+    {
+      "type" : "patreon",
+      "url" : "https://www.patreon.com/user"
+    }
+  ]
+}
+```
+
+Users can use the `npm fund` subcommand to list the `funding` URLs of all dependencies of their project, direct and indirect.
+A shortcut to visit each funding URL is also available when providing the project name such as:
+`npm fund <projectname>` (when there are multiple URLs, the first one will be visited)
+
+### files
+
+The optional `files` field is an array of file patterns that describes the entries to be included when your package is installed as a dependency.
+File patterns follow a similar syntax to `.gitignore`, but reversed: including a file, directory, or glob pattern (`*`, `**/*`, and such) will make it so that file is included in the tarball when it's packed.
+Omitting the field will make it default to `["*"]`, which means it will include all files.
+
+Some special files and directories are also included or excluded regardless of whether they exist in the `files` array (see below).
+
+You can also provide a `.npmignore` file in the root of your package or in subdirectories, which will keep files from being included.
+At the root of your package it will not override the "files" field, but in subdirectories it will.
+The `.npmignore` file works just like a `.gitignore`.
+If there is a `.gitignore` file, and `.npmignore` is missing, `.gitignore`'s contents will be used instead.
+
+Certain files are always included, regardless of settings:
+
+* `package.json`
+* `README`
+* `LICENSE` / `LICENCE`
+* The file in the "main" field
+* The file(s) in the "bin" field
+
+`README` & `LICENSE` can have any case and extension.
+
+Some files are always ignored by default:
+
+* `*.orig`
+* `.*.swp`
+* `.DS_Store`
+* `._*`
+* `.git`
+* `.hg`
+* `.lock-wscript`
+* `.npmrc`
+* `.svn`
+* `.wafpickle-N`
+* `CVS`
+* `config.gypi`
+* `node_modules`
+* `npm-debug.log`
+* `package-lock.json` (use [`npm-shrinkwrap.json`](/configuring-npm/npm-shrinkwrap-json) if you wish it to be published)
+* `pnpm-lock.yaml`
+* `yarn.lock`
+* `bun.lockb`
+
+Most of these ignored files can be included specifically if included in the `files` globs.
+Exceptions to this are:
+
+* `.git`
+* `.npmrc`
+* `node_modules`
+* `package-lock.json`
+* `pnpm-lock.yaml`
+* `yarn.lock`
+* `bun.lockb`
+
+These cannot be included.
+
+### exports
+
+The "exports" provides a modern alternative to "main" allowing multiple entry points to be defined, conditional entry resolution support between environments, and preventing any other entry points besides those defined in "exports". This encapsulation allows module authors to clearly define the public interface for their package.
+For more details see the [node.js documentation on package entry points](https://nodejs.org/api/packages.html#package-entry-points)
+
+### main
+
+The main field is a module ID that is the primary entry point to your program.
+That is, if your package is named `foo`, and a user installs it, and then does `require("foo")`, then your main module's exports object will be returned.
+
+This should be a module relative to the root of your package folder.
+
+For most modules, it makes the most sense to have a main script and often not much else.
+
+If `main` is not set, it defaults to `index.js` in the package's root folder.
+
+### type
+
+The `type` field defines how Node.js should interpret `.js` files in your package. This field is not used by npm.
+
+See the [Node.js documentation on the type field](https://nodejs.org/api/packages.html#type) for more information.
+
+### browser
+
+If your module is meant to be used client-side the browser field should be used instead of the main field.
+This is helpful to hint users that it might rely on primitives that aren't available in Node.js modules.
+(e.g. `window`)
+
+### bin
+
+A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)
+
+To use this, supply a `bin` field in your package.json which is a map of command name to local file name.
+When this package is installed globally, that file will be either linked inside the global bins directory or a cmd (Windows Command File) will be created which executes the specified file in the `bin` field, so it is available to run by `name` or `name.cmd` (on Windows PowerShell).
+When this package is installed as a dependency in another package, the file will be linked where it will be available to that package either directly by `npm exec` or by name in other scripts when invoking them via `npm run`.
+
+
+For example, myapp could have this:
+
+```json
+{
+  "bin": {
+    "myapp": "bin/cli.js"
+  }
+}
+```
+
+So, when you install myapp, in case of unix-like OS it'll create a symlink from the `cli.js` script to `/usr/local/bin/myapp` and in case of windows it will create a cmd file usually at `C:\Users\{Username}\AppData\Roaming\npm\myapp.cmd` which runs the `cli.js` script.
+
+If you have a single executable, and its name should be the name of the package, then you can just supply it as a string.
+For example:
+
+```json
+{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": "path/to/program"
+}
+```
+
+would be the same as this:
+
+```json
+{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": {
+    "my-program": "path/to/program"
+  }
+}
+```
+
+Please make sure that your file(s) referenced in `bin` starts with `#!/usr/bin/env node`; otherwise, the scripts are started without the node executable!
+
+Note that you can also set the executable files using [directories.bin](#directoriesbin).
+
+See [folders](/configuring-npm/folders#executables) for more info on executables.
+
+### man
+
+Specify either a single file or an array of filenames to put in place for the `man` program to find.
+
+If only a single file is provided, then it's installed such that it is the result from `man <pkgname>`, regardless of its actual filename.
+For example:
+
+```json
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": "./man/doc.1"
+}
+```
+
+would link the `./man/doc.1` file in such that it is the target for `man foo`
+
+If the filename doesn't start with the package name, then it's prefixed.
+So, this:
+
+```json
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": [
+    "./man/foo.1",
+    "./man/bar.1"
+  ]
+}
+```
+
+will create files to do `man foo` and `man foo-bar`.
+
+Man files must end with a number, and optionally a `.gz` suffix if they are compressed.
+The number dictates which man section the file is installed into.
+
+```json
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": [
+    "./man/foo.1",
+    "./man/foo.2"
+  ]
+}
+```
+
+will create entries for `man foo` and `man 2 foo`
+
+### directories
+
+The CommonJS [Packages](http://wiki.commonjs.org/wiki/Packages/1.0) spec details a few ways that you can indicate the structure of your package using a `directories` object.
+If you look at [npm's package.json](https://registry.npmjs.org/npm/latest), you'll see that it has directories for doc, lib, and man.
+
+In the future, this information may be used in other creative ways.
+
+#### directories.bin
+
+If you specify a `bin` directory in `directories.bin`, all the files in that folder will be added.
+
+Because of the way the `bin` directive works, specifying both a `bin` path and setting `directories.bin` is an error.
+If you want to specify individual files, use `bin`, and for all the files in an existing `bin` directory, use `directories.bin`.
+
+#### directories.man
+
+A folder that is full of man pages.
+Sugar to generate a "man" array by walking the folder.
+
+### repository
+
+Specify the place where your code lives.
+This is helpful for people who want to contribute.
+If the git repo is on GitHub, then the `npm repo` command will be able to find you.
+
+Do it like this:
+
+```json
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git"
+  }
+}
+```
+
+The URL should be a publicly available (perhaps read-only) URL that can be handed directly to a VCS program without any modification.
+It should not be a URL to an html project page that you put in your browser.
+It's for computers.
+
+For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for `npm install`:
+
+```json
+{
+  "repository": "npm/example",
+
+  "repository": "github:npm/example",
+
+  "repository": "gist:11081aaa281",
+
+  "repository": "bitbucket:user/repo",
+
+  "repository": "gitlab:user/repo"
+}
+```
+
+**Note on normalization:** When you publish a package, npm normalizes the `repository` field to the full object format with a `url` property. If you use a shorthand format (like `"npm/example"`), you'll see a warning during `npm publish` indicating that the field was auto-corrected. While the shorthand format currently works, it's recommended to use the full object format in your `package.json` to avoid warnings and ensure future compatibility:
+
+```json
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/example.git"
+  }
+}
+```
+
+You can run `npm pkg fix` to automatically convert shorthand formats to the normalized object format.
+
+If the `package.json` for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives:
+
+```json
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git",
+    "directory": "workspaces/libnpmpublish"
+  }
+}
+```
+
+### scripts
+
+The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package.
+The key is the lifecycle event, and the value is the command to run at that point.
+
+See [`scripts`](/using-npm/scripts) to find out more about writing package scripts.
+
+### gypfile
+
+If you have a binding.gyp file in the root of your package and you have not defined your own `install` or `preinstall` scripts, npm will default to building your module using node-gyp.
+
+To prevent npm from automatically building your module with node-gyp, set `gypfile` to `false`:
+
+```json
+{
+  "gypfile": false
+}
+```
+
+This is useful for packages that include native addons but want to handle the build process differently, or packages that have a binding.gyp file but should not be built as a native addon.
+
+### config
+
+A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades.
+For instance, if a package had the following:
+
+```json
+{
+  "name": "foo",
+  "config": {
+    "port": "8080"
+  }
+}
+```
+
+It could also have a "start" script that referenced the `npm_package_config_port` environment variable.
+
+### dependencies
+
+Dependencies are specified in a simple object that maps a package name to a version range.
+The version range is a string which has one or more space-separated descriptors.
+Dependencies can also be identified with a tarball or git URL.
+
+**Please do not put test harnesses or transpilers or other "development" time tools in your `dependencies` object.**
+See `devDependencies`, below.
+
+See [semver](https://github.com/npm/node-semver#versions) for more details about specifying version ranges.
+
+* `version` Must match `version` exactly
+* `>version` Must be greater than `version`
+* `>=version` etc
+* `<version`
+* `<=version`
+* `~version` "Approximately equivalent to version"  See [semver](https://github.com/npm/node-semver#versions)
+* `^version` "Compatible with version"  See [semver](https://github.com/npm/node-semver#versions)
+* `1.2.x` 1.2.0, 1.2.1, etc., but not 1.3.0
+* `http://...` See 'URLs as Dependencies' below
+* `*` Matches any version
+* `""` (just an empty string) Same as `*`
+* `version1 - version2` Same as `>=version1 <=version2`.
+* `range1 || range2` Passes if either range1 or range2 are satisfied.
+* `git...` See 'Git URLs as Dependencies' below
+* `user/repo` See 'GitHub URLs' below
+* `tag` A specific version tagged and published as `tag`  See [`npm dist-tag`](/commands/npm-dist-tag)
+* `path/path/path` See [Local Paths](#local-paths) below
+* `npm:@scope/pkg@version` Custom alias for a package See [`package-spec`](/using-npm/package-spec#aliases)
+
+For example, these are all valid:
+
+```json
+{
+  "dependencies": {
+    "foo": "1.0.0 - 2.9999.9999",
+    "bar": ">=1.0.2 <2.1.2",
+    "baz": ">1.0.2 <=2.3.4",
+    "boo": "2.0.1",
+    "qux": "<1.0.0 || >=2.3.1 <2.4.5 || >=2.5.2 <3.0.0",
+    "asd": "http://npmjs.com/example.tar.gz",
+    "til": "~1.2",
+    "elf": "~1.2.3",
+    "two": "2.x",
+    "thr": "3.3.x",
+    "lat": "latest",
+    "dyl": "file:../dyl",
+    "kpg": "npm:pkg@1.0.0"
+  }
+}
+```
+
+#### URLs as Dependencies
+
+You may specify a tarball URL in place of a version range.
+
+This tarball will be downloaded and installed locally to your package at install time.
+
+#### Git URLs as Dependencies
+
+Git URLs are of the form:
+
+```bash
+<protocol>://[<user>[:<password>]@]<hostname>[:<port>][:][/]<path>[#<commit-ish> | #semver:<semver>]
+```
+
+`<protocol>` is one of `git`, `git+ssh`, `git+http`, `git+https`, or `git+file`.
+
+If `#<commit-ish>` is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format `#semver:<semver>`, `<semver>` can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither `#<commit-ish>` or `#semver:<semver>` is specified, then the default branch is used.
+
+Examples:
+
+```bash
+git+ssh://git@github.com:npm/cli.git#v1.0.27
+git+ssh://git@github.com:npm/cli#semver:^5.0
+git+https://isaacs@github.com/npm/cli.git
+git://github.com/npm/cli.git#v1.0.27
+```
+
+When installing from a `git` repository, the presence of certain fields in the `package.json` will cause npm to believe it needs to perform a build.
+To do so your repository will be cloned into a temporary directory, all of its deps installed, relevant scripts run, and the resulting directory packed and installed.
+
+This flow will occur if your git dependency uses `workspaces`, or if any of the following scripts are present:
+
+* `build`
+* `prepare`
+* `prepack`
+* `preinstall`
+* `install`
+* `postinstall`
+
+If your git repository includes pre-built artifacts, you will likely want to make sure that none of the above scripts are defined, or your dependency will be rebuilt for every installation.
+
+#### GitHub URLs
+
+As of version 1.1.65, you can refer to GitHub URLs as just "foo":
+"user/foo-project".  Just as with git URLs, a `commit-ish` suffix can be included.
+For example:
+
+```json
+{
+  "name": "foo",
+  "version": "0.0.0",
+  "dependencies": {
+    "express": "expressjs/express",
+    "mocha": "mochajs/mocha#4727d357ea",
+    "module": "npm/example-github-repo#feature\/branch"
+  }
+}
+```
+
+#### Local Paths
+
+As of version 2.0.0 you can provide a path to a local directory that contains a package.
+Local paths can be saved using `npm install -S` or `npm install --save`, using any of these forms:
+
+```bash
+../foo/bar
+~/foo/bar
+./foo/bar
+/foo/bar
+```
+
+in which case they will be normalized to a relative path and added to your `package.json`.
+For example:
+
+```json
+{
+  "name": "baz",
+  "dependencies": {
+    "bar": "file:../foo/bar"
+  }
+}
+```
+
+This feature is helpful for local offline development and creating tests that require npm installing where you don't want to hit an external server, but should not be used when publishing your package to the public registry.
+
+*note*: Packages linked by local path will not have their own dependencies installed when `npm install` is run.
+You must run `npm install` from inside the local path itself.
+
+### devDependencies
+
+If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.
+
+In this case, it's best to map these additional items in a `devDependencies` object.
+
+These things will be installed when doing `npm link` or `npm install` from the root of a package, and can be managed like any other npm configuration param.
+See [`config`](/using-npm/config) for more on the topic.
+
+For build steps that are not platform-specific, such as compiling CoffeeScript or other languages to JavaScript, use the `prepare` script to do this, and make the required package a devDependency.
+
+For example:
+
+```json
+{
+  "name": "@npm/ethopia-waza",
+  "description": "a delightfully fruity coffee varietal",
+  "version": "1.2.3",
+  "devDependencies": {
+    "coffee-script": "~1.6.3"
+  },
+  "scripts": {
+    "prepare": "coffee -o lib/ -c src/waza.coffee"
+  },
+  "main": "lib/waza.js"
+}
+```
+
+The `prepare` script will be run before publishing, so that users can consume the functionality without requiring them to compile it themselves.
+In dev mode (ie, locally running `npm install`), it'll run this script as well, so that you can test it easily.
+
+### peerDependencies
+
+In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a `require` of this host.
+This is usually referred to as a *plugin*. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.
+
+For example:
+
+```json
+{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x"
+  }
+}
+```
+
+This ensures your package `@npm/tea-latte` can be installed *along* with the second major version of the host package `@npm/tea` only.
+`npm install tea-latte` could possibly yield the following dependency graph:
+
+```bash
+├── @npm/tea-latte@1.3.5
+└── @npm/tea@2.2.0
+```
+
+In npm versions 3 through 6, `peerDependencies` were not automatically installed, and would raise a warning if an invalid version of the peer dependency was found in the tree.
+As of npm v7, peerDependencies _are_ installed by default.
+
+Trying to install another plugin with a conflicting requirement may cause an error if the tree cannot be resolved correctly.
+For this reason, make sure your plugin requirement is as broad as possible, and not to lock it down to specific patch versions.
+
+Assuming the host complies with [semver](https://semver.org/), only changes in the host package's major version will break your plugin.
+Thus, if you've worked with every 1.x version of the host package, use `"^1.0"` or `"1.x"` to express this.
+If you depend on features introduced in 1.5.2, use `"^1.5.2"`.
+
+### peerDependenciesMeta
+
+The `peerDependenciesMeta` field serves to provide npm more information on how your peer dependencies are to be used.
+Specifically, it allows peer dependencies to be marked as optional.
+Npm will not automatically install optional peer dependencies.
+This allows you to integrate and interact with a variety of host packages without requiring all of them to be installed.
+
+For example:
+
+```json
+{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x",
+    "@npm/soy-milk": "1.2"
+  },
+  "peerDependenciesMeta": {
+    "@npm/soy-milk": {
+      "optional": true
+    }
+  }
+}
+```
+
+### bundleDependencies
+
+This defines an array of package names that will be bundled when publishing the package.
+
+In cases where you need to preserve npm packages locally or have them available through a single file download, you can bundle the packages in a tarball file by specifying the package names in the `bundleDependencies` array and executing `npm pack`.
+
+For example:
+
+If we define a package.json like this:
+
+```json
+{
+  "name": "@npm/awesome-web-framework",
+  "version": "1.0.0",
+  "bundleDependencies": [
+    "@npm/renderized",
+    "@npm/super-streams"
+  ]
+}
+```
+
+we can obtain `@npm/awesome-web-framework-1.0.0.tgz` file by running `npm pack`.
+This file contains the dependencies `@npm/renderized` and `@npm/super-streams` which can be installed in a new project by executing `npm install awesome-web-framework-1.0.0.tgz`.
+Note that the package names do not include any versions, as that information is specified in `dependencies`.
+
+If this is spelled `"bundledDependencies"`, then that is also honored.
+
+Alternatively, `"bundleDependencies"` can be defined as a boolean value.
+A value of `true` will bundle all dependencies, a value of `false` will bundle none.
+
+### optionalDependencies
+
+If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the `optionalDependencies` object.
+This is a map of package name to version or URL, just like the `dependencies` object.
+The difference is that build failures do not cause installation to fail.
+Running `npm install --omit=optional` will prevent these dependencies from being installed.
+
+It is still your program's responsibility to handle the lack of the dependency.
+For example, something like this:
+
+```js
+try {
+  var foo = require('@npm/foo')
+  var fooVersion = require('@npm/foo/package.json').version
+} catch (er) {
+  foo = null
+}
+if ( notGoodFooVersion(fooVersion) ) {
+  foo = null
+}
+
+// .. then later in your program ..
+
+if (foo) {
+  foo.doFooThings()
+}
+```
+
+Entries in `optionalDependencies` will override entries of the same name in `dependencies`, so it's usually best to only put in one place.
+
+### overrides
+
+If you need to make specific changes to dependencies of your dependencies, for example replacing the version of a dependency with a known security issue, replacing an existing dependency with a fork, or making sure that the same version of a package is used everywhere, then you may add an override.
+
+Overrides provide a way to replace a package in your dependency tree with another version, or another package entirely.
+These changes can be scoped as specific or as vague as desired.
+
+Overrides are only considered in the root `package.json` file for a project.
+Overrides in installed dependencies (including [workspaces](/using-npm/workspaces)) are not considered in dependency tree resolution.
+Published packages may dictate their resolutions by pinning dependencies or using an [`npm-shrinkwrap.json`](/configuring-npm/npm-shrinkwrap-json) file.
+
+To make sure the package `@npm/foo` is always installed as version `1.0.0` no matter what version your dependencies rely on:
+
+```json
+{
+  "overrides": {
+    "@npm/foo": "1.0.0"
+  }
+}
+```
+
+The above is a short hand notation, the full object form can be used to allow overriding a package itself as well as a child of the package.
+This will cause `@npm/foo` to always be `1.0.0` while also making `@npm/bar` at any depth beyond `@npm/foo` also `1.0.0`:
+
+```json
+{
+  "overrides": {
+    "@npm/foo": {
+      ".": "1.0.0",
+      "@npm/bar": "1.0.0"
+    }
+  }
+}
+```
+
+To only override `@npm/foo` to be `1.0.0` when it's a child (or grandchild, or great grandchild, etc) of the package `@npm/bar`:
+
+```json
+{
+  "overrides": {
+    "@npm/bar": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+```
+
+Keys can be nested to any arbitrary length.
+To override `@npm/foo` only when it's a child of `@npm/bar` and only when `@npm/bar` is a child of `@npm/baz`:
+
+```json
+{
+  "overrides": {
+    "@npm/baz": {
+      "@npm/bar": {
+        "@npm/foo": "1.0.0"
+      }
+    }
+  }
+}
+```
+
+The key of an override can also include a version, or range of versions.
+To override `@npm/foo` to `1.0.0`, but only when it's a child of `@npm/bar@2.0.0`:
+
+```json
+{
+  "overrides": {
+    "@npm/bar@2.0.0": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+```
+
+You may not set an override for a package that you directly depend on unless both the dependency and the override itself share the exact same spec.
+To make this limitation easier to deal with, overrides may also be defined as a reference to a spec for a direct dependency by prefixing the name of the package you wish the version to match with a `$`.
+
+```json
+{
+  "dependencies": {
+    "@npm/foo": "^1.0.0"
+  },
+  "overrides": {
+    // BAD, will throw an EOVERRIDE error
+    // "foo": "^2.0.0"
+    // GOOD, specs match so override is allowed
+    // "foo": "^1.0.0"
+    // BEST, the override is defined as a reference to the dependency
+    "@npm/foo": "$foo",
+    // the referenced package does not need to match the overridden one
+    "@npm/bar": "$foo"
+  }
+}
+```
+
+#### Replacing a dependency with a fork
+
+You can replace a package with a different package or fork using several methods:
+
+**Using the `npm:` prefix to replace with a different package name:**
+
+```json
+{
+  "overrides": {
+    "package-name": "npm:@scope/forked-package@1.0.0"
+  }
+}
+```
+
+**Using a GitHub repository (supports branches, tags, or commit hashes):**
+
+```json
+{
+  "overrides": {
+    "package-name": "github:username/repo#branch-name"
+  }
+}
+```
+
+**Using a local file path:**
+
+```json
+{
+  "overrides": {
+    "package-name": "file:../local-fork"
+  }
+}
+```
+
+These replacement methods work for both top-level overrides and nested overrides.
+For example, to replace a transitive dependency with a fork:
+
+```json
+{
+  "overrides": {
+    "parent-package": {
+      "vulnerable-dep": "github:username/patched-fork#v2.0.1"
+    }
+  }
+}
+```
+
+### engines
+
+You can specify the version of node that your stuff works on:
+
+```json
+{
+  "engines": {
+    "node": ">=0.10.3 <15"
+  }
+}
+```
+
+And, like with dependencies, if you don't specify the version (or if you specify "\*" as the version), then any version of node will do.
+
+You can also use the "engines" field to specify which versions of npm are capable of properly installing your program.
+For example:
+
+```json
+{
+  "engines": {
+    "npm": "~1.0.20"
+  }
+}
+```
+
+Unless the user has set the [`engine-strict` config](/using-npm/config#engine-strict) flag, this field is advisory only and will only produce warnings when your package is installed as a dependency.
+
+### os
+
+You can specify which operating systems your module will run on:
+
+```json
+{
+  "os": [
+    "darwin",
+    "linux"
+  ]
+}
+```
+
+You can also block instead of allowing operating systems, just prepend the blocked os with a '!':
+
+```json
+{
+  "os": [
+    "!win32"
+  ]
+}
+```
+
+The host operating system is determined by `process.platform`
+
+It is allowed to both block and allow an item, although there isn't any good reason to do this.
+
+### cpu
+
+If your code only runs on certain cpu architectures, you can specify which ones.
+
+```json
+{
+  "cpu": [
+    "x64",
+    "ia32"
+  ]
+}
+```
+
+Like the `os` option, you can also block architectures:
+
+```json
+{
+  "cpu": [
+    "!arm",
+    "!mips"
+  ]
+}
+```
+
+The host architecture is determined by `process.arch`
+
+### libc
+
+If your code only runs or builds in certain versions of libc, you can specify which ones.
+This field only applies if `os` is `linux`.
+
+```json
+{
+  "os": "linux",
+  "libc": "glibc"
+}
+```
+
+### devEngines
+
+The `devEngines` field aids engineers working on a codebase to all be using the same tooling.
+
+You can specify a `devEngines` property in your `package.json` which will run before `install`, `ci`, and `run` commands.
+
+
+> Note: `engines` and `devEngines` differ in object shape.
+They also function very differently.
+`engines` is designed to alert the user when a dependency uses a different npm or node version than the project it's being used in, whereas `devEngines` is used to alert people interacting with the source code of a project.
+
+The supported keys under the `devEngines` property are `cpu`, `os`, `libc`, `runtime`, and `packageManager`.
+Each property can be an object or an array of objects.
+Objects must contain `name`, and optionally can specify `version`, and `onFail`.
+`onFail` can be `warn`, `error`, or `ignore`, and if left undefined is of the same value as `error`.
+`npm` will assume that you're running with `node`.
+Here's an example of a project that will fail if the environment is not `node` and `npm`.
+If you set `runtime.name` or `packageManager.name` to any other string, it will fail within the npm CLI.
+
+```json
+{
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "onFail": "error"
+    }
+  }
+}
+```
+
+### private
+
+If you set `"private": true` in your package.json, then npm will refuse to publish it.
+
+This is a way to prevent accidental publication of private repositories.
+If you would like to ensure that a given package is only ever published to a specific registry (for example, an internal registry), then use the `publishConfig` dictionary described below to override the `registry` config param at publish-time.
+
+### publishConfig
+
+This is a set of config values that will be used at publish-time.
+It's especially handy if you want to set the tag, registry or access, so that you can ensure that a given package is not tagged with "latest", published to the global public registry or that a scoped module is private by default.
+
+See [`config`](/using-npm/config) to see the list of config options that can be overridden.
+
+### workspaces
+
+The optional `workspaces` field is an array of file patterns that describes locations within the local file system that the install client should look up to find each [workspace](/using-npm/workspaces) that needs to be symlinked to the top level `node_modules` folder.
+
+It can describe either the direct paths of the folders to be used as workspaces or it can define globs that will resolve to these same folders.
+
+In the following example, all folders located inside the folder `./packages` will be treated as workspaces as long as they have valid `package.json` files inside them:
+
+```json
+{
+  "name": "workspace-example",
+  "workspaces": [
+    "./packages/*"
+  ]
+}
+```
+
+See [`workspaces`](/using-npm/workspaces) for more examples.
+
+### DEFAULT VALUES
+
+npm will default some values based on package contents.
+
+* `"scripts": {"start": "node server.js"}`
+
+  If there is a `server.js` file in the root of your package, then npm will default the `start` command to `node server.js`.
+
+* `"scripts":{"install": "node-gyp rebuild"}`
+
+  If there is a `binding.gyp` file in the root of your package and you have not defined an `install` or `preinstall` script, npm will default the `install` command to compile using node-gyp.
+
+* `"contributors": [...]`
+
+  If there is an `AUTHORS` file in the root of your package, npm will treat each line as a `Name <email> (url)` format, where email and url are optional.
+  Lines which start with a `#` or are blank, will be ignored.
+
+### SEE ALSO
+
+* [semver](https://github.com/npm/node-semver#versions)
+* [workspaces](/using-npm/workspaces)
+* [npm init](/commands/npm-init)
+* [npm version](/commands/npm-version)
+* [npm config](/commands/npm-config)
+* [npm help](/commands/npm-help)
+* [npm install](/commands/npm-install)
+* [npm publish](/commands/npm-publish)
+* [npm uninstall](/commands/npm-uninstall)
diff --git a/node/node_modules/npm/docs/content/configuring-npm/package-lock-json.md b/node/node_modules/npm/docs/content/configuring-npm/package-lock-json.md
new file mode 100644
index 0000000000000000000000000000000000000000..9c4a298080aaa4b774b0fc171cbac3bf712346f7
--- /dev/null
+++ b/node/node_modules/npm/docs/content/configuring-npm/package-lock-json.md
@@ -0,0 +1,182 @@
+---
+title: package-lock.json
+section: 5
+description: A manifestation of the manifest
+---
+
+### Description
+
+`package-lock.json` is automatically generated for any operations where npm modifies either the `node_modules` tree, or `package.json`.
+It describes the exact tree that was generated, such that subsequent installs are able to generate identical trees, regardless of intermediate dependency updates.
+
+This file is intended to be committed into source repositories, and serves various purposes:
+
+* Describe a single representation of a dependency tree such that teammates, deployments, and continuous integration are guaranteed to install exactly the same dependencies.
+
+* Provide a facility for users to "time-travel" to previous states of `node_modules` without having to commit the directory itself.
+
+* Facilitate greater visibility of tree changes through readable source control diffs.
+
+* Optimize the installation process by allowing npm to skip repeated metadata resolutions for previously-installed packages.
+
+* As of npm v7, lockfiles include enough information to gain a complete picture of the package tree, reducing the need to read `package.json` files, and allowing for significant performance improvements.
+
+When `npm` creates or updates `package-lock.json`, it will infer line endings and indentation from `package.json` so that the formatting of both files matches.
+
+### `package-lock.json` vs `npm-shrinkwrap.json`
+
+Both of these files have the same format, and perform similar functions in the root of a project.
+
+The difference is that `package-lock.json` cannot be published, and it will be ignored if found in any place other than the root project.
+
+In contrast, [npm-shrinkwrap.json](/configuring-npm/npm-shrinkwrap-json) allows publication, and defines the dependency tree from the point encountered.
+This is not recommended unless deploying a CLI tool or otherwise using the publication process for producing production packages.
+
+If both `package-lock.json` and `npm-shrinkwrap.json` are present in the root of a project, `npm-shrinkwrap.json` will take precedence and `package-lock.json` will be ignored.
+
+### Hidden Lockfiles
+
+In order to avoid processing the `node_modules` folder repeatedly, npm as of v7 uses a "hidden" lockfile present in `node_modules/.package-lock.json`.
+This contains information about the tree, and is used in lieu of reading the entire `node_modules` hierarchy provided that the following conditions are met:
+
+- All package folders it references exist in the `node_modules` hierarchy.
+- No package folders exist in the `node_modules` hierarchy that are not listed in the lockfile.
+- The modified time of the file is at least as recent as all of the package folders it references.
+
+That is, the hidden lockfile will only be relevant if it was created as part of the most recent update to the package tree.
+If another CLI mutates the tree in any way, this will be detected, and the hidden lockfile will be ignored.
+
+Note that it _is_ possible to manually change the _contents_ of a package in such a way that the modified time of the package folder is unaffected.
+For example, if you add a file to `node_modules/foo/lib/bar.js`, then the modified time on `node_modules/foo` will not reflect this change.
+If you are manually editing files in `node_modules`, it is generally best to delete the file at `node_modules/.package-lock.json`.
+
+As the hidden lockfile is ignored by older npm versions, it does not contain the backwards compatibility affordances present in "normal" lockfiles.
+That is, it is `lockfileVersion: 3`, rather than `lockfileVersion: 2`.
+
+### Handling Old Lockfiles
+
+When npm detects a lockfile from npm v6 or before during the package installation process, it is automatically updated to fetch missing information from either the `node_modules` tree or (in the case of empty `node_modules` trees or very old lockfile formats) the npm registry.
+
+### File Format
+
+#### `name`
+
+The name of the package this is a package-lock for.
+This will match what's in `package.json`.
+
+#### `version`
+
+The version of the package this is a package-lock for.
+This will match what's in `package.json`.
+
+#### `lockfileVersion`
+
+An integer version, starting at `1` with the version number of this document whose semantics were used when generating this `package-lock.json`.
+
+Note that the file format changed significantly in npm v7 to track information that would have otherwise required looking in `node_modules` or the npm registry.
+Lockfiles generated by npm v7 will contain `lockfileVersion: 2`.
+
+* No version provided: an "ancient" shrinkwrap file from a version of npm prior to npm v5.
+* `1`: The lockfile version used by npm v5 and v6.
+* `2`: The lockfile version used by npm v7 and v8. Backwards compatible to v1 lockfiles.
+* `3`: The lockfile version used by npm v9 and above.
+  Backwards compatible to npm v7.
+
+npm will always attempt to get whatever data it can out of a lockfile, even if it is not a version that it was designed to support.
+
+#### `packages`
+
+This is an object that maps package locations to an object containing the information about that package.
+
+The root project is typically listed with a key of `""`, and all other packages are listed with their relative paths from the root project folder.
+
+Package descriptors have the following fields:
+
+* version: The version found in `package.json`
+
+* resolved: The place where the package was actually resolved from.
+  In the case of packages fetched from the registry, this will be a url to a tarball.
+  In the case of git dependencies, this will be the full git url with commit sha.
+  In the case of link dependencies, this will be the location of the link target.
+  `registry.npmjs.org` is a magic value meaning "the currently configured registry".
+
+* integrity: A `sha512` or `sha1` [Standard Subresource Integrity](https://w3c.github.io/webappsec/specs/subresourceintegrity/) string for the artifact that was unpacked in this location.
+
+* link: A flag to indicate that this is a symbolic link.
+  If this is present, no other fields are specified, since the link target will also be included in the lockfile.
+
+* dev, optional, devOptional: If the package is strictly part of the
+  `devDependencies` tree, then `dev` will be true.
+  If it is strictly part of the `optionalDependencies` tree, then `optional` will be set.
+  If it is both a `dev` dependency _and_ an `optional` dependency of a non-dev dependency, then `devOptional` will be set.
+  (An `optional` dependency of a `dev` dependency will have both `dev` and `optional` set.)
+
+* inBundle: A flag to indicate that the package is a bundled dependency.
+
+* hasInstallScript: A flag to indicate that the package has a `preinstall`, `install`, or `postinstall` script.
+
+* hasShrinkwrap: A flag to indicate that the package has an `npm-shrinkwrap.json` file.
+
+* bin, license, engines, dependencies, optionalDependencies: fields from `package.json`
+
+* os: An array of operating systems this package is compatible with, as specified in `package.json`. This field is included when the package specifies OS restrictions.
+
+* cpu: An array of CPU architectures this package is compatible with, as specified in `package.json`. This field is included when the package specifies CPU restrictions.
+
+* funding: Funding information for the package, as specified in `package.json`. This field contains details about how to support the package maintainers.
+
+#### dependencies
+
+Legacy data for supporting versions of npm that use `lockfileVersion: 1`.
+This is a mapping of package names to dependency objects.
+Because the object structure is strictly hierarchical, symbolic link dependencies are somewhat challenging to represent in some cases.
+
+npm v7 ignores this section entirely if a `packages` section is present, but does keep it up to date in order to support switching between npm v6 and npm v7.
+
+Dependency objects have the following fields:
+
+* version: a specifier that varies depending on the nature of the package, and is usable in fetching a new copy of it.
+  Note that for peer dependencies that are not installed, or optional dependencies that are not installed, this field may be omitted.
+
+    * bundled dependencies: Regardless of source, this is a version number that is purely for informational purposes.
+    * registry sources: This is a version number.
+      (eg, `1.2.3`)
+    * git sources: This is a git specifier with resolved committish.
+      (eg, `git+https://example.com/foo/bar#115311855adb0789a0466714ed48a1499ffea97e`)
+    * http tarball sources: This is the URL of the tarball.
+      (eg, `https://example.com/example-1.3.0.tgz`)
+    * local tarball sources: This is the file URL of the tarball.
+      (eg `file:///opt/storage/example-1.3.0.tgz`)
+    * local link sources: This is the file URL of the link.
+      (eg `file:libs/our-module`)
+
+    **Note:** The `version` field may be omitted for certain types of dependencies, such as optional peer dependencies that are not installed. In these cases, only metadata fields like `dev`, `optional`, and `peer` will be present.
+
+* integrity: A `sha512` or `sha1` [Standard Subresource Integrity](https://w3c.github.io/webappsec/specs/subresourceintegrity/) string for the artifact that was unpacked in this location.
+  For git dependencies, this is the commit sha.
+
+* resolved: For registry sources this is path of the tarball relative to the registry URL.
+  If the tarball URL isn't on the same server as the registry URL then this is a complete URL.
+  `registry.npmjs.org` is a magic value meaning "the currently configured registry".
+
+* bundled:  If true, this is the bundled dependency and will be installed by the parent module.
+  When installing, this module will be extracted from the parent module during the extract phase, not installed as a separate dependency.
+
+* dev: If true then this dependency is either a development dependency ONLY of the top level module or a transitive dependency of one.
+  This is false for dependencies that are both a development dependency of the top level and a transitive dependency of a non-development dependency of the top level.
+
+* optional: If true then this dependency is either an optional dependency ONLY of the top level module or a transitive dependency of one.
+  This is false for dependencies that are both an optional dependency of the top level and a transitive dependency of a non-optional dependency of the top level.
+
+* requires: This is a mapping of module name to version.
+  This is a list of everything this module requires, regardless of where it will be installed.
+  The version should match via normal matching rules a dependency either in our `dependencies` or in a level higher than us.
+
+* dependencies: The dependencies of this dependency, exactly as at the top level.
+
+### See also
+
+* [npm shrinkwrap](/commands/npm-shrinkwrap)
+* [npm-shrinkwrap.json](/configuring-npm/npm-shrinkwrap-json)
+* [package.json](/configuring-npm/package-json)
+* [npm install](/commands/npm-install)
diff --git a/node/node_modules/npm/docs/content/using-npm/config.md b/node/node_modules/npm/docs/content/using-npm/config.md
new file mode 100644
index 0000000000000000000000000000000000000000..bd344abde39ce01f68c40174e23877c25d6a8849
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/config.md
@@ -0,0 +1,2209 @@
+---
+title: Config
+section: 7
+description: About npm configuration
+---
+
+### Description
+
+This article details npm configuration in general.
+To learn about the `config` command, see [`npm config`](/commands/npm-config).
+
+npm gets its configuration values from the following sources, sorted by priority:
+
+#### Command Line Flags
+
+Putting `--foo bar` on the command line sets the `foo` configuration parameter to `"bar"`.
+A `--` argument tells the cli parser to stop reading flags.
+Using `--flag` without specifying any value will set the value to `true`.
+
+Example: `--flag1 --flag2` will set both configuration parameters to `true`, while `--flag1 --flag2 bar` will set `flag1` to `true`, and `flag2` to `bar`.
+Finally, `--flag1 --flag2 -- bar` will set both configuration parameters to `true`, and the `bar` is taken as a command argument.
+
+**Common examples:**
+
+* `npm install --prefix /path/to/dir` - Runs npm commands in a different directory without changing the current working directory
+* `npm install --global` - Installs packages globally (shorthand: `-g`)
+* `npm install --save-dev` - Saves to devDependencies (shorthand: `-D`)
+
+Any configuration option documented in the [Config Settings](#config-settings) section below can be set via command line flags using `--option-name value` syntax.
+
+#### Environment Variables
+
+Any environment variables that start with `npm_config_` will be interpreted as a configuration parameter.
+For example, putting `npm_config_foo=bar` in your environment will set the `foo` configuration parameter to `bar`.
+Any environment configurations that are not given a value will be given the value of `true`.
+Config values are case-insensitive, so `NPM_CONFIG_FOO=bar` will work the same.
+However, please note that inside [`scripts`](/using-npm/scripts) npm will set its own environment variables and Node will prefer those lowercase versions over any uppercase ones that you might set.
+For details see [this issue](https://github.com/npm/npm/issues/14528).
+
+Notice that you need to use underscores instead of dashes, so `--allow-same-version` would become `npm_config_allow_same_version=true`.
+
+**Important:** When defining custom configuration keys in `.npmrc` files, use hyphens instead of underscores (e.g., `custom-key=value`). This ensures they can be overridden by environment variables, since npm automatically converts underscores to hyphens when reading environment variables. Keys with underscores in `.npmrc` files cannot be overridden via environment variables.
+
+#### npmrc Files
+
+The four relevant files are:
+
+* per-project configuration file (`/path/to/my/project/.npmrc`)
+* per-user configuration file (defaults to `$HOME/.npmrc`; configurable via CLI option `--userconfig` or environment variable `$NPM_CONFIG_USERCONFIG`)
+* global configuration file (defaults to `$PREFIX/etc/npmrc`; configurable via CLI option `--globalconfig` or environment variable `$NPM_CONFIG_GLOBALCONFIG`)
+* npm's built-in configuration file (`/path/to/npm/npmrc`)
+
+See [npmrc](/configuring-npm/npmrc) for more details.
+
+#### Default Configs
+
+Run `npm config ls -l` to see a set of configuration parameters that are internal to npm, and are defaults if nothing else is specified.
+
+### Shorthands and Other CLI Niceties
+
+The following shorthands are parsed on the command-line:
+
+* `-a`: `--all`
+* `--enjoy-by`: `--before`
+* `-c`: `--call`
+* `--desc`: `--description`
+* `-f`: `--force`
+* `-g`: `--global`
+* `--iwr`: `--include-workspace-root`
+* `-L`: `--location`
+* `-d`: `--loglevel info`
+* `-s`: `--loglevel silent`
+* `--silent`: `--loglevel silent`
+* `--ddd`: `--loglevel silly`
+* `--dd`: `--loglevel verbose`
+* `--verbose`: `--loglevel verbose`
+* `-q`: `--loglevel warn`
+* `--quiet`: `--loglevel warn`
+* `-l`: `--long`
+* `-m`: `--message`
+* `--local`: `--no-global`
+* `-n`: `--no-yes`
+* `--no`: `--no-yes`
+* `-p`: `--parseable`
+* `--porcelain`: `--parseable`
+* `-C`: `--prefix`
+* `--readonly`: `--read-only`
+* `--reg`: `--registry`
+* `-S`: `--save`
+* `-B`: `--save-bundle`
+* `-D`: `--save-dev`
+* `-E`: `--save-exact`
+* `-O`: `--save-optional`
+* `-P`: `--save-prod`
+* `-?`: `--usage`
+* `-h`: `--usage`
+* `-H`: `--usage`
+* `--help`: `--usage`
+* `-v`: `--version`
+* `-w`: `--workspace`
+* `--ws`: `--workspaces`
+* `-y`: `--yes`
+
+If the specified configuration param resolves unambiguously to a known configuration parameter, then it is expanded to that configuration parameter.
+For example:
+
+```bash
+npm ls --par
+# same as:
+npm ls --parseable
+```
+
+If multiple single-character shorthands are strung together, and the resulting combination is unambiguously not some other configuration param, then it is expanded to its various component pieces.
+For example:
+
+```bash
+npm ls -gpld
+# same as:
+npm ls --global --parseable --long --loglevel info
+```
+
+### Config Settings
+
+#### `_auth`
+
+* Default: null
+* Type: null or String
+
+A basic-auth string to use when authenticating against the npm registry.
+This will ONLY be used to authenticate against the npm registry. For other
+registries you will need to scope it like "//other-registry.tld/:_auth"
+
+Warning: This should generally not be set via a command-line option. It is
+safer to use a registry-provided authentication bearer token stored in the
+~/.npmrc file by running `npm login`.
+
+
+
+#### `access`
+
+* Default: 'public' for new packages, existing packages it will not change the
+  current level
+* Type: null, "restricted", or "public"
+
+If you do not want your scoped package to be publicly viewable (and
+installable) set `--access=restricted`.
+
+Unscoped packages cannot be set to `restricted`.
+
+Note: This defaults to not changing the current access level for existing
+packages. Specifying a value of `restricted` or `public` during publish will
+change the access for an existing package the same way that `npm access set
+status` would.
+
+
+
+#### `all`
+
+* Default: false
+* Type: Boolean
+
+When running `npm outdated` and `npm ls`, setting `--all` will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.
+
+
+
+#### `allow-git`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.
+
+`all` allows any git dependencies to be fetched and installed. `none`
+prevents any git dependencies from being fetched and installed. `root` only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-same-version`
+
+* Default: false
+* Type: Boolean
+
+Prevents throwing an error when `npm version` is used to set the new version
+to the same value as the current version.
+
+
+
+#### `audit`
+
+* Default: true
+* Type: Boolean
+
+When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for [`npm audit`](/commands/npm-audit) for details on what is
+submitted.
+
+
+
+#### `audit-level`
+
+* Default: null
+* Type: null, "info", "low", "moderate", "high", "critical", or "none"
+
+The minimum level of vulnerability for `npm audit` to exit with a non-zero
+exit code.
+
+
+
+#### `auth-type`
+
+* Default: "web"
+* Type: "legacy" or "web"
+
+What authentication strategy to use with `login`. Note that if an `otp`
+config is given, this value will always be set to `legacy`.
+
+
+
+#### `before`
+
+* Default: null
+* Type: null or Date
+
+If passed to `npm install`, will rebuild the npm tree such that only
+versions that were available **on or before** the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.
+
+If the requested version is a `dist-tag` and the given tag does not pass the
+`--before` filter, the most recent version less than or equal to that tag
+will be used. For example, `foo@latest` might install `foo@1.2` even though
+`latest` is `2.0`.
+
+This config cannot be used with: `min-release-age`
+
+#### `bin-links`
+
+* Default: true
+* Type: Boolean
+
+Tells npm to create symlinks (or `.cmd` shims on Windows) for package
+executables.
+
+Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.
+
+
+
+#### `browser`
+
+* Default: macOS: `"open"`, Windows: `"start"`, Others: `"xdg-open"`
+* Type: null, Boolean, or String
+
+The browser that is called by npm commands to open websites.
+
+Set to `false` to suppress browser behavior and instead print urls to
+terminal.
+
+Set to `true` to use default system URL opener.
+
+
+
+#### `bypass-2fa`
+
+* Default: false
+* Type: Boolean
+
+When creating a Granular Access Token with `npm token create`, setting this
+to true will allow the token to bypass two-factor authentication. This is
+useful for automation and CI/CD workflows.
+
+
+
+#### `ca`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+The Certificate Authority signing certificate that is trusted for SSL
+connections to the registry. Values should be in PEM format (Windows calls
+it "Base-64 encoded X.509 (.CER)") with newlines replaced by the string
+"\n". For example:
+
+```ini
+ca="-----BEGIN CERTIFICATE-----\nXXXX\nXXXX\n-----END CERTIFICATE-----"
+```
+
+Set to `null` to only allow "known" registrars, or to a specific CA cert to
+trust only that specific signing authority.
+
+Multiple CAs can be trusted by specifying an array of certificates:
+
+```ini
+ca[]="..."
+ca[]="..."
+```
+
+See also the `strict-ssl` config.
+
+
+
+#### `cache`
+
+* Default: Windows: `%LocalAppData%\npm-cache`, Posix: `~/.npm`
+* Type: Path
+
+The location of npm's cache directory.
+
+
+
+#### `cafile`
+
+* Default: null
+* Type: Path
+
+A path to a file containing one or multiple Certificate Authority signing
+certificates. Similar to the `ca` setting, but allows for multiple CA's, as
+well as for the CA information to be stored in a file on disk.
+
+
+
+#### `call`
+
+* Default: ""
+* Type: String
+
+Optional companion option for `npm exec`, `npx` that allows for specifying a
+custom command to be run along with the installed packages.
+
+```bash
+npm exec --package yo --package generator-node --call "yo node"
+```
+
+
+
+#### `cidr`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+This is a list of CIDR address to be used when configuring limited access
+tokens with the `npm token create` command.
+
+
+
+#### `color`
+
+* Default: true unless the NO_COLOR environ is set to something other than '0'
+* Type: "always" or Boolean
+
+If false, never shows colors. If `"always"` then always shows colors. If
+true, then only prints color codes for tty file descriptors.
+
+
+
+#### `commit-hooks`
+
+* Default: true
+* Type: Boolean
+
+Run git commit hooks when using the `npm version` command.
+
+
+
+#### `cpu`
+
+* Default: null
+* Type: null or String
+
+Override CPU architecture of native modules to install. Acceptable values
+are same as `cpu` field of package.json, which comes from `process.arch`.
+
+
+
+#### `depth`
+
+* Default: `Infinity` if `--all` is set; otherwise, `0`
+* Type: null or Number
+
+The depth to go when recursing packages for `npm ls`.
+
+If not set, `npm ls` will show only the immediate dependencies of the root
+project. If `--all` is set, then npm will show all dependencies by default.
+
+
+
+#### `description`
+
+* Default: true
+* Type: Boolean
+
+Show the description in `npm search`
+
+
+
+#### `diff`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Define arguments to compare in `npm diff`.
+
+
+
+#### `diff-dst-prefix`
+
+* Default: "b/"
+* Type: String
+
+Destination prefix to be used in `npm diff` output.
+
+
+
+#### `diff-ignore-all-space`
+
+* Default: false
+* Type: Boolean
+
+Ignore whitespace when comparing lines in `npm diff`.
+
+
+
+#### `diff-name-only`
+
+* Default: false
+* Type: Boolean
+
+Prints only filenames when using `npm diff`.
+
+
+
+#### `diff-no-prefix`
+
+* Default: false
+* Type: Boolean
+
+Do not show any source or destination prefix in `npm diff` output.
+
+Note: this causes `npm diff` to ignore the `--diff-src-prefix` and
+`--diff-dst-prefix` configs.
+
+
+
+#### `diff-src-prefix`
+
+* Default: "a/"
+* Type: String
+
+Source prefix to be used in `npm diff` output.
+
+
+
+#### `diff-text`
+
+* Default: false
+* Type: Boolean
+
+Treat all files as text in `npm diff`.
+
+
+
+#### `diff-unified`
+
+* Default: 3
+* Type: Number
+
+The number of lines of context to print in `npm diff`.
+
+
+
+#### `dry-run`
+
+* Default: false
+* Type: Boolean
+
+Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, `install`, `update`,
+`dedupe`, `uninstall`, as well as `pack` and `publish`.
+
+Note: This is NOT honored by other network related commands, eg `dist-tags`,
+`owner`, etc.
+
+
+
+#### `editor`
+
+* Default: The EDITOR or VISUAL environment variables, or
+  '%SYSTEMROOT%\notepad.exe' on Windows, or 'vi' on Unix systems
+* Type: String
+
+The command to run for `npm edit` and `npm config edit`.
+
+
+
+#### `engine-strict`
+
+* Default: false
+* Type: Boolean
+
+If set to true, then npm will stubbornly refuse to install (or even consider
+installing) any package that claims to not be compatible with the current
+Node.js version.
+
+This can be overridden by setting the `--force` flag.
+
+
+
+#### `expect-result-count`
+
+* Default: null
+* Type: null or Number
+
+Tells to expect a specific number of results from the command.
+
+This config cannot be used with: `expect-results`
+
+#### `expect-results`
+
+* Default: null
+* Type: null or Boolean
+
+Tells npm whether or not to expect results from the command. Can be either
+true (expect some results) or false (expect no results).
+
+This config cannot be used with: `expect-result-count`
+
+#### `expires`
+
+* Default: null
+* Type: null or Number
+
+When creating a Granular Access Token with `npm token create`, this sets the
+expiration in days. If not specified, the server will determine the default
+expiration.
+
+
+
+#### `fetch-retries`
+
+* Default: 2
+* Type: Number
+
+The "retries" config for the `retry` module to use when fetching packages
+from the registry.
+
+npm will retry idempotent read requests to the registry in the case of
+network failures or 5xx HTTP errors.
+
+
+
+#### `fetch-retry-factor`
+
+* Default: 10
+* Type: Number
+
+The "factor" config for the `retry` module to use when fetching packages.
+
+
+
+#### `fetch-retry-maxtimeout`
+
+* Default: 60000 (1 minute)
+* Type: Number
+
+The "maxTimeout" config for the `retry` module to use when fetching
+packages.
+
+
+
+#### `fetch-retry-mintimeout`
+
+* Default: 10000 (10 seconds)
+* Type: Number
+
+The "minTimeout" config for the `retry` module to use when fetching
+packages.
+
+
+
+#### `fetch-timeout`
+
+* Default: 300000 (5 minutes)
+* Type: Number
+
+The maximum amount of time to wait for HTTP requests to complete.
+
+
+
+#### `force`
+
+* Default: false
+* Type: Boolean
+
+Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.
+
+* Allow clobbering non-npm files in global installs.
+* Allow the `npm version` command to work on an unclean git repository.
+* Allow deleting the cache folder with `npm cache clean`.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of npm.
+* Allow installing packages that have an `engines` declaration requiring a
+  different version of `node`, even if `--engine-strict` is enabled.
+* Allow `npm audit fix` to install modules outside your stated dependency
+  range (including SemVer-major changes).
+* Allow unpublishing all versions of a published package.
+* Allow conflicting peerDependencies to be installed in the root project.
+* Implicitly set `--yes` during `npm init`.
+* Allow clobbering existing values in `npm pkg`
+* Allow unpublishing of entire packages (not just a single version).
+
+If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!
+
+
+
+#### `foreground-scripts`
+
+* Default: `false` unless when using `npm pack` or `npm publish` where it
+  defaults to `true`
+* Type: Boolean
+
+Run all build scripts (ie, `preinstall`, `install`, and `postinstall`)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.
+
+Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.
+
+
+
+#### `format-package-lock`
+
+* Default: true
+* Type: Boolean
+
+Format `package-lock.json` or `npm-shrinkwrap.json` as a human readable
+file.
+
+
+
+#### `fund`
+
+* Default: true
+* Type: Boolean
+
+When "true" displays the message at the end of each `npm install`
+acknowledging the number of dependencies looking for funding. See [`npm
+fund`](/commands/npm-fund) for details.
+
+
+
+#### `git`
+
+* Default: "git"
+* Type: String
+
+The command to use for git commands. If git is installed on the computer,
+but is not in the `PATH`, then set this to the full path to the git binary.
+
+
+
+#### `git-tag-version`
+
+* Default: true
+* Type: Boolean
+
+Tag the commit when using the `npm version` command. Setting this to false
+results in no commit being made at all.
+
+
+
+#### `global`
+
+* Default: false
+* Type: Boolean
+
+Operates in "global" mode, so that packages are installed into the `prefix`
+folder instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `globalconfig`
+
+* Default: The global --prefix setting plus 'etc/npmrc'. For example,
+  '/usr/local/etc/npmrc'
+* Type: Path
+
+The config file to read for global config options.
+
+
+
+#### `heading`
+
+* Default: "npm"
+* Type: String
+
+The string that starts all the debugging log output.
+
+
+
+#### `https-proxy`
+
+* Default: null
+* Type: null or URL
+
+A proxy to use for outgoing https requests. If the `HTTPS_PROXY` or
+`https_proxy` or `HTTP_PROXY` or `http_proxy` environment variables are set,
+proxy settings will be honored by the underlying `make-fetch-happen`
+library.
+
+
+
+#### `if-present`
+
+* Default: false
+* Type: Boolean
+
+If true, npm will not exit with an error code when `run` is invoked for a
+script that isn't defined in the `scripts` section of `package.json`. This
+option can be used when it's desirable to optionally run a script when it's
+present and fail if the script fails. This is useful, for example, when
+running scripts that may only apply for some builds in an otherwise generic
+CI setup.
+
+This value is not exported to the environment for child processes.
+
+#### `ignore-scripts`
+
+* Default: false
+* Type: Boolean
+
+If true, npm does not run scripts specified in package.json files.
+
+Note that commands explicitly intended to run a particular script, such as
+`npm start`, `npm stop`, `npm restart`, `npm test`, and `npm run` will still
+run their intended script if `ignore-scripts` is set, but they will *not*
+run any pre- or post-scripts.
+
+
+
+#### `include`
+
+* Default:
+* Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+
+Option that allows for defining which types of dependencies to install.
+
+This is the inverse of `--omit=<type>`.
+
+Dependency types specified in `--include` will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.
+
+
+
+#### `include-attestations`
+
+* Default: false
+* Type: Boolean
+
+When used with `npm audit signatures --json`, includes the full sigstore
+attestation bundles in the JSON output for each verified package. The
+bundles contain DSSE envelopes, verification material, and transparency log
+entries.
+
+
+
+#### `include-staged`
+
+* Default: false
+* Type: Boolean
+
+Allow installing "staged" published packages, as defined by [npm RFC PR
+#92](https://github.com/npm/rfcs/pull/92).
+
+This is experimental, and not implemented by the npm public registry.
+
+
+
+#### `include-workspace-root`
+
+* Default: false
+* Type: Boolean
+
+Include the workspace root when workspaces are enabled for a command.
+
+When false, specifying individual workspaces via the `workspace` config, or
+all workspaces via the `workspaces` flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.
+
+This value is not exported to the environment for child processes.
+
+#### `init-author-email`
+
+* Default: ""
+* Type: String
+
+The value `npm init` should use by default for the package author's email.
+
+
+
+#### `init-author-name`
+
+* Default: ""
+* Type: String
+
+The value `npm init` should use by default for the package author's name.
+
+
+
+#### `init-author-url`
+
+* Default: ""
+* Type: "" or URL
+
+The value `npm init` should use by default for the package author's
+homepage.
+
+
+
+#### `init-license`
+
+* Default: "ISC"
+* Type: String
+
+The value `npm init` should use by default for the package license.
+
+
+
+#### `init-module`
+
+* Default: "~/.npm-init.js"
+* Type: Path
+
+A module that will be loaded by the `npm init` command. See the
+documentation for the
+[init-package-json](https://github.com/npm/init-package-json) module for
+more information, or [npm init](/commands/npm-init).
+
+
+
+#### `init-private`
+
+* Default: false
+* Type: Boolean
+
+The value `npm init` should use by default for the package's private flag.
+
+
+
+#### `init-type`
+
+* Default: "commonjs"
+* Type: String
+
+The value that `npm init` should use by default for the package.json type
+field.
+
+
+
+#### `init-version`
+
+* Default: "1.0.0"
+* Type: SemVer string
+
+The value that `npm init` should use by default for the package version
+number, if not already set in package.json.
+
+
+
+#### `install-links`
+
+* Default: false
+* Type: Boolean
+
+When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.
+
+
+
+#### `install-strategy`
+
+* Default: "hoisted"
+* Type: "hoisted", "nested", "shallow", or "linked"
+
+Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.
+
+
+
+#### `json`
+
+* Default: false
+* Type: Boolean
+
+Whether or not to output JSON data, rather than the normal output.
+
+* In `npm pkg set` it enables parsing set values with JSON.parse() before
+  saving them to your `package.json`.
+
+Not supported by all npm commands.
+
+
+
+#### `legacy-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+Causes npm to completely ignore `peerDependencies` when building a package
+tree, as in npm versions 3 through 6.
+
+If a package cannot be installed because of overly strict `peerDependencies`
+that collide, it provides a way to move forward resolving the situation.
+
+This differs from `--omit=peer`, in that `--omit=peer` will avoid unpacking
+`peerDependencies` on disk, but will still design a tree such that
+`peerDependencies` _could_ be unpacked in a correct place.
+
+Use of `legacy-peer-deps` is not recommended, as it will not enforce the
+`peerDependencies` contract that meta-dependencies may rely on.
+
+
+
+#### `libc`
+
+* Default: null
+* Type: null or String
+
+Override libc of native modules to install. Acceptable values are same as
+`libc` field of package.json
+
+
+
+#### `link`
+
+* Default: false
+* Type: Boolean
+
+Used with `npm ls`, limiting output to only those packages that are linked.
+
+
+
+#### `local-address`
+
+* Default: null
+* Type: IP Address
+
+The IP address of the local interface to use when making connections to the
+npm registry. Must be IPv4 in versions of Node prior to 0.12.
+
+
+
+#### `location`
+
+* Default: "user" unless `--global` is passed, which will also set this value
+  to "global"
+* Type: "global", "user", or "project"
+
+When passed to `npm config` this refers to which config file to use.
+
+When set to "global" mode, packages are installed into the `prefix` folder
+instead of the current working directory. See
+[folders](/configuring-npm/folders) for more on the differences in behavior.
+
+* packages are installed into the `{prefix}/lib/node_modules` folder, instead
+  of the current working directory.
+* bin files are linked to `{prefix}/bin`
+* man pages are linked to `{prefix}/share/man`
+
+
+
+#### `lockfile-version`
+
+* Default: Version 3 if no lockfile, auto-converting v1 lockfiles to v3;
+  otherwise, maintain current lockfile version.
+* Type: null, 1, 2, 3, "1", "2", or "3"
+
+Set the lockfile format version to be used in package-lock.json and
+npm-shrinkwrap-json files. Possible options are:
+
+1: The lockfile version used by npm versions 5 and 6. Lacks some data that
+is used during the install, resulting in slower and possibly less
+deterministic installs. Prevents lockfile churn when interoperating with
+older npm versions.
+
+2: The default lockfile version used by npm version 7 and 8. Includes both
+the version 1 lockfile data and version 3 lockfile data, for maximum
+determinism and interoperability, at the expense of more bytes on disk.
+
+3: Only the new lockfile information introduced in npm version 7. Smaller on
+disk than lockfile version 2, but not interoperable with older npm versions.
+Ideal if all users are on npm version 7 and higher.
+
+
+
+#### `loglevel`
+
+* Default: "notice"
+* Type: "silent", "error", "warn", "notice", "http", "info", "verbose", or
+  "silly"
+
+What level of logs to report. All logs are written to a debug log, with the
+path to that file printed if the execution of a command fails.
+
+Any logs of a higher level than the setting are shown. The default is
+"notice".
+
+See also the `foreground-scripts` config.
+
+
+
+#### `logs-dir`
+
+* Default: A directory named `_logs` inside the cache
+* Type: null or Path
+
+The location of npm's log directory. See [`npm logging`](/using-npm/logging)
+for more information.
+
+
+
+#### `logs-max`
+
+* Default: 10
+* Type: Number
+
+The maximum number of log files to store.
+
+If set to 0, no log files will be written for the current run.
+
+
+
+#### `long`
+
+* Default: false
+* Type: Boolean
+
+Show extended information in `ls`, `search`, and `help-search`.
+
+
+
+#### `maxsockets`
+
+* Default: 15
+* Type: Number
+
+The maximum number of connections to use per origin (protocol/host/port
+combination).
+
+
+
+#### `message`
+
+* Default: "%s"
+* Type: String
+
+Commit message which is used by `npm version` when creating version commit.
+
+Any "%s" in the message will be replaced with the version number.
+
+
+
+#### `min-release-age`
+
+* Default: null
+* Type: null or Number
+
+If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.
+
+This flag is a complement to `before`, which accepts an exact date instead
+of a relative number of days.
+
+This config cannot be used with: `before`
+
+This value is not exported to the environment for child processes.
+
+#### `name`
+
+* Default: null
+* Type: null or String
+
+When creating a Granular Access Token with `npm token create`, this sets the
+name/description for the token.
+
+
+
+#### `node-gyp`
+
+* Default: The path to the node-gyp bin that ships with npm
+* Type: Path
+
+This is the location of the "node-gyp" bin. By default it uses one that
+ships with npm itself.
+
+You can use this config to specify your own "node-gyp" to run when it is
+required to build a package.
+
+
+
+#### `node-options`
+
+* Default: null
+* Type: null or String
+
+Options to pass through to Node.js via the `NODE_OPTIONS` environment
+variable. This does not impact how npm itself is executed but it does impact
+how lifecycle scripts are called.
+
+
+
+#### `noproxy`
+
+* Default: The value of the NO_PROXY environment variable
+* Type: String (can be set multiple times)
+
+Domain extensions that should bypass any proxies.
+
+Also accepts a comma-delimited string.
+
+
+
+#### `offline`
+
+* Default: false
+* Type: Boolean
+
+Force offline mode: no network requests will be done during install. To
+allow the CLI to fill in missing cache data, see `--prefer-offline`.
+
+
+
+#### `omit`
+
+* Default: 'dev' if the `NODE_ENV` environment variable is set to
+  'production'; otherwise, empty.
+* Type: "dev", "optional", or "peer" (can be set multiple times)
+
+Dependency types to omit from the installation tree on disk.
+
+Note that these dependencies _are_ still resolved and added to the
+`package-lock.json` or `npm-shrinkwrap.json` file. They are just not
+physically installed on disk.
+
+If a package type appears in both the `--include` and `--omit` lists, then
+it will be included.
+
+If the resulting omit list includes `'dev'`, then the `NODE_ENV` environment
+variable will be set to `'production'` for all lifecycle scripts.
+
+
+
+#### `omit-lockfile-registry-resolved`
+
+* Default: false
+* Type: Boolean
+
+This option causes npm to create lock files without a `resolved` key for
+registry dependencies. Subsequent installs will need to resolve tarball
+endpoints with the configured registry, likely resulting in a longer install
+time.
+
+
+
+#### `orgs`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+When creating a Granular Access Token with `npm token create`, this limits
+the token access to specific organizations.
+
+
+
+#### `orgs-permission`
+
+* Default: null
+* Type: null, "read-only", "read-write", or "no-access"
+
+When creating a Granular Access Token with `npm token create`, sets the
+permission level for organizations. Options are "read-only", "read-write",
+or "no-access".
+
+
+
+#### `os`
+
+* Default: null
+* Type: null or String
+
+Override OS of native modules to install. Acceptable values are same as `os`
+field of package.json, which comes from `process.platform`.
+
+
+
+#### `otp`
+
+* Default: null
+* Type: null or String
+
+This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with `npm access`.
+
+If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.
+
+
+
+#### `pack-destination`
+
+* Default: "."
+* Type: String
+
+Directory in which `npm pack` will save tarballs.
+
+
+
+#### `package`
+
+* Default:
+* Type: String (can be set multiple times)
+
+The package or packages to install for [`npm exec`](/commands/npm-exec)
+
+
+
+#### `package-lock`
+
+* Default: true
+* Type: Boolean
+
+If set to false, then ignore `package-lock.json` files when installing. This
+will also prevent _writing_ `package-lock.json` if `save` is true.
+
+
+
+#### `package-lock-only`
+
+* Default: false
+* Type: Boolean
+
+If set to true, the current operation will only use the `package-lock.json`,
+ignoring `node_modules`.
+
+For `update` this means only the `package-lock.json` will be updated,
+instead of checking `node_modules` and downloading dependencies.
+
+For `list` this means the output will be based on the tree described by the
+`package-lock.json`, rather than the contents of `node_modules`.
+
+
+
+#### `packages`
+
+* Default:
+* Type: null or String (can be set multiple times)
+
+When creating a Granular Access Token with `npm token create`, this limits
+the token access to specific packages.
+
+
+
+#### `packages-all`
+
+* Default: false
+* Type: Boolean
+
+When creating a Granular Access Token with `npm token create`, grants the
+token access to all packages instead of limiting to specific packages.
+
+
+
+#### `packages-and-scopes-permission`
+
+* Default: null
+* Type: null, "read-only", "read-write", or "no-access"
+
+When creating a Granular Access Token with `npm token create`, sets the
+permission level for packages and scopes. Options are "read-only",
+"read-write", or "no-access".
+
+
+
+#### `parseable`
+
+* Default: false
+* Type: Boolean
+
+Output parseable results from commands that write to standard output. For
+`npm search`, this will be tab-separated table format.
+
+
+
+#### `password`
+
+* Default: null
+* Type: null or String
+
+Password for authentication. Can be provided via command line when creating
+tokens, though it's generally safer to be prompted for it.
+
+
+
+#### `prefer-dedupe`
+
+* Default: false
+* Type: Boolean
+
+Prefer to deduplicate packages if possible, rather than choosing a newer
+version of a dependency.
+
+
+
+#### `prefer-offline`
+
+* Default: false
+* Type: Boolean
+
+If true, staleness checks for cached data will be bypassed, but missing data
+will be requested from the server. To force full offline mode, use
+`--offline`.
+
+
+
+#### `prefer-online`
+
+* Default: false
+* Type: Boolean
+
+If true, staleness checks for cached data will be forced, making the CLI
+look for updates immediately even for fresh package data.
+
+
+
+#### `prefix`
+
+* Default: In global mode, the folder where the node executable is installed.
+  Otherwise, the nearest parent folder containing either a package.json file
+  or a node_modules folder.
+* Type: Path
+
+The location to install global items. If set on the command line, then it
+forces non-global commands to run in the specified folder.
+
+
+
+#### `preid`
+
+* Default: ""
+* Type: String
+
+The "prerelease identifier" to use as a prefix for the "prerelease" part of
+a semver. Like the `rc` in `1.2.0-rc.8`.
+
+
+
+#### `progress`
+
+* Default: `true` when not in CI and both stderr and stdout are TTYs and not
+  in a dumb terminal
+* Type: Boolean
+
+When set to `true`, npm will display a progress bar during time intensive
+operations, if `process.stderr` and `process.stdout` are a TTY.
+
+Set to `false` to suppress the progress bar.
+
+
+
+#### `provenance`
+
+* Default: false
+* Type: Boolean
+
+When publishing from a supported cloud CI/CD system, the package will be
+publicly linked to where it was built and published from.
+
+This config cannot be used with: `provenance-file`
+
+#### `provenance-file`
+
+* Default: null
+* Type: Path
+
+When publishing, the provenance bundle at the given path will be used.
+
+This config cannot be used with: `provenance`
+
+#### `proxy`
+
+* Default: null
+* Type: null, false, or URL
+
+A proxy to use for outgoing http requests. If the `HTTP_PROXY` or
+`http_proxy` environment variables are set, proxy settings will be honored
+by the underlying `request` library.
+
+
+
+#### `read-only`
+
+* Default: false
+* Type: Boolean
+
+This is used to mark a token as unable to publish when configuring limited
+access tokens with the `npm token create` command.
+
+
+
+#### `rebuild-bundle`
+
+* Default: true
+* Type: Boolean
+
+Rebuild bundled dependencies after installation.
+
+
+
+#### `registry`
+
+* Default: "https://registry.npmjs.org/"
+* Type: URL
+
+The base URL of the npm registry.
+
+
+
+#### `replace-registry-host`
+
+* Default: "npmjs"
+* Type: "npmjs", "never", "always", or String
+
+Defines behavior for replacing the registry host in a lockfile with the
+configured registry.
+
+The default behavior is to replace package dist URLs from the default
+registry (https://registry.npmjs.org) to the configured registry. If set to
+"never", then use the registry value. If set to "always", then replace the
+registry host with the configured host every time.
+
+You may also specify a bare hostname (e.g., "registry.npmjs.org").
+
+
+
+#### `save`
+
+* Default: `true` unless when using `npm update` where it defaults to `false`
+* Type: Boolean
+
+Save installed packages to a `package.json` file as dependencies.
+
+When used with the `npm rm` command, removes the dependency from
+`package.json`.
+
+Will also prevent writing to `package-lock.json` if set to `false`.
+
+
+
+#### `save-bundle`
+
+* Default: false
+* Type: Boolean
+
+If a package would be saved at install time by the use of `--save`,
+`--save-dev`, or `--save-optional`, then also put it in the
+`bundleDependencies` list.
+
+Ignored if `--save-peer` is set, since peerDependencies cannot be bundled.
+
+
+
+#### `save-dev`
+
+* Default: false
+* Type: Boolean
+
+Save installed packages to a package.json file as `devDependencies`.
+
+This config cannot be used with: `save-optional`, `save-peer`, `save-prod`
+
+#### `save-exact`
+
+* Default: false
+* Type: Boolean
+
+Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.
+
+
+
+#### `save-optional`
+
+* Default: false
+* Type: Boolean
+
+Save installed packages to a package.json file as `optionalDependencies`.
+
+This config cannot be used with: `save-dev`, `save-peer`, `save-prod`
+
+#### `save-peer`
+
+* Default: false
+* Type: Boolean
+
+Save installed packages to a package.json file as `peerDependencies`
+
+This config cannot be used with: `save-dev`, `save-optional`, `save-prod`
+
+#### `save-prefix`
+
+* Default: "^"
+* Type: String
+
+Configure how versions of packages installed to a package.json file via
+`--save` or `--save-dev` get prefixed.
+
+For example if a package has version `1.2.3`, by default its version is set
+to `^1.2.3` which allows minor upgrades for that package, but after `npm
+config set save-prefix='~'` it would be set to `~1.2.3` which only allows
+patch upgrades.
+
+
+
+#### `save-prod`
+
+* Default: false
+* Type: Boolean
+
+Save installed packages into `dependencies` specifically. This is useful if
+a package already exists in `devDependencies` or `optionalDependencies`, but
+you want to move it to be a non-optional production dependency.
+
+This is the default behavior if `--save` is true, and neither `--save-dev`
+or `--save-optional` are true.
+
+This config cannot be used with: `save-dev`, `save-optional`, `save-peer`
+
+#### `sbom-format`
+
+* Default: null
+* Type: "cyclonedx" or "spdx"
+
+SBOM format to use when generating SBOMs.
+
+
+
+#### `sbom-type`
+
+* Default: "library"
+* Type: "library", "application", or "framework"
+
+The type of package described by the generated SBOM. For SPDX, this is the
+value for the `primaryPackagePurpose` field. For CycloneDX, this is the
+value for the `type` field.
+
+
+
+#### `scope`
+
+* Default: the scope of the current project, if any, or ""
+* Type: String
+
+Associate an operation with a scope for a scoped registry.
+
+Useful when logging in to or out of a private registry:
+
+```
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+```
+
+This will cause `@mycorp` to be mapped to the registry for future
+installation of packages specified according to the pattern
+`@mycorp/package`.
+
+This will also cause `npm init` to create a scoped package.
+
+```
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+```
+
+
+
+#### `scopes`
+
+* Default: null
+* Type: null or String (can be set multiple times)
+
+When creating a Granular Access Token with `npm token create`, this limits
+the token access to specific scopes. Provide a scope name (with or without @
+prefix).
+
+
+
+#### `script-shell`
+
+* Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+* Type: null or String
+
+The shell to use for scripts run with the `npm exec`, `npm run` and `npm
+init <package-spec>` commands.
+
+
+
+#### `searchexclude`
+
+* Default: ""
+* Type: String
+
+Space-separated options that limit the results from search.
+
+
+
+#### `searchlimit`
+
+* Default: 20
+* Type: Number
+
+Number of items to limit search results to. Will not apply at all to legacy
+searches.
+
+
+
+#### `searchopts`
+
+* Default: ""
+* Type: String
+
+Space-separated options that are always passed to search.
+
+
+
+#### `searchstaleness`
+
+* Default: 900
+* Type: Number
+
+The age of the cache, in seconds, before another registry request is made if
+using legacy search endpoint.
+
+
+
+#### `shell`
+
+* Default: SHELL environment variable, or "bash" on Posix, or "cmd.exe" on
+  Windows
+* Type: String
+
+The shell to run for the `npm explore` command.
+
+
+
+#### `sign-git-commit`
+
+* Default: false
+* Type: Boolean
+
+If set to true, then the `npm version` command will commit the new package
+version using `-S` to add a signature.
+
+Note that git requires you to have set up GPG keys in your git configs for
+this to work properly.
+
+
+
+#### `sign-git-tag`
+
+* Default: false
+* Type: Boolean
+
+If set to true, then the `npm version` command will tag the version using
+`-s` to add a signature.
+
+Note that git requires you to have set up GPG keys in your git configs for
+this to work properly.
+
+
+
+#### `strict-peer-deps`
+
+* Default: false
+* Type: Boolean
+
+If set to `true`, and `--legacy-peer-deps` is not set, then _any_
+conflicting `peerDependencies` will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.
+
+By default, conflicting `peerDependencies` deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's `peerDependencies` object.
+
+When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If `--strict-peer-deps` is set, then
+this warning is treated as a failure.
+
+
+
+#### `strict-ssl`
+
+* Default: true
+* Type: Boolean
+
+Whether or not to do SSL key validation when making requests to the registry
+via https.
+
+See also the `ca` config.
+
+
+
+#### `tag`
+
+* Default: "latest"
+* Type: String
+
+If you ask npm to install a package and don't tell it a specific version,
+then it will install the specified tag.
+
+It is the tag added to the package@version specified in the `npm dist-tag
+add` command, if no explicit tag is given.
+
+When used by the `npm diff` command, this is the tag used to fetch the
+tarball that will be compared with the local files by default.
+
+If used in the `npm publish` command, this is the tag that will be added to
+the package submitted to the registry.
+
+
+
+#### `tag-version-prefix`
+
+* Default: "v"
+* Type: String
+
+If set, alters the prefix used when tagging a new version when performing a
+version increment using `npm version`. To remove the prefix altogether, set
+it to the empty string: `""`.
+
+Because other tools may rely on the convention that npm version tags look
+like `v1.0.0`, _only use this property if it is absolutely necessary_. In
+particular, use care when overriding this setting for public packages.
+
+
+
+#### `timing`
+
+* Default: false
+* Type: Boolean
+
+If true, writes timing information to a process specific json file in the
+cache or `logs-dir`. The file name ends with `-timing.json`.
+
+You can quickly view it with this [json](https://npm.im/json) command line:
+`cat ~/.npm/_logs/*-timing.json | npm exec -- json -g`.
+
+Timing information will also be reported in the terminal. To suppress this
+while still writing the timing file, use `--silent`.
+
+
+
+#### `token-description`
+
+* Default: null
+* Type: null or String
+
+Description text for the token when using `npm token create`.
+
+
+
+#### `umask`
+
+* Default: 0
+* Type: Octal numeric string in range 0000..0777 (0..511)
+
+The "umask" value to use when setting the file creation mode on files and
+folders.
+
+Folders and executables are given a mode which is `0o777` masked against
+this value. Other files are given a mode which is `0o666` masked against
+this value.
+
+Note that the underlying system will _also_ apply its own umask value to
+files and folders that are created, and npm does not circumvent this, but
+rather adds the `--umask` config to it.
+
+Thus, the effective default umask value on most POSIX systems is 0o22,
+meaning that folders and executables are created with a mode of 0o755 and
+other files are created with a mode of 0o644.
+
+
+
+#### `unicode`
+
+* Default: false on windows, true on mac/unix systems with a unicode locale,
+  as defined by the `LC_ALL`, `LC_CTYPE`, or `LANG` environment variables.
+* Type: Boolean
+
+When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.
+
+
+
+#### `update-notifier`
+
+* Default: true
+* Type: Boolean
+
+Set to false to suppress the update notification when using an older version
+of npm than the latest.
+
+
+
+#### `usage`
+
+* Default: false
+* Type: Boolean
+
+Show short usage output about the command specified.
+
+
+
+#### `user-agent`
+
+* Default: "npm/{npm-version} node/{node-version} {platform} {arch}
+  workspaces/{workspaces} {ci}"
+* Type: String
+
+Sets the User-Agent request header. The following fields are replaced with
+their actual counterparts:
+
+* `{npm-version}` - The npm version in use
+* `{node-version}` - The Node.js version in use
+* `{platform}` - The value of `process.platform`
+* `{arch}` - The value of `process.arch`
+* `{workspaces}` - Set to `true` if the `workspaces` or `workspace` options
+  are set.
+* `{ci}` - The value of the `ci-name` config, if set, prefixed with `ci/`, or
+  an empty string if `ci-name` is empty.
+
+
+
+#### `userconfig`
+
+* Default: "~/.npmrc"
+* Type: Path
+
+The location of user-level configuration settings.
+
+This may be overridden by the `npm_config_userconfig` environment variable
+or the `--userconfig` command line option, but may _not_ be overridden by
+settings in the `globalconfig` file.
+
+
+
+#### `version`
+
+* Default: false
+* Type: Boolean
+
+If true, output the npm version and exit successfully.
+
+Only relevant when specified explicitly on the command line.
+
+
+
+#### `versions`
+
+* Default: false
+* Type: Boolean
+
+If true, output the npm version as well as node's `process.versions` map and
+the version in the current working directory's `package.json` file if one
+exists, and exit successfully.
+
+Only relevant when specified explicitly on the command line.
+
+
+
+#### `viewer`
+
+* Default: "man" on Posix, "browser" on Windows
+* Type: String
+
+The program to use to view help content.
+
+Set to `"browser"` to view html help content in the default web browser.
+
+
+
+#### `which`
+
+* Default: null
+* Type: null or Number
+
+If there are multiple funding sources, which 1-indexed source URL to open.
+
+
+
+#### `workspace`
+
+* Default:
+* Type: String (can be set multiple times)
+
+Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.
+
+Valid values for the `workspace` config are either:
+
+* Workspace names
+* Path to a workspace directory
+* Path to a parent workspace directory (will result in selecting all
+  workspaces within that folder)
+
+When set for the `npm init` command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces`
+
+* Default: null
+* Type: null or Boolean
+
+Set to true to run the command in the context of **all** configured
+workspaces.
+
+Explicitly setting this to false will cause commands like `install` to
+ignore workspaces altogether. When not set explicitly:
+
+- Commands that operate on the `node_modules` tree (install, update, etc.)
+will link workspaces into the `node_modules` folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+_unless_ one or more workspaces are specified in the `workspace` config.
+
+This value is not exported to the environment for child processes.
+
+#### `workspaces-update`
+
+* Default: true
+* Type: Boolean
+
+If set to true, the npm cli will run an update after operations that may
+possibly change the workspaces installed to the `node_modules` folder.
+
+
+
+#### `yes`
+
+* Default: null
+* Type: null or Boolean
+
+Automatically answer "yes" to any prompts that npm might print on the
+command line.
+
+
+
+#### `also`
+
+* Default: null
+* Type: null, "dev", or "development"
+* DEPRECATED: Please use --include=dev instead.
+
+When set to `dev` or `development`, this is an alias for `--include=dev`.
+
+
+
+#### `cache-max`
+
+* Default: Infinity
+* Type: Number
+* DEPRECATED: This option has been deprecated in favor of `--prefer-online`
+
+`--cache-max=0` is an alias for `--prefer-online`
+
+
+
+#### `cache-min`
+
+* Default: 0
+* Type: Number
+* DEPRECATED: This option has been deprecated in favor of `--prefer-offline`.
+
+`--cache-min=9999 (or bigger)` is an alias for `--prefer-offline`.
+
+
+
+#### `cert`
+
+* Default: null
+* Type: null or String
+* DEPRECATED: `key` and `cert` are no longer used for most registry
+  operations. Use registry scoped `keyfile` and `certfile` instead. Example:
+  //other-registry.tld/:keyfile=/path/to/key.pem
+  //other-registry.tld/:certfile=/path/to/cert.crt
+
+A client certificate to pass when accessing the registry. Values should be
+in PEM format (Windows calls it "Base-64 encoded X.509 (.CER)") with
+newlines replaced by the string "\n". For example:
+
+```ini
+cert="-----BEGIN CERTIFICATE-----\nXXXX\nXXXX\n-----END CERTIFICATE-----"
+```
+
+It is _not_ the path to a certificate file, though you can set a
+registry-scoped "certfile" path like
+"//other-registry.tld/:certfile=/path/to/cert.pem".
+
+
+
+#### `dev`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: Please use --include=dev instead.
+
+Alias for `--include=dev`.
+
+
+
+#### `global-style`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=shallow`
+
+Only install direct dependencies in the top level `node_modules`, but hoist
+on deeper dependencies. Sets `--install-strategy=shallow`.
+
+
+
+#### `init.author.email`
+
+* Default: ""
+* Type: String
+* DEPRECATED: Use `--init-author-email` instead.
+
+Alias for `--init-author-email`
+
+
+
+#### `init.author.name`
+
+* Default: ""
+* Type: String
+* DEPRECATED: Use `--init-author-name` instead.
+
+Alias for `--init-author-name`
+
+
+
+#### `init.author.url`
+
+* Default: ""
+* Type: "" or URL
+* DEPRECATED: Use `--init-author-url` instead.
+
+Alias for `--init-author-url`
+
+
+
+#### `init.license`
+
+* Default: "ISC"
+* Type: String
+* DEPRECATED: Use `--init-license` instead.
+
+Alias for `--init-license`
+
+
+
+#### `init.module`
+
+* Default: "~/.npm-init.js"
+* Type: Path
+* DEPRECATED: Use `--init-module` instead.
+
+Alias for `--init-module`
+
+
+
+#### `init.version`
+
+* Default: "1.0.0"
+* Type: SemVer string
+* DEPRECATED: Use `--init-version` instead.
+
+Alias for `--init-version`
+
+
+
+#### `key`
+
+* Default: null
+* Type: null or String
+* DEPRECATED: `key` and `cert` are no longer used for most registry
+  operations. Use registry scoped `keyfile` and `certfile` instead. Example:
+  //other-registry.tld/:keyfile=/path/to/key.pem
+  //other-registry.tld/:certfile=/path/to/cert.crt
+
+A client key to pass when accessing the registry. Values should be in PEM
+format with newlines replaced by the string "\n". For example:
+
+```ini
+key="-----BEGIN PRIVATE KEY-----\nXXXX\nXXXX\n-----END PRIVATE KEY-----"
+```
+
+It is _not_ the path to a key file, though you can set a registry-scoped
+"keyfile" path like "//other-registry.tld/:keyfile=/path/to/key.pem".
+
+
+
+#### `legacy-bundling`
+
+* Default: false
+* Type: Boolean
+* DEPRECATED: This option has been deprecated in favor of
+  `--install-strategy=nested`
+
+Instead of hoisting package installs in `node_modules`, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets `--install-strategy=nested`.
+
+
+
+#### `only`
+
+* Default: null
+* Type: null, "prod", or "production"
+* DEPRECATED: Use `--omit=dev` to omit dev dependencies from the install.
+
+When set to `prod` or `production`, this is an alias for `--omit=dev`.
+
+
+
+#### `optional`
+
+* Default: null
+* Type: null or Boolean
+* DEPRECATED: Use `--omit=optional` to exclude optional dependencies, or
+  `--include=optional` to include them.
+
+Default value does install optional deps unless otherwise omitted.
+
+Alias for --include=optional or --omit=optional
+
+
+
+#### `production`
+
+* Default: null
+* Type: null or Boolean
+* DEPRECATED: Use `--omit=dev` instead.
+
+Alias for `--omit=dev`
+
+
+
+#### `shrinkwrap`
+
+* Default: true
+* Type: Boolean
+* DEPRECATED: Use the --package-lock setting instead.
+
+Alias for --package-lock
+
+
+
+### See also
+
+* [npm config](/commands/npm-config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm scripts](/using-npm/scripts)
+* [npm folders](/configuring-npm/folders)
+* [npm](/commands/npm)
diff --git a/node/node_modules/npm/docs/content/using-npm/dependency-selectors.md b/node/node_modules/npm/docs/content/using-npm/dependency-selectors.md
new file mode 100644
index 0000000000000000000000000000000000000000..271f8fb4c6a1a1653b11fedb8b43f96d9e6d7487
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/dependency-selectors.md
@@ -0,0 +1,247 @@
+---
+title: Dependency Selectors
+section: 7
+description: Dependency Selector Syntax & Querying
+---
+
+### Description
+
+The [`npm query`](/commands/npm-query) command exposes a new dependency selector syntax (informed by & respecting many aspects of the [CSS Selectors 4 Spec](https://dev.w3.org/csswg/selectors4/#relational)) which:
+
+- Standardizes the shape of, & querying of, dependency graphs with a robust object model, metadata & selector syntax
+- Leverages existing, known language syntax & operators from CSS to make disparate package information broadly accessible
+- Unlocks the ability to answer complex, multi-faceted questions about dependencies, their relationships & associative metadata
+- Consolidates redundant logic of similar query commands in `npm` (ex.
+`npm fund`, `npm ls`, `npm outdated`, `npm audit` ...)
+
+### Dependency Selector Syntax
+
+#### Overview:
+
+- there is no "type" or "tag" selectors (ex.
+`div, h1, a`) as a dependency/target is the only type of `Node` that can be queried
+- the term "dependencies" is in reference to any `Node` found in a `tree` returned by `Arborist`
+
+#### Combinators
+
+- `>` direct descendant/child
+- ` ` any descendant/child
+- `~` sibling
+
+#### Selectors
+
+- `*` universal selector
+- `#<name>` dependency selector (equivalent to `[name="..."]`)
+- `#<name>@<version>` (equivalent to `[name=<name>]:semver(<version>)`)
+- `,` selector list delimiter
+- `.` dependency type selector
+- `:` pseudo selector
+
+#### Dependency Type Selectors
+
+- `.prod` dependency found in the `dependencies` section of `package.json`, or is a child of said dependency
+- `.dev` dependency found in the `devDependencies` section of `package.json`, or is a child of said dependency
+- `.optional` dependency found in the `optionalDependencies` section of `package.json`, or has `"optional": true` set in its entry in the `peerDependenciesMeta` section of `package.json`, or a child of said dependency
+- `.peer` dependency found in the `peerDependencies` section of `package.json`
+- `.workspace` dependency found in the [`workspaces`](https://docs.npmjs.com/cli/v8/using-npm/workspaces) section of `package.json`
+- `.bundled` dependency found in the `bundleDependencies` section of `package.json`, or is a child of said dependency
+
+#### Pseudo Selectors
+- [`:not(<selector>)`](https://developer.mozilla.org/en-US/docs/Web/CSS/:not)
+- [`:has(<selector>)`](https://developer.mozilla.org/en-US/docs/Web/CSS/:has)
+- [`:is(<selector list>)`](https://developer.mozilla.org/en-US/docs/Web/CSS/:is)
+- [`:root`](https://developer.mozilla.org/en-US/docs/Web/CSS/:root) matches the root node/dependency
+- [`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) matches node/dependency it was queried against
+- [`:empty`](https://developer.mozilla.org/en-US/docs/Web/CSS/:empty) when a dependency has no dependencies
+- [`:private`](https://docs.npmjs.com/cli/v8/configuring-npm/package-json#private) when a dependency is private
+- `:link` when a dependency is linked (for instance, workspaces or packages manually [`linked`](https://docs.npmjs.com/cli/v8/commands/npm-link)
+- `:deduped` when a dependency has been deduped (note that this does *not* always mean the dependency has been hoisted to the root of node_modules)
+- `:overridden` when a dependency has been overridden
+- `:extraneous` when a dependency exists but is not defined as a dependency of any node
+- `:invalid` when a dependency version is out of its ancestors specified range
+- `:missing` when a dependency is not found on disk
+- `:semver(<spec>, [selector], [function])` match a valid [`node-semver`](https://github.com/npm/node-semver) version or range to a selector
+- `:path(<path>)` [glob](https://www.npmjs.com/package/glob) matching based on dependencies path relative to the project
+- `:type(<type>)` [based on currently recognized types](https://github.com/npm/npm-package-arg#result-object).  You can also use the aggregate type of `registry` for any registry dependency (e.g. tag, version, range, alias)
+- `:outdated(<type>)` when a dependency is outdated
+- `:vuln(<selector>)` when a dependency has a known vulnerability
+
+##### `:semver(<spec>, [selector], [function])`
+
+The `:semver()` pseudo selector allows comparing fields from each node's `package.json` using [semver](https://github.com/npm/node-semver#readme) methods.
+It accepts up to 3 parameters, all but the first of which are optional.
+
+- `spec` a semver version or range
+- `selector` an attribute selector for each node (default `[version]`)
+- `function` a semver method to apply, one of: `satisfies`, `intersects`, `subset`, `gt`, `gte`, `gtr`, `lt`, `lte`, `ltr`, `eq`, `neq` or the special function `infer` (default `infer`)
+
+When the special `infer` function is used the `spec` and the actual value from the node are compared.
+If both are versions, according to `semver.valid()`, `eq` is used.
+If both values are ranges, according to `!semver.valid()`, `intersects` is used.
+If the values are mixed types `satisfies` is used.
+
+Some examples:
+
+- `:semver(^1.0.0)` returns every node that has a `version` satisfied by the provided range `^1.0.0`
+- `:semver(16.0.0, :attr(engines, [node]))` returns every node which has an `engines.node` property satisfying the version `16.0.0`
+- `:semver(1.0.0, [version], lt)` every node with a `version` less than `1.0.0`
+
+##### `:outdated(<type>)`
+
+The `:outdated` pseudo selector retrieves data from the registry and returns information about which of your dependencies are outdated.
+The type parameter may be one of the following:
+
+- `any` (default) a version exists that is greater than the current one
+- `in-range` a version exists that is greater than the current one, and satisfies at least one if its parent's dependencies
+- `out-of-range` a version exists that is greater than the current one, does not satisfy at least one of its parent's dependencies
+- `major` a version exists that is a semver major greater than the current one
+- `minor` a version exists that is a semver minor greater than the current one
+- `patch` a version exists that is a semver patch greater than the current one
+
+In addition to the filtering performed by the pseudo selector, some extra data is added to the resulting objects.
+The following data can be found under the `queryContext` property of each node.
+
+- `versions` an array of every available version of the given node
+- `outdated.inRange` an array of objects, each with a `from` and `versions`, where `from` is the on-disk location of the node that depends on the current node and `versions` is an array of all available versions that satisfies that dependency.
+This is only populated if `:outdated(in-range)` is used.
+- `outdated.outOfRange` an array of objects, identical in shape to `inRange`, but where the `versions` array is every available version that does not satisfy the dependency.
+This is only populated if `:outdated(out-of-range)` is used.
+
+Some examples:
+
+- `:root > :outdated(major)` returns every direct dependency that has a new semver major release
+- `.prod:outdated(in-range)` returns production dependencies that have a new release that satisfies at least one of its parent's dependencies
+
+##### `:vuln`
+
+The `:vuln` pseudo selector retrieves data from the registry and returns information about which if your dependencies has a known vulnerability.
+Only dependencies whose current version matches a vulnerability will be returned.
+For example if you have `semver@7.6.0` in your tree, a vulnerability for `semver` which affects versions `<=6.3.1` will not match.
+
+You can also filter results by certain attributes in advisories.
+Currently that includes `severity` and `cwe`.
+Note that severity filtering is done per severity, it does not include severities "higher" or "lower" than the one specified.
+
+In addition to the filtering performed by the pseudo selector, info about each relevant advisory will be added to the `queryContext` attribute of each node under the `advisories` attribute.
+
+Some examples:
+
+- `:root > .prod:vuln` returns direct production dependencies with any known vulnerability
+- `:vuln([severity=high])` returns only dependencies with a vulnerability with a `high` severity.
+- `:vuln([severity=high],[severity=moderate])` returns only dependencies with a vulnerability with a `high`  or `moderate` severity.
+- `:vuln([cwe=1333])` returns only dependencies with a vulnerability that includes CWE-1333 (ReDoS)
+
+#### [Attribute Selectors](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors)
+
+The attribute selector evaluates the key/value pairs in `package.json` if they are `String`s.
+
+- `[]` attribute selector (ie.
+existence of attribute)
+- `[attribute=value]` attribute value is equivalent...
+- `[attribute~=value]` attribute value contains word...
+- `[attribute*=value]` attribute value contains string...
+- `[attribute|=value]` attribute value is equal to or starts with...
+- `[attribute^=value]` attribute value starts with...
+- `[attribute$=value]` attribute value ends with...
+
+#### `Array` & `Object` Attribute Selectors
+
+The generic `:attr()` pseudo selector standardizes a pattern which can be used for attribute selection of `Object`s, `Array`s or `Arrays` of `Object`s accessible via `Arborist`'s `Node.package` metadata.
+This allows for iterative attribute selection beyond top-level `String` evaluation.
+The last argument passed to `:attr()` must be an `attribute` selector or a nested `:attr()`.
+See examples below:
+
+#### `Objects`
+
+```css
+/* return dependencies that have a `scripts.test` containing `"tap"` */
+*:attr(scripts, [test~=tap])
+```
+
+#### Nested `Objects`
+
+Nested objects are expressed as sequential arguments to `:attr()`.
+
+```css
+/* return dependencies that have a [testling config](https://ci.testling.com/guide/advanced_configuration) for opera browsers */
+*:attr(testling, browsers, [~=opera])
+```
+
+#### `Arrays`
+
+`Array`s specifically uses a special/reserved `.` character in place of a typical attribute name.
+`Arrays` also support exact `value` matching when a `String` is passed to the selector.
+
+##### Example of an `Array` Attribute Selection:
+```css
+/* removes the distinction between properties & arrays */
+/* ie. we'd have to check the property & iterate to match selection */
+*:attr([keywords^=react])
+*:attr(contributors, :attr([name~=Jordan]))
+```
+
+##### Example of an `Array` matching directly to a value:
+```css
+/* return dependencies that have the exact keyword "react" */
+/* this is equivalent to `*:keywords([value="react"])` */
+*:attr([keywords=react])
+```
+
+##### Example of an `Array` of `Object`s:
+```css
+/* returns */
+*:attr(contributors, [email=ruyadorno@github.com])
+```
+
+### Groups
+
+Dependency groups are defined by the package relationships to their ancestors (ie.
+the dependency types that are defined in `package.json`).
+This approach is user-centric as the ecosystem has been taught to think about dependencies in these groups first-and-foremost.
+Dependencies are allowed to be included in multiple groups (ex.
+a `prod` dependency may also be a `dev` dependency (in that it's also required by another `dev` dependency) & may also be `bundled` - a selector for that type of dependency would look like: `*.prod.dev.bundled`).
+
+- `.prod`
+- `.dev`
+- `.optional`
+- `.peer`
+- `.bundled`
+- `.workspace`
+
+Please note that currently `workspace` deps are always `prod` dependencies.
+Additionally the `.root` dependency is also considered a `prod` dependency.
+
+### Programmatic Usage
+
+- `Arborist`'s `Node` Class has a `.querySelectorAll()` method
+  - this method will return a filtered, flattened dependency Arborist `Node` list based on a valid query selector
+
+```js
+const Arborist = require('@npmcli/arborist')
+const arb = new Arborist({})
+```
+
+```js
+// root-level
+arb.loadActual().then(async (tree) => {
+  // query all production dependencies
+  const results = await tree.querySelectorAll('.prod')
+  console.log(results)
+})
+```
+
+```js
+// iterative
+arb.loadActual().then(async (tree) => {
+  // query for the deduped version of react
+  const results = await tree.querySelectorAll('#react:not(:deduped)')
+  // query the deduped react for git deps
+  const deps = await results[0].querySelectorAll(':type(git)')
+  console.log(deps)
+})
+```
+
+## See Also
+
+* [npm query](/commands/npm-query)
+* [@npmcli/arborist](https://npm.im/@npmcli/arborist)
diff --git a/node/node_modules/npm/docs/content/using-npm/developers.md b/node/node_modules/npm/docs/content/using-npm/developers.md
new file mode 100644
index 0000000000000000000000000000000000000000..e02da225d1a6d91373d8ab5cab75f72f1c7a41bb
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/developers.md
@@ -0,0 +1,215 @@
+---
+title: Developers
+section: 7
+description: Developer guide
+---
+
+### Description
+
+So, you've decided to use npm to develop (and maybe publish/deploy) your project.
+
+Fantastic!
+
+There are a few things that you need to do above the simple steps that your users will do to install your program.
+
+### About These Documents
+
+These are man pages.
+If you install npm, you should be able to then do `man npm-thing` to get the documentation on a particular topic, or `npm help thing` to see the same information.
+
+### What is a Package
+
+A package is:
+
+* a) a folder containing a program described by a package.json file
+* b) a gzipped tarball containing (a)
+* c) a url that resolves to (b)
+* d) a `<name>@<version>` that is published on the registry with (c)
+* e) a `<name>@<tag>` that points to (d)
+* f) a `<name>` that has a "latest" tag satisfying (e)
+* g) a `git` url that, when cloned, results in (a).
+
+Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).
+
+Git urls can be of the form:
+
+```bash
+git://github.com/user/project.git#commit-ish
+git+ssh://user@hostname:project.git#commit-ish
+git+http://user@hostname/project/blah.git#commit-ish
+git+https://user@hostname/project/blah.git#commit-ish
+```
+
+The `commit-ish` can be any tag, sha, or branch which can be supplied as an argument to `git checkout`.
+The default is whatever the repository uses as its default branch.
+
+### The package.json File
+
+You need to have a `package.json` file in the root of your project to do much of anything with npm.
+That is basically the whole interface.
+
+See [`package.json`](/configuring-npm/package-json) for details about what goes in that file.
+At the very least, you need:
+
+* name: This should be a string that identifies your project.
+  Please do not use the name to specify that it runs on node, or is in JavaScript.
+  You can use the "engines" field to explicitly state the versions of node (or whatever else) that your program requires, and it's pretty well assumed that it's JavaScript.
+
+  It does not necessarily need to match your github repository name.
+
+  So, `node-foo` and `bar-js` are bad names.
+  `foo` or `bar` are better.
+
+* version: A semver-compatible version.
+
+* engines: Specify the versions of node (or whatever else) that your program runs on.
+  The node API changes a lot, and there may be bugs or new functionality that you depend on.
+  Be explicit.
+
+* author: Take some credit.
+
+* scripts: If you have a special compilation or installation script, then you should put it in the `scripts` object.
+  You should definitely have at least a basic smoke-test command as the "scripts.test" field.
+  See [scripts](/using-npm/scripts).
+
+* main: If you have a single module that serves as the entry point to your program (like what the "foo" package gives you at require("foo")), then you need to specify that in the "main" field.
+
+* directories: This is an object mapping names to folders.
+  The best ones to include are "lib" and "doc", but if you use "man" to specify a folder full of man pages, they'll get installed just like these ones.
+
+You can use `npm init` in the root of your package in order to get you started with a pretty basic package.json file.
+See [`npm init`](/commands/npm-init) for more info.
+
+### Keeping files *out* of your Package
+
+Use a `.npmignore` file to keep stuff out of your package.
+If there's no `.npmignore` file, but there *is* a `.gitignore` file, then npm will ignore the stuff matched by the `.gitignore` file.
+If you *want* to include something that is excluded by your `.gitignore` file, you can create an empty `.npmignore` file to override it.
+Like `git`, `npm` looks for `.npmignore` and `.gitignore` files in all subdirectories of your package, not only the root directory.
+
+`.npmignore` files follow the [same pattern rules](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring) as `.gitignore` files:
+
+* Blank lines or lines starting with `#` are ignored.
+* Standard glob patterns work.
+* You can end patterns with a forward slash `/` to specify a directory.
+* You can negate a pattern by starting it with an exclamation point `!`.
+
+By default, some paths and files are ignored, so there's no need to add them to `.npmignore` explicitly.
+Some examples are:
+
+* `.*.swp`
+* `._*`
+* `.DS_Store`
+* `.git`
+* `.gitignore`
+* `.hg`
+* `.npmignore`
+* `.npmrc`
+* `.lock-wscript`
+* `.svn`
+* `.wafpickle-*`
+* `config.gypi`
+* `CVS`
+* `npm-debug.log`
+
+Additionally, everything in `node_modules` is ignored, except for bundled dependencies.
+npm automatically handles this for you, so don't bother adding `node_modules` to `.npmignore`.
+
+The following paths and files are never ignored, so adding them to `.npmignore` is pointless:
+
+* `package.json`
+* `README` (and its variants)
+* `LICENSE` / `LICENCE`
+
+If, given the structure of your project, you find `.npmignore` to be a maintenance headache, you might instead try populating the `files` property of `package.json`, which is an array of file or directory names that should be included in your package.
+Sometimes manually picking which items to allow is easier to manage than building a block list.
+
+See [`package.json`](/configuring-npm/package-json) for more info on what can and can't be ignored.
+
+#### Testing whether your `.npmignore` or `files` config works
+
+If you want to double check that your package will include only the files you intend it to when published, you can run the `npm pack` command locally which will generate a tarball in the working directory, the same way it does for publishing.
+
+### Link Packages
+
+`npm link` is designed to install a development package and see the changes in real time without having to keep re-installing it.
+(You do need to either re-link or `npm rebuild -g` to update compiled packages, of course.)
+
+More info at [`npm link`](/commands/npm-link).
+
+### Before Publishing: Make Sure Your Package Installs and Works
+
+**This is important.**
+
+If you cannot install it locally, you'll have problems trying to publish it.
+Or, worse yet, you'll be able to publish it, but you'll be publishing a broken or pointless package.
+So don't do that.
+
+In the root of your package, do this:
+
+```bash
+npm install . -g
+```
+
+That'll show you that it's working.
+If you'd rather just create a symlink package that points to your working directory, then do this:
+
+```bash
+npm link
+```
+
+Use `npm ls -g` to see if it's there.
+
+To test a local install, go into some other folder, and then do:
+
+```bash
+cd ../some-other-folder
+npm install ../my-package
+```
+
+to install it locally into the node_modules folder in that other place.
+
+Then go into the node-repl, and try using require("my-thing") to bring in your module's main module.
+
+### Create a User Account
+
+Create a user with the adduser command.
+It works like this:
+
+```bash
+npm adduser
+```
+
+and then follow the prompts.
+
+This is documented better in [npm adduser](/commands/npm-adduser).
+
+### Publish your Package
+
+This part's easy.
+In the root of your folder, do this:
+
+```bash
+npm publish
+```
+
+You can give publish a url to a tarball, or a filename of a tarball, or a path to a folder.
+
+Note that pretty much **everything in that folder will be exposed** by default.
+So, if you have secret stuff in there, use a `.npmignore` file to list out the globs to ignore, or publish from a fresh checkout.
+
+### Brag about it
+
+Send emails, write blogs, blab in IRC.
+
+Tell the world how easy it is to install your program!
+
+### See also
+
+* [npm](/commands/npm)
+* [npm init](/commands/npm-init)
+* [package.json](/configuring-npm/package-json)
+* [npm scripts](/using-npm/scripts)
+* [npm publish](/commands/npm-publish)
+* [npm adduser](/commands/npm-adduser)
+* [npm registry](/using-npm/registry)
diff --git a/node/node_modules/npm/docs/content/using-npm/logging.md b/node/node_modules/npm/docs/content/using-npm/logging.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f4433711c308dbcfac13af4933c524bef6544f2
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/logging.md
@@ -0,0 +1,99 @@
+---
+title: Logging
+section: 7
+description: Why, What & How we Log
+---
+
+### Description
+
+The `npm` CLI has various mechanisms for showing different levels of information back to end-users for certain commands, configurations & environments.
+
+### Setting Log File Location
+
+All logs are written to a debug log, with the path to that file printed if the execution of a command fails.
+
+The default location of the logs directory is a directory named `_logs` inside the npm cache.
+This can be changed with the `logs-dir` config option.
+
+For example, if you wanted to write all your logs to the current working directory, you could run: `npm install --logs-dir=.`.
+This is especially helpful in debugging a specific `npm` issue as you can run a command multiple times with different config values and then diff all the log files.
+
+Log files will be removed from the `logs-dir` when the number of log files exceeds `logs-max`, with the oldest logs being deleted first.
+
+To turn off logs completely set `--logs-max=0`.
+
+### Setting Log Levels
+
+#### `loglevel`
+
+`loglevel` is a global argument/config that can be set to determine the type of information to be displayed.
+
+The default value of `loglevel` is `"notice"` but there are several levels/types of logs available, including:
+
+- `"silent"`
+- `"error"`
+- `"warn"`
+- `"notice"`
+- `"http"`
+- `"info"`
+- `"verbose"`
+- `"silly"`
+
+All logs pertaining to a level preceding the current setting will be shown.
+
+##### Aliases
+
+The log levels listed above have various corresponding aliases, including:
+
+- `-d`: `--loglevel info`
+- `--dd`: `--loglevel verbose`
+- `--verbose`: `--loglevel verbose`
+- `--ddd`: `--loglevel silly`
+- `-q`: `--loglevel warn`
+- `--quiet`: `--loglevel warn`
+- `-s`: `--loglevel silent`
+- `--silent`: `--loglevel silent`
+
+#### `foreground-scripts`
+
+The `npm` CLI began hiding the output of lifecycle scripts for `npm install` as of `v7`.
+Notably, this means you will not see logs/output from packages that may be using "install scripts" to display information back to you or from your own project's scripts defined in `package.json`.
+If you'd like to change this behavior & log this output you can set `foreground-scripts` to `true`.
+
+### Timing Information
+
+The [`--timing` config](/using-npm/config#timing) can be set which does a few things:
+
+1. Always shows the full path to the debug log regardless of command exit status
+1. Write timing information to a process specific timing file in the cache or `logs-dir`
+1. Output timing information to the terminal
+
+This file contains a `timers` object where the keys are an identifier for the portion of the process being timed and the value is the number of milliseconds it took to complete.
+
+Sometimes it is helpful to get timing information without outputting anything to the terminal.
+For example, the performance might be affected by writing to the terminal.
+In this case you can use
+`--timing --silent` which will still write the timing file, but not output anything to the terminal while running.
+
+### Registry Response Headers
+
+#### `npm-notice`
+
+The `npm` CLI reads from & logs any `npm-notice` headers that are returned from the configured registry.
+This mechanism can be used by third-party registries to provide useful information when network-dependent requests occur.
+
+This header is not cached, and will not be logged if the request is served from the cache.
+
+### Logs and Sensitive Information
+
+The `npm` CLI makes a best effort to redact the following from terminal output and log files:
+
+- Passwords inside basic auth URLs
+- npm tokens
+
+However, this behavior should not be relied on to keep all possible sensitive information redacted.
+If you are concerned about secrets in your log file or terminal output, you can use `--loglevel=silent` and `--logs-max=0` to ensure no logs are written to your terminal or filesystem.
+
+### See also
+
+* [config](/using-npm/config)
diff --git a/node/node_modules/npm/docs/content/using-npm/orgs.md b/node/node_modules/npm/docs/content/using-npm/orgs.md
new file mode 100644
index 0000000000000000000000000000000000000000..f383357efdf05d3cc814eebac8e9b0772ca9d880
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/orgs.md
@@ -0,0 +1,98 @@
+---
+title: Organizations
+section: 7
+description: Working with teams & organizations
+---
+
+### Description
+
+There are three levels of org users:
+
+1. Super admin, controls billing & adding people to the org.
+2. Team admin, manages team membership & package access.
+3. Developer, works on packages they are given access to.
+
+The super admin is the only person who can add users to the org because it impacts the monthly bill.
+The super admin will use the website to manage membership.
+Every org has a `developers` team that all users are automatically added to.
+
+The team admin is the person who manages team creation, team membership, and package access for teams.
+The team admin grants package access to teams, not individuals.
+
+The developer will be able to access packages based on the teams they are on.
+Access is either read-write or read-only.
+
+There are two main commands:
+
+1. `npm team` see [npm team](/commands/npm-team) for more details
+2. `npm access` see [npm access](/commands/npm-access) for more details
+
+### Team Admins create teams
+
+* Check who you’ve added to your org:
+
+```bash
+npm team ls <org>:developers
+```
+
+* Each org is automatically given a `developers` team, so you can see the whole list of team members in your org.
+This team automatically gets read-write access to all packages, but you can change that with the `access` command.
+
+* Create a new team:
+
+```bash
+npm team create <org:team>
+```
+
+* Add members to that team:
+
+```bash
+npm team add <org:team> <user>
+```
+
+### Publish a package and adjust package access
+
+* In package directory, run
+
+```bash
+npm init --scope=<org>
+```
+to scope it for your org & publish as usual
+
+* Grant access:  
+
+```bash
+npm access grant <read-only|read-write> <org:team> [<package>]
+```
+
+* Revoke access:
+
+```bash
+npm access revoke <org:team> [<package>]
+```
+
+### Monitor your package access
+
+* See what org packages a team member can access:
+
+```bash
+npm access list packages <org> <user>
+```
+
+* See packages available to a specific team:
+
+```bash
+npm access list packages <org:team>
+```
+
+* Check which teams are collaborating on a package:
+
+```bash
+npm access list collaborators <pkg>
+```
+
+### See also
+
+* [npm team](/commands/npm-team)
+* [npm access](/commands/npm-access)
+* [npm scope](/using-npm/scope)
diff --git a/node/node_modules/npm/docs/content/using-npm/package-spec.md b/node/node_modules/npm/docs/content/using-npm/package-spec.md
new file mode 100644
index 0000000000000000000000000000000000000000..36d86c24982364d9c7277fcd7b13aaffa6168e37
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/package-spec.md
@@ -0,0 +1,92 @@
+---
+title: Package spec
+section: 7
+description: Package name specifier
+---
+
+### Description
+
+Commands like `npm install` and the dependency sections in the `package.json` use a package name specifier.
+This can be many different things that all refer to a "package".  Examples include a package name, git url, tarball, or local directory.
+These will generally be referred to as `<package-spec>` in the help output for the npm commands that use this package name specifier.
+
+### Package name
+
+* `[<@scope>/]<pkg>`
+* `[<@scope>/]<pkg>@<tag>`
+* `[<@scope>/]<pkg>@<version>`
+* `[<@scope>/]<pkg>@<version range>`
+
+Refers to a package by name, with or without a scope, and optionally tag, version, or version range.
+This is typically used in combination with the [registry](/using-npm/config#registry) config to refer to a package in a registry.
+
+Examples:
+* `npm`
+* `@npmcli/arborist`
+* `@npmcli/arborist@latest`
+* `npm@6.13.1`
+* `npm@^4.0.0`
+
+### Aliases
+
+* `<alias>@npm:<name>`
+
+Primarily used by commands like `npm install` and in the dependency sections in the `package.json`, this refers to a package by an alias.
+The `<alias>` is the name of the package as it is reified in the `node_modules` folder, and the `<name>` refers to a package name as found in the configured registry.
+
+See `Package name` above for more info on referring to a package by name, and [registry](/using-npm/config#registry) for configuring which registry is used when referring to a package by name.
+
+Examples:
+* `semver@npm:@npmcli/semver-with-patch`
+* `semver@npm:semver@7.2.2`
+* `semver@npm:semver@legacy`
+
+### Folders
+
+* `<folder>`
+
+This refers to a package on the local filesystem.
+Specifically this is a folder with a `package.json` file in it.
+This *should* always be prefixed with a `/` or `./` (or your OS equivalent) to reduce confusion.
+npm currently will parse a string with more than one `/` in it as a folder, but this is legacy behavior that may be removed in a future version.
+
+Examples:
+
+* `./my-package`
+* `/opt/npm/my-package`
+
+### Tarballs
+
+* `<tarball file>`
+* `<tarball url>`
+
+Examples:
+
+* `./my-package.tgz`
+* `https://registry.npmjs.org/semver/-/semver-1.0.0.tgz`
+
+Refers to a package in a tarball format, either on the local filesystem or remotely via url.
+This is the format that packages exist in when uploaded to a registry.
+
+### git urls
+
+* `<git:// url>`
+* `<github username>/<github project>`
+
+Refers to a package in a git repo.
+This can be a full git url, git shorthand, or a username/package on GitHub.
+You can specify a git tag, branch, or other git ref by appending `#ref`.
+
+Examples:
+
+* `https://github.com/npm/cli.git`
+* `git@github.com:npm/cli.git`
+* `git+ssh://git@github.com/npm/cli#v6.0.0`
+* `github:npm/cli#HEAD`
+* `npm/cli#c12ea07`
+
+### See also
+
+* [npm-package-arg](https://npm.im/npm-package-arg)
+* [scope](/using-npm/scope)
+* [config](/using-npm/config)
diff --git a/node/node_modules/npm/docs/content/using-npm/registry.md b/node/node_modules/npm/docs/content/using-npm/registry.md
new file mode 100644
index 0000000000000000000000000000000000000000..1b1d8f855e2382e9d95c3b385485d4db80715de5
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/registry.md
@@ -0,0 +1,61 @@
+---
+title: Registry
+section: 7
+description: The JavaScript Package Registry
+---
+
+### Description
+
+To resolve packages by name and version, npm talks to a registry website that implements the CommonJS Package Registry specification for reading package info.
+
+npm is configured to use the **npm public registry** at
+<https://registry.npmjs.org> by default.
+Use of the npm public registry is subject to terms of use available at <https://docs.npmjs.com/policies/terms>.
+
+You can configure npm to use any compatible registry you like, and even run your own registry.
+Use of someone else's registry may be governed by their terms of use.
+
+npm's package registry implementation supports several write APIs as well, to allow for publishing packages and managing user account information.
+
+The registry URL used is determined by the scope of the package (see [`scope`](/using-npm/scope).
+If no scope is specified, the default registry is used, which is supplied by the [`registry` config](/using-npm/config#registry) parameter.
+See [`npm config`](/commands/npm-config), [`npmrc`](/configuring-npm/npmrc), and [`config`](/using-npm/config) for more on managing npm's configuration.
+Authentication configuration such as auth tokens and certificates are configured specifically scoped to an individual registry.
+See [Auth Related Configuration](/configuring-npm/npmrc#auth-related-configuration)
+
+When the default registry is used in a package-lock or shrinkwrap it has the special meaning of "the currently configured registry". If you create a lock file while using the default registry you can switch to another registry and npm will install packages from the new registry, but if you create a lock file while using a custom registry packages will be installed from that registry even after you change to another registry.
+
+### Does npm send any information about me back to the registry?
+
+Yes.
+
+When making requests of the registry npm adds two headers with information about your environment:
+
+* `Npm-Scope` – If your project is scoped, this header will contain its scope.
+In the future npm hopes to build registry features that use this information to allow you to customize your experience for your organization.
+* `Npm-In-CI` – Set to "true" if npm believes this install is running in a continuous integration environment, "false" otherwise.
+This is detected by looking for the following environment variables: `CI`, `TDDIUM`,
+  `JENKINS_URL`, `bamboo.buildKey`.
+If you'd like to learn more you may find the [original PR](https://github.com/npm/npm-registry-client/pull/129) interesting.
+  This is used to gather better metrics on how npm is used by humans, versus build farms.
+
+The npm registry does not try to correlate the information in these headers with any authenticated accounts that may be used in the same requests.
+
+### How can I prevent my package from being published in the official registry?
+
+Set `"private": true` in your `package.json` to prevent it from being published at all, or
+`"publishConfig":{"registry":"http://my-internal-registry.local"}`
+to force it to be published only to your internal/private registry.
+
+See [`package.json`](/configuring-npm/package-json) for more info on what goes in the package.json file.
+
+### Where can I find my (and others') published packages?
+
+<https://www.npmjs.com/>
+
+### See also
+
+* [npm config](/commands/npm-config)
+* [config](/using-npm/config)
+* [npmrc](/configuring-npm/npmrc)
+* [npm developers](/using-npm/developers)
diff --git a/node/node_modules/npm/docs/content/using-npm/removal.md b/node/node_modules/npm/docs/content/using-npm/removal.md
new file mode 100644
index 0000000000000000000000000000000000000000..4dd6a340e330fa772c8fcb25b32ad4476aa6bfcc
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/removal.md
@@ -0,0 +1,55 @@
+---
+title: Removal
+section: 7
+description: Cleaning the slate
+---
+
+### Synopsis
+
+So sad to see you go.
+
+```bash
+sudo npm uninstall npm -g
+```
+
+Or, if that fails, please proceed to more severe uninstalling methods.
+
+### More Severe Uninstalling
+
+Usually, the above instructions are sufficient.
+That will remove npm, but leave behind anything you've installed.
+
+If that doesn't work, or if you require more drastic measures, continue reading.
+
+Note that this is only necessary for globally-installed packages.
+Local installs are completely contained within a project's `node_modules` folder.
+Delete that folder, and everything is gone unless a package's install script is particularly ill-behaved.
+
+This assumes that you installed node and npm in the default place.
+If you configured node with a different `--prefix`, or installed npm with a different prefix setting, then adjust the paths accordingly, replacing
+`/usr/local` with your install prefix.
+
+To remove everything npm-related manually:
+
+```bash
+rm -rf /usr/local/{lib/node{,/.npm,_modules},bin,share/man}/npm*
+```
+
+If you installed things *with* npm, then your best bet is to uninstall them with npm first, and then install them again once you have a proper install.
+This can help find any symlinks that are lying around:
+
+```bash
+ls -laF /usr/local/{lib/node{,/.npm},bin,share/man} | grep npm
+```
+
+Prior to version 0.3, npm used shim files for executables and node modules.
+To track those down, you can do the following:
+
+```bash
+find /usr/local/{lib/node,bin} -exec grep -l npm \{\} \; ;
+```
+
+### See also
+
+* [npm uninstall](/commands/npm-uninstall)
+* [npm prune](/commands/npm-prune)
diff --git a/node/node_modules/npm/docs/content/using-npm/scope.md b/node/node_modules/npm/docs/content/using-npm/scope.md
new file mode 100644
index 0000000000000000000000000000000000000000..e5aadae51dad930d416fb985a4fd1ffab1ee67a3
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/scope.md
@@ -0,0 +1,123 @@
+---
+title: Scope
+section: 7
+description: Scoped packages
+---
+
+### Description
+
+All npm packages have a name.
+Some package names also have a scope.
+A scope follows the usual rules for package names (URL-safe characters, no leading dots or underscores).
+When used in package names, scopes are preceded by an `@` symbol and followed by a slash, e.g.
+
+```bash
+@somescope/somepackagename
+```
+
+Scopes are a way of grouping related packages together, and also affect a few things about the way npm treats the package.
+
+Each npm user/organization has their own scope, and only you can add packages in your scope.
+This means you don't have to worry about someone taking your package name ahead of you.
+Thus it is also a good way to signal official packages for organizations.
+
+Scoped packages can be published and installed as of `npm@2` and are supported by the primary npm registry.
+Unscoped packages can depend on scoped packages and vice versa.
+The npm client is backwards-compatible with unscoped registries, so it can be used to work with scoped and unscoped registries at the same time.
+
+### Installing scoped packages
+
+Scoped packages are installed to a sub-folder of the regular installation folder, e.g. if your other packages are installed in `node_modules/packagename`, scoped modules will be installed in `node_modules/@myorg/packagename`.
+The scope folder (`@myorg`) is simply the name of the scope preceded by an `@` symbol, and can contain any number of scoped packages.
+
+A scoped package is installed by referencing it by name, preceded by an
+`@` symbol, in `npm install`:
+
+```bash
+npm install @myorg/mypackage
+```
+
+Or in `package.json`:
+
+```json
+"dependencies": {
+  "@myorg/mypackage": "^1.3.0"
+}
+```
+
+Note that if the `@` symbol is omitted, in either case, npm will instead attempt to install from GitHub; see [`npm install`](/commands/npm-install).
+
+### Requiring scoped packages
+
+Because scoped packages are installed into a scope folder, you have to include the name of the scope when requiring them in your code, e.g.
+
+```javascript
+require('@myorg/mypackage')
+```
+
+There is nothing special about the way Node treats scope folders.
+This simply requires the `mypackage` module in the folder named `@myorg`.
+
+### Publishing scoped packages
+
+Scoped packages can be published from the CLI as of `npm@2` and can be published to any registry that supports them, including the primary npm registry.
+
+(As of 2015-04-19, and with npm 2.0 or better, the primary npm registry
+**does** support scoped packages.)
+
+If you wish, you may associate a scope with a registry; see below.
+
+#### Publishing public scoped packages to the primary npm registry
+
+Publishing to a scope, you have two options:
+
+- Publishing to your user scope (example: `@username/module`)
+- Publishing to an organization scope (example: `@org/module`)
+
+If publishing a public module to an organization scope, you must first either create an organization with the name of the scope that you'd like to publish to or be added to an existing organization with the appropriate permissions.
+For example, if you'd like to publish to `@org`, you would  need to create the `org` organization on npmjs.com prior to trying to publish.
+
+Scoped packages are not public by default.
+You will need to specify
+`--access public` with the initial `npm publish` command.
+This will publish the package and set access to `public` as if you had run `npm access public` after publishing.
+You do not need to do this when publishing new versions of an existing scoped package.
+
+#### Publishing private scoped packages to the npm registry
+
+To publish a private scoped package to the npm registry, you must have an [npm Private Modules](https://docs.npmjs.com/private-modules/intro) account.
+
+You can then publish the module with `npm publish` or `npm publish
+--access restricted`, and it will be present in the npm registry, with restricted access.
+You can then change the access permissions, if desired, with `npm access` or on the npmjs.com website.
+
+### Associating a scope with a registry
+
+Scopes can be associated with a separate registry.
+This allows you to seamlessly use a mix of packages from the primary npm registry and one or more private registries, such as [GitHub Packages](https://github.com/features/packages) or the open source [Verdaccio](https://verdaccio.org) project.
+
+You can associate a scope with a registry at login, e.g.
+
+```bash
+npm login --registry=http://reg.example.com --scope=@myco
+```
+
+Scopes have a many-to-one relationship with registries: one registry can host multiple scopes, but a scope only ever points to one registry.
+
+You can also associate a scope with a registry using `npm config`:
+
+```bash
+npm config set @myco:registry=http://reg.example.com
+```
+
+Once a scope is associated with a registry, any `npm install` for a package with that scope will request packages from that registry instead.
+Any
+`npm publish` for a package name that contains the scope will be published to
+that registry instead.
+
+### See also
+
+* [npm install](/commands/npm-install)
+* [npm publish](/commands/npm-publish)
+* [npm access](/commands/npm-access)
+* [npm registry](/using-npm/registry)
diff --git a/node/node_modules/npm/docs/content/using-npm/scripts.md b/node/node_modules/npm/docs/content/using-npm/scripts.md
new file mode 100644
index 0000000000000000000000000000000000000000..9eb8a8224161ffc09fd65afbdac4f127b1ad57e2
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/scripts.md
@@ -0,0 +1,366 @@
+---
+title: Scripts
+section: 7
+description: How npm handles the "scripts" field
+---
+
+### Description
+
+The `"scripts"` property of your `package.json` file supports a number of built-in scripts and their preset life cycle events as well as arbitrary scripts.
+These all can be executed by running `npm run <stage>`.
+*Pre* and *post* commands with matching names will be run for those as well (e.g.
+`premyscript`,
+`myscript`, `postmyscript`).
+Scripts from dependencies can be run with `npm explore <pkg> -- npm run <stage>`.
+
+### Pre & Post Scripts
+
+To create "pre" or "post" scripts for any scripts defined in the
+`"scripts"` section of the `package.json`, simply create another script
+*with a matching name* and add "pre" or "post" to the beginning of them.
+
+```json
+{
+  "scripts": {
+    "precompress": "{{ executes BEFORE the `compress` script }}",
+    "compress": "{{ run command to compress files }}",
+    "postcompress": "{{ executes AFTER `compress` script }}"
+  }
+}
+```
+
+In this example `npm run compress` would execute these scripts as described.
+
+### Life Cycle Scripts
+
+There are some special life cycle scripts that happen only in certain situations.
+These scripts happen in addition to the `pre<event>`, `post<event>`, and
+`<event>` scripts.
+
+* `prepare`, `prepublish`, `prepublishOnly`, `prepack`, `postpack`, `dependencies`
+
+**prepare** (since `npm@4.0.0`)
+* Runs BEFORE the package is packed, i.e.
+during `npm publish` and `npm pack`
+* Runs on local `npm install` without package arguments (runs with flags like `--production` or `--omit=dev`, but does not run when installing specific packages like `npm install express`)
+* Runs AFTER `prepublishOnly` and `prepack`, but BEFORE `postpack`
+* Runs for a package if it's being installed as a link through `npm install <folder>`
+
+* NOTE: If a package being installed through git contains a `prepare` script, its `dependencies` and `devDependencies` will be installed, and the prepare script will be run, before the package is packaged and installed.
+
+* As of `npm@7` these scripts run in the background.
+  To see the output, run with: `--foreground-scripts`.
+
+* **In workspaces, prepare scripts run concurrently** across all packages. If you have interdependent packages where one must build before another, consider using `--foreground-scripts` (which can be set in `.npmrc` with `foreground-scripts=true`) to run scripts sequentially, or structure your build differently.
+
+**prepublish** (DEPRECATED)
+* Does not run during `npm publish`, but does run during `npm ci` and `npm install`.
+See below for more info.
+
+**prepublishOnly**
+* Runs BEFORE the package is prepared and packed, ONLY on `npm publish`.
+
+**prepack**
+* Runs BEFORE a tarball is packed (on "`npm pack`", "`npm publish`", and when installing a git dependency).
+* NOTE: "`npm run pack`" is NOT the same as "`npm pack`". "`npm run pack`" is an arbitrary user defined script name, whereas, "`npm pack`" is a CLI defined command.
+
+**postpack**
+* Runs AFTER the tarball has been generated but before it is moved to its final destination (if at all, publish does not save the tarball locally)
+
+**dependencies**
+* Runs AFTER any operations that modify the `node_modules` directory IF changes occurred.
+* Does NOT run in global mode
+
+#### Prepare and Prepublish
+
+**Deprecation Note: prepublish**
+
+Since `npm@1.1.71`, the npm CLI has run the `prepublish` script for both `npm publish` and `npm install`, because it's a convenient way to prepare a package for use (some common use cases are described in the section below).
+It has also turned out to be, in practice, [very confusing](https://github.com/npm/npm/issues/10074).
+As of `npm@4.0.0`, a new event has been introduced, `prepare`, that preserves this existing behavior.
+A _new_ event, `prepublishOnly` has been added as a transitional strategy to allow users to avoid the confusing behavior of existing npm versions and only run on `npm publish` (for instance, running the tests one last time to ensure they're in good shape).
+
+See <https://github.com/npm/npm/issues/10074> for a much lengthier justification, with further reading, for this change.
+
+**Use Cases**
+
+Use a `prepare` script to perform build tasks that are platform-independent and need to run before your package is used.
+This includes tasks such as:
+
+* Compiling TypeScript or other source code into JavaScript.
+* Creating minified versions of JavaScript source code.
+* Fetching remote resources that your package will use.
+
+Running these build tasks in the `prepare` script ensures they happen once, in a single place, reducing complexity and variability.
+Additionally, this means that:
+
+* You can depend on build tools as `devDependencies`, and thus your users don't need to have them installed.
+* You don't need to include minifiers in your package, reducing the size for your users.
+* You don't need to rely on your users having `curl` or `wget` or other system tools on the target machines.
+
+#### Dependencies
+
+The `dependencies` script is run any time an `npm` command causes changes to the `node_modules` directory.
+It is run AFTER the changes have been applied and the `package.json` and `package-lock.json` files have been updated.
+
+### Life Cycle Operation Order
+
+#### [`npm cache add`](/commands/npm-cache)
+
+* `prepare`
+
+#### [`npm ci`](/commands/npm-ci)
+
+* `preinstall`
+* `install`
+* `postinstall`
+* `prepublish`
+* `preprepare`
+* `prepare`
+* `postprepare`
+
+These all run after the actual installation of modules into
+ `node_modules`, in order, with no internal actions happening in between
+
+#### [`npm diff`](/commands/npm-diff)
+
+* `prepare`
+
+#### [`npm install`](/commands/npm-install)
+
+These also run when you run `npm install -g <pkg-name>`
+
+* `preinstall`
+* `install`
+* `postinstall`
+* `prepublish`
+* `preprepare`
+* `prepare`
+* `postprepare`
+
+If there is a `binding.gyp` file in the root of your package and you haven't defined your own `install` or `preinstall` scripts, npm will default the `install` command to compile using node-gyp via `node-gyp rebuild`
+
+These are run from the scripts of `<pkg-name>`
+
+#### [`npm pack`](/commands/npm-pack)
+
+* `prepack`
+* `prepare`
+* `postpack`
+
+#### [`npm publish`](/commands/npm-publish)
+
+* `prepublishOnly`
+* `prepack`
+* `prepare`
+* `postpack`
+* `publish`
+* `postpublish`
+
+#### [`npm rebuild`](/commands/npm-rebuild)
+
+* `preinstall`
+* `install`
+* `postinstall`
+* `prepare`
+
+`prepare` is only run if the current directory is a symlink (e.g.
+with linked packages)
+
+#### [`npm restart`](/commands/npm-restart)
+
+If there is a `restart` script defined, these events are run; otherwise,
+`stop` and `start` are both run if present, including their `pre` and `post` iterations)
+
+* `prerestart`
+* `restart`
+* `postrestart`
+
+#### [`npm run <user defined>`](/commands/npm-run)
+
+* `pre<user-defined>`
+* `<user-defined>`
+* `post<user-defined>`
+
+#### [`npm start`](/commands/npm-start)
+
+* `prestart`
+* `start`
+* `poststart`
+
+If there is a `server.js` file in the root of your package, then npm will default the `start` command to `node server.js`.
+`prestart` and `poststart` will still run in this case.
+
+#### [`npm stop`](/commands/npm-stop)
+
+* `prestop`
+* `stop`
+* `poststop`
+
+#### [`npm test`](/commands/npm-test)
+
+* `pretest`
+* `test`
+* `posttest`
+
+#### [`npm version`](/commands/npm-version)
+
+* `preversion`
+* `version`
+* `postversion`
+
+#### A Note on a lack of [`npm uninstall`](/commands/npm-uninstall) scripts
+
+While npm v6 had `uninstall` lifecycle scripts, npm v7 does not.
+Removal of a package can happen for a wide variety of reasons, and there's no clear way to currently give the script enough context to be useful.
+
+
+Reasons for a package removal include:
+
+* a user directly uninstalled this package
+* a user uninstalled a dependent package and so this dependency is being uninstalled
+* a user uninstalled a dependent package but another package also depends on this version
+* this version has been merged as a duplicate with another version
+* etc.
+
+Due to the lack of necessary context, `uninstall` lifecycle scripts are not implemented and will not function.
+
+### Working Directory for Scripts
+
+Scripts are always run from the root of the package folder, regardless of what the current working directory is when `npm` is invoked.
+This means your scripts can reliably assume they are running in the package root.
+
+If you want your script to behave differently based on the directory you were in when you ran `npm`, you can use the `INIT_CWD` environment variable, which holds the full path you were in when you ran `npm run`.
+
+#### Historical Behavior in Older npm Versions
+
+For npm v6 and earlier, scripts were generally run from the root of the package, but there were rare cases and bugs in older versions where this was not guaranteed.
+If your package must support very old npm versions, you may wish to add a safeguard in your scripts (for example, by checking process.cwd()).
+
+For more details, see:
+- [npm v7 release notes](https://github.com/npm/cli/releases/tag/v7.0.0)
+- [Discussion about script working directory reliability in npm v6 and earlier](https://github.com/npm/npm/issues/12356)
+
+### Environment
+
+Package scripts run in an environment where many pieces of information are made available regarding the setup of npm and the current state of the process.
+
+#### path
+
+If you depend on modules that define executable scripts, like test suites, then those executables will be added to the `PATH` for executing the scripts.
+So, if your package.json has this:
+
+```json
+{
+  "name" : "foo",
+  "dependencies" : {
+    "bar" : "0.1.x"
+  },
+  "scripts": {
+    "start" : "bar ./test"
+  }
+}
+```
+
+then you could run `npm start` to execute the `bar` script, which is exported into the `node_modules/.bin` directory on `npm install`.
+
+#### package.json vars
+
+npm sets the following environment variables from the package.json:
+
+* `npm_package_name` - The package name
+* `npm_package_version` - The package version
+* `npm_package_bin_*` - Each executable defined in the bin field
+* `npm_package_engines_*` - Each engine defined in the engines field
+* `npm_package_config_*` - Each config value defined in the config field
+* `npm_package_json` - The full path to the package.json file
+
+Additionally, for install scripts (`preinstall`, `install`, `postinstall`), npm sets these environment variables:
+
+* `npm_package_resolved` - The resolved URL for the package
+* `npm_package_integrity` - The integrity hash for the package
+* `npm_package_optional` - Set to `"true"` if the package is optional
+* `npm_package_dev` - Set to `"true"` if the package is a dev dependency
+* `npm_package_peer` - Set to `"true"` if the package is a peer dependency
+* `npm_package_dev_optional` - Set to `"true"` if the package is both dev and optional
+
+For example, if you had `{"name":"foo", "version":"1.2.5"}` in your package.json file, then your package scripts would have the `npm_package_name` environment variable set to "foo", and the `npm_package_version` set to "1.2.5". You can access these variables in your code with `process.env.npm_package_name` and `process.env.npm_package_version`.
+
+**Note:** In npm 7 and later, most package.json fields are no longer provided as environment variables. Scripts that need access to other package.json fields should read the package.json file directly. The `npm_package_json` environment variable provides the path to the file for this purpose.
+
+See [`package.json`](/configuring-npm/package-json) for more on package configs.
+
+#### current lifecycle event
+
+Lastly, the `npm_lifecycle_event` environment variable is set to whichever stage of the cycle is being executed.
+So, you could have a single script used for different parts of the process which switches based on what's currently happening.
+
+Objects are flattened following this format, so if you had
+`{"scripts":{"install":"foo.js"}}` in your package.json, then you'd see this in the script:
+
+```bash
+process.env.npm_package_scripts_install === "foo.js"
+```
+
+### Examples
+
+For example, if your package.json contains this:
+
+```json
+{
+  "scripts" : {
+    "prepare" : "scripts/build.js",
+    "test" : "scripts/test.js"
+  }
+}
+```
+
+then `scripts/build.js` will be called for the prepare stage of the lifecycle, and you can check the
+`npm_lifecycle_event` environment variable if your script needs to behave differently in different contexts.
+
+If you want to run build commands, you can do so.
+This works just fine:
+
+```json
+{
+  "scripts" : {
+    "prepare" : "npm run build",
+    "build" : "tsc",
+    "test" : "jest"
+  }
+}
+```
+
+### Exiting
+
+Scripts are run by passing the line as a script argument to `/bin/sh` on POSIX systems or `cmd.exe` on Windows.
+You can control which shell is used by setting the [`script-shell`](/using-npm/config#script-shell) configuration option.
+
+If the script exits with a code other than 0, then this will abort the process.
+
+Note that these script files don't have to be Node.js or even JavaScript programs.
+They just have to be some kind of executable file.
+
+### Best Practices
+
+* Don't exit with a non-zero error code unless you *really* mean it.
+  If the failure is minor or only will prevent some optional features, then it's better to just print a warning and exit successfully.
+* Try not to use scripts to do what npm can do for you.
+Read through [`package.json`](/configuring-npm/package-json) to see all the things that you can specify and enable by simply describing your package appropriately.
+In general, this will lead to a more robust and consistent state.
+* Inspect the env to determine where to put things.
+For instance, if the `NPM_CONFIG_BINROOT` environment variable is set to `/home/user/bin`, then don't try to install executables into `/usr/local/bin`.
+The user probably set it up that way for a reason.
+* Don't prefix your script commands with "sudo".  If root permissions are required for some reason, then it'll fail with that error, and the user will sudo the npm command in question.
+* Don't use `install`.
+Use a `.gyp` file for compilation, and `prepare` for anything else.
+You should almost never have to explicitly set a preinstall or install script.
+If you are doing this, please consider if there is another option.
+The only valid use of `install` or `preinstall` scripts is for compilation which must be done on the target architecture.
+
+### See Also
+
+* [npm run](/commands/npm-run)
+* [package.json](/configuring-npm/package-json)
+* [npm developers](/using-npm/developers)
+* [npm install](/commands/npm-install)
diff --git a/node/node_modules/npm/docs/content/using-npm/workspaces.md b/node/node_modules/npm/docs/content/using-npm/workspaces.md
new file mode 100644
index 0000000000000000000000000000000000000000..3344c3fe306b9fc81e3eb4682de36cd8c6ccff16
--- /dev/null
+++ b/node/node_modules/npm/docs/content/using-npm/workspaces.md
@@ -0,0 +1,219 @@
+---
+title: Workspaces
+section: 7
+description: Working with workspaces
+---
+
+### Description
+
+**Workspaces** is a generic term that refers to the set of features in the npm cli that provides support for managing multiple packages from your local file system from within a singular top-level, root package.
+
+This set of features makes up for a much more streamlined workflow handling linked packages from the local file system.
+It automates the linking process as part of `npm install` and removes the need to manually use `npm link` in order to add references to packages that should be symlinked into the current `node_modules` folder.
+
+We also refer to these packages being auto-symlinked during `npm install` as a single **workspace**, meaning it's a nested package within the current local file system that is explicitly defined in the [`package.json`](/configuring-npm/package-json#workspaces)
+`workspaces` configuration.
+
+### Defining workspaces
+
+Workspaces are usually defined via the `workspaces` property of the [`package.json`](/configuring-npm/package-json#workspaces) file, e.g:
+
+```json
+{
+  "name": "my-workspaces-powered-project",
+  "workspaces": [
+    "packages/a"
+  ]
+}
+```
+
+Given the above `package.json` example living at a current working directory `.` that contains a folder named `packages/a` that itself contains a `package.json` inside it, defining a Node.js package, e.g:
+
+```
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+```
+
+The expected result once running `npm install` in this current working directory `.` is that the folder `packages/a` will get symlinked to the `node_modules` folder of the current working dir.
+
+Below is a post `npm install` example, given that same previous example structure of files and folders:
+
+```
+.
++-- node_modules
+|  `-- a -> ../packages/a
++-- package-lock.json
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+```
+
+### Getting started with workspaces
+
+You may automate the required steps to define a new workspace using [npm init](/commands/npm-init).
+For example in a project that already has a `package.json` defined you can run:
+
+```
+npm init -w ./packages/a
+```
+
+This command will create the missing folders and a new `package.json` file (if needed) while also making sure to properly configure the
+`"workspaces"` property of your root project `package.json`.
+
+### Adding dependencies to a workspace
+
+It's possible to directly add/remove/update dependencies of your workspaces using the [`workspace` config](/using-npm/config#workspace).
+
+For example, assuming the following structure:
+
+```
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- b
+       `-- package.json
+```
+
+If you want to add a dependency named `abbrev` from the registry as a dependency of your workspace **a**, you may use the workspace config to tell the npm installer that package should be added as a dependency of the provided workspace:
+
+```
+npm install abbrev -w a
+```
+
+**Adding a workspace as a dependency of another workspace:**
+
+The same approach works when adding one workspace as a dependency of another.
+If you want to add workspace **b** as a dependency of workspace **a**, run:
+
+```
+npm install b -w a
+```
+
+npm will detect that **b** is a workspace and automatically symlink it rather
+than fetching it from the registry. The resulting entry in workspace **a**'s
+`package.json` will use a standard version range:
+
+```json
+{
+  "dependencies": {
+    "b": "^1.0.0"
+  }
+}
+```
+
+Note: other installing commands such as `uninstall`, `ci`, etc will also respect the provided `workspace` configuration.
+
+### Using workspaces
+
+Given the [specifics of how Node.js handles module resolution](https://nodejs.org/dist/latest-v14.x/docs/api/modules.html#modules_all_together) it's possible to consume any defined workspace by its declared `package.json` `name`.
+Continuing from the example defined above, let's also create a Node.js script that will require the workspace `a` example module, e.g:
+
+```
+// ./packages/a/index.js
+module.exports = 'a'
+
+// ./lib/index.js
+const moduleA = require('a')
+console.log(moduleA) // -> a
+```
+
+When running it with:
+
+`node lib/index.js`
+
+This demonstrates how the nature of `node_modules` resolution allows for
+**workspaces** to enable a portable workflow for requiring each **workspace** in such a way that is also easy to [publish](/commands/npm-publish) these nested workspaces to be consumed elsewhere.
+
+### Running commands in the context of workspaces
+
+You can use the `workspace` configuration option to run commands in the context of a configured workspace.
+Additionally, if your current directory is in a workspace, the `workspace` configuration is implicitly set, and `prefix` is set to the root workspace.
+
+Following is a quick example on how to use the `npm run` command in the context of nested workspaces.
+For a project containing multiple workspaces, e.g:
+
+```
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- b
+       `-- package.json
+```
+
+By running a command using the `workspace` option, it's possible to run the given command in the context of that specific workspace.
+e.g:
+
+```
+npm run test --workspace=a
+```
+
+You could also run the command within the workspace.
+
+```
+cd packages/a && npm run test
+```
+
+Either will run the `test` script defined within the
+`./packages/a/package.json` file.
+
+Please note that you can also specify this argument multiple times in the command-line in order to target multiple workspaces, e.g:
+
+```
+npm run test --workspace=a --workspace=b
+```
+
+Or run the command for each workspace within the 'packages' folder:
+```
+npm run test --workspace=packages
+```
+
+It's also possible to use the `workspaces` (plural) configuration option to enable the same behavior but running that command in the context of **all** configured workspaces.
+e.g:
+
+```
+npm run test --workspaces
+```
+
+Will run the `test` script in both `./packages/a` and `./packages/b`.
+
+Commands will be run in each workspace in the order they appear in your `package.json`
+
+```
+{
+  "workspaces": [ "packages/a", "packages/b" ]
+}
+```
+
+Order of run is different with:
+
+```
+{
+  "workspaces": [ "packages/b", "packages/a" ]
+}
+```
+
+### Ignoring missing scripts
+
+It is not required for all of the workspaces to implement scripts run with the `npm run` command.
+
+By running the command with the `--if-present` flag, npm will ignore workspaces missing target script.
+
+```
+npm run test --workspaces --if-present
+```
+
+### See also
+
+* [npm install](/commands/npm-install)
+* [npm publish](/commands/npm-publish)
+* [npm run](/commands/npm-run)
+* [config](/using-npm/config)
+
diff --git a/node/node_modules/npm/docs/lib/index.js b/node/node_modules/npm/docs/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..99506e75c2131989dc0e524a4d03d0a40c01e33a
--- /dev/null
+++ b/node/node_modules/npm/docs/lib/index.js
@@ -0,0 +1,310 @@
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { join, basename, resolve } = require('path')
+const transformHTML = require('./transform-html.js')
+const { version } = require('../../lib/npm.js')
+const { aliases } = require('../../lib/utils/cmd-list')
+const { shorthands, definitions } = require('@npmcli/config/lib/definitions')
+
+const DOC_EXT = '.md'
+
+const TAGS = {
+  CONFIG: '<!-- AUTOGENERATED CONFIG DESCRIPTIONS -->',
+  USAGE: '<!-- AUTOGENERATED USAGE DESCRIPTIONS -->',
+  SHORTHANDS: '<!-- AUTOGENERATED CONFIG SHORTHANDS -->',
+}
+
+const assertPlaceholder = (src, path, placeholder) => {
+  if (!src.includes(placeholder)) {
+    throw new Error(
+      `Cannot replace ${placeholder} in ${path} due to missing placeholder`
+    )
+  }
+  return placeholder
+}
+
+// Default command loader - loads commands from lib/commands
+const defaultCommandLoader = (name) => {
+  return require(`../../lib/commands/${name}`)
+}
+
+// Load a command using the provided loader or default
+const getCommand = (name, commandLoader = defaultCommandLoader) => {
+  return commandLoader(name)
+}
+
+// Resolve definitions for a command - use definitions if present, otherwise build from params
+const resolveDefinitions = (command) => {
+  // If command has definitions, use them directly (ignore params)
+  if (command.definitions && Object.keys(command.definitions).length > 0) {
+    return command.definitions
+  }
+
+  // Otherwise build from params using global definitions
+  if (command.params) {
+    const resolved = {}
+    for (const param of command.params) {
+      if (definitions[param]) {
+        resolved[param] = definitions[param]
+      }
+    }
+    return resolved
+  }
+
+  return {}
+}
+
+const getCommandByDoc = (docFile, docExt, commandLoader = defaultCommandLoader) => {
+  // Grab the command name from the *.md filename
+  // NOTE: We cannot use the name property command file because in the case of
+  // `npx` the file being used is `lib/commands/exec.js`
+  const name = basename(docFile, docExt).replace('npm-', '')
+
+  if (name === 'npm') {
+    return {
+      name,
+      definitions: [],
+      usage: 'npm',
+    }
+  }
+
+  // special case for `npx`:
+  // `npx` is not technically a command in and of itself,
+  // so it just needs the usage of npm exec
+  const srcName = name === 'npx' ? 'exec' : name
+  const command = getCommand(srcName, commandLoader)
+  const { usage = [''], workspaces } = command
+  const usagePrefix = name === 'npx' ? 'npx' : `npm ${name}`
+
+  // Resolve definitions - handles exclusive params expansion
+  const commandDefs = resolveDefinitions(command)
+  const resolvedDefs = {}
+  for (const [key, def] of Object.entries(commandDefs)) {
+    resolvedDefs[key] = def
+    // Handle exclusive params
+    if (def.exclusive) {
+      for (const e of def.exclusive) {
+        if (!resolvedDefs[e] && definitions[e]) {
+          resolvedDefs[e] = definitions[e]
+        }
+      }
+    }
+  }
+
+  return {
+    name,
+    workspaces,
+    definitions: name === 'npx' ? {} : resolvedDefs,
+    usage: usage?.map(u => `${usagePrefix} ${u}`.trim()).join('\n'),
+  }
+}
+
+const replaceVersion = (src) => src.replace(/@VERSION@/g, version)
+
+const replaceUsage = (src, { path, commandLoader }) => {
+  const replacer = assertPlaceholder(src, path, TAGS.USAGE)
+  const { usage, name, workspaces } = getCommandByDoc(path, DOC_EXT, commandLoader)
+
+  const synopsis = []
+
+  if (usage) {
+    synopsis.push('```bash', usage)
+
+    const cmdAliases = Object.keys(aliases).reduce((p, c) => {
+      if (aliases[c] === name) {
+        p.push(c)
+      }
+      return p
+    }, [])
+
+    if (cmdAliases.length === 1) {
+      synopsis.push('', `alias: ${cmdAliases[0]}`)
+    } else if (cmdAliases.length > 1) {
+      synopsis.push('', `aliases: ${cmdAliases.join(', ')}`)
+    }
+
+    synopsis.push('```')
+  }
+
+  if (!workspaces) {
+    if (synopsis.length) {
+      synopsis.push('')
+    }
+    synopsis.push('Note: This command is unaware of workspaces.')
+  }
+
+  return src.replace(replacer, synopsis.join('\n'))
+}
+
+// Helper to generate a markdown table from definitions
+const generateFlagsTable = (definitionPool) => {
+  const rows = Object.keys(definitionPool).map((n) => {
+    const def = definitionPool[n]
+    const flags = [`\`--${def.key}\``]
+    if (def.alias) {
+      flags.push(...def.alias.map(a => `\`--${a}\``))
+    }
+    if (def.short) {
+      flags.push(`\`-${def.short}\``)
+    }
+    const flagsStr = flags.join(', ')
+    let defaultVal = def.defaultDescription
+    if (!defaultVal) {
+      defaultVal = String(def.default)
+    }
+    let typeVal = def.typeDescription || String(def.type)
+    if (def.required) {
+      typeVal = `${typeVal} (required)`
+    }
+    const desc = (def.description || '').replace(/\n/g, ' ').trim()
+    return `| ${flagsStr} | ${defaultVal} | ${typeVal} | ${desc} |`
+  })
+
+  return [
+    '| Flag | Default | Type | Description |',
+    '| --- | --- | --- | --- |',
+    ...rows,
+  ].join('\n')
+}
+
+const replaceDefinitions = (src, { path, commandLoader }) => {
+  const { definitions: commandDefs, name } = getCommandByDoc(path, DOC_EXT, commandLoader)
+
+  let subcommands = {}
+  try {
+    const command = getCommand(name, commandLoader)
+    subcommands = command.subcommands || {}
+  } catch {
+    // Command doesn't exist
+  }
+
+  // If no definitions and no subcommands, nothing to replace
+  if (Object.keys(commandDefs).length === 0 && Object.keys(subcommands).length === 0) {
+    return src
+  }
+
+  // Assert placeholder is present
+  const replacer = assertPlaceholder(src, path, TAGS.CONFIG)
+
+  // If command has subcommands, generate sections for each subcommand
+  if (Object.keys(subcommands).length > 0) {
+    const subcommandSections = Object.entries(subcommands).map(([subName, SubCommand]) => {
+      const subUsage = SubCommand.usage || []
+      const subDefs = resolveDefinitions(SubCommand)
+
+      const parts = [`### \`npm ${name} ${subName}\``, '']
+
+      if (SubCommand.description) {
+        parts.push(SubCommand.description, '')
+      }
+
+      // Add usage/synopsis
+      if (subUsage.length > 0) {
+        parts.push('#### Synopsis', '', '```bash')
+        subUsage.forEach(u => {
+          parts.push(`npm ${name} ${subName} ${u}`.trim())
+        })
+        parts.push('```', '')
+      }
+
+      // Add flags section if definitions exist
+      if (Object.keys(subDefs).length > 0) {
+        parts.push('#### Flags', '')
+        parts.push(generateFlagsTable(subDefs), '')
+      }
+
+      return parts.join('\n')
+    })
+
+    return src.replace(replacer, subcommandSections.join('\n'))
+  }
+
+  // For commands without subcommands - commandDefs must be non-empty here
+  // (we would have returned early at line 175 if both were empty)
+  const paramDescriptions = Object.values(commandDefs)
+    .map(def => def.describe())
+
+  return src.replace(replacer, paramDescriptions.join('\n\n'))
+}
+
+const replaceConfig = (src, { path }) => {
+  const replacer = assertPlaceholder(src, path, TAGS.CONFIG)
+
+  // sort not-deprecated ones to the top
+  /* istanbul ignore next - typically already sorted in the definitions file,
+   * but this is here so that our help doc will stay consistent if we decide
+   * to move them around. */
+  const sort = ([keya, { deprecated: depa }], [keyb, { deprecated: depb }]) => {
+    return depa && !depb ? 1
+      : !depa && depb ? -1
+      : localeCompare(keya, keyb)
+  }
+
+  const allConfig = Object.entries(definitions).sort(sort)
+    .map(([, def]) => def.describe())
+    .join('\n\n')
+
+  return src.replace(replacer, allConfig)
+}
+
+const replaceShorthands = (src, { path }) => {
+  const replacer = assertPlaceholder(src, path, TAGS.SHORTHANDS)
+
+  const sh = Object.entries(shorthands)
+    .sort(([shorta, expansiona], [shortb, expansionb]) =>
+      // sort by what they're short FOR
+      localeCompare(expansiona.join(' '), expansionb.join(' ')) || localeCompare(shorta, shortb)
+    )
+    .map(([short, expansion]) => {
+      // XXX: this is incorrect. we have multicharacter flags like `-iwr` that
+      // can only be set with a single dash
+      const dash = short.length === 1 ? '-' : '--'
+      return `* \`${dash}${short}\`: \`${expansion.join(' ')}\``
+    })
+
+  return src.replace(replacer, sh.join('\n'))
+}
+
+const replaceHelpLinks = (src) => {
+  // replaces markdown links with equivalent-ish npm help commands
+  return src.replace(
+    /\[`?([\w\s-]+)`?\]\(\/(?:commands|configuring-npm|using-npm)\/(?:[\w\s-]+)\)/g,
+    (_, p1) => {
+      const term = p1.replace(/npm\s/g, '').replace(/\s+/g, ' ').trim()
+      const help = `npm help ${term.includes(' ') ? `"${term}"` : term}`
+      return help
+    }
+  )
+}
+
+const transformMan = (src, { data, unified, remarkParse, remarkMan }) => unified()
+  .use(remarkParse)
+  .use(remarkMan, { version: `NPM@${version}` })
+  .processSync(`# ${data.title}(${data.section}) - ${data.description}\n\n${src}`)
+  .toString()
+
+const manPath = (name, { data }) => join(`man${data.section}`, `${name}.${data.section}`)
+
+const transformMd = (src, { frontmatter }) => ['---', frontmatter, '---', '', src].join('\n')
+
+module.exports = {
+  DOC_EXT,
+  TAGS,
+  paths: {
+    content: resolve(__dirname, 'content'),
+    nav: resolve(__dirname, 'content', 'nav.yml'),
+    template: resolve(__dirname, 'template.html'),
+    man: resolve(__dirname, '..', '..', 'man'),
+    html: resolve(__dirname, '..', 'output'),
+    md: resolve(__dirname, '..', 'content'),
+  },
+  usage: replaceUsage,
+  definitions: replaceDefinitions,
+  config: replaceConfig,
+  shorthands: replaceShorthands,
+  version: replaceVersion,
+  helpLinks: replaceHelpLinks,
+  man: transformMan,
+  manPath: manPath,
+  md: transformMd,
+  html: transformHTML,
+}
diff --git a/node/node_modules/npm/docs/output/commands/npm-access.html b/node/node_modules/npm/docs/output/commands/npm-access.html
new file mode 100644
index 0000000000000000000000000000000000000000..61ac7d3b38c470bb5fbf0daff58d4d12929a67d2
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-access.html
@@ -0,0 +1,280 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-access</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-access----11130">
+    <span>npm-access</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Set access level on published packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#details">Details</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#json"><code>json</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#registry"><code>registry</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm access list packages [&lt;user&gt;|&lt;scope&gt;|&lt;scope:team&gt;] [&lt;package&gt;]
+npm access list collaborators [&lt;package&gt; [&lt;user&gt;]]
+npm access get status [&lt;package&gt;]
+npm access set status=public|private [&lt;package&gt;]
+npm access set mfa=none|publish|automation [&lt;package&gt;]
+npm access grant &lt;read-only|read-write&gt; &lt;scope:team&gt; [&lt;package&gt;]
+npm access revoke &lt;scope:team&gt; [&lt;package&gt;]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Used to set access controls on private packages.</p>
+<p>For all of the subcommands, <code>npm access</code> will perform actions on the packages in the current working directory if no package name is passed to the subcommand.</p>
+<ul>
+<li>grant / revoke:
+Add or remove the ability of users and teams to have read-only or read-write access to a package.</li>
+</ul>
+<h3 id="details">Details</h3>
+<p><code>npm access</code> always operates directly on the current registry, configurable from the command line using <code>--registry=&lt;registry url&gt;</code>.</p>
+<p>Unscoped packages are <em>always public</em>.</p>
+<p>Scoped packages <em>default to restricted</em>, but you can either publish them as public using <code>npm publish --access=public</code>, or set their access as public using <code>npm access set status=public</code> after the initial publish.</p>
+<p>You must have privileges to set the access of a package:</p>
+<ul>
+<li>You are an owner of an unscoped or scoped package.</li>
+<li>You are a member of the team that owns a scope.</li>
+<li>You have been given read-write privileges for a package, either as a member of a team or directly as an owner.</li>
+</ul>
+<p>If you have two-factor authentication enabled then you'll be prompted to provide a second factor, or may use the <code>--otp=...</code> option to specify it on the command line.</p>
+<p>If your account is not paid, then attempts to publish scoped packages will fail with an HTTP 402 status code (logically enough), unless you use
+<code>--access=public</code>.</p>
+<p>Management of teams and team memberships is done with the <code>npm team</code> command.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="https://npm.im/libnpmaccess"><code>libnpmaccess</code></a></li>
+<li><a href="../commands/npm-team.html">npm team</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-access.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-adduser.html b/node/node_modules/npm/docs/output/commands/npm-adduser.html
new file mode 100644
index 0000000000000000000000000000000000000000..2544f39244e2bf27c1b0a019437212b94ed007c6
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-adduser.html
@@ -0,0 +1,271 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-adduser</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-adduser----11130">
+    <span>npm-adduser</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Add a registry user account</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#scope"><code>scope</code></a></li><li><a href="#auth-type"><code>auth-type</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm adduser
+
+alias: add-user
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Create a new user in the specified registry, and save the credentials to the <code>.npmrc</code> file.
+If no registry is specified, the default registry will be used (see <a href="../using-npm/registry.html"><code>registry</code></a>).</p>
+<p>When you run <code>npm adduser</code>, the CLI automatically generates a legacy token of <code>publish</code> type.
+For more information, see <a href="../about-access-tokens#about-legacy-tokens.html">About legacy tokens</a>.</p>
+<p>When using <code>legacy</code> for your <code>auth-type</code>, the username, password, and email are read in from prompts.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="scope"><code>scope</code></h4>
+<ul>
+<li>Default: the scope of the current project, if any, or ""</li>
+<li>Type: String</li>
+</ul>
+<p>Associate an operation with a scope for a scoped registry.</p>
+<p>Useful when logging in to or out of a private registry:</p>
+<pre><code># log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+</code></pre>
+<p>This will cause <code>@mycorp</code> to be mapped to the registry for future
+installation of packages specified according to the pattern
+<code>@mycorp/package</code>.</p>
+<p>This will also cause <code>npm init</code> to create a scoped package.</p>
+<pre><code># accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+</code></pre>
+<h4 id="auth-type"><code>auth-type</code></h4>
+<ul>
+<li>Default: "web"</li>
+<li>Type: "legacy" or "web"</li>
+</ul>
+<p>What authentication strategy to use with <code>login</code>. Note that if an <code>otp</code>
+config is given, this value will always be set to <code>legacy</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-token.html">npm token</a></li>
+<li><a href="../commands/npm-profile.html">npm profile</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-adduser.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-audit.html b/node/node_modules/npm/docs/output/commands/npm-audit.html
new file mode 100644
index 0000000000000000000000000000000000000000..14f5de241f4f119110ca1f5a970359f5082e8ac7
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-audit.html
@@ -0,0 +1,528 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-audit</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-audit----11130">
+    <span>npm-audit</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Run a security audit</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#package-lock">Package lock</a></li><li><a href="#audit-signatures">Audit Signatures</a></li><li><a href="#audit-endpoints">Audit Endpoints</a></li><ul><li><a href="#bulk-advisory-endpoint">Bulk Advisory Endpoint</a></li><li><a href="#quick-audit-endpoint">Quick Audit Endpoint</a></li><li><a href="#scrubbing">Scrubbing</a></li><li><a href="#calculating-meta-vulnerabilities-and-remediations">Calculating Meta-Vulnerabilities and Remediations</a></li></ul><li><a href="#exit-code">Exit Code</a></li><li><a href="#examples">Examples</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#audit-level"><code>audit-level</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#force"><code>force</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#package-lock2"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#include-attestations"><code>include-attestations</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm audit [fix|signatures]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>The audit command submits a description of the dependencies configured in your project to your default registry and asks for a report of known vulnerabilities.
+If any vulnerabilities are found, then the impact and appropriate remediation will be calculated.
+If the <code>fix</code> argument is provided, then remediations will be applied to the package tree.</p>
+<p>The command will exit with a 0 exit code if no vulnerabilities were found.</p>
+<p>Note that some vulnerabilities cannot be fixed automatically and will require manual intervention or review.
+Also note that since <code>npm audit fix</code> runs a full-fledged <code>npm install</code> under the hood, all configs that apply to the installer will also apply to <code>npm install</code> -- so things like <code>npm audit fix --package-lock-only</code> will work as expected.</p>
+<p>By default, the audit command will exit with a non-zero code if any vulnerability is found.
+It may be useful in CI environments to include the <code>--audit-level</code> parameter to specify the minimum vulnerability level that will cause the command to fail.
+This option does not filter the report output, it simply changes the command's failure threshold.</p>
+<h3 id="package-lock">Package lock</h3>
+<p>By default npm requires a package-lock or shrinkwrap in order to run the audit.
+You can bypass the package lock with <code>--no-package-lock</code> but be aware the results may be different with every run, since npm will re-build the dependency tree each time.</p>
+<h3 id="audit-signatures">Audit Signatures</h3>
+<p>To ensure the integrity of packages you download from the public npm registry, or any registry that supports signatures, you can verify the registry signatures of downloaded packages using the npm CLI.</p>
+<p>Registry signatures can be verified using the following <code>audit</code> command:</p>
+<pre><code class="language-bash">$ npm audit signatures
+</code></pre>
+<p>The <code>audit signatures</code> command will also verify the provenance attestations of downloaded packages.
+Because provenance attestations are such a new feature, security features may be added to (or changed in) the attestation format over time.
+To ensure that you're always able to verify attestation signatures check that you're running the latest version of the npm CLI. Please note this often means updating npm beyond the version that ships with Node.js.</p>
+<p>To include the full sigstore attestation bundles in JSON output, use:</p>
+<pre><code class="language-bash">$ npm audit signatures --json --include-attestations
+</code></pre>
+<p>This adds a <code>verified</code> array to the JSON output containing the attestation
+bundles (DSSE envelopes, verification material, and transparency log entries)
+for each verified package.</p>
+<p>The npm CLI supports registry signatures and signing keys provided by any registry if the following conventions are followed:</p>
+<ol>
+<li>Signatures are provided in the package's <code>packument</code> in each published version within the <code>dist</code> object:</li>
+</ol>
+<pre><code class="language-json">"dist":{
+  "..omitted..": "..omitted..",
+  "signatures": [{
+    "keyid": "SHA256:{{SHA256_PUBLIC_KEY}}",
+    "sig": "a312b9c3cb4a1b693e8ebac5ee1ca9cc01f2661c14391917dcb111517f72370809..."
+  }]
+}
+</code></pre>
+<p>See this <a href="https://registry.npmjs.org/light-cycle/1.4.3">example</a> of a signed package from the public npm registry.</p>
+<p>The <code>sig</code> is generated using the following template: <code>${package.name}@${package.version}:${package.dist.integrity}</code> and the <code>keyid</code> has to match one of the public signing keys below.</p>
+<ol start="2">
+<li>Public signing keys are provided at <code>registry-host.tld/-/npm/v1/keys</code> in the following format:</li>
+</ol>
+<pre><code>{
+  "keys": [{
+    "expires": null,
+    "keyid": "SHA256:{{SHA256_PUBLIC_KEY}}",
+    "keytype": "ecdsa-sha2-nistp256",
+    "scheme": "ecdsa-sha2-nistp256",
+    "key": "{{B64_PUBLIC_KEY}}"
+  }]
+}
+</code></pre>
+<p>Keys response:</p>
+<ul>
+<li><code>expires</code>: null or a simplified extended <a href="https://en.wikipedia.org/wiki/ISO_8601">ISO 8601 format</a>: <code>YYYY-MM-DDTHH:mm:ss.sssZ</code></li>
+<li><code>keyid</code>: sha256 fingerprint of the public key</li>
+<li><code>keytype</code>: only <code>ecdsa-sha2-nistp256</code> is currently supported by the npm CLI</li>
+<li><code>scheme</code>: only <code>ecdsa-sha2-nistp256</code> is currently supported by the npm CLI</li>
+<li><code>key</code>: base64 encoded public key</li>
+</ul>
+<p>See this <a href="https://registry.npmjs.org/-/npm/v1/keys">example key's response from the public npm registry</a>.</p>
+<h3 id="audit-endpoints">Audit Endpoints</h3>
+<p>There are two audit endpoints that npm may use to fetch vulnerability information: the <code>Bulk Advisory</code> endpoint and the <code>Quick Audit</code> endpoint.</p>
+<h4 id="bulk-advisory-endpoint">Bulk Advisory Endpoint</h4>
+<p>As of version 7, npm uses the much faster <code>Bulk Advisory</code> endpoint to optimize the speed of calculating audit results.</p>
+<p>npm will generate a JSON payload with the name and list of versions of each package in the tree, and POST it to the default configured registry at the path <code>/-/npm/v1/security/advisories/bulk</code>.</p>
+<p>Any packages in the tree that do not have a <code>version</code> field in their package.json file will be ignored.
+If any <code>--omit</code> options are specified (either via the <a href="../using-npm/config#omit.html"><code>--omit</code> config</a>, or one of the shorthands such as <code>--production</code>, <code>--only=dev</code>, and so on), then packages will be omitted from the submitted payload as appropriate.</p>
+<p>If the registry responds with an error, or with an invalid response, then npm will attempt to load advisory data from the <code>Quick Audit</code> endpoint.</p>
+<p>The expected result will contain a set of advisory objects for each dependency that matches the advisory range.
+Each advisory object contains a <code>name</code>, <code>url</code>, <code>id</code>, <code>severity</code>, <code>vulnerable_versions</code>, and <code>title</code>.</p>
+<p>npm then uses these advisory objects to calculate vulnerabilities and meta-vulnerabilities of the dependencies within the tree.</p>
+<h4 id="quick-audit-endpoint">Quick Audit Endpoint</h4>
+<p>If the <code>Bulk Advisory</code> endpoint returns an error, or invalid data, npm will attempt to load advisory data from the <code>Quick Audit</code> endpoint, which is considerably slower in most cases.</p>
+<p>The full package tree as found in <code>package-lock.json</code> is submitted, along with the following pieces of additional metadata:</p>
+<ul>
+<li><code>npm_version</code></li>
+<li><code>node_version</code></li>
+<li><code>platform</code></li>
+<li><code>arch</code></li>
+<li><code>node_env</code></li>
+</ul>
+<p>All packages in the tree are submitted to the Quick Audit endpoint.
+Omitted dependency types are skipped when generating the report.</p>
+<h4 id="scrubbing">Scrubbing</h4>
+<p>Out of an abundance of caution, npm versions 5 and 6 would "scrub" any packages from the submitted report if their name contained a <code>/</code> character, so as to avoid leaking the names of potentially private packages or git URLs.</p>
+<p>However, in practice, this resulted in audits often failing to properly detect meta-vulnerabilities, because the tree would appear to be invalid due to missing dependencies, and prevented the detection of vulnerabilities in package trees that used git dependencies or private modules.</p>
+<p>This scrubbing has been removed from npm as of version 7.</p>
+<h4 id="calculating-meta-vulnerabilities-and-remediations">Calculating Meta-Vulnerabilities and Remediations</h4>
+<p>npm uses the <a href="http://npm.im/@npmcli/metavuln-calculator"><code>@npmcli/metavuln-calculator</code></a> module to turn a set of security advisories into a set of "vulnerability" objects.
+A "meta-vulnerability" is a dependency that is vulnerable by virtue of dependence on vulnerable versions of a vulnerable package.</p>
+<p>For example, if the package <code>foo</code> is vulnerable in the range <code>&gt;=1.0.2 &lt;2.0.0</code>, and the package <code>bar</code> depends on <code>foo@^1.1.0</code>, then that version of <code>bar</code> can only be installed by installing a vulnerable version of <code>foo</code>.
+In this case, <code>bar</code> is a "metavulnerability".</p>
+<p>Once metavulnerabilities for a given package are calculated, they are cached in the <code>~/.npm</code> folder and only re-evaluated if the advisory range changes, or a new version of the package is published (in which case, the new version is checked for metavulnerable status as well).</p>
+<p>If the chain of metavulnerabilities extends all the way to the root project, and it cannot be updated without changing its dependency ranges, then <code>npm audit fix</code> will require the <code>--force</code> option to apply the remediation.
+If remediations do not require changes to the dependency ranges, then all vulnerable packages will be updated to a version that does not have an advisory or metavulnerability posted against it.</p>
+<h3 id="exit-code">Exit Code</h3>
+<p>The <code>npm audit</code> command will exit with a 0 exit code if no vulnerabilities were found.
+The <code>npm audit fix</code> command will exit with 0 exit code if no vulnerabilities are found <em>or</em> if the remediation is able to successfully fix all vulnerabilities.</p>
+<p>If vulnerabilities were found the exit code will depend on the <a href="../using-npm/config#audit-level.html"><code>audit-level</code> config</a>.</p>
+<h3 id="examples">Examples</h3>
+<p>Scan your project for vulnerabilities and automatically install any compatible updates to vulnerable dependencies:</p>
+<pre><code class="language-bash">$ npm audit fix
+</code></pre>
+<p>Run <code>audit fix</code> without modifying <code>node_modules</code>, but still updating the pkglock:</p>
+<pre><code class="language-bash">$ npm audit fix --package-lock-only
+</code></pre>
+<p>Skip updating <code>devDependencies</code>:</p>
+<pre><code class="language-bash">$ npm audit fix --only=prod
+</code></pre>
+<p>Have <code>audit fix</code> install SemVer-major updates to toplevel dependencies, not just SemVer-compatible ones:</p>
+<pre><code class="language-bash">$ npm audit fix --force
+</code></pre>
+<p>Do a dry run to get an idea of what <code>audit fix</code> will do, and <em>also</em> output install information in JSON format:</p>
+<pre><code class="language-bash">$ npm audit fix --dry-run --json
+</code></pre>
+<p>Scan your project for vulnerabilities and just show the details, without fixing anything:</p>
+<pre><code class="language-bash">$ npm audit
+</code></pre>
+<p>Get the detailed audit report in JSON format:</p>
+<pre><code class="language-bash">$ npm audit --json
+</code></pre>
+<p>Fail an audit only if the results include a vulnerability with a level of moderate or higher:</p>
+<pre><code class="language-bash">$ npm audit --audit-level=moderate
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="audit-level"><code>audit-level</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "info", "low", "moderate", "high", "critical", or "none"</li>
+</ul>
+<p>The minimum level of vulnerability for <code>npm audit</code> to exit with a non-zero
+exit code.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="force"><code>force</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.</p>
+<ul>
+<li>Allow clobbering non-npm files in global installs.</li>
+<li>Allow the <code>npm version</code> command to work on an unclean git repository.</li>
+<li>Allow deleting the cache folder with <code>npm cache clean</code>.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of npm.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of <code>node</code>, even if <code>--engine-strict</code> is enabled.</li>
+<li>Allow <code>npm audit fix</code> to install modules outside your stated dependency
+range (including SemVer-major changes).</li>
+<li>Allow unpublishing all versions of a published package.</li>
+<li>Allow conflicting peerDependencies to be installed in the root project.</li>
+<li>Implicitly set <code>--yes</code> during <code>npm init</code>.</li>
+<li>Allow clobbering existing values in <code>npm pkg</code></li>
+<li>Allow unpublishing of entire packages (not just a single version).</li>
+</ul>
+<p>If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="package-lock2"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="include-attestations"><code>include-attestations</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When used with <code>npm audit signatures --json</code>, includes the full sigstore
+attestation bundles in the JSON output for each verified package. The
+bundles contain DSSE envelopes, verification material, and transparency log
+entries.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-audit.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-bugs.html b/node/node_modules/npm/docs/output/commands/npm-bugs.html
new file mode 100644
index 0000000000000000000000000000000000000000..3d6633da3bf2db28eb85577b36ae50f7beaee55f
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-bugs.html
@@ -0,0 +1,293 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-bugs</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-bugs----11130">
+    <span>npm-bugs</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Report bugs for a package in a web browser</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#browser"><code>browser</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm bugs [&lt;pkgname&gt; [&lt;pkgname&gt; ...]]
+
+alias: issues
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command tries to guess at the likely location of a package's bug tracker URL or the <code>mailto</code> URL of the support email, and then tries to open it using the <a href="../using-npm/config#browser.html"><code>--browser</code> config</a> param.
+If no package name is provided, it will search for a <code>package.json</code> in the current folder and use the <code>name</code> property.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="browser"><code>browser</code></h4>
+<ul>
+<li>Default: macOS: <code>"open"</code>, Windows: <code>"start"</code>, Others: <code>"xdg-open"</code></li>
+<li>Type: null, Boolean, or String</li>
+</ul>
+<p>The browser that is called by npm commands to open websites.</p>
+<p>Set to <code>false</code> to suppress browser behavior and instead print urls to
+terminal.</p>
+<p>Set to <code>true</code> to use default system URL opener.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-docs.html">npm docs</a></li>
+<li><a href="../commands/npm-view.html">npm view</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-bugs.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-cache.html b/node/node_modules/npm/docs/output/commands/npm-cache.html
new file mode 100644
index 0000000000000000000000000000000000000000..babe8ab444af7fd076519d1a076e08253067a9f5
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-cache.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-cache</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-cache----11130">
+    <span>npm-cache</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manipulates packages cache</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#npm-cache"><code>npm cache</code></a></li><li><a href="#npm-cache-npx"><code>npm cache npx</code></a></li></ul><li><a href="#details">Details</a></li><li><a href="#a-note-about-the-caches-design">A note about the cache's design</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#cache"><code>cache</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm cache add &lt;package-spec&gt;
+npm cache clean [&lt;key&gt;]
+npm cache ls [&lt;name&gt;@&lt;version&gt;]
+npm cache verify
+npm cache npx ls
+npm cache npx rm [&lt;key&gt;...]
+npm cache npx info &lt;key&gt;...
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Used to add, list, or clean the <code>npm cache</code> folder.
+Also used to view info about entries in the <code>npm exec</code> (aka <code>npx</code>) cache folder.</p>
+<h4 id="npm-cache"><code>npm cache</code></h4>
+<ul>
+<li>
+<p>add:
+Add the specified packages to the local cache.
+This command is primarily intended to be used internally by npm, but it can provide a way to add data to the local installation cache explicitly.</p>
+</li>
+<li>
+<p>clean:
+Delete a single entry or all entries out of the cache folder.
+Note that this is typically unnecessary, as npm's cache is self-healing and resistant to data corruption issues.</p>
+</li>
+<li>
+<p>ls:
+List given entries or all entries in the local cache.</p>
+</li>
+<li>
+<p>verify:
+Verify the contents of the cache folder, garbage collecting any unneeded data, and verifying the integrity of the cache index and all cached data.</p>
+</li>
+</ul>
+<h4 id="npm-cache-npx"><code>npm cache npx</code></h4>
+<ul>
+<li>
+<p>ls:
+List all entries in the npx cache.</p>
+</li>
+<li>
+<p>rm:
+Remove given entries or all entries from the npx cache.</p>
+</li>
+<li>
+<p>info:
+Get detailed information about given entries in the npx cache.</p>
+</li>
+</ul>
+<h3 id="details">Details</h3>
+<p>npm stores cache data in an opaque directory within the configured <code>cache</code>, named <code>_cacache</code>.
+This directory is a <a href="http://npm.im/cacache"><code>cacache</code></a>-based content-addressable cache that stores all http request data as well as other package-related data.
+This directory is primarily accessed through <code>pacote</code>, the library responsible for all package fetching as of npm@5.</p>
+<p>All data that passes through the cache is fully verified for integrity on both insertion and extraction.
+Cache corruption will either trigger an error, or signal to <code>pacote</code> that the data must be refetched, which it will do automatically.
+For this reason, it should never be necessary to clear the cache for any reason other than reclaiming disk space, thus why <code>clean</code> now requires <code>--force</code> to run.</p>
+<p>There is currently no method exposed through npm to inspect or directly manage the contents of this cache.
+In order to access it, <code>cacache</code> must be used directly.</p>
+<p>npm will not remove data by itself: the cache will grow as new packages are installed.</p>
+<h3 id="a-note-about-the-caches-design">A note about the cache's design</h3>
+<p>The npm cache is strictly a cache: it should not be relied upon as a persistent and reliable data store for package data.
+npm makes no guarantee that a previously-cached piece of data will be available later, and will automatically delete corrupted contents.
+The primary guarantee that the cache makes is that, if it does return data, that data will be exactly the data that was inserted.</p>
+<p>To run an offline verification of existing cache contents, use <code>npm cache verify</code>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="cache"><code>cache</code></h4>
+<ul>
+<li>Default: Windows: <code>%LocalAppData%\npm-cache</code>, Posix: <code>~/.npm</code></li>
+<li>Type: Path</li>
+</ul>
+<p>The location of npm's cache directory.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-pack.html">npm pack</a></li>
+<li><a href="../commands/npm-exec.html">npm exec</a></li>
+<li><a href="https://npm.im/cacache">https://npm.im/cacache</a></li>
+<li><a href="https://npm.im/pacote">https://npm.im/pacote</a></li>
+<li><a href="https://npm.im/@npmcli/arborist">https://npm.im/@npmcli/arborist</a></li>
+<li><a href="https://npm.im/make-fetch-happen">https://npm.im/make-fetch-happen</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-cache.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-ci.html b/node/node_modules/npm/docs/output/commands/npm-ci.html
new file mode 100644
index 0000000000000000000000000000000000000000..67ecd3073393a0a093c874e21b672685e631c370
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-ci.html
@@ -0,0 +1,458 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-ci</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-ci----11130">
+    <span>npm-ci</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Clean install a project</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm ci
+
+aliases: clean-install, ic, install-clean, isntall-clean
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command is similar to <a href="../commands/npm-install.html"><code>npm install</code></a>, except it's meant to be used in automated environments such as test platforms, continuous integration, and deployment -- or any situation where you want to make sure you're doing a clean install of your dependencies.</p>
+<p>The main differences between using <code>npm install</code> and <code>npm ci</code> are:</p>
+<ul>
+<li>The project <strong>must</strong> have an existing <code>package-lock.json</code> or
+<code>npm-shrinkwrap.json</code>.</li>
+<li>If dependencies in the package lock do not match those in <code>package.json</code>,
+<code>npm ci</code> will exit with an error, instead of updating the package lock.</li>
+<li><code>npm ci</code> can only install entire projects at a time: individual dependencies cannot be added with this command.</li>
+<li>If a <code>node_modules</code> is already present, it will be automatically removed before <code>npm ci</code> begins its install.</li>
+<li>It will never write to <code>package.json</code> or any of the package-locks:
+installs are essentially frozen.</li>
+</ul>
+<p>NOTE: If you create your <code>package-lock.json</code> file by running <code>npm install</code> with flags that can affect the shape of your dependency tree, such as
+<code>--legacy-peer-deps</code> or <code>--install-links</code>, you <em>must</em> provide the same flags to <code>npm ci</code> or you are likely to encounter errors.
+An easy way to do this is to run, for example,
+<code>npm config set legacy-peer-deps=true --location=project</code> and commit the
+<code>.npmrc</code> file to your repo.</p>
+<h3 id="example">Example</h3>
+<p>Make sure you have a package-lock and an up-to-date install:</p>
+<pre><code class="language-bash">$ cd ./my/npm/project
+$ npm install
+added 154 packages in 10s
+$ ls | grep package-lock
+</code></pre>
+<p>Run <code>npm ci</code> in that project</p>
+<pre><code class="language-bash">$ npm ci
+added 154 packages in 5s
+</code></pre>
+<p>Configure Travis CI to build using <code>npm ci</code> instead of <code>npm install</code>:</p>
+<pre><code class="language-bash"># .travis.yml
+install:
+- npm ci
+# keep the npm cache around to speed up installs
+cache:
+  directories:
+  - "$HOME/.npm"
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../configuring-npm/package-lock-json.html">package-lock.json</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-ci.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-completion.html b/node/node_modules/npm/docs/output/commands/npm-completion.html
new file mode 100644
index 0000000000000000000000000000000000000000..0376a4a6b0ff75feb8c264e882013af4feb0d0b1
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-completion.html
@@ -0,0 +1,234 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-completion</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-completion----11130">
+    <span>npm-completion</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Tab Completion for npm</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm completion
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Enables tab-completion in all npm commands.</p>
+<p>The synopsis above loads the completions into your current shell.
+Adding it to your ~/.bashrc or ~/.zshrc will make the completions available everywhere:</p>
+<pre><code class="language-bash">npm completion &gt;&gt; ~/.bashrc
+npm completion &gt;&gt; ~/.zshrc
+</code></pre>
+<p>You may of course also pipe the output of <code>npm completion</code> to a file such as <code>/usr/local/etc/bash_completion.d/npm</code> or
+<code>/etc/bash_completion.d/npm</code> if you have a system that will read
+that file for you.</p>
+<p>When <code>COMP_CWORD</code>, <code>COMP_LINE</code>, and <code>COMP_POINT</code> are defined in the environment, <code>npm completion</code> acts in "plumbing mode", and outputs completions based on the arguments.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/developers.html">npm developers</a></li>
+<li><a href="../commands/npm.html">npm</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-completion.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-config.html b/node/node_modules/npm/docs/output/commands/npm-config.html
new file mode 100644
index 0000000000000000000000000000000000000000..757de9811bb473c0deb9dc0a3112837f345da05d
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-config.html
@@ -0,0 +1,331 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-config</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-config----11130">
+    <span>npm-config</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manage the npm configuration files</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#sub-commands">Sub-commands</a></li><ul><li><a href="#set">set</a></li><li><a href="#get">get</a></li><li><a href="#list">list</a></li><li><a href="#delete">delete</a></li><li><a href="#edit2">edit</a></li><li><a href="#fix">fix</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#json"><code>json</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#editor"><code>editor</code></a></li><li><a href="#location"><code>location</code></a></li><li><a href="#long"><code>long</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm config set &lt;key&gt;=&lt;value&gt; [&lt;key&gt;=&lt;value&gt; ...]
+npm config get [&lt;key&gt; [&lt;key&gt; ...]]
+npm config delete &lt;key&gt; [&lt;key&gt; ...]
+npm config list [--json]
+npm config edit
+npm config fix
+
+alias: c
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>npm gets its config settings from the command line, environment variables, <code>npmrc</code> files, and in some cases, the <code>package.json</code> file.</p>
+<p>See <a href="../configuring-npm/npmrc.html">npmrc</a> for more information about the npmrc files.</p>
+<p>See <a href="../using-npm/config.html">config</a> for a more thorough explanation of the mechanisms involved, and a full list of config options available.</p>
+<p>The <code>npm config</code> command can be used to update and edit the contents of the user and global npmrc files.</p>
+<h3 id="sub-commands">Sub-commands</h3>
+<p>Config supports the following sub-commands:</p>
+<h4 id="set">set</h4>
+<pre><code class="language-bash">npm config set key=value [key=value...]
+npm set key=value [key=value...]
+</code></pre>
+<p>Sets each of the config keys to the value provided.
+Modifies the user configuration file unless <a href="../commands/npm-config#location.html"><code>location</code></a> is passed.</p>
+<p>If value is omitted, the key will be removed from your config file entirely.</p>
+<p>Note: for backwards compatibility, <code>npm config set key value</code> is supported as an alias for <code>npm config set key=value</code>.</p>
+<h4 id="get">get</h4>
+<pre><code class="language-bash">npm config get [key ...]
+npm get [key ...]
+</code></pre>
+<p>Echo the config value(s) to stdout.</p>
+<p>If multiple keys are provided, then the values will be prefixed with the key names.</p>
+<p>If no keys are provided, then this command behaves the same as <code>npm config list</code>.</p>
+<h4 id="list">list</h4>
+<pre><code class="language-bash">npm config list
+</code></pre>
+<p>Show all the config settings.
+Use <code>-l</code> to also show defaults.
+Use <code>--json</code> to show the settings in json format.</p>
+<h4 id="delete">delete</h4>
+<pre><code class="language-bash">npm config delete key [key ...]
+</code></pre>
+<p>Deletes the specified keys from all configuration files.</p>
+<h4 id="edit2">edit</h4>
+<pre><code class="language-bash">npm config edit
+</code></pre>
+<p>Opens the config file in an editor.
+Use the <code>--global</code> flag to edit the global config.</p>
+<h4 id="fix">fix</h4>
+<pre><code class="language-bash">npm config fix
+</code></pre>
+<p>Attempts to repair invalid configuration items.
+Usually this means attaching authentication config (i.e.
+<code>_auth</code>, <code>_authToken</code>) to the configured <code>registry</code>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="editor"><code>editor</code></h4>
+<ul>
+<li>Default: The EDITOR or VISUAL environment variables, or
+'%SYSTEMROOT%\notepad.exe' on Windows, or 'vi' on Unix systems</li>
+<li>Type: String</li>
+</ul>
+<p>The command to run for <code>npm edit</code> and <code>npm config edit</code>.</p>
+<h4 id="location"><code>location</code></h4>
+<ul>
+<li>Default: "user" unless <code>--global</code> is passed, which will also set this value
+to "global"</li>
+<li>Type: "global", "user", or "project"</li>
+</ul>
+<p>When passed to <code>npm config</code> this refers to which config file to use.</p>
+<p>When set to "global" mode, packages are installed into the <code>prefix</code> folder
+instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm.html">npm</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-config.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-dedupe.html b/node/node_modules/npm/docs/output/commands/npm-dedupe.html
new file mode 100644
index 0000000000000000000000000000000000000000..bc5cc47a14caaf241662e1de1a1204fbd017b209
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-dedupe.html
@@ -0,0 +1,450 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-dedupe</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-dedupe----11130">
+    <span>npm-dedupe</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Reduce duplication in the package tree</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm dedupe
+
+alias: ddp
+</code></pre>
+<h3 id="description">Description</h3>
+<p>Searches the local package tree and attempts to simplify the overall structure by moving dependencies further up the tree, where they can be more effectively shared by multiple dependent packages.</p>
+<p>For example, consider this dependency graph:</p>
+<pre><code>a
++-- b &lt;-- depends on c@1.0.x
+|   `-- c@1.0.3
+`-- d &lt;-- depends on c@~1.0.9
+    `-- c@1.0.10
+</code></pre>
+<p>In this case, <code>npm dedupe</code> will transform the tree to:</p>
+<pre><code class="language-bash">a
++-- b
++-- d
+`-- c@1.0.10
+</code></pre>
+<p>Because of the hierarchical nature of node's module lookup, b and d will both get their dependency met by the single c package at the root level of the tree.</p>
+<p>In some cases, you may have a dependency graph like this:</p>
+<pre><code>a
++-- b &lt;-- depends on c@1.0.x
++-- c@1.0.3
+`-- d &lt;-- depends on c@1.x
+    `-- c@1.9.9
+</code></pre>
+<p>During the installation process, the <code>c@1.0.3</code> dependency for <code>b</code> was placed in the root of the tree.
+Though <code>d</code>'s dependency on <code>c@1.x</code> could have been satisfied by <code>c@1.0.3</code>, the newer <code>c@1.9.9</code> dependency was used, because npm favors updates by default, even when doing so causes duplication.</p>
+<p>Running <code>npm dedupe</code> will cause npm to note the duplication and re-evaluate, deleting the nested <code>c</code> module, because the one in the root is sufficient.</p>
+<p>To prefer deduplication over novelty during the installation process, run <code>npm install --prefer-dedupe</code> or <code>npm config set prefer-dedupe true</code>.</p>
+<p>Arguments are ignored.
+Dedupe always acts on the entire tree.</p>
+<p>Note that this operation transforms the dependency tree, but will never result in new modules being installed.</p>
+<p>Using <code>npm find-dupes</code> will run the command in <code>--dry-run</code> mode.</p>
+<p>Note: <code>npm dedupe</code> will never update the semver values of direct dependencies in your project <code>package.json</code>, if you want to update values in <code>package.json</code> you can run: <code>npm update --save</code> instead.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-find-dupes.html">npm find-dupes</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+<li><a href="../commands/npm-update.html">npm update</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-dedupe.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-deprecate.html b/node/node_modules/npm/docs/output/commands/npm-deprecate.html
new file mode 100644
index 0000000000000000000000000000000000000000..8311786735da7dd916da7ffb9ae40ba0677d7ae1
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-deprecate.html
@@ -0,0 +1,267 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-deprecate</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-deprecate----11130">
+    <span>npm-deprecate</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Deprecate a version of a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm deprecate &lt;package-spec&gt; &lt;message&gt;
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>This command will update the npm registry entry for a package, providing a deprecation warning to all who attempt to install it.</p>
+<p>It works on <a href="https://semver.npmjs.com/">version ranges</a> as well as specific versions, so you can do something like this:</p>
+<pre><code class="language-bash">npm deprecate my-thing@"&lt; 0.2.3" "critical bug fixed in v0.2.3"
+</code></pre>
+<p>SemVer ranges passed to this command are interpreted such that they <em>do</em> include prerelease versions.
+For example:</p>
+<pre><code class="language-bash">npm deprecate my-thing@1.x "1.x is no longer supported"
+</code></pre>
+<p>In this case, a version <code>my-thing@1.0.0-beta.0</code> will also be deprecated.</p>
+<p>You must be the package owner to deprecate something.
+See the <code>owner</code> and <code>adduser</code> help topics.</p>
+<p>To un-deprecate a package, specify an empty string (<code>""</code>) for the <code>message</code> argument.
+Note that you must use double quotes with no space between them to format an empty string.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-deprecate.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-diff.html b/node/node_modules/npm/docs/output/commands/npm-diff.html
new file mode 100644
index 0000000000000000000000000000000000000000..a75df6faac2bc8d17b21665a89b2a061aa74302d
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-diff.html
@@ -0,0 +1,415 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-diff</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-diff----11130">
+    <span>npm-diff</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">The registry diff command</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm diff [...&lt;paths&gt;]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>Similar to its <code>git diff</code> counterpart, this command will print diff patches of files for packages published to the npm registry.</p>
+<ul>
+<li>
+<p><code>npm diff --diff=&lt;spec-a&gt; --diff=&lt;spec-b&gt;</code></p>
+<p>Compares two package versions using their registry specifiers, e.g: <code>npm diff --diff=pkg@1.0.0 --diff=pkg@^2.0.0</code>.
+It's also possible to compare across forks of any package, e.g: <code>npm diff --diff=pkg@1.0.0 --diff=pkg-fork@1.0.0</code>.</p>
+<p>Any valid spec can be used, so that it's also possible to compare directories or git repositories, e.g: <code>npm diff --diff=pkg@latest --diff=./packages/pkg</code></p>
+<p>Here's an example comparing two different versions of a package named <code>abbrev</code> from the registry:</p>
+<pre><code class="language-bash">npm diff --diff=abbrev@1.1.0 --diff=abbrev@1.1.1
+</code></pre>
+<p>On success, output looks like:</p>
+<pre><code class="language-bash">diff --git a/package.json b/package.json
+index v1.1.0..v1.1.1 100644
+--- a/package.json
++++ b/package.json
+@@ -1,6 +1,6 @@
+ {
+   "name": "abbrev",
+-  "version": "1.1.0",
++  "version": "1.1.1",
+   "description": "Like ruby's abbrev module, but in js",
+   "author": "Isaac Z. Schlueter &lt;i@izs.me&gt;",
+   "main": "abbrev.js",
+</code></pre>
+<p>Given the flexible nature of npm specs, you can also target local directories or git repos just like when using <code>npm install</code>:</p>
+<pre><code class="language-bash">npm diff --diff=https://github.com/npm/libnpmdiff --diff=./local-path
+</code></pre>
+<p>In the example above we can compare the contents from the package installed from the git repo at <code>github.com/npm/libnpmdiff</code> with the contents of the <code>./local-path</code> that contains a valid package, such as a modified copy of the original.</p>
+</li>
+<li>
+<p><code>npm diff</code> (in a package directory, no arguments):</p>
+<p>If the package is published to the registry, <code>npm diff</code> will fetch the tarball version tagged as <code>latest</code> (this value can be configured using the <code>tag</code> option) and proceed to compare the contents of files present in that tarball, with the current files in your local file system.</p>
+<p>This workflow provides a handy way for package authors to see what package-tracked files have been changed in comparison with the latest published version of that package.</p>
+</li>
+<li>
+<p><code>npm diff --diff=&lt;pkg-name&gt;</code> (in a package directory):</p>
+<p>When using a single package name (with no version or tag specifier) as an argument, <code>npm diff</code> will work in a similar way to <a href="npm-outdated"><code>npm-outdated</code></a> and reach for the registry to figure out what current published version of the package named <code>&lt;pkg-name&gt;</code> will satisfy its dependent declared semver-range.
+Once that specific version is known <code>npm diff</code> will print diff patches comparing the current version of <code>&lt;pkg-name&gt;</code> found in the local file system with that specific version returned by the registry.</p>
+<p>Given a package named <code>abbrev</code> that is currently installed:</p>
+<pre><code class="language-bash">npm diff --diff=abbrev
+</code></pre>
+<p>That will request from the registry its most up to date version and will print a diff output comparing the currently installed version to this newer one if the version numbers are not the same.</p>
+</li>
+<li>
+<p><code>npm diff --diff=&lt;spec-a&gt;</code> (in a package directory):</p>
+<p>Similar to using only a single package name, it's also possible to declare a full registry specifier version if you wish to compare the local version of an installed package with the specific version/tag/semver-range provided in <code>&lt;spec-a&gt;</code>.</p>
+<p>An example: assuming <code>pkg@1.0.0</code> is installed in the current <code>node_modules</code> folder, running:</p>
+<pre><code class="language-bash">npm diff --diff=pkg@2.0.0
+</code></pre>
+<p>It will effectively be an alias to
+<code>npm diff --diff=pkg@1.0.0 --diff=pkg@2.0.0</code>.</p>
+</li>
+<li>
+<p><code>npm diff --diff=&lt;semver-a&gt; [--diff=&lt;semver-b&gt;]</code> (in a package directory):</p>
+<p>Using <code>npm diff</code> along with semver-valid version numbers is a shorthand to compare different versions of the current package.</p>
+<p>It needs to be run from a package directory, such that for a package named <code>pkg</code> running <code>npm diff --diff=1.0.0 --diff=1.0.1</code> is the same as running <code>npm diff --diff=pkg@1.0.0 --diff=pkg@1.0.1</code>.</p>
+<p>If only a single argument <code>&lt;version-a&gt;</code> is provided, then the current local file system is going to be compared against that version.</p>
+<p>Here's an example comparing two specific versions (published to the configured registry) of the current project directory:</p>
+<pre><code class="language-bash">npm diff --diff=1.0.0 --diff=1.1.0
+</code></pre>
+</li>
+</ul>
+<p>Note that tag names are not valid <code>--diff</code> argument values, if you wish to compare to a published tag, you must use the <code>pkg@tagname</code> syntax.</p>
+<h4 id="filtering-files">Filtering files</h4>
+<p>It's possible to also specify positional arguments using file names or globs pattern matching in order to limit the result of diff patches to only a subset of files for a given package, e.g:</p>
+<pre><code class="language-bash">npm diff --diff=pkg@2 ./lib/ CHANGELOG.md
+</code></pre>
+<p>In the example above the diff output is only going to print contents of files located within the folder <code>./lib/</code> and changed lines of code within the <code>CHANGELOG.md</code> file.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="diff"><code>diff</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Define arguments to compare in <code>npm diff</code>.</p>
+<h4 id="diff-name-only"><code>diff-name-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prints only filenames when using <code>npm diff</code>.</p>
+<h4 id="diff-unified"><code>diff-unified</code></h4>
+<ul>
+<li>Default: 3</li>
+<li>Type: Number</li>
+</ul>
+<p>The number of lines of context to print in <code>npm diff</code>.</p>
+<h4 id="diff-ignore-all-space"><code>diff-ignore-all-space</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Ignore whitespace when comparing lines in <code>npm diff</code>.</p>
+<h4 id="diff-no-prefix"><code>diff-no-prefix</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Do not show any source or destination prefix in <code>npm diff</code> output.</p>
+<p>Note: this causes <code>npm diff</code> to ignore the <code>--diff-src-prefix</code> and
+<code>--diff-dst-prefix</code> configs.</p>
+<h4 id="diff-src-prefix"><code>diff-src-prefix</code></h4>
+<ul>
+<li>Default: "a/"</li>
+<li>Type: String</li>
+</ul>
+<p>Source prefix to be used in <code>npm diff</code> output.</p>
+<h4 id="diff-dst-prefix"><code>diff-dst-prefix</code></h4>
+<ul>
+<li>Default: "b/"</li>
+<li>Type: String</li>
+</ul>
+<p>Destination prefix to be used in <code>npm diff</code> output.</p>
+<h4 id="diff-text"><code>diff-text</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Treat all files as text in <code>npm diff</code>.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="tag"><code>tag</code></h4>
+<ul>
+<li>Default: "latest"</li>
+<li>Type: String</li>
+</ul>
+<p>If you ask npm to install a package and don't tell it a specific version,
+then it will install the specified tag.</p>
+<p>It is the tag added to the package@version specified in the <code>npm dist-tag add</code> command, if no explicit tag is given.</p>
+<p>When used by the <code>npm diff</code> command, this is the tag used to fetch the
+tarball that will be compared with the local files by default.</p>
+<p>If used in the <code>npm publish</code> command, this is the tag that will be added to
+the package submitted to the registry.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h2 id="see-also">See Also</h2>
+<ul>
+<li><a href="../commands/npm-outdated.html">npm outdated</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-diff.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-dist-tag.html b/node/node_modules/npm/docs/output/commands/npm-dist-tag.html
new file mode 100644
index 0000000000000000000000000000000000000000..8f2af21253f85b059159ebfe4d9b69b3348c5331
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-dist-tag.html
@@ -0,0 +1,318 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-dist-tag</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-dist-tag----11130">
+    <span>npm-dist-tag</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Modify package distribution tags</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#purpose">Purpose</a></li><li><a href="#caveats">Caveats</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm dist-tag add &lt;package-spec (with version)&gt; [&lt;tag&gt;]
+npm dist-tag rm &lt;package-spec&gt; &lt;tag&gt;
+npm dist-tag ls [&lt;package-spec&gt;]
+
+alias: dist-tags
+</code></pre>
+<h3 id="description">Description</h3>
+<p>Add, remove, and enumerate distribution tags on a package:</p>
+<ul>
+<li>
+<p>add: Tags the specified version of the package with the specified tag, or the <a href="../using-npm/config#tag.html"><code>--tag</code> config</a> if not specified.
+If you have two-factor authentication on auth-and-writes then you’ll need to include a one-time password on the command line with <code>--otp &lt;one-time password&gt;</code>, or go through a second factor flow based on your <code>authtype</code>.</p>
+</li>
+<li>
+<p>rm: Clear a tag that is no longer in use from the package.
+If you have two-factor authentication on auth-and-writes then you’ll need to include a one-time password on the command line with <code>--otp &lt;one-time password&gt;</code>, or go through a second factor flow based on your <code>authtype</code></p>
+</li>
+<li>
+<p>ls: Show all of the dist-tags for a package, defaulting to the package in the current prefix.
+This is the default action if none is specified.</p>
+</li>
+</ul>
+<p>A tag can be used when installing packages as a reference to a version instead of using a specific version number:</p>
+<pre><code class="language-bash">npm install &lt;name&gt;@&lt;tag&gt;
+</code></pre>
+<p>When installing dependencies, a preferred tagged version may be specified:</p>
+<pre><code class="language-bash">npm install --tag &lt;tag&gt;
+</code></pre>
+<p>(This also applies to any other commands that resolve and install dependencies, such as <code>npm dedupe</code>, <code>npm update</code>, and <code>npm audit fix</code>.)</p>
+<p>Publishing a package sets the <code>latest</code> tag to the published version unless the <code>--tag</code> option is used.
+For example, <code>npm publish --tag=beta</code>.</p>
+<p>By default, <code>npm install &lt;pkg&gt;</code> (without any <code>@&lt;version&gt;</code> or <code>@&lt;tag&gt;</code> specifier) installs the <code>latest</code> tag.</p>
+<h3 id="purpose">Purpose</h3>
+<p>Tags can be used to provide an alias instead of version numbers.</p>
+<p>For example, a project might choose to have multiple streams of development and use a different tag for each stream, e.g., <code>stable</code>, <code>beta</code>, <code>dev</code>,
+<code>canary</code>.</p>
+<p>By default, the <code>latest</code> tag is used by npm to identify the current version of a package, and <code>npm install &lt;pkg&gt;</code> (without any <code>@&lt;version&gt;</code> or <code>@&lt;tag&gt;</code> specifier) installs the <code>latest</code> tag.
+Typically, projects only use the <code>latest</code> tag for stable release versions, and use other tags for unstable versions such as prereleases.</p>
+<p>The <code>next</code> tag is used by some projects to identify the upcoming version.</p>
+<p>Other than <code>latest</code>, no tag has any special significance to npm itself.</p>
+<h3 id="caveats">Caveats</h3>
+<p>This command used to be known as <code>npm tag</code>, which only created new tags, and so had a different syntax.</p>
+<p>Tags must share a namespace with version numbers, because they are specified in the same slot: <code>npm install &lt;pkg&gt;@&lt;version&gt;</code> vs <code>npm install &lt;pkg&gt;@&lt;tag&gt;</code>.</p>
+<p>Tags that can be interpreted as valid semver ranges will be rejected.
+For example, <code>v1.4</code> cannot be used as a tag, because it is interpreted by semver as <code>&gt;=1.4.0 &lt;1.5.0</code>.
+See <a href="https://github.com/npm/npm/issues/6082">https://github.com/npm/npm/issues/6082</a>.</p>
+<p>The simplest way to avoid semver problems with tags is to use tags that do not begin with a number or the letter <code>v</code>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-dedupe.html">npm dedupe</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-dist-tag.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-docs.html b/node/node_modules/npm/docs/output/commands/npm-docs.html
new file mode 100644
index 0000000000000000000000000000000000000000..b519c35afe87cc84aca66573af85ac37eb70f396
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-docs.html
@@ -0,0 +1,293 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-docs</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-docs----11130">
+    <span>npm-docs</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Open documentation for a package in a web browser</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#browser"><code>browser</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm docs [&lt;pkgname&gt; [&lt;pkgname&gt; ...]]
+
+alias: home
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command tries to guess at the likely location of a package's documentation URL, and then tries to open it using the <a href="../using-npm/config#browser.html"><code>--browser</code> config</a> param.
+You can pass multiple package names at once.
+If no package name is provided, it will search for a <code>package.json</code> in the current folder and use the <code>name</code> property.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="browser"><code>browser</code></h4>
+<ul>
+<li>Default: macOS: <code>"open"</code>, Windows: <code>"start"</code>, Others: <code>"xdg-open"</code></li>
+<li>Type: null, Boolean, or String</li>
+</ul>
+<p>The browser that is called by npm commands to open websites.</p>
+<p>Set to <code>false</code> to suppress browser behavior and instead print urls to
+terminal.</p>
+<p>Set to <code>true</code> to use default system URL opener.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-view.html">npm view</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-docs.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-doctor.html b/node/node_modules/npm/docs/output/commands/npm-doctor.html
new file mode 100644
index 0000000000000000000000000000000000000000..b785f7b623b4ed63ec3e2686201790b082627911
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-doctor.html
@@ -0,0 +1,282 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-doctor</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-doctor----11130">
+    <span>npm-doctor</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Check the health of your npm environment</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#connecting-to-the-registry"><code>Connecting to the registry</code></a></li><li><a href="#checking-npm-version"><code>Checking npm version</code></a></li><li><a href="#checking-node-version"><code>Checking node version</code></a></li><li><a href="#checking-configured-npm-registry"><code>Checking configured npm registry</code></a></li><li><a href="#checking-for-git-executable-in-path"><code>Checking for git executable in PATH</code></a></li><li><a href="#permissions-checks">Permissions checks</a></li><li><a href="#validate-the-checksums-of-cached-packages">Validate the checksums of cached packages</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm doctor [connection] [registry] [versions] [environment] [permissions] [cache]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p><code>npm doctor</code> runs a set of checks to ensure that your npm installation has what it needs to manage your JavaScript packages.
+npm is mostly a standalone tool, but it does have some basic requirements that must be met:</p>
+<ul>
+<li>Node.js and git must be executable by npm.</li>
+<li>The primary npm registry, <code>registry.npmjs.com</code>, or another service that uses the registry API, is available.</li>
+<li>The directories that npm uses, <code>node_modules</code> (both locally and globally), exist and can be written by the current user.</li>
+<li>The npm cache exists, and the package tarballs within it aren't corrupt.</li>
+</ul>
+<p>Without all of these working properly, npm may not work properly.
+Many issues are often attributable to things that are outside npm's code base, so <code>npm doctor</code> confirms that the npm installation is in a good state.</p>
+<p>Also, in addition to this, there are also very many issue reports due to using old versions of npm.
+Since npm is constantly improving, running <code>npm@latest</code> is better than an old version.</p>
+<p><code>npm doctor</code> verifies the following items in your environment, and if there are any recommended changes, it will display them.
+By default npm runs all of these checks.
+You can limit what checks are ran by specifying them as extra arguments.</p>
+<h4 id="connecting-to-the-registry"><code>Connecting to the registry</code></h4>
+<p>By default, npm installs from the primary npm registry,
+<code>registry.npmjs.org</code>.
+<code>npm doctor</code> hits a special connection testing endpoint within the registry.
+This can also be checked with <code>npm ping</code>.
+If this check fails, you may be using a proxy that needs to be configured, or may need to talk to your IT staff to get access over HTTPS to <code>registry.npmjs.org</code>.</p>
+<p>This check is done against whichever registry you've configured (you can see what that is by running <code>npm config get registry</code>), and if you're using a private registry that doesn't support the <code>/whoami</code> endpoint supported by the primary registry, this check may fail.</p>
+<h4 id="checking-npm-version"><code>Checking npm version</code></h4>
+<p>While Node.js may come bundled with a particular version of npm, it's the policy of the CLI team that we recommend all users run <code>npm@latest</code> if they can.
+As the CLI is maintained by a small team of contributors, there are only resources for a single line of development, so npm's own long-term support releases typically only receive critical security and regression fixes.
+The team believes that the latest tested version of npm is almost always likely to be the most functional and defect-free version of npm.</p>
+<h4 id="checking-node-version"><code>Checking node version</code></h4>
+<p>For most users, in most circumstances, the best version of Node will be the latest long-term support (LTS) release.
+Those of you who want access to new ECMAscript features or bleeding-edge changes to Node's standard library may be running a newer version, and some may be required to run an older version of Node because of enterprise change control policies.
+That's OK!
+But in general, the npm team recommends that most users run Node.js LTS.</p>
+<h4 id="checking-configured-npm-registry"><code>Checking configured npm registry</code></h4>
+<p>You may be installing from private package registries for your project or company.
+That's great! Others may be following tutorials or StackOverflow questions in an effort to troubleshoot problems you may be having.
+Sometimes, this may entail changing the registry you're pointing at.
+This part of <code>npm doctor</code> just lets you, and maybe whoever's helping you with support, know that you're not using the default registry.</p>
+<h4 id="checking-for-git-executable-in-path"><code>Checking for git executable in PATH</code></h4>
+<p>While it's documented in the README, it may not be obvious that npm needs Git installed to do many of the things that it does.
+Also, in some cases –&nbsp;especially on Windows –&nbsp;you may have Git set up in such a way that it's not accessible via your <code>PATH</code> so that npm can find it.
+This check ensures that Git is available.</p>
+<h4 id="permissions-checks">Permissions checks</h4>
+<ul>
+<li>Your cache must be readable and writable by the user running npm.</li>
+<li>Global package binaries must be writable by the user running npm.</li>
+<li>Your local <code>node_modules</code> path, if you're running <code>npm doctor</code> with a project directory, must be readable and writable by the user running npm.</li>
+</ul>
+<h4 id="validate-the-checksums-of-cached-packages">Validate the checksums of cached packages</h4>
+<p>When an npm package is published, the publishing process generates a checksum that npm uses at install time to verify that the package didn't get corrupted in transit.
+<code>npm doctor</code> uses these checksums to validate the package tarballs in your local cache (you can see where that cache is located with <code>npm config get cache</code>).
+In the event that there are corrupt packages in your cache, you should probably run <code>npm cache clean -f</code> and reset the cache.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-bugs.html">npm bugs</a></li>
+<li><a href="../commands/npm-help.html">npm help</a></li>
+<li><a href="../commands/npm-ping.html">npm ping</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-doctor.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-edit.html b/node/node_modules/npm/docs/output/commands/npm-edit.html
new file mode 100644
index 0000000000000000000000000000000000000000..a648b80a31379d1d54f5199c3ee26a4c90be1352
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-edit.html
@@ -0,0 +1,238 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-edit</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-edit----11130">
+    <span>npm-edit</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Edit an installed package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#editor"><code>editor</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm edit &lt;pkg&gt;[/&lt;subpkg&gt;...]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Selects a dependency in the current project and opens the package folder in the default editor (or whatever you've configured as the npm <code>editor</code> config -- see <a href="npm-config"><code>npm-config</code></a>.)</p>
+<p>After it has been edited, the package is rebuilt so as to pick up any changes in compiled packages.</p>
+<p>For instance, you can do <code>npm install connect</code> to install connect into your package, and then <code>npm edit connect</code> to make a few changes to your locally installed copy.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="editor"><code>editor</code></h4>
+<ul>
+<li>Default: The EDITOR or VISUAL environment variables, or
+'%SYSTEMROOT%\notepad.exe' on Windows, or 'vi' on Unix systems</li>
+<li>Type: String</li>
+</ul>
+<p>The command to run for <code>npm edit</code> and <code>npm config edit</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-explore.html">npm explore</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-edit.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-exec.html b/node/node_modules/npm/docs/output/commands/npm-exec.html
new file mode 100644
index 0000000000000000000000000000000000000000..d95fb8bce9096ed5b15a15a7227c98ff592373cb
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-exec.html
@@ -0,0 +1,436 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-exec</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-exec----11130">
+    <span>npm-exec</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Run a command from a local or remote npm package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#npx-vs-npm-exec"><code>npx</code> vs <code>npm exec</code></a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#package"><code>package</code></a></li><li><a href="#call"><code>call</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#examples">Examples</a></li><li><a href="#workspaces-support">Workspaces support</a></li><ul><li><a href="#filtering-workspaces">Filtering workspaces</a></li></ul><li><a href="#compatibility-with-older-npx-versions">Compatibility with Older npx Versions</a></li><li><a href="#a-note-on-caching">A note on caching</a></li><ul><li><a href="#prefer-online">prefer-online</a></li><li><a href="#prefer-offline">prefer-offline</a></li><li><a href="#offline">offline</a></li><li><a href="#workspace2">workspace</a></li><li><a href="#workspaces2">workspaces</a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm exec -- &lt;pkg&gt;[@&lt;version&gt;] [args...]
+npm exec --package=&lt;pkg&gt;[@&lt;version&gt;] -- &lt;cmd&gt; [args...]
+npm exec -c '&lt;cmd&gt; [args...]'
+npm exec --package=foo -c '&lt;cmd&gt; [args...]'
+
+alias: x
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command allows you to run an arbitrary command from an npm package (either one installed locally, or fetched remotely), in a similar context as running it via <code>npm run</code>.</p>
+<p>Run without positional arguments or <code>--call</code>, this allows you to interactively run commands in the same sort of shell environment that <code>package.json</code> scripts are run.
+Interactive mode is not supported in CI environments when standard input is a TTY, to prevent hangs.</p>
+<p>Whatever packages are specified by the <code>--package</code> option will be provided in the <code>PATH</code> of the executed command, along with any locally installed package executables.
+The <code>--package</code> option may be specified multiple times, to execute the supplied command in an environment where all specified packages are available.</p>
+<p>If any requested packages are not present in the local project dependencies, then a prompt is printed, which can be suppressed by providing either <code>--yes</code> or <code>--no</code>.
+When standard input is not a TTY or a CI environment is detected, <code>--yes</code> is assumed.
+The requested packages are installed to a folder in the npm cache, which is added to the <code>PATH</code> environment variable in the executed process.</p>
+<p>Package names provided without a specifier will be matched with whatever version exists in the local project.
+Package names with a specifier will only be considered a match if they have the exact same name and version as the local dependency.</p>
+<p>If no <code>-c</code> or <code>--call</code> option is provided, then the positional arguments are used to generate the command string.
+If no <code>--package</code> options are provided, then npm will attempt to determine the executable name from the package specifier provided as the first positional argument according to the following heuristic:</p>
+<ul>
+<li>If the package has a single entry in its <code>bin</code> field in <code>package.json</code>, or if all entries are aliases of the same command, then that command will be used.</li>
+<li>If the package has multiple <code>bin</code> entries, and one of them matches the unscoped portion of the <code>name</code> field, then that command will be used.</li>
+<li>If this does not result in exactly one option (either because there are no bin entries, or none of them match the <code>name</code> of the package), then <code>npm exec</code> exits with an error.</li>
+</ul>
+<p>To run a binary <em>other than</em> the named binary, specify one or more <code>--package</code> options, which will prevent npm from inferring the package from the first command argument.</p>
+<h3 id="npx-vs-npm-exec"><code>npx</code> vs <code>npm exec</code></h3>
+<p>When run via the <code>npx</code> binary, all flags and options <em>must</em> be set prior to any positional arguments.
+When run via <code>npm exec</code>, a double-hyphen <code>--</code> flag can be used to suppress npm's parsing of switches and options that should be sent to the executed command.</p>
+<p>For example:</p>
+<pre><code>$ npx foo@latest bar --package=@npmcli/foo
+</code></pre>
+<p>In this case, npm will resolve the <code>foo</code> package name, and run the following command:</p>
+<pre><code>$ foo bar --package=@npmcli/foo
+</code></pre>
+<p>Since the <code>--package</code> option comes <em>after</em> the positional arguments, it is treated as an argument to the executed command.</p>
+<p>In contrast, due to npm's argument parsing logic, running this command is different:</p>
+<pre><code>$ npm exec foo@latest bar --package=@npmcli/foo
+</code></pre>
+<p>In this case, npm will parse the <code>--package</code> option first, resolving the <code>@npmcli/foo</code> package.
+Then, it will execute the following command in that context:</p>
+<pre><code>$ foo@latest bar
+</code></pre>
+<p>The double-hyphen character is recommended to explicitly tell npm to stop parsing command line options and switches.
+The following command would thus be equivalent to the <code>npx</code> command above:</p>
+<pre><code>$ npm exec -- foo@latest bar --package=@npmcli/foo
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="package"><code>package</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>The package or packages to install for <a href="../commands/npm-exec.html"><code>npm exec</code></a></p>
+<h4 id="call"><code>call</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>Optional companion option for <code>npm exec</code>, <code>npx</code> that allows for specifying a
+custom command to be run along with the installed packages.</p>
+<pre><code class="language-bash">npm exec --package yo --package generator-node --call "yo node"
+</code></pre>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="examples">Examples</h3>
+<p>Run the version of <code>tap</code> in the local dependencies, with the provided arguments:</p>
+<pre><code>$ npm exec -- tap --bail test/foo.js
+$ npx tap --bail test/foo.js
+</code></pre>
+<p>Run a command <em>other than</em> the command whose name matches the package name by specifying a <code>--package</code> option:</p>
+<pre><code>$ npm exec --package=foo -- bar --bar-argument
+# ~ or ~
+$ npx --package=foo bar --bar-argument
+</code></pre>
+<p>Run an arbitrary shell script, in the context of the current project:</p>
+<pre><code>$ npm x -c 'eslint &amp;&amp; say "hooray, lint passed"'
+$ npx -c 'eslint &amp;&amp; say "hooray, lint passed"'
+</code></pre>
+<h3 id="workspaces-support">Workspaces support</h3>
+<p>You may use the <a href="../using-npm/config#workspace.html"><code>workspace</code></a> or <a href="../using-npm/config#workspaces.html"><code>workspaces</code></a> configs in order to run an arbitrary command from an npm package (either one installed locally, or fetched remotely) in the context of the specified workspaces.
+If no positional argument or <code>--call</code> option is provided, it will open an interactive subshell in the context of each of these configured workspaces one at a time.</p>
+<p>Given a project with configured workspaces, e.g:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   +-- b
+   |   `-- package.json
+   `-- c
+       `-- package.json
+</code></pre>
+<p>Assuming the workspace configuration is properly set up at the root level <code>package.json</code> file.
+e.g:</p>
+<pre><code>{
+    "workspaces": [ "./packages/*" ]
+}
+</code></pre>
+<p>You can execute an arbitrary command from a package in the context of each of the configured workspaces when using the <a href="../using-npm/config#workspace.html"><code>workspaces</code> config options</a>, in this example we're using <strong>eslint</strong> to lint any js file found within each workspace folder:</p>
+<pre><code>npm exec --ws -- eslint ./*.js
+</code></pre>
+<h4 id="filtering-workspaces">Filtering workspaces</h4>
+<p>It's also possible to execute a command in a single workspace using the <code>workspace</code> config along with a name or directory path:</p>
+<pre><code>npm exec --workspace=a -- eslint ./*.js
+</code></pre>
+<p>The <code>workspace</code> config can also be specified multiple times in order to run a specific script in the context of multiple workspaces.
+When defining values for the <code>workspace</code> config in the command line, it also possible to use <code>-w</code> as a shorthand, e.g:</p>
+<pre><code>npm exec -w a -w b -- eslint ./*.js
+</code></pre>
+<p>This last command will run the <code>eslint</code> command in both <code>./packages/a</code> and
+<code>./packages/b</code> folders.</p>
+<h3 id="compatibility-with-older-npx-versions">Compatibility with Older npx Versions</h3>
+<p>The <code>npx</code> binary was rewritten in npm v7.0.0, and the standalone <code>npx</code> package deprecated at that time.
+<code>npx</code> uses the <code>npm exec</code> command instead of a separate argument parser and install process, with some affordances to maintain backwards compatibility with the arguments it accepted in previous versions.</p>
+<p>This resulted in some shifts in its functionality:</p>
+<ul>
+<li>Any <code>npm</code> config value may be provided.</li>
+<li>To prevent security and user-experience problems from mistyping package
+names, <code>npx</code> prompts before installing anything.
+Suppress this prompt with the <code>-y</code> or <code>--yes</code> option.</li>
+<li>The <code>--no-install</code> option is deprecated, and will be converted to <code>--no</code>.</li>
+<li>Shell fallback functionality is removed, as it is not advisable.</li>
+<li>The <code>-p</code> argument is a shorthand for <code>--parseable</code> in npm, but shorthand for <code>--package</code> in npx.
+This is maintained, but only for the <code>npx</code> executable.</li>
+<li>The <code>--ignore-existing</code> option is removed.
+Locally installed bins are always present in the executed process <code>PATH</code>.</li>
+<li>The <code>--npm</code> option is removed.
+<code>npx</code> will always use the <code>npm</code> it ships with.</li>
+<li>The <code>--node-arg</code> and <code>-n</code> options are removed.</li>
+<li>The <code>--always-spawn</code> option is redundant, and thus removed.</li>
+<li>The <code>--shell</code> option is replaced with <code>--script-shell</code>, but maintained in the <code>npx</code> executable for backwards compatibility.</li>
+</ul>
+<h3 id="a-note-on-caching">A note on caching</h3>
+<p>The npm cli utilizes its internal package cache when using the package name specified.
+You can use the following to change how and when the cli uses this cache.
+See <a href="../commands/npm-cache.html"><code>npm cache</code></a> for more on how the cache works.</p>
+<h4 id="prefer-online">prefer-online</h4>
+<p>Forces staleness checks for packages, making the cli look for updates immediately even if the package is already in the cache.</p>
+<h4 id="prefer-offline">prefer-offline</h4>
+<p>Bypasses staleness checks for packages.
+Missing data will still be requested from the server.
+To force full offline mode, use <code>offline</code>.</p>
+<h4 id="offline">offline</h4>
+<p>Forces full offline mode.
+Any packages not locally cached will result in an error.</p>
+<h4 id="workspace2">workspace</h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result to selecting all of the nested workspaces)</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces2">workspaces</h4>
+<ul>
+<li>Alias: <code>--ws</code></li>
+<li>Type: Boolean</li>
+<li>Default: <code>false</code></li>
+</ul>
+<p>Run scripts in the context of all configured workspaces for the current project.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+<li><a href="../commands/npm-start.html">npm start</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+<li><a href="../commands/npm-stop.html">npm stop</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/workspaces.html">npm workspaces</a></li>
+<li><a href="../commands/npx.html">npx</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-exec.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-explain.html b/node/node_modules/npm/docs/output/commands/npm-explain.html
new file mode 100644
index 0000000000000000000000000000000000000000..3ff39f30ba05a43c9fa4773949b5abb075d78f00
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-explain.html
@@ -0,0 +1,291 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-explain</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-explain----11130">
+    <span>npm-explain</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Explain installed packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#json"><code>json</code></a></li><li><a href="#workspace"><code>workspace</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm explain &lt;package-spec&gt;
+
+alias: why
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command will print the chain of dependencies causing a given package to be installed in the current project.</p>
+<p>If one or more package specs are provided, then only packages matching one of the specifiers will have their relationships explained.</p>
+<p>The package spec can also refer to a folder within <code>./node_modules</code></p>
+<p>For example, running <code>npm explain glob</code> within npm's source tree will show:</p>
+<pre><code class="language-bash">glob@7.1.6
+node_modules/glob
+  glob@"^7.1.4" from the root project
+
+glob@7.1.1 dev
+node_modules/tacks/node_modules/glob
+  glob@"^7.0.5" from rimraf@2.6.2
+  node_modules/tacks/node_modules/rimraf
+    rimraf@"^2.6.2" from tacks@1.3.0
+    node_modules/tacks
+      dev tacks@"^1.3.0" from the root project
+</code></pre>
+<p>To explain just the package residing at a specific folder, pass that as the argument to the command.
+This can be useful when trying to figure out exactly why a given dependency is being duplicated to satisfy conflicting version requirements within the project.</p>
+<pre><code class="language-bash">$ npm explain node_modules/nyc/node_modules/find-up
+find-up@3.0.0 dev
+node_modules/nyc/node_modules/find-up
+  find-up@"^3.0.0" from nyc@14.1.1
+  node_modules/nyc
+    nyc@"^14.1.1" from tap@14.10.8
+    node_modules/tap
+      dev tap@"^14.10.8" from the root project
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-link.html">npm link</a></li>
+<li><a href="../commands/npm-prune.html">npm prune</a></li>
+<li><a href="../commands/npm-outdated.html">npm outdated</a></li>
+<li><a href="../commands/npm-update.html">npm update</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-explain.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-explore.html b/node/node_modules/npm/docs/output/commands/npm-explore.html
new file mode 100644
index 0000000000000000000000000000000000000000..a83b633b57a88bf757dd7d94641c7fb74cfc9fbe
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-explore.html
@@ -0,0 +1,240 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-explore</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-explore----11130">
+    <span>npm-explore</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Browse an installed package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#shell"><code>shell</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm explore &lt;pkg&gt; [ -- &lt;command&gt;]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Spawn a subshell in the directory of the installed package specified.</p>
+<p>If a command is specified, then it is run in the subshell, which then immediately terminates.</p>
+<p>This is particularly handy in the case of git submodules in the <code>node_modules</code> folder:</p>
+<pre><code class="language-bash">npm explore some-dependency -- git pull origin master
+</code></pre>
+<p>Note that the package is <em>not</em> automatically rebuilt afterwards, so be sure to use <code>npm rebuild &lt;pkg&gt;</code> if you make any changes.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="shell"><code>shell</code></h4>
+<ul>
+<li>Default: SHELL environment variable, or "bash" on Posix, or "cmd.exe" on
+Windows</li>
+<li>Type: String</li>
+</ul>
+<p>The shell to run for the <code>npm explore</code> command.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-edit.html">npm edit</a></li>
+<li><a href="../commands/npm-rebuild.html">npm rebuild</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-explore.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-find-dupes.html b/node/node_modules/npm/docs/output/commands/npm-find-dupes.html
new file mode 100644
index 0000000000000000000000000000000000000000..f032270df1eba24d078db6bb0cd6e6d18bff9966
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-find-dupes.html
@@ -0,0 +1,393 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-find-dupes</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-find-dupes----11130">
+    <span>npm-find-dupes</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Find duplication in the package tree</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm find-dupes
+</code></pre>
+<h3 id="description">Description</h3>
+<p>Runs <code>npm dedupe</code> in <code>--dry-run</code> mode, making npm only output the duplications, without actually changing the package tree.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-dedupe.html">npm dedupe</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+<li><a href="../commands/npm-update.html">npm update</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-find-dupes.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-fund.html b/node/node_modules/npm/docs/output/commands/npm-fund.html
new file mode 100644
index 0000000000000000000000000000000000000000..038be21217d5c8fd6da5873404255d688ce5d94b
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-fund.html
@@ -0,0 +1,311 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-fund</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-fund----11130">
+    <span>npm-fund</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Retrieve funding information</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm fund [&lt;package-spec&gt;]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command retrieves information on how to fund the dependencies of a given project.
+If no package name is provided, it will list all dependencies that are looking for funding in a tree structure, listing the type of funding and the url to visit.
+If a package name is provided then it tries to open its funding url using the <a href="../using-npm/config#browser.html"><code>--browser</code> config</a> param; if there are multiple funding sources for the package, the user will be instructed to pass the
+<code>--which</code> option to disambiguate.</p>
+<p>The list will avoid duplicated entries and will stack all packages that share the same url as a single entry.
+Thus, the list does not have the same shape of the output from <code>npm ls</code>.</p>
+<h4 id="example">Example</h4>
+<h3 id="workspaces-support">Workspaces support</h3>
+<p>It's possible to filter the results to only include a single workspace and its dependencies using the <a href="../using-npm/config#workspace.html"><code>workspace</code> config</a> option.</p>
+<h4 id="example2">Example:</h4>
+<p>Here's an example running <code>npm fund</code> in a project with a configured workspace <code>a</code>:</p>
+<pre><code class="language-bash">$ npm fund
+test-workspaces-fund@1.0.0
++-- https://example.com/a
+| | `-- a@1.0.0
+| `-- https://example.com/maintainer
+|     `-- foo@1.0.0
++-- https://example.com/npmcli-funding
+|   `-- @npmcli/test-funding
+`-- https://example.com/org
+    `-- bar@2.0.0
+</code></pre>
+<p>And here is an example of the expected result when filtering only by a specific workspace <code>a</code> in the same project:</p>
+<pre><code class="language-bash">$ npm fund -w a
+test-workspaces-fund@1.0.0
+`-- https://example.com/a
+  | `-- a@1.0.0
+  `-- https://example.com/maintainer
+      `-- foo@2.0.0
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="browser"><code>browser</code></h4>
+<ul>
+<li>Default: macOS: <code>"open"</code>, Windows: <code>"start"</code>, Others: <code>"xdg-open"</code></li>
+<li>Type: null, Boolean, or String</li>
+</ul>
+<p>The browser that is called by npm commands to open websites.</p>
+<p>Set to <code>false</code> to suppress browser behavior and instead print urls to
+terminal.</p>
+<p>Set to <code>true</code> to use default system URL opener.</p>
+<h4 id="unicode"><code>unicode</code></h4>
+<ul>
+<li>Default: false on windows, true on mac/unix systems with a unicode locale,
+as defined by the <code>LC_ALL</code>, <code>LC_CTYPE</code>, or <code>LANG</code> environment variables.</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="which"><code>which</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If there are multiple funding sources, which 1-indexed source URL to open.</p>
+<h2 id="see-also">See Also</h2>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-docs.html">npm docs</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/workspaces.html">npm workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-fund.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-get.html b/node/node_modules/npm/docs/output/commands/npm-get.html
new file mode 100644
index 0000000000000000000000000000000000000000..ba6ea17747c724d11256fae8e906ca0e5a5a92a4
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-get.html
@@ -0,0 +1,231 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-get</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-get----11130">
+    <span>npm-get</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Get a value from the npm configuration</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#long"><code>long</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm get [&lt;key&gt; ...] (See `npm config`)
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Get a value from the npm configuration</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-config.html">npm help config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-get.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-help-search.html b/node/node_modules/npm/docs/output/commands/npm-help-search.html
new file mode 100644
index 0000000000000000000000000000000000000000..1a0b971d63cd809c18b9899d0ff851762eb2d5c5
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-help-search.html
@@ -0,0 +1,235 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-help-search</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-help-search----11130">
+    <span>npm-help-search</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Search npm help documentation</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#long"><code>long</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm help-search &lt;text&gt;
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>This command will search the npm markdown documentation files for the terms provided, and then list the results, sorted by relevance.</p>
+<p>If only one result is found, then it will show that help topic.</p>
+<p>If the argument to <code>npm help</code> is not a known help topic, then it will call <code>help-search</code>.
+It is rarely if ever necessary to call this command directly.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm.html">npm</a></li>
+<li><a href="../commands/npm-help.html">npm help</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-help-search.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-help.html b/node/node_modules/npm/docs/output/commands/npm-help.html
new file mode 100644
index 0000000000000000000000000000000000000000..d6b0585bf2b379da1899397fe6451a0f4604b326
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-help.html
@@ -0,0 +1,241 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-help</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-help----11130">
+    <span>npm-help</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Get help on npm</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#viewer"><code>viewer</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm help &lt;term&gt; [&lt;terms..&gt;]
+
+alias: hlep
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>If supplied a topic, then show the appropriate documentation page.</p>
+<p>If the topic does not exist, or if multiple terms are provided, then npm will run the <code>help-search</code> command to find a match.
+Note that, if <code>help-search</code> finds a single subject, then it will run <code>help</code> on that topic, so unique matches are equivalent to specifying a topic name.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="viewer"><code>viewer</code></h4>
+<ul>
+<li>Default: "man" on Posix, "browser" on Windows</li>
+<li>Type: String</li>
+</ul>
+<p>The program to use to view help content.</p>
+<p>Set to <code>"browser"</code> to view html help content in the default web browser.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm.html">npm</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-help-search.html">npm help-search</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-help.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-init.html b/node/node_modules/npm/docs/output/commands/npm-init.html
new file mode 100644
index 0000000000000000000000000000000000000000..1cf5f710e0dab8847f8051759d05a0bd59b38968
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-init.html
@@ -0,0 +1,467 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-init</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-init----11130">
+    <span>npm-init</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Create a package.json file</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#forwarding-additional-options">Forwarding additional options</a></li></ul><li><a href="#examples">Examples</a></li><li><a href="#workspaces-support">Workspaces support</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#init-author-name"><code>init-author-name</code></a></li><li><a href="#init-author-url"><code>init-author-url</code></a></li><li><a href="#init-license"><code>init-license</code></a></li><li><a href="#init-module"><code>init-module</code></a></li><li><a href="#init-type"><code>init-type</code></a></li><li><a href="#init-version"><code>init-version</code></a></li><li><a href="#init-private"><code>init-private</code></a></li><li><a href="#yes"><code>yes</code></a></li><li><a href="#force"><code>force</code></a></li><li><a href="#scope"><code>scope</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#workspaces-update"><code>workspaces-update</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm init &lt;package-spec&gt; (same as `npx create-&lt;package-spec&gt;`)
+npm init &lt;@scope&gt; (same as `npx &lt;@scope&gt;/create`)
+
+aliases: create, innit
+</code></pre>
+<h3 id="description">Description</h3>
+<p><code>npm init &lt;initializer&gt;</code> can be used to set up a new or existing npm package.</p>
+<p><code>initializer</code> in this case is an npm package named <code>create-&lt;initializer&gt;</code>,
+which will be installed by <a href="../commands/npm-exec.html"><code>npm-exec</code></a>, and then have its main bin executed -- presumably creating or updating <code>package.json</code> and running any other initialization-related operations.</p>
+<p>The init command is transformed to a corresponding <code>npm exec</code> operation as follows:</p>
+<ul>
+<li><code>npm init foo</code> -&gt; <code>npm exec create-foo</code></li>
+<li><code>npm init @usr/foo</code> -&gt; <code>npm exec @usr/create-foo</code></li>
+<li><code>npm init @usr</code> -&gt; <code>npm exec @usr/create</code></li>
+<li><code>npm init @usr@2.0.0</code> -&gt; <code>npm exec @usr/create@2.0.0</code></li>
+<li><code>npm init @usr/foo@2.0.0</code> -&gt; <code>npm exec @usr/create-foo@2.0.0</code></li>
+</ul>
+<p>If the initializer is omitted (by just calling <code>npm init</code>), init will fall back to legacy init behavior.
+It will ask you a bunch of questions, and then write a package.json for you.
+It will attempt to make reasonable guesses based on existing fields, dependencies, and options selected.
+It is strictly additive, so it will keep any fields and values that were already set.
+You can also use <code>-y</code>/<code>--yes</code> to skip the questionnaire altogether.
+If you pass <code>--scope</code>, it will create a scoped package.</p>
+<p><em>Note:</em> if a user already has the <code>create-&lt;initializer&gt;</code> package globally installed, that will be what <code>npm init</code> uses.
+If you want npm to use the latest version, or another specific version you must specify it:</p>
+<ul>
+<li><code>npm init foo@latest</code> # fetches and runs the latest <code>create-foo</code> from the registry</li>
+<li><code>npm init foo@1.2.3</code> #  runs <code>create-foo@1.2.3</code> specifically</li>
+</ul>
+<h4 id="forwarding-additional-options">Forwarding additional options</h4>
+<p>Any additional options will be passed directly to the command, so <code>npm init foo -- --hello</code> will map to <code>npm exec -- create-foo --hello</code>.</p>
+<p>To better illustrate how options are forwarded, here's a more evolved example showing options passed to both the <strong>npm cli</strong> and a create package, both following commands are equivalent:</p>
+<ul>
+<li><code>npm init foo -y --registry=&lt;url&gt; -- --hello -a</code></li>
+<li><code>npm exec -y --registry=&lt;url&gt; -- create-foo --hello -a</code></li>
+</ul>
+<h3 id="examples">Examples</h3>
+<p>Create a new React-based project using <a href="https://npm.im/create-react-app"><code>create-react-app</code></a>:</p>
+<pre><code class="language-bash">$ npm init react-app ./my-react-app
+</code></pre>
+<p>Create a new <code>esm</code>-compatible package using <a href="https://npm.im/create-esm"><code>create-esm</code></a>:</p>
+<pre><code class="language-bash">$ mkdir my-esm-lib &amp;&amp; cd my-esm-lib
+$ npm init esm --yes
+</code></pre>
+<p>Generate a plain old package.json using legacy init:</p>
+<pre><code class="language-bash">$ mkdir my-npm-pkg &amp;&amp; cd my-npm-pkg
+$ git init
+$ npm init
+</code></pre>
+<p>Generate it without having it ask any questions:</p>
+<pre><code class="language-bash">$ npm init -y
+</code></pre>
+<p>Set the private flag to <code>true</code> in package.json:</p>
+<pre><code class="language-bash">$ npm init --init-private -y
+</code></pre>
+<h3 id="workspaces-support">Workspaces support</h3>
+<p>It's possible to create a new workspace within your project by using the <code>workspace</code> config option.
+When using <code>npm init -w &lt;dir&gt;</code> the cli will create the folders and boilerplate expected while also adding a reference to your project <code>package.json</code> <code>"workspaces": []</code> property in order to make sure that new generated <strong>workspace</strong> is properly set up as such.</p>
+<p>Given a project with no workspaces, e.g:</p>
+<pre><code>.
++-- package.json
+</code></pre>
+<p>You may generate a new workspace using the legacy init:</p>
+<pre><code class="language-bash">$ npm init -w packages/a
+</code></pre>
+<p>That will generate a new folder and <code>package.json</code> file, while also updating your top-level <code>package.json</code> to add the reference to this new workspace:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   `-- a
+       `-- package.json
+</code></pre>
+<p>The workspaces init also supports the <code>npm init &lt;initializer&gt; -w &lt;dir&gt;</code> syntax, following the same set of rules explained earlier in the initial
+<strong>Description</strong> section of this page.
+Similar to the previous example of creating a new React-based project using <a href="https://npm.im/create-react-app"><code>create-react-app</code></a>, the following syntax will make sure to create the new react app as a nested <strong>workspace</strong> within your project and configure your <code>package.json</code> to recognize it as such:</p>
+<pre><code class="language-bash">npm init -w packages/my-react-app react-app .
+</code></pre>
+<p>This will make sure to generate your react app as expected, one important consideration to have in mind is that <code>npm exec</code> is going to be run in the context of the newly created folder for that workspace, and that's the reason why in this example the initializer uses the initializer name followed with a dot to represent the current directory in that context, e.g: <code>react-app .</code>:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- my-react-app
+       +-- README
+       +-- package.json
+       `-- ...
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="init-author-name"><code>init-author-name</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package author's name.</p>
+<h4 id="init-author-url"><code>init-author-url</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: "" or URL</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package author's
+homepage.</p>
+<h4 id="init-license"><code>init-license</code></h4>
+<ul>
+<li>Default: "ISC"</li>
+<li>Type: String</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package license.</p>
+<h4 id="init-module"><code>init-module</code></h4>
+<ul>
+<li>Default: "~/.npm-init.js"</li>
+<li>Type: Path</li>
+</ul>
+<p>A module that will be loaded by the <code>npm init</code> command. See the
+documentation for the
+<a href="https://github.com/npm/init-package-json">init-package-json</a> module for
+more information, or <a href="../commands/npm-init.html">npm init</a>.</p>
+<h4 id="init-type"><code>init-type</code></h4>
+<ul>
+<li>Default: "commonjs"</li>
+<li>Type: String</li>
+</ul>
+<p>The value that <code>npm init</code> should use by default for the package.json type
+field.</p>
+<h4 id="init-version"><code>init-version</code></h4>
+<ul>
+<li>Default: "1.0.0"</li>
+<li>Type: SemVer string</li>
+</ul>
+<p>The value that <code>npm init</code> should use by default for the package version
+number, if not already set in package.json.</p>
+<h4 id="init-private"><code>init-private</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package's private flag.</p>
+<h4 id="yes"><code>yes</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Automatically answer "yes" to any prompts that npm might print on the
+command line.</p>
+<h4 id="force"><code>force</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.</p>
+<ul>
+<li>Allow clobbering non-npm files in global installs.</li>
+<li>Allow the <code>npm version</code> command to work on an unclean git repository.</li>
+<li>Allow deleting the cache folder with <code>npm cache clean</code>.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of npm.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of <code>node</code>, even if <code>--engine-strict</code> is enabled.</li>
+<li>Allow <code>npm audit fix</code> to install modules outside your stated dependency
+range (including SemVer-major changes).</li>
+<li>Allow unpublishing all versions of a published package.</li>
+<li>Allow conflicting peerDependencies to be installed in the root project.</li>
+<li>Implicitly set <code>--yes</code> during <code>npm init</code>.</li>
+<li>Allow clobbering existing values in <code>npm pkg</code></li>
+<li>Allow unpublishing of entire packages (not just a single version).</li>
+</ul>
+<p>If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!</p>
+<h4 id="scope"><code>scope</code></h4>
+<ul>
+<li>Default: the scope of the current project, if any, or ""</li>
+<li>Type: String</li>
+</ul>
+<p>Associate an operation with a scope for a scoped registry.</p>
+<p>Useful when logging in to or out of a private registry:</p>
+<pre><code># log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+</code></pre>
+<p>This will cause <code>@mycorp</code> to be mapped to the registry for future
+installation of packages specified according to the pattern
+<code>@mycorp/package</code>.</p>
+<p>This will also cause <code>npm init</code> to create a scoped package.</p>
+<pre><code># accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+</code></pre>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces-update"><code>workspaces-update</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the npm cli will run an update after operations that may
+possibly change the workspaces installed to the <code>node_modules</code> folder.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="http://npm.im/init-package-json">init-package-json module</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-version.html">npm version</a></li>
+<li><a href="../using-npm/scope.html">npm scope</a></li>
+<li><a href="../commands/npm-exec.html">npm exec</a></li>
+<li><a href="../using-npm/workspaces.html">npm workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-init.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-install-ci-test.html b/node/node_modules/npm/docs/output/commands/npm-install-ci-test.html
new file mode 100644
index 0000000000000000000000000000000000000000..842cae13ba16cf28569df45687dd77c2919f72b9
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-install-ci-test.html
@@ -0,0 +1,423 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-install-ci-test</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-install-ci-test----11130">
+    <span>npm-install-ci-test</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Install a project with a clean slate and run tests</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm install-ci-test
+
+aliases: cit, clean-install-test, sit
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command runs <code>npm ci</code> followed immediately by <code>npm test</code>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-install-test.html">npm install-test</a></li>
+<li><a href="../commands/npm-ci.html">npm ci</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-install-ci-test.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-install-test.html b/node/node_modules/npm/docs/output/commands/npm-install-test.html
new file mode 100644
index 0000000000000000000000000000000000000000..2359cce146616b6c67a6e05c447e7b70b78ed542
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-install-test.html
@@ -0,0 +1,527 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-install-test</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-install-test----11130">
+    <span>npm-install-test</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Install package(s) and run tests</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm install-test [&lt;package-spec&gt; ...]
+
+alias: it
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command runs an <code>npm install</code> followed immediately by an <code>npm test</code>.
+It takes exactly the same arguments as <code>npm install</code>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="save-exact"><code>save-exact</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="prefer-dedupe"><code>prefer-dedupe</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prefer to deduplicate packages if possible, rather than choosing a newer
+version of a dependency.</p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="before"><code>before</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Date</li>
+</ul>
+<p>If passed to <code>npm install</code>, will rebuild the npm tree such that only
+versions that were available <strong>on or before</strong> the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.</p>
+<p>If the requested version is a <code>dist-tag</code> and the given tag does not pass the
+<code>--before</code> filter, the most recent version less than or equal to that tag
+will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
+<code>latest</code> is <code>2.0</code>.</p>
+<p>This config cannot be used with: <code>min-release-age</code></p>
+<h4 id="min-release-age"><code>min-release-age</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.</p>
+<p>This flag is a complement to <code>before</code>, which accepts an exact date instead
+of a relative number of days.</p>
+<p>This config cannot be used with: <code>before</code></p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="cpu"><code>cpu</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override CPU architecture of native modules to install. Acceptable values
+are same as <code>cpu</code> field of package.json, which comes from <code>process.arch</code>.</p>
+<h4 id="os"><code>os</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override OS of native modules to install. Acceptable values are same as <code>os</code>
+field of package.json, which comes from <code>process.platform</code>.</p>
+<h4 id="libc"><code>libc</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override libc of native modules to install. Acceptable values are same as
+<code>libc</code> field of package.json</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-install-ci-test.html">npm install-ci-test</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-install-test.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-install.html b/node/node_modules/npm/docs/output/commands/npm-install.html
new file mode 100644
index 0000000000000000000000000000000000000000..c79d7d45d209b479ea6caffc3a4b0370b1018825
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-install.html
@@ -0,0 +1,833 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-install</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-install----11130">
+    <span>npm-install</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Install a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#how-npm-install-uses-package-lockjson">How <code>npm install</code> uses <code>package-lock.json</code></a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#algorithm">Algorithm</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm install [&lt;package-spec&gt; ...]
+
+aliases: add, i, in, ins, inst, insta, instal, isnt, isnta, isntal, isntall
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command installs a package and any packages that it depends on.
+If the package has a package-lock, or an npm shrinkwrap file, or a yarn lock file, the installation of dependencies will be driven by that, respecting the following order of precedence:</p>
+<ul>
+<li><code>npm-shrinkwrap.json</code></li>
+<li><code>package-lock.json</code></li>
+<li><code>yarn.lock</code></li>
+</ul>
+<p>See <a href="../configuring-npm/package-lock-json.html">package-lock.json</a> and <a href="../commands/npm-shrinkwrap.html"><code>npm shrinkwrap</code></a>.</p>
+<h4 id="how-npm-install-uses-package-lockjson">How <code>npm install</code> uses <code>package-lock.json</code></h4>
+<p>When you run <code>npm install</code> without arguments, npm compares <code>package.json</code> and <code>package-lock.json</code>:</p>
+<ul>
+<li>
+<p><strong>If the lockfile's resolved versions satisfy the <code>package.json</code> ranges:</strong> npm uses the exact versions from <code>package-lock.json</code> to ensure reproducible builds across environments.</p>
+</li>
+<li>
+<p><strong>If the ranges don't match:</strong> npm resolves new versions that satisfy the <code>package.json</code> ranges and updates <code>package-lock.json</code> accordingly. This happens when you modify version ranges in <code>package.json</code> (e.g., changing <code>^7.0.0</code> to <code>^8.0.0</code>). Note that changing a range within the same major version (e.g., <code>^7.0.0</code> to <code>^7.1.0</code>) will only update the metadata in the lockfile if the currently installed version still satisfies the new range.</p>
+</li>
+</ul>
+<p>In essence, <code>package-lock.json</code> locks your dependencies to specific versions, but <code>package.json</code> is the source of truth for acceptable version ranges. When the lockfile's versions satisfy the <code>package.json</code> ranges, the lockfile wins. When they conflict, <code>package.json</code> wins and the lockfile is updated.</p>
+<p>If you want to install packages while ensuring that <code>package.json</code> is not modified and that both files are strictly in sync, use <a href="../commands/npm-ci.html"><code>npm ci</code></a> instead.</p>
+<p>A <code>package</code> is:</p>
+<ul>
+<li>a) a folder containing a program described by a <a href="../configuring-npm/package-json.html"><code>package.json</code></a> file</li>
+<li>b) a gzipped tarball containing (a)</li>
+<li>c) a url that resolves to (b)</li>
+<li>d) a <code>&lt;name&gt;@&lt;version&gt;</code> that is published on the registry (see <a href="../using-npm/registry.html"><code>registry</code></a>) with (c)</li>
+<li>e) a <code>&lt;name&gt;@&lt;tag&gt;</code> (see <a href="../commands/npm-dist-tag.html"><code>npm dist-tag</code></a>) that points to (d)</li>
+<li>f) a <code>&lt;name&gt;</code> that has a "latest" tag satisfying (e)</li>
+<li>g) a <code>&lt;git remote url&gt;</code> that resolves to (a)</li>
+</ul>
+<p>Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).</p>
+<ul>
+<li>
+<p><code>npm install</code> (in a package directory, no arguments):</p>
+<p>Install the dependencies to the local <code>node_modules</code> folder.</p>
+<p>In global mode (ie, with <code>-g</code> or <code>--global</code> appended to the command), it installs the current package context (ie, the current working directory) as a global package.</p>
+<p>By default, <code>npm install</code> will install all modules listed as dependencies in <a href="../configuring-npm/package-json.html"><code>package.json</code></a>.</p>
+<p>With the <code>--production</code> flag (or when the <code>NODE_ENV</code> environment variable is set to <code>production</code>), npm will not install modules listed in <code>devDependencies</code>.
+To install all modules listed in both <code>dependencies</code> and <code>devDependencies</code> when <code>NODE_ENV</code> environment variable is set to <code>production</code>, you can use <code>--production=false</code>.</p>
+<blockquote>
+<p>NOTE: The <code>--production</code> flag has no particular meaning when adding a dependency to a project.</p>
+</blockquote>
+</li>
+<li>
+<p><code>npm install &lt;folder&gt;</code>:</p>
+<p>If <code>&lt;folder&gt;</code> sits inside the root of your project, its dependencies will be installed and may be hoisted to the top-level <code>node_modules</code> as they would for other types of dependencies.
+If <code>&lt;folder&gt;</code> sits outside the root of your project, <em>npm will not install the package dependencies</em> in the directory <code>&lt;folder&gt;</code>, but it will create a symlink to <code>&lt;folder&gt;</code>.</p>
+<blockquote>
+<p>NOTE: If you want to install the content of a directory like a package from the registry instead of creating a link, you would need to use the <code>--install-links</code> option.</p>
+</blockquote>
+<p>Example:</p>
+<pre><code class="language-bash">npm install ../../other-package --install-links
+npm install ./sub-package
+</code></pre>
+</li>
+<li>
+<p><code>npm install &lt;tarball file&gt;</code>:</p>
+<p>Install a package that is sitting on the filesystem.
+Note: if you just want to link a dev directory into your npm root, you can do this more easily by using <a href="../commands/npm-link.html"><code>npm link</code></a>.</p>
+<p>Tarball requirements:</p>
+<ul>
+<li>The filename <em>must</em> use <code>.tar</code>, <code>.tar.gz</code>, or <code>.tgz</code> as the extension.</li>
+<li>The package contents should reside in a subfolder inside the tarball (usually it is called <code>package/</code>).
+npm strips one directory layer when installing the package (an equivalent of <code>tar x --strip-components=1</code> is run).</li>
+<li>The package must contain a <code>package.json</code> file with <code>name</code> and <code>version</code> properties.</li>
+</ul>
+<p>Example:</p>
+<pre><code class="language-bash">npm install ./package.tgz
+</code></pre>
+</li>
+<li>
+<p><code>npm install &lt;tarball url&gt;</code>:</p>
+<p>Fetch the tarball url, and then install it.
+In order to distinguish between this and other options, the argument must start with "http://" or "https://"</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install https://github.com/indexzero/forever/tarball/v0.5.6
+</code></pre>
+</li>
+<li>
+<p><code>npm install [&lt;@scope&gt;/]&lt;name&gt;</code>:</p>
+<p>Do a <code>&lt;name&gt;@&lt;tag&gt;</code> install, where <code>&lt;tag&gt;</code> is the "tag" config.
+(See <a href="../using-npm/config#tag.html"><code>config</code></a>.
+The config's default value is <code>latest</code>.)</p>
+<p>In most cases, this will install the version of the modules tagged as <code>latest</code> on the npm registry.</p>
+<p><strong>Note:</strong> When installing by name without specifying a version or tag, npm prioritizes versions that match the current Node.js version based on the package's <code>engines</code> field. If the <code>latest</code> tag points to a version incompatible with your current Node.js version, npm will install the newest compatible version instead. To install a specific version regardless of <code>engines</code> compatibility, explicitly specify the version or tag: <code>npm install &lt;name&gt;@latest</code>.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install sax
+</code></pre>
+<p><code>npm install</code> saves any specified packages into <code>dependencies</code> by default.
+Additionally, you can control where and how they get saved with some additional flags:</p>
+<ul>
+<li>
+<p><code>-P, --save-prod</code>: Package will appear in your <code>dependencies</code>.
+This is the default unless <code>-D</code> or <code>-O</code> are present.</p>
+</li>
+<li>
+<p><code>-D, --save-dev</code>: Package will appear in your <code>devDependencies</code>.</p>
+</li>
+<li>
+<p><code>--save-peer</code>: Package will appear in your <code>peerDependencies</code>.</p>
+</li>
+<li>
+<p><code>-O, --save-optional</code>: Package will appear in your
+<code>optionalDependencies</code>.</p>
+</li>
+<li>
+<p><code>--no-save</code>: Prevents saving to <code>dependencies</code>.</p>
+</li>
+</ul>
+<p>When using any of the above options to save dependencies to your package.json, there are two additional, optional flags:</p>
+<ul>
+<li>
+<p><code>-E, --save-exact</code>: Saved dependencies will be configured with an exact version rather than using npm's default semver range operator.</p>
+</li>
+<li>
+<p><code>-B, --save-bundle</code>: Saved dependencies will also be added to your <code>bundleDependencies</code> list.</p>
+</li>
+</ul>
+<p>Further, if you have an <code>npm-shrinkwrap.json</code> or <code>package-lock.json</code> then it will be updated as well.</p>
+<p><code>&lt;scope&gt;</code> is optional.
+The package will be downloaded from the registry associated with the specified scope.
+If no registry is associated with the given scope the default registry is assumed.
+See <a href="../using-npm/scope.html"><code>scope</code></a>.</p>
+<p>Note: if you do not include the @-symbol on your scope name, npm will interpret this as a GitHub repository instead, see below.
+Scopes names must also be followed by a slash.</p>
+<p>Examples:</p>
+<pre><code class="language-bash">npm install sax
+npm install githubname/reponame
+npm install @myorg/privatepackage
+npm install node-tap --save-dev
+npm install dtrace-provider --save-optional
+npm install readable-stream --save-exact
+npm install ansi-regex --save-bundle
+</code></pre>
+</li>
+<li>
+<p><code>npm install &lt;alias&gt;@npm:&lt;name&gt;</code>:</p>
+<p>Install a package under a custom alias.
+Allows multiple versions of a same-name package side-by-side, more convenient import names for packages with otherwise long ones, and using git forks replacements or forked npm packages as replacements.
+Aliasing works only on your project and does not rename packages in transitive dependencies.
+Aliases should follow the naming conventions stated in <a href="https://www.npmjs.com/package/validate-npm-package-name#naming-rules"><code>validate-npm-package-name</code></a>.</p>
+<p>Examples:</p>
+<pre><code class="language-bash">npm install my-react@npm:react
+npm install jquery2@npm:jquery@2
+npm install jquery3@npm:jquery@3
+npm install npa@npm:npm-package-arg
+</code></pre>
+</li>
+<li>
+<p><code>npm install [&lt;@scope&gt;/]&lt;name&gt;@&lt;tag&gt;</code>:</p>
+<p>Install the version of the package that is referenced by the specified tag.
+If the tag does not exist in the registry data for that package, then this will fail.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install sax@latest
+npm install @myorg/mypackage@latest
+</code></pre>
+</li>
+<li>
+<p><code>npm install [&lt;@scope&gt;/]&lt;name&gt;@&lt;version&gt;</code>:</p>
+<p>Install the specified version of the package.
+This will fail if the version has not been published to the registry.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install sax@0.1.1
+npm install @myorg/privatepackage@1.5.0
+</code></pre>
+</li>
+<li>
+<p><code>npm install [&lt;@scope&gt;/]&lt;name&gt;@&lt;version range&gt;</code>:</p>
+<p>Install a version of the package matching the specified version range.
+This will follow the same rules for resolving dependencies described in <a href="../configuring-npm/package-json.html"><code>package.json</code></a>.</p>
+<p>Note that most version ranges must be put in quotes so that your shell will treat it as a single argument.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install sax@"&gt;=0.1.0 &lt;0.2.0"
+npm install @myorg/privatepackage@"16 - 17"
+</code></pre>
+<p><strong>Prerelease versions:</strong> By default, version ranges only match stable versions. To include prerelease versions, they must be explicitly specified in the range. Prerelease versions are tied to a specific version triple (major.minor.patch). For example, <code>^1.2.3-beta.1</code> will only match prereleases for <code>1.2.x</code>, not <code>1.3.x</code>. To match all prereleases for a major version, use a range like <code>^1.0.0-0</code>, which will include all <code>1.x.x</code> prereleases.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install package@^1.2.3-beta.1  # Matches 1.2.3-beta.1, 1.2.3-beta.2, 1.2.4-beta.1, etc.
+npm install package@^1.0.0-0       # Matches all 1.x.x prereleases and stable versions
+</code></pre>
+</li>
+<li>
+<p><code>npm install &lt;git remote url&gt;</code>:</p>
+<p>Installs the package from the hosted git provider, cloning it with <code>git</code>.
+For a full git remote url, only that URL will be attempted.</p>
+<pre><code class="language-bash">&lt;protocol&gt;://[&lt;user&gt;[:&lt;password&gt;]@]&lt;hostname&gt;[:&lt;port&gt;][:][/]&lt;path&gt;[#&lt;commit-ish&gt; | #semver:&lt;semver&gt;]
+</code></pre>
+<p><code>&lt;protocol&gt;</code> is one of <code>git</code>, <code>git+ssh</code>, <code>git+http</code>, <code>git+https</code>, or
+<code>git+file</code>.</p>
+<p>If <code>#&lt;commit-ish&gt;</code> is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format <code>#semver:&lt;semver&gt;</code>, <code>&lt;semver&gt;</code> can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither <code>#&lt;commit-ish&gt;</code> or <code>#semver:&lt;semver&gt;</code> is specified, then the default branch of the repository is used.</p>
+<p>If the repository makes use of submodules, those submodules will be cloned as well.</p>
+<p>If the package being installed contains a <code>prepare</code> script, its <code>dependencies</code> and <code>devDependencies</code> will be installed, and the prepare script will be run, before the package is packaged and installed.</p>
+<p>The following git environment variables are recognized by npm and will be added to the environment when running git:</p>
+<ul>
+<li><code>GIT_ASKPASS</code></li>
+<li><code>GIT_EXEC_PATH</code></li>
+<li><code>GIT_PROXY_COMMAND</code></li>
+<li><code>GIT_SSH</code></li>
+<li><code>GIT_SSH_COMMAND</code></li>
+<li><code>GIT_SSL_CAINFO</code></li>
+<li><code>GIT_SSL_NO_VERIFY</code></li>
+</ul>
+<p>See the git man page for details.</p>
+<p>Examples:</p>
+<pre><code class="language-bash">npm install git+ssh://git@github.com:npm/cli.git#v1.0.27
+npm install git+ssh://git@github.com:npm/cli#pull/273
+npm install git+ssh://git@github.com:npm/cli#semver:^5.0
+npm install git+https://isaacs@github.com/npm/cli.git
+npm install git://github.com/npm/cli.git#v1.0.27
+GIT_SSH_COMMAND='ssh -i ~/.ssh/custom_ident' npm install git+ssh://git@github.com:npm/cli.git
+</code></pre>
+</li>
+<li>
+<p><code>npm install &lt;githubname&gt;/&lt;githubrepo&gt;[#&lt;commit-ish&gt;]</code>:</p>
+</li>
+<li>
+<p><code>npm install github:&lt;githubname&gt;/&lt;githubrepo&gt;[#&lt;commit-ish&gt;]</code>:</p>
+<p>Install the package at <code>https://github.com/githubname/githubrepo</code> by attempting to clone it using <code>git</code>.</p>
+<p>If <code>#&lt;commit-ish&gt;</code> is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format <code>#semver:&lt;semver&gt;</code>, <code>&lt;semver&gt;</code> can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither <code>#&lt;commit-ish&gt;</code> or <code>#semver:&lt;semver&gt;</code> is specified, then the default branch is used.</p>
+<p>As with regular git dependencies, <code>dependencies</code> and <code>devDependencies</code> will be installed if the package has a <code>prepare</code> script before the package is done installing.</p>
+<p>Examples:</p>
+<pre><code class="language-bash">npm install mygithubuser/myproject
+npm install github:mygithubuser/myproject
+</code></pre>
+</li>
+<li>
+<p><code>npm install gist:[&lt;githubname&gt;/]&lt;gistID&gt;[#&lt;commit-ish&gt;|#semver:&lt;semver&gt;]</code>:</p>
+<p>Install the package at <code>https://gist.github.com/gistID</code> by attempting to clone it using <code>git</code>.
+The GitHub username associated with the gist is optional and will not be saved in <code>package.json</code>.</p>
+<p>As with regular git dependencies, <code>dependencies</code> and <code>devDependencies</code> will be installed if the package has a <code>prepare</code> script before the package is done installing.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install gist:101a11beef
+</code></pre>
+</li>
+<li>
+<p><code>npm install bitbucket:&lt;bitbucketname&gt;/&lt;bitbucketrepo&gt;[#&lt;commit-ish&gt;]</code>:</p>
+<p>Install the package at <code>https://bitbucket.org/bitbucketname/bitbucketrepo</code> by attempting to clone it using <code>git</code>.</p>
+<p>If <code>#&lt;commit-ish&gt;</code> is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format <code>#semver:&lt;semver&gt;</code>, <code>&lt;semver&gt;</code> can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither <code>#&lt;commit-ish&gt;</code> or <code>#semver:&lt;semver&gt;</code> is specified, then <code>master</code> is used.</p>
+<p>As with regular git dependencies, <code>dependencies</code> and <code>devDependencies</code> will be installed if the package has a <code>prepare</code> script before the package is done installing.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install bitbucket:mybitbucketuser/myproject
+</code></pre>
+</li>
+<li>
+<p><code>npm install gitlab:&lt;gitlabname&gt;/&lt;gitlabrepo&gt;[#&lt;commit-ish&gt;]</code>:</p>
+<p>Install the package at <code>https://gitlab.com/gitlabname/gitlabrepo</code> by attempting to clone it using <code>git</code>.</p>
+<p>If <code>#&lt;commit-ish&gt;</code> is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format <code>#semver:&lt;semver&gt;</code>, <code>&lt;semver&gt;</code> can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither <code>#&lt;commit-ish&gt;</code> or <code>#semver:&lt;semver&gt;</code> is specified, then <code>master</code> is used.</p>
+<p>As with regular git dependencies, <code>dependencies</code> and <code>devDependencies</code> will be installed if the package has a <code>prepare</code> script before the package is done installing.</p>
+<p>Example:</p>
+<pre><code class="language-bash">npm install gitlab:mygitlabuser/myproject
+npm install gitlab:myusr/myproj#semver:^5.0
+</code></pre>
+</li>
+</ul>
+<p>You may combine multiple arguments and even multiple types of arguments.
+For example:</p>
+<pre><code class="language-bash">npm install sax@"&gt;=0.1.0 &lt;0.2.0" bench supervisor
+</code></pre>
+<p>The <code>--tag</code> argument will apply to all of the specified install targets.
+If a tag with the given name exists, the tagged version is preferred over newer versions.</p>
+<p><strong>Note:</strong> The <code>--tag</code> option only affects packages specified on the command line. It does not override version ranges specified in <code>package.json</code>. For example, if <code>package.json</code> specifies <code>"foo": "^1.0.0"</code> and you run <code>npm install --tag beta</code>, npm will still install a version matching <code>^1.0.0</code> even if the <code>beta</code> tag points to a different version. To install a tagged version, specify the package explicitly: <code>npm install foo@beta</code>.</p>
+<p>The <code>--dry-run</code> argument will report in the usual way what the install would have done without actually installing anything.</p>
+<p>The <code>--package-lock-only</code> argument will only update the <code>package-lock.json</code>, instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>The <code>-f</code> or <code>--force</code> argument will force npm to fetch remote resources even if a local copy exists on disk.</p>
+<pre><code class="language-bash">npm install sax --force
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<p>See the <a href="../using-npm/config.html"><code>config</code></a> help doc.
+Many of the configuration params have some effect on installation, since that's most of what npm does.</p>
+<p>These are some of the most common options related to installation.</p>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="save-exact"><code>save-exact</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="prefer-dedupe"><code>prefer-dedupe</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prefer to deduplicate packages if possible, rather than choosing a newer
+version of a dependency.</p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="before"><code>before</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Date</li>
+</ul>
+<p>If passed to <code>npm install</code>, will rebuild the npm tree such that only
+versions that were available <strong>on or before</strong> the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.</p>
+<p>If the requested version is a <code>dist-tag</code> and the given tag does not pass the
+<code>--before</code> filter, the most recent version less than or equal to that tag
+will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
+<code>latest</code> is <code>2.0</code>.</p>
+<p>This config cannot be used with: <code>min-release-age</code></p>
+<h4 id="min-release-age"><code>min-release-age</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.</p>
+<p>This flag is a complement to <code>before</code>, which accepts an exact date instead
+of a relative number of days.</p>
+<p>This config cannot be used with: <code>before</code></p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="cpu"><code>cpu</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override CPU architecture of native modules to install. Acceptable values
+are same as <code>cpu</code> field of package.json, which comes from <code>process.arch</code>.</p>
+<h4 id="os"><code>os</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override OS of native modules to install. Acceptable values are same as <code>os</code>
+field of package.json, which comes from <code>process.platform</code>.</p>
+<h4 id="libc"><code>libc</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override libc of native modules to install. Acceptable values are same as
+<code>libc</code> field of package.json</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="algorithm">Algorithm</h3>
+<p>Given a <code>package{dep}</code> structure: <code>A{B,C}, B{C}, C{D}</code>, the npm install algorithm produces:</p>
+<pre><code class="language-bash">A
++-- B
++-- C
++-- D
+</code></pre>
+<p>That is, the dependency from B to C is satisfied by the fact that A already caused C to be installed at a higher level.
+D is still installed at the top level because nothing conflicts with it.</p>
+<p>For <code>A{B,C}, B{C,D@1}, C{D@2}</code>, this algorithm produces:</p>
+<pre><code class="language-bash">A
++-- B
++-- C
+   `-- D@2
++-- D@1
+</code></pre>
+<p>Because B's D@1 will be installed in the top-level, C now has to install D@2 privately for itself.
+This algorithm is deterministic, but different trees may be produced if two dependencies are requested for installation in a different order.</p>
+<p>See <a href="../configuring-npm/folders.html">folders</a> for a more detailed description of the specific folder structures that npm creates.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-update.html">npm update</a></li>
+<li><a href="../commands/npm-audit.html">npm audit</a></li>
+<li><a href="../commands/npm-fund.html">npm fund</a></li>
+<li><a href="../commands/npm-link.html">npm link</a></li>
+<li><a href="../commands/npm-rebuild.html">npm rebuild</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-dist-tag.html">npm dist-tag</a></li>
+<li><a href="../commands/npm-uninstall.html">npm uninstall</a></li>
+<li><a href="../commands/npm-shrinkwrap.html">npm shrinkwrap</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../using-npm/workspaces.html">workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-install.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-link.html b/node/node_modules/npm/docs/output/commands/npm-link.html
new file mode 100644
index 0000000000000000000000000000000000000000..7b8d3d28dd00cf15e14186e1f1f0511de41422e6
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-link.html
@@ -0,0 +1,496 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-link</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-link----11130">
+    <span>npm-link</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Symlink a package folder</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#caveat">Caveat</a></li><li><a href="#workspace-usage">Workspace Usage</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm link [&lt;package-spec&gt;]
+
+alias: ln
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This is handy for installing your own stuff, so that you can work on it and test iteratively without having to continually rebuild.</p>
+<p>Package linking is a two-step process.</p>
+<p>First, <code>npm link</code> in a package folder with no arguments will create a symlink in the global folder <code>{prefix}/lib/node_modules/&lt;package&gt;</code> that links to the package where the <code>npm link</code> command was executed.
+It will also link any bins in the package to <code>{prefix}/bin/{name}</code>.
+Note that <code>npm link</code> uses the global prefix (see <code>npm prefix -g</code> for its value).</p>
+<p>Next, in some other location, <code>npm link package-name</code> will create a symbolic link from globally-installed <code>package-name</code> to <code>node_modules/</code> of the current folder.</p>
+<p>Note that <code>package-name</code> is taken from <code>package.json</code>, <em>not</em> from the directory name.</p>
+<p>The package name can be optionally prefixed with a scope.
+See <a href="../using-npm/scope.html"><code>scope</code></a>.
+The scope must be preceded by an @-symbol and followed by a slash.</p>
+<p>When creating tarballs for <code>npm publish</code>, the linked packages are "snapshotted" to their current state by resolving the symbolic links, if they are included in <code>bundleDependencies</code>.</p>
+<p>For example:</p>
+<pre><code class="language-bash">cd ~/projects/node-redis    # go into the package directory
+npm link                    # creates global link
+cd ~/projects/node-bloggy   # go into some other package directory.
+npm link redis              # link-install the package
+</code></pre>
+<p>Now, any changes to <code>~/projects/node-redis</code> will be reflected in
+<code>~/projects/node-bloggy/node_modules/node-redis/</code>.
+Note that the link should be to the package name, not the directory name for that package.</p>
+<p>You may also shortcut the two steps in one.
+For example, to do the above use-case in a shorter way:</p>
+<pre><code class="language-bash">cd ~/projects/node-bloggy  # go into the dir of your main project
+npm link ../node-redis     # link the dir of your dependency
+</code></pre>
+<p>The second line is the equivalent of doing:</p>
+<pre><code class="language-bash">(cd ../node-redis; npm link)
+npm link redis
+</code></pre>
+<p>That is, it first creates a global link, and then links the global installation target into your project's <code>node_modules</code> folder.</p>
+<p>Note that in this case, you are referring to the directory name,
+<code>node-redis</code>, rather than the package name <code>redis</code>.</p>
+<p>If your linked package is scoped (see <a href="../using-npm/scope.html"><code>scope</code></a>) your link command must include that scope, e.g.</p>
+<pre><code class="language-bash">npm link @myorg/privatepackage
+</code></pre>
+<h3 id="caveat">Caveat</h3>
+<p>Note that package dependencies linked in this way are <em>not</em> saved to <code>package.json</code> by default, on the assumption that the intention is to have a link stand in for a regular non-link dependency.
+Otherwise, for example, if you depend on <code>redis@^3.0.1</code>, and ran <code>npm link redis</code>, it would replace the <code>^3.0.1</code> dependency with <code>file:../path/to/node-redis</code>, which you probably don't want!  Additionally, other users or developers on your project would run into issues if they do not have their folders set up exactly the same as yours.</p>
+<p>If you are adding a <em>new</em> dependency as a link, you should add it to the relevant metadata by running <code>npm install &lt;dep&gt; --package-lock-only</code>.</p>
+<p>If you <em>want</em> to save the <code>file:</code> reference in your <code>package.json</code> and <code>package-lock.json</code> files, you can use <code>npm link &lt;dep&gt; --save</code> to do so.</p>
+<h3 id="workspace-usage">Workspace Usage</h3>
+<p><code>npm link &lt;pkg&gt; --workspace &lt;name&gt;</code> will link the relevant package as a dependency of the specified workspace(s).
+Note that It may actually be linked into the parent project's <code>node_modules</code> folder, if there are no conflicting dependencies.</p>
+<p><code>npm link --workspace &lt;name&gt;</code> will create a global link to the specified workspace(s).</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="save-exact"><code>save-exact</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../using-npm/developers.html">npm developers</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-link.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-ll.html b/node/node_modules/npm/docs/output/commands/npm-ll.html
new file mode 100644
index 0000000000000000000000000000000000000000..8fbceea12e5f21f25025aeeb103131d562d1e005
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-ll.html
@@ -0,0 +1,381 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-ll</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-ll----11130">
+    <span>npm-ll</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">List installed packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#all"><code>all</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#long"><code>long</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#depth"><code>depth</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#link"><code>link</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm ll [[&lt;@scope&gt;/]&lt;pkg&gt; ...]
+
+alias: la
+</code></pre>
+<h3 id="description">Description</h3>
+<p>List installed packages</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="all"><code>all</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When running <code>npm outdated</code> and <code>npm ls</code>, setting <code>--all</code> will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="depth"><code>depth</code></h4>
+<ul>
+<li>Default: <code>Infinity</code> if <code>--all</code> is set; otherwise, <code>0</code></li>
+<li>Type: null or Number</li>
+</ul>
+<p>The depth to go when recursing packages for <code>npm ls</code>.</p>
+<p>If not set, <code>npm ls</code> will show only the immediate dependencies of the root
+project. If <code>--all</code> is set, then npm will show all dependencies by default.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="link"><code>link</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Used with <code>npm ls</code>, limiting output to only those packages that are linked.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="unicode"><code>unicode</code></h4>
+<ul>
+<li>Default: false on windows, true on mac/unix systems with a unicode locale,
+as defined by the <code>LC_ALL</code>, <code>LC_CTYPE</code>, or <code>LANG</code> environment variables.</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-config.html">npm help config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-ll.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-login.html b/node/node_modules/npm/docs/output/commands/npm-login.html
new file mode 100644
index 0000000000000000000000000000000000000000..80066f5f9d4a3fe8eab874504744022d02465655
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-login.html
@@ -0,0 +1,274 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-login</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-login----11130">
+    <span>npm-login</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Login to a registry user account</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#scope"><code>scope</code></a></li><li><a href="#auth-type"><code>auth-type</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm login
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Verify a user in the specified registry, and save the credentials to the
+<code>.npmrc</code> file.
+If no registry is specified, the default registry will be used (see <a href="../using-npm/config.html"><code>config</code></a>).</p>
+<p>When you run <code>npm login</code>, the CLI automatically generates a legacy token of <code>publish</code> type.
+For more information, see <a href="../about-access-tokens#about-legacy-tokens.html">About legacy tokens</a>.</p>
+<p>When using <code>legacy</code> for your <code>auth-type</code>, the username and password, are read in from prompts.</p>
+<p>To reset your password, go to <a href="https://www.npmjs.com/forgot">https://www.npmjs.com/forgot</a></p>
+<p>To change your email address, go to <a href="https://www.npmjs.com/email-edit">https://www.npmjs.com/email-edit</a></p>
+<p>You may use this command multiple times with the same user account to authorize on a new machine.
+When authenticating on a new machine, the username, password and email address must all match with your existing record.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="scope"><code>scope</code></h4>
+<ul>
+<li>Default: the scope of the current project, if any, or ""</li>
+<li>Type: String</li>
+</ul>
+<p>Associate an operation with a scope for a scoped registry.</p>
+<p>Useful when logging in to or out of a private registry:</p>
+<pre><code># log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+</code></pre>
+<p>This will cause <code>@mycorp</code> to be mapped to the registry for future
+installation of packages specified according to the pattern
+<code>@mycorp/package</code>.</p>
+<p>This will also cause <code>npm init</code> to create a scoped package.</p>
+<pre><code># accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+</code></pre>
+<h4 id="auth-type"><code>auth-type</code></h4>
+<ul>
+<li>Default: "web"</li>
+<li>Type: "legacy" or "web"</li>
+</ul>
+<p>What authentication strategy to use with <code>login</code>. Note that if an <code>otp</code>
+config is given, this value will always be set to <code>legacy</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-token.html">npm token</a></li>
+<li><a href="../commands/npm-profile.html">npm profile</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-login.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-logout.html b/node/node_modules/npm/docs/output/commands/npm-logout.html
new file mode 100644
index 0000000000000000000000000000000000000000..61e740e4fd5b3b358d305f092b26509f868cb8df
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-logout.html
@@ -0,0 +1,259 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-logout</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-logout----11130">
+    <span>npm-logout</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Log out of the registry</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#scope"><code>scope</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm logout
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>When logged into a registry that supports token-based authentication, tell the server to end this token's session.
+This will invalidate the token everywhere you're using it, not just for the current environment.</p>
+<p>When logged into a legacy registry that uses username and password authentication, this will clear the credentials in your user configuration.
+In this case, it will <em>only</em> affect the current environment.</p>
+<p>If <code>--scope</code> is provided, this will find the credentials for the registry connected to that scope, if set.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="scope"><code>scope</code></h4>
+<ul>
+<li>Default: the scope of the current project, if any, or ""</li>
+<li>Type: String</li>
+</ul>
+<p>Associate an operation with a scope for a scoped registry.</p>
+<p>Useful when logging in to or out of a private registry:</p>
+<pre><code># log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+</code></pre>
+<p>This will cause <code>@mycorp</code> to be mapped to the registry for future
+installation of packages specified according to the pattern
+<code>@mycorp/package</code>.</p>
+<p>This will also cause <code>npm init</code> to create a scoped package.</p>
+<pre><code># accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+</code></pre>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-logout.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-ls.html b/node/node_modules/npm/docs/output/commands/npm-ls.html
new file mode 100644
index 0000000000000000000000000000000000000000..238243dd98b4f102aa34f761aa726faf2a0d29dd
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-ls.html
@@ -0,0 +1,403 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-ls</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-ls----11130">
+    <span>npm-ls</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">List installed packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#all"><code>all</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#long"><code>long</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#depth"><code>depth</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#link"><code>link</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm ls &lt;package-spec&gt;
+
+alias: list
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command will print to stdout all the versions of packages that are installed, as well as their dependencies when <code>--all</code> is specified, in a tree structure.</p>
+<p>Note: to get a "bottoms up" view of why a given package is included in the tree at all, use <a href="../commands/npm-explain.html"><code>npm explain</code></a>.</p>
+<p>Positional arguments are <code>name@version-range</code> identifiers, which will limit the results to only the paths to the packages named.
+Note that nested packages will <em>also</em> show the paths to the specified packages.
+For example, running <code>npm ls promzard</code> in npm's source tree will show:</p>
+<pre><code class="language-bash">npm@11.13.0 /path/to/npm
+└─┬ init-package-json@0.0.4
+  └── promzard@0.1.5
+</code></pre>
+<p>It will print out extraneous, missing, and invalid packages.</p>
+<p>If a project specifies git urls for dependencies these are shown in parentheses after the <code>name@version</code> to make it easier for users to recognize potential forks of a project.</p>
+<p>The tree shown is the logical dependency tree, based on package dependencies, not the physical layout of your <code>node_modules</code> folder.</p>
+<p>When run as <code>ll</code> or <code>la</code>, it shows extended information by default.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="all"><code>all</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When running <code>npm outdated</code> and <code>npm ls</code>, setting <code>--all</code> will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="depth"><code>depth</code></h4>
+<ul>
+<li>Default: <code>Infinity</code> if <code>--all</code> is set; otherwise, <code>0</code></li>
+<li>Type: null or Number</li>
+</ul>
+<p>The depth to go when recursing packages for <code>npm ls</code>.</p>
+<p>If not set, <code>npm ls</code> will show only the immediate dependencies of the root
+project. If <code>--all</code> is set, then npm will show all dependencies by default.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="link"><code>link</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Used with <code>npm ls</code>, limiting output to only those packages that are linked.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="unicode"><code>unicode</code></h4>
+<ul>
+<li>Default: false on windows, true on mac/unix systems with a unicode locale,
+as defined by the <code>LC_ALL</code>, <code>LC_CTYPE</code>, or <code>LANG</code> environment variables.</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-explain.html">npm explain</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-explain.html">npm explain</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-link.html">npm link</a></li>
+<li><a href="../commands/npm-prune.html">npm prune</a></li>
+<li><a href="../commands/npm-outdated.html">npm outdated</a></li>
+<li><a href="../commands/npm-update.html">npm update</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-ls.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-org.html b/node/node_modules/npm/docs/output/commands/npm-org.html
new file mode 100644
index 0000000000000000000000000000000000000000..8adbf0cbd03a06b49c65e8fb292a6009a9f3015b
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-org.html
@@ -0,0 +1,283 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-org</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-org----11130">
+    <span>npm-org</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manage orgs</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#example">Example</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#parseable"><code>parseable</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm org set orgname username [developer | admin | owner]
+npm org rm orgname username
+npm org ls orgname [&lt;username&gt;]
+
+alias: ogr
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="example">Example</h3>
+<p>Add a new developer to an org:</p>
+<pre><code class="language-bash">$ npm org set my-org @mx-smith
+</code></pre>
+<p>Add a new admin to an org (or change a developer to an admin):</p>
+<pre><code class="language-bash">$ npm org set my-org @mx-santos admin
+</code></pre>
+<p>Remove a user from an org:</p>
+<pre><code class="language-bash">$ npm org rm my-org mx-santos
+</code></pre>
+<p>List all users in an org:</p>
+<pre><code class="language-bash">$ npm org ls my-org
+</code></pre>
+<p>List all users in JSON format:</p>
+<pre><code class="language-bash">$ npm org ls my-org --json
+</code></pre>
+<p>See what role a user has in an org:</p>
+<pre><code class="language-bash">$ npm org ls my-org @mx-santos
+</code></pre>
+<h3 id="description">Description</h3>
+<p>You can use the <code>npm org</code> commands to manage and view users of an organization.
+It supports adding and removing users, changing their roles, listing them, and finding specific ones and their roles.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/orgs.html">using orgs</a></li>
+<li><a href="https://docs.npmjs.com/orgs/">Documentation on npm Orgs</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-org.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-outdated.html b/node/node_modules/npm/docs/output/commands/npm-outdated.html
new file mode 100644
index 0000000000000000000000000000000000000000..d9289aab88e2be4a06edafe365e370907d5f5c58
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-outdated.html
@@ -0,0 +1,367 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-outdated</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-outdated----11130">
+    <span>npm-outdated</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Check for outdated packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#an-example">An example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#all"><code>all</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#long"><code>long</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm outdated [&lt;package-spec&gt; ...]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command will check the registry to see if any (or, specific) installed packages are currently outdated.</p>
+<p>By default, only the direct dependencies of the root project and direct dependencies of your configured <em>workspaces</em> are shown.
+Use <code>--all</code> to find all outdated meta-dependencies as well.</p>
+<p>In the output:</p>
+<ul>
+<li><code>wanted</code> is the maximum version of the package that satisfies the semver range specified in <code>package.json</code>.
+If there's no available semver range (i.e. you're running <code>npm outdated --global</code>, or the package isn't included in <code>package.json</code>), then <code>wanted</code> shows the currently-installed version.</li>
+<li><code>latest</code> is the version of the package tagged as latest in the registry.
+Running <code>npm publish</code> with no special configuration will publish the package with a dist-tag of <code>latest</code>.
+This may or may not be the maximum version of the package, or the most-recently published version of the package, depending on how the package's developer manages the latest <a href="../commands/npm-dist-tag.html">dist-tag</a>.</li>
+<li><code>location</code> is where in the physical tree the package is located.</li>
+<li><code>depended by</code> shows which package depends on the displayed dependency</li>
+<li><code>package type</code> (when using <code>--long</code> / <code>-l</code>) tells you whether this package is a <code>dependency</code> or a dev/peer/optional dependency.
+Packages not included in <code>package.json</code> are always marked <code>dependencies</code>.</li>
+<li><code>homepage</code> (when using <code>--long</code> / <code>-l</code>) is the <code>homepage</code> value contained in the package's packument</li>
+<li><code>depended by location</code> (when using <code>--long</code> / <code>-l</code>) shows location of the package that depends on the displayed dependency</li>
+<li>Red means there's a newer version matching your semver requirements, so you should update now.</li>
+<li>Yellow indicates that there's a newer version <em>above</em> your semver requirements (usually new major, or new 0.x minor) so proceed with caution.</li>
+</ul>
+<h3 id="an-example">An example</h3>
+<pre><code class="language-bash">$ npm outdated
+Package      Current   Wanted   Latest  Location                  Depended by
+glob          5.0.15   5.0.15    6.0.1  node_modules/glob         dependent-package-name
+nothingness    0.0.3      git      git  node_modules/nothingness  dependent-package-name
+npm            3.5.1    3.5.2    3.5.1  node_modules/npm          dependent-package-name
+local-dev      0.0.3   linked   linked  local-dev                 dependent-package-name
+once           1.3.2    1.3.3    1.3.3  node_modules/once         dependent-package-name
+</code></pre>
+<p>With these <code>dependencies</code>:</p>
+<pre><code class="language-json">{
+  "glob": "^5.0.15",
+  "nothingness": "github:othiym23/nothingness#master",
+  "npm": "^3.5.1",
+  "once": "^1.3.1"
+}
+</code></pre>
+<p>A few things to note:</p>
+<ul>
+<li><code>glob</code> requires <code>^5</code>, which prevents npm from installing <code>glob@6</code>, which is outside the semver range.</li>
+<li>Git dependencies will always be reinstalled, because of how they're specified.
+The installed committish might satisfy the dependency specifier (if it's something immutable, like a commit SHA), or it might not, so <code>npm outdated</code> and <code>npm update</code> have to fetch Git repos to check.
+This is why currently doing a reinstall of a Git dependency always forces a new clone and install.</li>
+<li><code>npm@3.5.2</code> is marked as "wanted", but "latest" is <code>npm@3.5.1</code> because npm uses dist-tags to manage its <code>latest</code> and <code>next</code> release channels.
+<code>npm update</code> will install the <em>newest</em> version, but <code>npm install npm</code> (with no semver range) will install whatever's tagged as <code>latest</code>.</li>
+<li><code>once</code> is just plain out of date.
+Reinstalling <code>node_modules</code> from scratch or running <code>npm update</code> will bring it up to spec.</li>
+</ul>
+<h3 id="configuration">Configuration</h3>
+<h4 id="all"><code>all</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When running <code>npm outdated</code> and <code>npm ls</code>, setting <code>--all</code> will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="before"><code>before</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Date</li>
+</ul>
+<p>If passed to <code>npm install</code>, will rebuild the npm tree such that only
+versions that were available <strong>on or before</strong> the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.</p>
+<p>If the requested version is a <code>dist-tag</code> and the given tag does not pass the
+<code>--before</code> filter, the most recent version less than or equal to that tag
+will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
+<code>latest</code> is <code>2.0</code>.</p>
+<p>This config cannot be used with: <code>min-release-age</code></p>
+<h4 id="min-release-age"><code>min-release-age</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.</p>
+<p>This flag is a complement to <code>before</code>, which accepts an exact date instead
+of a relative number of days.</p>
+<p>This config cannot be used with: <code>before</code></p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-update.html">npm update</a></li>
+<li><a href="../commands/npm-dist-tag.html">npm dist-tag</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../using-npm/workspaces.html">npm workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-outdated.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-owner.html b/node/node_modules/npm/docs/output/commands/npm-owner.html
new file mode 100644
index 0000000000000000000000000000000000000000..5a3063c574cddba3976807163cc4844f50c8951d
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-owner.html
@@ -0,0 +1,294 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-owner</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-owner----11130">
+    <span>npm-owner</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manage package owners</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm owner add &lt;user&gt; &lt;package-spec&gt;
+npm owner rm &lt;user&gt; &lt;package-spec&gt;
+npm owner ls &lt;package-spec&gt;
+
+alias: author
+</code></pre>
+<h3 id="description">Description</h3>
+<p>Manage ownership of published packages.</p>
+<ul>
+<li>ls: List all the users who have access to modify a package and push new versions.
+Handy when you need to know who to bug for help.</li>
+<li>add: Add a new user as a maintainer of a package.
+This user is enabled to modify metadata, publish new versions, and add other owners.</li>
+<li>rm: Remove a user from the package owner list.
+This immediately revokes their privileges.</li>
+</ul>
+<p>Note that there is only one level of access.
+Either you can modify a package, or you can't.
+Future versions may contain more fine-grained access levels, but that is not implemented at this time.</p>
+<p>If you have two-factor authentication enabled with <code>auth-and-writes</code> (see <a href="../commands/npm-profile.html"><code>npm-profile</code></a>) then you'll need to go through a second factor flow when changing ownership or include an otp on the command line with <code>--otp</code>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-profile.html">npm profile</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-owner.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-pack.html b/node/node_modules/npm/docs/output/commands/npm-pack.html
new file mode 100644
index 0000000000000000000000000000000000000000..59fa3191c7e9f5a578860275e3ec9f8d7aab193e
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-pack.html
@@ -0,0 +1,314 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-pack</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-pack----11130">
+    <span>npm-pack</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Create a tarball from a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#pack-destination"><code>pack-destination</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li></ul><li><a href="#description">Description</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm pack &lt;package-spec&gt;
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="pack-destination"><code>pack-destination</code></h4>
+<ul>
+<li>Default: "."</li>
+<li>Type: String</li>
+</ul>
+<p>Directory in which <code>npm pack</code> will save tarballs.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h3 id="description">Description</h3>
+<p>For anything that's installable (that is, a package folder, tarball, tarball url, git url, name@tag, name@version, name, or scoped name), this command will fetch it to the cache, copy the tarball to the current working directory as <code>&lt;name&gt;-&lt;version&gt;.tgz</code>, and then write the filenames out to stdout.</p>
+<p>If the same package is specified multiple times, then the file will be overwritten the second time.</p>
+<p>If no arguments are supplied, then npm packs the current package folder.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="http://npm.im/npm-packlist">npm-packlist package</a></li>
+<li><a href="../commands/npm-cache.html">npm cache</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-pack.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-ping.html b/node/node_modules/npm/docs/output/commands/npm-ping.html
new file mode 100644
index 0000000000000000000000000000000000000000..75b11723fe4625e51b259ede4abb998554723816
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-ping.html
@@ -0,0 +1,242 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-ping</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-ping----11130">
+    <span>npm-ping</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Ping npm registry</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm ping
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Ping the configured or given npm registry and verify authentication.
+If it works it will output something like:</p>
+<pre><code class="language-bash">npm notice PING https://registry.npmjs.org/
+npm notice PONG 255ms
+</code></pre>
+<p>otherwise you will get an error:</p>
+<pre><code class="language-bash">npm notice PING http://foo.com/
+npm ERR! code E404
+npm ERR! 404 Not Found - GET http://www.foo.com/-/ping?write=true
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-doctor.html">npm doctor</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-ping.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-pkg.html b/node/node_modules/npm/docs/output/commands/npm-pkg.html
new file mode 100644
index 0000000000000000000000000000000000000000..a3a55dada138031080b10ad484f7036e2d6c1d1d
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-pkg.html
@@ -0,0 +1,389 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-pkg</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-pkg----11130">
+    <span>npm-pkg</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manages your package.json</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm pkg set &lt;key&gt;=&lt;value&gt; [&lt;key&gt;=&lt;value&gt; ...]
+npm pkg get [&lt;key&gt; [&lt;key&gt; ...]]
+npm pkg delete &lt;key&gt; [&lt;key&gt; ...]
+npm pkg set [&lt;array&gt;[&lt;index&gt;].&lt;key&gt;=&lt;value&gt; ...]
+npm pkg set [&lt;array&gt;[].&lt;key&gt;=&lt;value&gt; ...]
+npm pkg fix
+</code></pre>
+<h3 id="description">Description</h3>
+<p>A command that automates the management of <code>package.json</code> files.
+<code>npm pkg</code> provide 3 different sub commands that allow you to modify or retrieve values for given object keys in your <code>package.json</code>.</p>
+<p>The syntax to retrieve and set fields is a dot separated representation of the nested object properties to be found within your <code>package.json</code>, it's the same notation used in <a href="../commands/npm-view.html"><code>npm view</code></a> to retrieve information from the registry manifest, below you can find more examples on how to use it.</p>
+<p>Returned values are always in <strong>json</strong> format.</p>
+<ul>
+<li>
+<p><code>npm pkg get &lt;field&gt;</code></p>
+<p>Retrieves a value <code>key</code>, defined in your <code>package.json</code> file.</p>
+<p>For example, in order to retrieve the name of the current package, you can run:</p>
+<pre><code class="language-bash">npm pkg get name
+</code></pre>
+<p>It's also possible to retrieve multiple values at once:</p>
+<pre><code class="language-bash">npm pkg get name version
+</code></pre>
+<p>You can view child fields by separating them with a period.
+To retrieve the value of a test <code>script</code> value, you would run the following command:</p>
+<pre><code class="language-bash">npm pkg get scripts.test
+</code></pre>
+<p>For fields that are arrays, requesting a non-numeric field will return all of the values from the objects in the list.
+For example, to get all the contributor emails for a package, you would run:</p>
+<pre><code class="language-bash">npm pkg get contributors.email
+</code></pre>
+<p>You may also use numeric indices in square braces to specifically select an item in an array field.
+To just get the email address of the first contributor in the list, you can run:</p>
+<pre><code class="language-bash">npm pkg get contributors[0].email
+</code></pre>
+<p>For complex fields you can also name a property in square brackets to specifically select a child field.
+This is especially helpful with the exports object:</p>
+<pre><code class="language-bash">npm pkg get "exports[.].require"
+</code></pre>
+</li>
+<li>
+<p><code>npm pkg set &lt;field&gt;=&lt;value&gt;</code></p>
+<p>Sets a <code>value</code> in your <code>package.json</code> based on the <code>field</code> value.
+When saving to your <code>package.json</code> file the same set of rules used during <code>npm install</code> and other cli commands that touches the <code>package.json</code> file are used, making sure to respect the existing indentation and possibly applying some validation prior to saving values to the file.</p>
+<p>The same syntax used to retrieve values from your package can also be used to define new properties or overriding existing ones, below are some examples of how the dot separated syntax can be used to edit your <code>package.json</code> file.</p>
+<p>Defining a new bin named <code>mynewcommand</code> in your <code>package.json</code> that points to a file <code>cli.js</code>:</p>
+<pre><code class="language-bash">npm pkg set bin.mynewcommand=cli.js
+</code></pre>
+<p>Setting multiple fields at once is also possible:</p>
+<pre><code class="language-bash">npm pkg set description='Awesome package' engines.node='&gt;=10'
+</code></pre>
+<p>It's also possible to add to array values, for example to add a new contributor entry:</p>
+<pre><code class="language-bash">npm pkg set contributors[0].name='Foo' contributors[0].email='foo@bar.ca'
+</code></pre>
+<p>You may also append items to the end of an array using the special empty bracket notation:</p>
+<pre><code class="language-bash">npm pkg set contributors[].name='Foo' contributors[].name='Bar'
+</code></pre>
+<p>It's also possible to parse values as json prior to saving them to your <code>package.json</code> file, for example in order to set a <code>"private": true</code> property:</p>
+<pre><code class="language-bash">npm pkg set private=true --json
+</code></pre>
+<p>It also enables saving values as numbers:</p>
+<pre><code class="language-bash">npm pkg set tap.timeout=60 --json
+</code></pre>
+</li>
+<li>
+<p><code>npm pkg delete &lt;key&gt;</code></p>
+<p>Deletes a <code>key</code> from your <code>package.json</code></p>
+<p>The same syntax used to set values from your package can also be used to remove existing ones.
+For example, in order to remove a script named build:</p>
+<pre><code class="language-bash">npm pkg delete scripts.build
+</code></pre>
+</li>
+<li>
+<p><code>npm pkg fix</code></p>
+<p>Auto corrects common errors in your <code>package.json</code>.
+npm already does this during <code>publish</code>, which leads to subtle (mostly harmless) differences between the contents of your <code>package.json</code> file and the manifest that npm uses during installation.</p>
+</li>
+</ul>
+<h3 id="workspaces-support">Workspaces support</h3>
+<p>You can set/get/delete items across your configured workspaces by using the <a href="../using-npm/config#workspace.html"><code>workspace</code></a> or <a href="../using-npm/config#workspaces.html"><code>workspaces</code></a> config options.</p>
+<p>For example, setting a <code>funding</code> value across all configured workspaces of a project:</p>
+<pre><code class="language-bash">npm pkg set funding=https://example.com --ws
+</code></pre>
+<p>When using <code>npm pkg get</code> to retrieve info from your configured workspaces, the returned result will be in a json format in which top level keys are the names of each workspace, the values of these keys will be the result values returned from each of the configured workspaces, e.g:</p>
+<pre><code>npm pkg get name version --ws
+{
+  "a": {
+    "name": "a",
+    "version": "1.0.0"
+  },
+  "b": {
+    "name": "b",
+    "version": "1.0.0"
+  }
+}
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="force"><code>force</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.</p>
+<ul>
+<li>Allow clobbering non-npm files in global installs.</li>
+<li>Allow the <code>npm version</code> command to work on an unclean git repository.</li>
+<li>Allow deleting the cache folder with <code>npm cache clean</code>.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of npm.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of <code>node</code>, even if <code>--engine-strict</code> is enabled.</li>
+<li>Allow <code>npm audit fix</code> to install modules outside your stated dependency
+range (including SemVer-major changes).</li>
+<li>Allow unpublishing all versions of a published package.</li>
+<li>Allow conflicting peerDependencies to be installed in the root project.</li>
+<li>Implicitly set <code>--yes</code> during <code>npm init</code>.</li>
+<li>Allow clobbering existing values in <code>npm pkg</code></li>
+<li>Allow unpublishing of entire packages (not just a single version).</li>
+</ul>
+<p>If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h2 id="see-also">See Also</h2>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-init.html">npm init</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/workspaces.html">workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-pkg.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-prefix.html b/node/node_modules/npm/docs/output/commands/npm-prefix.html
new file mode 100644
index 0000000000000000000000000000000000000000..3a5f236aca922c2ff03ee2f25926aff08dfac569
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-prefix.html
@@ -0,0 +1,252 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-prefix</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-prefix----11130">
+    <span>npm-prefix</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Display prefix</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#global"><code>global</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm prefix
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Print the local prefix to standard output.
+This is the closest parent directory to contain a <code>package.json</code> file or <code>node_modules</code> directory, unless <code>-g</code> is also specified.</p>
+<p>If <code>-g</code> is specified, this will be the value of the global prefix.
+See <a href="../commands/npm-config.html"><code>npm config</code></a> for more detail.</p>
+<h3 id="example">Example</h3>
+<pre><code class="language-bash">npm prefix
+/usr/local/projects/foo
+</code></pre>
+<pre><code class="language-bash">npm prefix -g
+/usr/local
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-root.html">npm root</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-prefix.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-profile.html b/node/node_modules/npm/docs/output/commands/npm-profile.html
new file mode 100644
index 0000000000000000000000000000000000000000..b2f304ccb5fdbf58eac503192e2675c111bbc206
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-profile.html
@@ -0,0 +1,309 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-profile</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-profile----11130">
+    <span>npm-profile</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Change settings on your registry profile</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#details">Details</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#otp"><code>otp</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm profile enable-2fa [auth-only|auth-and-writes]
+npm profile disable-2fa
+npm profile get [&lt;key&gt;]
+npm profile set &lt;key&gt; &lt;value&gt;
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Change your profile information on the registry.
+Note that this command depends on the registry implementation, so third-party registries may not support this interface.</p>
+<ul>
+<li><code>npm profile get [&lt;property&gt;]</code>: Display all of the properties of your profile, or one or more specific properties.
+It looks like:</li>
+</ul>
+<pre><code>name: example
+email: e@example.com (verified)
+two-factor auth: auth-and-writes
+fullname: Example User
+homepage:
+freenode:
+twitter:
+github:
+created: 2015-02-26T01:38:35.892Z
+updated: 2017-10-02T21:29:45.922Z
+</code></pre>
+<ul>
+<li>
+<p><code>npm profile set &lt;property&gt; &lt;value&gt;</code>: Set the value of a profile property.
+You can set the following properties this way: email, fullname, homepage, freenode, twitter, github</p>
+</li>
+<li>
+<p><code>npm profile set password</code>: Change your password.
+This is interactive, you'll be prompted for your current password and a new password.
+You'll also be prompted for an OTP if you have two-factor authentication enabled.</p>
+</li>
+<li>
+<p><code>npm profile enable-2fa [auth-and-writes|auth-only]</code>: Enables two-factor authentication.
+Defaults to <code>auth-and-writes</code> mode.
+Modes are:</p>
+<ul>
+<li><code>auth-only</code>: Require an OTP when logging in or making changes to your account's authentication.
+The OTP will be required on both the website and the command line.</li>
+<li><code>auth-and-writes</code>: Requires an OTP at all the times <code>auth-only</code> does, and also requires one when publishing a module, setting the <code>latest</code> dist-tag, or changing access via <code>npm access</code> and <code>npm owner</code>.</li>
+</ul>
+</li>
+<li>
+<p><code>npm profile disable-2fa</code>: Disables two-factor authentication.</p>
+</li>
+</ul>
+<h3 id="details">Details</h3>
+<p>Some of these commands may not be available on non npmjs.com registries.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-token.html">npm token</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-profile.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-prune.html b/node/node_modules/npm/docs/output/commands/npm-prune.html
new file mode 100644
index 0000000000000000000000000000000000000000..d0db33352c4867f6789a89d3842eca652a587853
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-prune.html
@@ -0,0 +1,352 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-prune</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-prune----11130">
+    <span>npm-prune</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Remove extraneous packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm prune [[&lt;@scope&gt;/]&lt;pkg&gt;...]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command removes "extraneous" packages.
+If a package name is provided, then only packages matching one of the supplied names are removed.</p>
+<p>Extraneous packages are those present in the <code>node_modules</code> folder that are not listed as any package's dependency list.</p>
+<p>If the <code>--omit=dev</code> flag is specified or the <code>NODE_ENV</code> environment variable is set to <code>production</code>, this command will remove the packages specified in your <code>devDependencies</code>.</p>
+<p>If the <code>--dry-run</code> flag is used then no changes will actually be made.</p>
+<p>If the <code>--json</code> flag is used, then the changes <code>npm prune</code> made (or would have made with <code>--dry-run</code>) are printed as a JSON object.</p>
+<p>In normal operation, extraneous modules are pruned automatically, so you'll only need this command with the <code>--production</code> flag.
+However, in the real world, operation is not always "normal".  When crashes or mistakes happen, this command can help clean up any resulting garbage.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-uninstall.html">npm uninstall</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-prune.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-publish.html b/node/node_modules/npm/docs/output/commands/npm-publish.html
new file mode 100644
index 0000000000000000000000000000000000000000..4b35f2aedd6b0545c2d7d1c43a3569b56d03fde6
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-publish.html
@@ -0,0 +1,396 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-publish</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-publish----11130">
+    <span>npm-publish</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Publish a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#examples">Examples</a></li><li><a href="#files-included-in-package">Files included in package</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#tag"><code>tag</code></a></li><li><a href="#access"><code>access</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#provenance"><code>provenance</code></a></li><li><a href="#provenance-file"><code>provenance-file</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm publish &lt;package-spec&gt;
+</code></pre>
+<h3 id="description">Description</h3>
+<p>Publishes a package to the registry so that it can be installed by name.</p>
+<h3 id="examples">Examples</h3>
+<p>Publish the package in the current directory:</p>
+<pre><code class="language-bash">npm publish
+</code></pre>
+<p>Publish a specific workspace:</p>
+<pre><code class="language-bash">npm publish --workspace=&lt;workspace-name&gt;
+</code></pre>
+<p>Publish multiple workspaces:</p>
+<pre><code class="language-bash">npm publish --workspace=workspace-a --workspace=workspace-b
+</code></pre>
+<p>Publish all workspaces:</p>
+<pre><code class="language-bash">npm publish --workspaces
+</code></pre>
+<p>By default npm will publish to the public registry.
+This can be overridden by specifying a different default registry or using a <a href="../using-npm/scope.html"><code>scope</code></a> in the name, combined with a scope-configured registry (see <a href="../configuring-npm/package-json.html"><code>package.json</code></a>).</p>
+<p>A <code>package</code> is interpreted the same way as other commands (like <code>npm install</code>) and can be:</p>
+<ul>
+<li>a) a folder containing a program described by a <a href="../configuring-npm/package-json.html"><code>package.json</code></a> file</li>
+<li>b) a gzipped tarball containing (a)</li>
+<li>c) a url that resolves to (b)</li>
+<li>d) a <code>&lt;name&gt;@&lt;version&gt;</code> that is published on the registry (see <a href="../using-npm/registry.html"><code>registry</code></a>) with (c)</li>
+<li>e) a <code>&lt;name&gt;@&lt;tag&gt;</code> (see <a href="../commands/npm-dist-tag.html"><code>npm dist-tag</code></a>) that points to (d)</li>
+<li>f) a <code>&lt;name&gt;</code> that has a "latest" tag satisfying (e)</li>
+<li>g) a <code>&lt;git remote url&gt;</code> that resolves to (a)</li>
+</ul>
+<p>If either (a) or (b) is specified as a relative path, it should begin with an explicit <code>./</code> prefix.</p>
+<p>The publish will fail if the package name and version combination already exists in the specified registry.</p>
+<p>Once a package is published with a given name and version, that specific name and version combination can never be used again, even if it is removed with <a href="../commands/npm-unpublish.html"><code>npm unpublish</code></a>.</p>
+<p>As of <code>npm@5</code>, both a sha1sum and an integrity field with a sha512sum of the tarball will be submitted to the registry during publication.
+Subsequent installs will use the strongest supported algorithm to verify downloads.</p>
+<p>Similar to <code>--dry-run</code> see <a href="../commands/npm-pack.html"><code>npm pack</code></a>, which figures out the files to be included and packs them into a tarball to be uploaded to the registry.</p>
+<h3 id="files-included-in-package">Files included in package</h3>
+<p>To see what will be included in your package, run <code>npm pack --dry-run</code>.
+All files are included by default, with the following exceptions:</p>
+<ul>
+<li>
+<p>Certain files that are relevant to package installation and distribution are always included.
+For example, <code>package.json</code>, <code>README.md</code>,
+<code>LICENSE</code>, and so on.</p>
+</li>
+<li>
+<p>If there is a "files" list in <a href="../configuring-npm/package-json.html"><code>package.json</code></a>, then only the files specified will be included.
+(If directories are specified, then they will be walked recursively and their contents included, subject to the same ignore rules.)</p>
+</li>
+<li>
+<p>If there is a <code>.gitignore</code> or <code>.npmignore</code> file, then ignored files in that and all child directories will be excluded from the package.
+If <em>both</em> files exist, then the <code>.gitignore</code> is ignored, and only the
+<code>.npmignore</code> is used.</p>
+<p><code>.npmignore</code> files follow the <a href="https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring">same pattern rules</a> as <code>.gitignore</code> files</p>
+</li>
+<li>
+<p>If the file matches certain patterns, then it will <em>never</em> be included, unless explicitly added to the <code>"files"</code> list in <code>package.json</code>, or un-ignored with a <code>!</code> rule in a <code>.npmignore</code> or <code>.gitignore</code> file.</p>
+</li>
+<li>
+<p>Symbolic links are never included in npm packages.</p>
+</li>
+</ul>
+<p>See <a href="../using-npm/developers.html"><code>developers</code></a> for full details on what's included in the published package, as well as details on how the package is built.</p>
+<p>See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more info on what can and can't be ignored.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="tag"><code>tag</code></h4>
+<ul>
+<li>Default: "latest"</li>
+<li>Type: String</li>
+</ul>
+<p>If you ask npm to install a package and don't tell it a specific version,
+then it will install the specified tag.</p>
+<p>It is the tag added to the package@version specified in the <code>npm dist-tag add</code> command, if no explicit tag is given.</p>
+<p>When used by the <code>npm diff</code> command, this is the tag used to fetch the
+tarball that will be compared with the local files by default.</p>
+<p>If used in the <code>npm publish</code> command, this is the tag that will be added to
+the package submitted to the registry.</p>
+<h4 id="access"><code>access</code></h4>
+<ul>
+<li>Default: 'public' for new packages, existing packages it will not change the
+current level</li>
+<li>Type: null, "restricted", or "public"</li>
+</ul>
+<p>If you do not want your scoped package to be publicly viewable (and
+installable) set <code>--access=restricted</code>.</p>
+<p>Unscoped packages cannot be set to <code>restricted</code>.</p>
+<p>Note: This defaults to not changing the current access level for existing
+packages. Specifying a value of <code>restricted</code> or <code>public</code> during publish will
+change the access for an existing package the same way that <code>npm access set status</code> would.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="provenance"><code>provenance</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When publishing from a supported cloud CI/CD system, the package will be
+publicly linked to where it was built and published from.</p>
+<p>This config cannot be used with: <code>provenance-file</code></p>
+<h4 id="provenance-file"><code>provenance-file</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: Path</li>
+</ul>
+<p>When publishing, the provenance bundle at the given path will be used.</p>
+<p>This config cannot be used with: <code>provenance</code></p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="http://npm.im/npm-packlist">npm-packlist package</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../using-npm/scope.html">npm scope</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-deprecate.html">npm deprecate</a></li>
+<li><a href="../commands/npm-dist-tag.html">npm dist-tag</a></li>
+<li><a href="../commands/npm-pack.html">npm pack</a></li>
+<li><a href="../commands/npm-profile.html">npm profile</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-publish.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-query.html b/node/node_modules/npm/docs/output/commands/npm-query.html
new file mode 100644
index 0000000000000000000000000000000000000000..ebe9ecda225b363d600ed624f58e74cb07fdbb48
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-query.html
@@ -0,0 +1,434 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-query</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-query----11130">
+    <span>npm-query</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Dependency selector query</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm query &lt;selector&gt;
+</code></pre>
+<h3 id="description">Description</h3>
+<p>The <code>npm query</code> command allows for usage of css selectors in order to retrieve an array of dependency objects.</p>
+<h3 id="piping-npm-query-to-other-commands">Piping npm query to other commands</h3>
+<pre><code class="language-bash"># find all dependencies with postinstall scripts &amp; uninstall them
+npm query ":attr(scripts, [postinstall])" | jq 'map(.name)|join("\n")' -r | xargs -I {} npm uninstall {}
+
+# find all git dependencies &amp; explain who requires them
+npm query ":type(git)" | jq 'map(.name)' | xargs -I {} npm why {}
+</code></pre>
+<h3 id="extended-use-cases--queries">Extended Use Cases &amp; Queries</h3>
+<pre><code class="language-stylus">// all deps
+*
+
+// all direct deps
+:root &gt; *
+
+// direct production deps
+:root &gt; .prod
+
+// direct development deps
+:root &gt; .dev
+
+// any peer dep of a direct deps
+:root &gt; * &gt; .peer
+
+// any workspace dep
+.workspace
+
+// all workspaces that depend on another workspace
+.workspace &gt; .workspace
+
+// all workspaces that have peer deps
+.workspace:has(.peer)
+
+// any dep named "lodash"
+// equivalent to [name="lodash"]
+#lodash
+
+// any deps named "lodash" &amp; within semver range ^"1.2.3"
+#lodash@^1.2.3
+// equivalent to...
+[name="lodash"]:semver(^1.2.3)
+
+// get the hoisted node for a given semver range
+#lodash@^1.2.3:not(:deduped)
+
+// querying deps with a specific version
+#lodash@2.1.5
+// equivalent to...
+[name="lodash"][version="2.1.5"]
+
+// has any deps
+:has(*)
+
+// deps with no other deps (ie. "leaf" nodes)
+:empty
+
+// manually querying git dependencies
+[repository^=github:],
+[repository^=git:],
+[repository^=https://github.com],
+[repository^=http://github.com],
+[repository^=https://github.com],
+[repository^=+git:...]
+
+// querying for all git dependencies
+:type(git)
+
+// get production dependencies that aren't also dev deps
+.prod:not(.dev)
+
+// get dependencies with specific licenses
+[license=MIT], [license=ISC]
+
+// find all packages that have @ruyadorno as a contributor
+:attr(contributors, [email=ruyadorno@github.com])
+</code></pre>
+<h3 id="example-response-output">Example Response Output</h3>
+<ul>
+<li>an array of dependency objects is returned which can contain multiple copies of the same package which may or may not have been linked or deduped</li>
+</ul>
+<pre><code class="language-json">[
+  {
+    "name": "",
+    "version": "",
+    "description": "",
+    "homepage": "",
+    "bugs": {},
+    "author": {},
+    "license": {},
+    "funding": {},
+    "files": [],
+    "main": "",
+    "browser": "",
+    "bin": {},
+    "man": [],
+    "directories": {},
+    "repository": {},
+    "scripts": {},
+    "config": {},
+    "dependencies": {},
+    "devDependencies": {},
+    "optionalDependencies": {},
+    "bundledDependencies": {},
+    "peerDependencies": {},
+    "peerDependenciesMeta": {},
+    "engines": {},
+    "os": [],
+    "cpu": [],
+    "workspaces": {},
+    "keywords": [],
+    ...
+  },
+  ...
+</code></pre>
+<h3 id="expecting-a-certain-number-of-results">Expecting a certain number of results</h3>
+<p>One common use of <code>npm query</code> is to make sure there is only one version of a certain dependency in your tree.
+This is especially common for ecosystems like that rely on <code>typescript</code> where having state split across two different but identically-named packages causes bugs.
+You can use the <code>--expect-results</code> or <code>--expect-result-count</code> in your setup to ensure that npm will exit with an exit code if your tree doesn't look like you want it to.</p>
+<pre><code class="language-sh">$ npm query '#react' --expect-result-count=1
+</code></pre>
+<p>Perhaps you want to quickly check if there are any production dependencies that could be updated:</p>
+<pre><code class="language-sh">$ npm query ':root&gt;:outdated(in-range).prod' --no-expect-results
+</code></pre>
+<h3 id="package-lock-only-mode">Package lock only mode</h3>
+<p>If package-lock-only is enabled, only the information in the package lock (or shrinkwrap) is loaded.
+This means that information from the package.json files of your dependencies will not be included in the result set (e.g. description, homepage, engines).</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="expect-results"><code>expect-results</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Tells npm whether or not to expect results from the command. Can be either
+true (expect some results) or false (expect no results).</p>
+<p>This config cannot be used with: <code>expect-result-count</code></p>
+<h4 id="expect-result-count"><code>expect-result-count</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>Tells to expect a specific number of results from the command.</p>
+<p>This config cannot be used with: <code>expect-results</code></p>
+<h2 id="see-also">See Also</h2>
+<ul>
+<li><a href="../using-npm/dependency-selectors.html">dependency selectors</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-query.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-rebuild.html b/node/node_modules/npm/docs/output/commands/npm-rebuild.html
new file mode 100644
index 0000000000000000000000000000000000000000..a970570d7984abc109c3581b88dde618602f502b
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-rebuild.html
@@ -0,0 +1,343 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-rebuild</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-rebuild----11130">
+    <span>npm-rebuild</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Rebuild a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#global"><code>global</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm rebuild [&lt;package-spec&gt;] ...]
+
+alias: rb
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command does the following:</p>
+<ol>
+<li>Execute lifecycle scripts (<code>preinstall</code>, <code>install</code>, <code>postinstall</code>, <code>prepare</code>)</li>
+<li>Links bins depending on whether bin links are enabled</li>
+</ol>
+<p>This command is particularly useful in scenarios including but not limited to:</p>
+<ol>
+<li>Installing a new version of <strong>node.js</strong>, where you need to recompile all your C++ add-ons with the updated binary.</li>
+<li>Installing with <code>--ignore-scripts</code> and <code>--no-bin-links</code>, to explicitly choose which packages to build and/or link bins.</li>
+</ol>
+<p>If one or more package specs are provided, then only packages with a name and version matching one of the specifiers will be rebuilt.</p>
+<p>Usually, you should not need to run <code>npm rebuild</code> as it is already done for you as part of npm install (unless you suppressed these steps with <code>--ignore-scripts</code> or <code>--no-bin-links</code>).</p>
+<p>If there is a <code>binding.gyp</code> file in the root of your package, then npm will use a default install hook:</p>
+<pre><code>"scripts": {
+    "install": "node-gyp rebuild"
+}
+</code></pre>
+<p>This default behavior is suppressed if the <code>package.json</code> has its own <code>install</code> or <code>preinstall</code> scripts.
+It is also suppressed if the package specifies <code>"gypfile": false</code></p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-rebuild.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-repo.html b/node/node_modules/npm/docs/output/commands/npm-repo.html
new file mode 100644
index 0000000000000000000000000000000000000000..e9c86b64ce983478d33382d45baca7a68afa53a1
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-repo.html
@@ -0,0 +1,286 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-repo</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-repo----11130">
+    <span>npm-repo</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Open package repository page in the browser</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#browser"><code>browser</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm repo [&lt;pkgname&gt; [&lt;pkgname&gt; ...]]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command tries to guess at the likely location of a package's repository URL, and then tries to open it using the <a href="../using-npm/config#browser.html"><code>--browser</code> config</a> param.
+If no package name is provided, it will search for a <code>package.json</code> in the current folder and use the <code>repository</code> property.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="browser"><code>browser</code></h4>
+<ul>
+<li>Default: macOS: <code>"open"</code>, Windows: <code>"start"</code>, Others: <code>"xdg-open"</code></li>
+<li>Type: null, Boolean, or String</li>
+</ul>
+<p>The browser that is called by npm commands to open websites.</p>
+<p>Set to <code>false</code> to suppress browser behavior and instead print urls to
+terminal.</p>
+<p>Set to <code>true</code> to use default system URL opener.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-docs.html">npm docs</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-repo.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-restart.html b/node/node_modules/npm/docs/output/commands/npm-restart.html
new file mode 100644
index 0000000000000000000000000000000000000000..cc86e6a8b5d29071371204c0156bb9a52dd06e70
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-restart.html
@@ -0,0 +1,263 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-restart</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-restart----11130">
+    <span>npm-restart</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Restart a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm restart [-- &lt;args&gt;]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This restarts a project.
+It is equivalent to running <code>npm run restart</code>.</p>
+<p>If the current project has a <code>"restart"</code> script specified in <code>package.json</code>, then the following scripts will be run:</p>
+<ol>
+<li>prerestart</li>
+<li>restart</li>
+<li>postrestart</li>
+</ol>
+<p>If it does <em>not</em> have a <code>"restart"</code> script specified, but it does have <code>stop</code> and/or <code>start</code> scripts, then the following scripts will be run:</p>
+<ol>
+<li>prerestart</li>
+<li>prestop</li>
+<li>stop</li>
+<li>poststop</li>
+<li>prestart</li>
+<li>start</li>
+<li>poststart</li>
+<li>postrestart</li>
+</ol>
+<h3 id="configuration">Configuration</h3>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="script-shell"><code>script-shell</code></h4>
+<ul>
+<li>Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows</li>
+<li>Type: null or String</li>
+</ul>
+<p>The shell to use for scripts run with the <code>npm exec</code>, <code>npm run</code> and <code>npm init &lt;package-spec&gt;</code> commands.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+<li><a href="../commands/npm-start.html">npm start</a></li>
+<li><a href="../commands/npm-stop.html">npm stop</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-restart.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-root.html b/node/node_modules/npm/docs/output/commands/npm-root.html
new file mode 100644
index 0000000000000000000000000000000000000000..3647cc76f525c1c30cda8659659b71fe81825ac9
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-root.html
@@ -0,0 +1,248 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-root</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-root----11130">
+    <span>npm-root</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Display npm root</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#global"><code>global</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm root
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Print the effective <code>node_modules</code> folder to standard out.</p>
+<p>Useful for using npm in shell scripts that do things with the <code>node_modules</code> folder.
+For example:</p>
+<pre><code class="language-bash">#!/bin/bash
+global_node_modules="$(npm root --global)"
+echo "Global packages installed in: ${global_node_modules}"
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-prefix.html">npm prefix</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-root.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-run.html b/node/node_modules/npm/docs/output/commands/npm-run.html
new file mode 100644
index 0000000000000000000000000000000000000000..19211a4a16e6074b96cd85a65f04acbe275f0d0f
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-run.html
@@ -0,0 +1,376 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-run</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-run----11130">
+    <span>npm-run</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Run arbitrary package scripts</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#workspaces-support">Workspaces support</a></li><ul><li><a href="#filtering-workspaces">Filtering workspaces</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#if-present"><code>if-present</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm run &lt;command&gt; [-- &lt;args&gt;]
+
+aliases: run-script, rum, urn
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This runs an arbitrary command from a package's <code>"scripts"</code> object.
+If no
+<code>"command"</code> is provided, it will list the available scripts.</p>
+<p><code>run[-script]</code> is used by the test, start, restart, and stop commands, but can be called directly, as well.
+When the scripts in the package are printed out, they're separated into lifecycle (test, start, restart) and directly-run scripts.</p>
+<p>Any positional arguments are passed to the specified script.
+Use <code>--</code> to pass <code>-</code>-prefixed flags and options which would otherwise be parsed by npm.</p>
+<p>For example:</p>
+<pre><code class="language-bash">npm run test -- --grep="pattern"
+</code></pre>
+<p>The arguments will only be passed to the script specified after <code>npm run</code> and not to any <code>pre</code> or <code>post</code> script.</p>
+<p>The <code>env</code> script is a special built-in command that can be used to list environment variables that will be available to the script at runtime.
+If an "env" command is defined in your package, it will take precedence over the built-in.</p>
+<p>In addition to the shell's pre-existing <code>PATH</code>, <code>npm run</code> adds <code>node_modules/.bin</code> to the <code>PATH</code> provided to scripts.
+Any binaries provided by locally-installed dependencies can be used without the <code>node_modules/.bin</code> prefix.
+For example, if there is a <code>devDependency</code> on <code>tap</code> in your package, you should write:</p>
+<pre><code class="language-bash">"scripts": {"test": "tap test/*.js"}
+</code></pre>
+<p>instead of</p>
+<pre><code class="language-bash">"scripts": {"test": "node_modules/.bin/tap test/*.js"}
+</code></pre>
+<p>The actual shell your script is run within is platform dependent.
+By default, on Unix-like systems it is the <code>/bin/sh</code> command, on Windows it is <code>cmd.exe</code>.
+The actual shell referred to by <code>/bin/sh</code> also depends on the system.
+You can customize the shell with the <a href="../using-npm/config#script-shell.html"><code>script-shell</code> config</a>.</p>
+<p>Scripts are run from the root of the package folder, regardless of what the current working directory is when <code>npm run</code> is called.
+If you want your script to use different behavior based on what subdirectory you're in, you can use the <code>INIT_CWD</code> environment variable, which holds the full path you were in when you ran <code>npm run</code>.</p>
+<p><code>npm run</code> sets the <code>NODE</code> environment variable to the <code>node</code> executable with which <code>npm</code> is executed.</p>
+<p>If you try to run a script without having a <code>node_modules</code> directory and it fails, you will be given a warning to run <code>npm install</code>, just in case you've forgotten.</p>
+<h3 id="workspaces-support">Workspaces support</h3>
+<p>You may use the <a href="../using-npm/config#workspace.html"><code>workspace</code></a> or <a href="../using-npm/config#workspaces.html"><code>workspaces</code></a> configs in order to run an arbitrary command from a package's <code>"scripts"</code> object in the context of the specified workspaces.
+If no <code>"command"</code> is provided, it will list the available scripts for each of these configured workspaces.</p>
+<p>Given a project with configured workspaces, e.g:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   +-- b
+   |   `-- package.json
+   `-- c
+       `-- package.json
+</code></pre>
+<p>Assuming the workspace configuration is properly set up at the root level <code>package.json</code> file.
+e.g:</p>
+<pre><code>{
+    "workspaces": [ "./packages/*" ]
+}
+</code></pre>
+<p>And that each of the configured workspaces has a configured <code>test</code> script, we can run tests in all of them using the <a href="../using-npm/config#workspaces.html"><code>workspaces</code> config</a>:</p>
+<pre><code>npm test --workspaces
+</code></pre>
+<h4 id="filtering-workspaces">Filtering workspaces</h4>
+<p>It's also possible to run a script in a single workspace using the <code>workspace</code> config along with a name or directory path:</p>
+<pre><code>npm test --workspace=a
+</code></pre>
+<p>The <code>workspace</code> config can also be specified multiple times in order to run a specific script in the context of multiple workspaces.
+When defining values for the <code>workspace</code> config in the command line, it also possible to use <code>-w</code> as a shorthand, e.g:</p>
+<pre><code>npm test -w a -w b
+</code></pre>
+<p>This last command will run <code>test</code> in both <code>./packages/a</code> and <code>./packages/b</code> packages.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="if-present"><code>if-present</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm will not exit with an error code when <code>run</code> is invoked for a
+script that isn't defined in the <code>scripts</code> section of <code>package.json</code>. This
+option can be used when it's desirable to optionally run a script when it's
+present and fail if the script fails. This is useful, for example, when
+running scripts that may only apply for some builds in an otherwise generic
+CI setup.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="script-shell"><code>script-shell</code></h4>
+<ul>
+<li>Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows</li>
+<li>Type: null or String</li>
+</ul>
+<p>The shell to use for scripts run with the <code>npm exec</code>, <code>npm run</code> and <code>npm init &lt;package-spec&gt;</code> commands.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+<li><a href="../commands/npm-start.html">npm start</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+<li><a href="../commands/npm-stop.html">npm stop</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/workspaces.html">npm workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-run.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-sbom.html b/node/node_modules/npm/docs/output/commands/npm-sbom.html
new file mode 100644
index 0000000000000000000000000000000000000000..82f14db2a5c22bafc2ffa6abb3f38be53d16e0da
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-sbom.html
@@ -0,0 +1,490 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-sbom</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-sbom----11130">
+    <span>npm-sbom</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Generate a Software Bill of Materials (SBOM)</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm sbom
+</code></pre>
+<h3 id="description">Description</h3>
+<p>The <code>npm sbom</code> command generates a Software Bill of Materials (SBOM) listing the dependencies for the current project.
+SBOMs can be generated in either <a href="https://spdx.dev/">SPDX</a> or <a href="https://cyclonedx.org/">CycloneDX</a> format.</p>
+<h3 id="example-cyclonedx-sbom">Example CycloneDX SBOM</h3>
+<pre><code class="language-json">{
+  "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "serialNumber": "urn:uuid:09f55116-97e1-49cf-b3b8-44d0207e7730",
+  "version": 1,
+  "metadata": {
+    "timestamp": "2023-09-01T00:00:00.001Z",
+    "lifecycles": [
+      {
+        "phase": "build"
+      }
+    ],
+    "tools": [
+      {
+        "vendor": "npm",
+        "name": "cli",
+        "version": "10.1.0"
+      }
+    ],
+    "component": {
+      "bom-ref": "simple@1.0.0",
+      "type": "library",
+      "name": "simple",
+      "version": "1.0.0",
+      "scope": "required",
+      "author": "John Doe",
+      "description": "simple react app",
+      "purl": "pkg:npm/simple@1.0.0",
+      "properties": [
+        {
+          "name": "cdx:npm:package:path",
+          "value": ""
+        }
+      ],
+      "externalReferences": [],
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    }
+  },
+  "components": [
+    {
+      "bom-ref": "lodash@4.17.21",
+      "type": "library",
+      "name": "lodash",
+      "version": "4.17.21",
+      "scope": "required",
+      "author": "John-David Dalton",
+      "description": "Lodash modular utilities.",
+      "purl": "pkg:npm/lodash@4.17.21",
+      "properties": [
+        {
+          "name": "cdx:npm:package:path",
+          "value": "node_modules/lodash"
+        }
+      ],
+      "externalReferences": [
+        {
+          "type": "distribution",
+          "url": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
+        },
+        {
+          "type": "vcs",
+          "url": "git+https://github.com/lodash/lodash.git"
+        },
+        {
+          "type": "website",
+          "url": "https://lodash.com/"
+        },
+        {
+          "type": "issue-tracker",
+          "url": "https://github.com/lodash/lodash/issues"
+        }
+      ],
+      "hashes": [
+        {
+          "alg": "SHA-512",
+          "content": "bf690311ee7b95e713ba568322e3533f2dd1cb880b189e99d4edef13592b81764daec43e2c54c61d5c558dc5cfb35ecb85b65519e74026ff17675b6f8f916f4a"
+        }
+      ],
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "simple@1.0.0",
+      "dependsOn": [
+        "lodash@4.17.21"
+      ]
+    },
+    {
+      "ref": "lodash@4.17.21",
+      "dependsOn": []
+    }
+  ]
+}
+</code></pre>
+<h3 id="example-spdx-sbom">Example SPDX SBOM</h3>
+<pre><code class="language-json">{
+  "spdxVersion": "SPDX-2.3",
+  "dataLicense": "CC0-1.0",
+  "SPDXID": "SPDXRef-DOCUMENT",
+  "name": "simple@1.0.0",
+  "documentNamespace": "http://spdx.org/spdxdocs/simple-1.0.0-bf81090e-8bbc-459d-bec9-abeb794e096a",
+  "creationInfo": {
+    "created": "2023-09-01T00:00:00.001Z",
+    "creators": [
+      "Tool: npm/cli-10.1.0"
+    ]
+  },
+  "documentDescribes": [
+    "SPDXRef-Package-simple-1.0.0"
+  ],
+  "packages": [
+    {
+      "name": "simple",
+      "SPDXID": "SPDXRef-Package-simple-1.0.0",
+      "versionInfo": "1.0.0",
+      "packageFileName": "",
+      "description": "simple react app",
+      "primaryPackagePurpose": "LIBRARY",
+      "downloadLocation": "NOASSERTION",
+      "filesAnalyzed": false,
+      "homepage": "NOASSERTION",
+      "licenseDeclared": "MIT",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/simple@1.0.0"
+        }
+      ]
+    },
+    {
+      "name": "lodash",
+      "SPDXID": "SPDXRef-Package-lodash-4.17.21",
+      "versionInfo": "4.17.21",
+      "packageFileName": "node_modules/lodash",
+      "description": "Lodash modular utilities.",
+      "downloadLocation": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "filesAnalyzed": false,
+      "homepage": "https://lodash.com/",
+      "licenseDeclared": "MIT",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/lodash@4.17.21"
+        }
+      ],
+      "checksums": [
+        {
+          "algorithm": "SHA512",
+          "checksumValue": "bf690311ee7b95e713ba568322e3533f2dd1cb880b189e99d4edef13592b81764daec43e2c54c61d5c558dc5cfb35ecb85b65519e74026ff17675b6f8f916f4a"
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "spdxElementId": "SPDXRef-DOCUMENT",
+      "relatedSpdxElement": "SPDXRef-Package-simple-1.0.0",
+      "relationshipType": "DESCRIBES"
+    },
+    {
+      "spdxElementId": "SPDXRef-Package-simple-1.0.0",
+      "relatedSpdxElement": "SPDXRef-Package-lodash-4.17.21",
+      "relationshipType": "DEPENDS_ON"
+    }
+  ]
+}
+</code></pre>
+<h3 id="package-lock-only-mode">Package lock only mode</h3>
+<p>If package-lock-only is enabled, only the information in the package lock (or shrinkwrap) is loaded.
+This means that information from the package.json files of your dependencies will not be included in the result set (e.g.
+description, homepage, engines).</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="sbom-format"><code>sbom-format</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: "cyclonedx" or "spdx"</li>
+</ul>
+<p>SBOM format to use when generating SBOMs.</p>
+<h4 id="sbom-type"><code>sbom-type</code></h4>
+<ul>
+<li>Default: "library"</li>
+<li>Type: "library", "application", or "framework"</li>
+</ul>
+<p>The type of package described by the generated SBOM. For SPDX, this is the
+value for the <code>primaryPackagePurpose</code> field. For CycloneDX, this is the
+value for the <code>type</code> field.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h2 id="see-also">See Also</h2>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../using-npm/dependency-selectors.html">dependency selectors</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../using-npm/workspaces.html">workspaces</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-sbom.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-search.html b/node/node_modules/npm/docs/output/commands/npm-search.html
new file mode 100644
index 0000000000000000000000000000000000000000..3e28bdeecf451e4b683c52657bf3c109694d77b6
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-search.html
@@ -0,0 +1,320 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-search</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-search----11130">
+    <span>npm-search</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Search for packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#json"><code>json</code></a></li><li><a href="#color"><code>color</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#description2"><code>description</code></a></li><li><a href="#searchlimit"><code>searchlimit</code></a></li><li><a href="#searchopts"><code>searchopts</code></a></li><li><a href="#searchexclude"><code>searchexclude</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#prefer-online"><code>prefer-online</code></a></li><li><a href="#prefer-offline"><code>prefer-offline</code></a></li><li><a href="#offline"><code>offline</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm search &lt;search term&gt; [&lt;search term&gt; ...]
+
+aliases: find, s, se
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Search the registry for packages matching the search terms.
+<code>npm search</code>
+performs a linear, incremental, lexically-ordered search through package metadata for all files in the registry.
+If your terminal has color support, it will further highlight the matches in the results.
+This can be disabled with the config item <code>color</code></p>
+<p>Additionally, using the <code>--searchopts</code> and <code>--searchexclude</code> options paired with more search terms will include and exclude further patterns.
+The main difference between <code>--searchopts</code> and the standard search terms is that the former does not highlight results in the output and you can use them more fine-grained filtering.
+Additionally, you can add both of these to your config to change default search filtering behavior.</p>
+<p>Search also allows targeting of maintainers in search results, by prefixing their npm username with <code>=</code>.</p>
+<p>If a term starts with <code>/</code>, then it's interpreted as a regular expression and supports standard JavaScript RegExp syntax.
+In this case search will ignore a trailing <code>/</code> .  (Note you must escape or quote many regular expression characters in most shells.)</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="color"><code>color</code></h4>
+<ul>
+<li>Default: true unless the NO_COLOR environ is set to something other than '0'</li>
+<li>Type: "always" or Boolean</li>
+</ul>
+<p>If false, never shows colors. If <code>"always"</code> then always shows colors. If
+true, then only prints color codes for tty file descriptors.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="description2"><code>description</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show the description in <code>npm search</code></p>
+<h4 id="searchlimit"><code>searchlimit</code></h4>
+<ul>
+<li>Default: 20</li>
+<li>Type: Number</li>
+</ul>
+<p>Number of items to limit search results to. Will not apply at all to legacy
+searches.</p>
+<h4 id="searchopts"><code>searchopts</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>Space-separated options that are always passed to search.</p>
+<h4 id="searchexclude"><code>searchexclude</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>Space-separated options that limit the results from search.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="prefer-online"><code>prefer-online</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, staleness checks for cached data will be forced, making the CLI
+look for updates immediately even for fresh package data.</p>
+<h4 id="prefer-offline"><code>prefer-offline</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, staleness checks for cached data will be bypassed, but missing data
+will be requested from the server. To force full offline mode, use
+<code>--offline</code>.</p>
+<h4 id="offline"><code>offline</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Force offline mode: no network requests will be done during install. To
+allow the CLI to fill in missing cache data, see <code>--prefer-offline</code>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-view.html">npm view</a></li>
+<li><a href="../commands/npm-cache.html">npm cache</a></li>
+<li><a href="https://npm.im/npm-registry-fetch">https://npm.im/npm-registry-fetch</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-search.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-set.html b/node/node_modules/npm/docs/output/commands/npm-set.html
new file mode 100644
index 0000000000000000000000000000000000000000..5b03c876fd66e6779d33f22442ca3e733c8e00c5
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-set.html
@@ -0,0 +1,255 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-set</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-set----11130">
+    <span>npm-set</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Set a value in the npm configuration</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#global"><code>global</code></a></li><li><a href="#location"><code>location</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm set &lt;key&gt;=&lt;value&gt; [&lt;key&gt;=&lt;value&gt; ...] (See `npm config`)
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Set a value in the npm configuration</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="location"><code>location</code></h4>
+<ul>
+<li>Default: "user" unless <code>--global</code> is passed, which will also set this value
+to "global"</li>
+<li>Type: "global", "user", or "project"</li>
+</ul>
+<p>When passed to <code>npm config</code> this refers to which config file to use.</p>
+<p>When set to "global" mode, packages are installed into the <code>prefix</code> folder
+instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-config.html">npm help config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-set.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-shrinkwrap.html b/node/node_modules/npm/docs/output/commands/npm-shrinkwrap.html
new file mode 100644
index 0000000000000000000000000000000000000000..17648c9fb98d03299f577fab24bd58ebf220c054
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-shrinkwrap.html
@@ -0,0 +1,232 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-shrinkwrap</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-shrinkwrap----11130">
+    <span>npm-shrinkwrap</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Lock down dependency versions for publication</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm shrinkwrap
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>This command repurposes <code>package-lock.json</code> into a publishable <code>npm-shrinkwrap.json</code> or simply creates a new one.
+The file created and updated by this command will then take precedence over any other existing or future <code>package-lock.json</code> files.
+For a detailed explanation of the design and purpose of package locks in npm, see <a href="../configuring-npm/package-lock-json.html">package-lock-json</a>.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../configuring-npm/package-lock-json.html">package-lock.json</a></li>
+<li><a href="../configuring-npm/npm-shrinkwrap-json.html">npm-shrinkwrap.json</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-shrinkwrap.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-star.html b/node/node_modules/npm/docs/output/commands/npm-star.html
new file mode 100644
index 0000000000000000000000000000000000000000..00cefecf2021ae135898abb8142c0de98310cfcf
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-star.html
@@ -0,0 +1,263 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-star</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-star----11130">
+    <span>npm-star</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Mark your favorite packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#more">More</a></li><ul><li><a href="#unstar">Unstar</a></li><li><a href="#listing-stars">Listing stars</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#otp"><code>otp</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm star [&lt;package-spec&gt;...]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>"Starring" a package means that you have some interest in it.
+It's a vaguely positive way to show that you care.</p>
+<p>It's a boolean thing.
+Starring repeatedly has no additional effect.</p>
+<h3 id="more">More</h3>
+<p>There's also these extra commands to help you manage your favorite packages:</p>
+<h4 id="unstar">Unstar</h4>
+<p>You can also "unstar" a package using <a href="../commands/npm-unstar.html"><code>npm unstar</code></a></p>
+<p>"Unstarring" is the same thing, but in reverse.</p>
+<h4 id="listing-stars">Listing stars</h4>
+<p>You can see all your starred packages using <a href="../commands/npm-stars.html"><code>npm stars</code></a></p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="unicode"><code>unicode</code></h4>
+<ul>
+<li>Default: false on windows, true on mac/unix systems with a unicode locale,
+as defined by the <code>LC_ALL</code>, <code>LC_CTYPE</code>, or <code>LANG</code> environment variables.</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-unstar.html">npm unstar</a></li>
+<li><a href="../commands/npm-stars.html">npm stars</a></li>
+<li><a href="../commands/npm-view.html">npm view</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-star.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-stars.html b/node/node_modules/npm/docs/output/commands/npm-stars.html
new file mode 100644
index 0000000000000000000000000000000000000000..56e5a0741d20c5267f4ed89116485dcd9711147d
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-stars.html
@@ -0,0 +1,236 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-stars</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-stars----11130">
+    <span>npm-stars</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">View packages marked as favorites</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm stars [&lt;user&gt;]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>If you have starred a lot of neat things and want to find them again quickly this command lets you do just that.</p>
+<p>You may also want to see your friend's favorite packages, in this case you will most certainly enjoy this command.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-star.html">npm star</a></li>
+<li><a href="../commands/npm-unstar.html">npm unstar</a></li>
+<li><a href="../commands/npm-view.html">npm view</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-stars.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-start.html b/node/node_modules/npm/docs/output/commands/npm-start.html
new file mode 100644
index 0000000000000000000000000000000000000000..a212b447cfa941be75fc690d6f0e2b89a1431038
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-start.html
@@ -0,0 +1,263 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-start</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-start----11130">
+    <span>npm-start</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Start a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm start [-- &lt;args&gt;]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This runs a predefined command specified in the <code>"start"</code> property of a package's <code>"scripts"</code> object.</p>
+<p>If the <code>"scripts"</code> object does not define a  <code>"start"</code> property, npm will run <code>node server.js</code>.</p>
+<p>Note that this is different from the default node behavior of running the file specified in a package's <code>"main"</code> attribute when evoking with <code>node .</code></p>
+<p>As of <a href="https://blog.npmjs.org/post/98131109725/npm-2-0-0"><code>npm@2.0.0</code></a>, you can use custom arguments when executing scripts.
+Refer to <a href="../commands/npm-run.html"><code>npm run</code></a> for more details.</p>
+<h3 id="example">Example</h3>
+<pre><code class="language-json">{
+  "scripts": {
+    "start": "node foo.js"
+  }
+}
+</code></pre>
+<pre><code class="language-bash">npm start
+
+&gt; npm@x.x.x start
+&gt; node foo.js
+
+(foo.js output would be here)
+
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="script-shell"><code>script-shell</code></h4>
+<ul>
+<li>Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows</li>
+<li>Type: null or String</li>
+</ul>
+<p>The shell to use for scripts run with the <code>npm exec</code>, <code>npm run</code> and <code>npm init &lt;package-spec&gt;</code> commands.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+<li><a href="../commands/npm-stop.html">npm stop</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-start.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-stop.html b/node/node_modules/npm/docs/output/commands/npm-stop.html
new file mode 100644
index 0000000000000000000000000000000000000000..ba94fe72b9040aecd9100743a64af19a281b45e9
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-stop.html
@@ -0,0 +1,260 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-stop</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-stop----11130">
+    <span>npm-stop</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Stop a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm stop [-- &lt;args&gt;]
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This runs a predefined command specified in the "stop" property of a package's "scripts" object.</p>
+<p>Unlike with <a href="../commands/npm-start.html">npm start</a>, there is no default script that will run if the <code>"stop"</code> property is not defined.</p>
+<h3 id="example">Example</h3>
+<pre><code class="language-json">{
+  "scripts": {
+    "stop": "node bar.js"
+  }
+}
+</code></pre>
+<pre><code class="language-bash">npm stop
+
+&gt; npm@x.x.x stop
+&gt; node bar.js
+
+(bar.js output would be here)
+
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="script-shell"><code>script-shell</code></h4>
+<ul>
+<li>Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows</li>
+<li>Type: null or String</li>
+</ul>
+<p>The shell to use for scripts run with the <code>npm exec</code>, <code>npm run</code> and <code>npm init &lt;package-spec&gt;</code> commands.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+<li><a href="../commands/npm-start.html">npm start</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-stop.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-team.html b/node/node_modules/npm/docs/output/commands/npm-team.html
new file mode 100644
index 0000000000000000000000000000000000000000..f39ba092331b0ab45b4c428f16d963db57c9ba7a
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-team.html
@@ -0,0 +1,314 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-team</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-team----11130">
+    <span>npm-team</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manage organization teams and team memberships</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#details">Details</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#json"><code>json</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm team create &lt;scope:team&gt; [--otp &lt;otpcode&gt;]
+npm team destroy &lt;scope:team&gt; [--otp &lt;otpcode&gt;]
+npm team add &lt;scope:team&gt; &lt;user&gt; [--otp &lt;otpcode&gt;]
+npm team rm &lt;scope:team&gt; &lt;user&gt; [--otp &lt;otpcode&gt;]
+npm team ls &lt;scope&gt;|&lt;scope:team&gt;
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Used to manage teams in organizations, and change team memberships.
+Does not handle permissions for packages.</p>
+<p>Teams must always be fully qualified with the organization/scope they belong to when operating on them, separated by a colon (<code>:</code>).
+That is, if you have a <code>newteam</code> team in an <code>org</code> organization, you must always refer to that team as <code>@org:newteam</code> in these commands.</p>
+<p>If you have two-factor authentication enabled in <code>auth-and-writes</code> mode, then you can provide a code from your authenticator with <code>[--otp &lt;otpcode&gt;]</code>.
+If you don't include this then you will be taken through a second factor flow based on your <code>authtype</code>.</p>
+<ul>
+<li>
+<p>create / destroy:
+Create a new team, or destroy an existing one.
+Note: You cannot remove the <code>developers</code> team, <a href="https://docs.npmjs.com/about-developers-team">learn more.</a></p>
+<p>Here's how to create a new team <code>newteam</code> under the <code>org</code> org:</p>
+<pre><code class="language-bash">npm team create @org:newteam
+</code></pre>
+<p>You should see a confirming message such as: <code>+@org:newteam</code> once the new team has been created.</p>
+</li>
+<li>
+<p>add:
+Add a user to an existing team.</p>
+<p>Adding a new user <code>username</code> to a team named <code>newteam</code> under the <code>org</code> org:</p>
+<pre><code class="language-bash">npm team add @org:newteam username
+</code></pre>
+<p>On success, you should see a message: <code>username added to @org:newteam</code></p>
+</li>
+<li>
+<p>rm:
+Using <code>npm team rm</code> you can also remove users from a team they belong to.</p>
+<p>Here's an example removing user <code>username</code> from <code>newteam</code> team in <code>org</code> organization:</p>
+<pre><code class="language-bash">npm team rm @org:newteam username
+</code></pre>
+<p>Once the user is removed a confirmation message is displayed:
+<code>username removed from @org:newteam</code></p>
+</li>
+<li>
+<p>ls:
+If performed on an organization name, will return a list of existing teams under that organization.
+If performed on a team, it will instead return a list of all users belonging to that particular team.</p>
+<p>Here's an example of how to list all teams from an org named <code>org</code>:</p>
+<pre><code class="language-bash">npm team ls @org
+</code></pre>
+<p>Example listing all members of a team named <code>newteam</code>:</p>
+<pre><code class="language-bash">npm team ls @org:newteam
+</code></pre>
+</li>
+</ul>
+<h3 id="details">Details</h3>
+<p><code>npm team</code> always operates directly on the current registry, configurable from the command line using <code>--registry=&lt;registry url&gt;</code>.</p>
+<p>You must be a <em>team admin</em> to create teams and manage team membership, under the given organization.
+Listing teams and team memberships may be done by any member of the organization.</p>
+<p>Organization creation and management of team admins and <em>organization</em> members is done through the website, not the npm CLI.</p>
+<p>To use teams to manage permissions on packages belonging to your organization, use the <code>npm access</code> command to grant or revoke the appropriate permissions.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-access.html">npm access</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-team.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-test.html b/node/node_modules/npm/docs/output/commands/npm-test.html
new file mode 100644
index 0000000000000000000000000000000000000000..0a3d484c69fa903e95732d84c6d95c15313be33d
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-test.html
@@ -0,0 +1,259 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-test</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-test----11130">
+    <span>npm-test</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Test a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm test [-- &lt;args&gt;]
+
+aliases: tst, t
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This runs a predefined command specified in the <code>"test"</code> property of a package's <code>"scripts"</code> object.</p>
+<h3 id="example">Example</h3>
+<pre><code class="language-json">{
+  "scripts": {
+    "test": "node test.js"
+  }
+}
+</code></pre>
+<pre><code class="language-bash">npm test
+&gt; npm@x.x.x test
+&gt; node test.js
+
+(test.js output would be here)
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="script-shell"><code>script-shell</code></h4>
+<ul>
+<li>Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows</li>
+<li>Type: null or String</li>
+</ul>
+<p>The shell to use for scripts run with the <code>npm exec</code>, <code>npm run</code> and <code>npm init &lt;package-spec&gt;</code> commands.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-start.html">npm start</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+<li><a href="../commands/npm-stop.html">npm stop</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-test.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-token.html b/node/node_modules/npm/docs/output/commands/npm-token.html
new file mode 100644
index 0000000000000000000000000000000000000000..07147bc2650289a1e3c9714c46aa46a004ee0b8e
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-token.html
@@ -0,0 +1,351 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-token</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-token----11130">
+    <span>npm-token</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manage your authentication tokens</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#listing-tokens">Listing tokens</a></li><li><a href="#generating-tokens">Generating tokens</a></li><li><a href="#revoking-tokens">Revoking tokens</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#name"><code>name</code></a></li><li><a href="#token-description"><code>token-description</code></a></li><li><a href="#expires"><code>expires</code></a></li><li><a href="#packages"><code>packages</code></a></li><li><a href="#packages-all"><code>packages-all</code></a></li><li><a href="#scopes"><code>scopes</code></a></li><li><a href="#orgs"><code>orgs</code></a></li><li><a href="#packages-and-scopes-permission"><code>packages-and-scopes-permission</code></a></li><li><a href="#orgs-permission"><code>orgs-permission</code></a></li><li><a href="#cidr"><code>cidr</code></a></li><li><a href="#bypass-2fa"><code>bypass-2fa</code></a></li><li><a href="#password"><code>password</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#read-only"><code>read-only</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm token list
+npm token revoke &lt;id|token&gt;
+npm token create
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>This lets you list, create and revoke authentication tokens.</p>
+<h4 id="listing-tokens">Listing tokens</h4>
+<p>When listing tokens, an abbreviated token will be displayed.  For security purposes the full token is not displayed.</p>
+<h4 id="generating-tokens">Generating tokens</h4>
+<p>When generating tokens, you will be prompted you for your password and, if you have two-factor authentication enabled, an otp.</p>
+<p>Please refer to the <a href="https://docs.npmjs.com/creating-and-viewing-access-tokens">docs website</a> for more information on generating tokens for CI/CD.</p>
+<h4 id="revoking-tokens">Revoking tokens</h4>
+<p>When revoking a token, you can use the full token (e.g. what you get back from <code>npm token create</code>, or as can be found in an <code>.npmrc</code> file), or a truncated id.  If the given truncated id is not distinct enough to differentiate between multiple existing tokens, you will need to use enough of the id to allow npm to distinguish between them.  Full token ids can be found on the <a href="https://www.npmjs.com">npm website</a>, or in the <code>--parseable</code> or <code>--json</code> output of <code>npm token list</code>.  This command will NOT accept the truncated token found in the normal <code>npm token list</code> output.</p>
+<p>A revoked token will immediately be removed from the registry and you will no longer be able to use it.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="name"><code>name</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this sets the
+name/description for the token.</p>
+<h4 id="token-description"><code>token-description</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Description text for the token when using <code>npm token create</code>.</p>
+<h4 id="expires"><code>expires</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this sets the
+expiration in days. If not specified, the server will determine the default
+expiration.</p>
+<h4 id="packages"><code>packages</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this limits
+the token access to specific packages.</p>
+<h4 id="packages-all"><code>packages-all</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, grants the
+token access to all packages instead of limiting to specific packages.</p>
+<h4 id="scopes"><code>scopes</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this limits
+the token access to specific scopes. Provide a scope name (with or without @
+prefix).</p>
+<h4 id="orgs"><code>orgs</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this limits
+the token access to specific organizations.</p>
+<h4 id="packages-and-scopes-permission"><code>packages-and-scopes-permission</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "read-only", "read-write", or "no-access"</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, sets the
+permission level for packages and scopes. Options are "read-only",
+"read-write", or "no-access".</p>
+<h4 id="orgs-permission"><code>orgs-permission</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "read-only", "read-write", or "no-access"</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, sets the
+permission level for organizations. Options are "read-only", "read-write",
+or "no-access".</p>
+<h4 id="cidr"><code>cidr</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>This is a list of CIDR address to be used when configuring limited access
+tokens with the <code>npm token create</code> command.</p>
+<h4 id="bypass-2fa"><code>bypass-2fa</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, setting this
+to true will allow the token to bypass two-factor authentication. This is
+useful for automation and CI/CD workflows.</p>
+<h4 id="password"><code>password</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Password for authentication. Can be provided via command line when creating
+tokens, though it's generally safer to be prompted for it.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="read-only"><code>read-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>This is used to mark a token as unable to publish when configuring limited
+access tokens with the <code>npm token create</code> command.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-profile.html">npm profile</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-token.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-trust.html b/node/node_modules/npm/docs/output/commands/npm-trust.html
new file mode 100644
index 0000000000000000000000000000000000000000..1a307d671e6b47f60eff9b5d6118abddf20dc897
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-trust.html
@@ -0,0 +1,508 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-trust</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-trust----11130">
+    <span>npm-trust</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Manage trusted publishing relationships between packages and CI/CD providers</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#prerequisites">Prerequisites</a></li><li><a href="#description">Description</a></li><li><a href="#bulk-usage">Bulk Usage</a></li><li><a href="#configuration">Configuration</a></li><li><a href="#npm-trust-github"><code>npm trust github</code></a></li><ul><li><a href="#synopsis2">Synopsis</a></li><li><a href="#flags">Flags</a></li></ul><li><a href="#npm-trust-gitlab"><code>npm trust gitlab</code></a></li><ul><li><a href="#synopsis3">Synopsis</a></li><li><a href="#flags2">Flags</a></li></ul><li><a href="#npm-trust-circleci"><code>npm trust circleci</code></a></li><ul><li><a href="#synopsis4">Synopsis</a></li><li><a href="#flags3">Flags</a></li></ul><li><a href="#npm-trust-list"><code>npm trust list</code></a></li><ul><li><a href="#synopsis5">Synopsis</a></li><li><a href="#flags4">Flags</a></li></ul><li><a href="#npm-trust-revoke"><code>npm trust revoke</code></a></li><ul><li><a href="#synopsis6">Synopsis</a></li><li><a href="#flags5">Flags</a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="prerequisites">Prerequisites</h3>
+<p>Before using npm trust commands, ensure the following requirements are met:</p>
+<ul>
+<li><strong>npm version</strong>: <code>npm@11.10.0</code> or above is required. Use <code>npm install -g npm@^11.10.0</code> to update if needed.</li>
+<li><strong>Write permissions on the package</strong>: You must have write access to the package you're configuring.</li>
+<li><strong>2FA enabled on account</strong>: Two-factor authentication must be enabled at the account level. Even if it's not currently enabled, you must enable it to use trust commands.</li>
+<li><strong>Supported authentication methods</strong>: Granular Access Tokens (GAT) with the bypass 2FA option are not supported. Legacy basic auth (username and password) credentials will not work for trust commands or endpoints.</li>
+<li><strong>Package must exist</strong>: The package you're configuring must already exist on the npm registry.</li>
+</ul>
+<h3 id="description">Description</h3>
+<p>Configure trust relationships between npm packages and CI/CD providers using OpenID Connect (OIDC). This is the command-line equivalent of managing trusted publisher configurations on the npm website.</p>
+<p>For a comprehensive overview of trusted publishing, see the <a href="https://docs.npmjs.com/trusted-publishers">npm trusted publishers documentation</a>.</p>
+<p>The <code>[package]</code> argument specifies the package name. If omitted, npm will use the name from the <code>package.json</code> in the current directory.</p>
+<p>Each trust relationship has its own set of configuration options and flags based on the OIDC claims provided by that provider. OIDC claims come from the CI/CD provider and include information such as repository name, workflow file, or environment. Since each provider's claims differ, the available flags and configuration keys are not universal—npm matches the claims supported by each provider's OIDC configuration. For specific details on which claims and flags are supported for a given provider, use <code>npm trust &lt;provider&gt; --help</code>.</p>
+<p>The required options depend on the CI/CD provider you're configuring. Detailed information about each option is available in the <a href="https://docs.npmjs.com/trusted-publishers#managing-trusted-publisher-configurations">managing trusted publisher configurations</a> section of the npm documentation. If a provider is repository-based and the option is not provided, npm will use the <code>repository.url</code> field from your <code>package.json</code>, if available.</p>
+<p>Currently, the registry only supports one configuration per package. If you attempt to create a new trust relationship when one already exists, it will result in an error. To replace an existing configuration:</p>
+<ol>
+<li>Use <code>npm trust list [package]</code> to view the ID of the existing trusted publisher</li>
+<li>Use <code>npm trust revoke --id &lt;id&gt; [package]</code> to remove the existing configuration</li>
+<li>Then create your new trust relationship</li>
+</ol>
+<h3 id="bulk-usage">Bulk Usage</h3>
+<p>For maintainers managing a large number of packages, you can configure trusted publishing in bulk using bash scripting. Create a loop that iterates through package names and their corresponding configuration details, executing the <code>npm trust &lt;provider&gt;</code> command with the <code>--yes</code> flag for each package.</p>
+<p>The first request will require two-factor authentication. During two-factor authentication, you'll see an option on the npm website to skip two-factor authentication for the next 5 minutes. Enabling this option will allow subsequent <code>npm trust &lt;provider&gt;</code> commands to proceed without two-factor authentication, streamlining the bulk configuration process.</p>
+<p>We recommend adding a 2-second sleep between each call to avoid rate limiting. With this approach, you can configure approximately 80 packages within the 5-minute two-factor authentication skip window.</p>
+<h3 id="configuration">Configuration</h3>
+<h3 id="npm-trust-github"><code>npm trust github</code></h3>
+<p>Create a trusted relationship between a package and GitHub Actions</p>
+<h4 id="synopsis2">Synopsis</h4>
+<pre><code class="language-bash">npm trust github [package] --file [--repo|--repository] [--env|--environment] [-y|--yes]
+</code></pre>
+<h4 id="flags">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--file</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>Name of workflow file within a repositories .GitHub folder (must end in yaml, yml)</td>
+</tr>
+<tr>
+<td><code>--repository</code>, <code>--repo</code></td>
+<td>null</td>
+<td>String</td>
+<td>Name of the repository in the format owner/repo</td>
+</tr>
+<tr>
+<td><code>--environment</code>, <code>--env</code></td>
+<td>null</td>
+<td>String</td>
+<td>CI environment name</td>
+</tr>
+<tr>
+<td><code>--dry-run</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, <code>install</code>,       <code>update</code>, <code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and       <code>publish</code>.        Note: This is NOT honored by other network related commands, eg       <code>dist-tags</code>, <code>owner</code>, etc.</td>
+</tr>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+<tr>
+<td><code>--yes</code>, <code>-y</code></td>
+<td>null</td>
+<td>null or Boolean</td>
+<td>Automatically answer "yes" to any prompts that npm might print on       the command line.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-trust-gitlab"><code>npm trust gitlab</code></h3>
+<p>Create a trusted relationship between a package and GitLab CI/CD</p>
+<h4 id="synopsis3">Synopsis</h4>
+<pre><code class="language-bash">npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]
+</code></pre>
+<h4 id="flags2">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--file</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>Name of pipeline file (e.g., .gitlab-ci.yml)</td>
+</tr>
+<tr>
+<td><code>--project</code></td>
+<td>null</td>
+<td>String</td>
+<td>Name of the project in the format group/project or group/subgroup/project</td>
+</tr>
+<tr>
+<td><code>--environment</code>, <code>--env</code></td>
+<td>null</td>
+<td>String</td>
+<td>CI environment name</td>
+</tr>
+<tr>
+<td><code>--dry-run</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, <code>install</code>,       <code>update</code>, <code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and       <code>publish</code>.        Note: This is NOT honored by other network related commands, eg       <code>dist-tags</code>, <code>owner</code>, etc.</td>
+</tr>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+<tr>
+<td><code>--yes</code>, <code>-y</code></td>
+<td>null</td>
+<td>null or Boolean</td>
+<td>Automatically answer "yes" to any prompts that npm might print on       the command line.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-trust-circleci"><code>npm trust circleci</code></h3>
+<p>Create a trusted relationship between a package and CircleCI</p>
+<h4 id="synopsis4">Synopsis</h4>
+<pre><code class="language-bash">npm trust circleci [package] --org-id &lt;uuid&gt; --project-id &lt;uuid&gt; --pipeline-definition-id &lt;uuid&gt; --vcs-origin &lt;origin&gt; [--context-id &lt;uuid&gt;...] [-y|--yes]
+</code></pre>
+<h4 id="flags3">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--org-id</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>CircleCI organization UUID</td>
+</tr>
+<tr>
+<td><code>--project-id</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>CircleCI project UUID</td>
+</tr>
+<tr>
+<td><code>--pipeline-definition-id</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>CircleCI pipeline definition UUID</td>
+</tr>
+<tr>
+<td><code>--vcs-origin</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>CircleCI repository origin in format 'provider/owner/repo'</td>
+</tr>
+<tr>
+<td><code>--context-id</code></td>
+<td>null</td>
+<td>null or String (can be set multiple times)</td>
+<td>CircleCI context UUID to match</td>
+</tr>
+<tr>
+<td><code>--dry-run</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, <code>install</code>,       <code>update</code>, <code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and       <code>publish</code>.        Note: This is NOT honored by other network related commands, eg       <code>dist-tags</code>, <code>owner</code>, etc.</td>
+</tr>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+<tr>
+<td><code>--yes</code>, <code>-y</code></td>
+<td>null</td>
+<td>null or Boolean</td>
+<td>Automatically answer "yes" to any prompts that npm might print on       the command line.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-trust-list"><code>npm trust list</code></h3>
+<p>List trusted relationships for a package</p>
+<h4 id="synopsis5">Synopsis</h4>
+<pre><code class="language-bash">npm trust list [package]
+</code></pre>
+<h4 id="flags4">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-trust-revoke"><code>npm trust revoke</code></h3>
+<p>Revoke a trusted relationship for a package</p>
+<h4 id="synopsis6">Synopsis</h4>
+<pre><code class="language-bash">npm trust revoke [package] --id=&lt;trust-id&gt;
+</code></pre>
+<h4 id="flags5">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--id</code></td>
+<td>null</td>
+<td>String (required)</td>
+<td>ID of the trusted relationship to revoke</td>
+</tr>
+<tr>
+<td><code>--dry-run</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, <code>install</code>,       <code>update</code>, <code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and       <code>publish</code>.        Note: This is NOT honored by other network related commands, eg       <code>dist-tags</code>, <code>owner</code>, etc.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-token.html">npm token</a></li>
+<li><a href="../commands/npm-access.html">npm access</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-trust.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-undeprecate.html b/node/node_modules/npm/docs/output/commands/npm-undeprecate.html
new file mode 100644
index 0000000000000000000000000000000000000000..479587573fdb8fb6bca1b4392f7a02406e38ec11
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-undeprecate.html
@@ -0,0 +1,252 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-undeprecate</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-undeprecate----11130">
+    <span>npm-undeprecate</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Undeprecate a version of a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm undeprecate &lt;package-spec&gt;
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>This command will update the npm registry entry for a package, removing any deprecation warnings that currently exist.</p>
+<p>It works in the same way as <a href="../commands/npm-deprecate.html">npm deprecate</a>, except that this command removes deprecation warnings instead of adding them.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-deprecate.html">npm deprecate</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-undeprecate.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-uninstall.html b/node/node_modules/npm/docs/output/commands/npm-uninstall.html
new file mode 100644
index 0000000000000000000000000000000000000000..91d0df082ac5fac91e10b97eeefbdd8822f60c59
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-uninstall.html
@@ -0,0 +1,323 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-uninstall</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-uninstall----11130">
+    <span>npm-uninstall</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Remove a package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#examples">Examples</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm uninstall [&lt;@scope&gt;/]&lt;pkg&gt;...
+
+aliases: unlink, remove, rm, r, un
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This uninstalls a package, completely removing everything npm installed on its behalf.</p>
+<p>It also removes the package from the <code>dependencies</code>, <code>devDependencies</code>,
+<code>optionalDependencies</code>, and <code>peerDependencies</code> objects in your <code>package.json</code>.</p>
+<p>Further, if you have an <code>npm-shrinkwrap.json</code> or <code>package-lock.json</code>, npm will update those files as well.</p>
+<p><code>--no-save</code> will tell npm not to remove the package from your <code>package.json</code>, <code>npm-shrinkwrap.json</code>, or <code>package-lock.json</code> files.</p>
+<p><code>--save</code> or <code>-S</code> will tell npm to remove the package from your <code>package.json</code>, <code>npm-shrinkwrap.json</code>, and <code>package-lock.json</code> files.
+This is the default, but you may need to use this if you have for instance <code>save=false</code> in your <code>npmrc</code> file</p>
+<p>In global mode (ie, with <code>-g</code> or <code>--global</code> appended to the command), it uninstalls the current package context as a global package.
+<code>--no-save</code> is ignored in this case.</p>
+<p>Scope is optional and follows the usual rules for <a href="../using-npm/scope.html"><code>scope</code></a>.</p>
+<h3 id="examples">Examples</h3>
+<pre><code class="language-bash">npm uninstall sax
+</code></pre>
+<p><code>sax</code> will no longer be in your <code>package.json</code>, <code>npm-shrinkwrap.json</code>, or <code>package-lock.json</code> files.</p>
+<pre><code class="language-bash">npm uninstall lodash --no-save
+</code></pre>
+<p><code>lodash</code> will not be removed from your <code>package.json</code>,
+<code>npm-shrinkwrap.json</code>, or <code>package-lock.json</code> files.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-prune.html">npm prune</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-uninstall.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-unpublish.html b/node/node_modules/npm/docs/output/commands/npm-unpublish.html
new file mode 100644
index 0000000000000000000000000000000000000000..7b1959e608ed6ff3cb86f9fb704f762bc92c5d3f
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-unpublish.html
@@ -0,0 +1,310 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-unpublish</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-unpublish----11130">
+    <span>npm-unpublish</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Remove a package from the registry</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#warning">Warning</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#force"><code>force</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm unpublish [&lt;package-spec&gt;]
+</code></pre>
+<p>To learn more about how the npm registry treats unpublish, see our <a href="https://docs.npmjs.com/policies/unpublish">unpublish policies</a>.</p>
+<h3 id="warning">Warning</h3>
+<p>Consider using the <a href="../commands/npm-deprecate.html"><code>deprecate</code></a> command instead, if your intent is to encourage users to upgrade, or if you no longer want to maintain a package.</p>
+<h3 id="description">Description</h3>
+<p>This removes a package version from the registry, deleting its entry and removing the tarball.</p>
+<p>The npm registry will return an error if you are not <a href="../commands/npm-adduser.html">logged in</a>.</p>
+<p>If you do not specify a package name at all, the name and version to be unpublished will be pulled from the project in the current directory.</p>
+<p>If you specify a package name but do not specify a version or if you remove all of a package's versions then the registry will remove the root package entry entirely.</p>
+<p>Even if you unpublish a package version, that specific name and version combination can never be reused.
+In order to publish the package again, you must use a new version number.
+If you unpublish the entire package, you may not publish any new versions of that package until 24 hours have passed.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="force"><code>force</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.</p>
+<ul>
+<li>Allow clobbering non-npm files in global installs.</li>
+<li>Allow the <code>npm version</code> command to work on an unclean git repository.</li>
+<li>Allow deleting the cache folder with <code>npm cache clean</code>.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of npm.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of <code>node</code>, even if <code>--engine-strict</code> is enabled.</li>
+<li>Allow <code>npm audit fix</code> to install modules outside your stated dependency
+range (including SemVer-major changes).</li>
+<li>Allow unpublishing all versions of a published package.</li>
+<li>Allow conflicting peerDependencies to be installed in the root project.</li>
+<li>Implicitly set <code>--yes</code> during <code>npm init</code>.</li>
+<li>Allow clobbering existing values in <code>npm pkg</code></li>
+<li>Allow unpublishing of entire packages (not just a single version).</li>
+</ul>
+<p>If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-deprecate.html">npm deprecate</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+<li><a href="../commands/npm-owner.html">npm owner</a></li>
+<li><a href="../commands/npm-adduser.html">npm login</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-unpublish.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-unstar.html b/node/node_modules/npm/docs/output/commands/npm-unstar.html
new file mode 100644
index 0000000000000000000000000000000000000000..67a373f2b580d0e68007eedc4f674f83c91618b3
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-unstar.html
@@ -0,0 +1,258 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-unstar</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-unstar----11130">
+    <span>npm-unstar</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Remove an item from your favorite packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#more">More</a></li><ul><li><a href="#star">Star</a></li><li><a href="#listing-stars">Listing stars</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#otp"><code>otp</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm unstar [&lt;package-spec&gt;...]
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>"Unstarring" a package is the opposite of <a href="../commands/npm-star.html"><code>npm star</code></a>, it removes an item from your list of favorite packages.</p>
+<h3 id="more">More</h3>
+<p>There's also these extra commands to help you manage your favorite packages:</p>
+<h4 id="star">Star</h4>
+<p>You can "star" a package using <a href="../commands/npm-star.html"><code>npm star</code></a></p>
+<h4 id="listing-stars">Listing stars</h4>
+<p>You can see all your starred packages using <a href="../commands/npm-stars.html"><code>npm stars</code></a></p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="unicode"><code>unicode</code></h4>
+<ul>
+<li>Default: false on windows, true on mac/unix systems with a unicode locale,
+as defined by the <code>LC_ALL</code>, <code>LC_CTYPE</code>, or <code>LANG</code> environment variables.</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-star.html">npm star</a></li>
+<li><a href="../commands/npm-stars.html">npm stars</a></li>
+<li><a href="../commands/npm-view.html">npm view</a></li>
+<li><a href="../commands/npm-whoami.html">npm whoami</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-unstar.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-update.html b/node/node_modules/npm/docs/output/commands/npm-update.html
new file mode 100644
index 0000000000000000000000000000000000000000..d21a0f95f4373248a9b96388efa6da0c66e28d5f
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-update.html
@@ -0,0 +1,549 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-update</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-update----11130">
+    <span>npm-update</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Update packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><ul><li><a href="#caret-dependencies">Caret Dependencies</a></li><li><a href="#tilde-dependencies">Tilde Dependencies</a></li><li><a href="#caret-dependencies-below-100">Caret Dependencies below 1.0.0</a></li><li><a href="#subdependencies">Subdependencies</a></li><li><a href="#updating-globally-installed-packages">Updating Globally-Installed Packages</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm update [&lt;pkg&gt;...]
+
+aliases: u, up, upgrade, udpate
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command will update all the packages listed to the latest version (specified by the <a href="../using-npm/config#tag.html"><code>tag</code> config</a>), respecting the semver constraints of both your package and its dependencies (if they also require the same package).</p>
+<p>It will also install missing packages.</p>
+<p>If the <code>-g</code> flag is specified, this command will update globally installed packages.</p>
+<p>If no package name is specified, all packages in the specified location (global or local) will be updated.</p>
+<p>Note that by default <code>npm update</code> will not update the semver values of direct dependencies in your project <code>package.json</code>.
+If you want to also update values in <code>package.json</code> you can run: <code>npm update --save</code> (or add the <code>save=true</code> option to a <a href="../configuring-npm/npmrc.html">configuration file</a> to make that the default behavior).</p>
+<h3 id="example">Example</h3>
+<p>For the examples below, assume that the current package is <code>app</code> and it depends on dependencies, <code>dep1</code> (<code>dep2</code>, .. etc.).
+The published versions of <code>dep1</code> are:</p>
+<pre><code class="language-json">{
+  "dist-tags": { "latest": "1.2.2" },
+  "versions": [
+    "1.2.2",
+    "1.2.1",
+    "1.2.0",
+    "1.1.2",
+    "1.1.1",
+    "1.0.0",
+    "0.4.1",
+    "0.4.0",
+    "0.2.0"
+  ]
+}
+</code></pre>
+<h4 id="caret-dependencies">Caret Dependencies</h4>
+<p>If <code>app</code>'s <code>package.json</code> contains:</p>
+<pre><code class="language-json">"dependencies": {
+  "dep1": "^1.1.1"
+}
+</code></pre>
+<p>Then <code>npm update</code> will install <code>dep1@1.2.2</code>, because <code>1.2.2</code> is <code>latest</code> and
+<code>1.2.2</code> satisfies <code>^1.1.1</code>.</p>
+<h4 id="tilde-dependencies">Tilde Dependencies</h4>
+<p>However, if <code>app</code>'s <code>package.json</code> contains:</p>
+<pre><code class="language-json">"dependencies": {
+  "dep1": "~1.1.1"
+}
+</code></pre>
+<p>In this case, running <code>npm update</code> will install <code>dep1@1.1.2</code>.
+Even though the <code>latest</code> tag points to <code>1.2.2</code>, this version does not satisfy <code>~1.1.1</code>, which is equivalent to <code>&gt;=1.1.1 &lt;1.2.0</code>.
+So the highest-sorting version that satisfies
+<code>~1.1.1</code> is used, which is <code>1.1.2</code>.</p>
+<h4 id="caret-dependencies-below-100">Caret Dependencies below 1.0.0</h4>
+<p>Suppose <code>app</code> has a caret dependency on a version below <code>1.0.0</code>, for example:</p>
+<pre><code class="language-json">"dependencies": {
+  "dep1": "^0.2.0"
+}
+</code></pre>
+<p><code>npm update</code> will install <code>dep1@0.2.0</code>.</p>
+<p>If the dependence were on <code>^0.4.0</code>:</p>
+<pre><code class="language-json">"dependencies": {
+  "dep1": "^0.4.0"
+}
+</code></pre>
+<p>Then <code>npm update</code> will install <code>dep1@0.4.1</code>, because that is the highest-sorting version that satisfies <code>^0.4.0</code> (<code>&gt;= 0.4.0 &lt;0.5.0</code>)</p>
+<h4 id="subdependencies">Subdependencies</h4>
+<p>Suppose your app now also has a dependency on <code>dep2</code></p>
+<pre><code class="language-json">{
+  "name": "my-app",
+  "dependencies": {
+      "dep1": "^1.0.0",
+      "dep2": "1.0.0"
+  }
+}
+</code></pre>
+<p>and <code>dep2</code> itself depends on this limited range of <code>dep1</code></p>
+<pre><code class="language-json">{
+"name": "dep2",
+  "dependencies": {
+    "dep1": "~1.1.1"
+  }
+}
+</code></pre>
+<p>Then <code>npm update</code> will install <code>dep1@1.1.2</code> because that is the highest version that <code>dep2</code> allows.
+npm will prioritize having a single version of <code>dep1</code> in your tree rather than two when that single version can satisfy the semver requirements of multiple dependencies in your tree.
+In this case if you really did need your package to use a newer version you would need to use <code>npm install</code>.</p>
+<h4 id="updating-globally-installed-packages">Updating Globally-Installed Packages</h4>
+<p><code>npm update -g</code> will apply the <code>update</code> action to each globally installed package that is <code>outdated</code> -- that is, has a version that is different from <code>wanted</code>.</p>
+<p>Note: Globally installed packages are treated as if they are installed with a caret semver range specified.
+So if you require to update to <code>latest</code> you may need to run <code>npm install -g [&lt;pkg&gt;...]</code></p>
+<p>NOTE: If a package has been upgraded to a version newer than <code>latest</code>, it will be <em>downgraded</em>.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="before"><code>before</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Date</li>
+</ul>
+<p>If passed to <code>npm install</code>, will rebuild the npm tree such that only
+versions that were available <strong>on or before</strong> the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.</p>
+<p>If the requested version is a <code>dist-tag</code> and the given tag does not pass the
+<code>--before</code> filter, the most recent version less than or equal to that tag
+will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
+<code>latest</code> is <code>2.0</code>.</p>
+<p>This config cannot be used with: <code>min-release-age</code></p>
+<h4 id="min-release-age"><code>min-release-age</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.</p>
+<p>This flag is a complement to <code>before</code>, which accepts an exact date instead
+of a relative number of days.</p>
+<p>This config cannot be used with: <code>before</code></p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-outdated.html">npm outdated</a></li>
+<li><a href="../commands/npm-shrinkwrap.html">npm shrinkwrap</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-ls.html">npm ls</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-update.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-version.html b/node/node_modules/npm/docs/output/commands/npm-version.html
new file mode 100644
index 0000000000000000000000000000000000000000..870d6b1efaf00f01e19ecfbec6fc6146c14de085
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-version.html
@@ -0,0 +1,403 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-version</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-version----11130">
+    <span>npm-version</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Bump a package version</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#allow-same-version"><code>allow-same-version</code></a></li><li><a href="#commit-hooks"><code>commit-hooks</code></a></li><li><a href="#git-tag-version"><code>git-tag-version</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#preid"><code>preid</code></a></li><li><a href="#sign-git-tag"><code>sign-git-tag</code></a></li><li><a href="#save"><code>save</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#workspaces-update"><code>workspaces-update</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li></ul><li><a href="#description">Description</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm version [&lt;newversion&gt; | major | minor | patch | premajor | preminor | prepatch | prerelease | from-git]
+
+alias: verison
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="allow-same-version"><code>allow-same-version</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prevents throwing an error when <code>npm version</code> is used to set the new version
+to the same value as the current version.</p>
+<h4 id="commit-hooks"><code>commit-hooks</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run git commit hooks when using the <code>npm version</code> command.</p>
+<h4 id="git-tag-version"><code>git-tag-version</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tag the commit when using the <code>npm version</code> command. Setting this to false
+results in no commit being made at all.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="preid"><code>preid</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>The "prerelease identifier" to use as a prefix for the "prerelease" part of
+a semver. Like the <code>rc</code> in <code>1.2.0-rc.8</code>.</p>
+<h4 id="sign-git-tag"><code>sign-git-tag</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, then the <code>npm version</code> command will tag the version using
+<code>-s</code> to add a signature.</p>
+<p>Note that git requires you to have set up GPG keys in your git configs for
+this to work properly.</p>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces-update"><code>workspaces-update</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the npm cli will run an update after operations that may
+possibly change the workspaces installed to the <code>node_modules</code> folder.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h3 id="description">Description</h3>
+<p>Run this in a package directory to bump the version and write the new data back to <code>package.json</code>, <code>package-lock.json</code>, and, if present,
+<code>npm-shrinkwrap.json</code>.</p>
+<p>The <code>newversion</code> argument should be a valid semver string, a valid second argument to <a href="https://github.com/npm/node-semver#functions">semver.inc</a> (one of <code>patch</code>, <code>minor</code>, <code>major</code>, <code>prepatch</code>, <code>preminor</code>, <code>premajor</code>, <code>prerelease</code>), or <code>from-git</code>.
+In the second case, the existing version will be incremented by 1 in the specified field.
+<code>from-git</code> will try to read the latest git tag, and use that as the new npm version.</p>
+<p><strong>Note:</strong> If the current version is a prerelease version, <code>patch</code> will simply remove the prerelease suffix without incrementing the patch version number. For example, <code>1.2.0-5</code> becomes <code>1.2.0</code> with <code>npm version patch</code>, not <code>1.2.1</code>.</p>
+<p>If run in a git repo, it will also create a version commit and tag.
+This behavior is controlled by <code>git-tag-version</code> (see below), and can be disabled on the command line by running <code>npm --no-git-tag-version version</code>.
+It will fail if the working directory is not clean, unless the <code>-f</code> or <code>--force</code> flag is set.</p>
+<p><strong>Note:</strong> Git integration requires a reasonably recent version of git (2.0.0 or later is recommended). If you encounter issues with git commands, ensure your git installation is up to date.</p>
+<p>If supplied with <code>-m</code> or <a href="../using-npm/config#message.html"><code>--message</code> config</a> option, npm will use it as a commit message when creating a version commit.
+If the <code>message</code> config contains <code>%s</code> then that will be replaced with the resulting version number.
+For example:</p>
+<pre><code class="language-bash">npm version patch -m "Upgrade to %s for reasons"
+</code></pre>
+<p>If the <a href="../using-npm/config#sign-git-tag.html"><code>sign-git-tag</code> config</a> is set, then the tag will be signed using the <code>-s</code> flag to git.
+Note that you must have a default GPG key set up in your git config for this to work properly.
+For example:</p>
+<pre><code class="language-bash">$ npm config set sign-git-tag true
+$ npm version patch
+
+You need a passphrase to unlock the secret key for user: "isaacs (http://blog.izs.me/) &lt;i@izs.me&gt;"
+2048-bit RSA key, ID 6C481CF6, created 2010-08-31
+
+Enter passphrase:
+</code></pre>
+<p>If <code>preversion</code>, <code>version</code>, or <code>postversion</code> are in the <code>scripts</code> property of the package.json, they will be executed as part of running <code>npm version</code>.</p>
+<p>The exact order of execution is as follows:</p>
+<ol>
+<li>Check to make sure the git working directory is clean before we get started.
+Your scripts may add files to the commit in future steps.
+This step is skipped if the <code>--force</code> flag is set.</li>
+<li>Run the <code>preversion</code> script.
+These scripts have access to the old <code>version</code> in package.json.
+A typical use would be running your full test suite before deploying.
+Any files you want added to the commit should be explicitly added using <code>git add</code>.</li>
+<li>Bump <code>version</code> in <code>package.json</code> as requested (<code>patch</code>, <code>minor</code>, <code>major</code>, etc).</li>
+<li>Run the <code>version</code> script.
+These scripts have access to the new <code>version</code> in package.json (so they can incorporate it into file headers in generated files for example).
+Again, scripts should explicitly add generated files to the commit using <code>git add</code>.</li>
+<li>Commit and tag.</li>
+<li>Run the <code>postversion</code> script.
+Use it to clean up the file system or automatically push the commit and/or tag.</li>
+</ol>
+<p>Take the following example:</p>
+<pre><code class="language-json">{
+  "scripts": {
+    "preversion": "npm test",
+    "version": "npm run build &amp;&amp; git add -A dist",
+    "postversion": "git push &amp;&amp; git push --tags &amp;&amp; rm -rf build/temp"
+  }
+}
+</code></pre>
+<p>This runs all your tests and proceeds only if they pass.
+Then runs your <code>build</code> script, and adds everything in the <code>dist</code> directory to the commit.
+After the commit, it pushes the new commit and tag up to the server, and deletes the <code>build/temp</code> directory.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-init.html">npm init</a></li>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-version.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-view.html b/node/node_modules/npm/docs/output/commands/npm-view.html
new file mode 100644
index 0000000000000000000000000000000000000000..d6bec0df348013469ab4435d3ccff649175488d1
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-view.html
@@ -0,0 +1,383 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-view</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-view----11130">
+    <span>npm-view</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">View registry info</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#field-access-patterns">Field Access Patterns</a></li><ul><li><a href="#nested-object-fields">Nested Object Fields</a></li><li><a href="#array-element-access">Array Element Access</a></li><li><a href="#object-property-access">Object Property Access</a></li><li><a href="#extracting-fields-from-arrays">Extracting Fields from Arrays</a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#json"><code>json</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li></ul><li><a href="#output">Output</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm view [&lt;package-spec&gt;] [&lt;field&gt;[.subfield]...]
+
+aliases: info, show, v
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command shows data about a package and prints it to stdout.</p>
+<p>As an example, to view information about the <code>connect</code> package from the registry, you would run:</p>
+<pre><code class="language-bash">npm view connect
+</code></pre>
+<p>The default version is <code>"latest"</code> if unspecified.</p>
+<p>Field names can be specified after the package descriptor.
+For example, to show the dependencies of the <code>ronn</code> package at version
+<code>0.3.5</code>, you could do the following:</p>
+<pre><code class="language-bash">npm view ronn@0.3.5 dependencies
+</code></pre>
+<p>By default, <code>npm view</code> shows data about the current project context (by looking for a <code>package.json</code>).
+To show field data for the current project use a file path (i.e.
+<code>.</code>):</p>
+<pre><code class="language-bash">npm view . dependencies
+</code></pre>
+<p>You can view child fields by separating them with a period.
+To view the git repository URL for the latest version of <code>npm</code>, you would run the following command:</p>
+<pre><code class="language-bash">npm view npm repository.url
+</code></pre>
+<p>This makes it easy to view information about a dependency with a bit of shell scripting.
+For example, to view all the data about the version of <code>opts</code> that <code>ronn</code> depends on, you could write the following:</p>
+<pre><code class="language-bash">npm view opts@$(npm view ronn dependencies.opts)
+</code></pre>
+<p>For fields that are arrays, requesting a non-numeric field will return all of the values from the objects in the list.
+For example, to get all the contributor email addresses for the <code>express</code> package, you would run:</p>
+<pre><code class="language-bash">npm view express contributors.email
+</code></pre>
+<p>You may also use numeric indices in square braces to specifically select an item in an array field.
+To just get the email address of the first contributor in the list, you can run:</p>
+<pre><code class="language-bash">npm view express contributors[0].email
+</code></pre>
+<p>If the field value you are querying for is a property of an object, you should run:</p>
+<pre><code class="language-bash">npm view express time'[4.8.0]'
+</code></pre>
+<p>Note: When accessing object properties that contain special characters or numeric keys, you need to use quotes around the key name.
+For example, to get the publish time of a specific version:</p>
+<pre><code class="language-bash">npm view express "time[4.17.1]"
+</code></pre>
+<p>Without quotes, the shell may interpret the square brackets as glob patterns, causing the command to fail.
+You can also access the time field for a specific version by specifying the version in the package descriptor:</p>
+<pre><code class="language-bash">npm view express@4.17.1 time
+</code></pre>
+<p>This will return all version-time pairs, but the context will be for that specific version.</p>
+<p>Multiple fields may be specified, and will be printed one after another.
+For example, to get all the contributor names and email addresses, you can do this:</p>
+<pre><code class="language-bash">npm view express contributors.name contributors.email
+</code></pre>
+<p>"Person" fields are shown as a string if they would be shown as an object.
+So, for example, this will show the list of <code>npm</code> contributors in the shortened string format.
+(See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more on this.)</p>
+<pre><code class="language-bash">npm view npm contributors
+</code></pre>
+<p>If a version range is provided, then data will be printed for every matching version of the package.
+This will show which version of <code>jsdom</code> was required by each matching version of <code>yui3</code>:</p>
+<pre><code class="language-bash">npm view yui3@'&gt;0.5.4' dependencies.jsdom
+</code></pre>
+<p>To show the <code>connect</code> package version history, you can do this:</p>
+<pre><code class="language-bash">npm view connect versions
+</code></pre>
+<h3 id="field-access-patterns">Field Access Patterns</h3>
+<p>The <code>npm view</code> command supports different ways to access nested fields and array elements in package metadata. Understanding these patterns makes it easier to extract specific information.</p>
+<h4 id="nested-object-fields">Nested Object Fields</h4>
+<p>Use dot notation to access nested object fields:</p>
+<pre><code class="language-bash"># Access nested properties
+npm view npm repository.url
+npm view express bugs.url
+</code></pre>
+<h4 id="array-element-access">Array Element Access</h4>
+<p>For arrays, use numeric indices in square brackets to access specific elements:</p>
+<pre><code class="language-bash"># Get the first contributor's email
+npm view express contributors[0].email
+
+# Get the second maintainer's name
+npm view express maintainers[1].name
+</code></pre>
+<h4 id="object-property-access">Object Property Access</h4>
+<p>For object properties (like accessing specific versions in the <code>time</code> field), use bracket notation with the property name in quotes:</p>
+<pre><code class="language-bash"># Get publish time for a specific version
+npm view express "time[4.17.1]"
+
+# Get dist-tags
+npm view express "dist-tags.latest"
+</code></pre>
+<h4 id="extracting-fields-from-arrays">Extracting Fields from Arrays</h4>
+<p>Request a non-numeric field on an array to get all values from objects in the list:</p>
+<pre><code class="language-bash"># Get all contributor emails
+npm view express contributors.email
+
+# Get all contributor names
+npm view express contributors.name
+</code></pre>
+<h3 id="configuration">Configuration</h3>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h3 id="output">Output</h3>
+<p>If only a single string field for a single version is output, then it will not be colorized or quoted, to enable piping the output to another command.
+If the field is an object, it will be output as a JavaScript object literal.</p>
+<p>If the <code>--json</code> flag is given, the outputted fields will be JSON.</p>
+<p>If the version range matches multiple versions then each printed value will be prefixed with the version it applies to.</p>
+<p>If multiple fields are requested, then each of them is prefixed with the field name.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../using-npm/package-spec.html">package spec</a></li>
+<li><a href="../commands/npm-search.html">npm search</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-docs.html">npm docs</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-view.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm-whoami.html b/node/node_modules/npm/docs/output/commands/npm-whoami.html
new file mode 100644
index 0000000000000000000000000000000000000000..fd46b3473248c314f263b044775fd40872a94f90
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm-whoami.html
@@ -0,0 +1,235 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-whoami</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-whoami----11130">
+    <span>npm-whoami</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Display npm username</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#registry"><code>registry</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm whoami
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Display the npm username of the currently logged-in user.</p>
+<p>If logged into a registry that provides token-based authentication, then connect to the <code>/-/whoami</code> registry endpoint to find the username associated with the token, and print to standard output.</p>
+<p>If logged into a registry that uses Basic Auth, then simply print the <code>username</code> portion of the authentication string.</p>
+<h3 id="configuration">Configuration</h3>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-whoami.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npm.html b/node/node_modules/npm/docs/output/commands/npm.html
new file mode 100644
index 0000000000000000000000000000000000000000..68c60e97976abbee18b448eb4aa5bc94a0e4109b
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npm.html
@@ -0,0 +1,323 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm----11130">
+    <span>npm</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">javascript package manager</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#version">Version</a></li><li><a href="#description">Description</a></li><li><a href="#important">Important</a></li><li><a href="#introduction">Introduction</a></li><li><a href="#dependencies">Dependencies</a></li><li><a href="#directories">Directories</a></li><li><a href="#developer-usage">Developer Usage</a></li><ul><li><a href="#configuration">Configuration</a></li></ul><li><a href="#contributions">Contributions</a></li><li><a href="#bugs">Bugs</a></li><li><a href="#feature-requests">Feature Requests</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="version">Version</h3>
+<p>11.13.0</p>
+<h3 id="description">Description</h3>
+<p>npm is the package manager for the Node JavaScript platform.
+It puts modules in place so that node can find them, and manages dependency conflicts intelligently.</p>
+<p>It is extremely configurable to support a variety of use cases.
+Most commonly, you use it to publish, discover, install, and develop node programs.</p>
+<p>Run <code>npm help</code> to get a list of available commands.</p>
+<h3 id="important">Important</h3>
+<p>npm comes preconfigured to use npm's public registry at <a href="https://registry.npmjs.org">https://registry.npmjs.org</a> by default.
+Use of the npm public registry is subject to terms of use available at <a href="https://docs.npmjs.com/policies/terms">https://docs.npmjs.com/policies/terms</a>.</p>
+<p>You can configure npm to use any compatible registry you like, and even run your own registry.
+Use of someone else's registry is governed by their terms of use.</p>
+<h3 id="introduction">Introduction</h3>
+<p>You probably got npm because you want to install stuff.</p>
+<p>The very first thing you will most likely want to run in any node program is <code>npm install</code> to install its dependencies.</p>
+<p>You can also run <code>npm install blerg</code> to install the latest version of "blerg".  Check out <a href="../commands/npm-install.html"><code>npm install</code></a> for more info.
+It can do a lot of stuff.</p>
+<p>Use the <code>npm search</code> command to show everything that's available in the public registry.
+Use <code>npm ls</code> to show everything you've installed.</p>
+<h3 id="dependencies">Dependencies</h3>
+<p>If a package lists a dependency using a git URL, npm will install that dependency using the <a href="https://github.com/git-guides/install-git"><code>git</code></a> command and will generate an error if it is not installed.</p>
+<p>If one of the packages npm tries to install is a native node module and requires compiling of C++ Code, npm will use <a href="https://github.com/nodejs/node-gyp">node-gyp</a> for that task.
+For a Unix system, <a href="https://github.com/nodejs/node-gyp">node-gyp</a> needs Python, make and a buildchain like GCC. On Windows, Python and Microsoft Visual Studio C++ are needed.
+For more information visit <a href="https://github.com/nodejs/node-gyp">the node-gyp repository</a> and the <a href="https://github.com/nodejs/node-gyp/wiki">node-gyp Wiki</a>.</p>
+<h3 id="directories">Directories</h3>
+<p>See <a href="../configuring-npm/folders.html"><code>folders</code></a> to learn about where npm puts stuff.</p>
+<p>In particular, npm has two modes of operation:</p>
+<ul>
+<li>local mode:
+npm installs packages into the current project directory, which defaults to the current working directory.
+Packages install to <code>./node_modules</code>, and bins to <code>./node_modules/.bin</code>.</li>
+<li>global mode:
+npm installs packages into the install prefix at <code>$NPM_CONFIG_PREFIX/lib/node_modules</code> and bins to <code>$NPM_CONFIG_PREFIX/bin</code>.</li>
+</ul>
+<p>Local mode is the default.
+Use <code>-g</code> or <code>--global</code> on any command to run in global mode instead.</p>
+<h3 id="developer-usage">Developer Usage</h3>
+<p>If you're using npm to develop and publish your code, check out the following help topics:</p>
+<ul>
+<li>json:
+Make a package.json file.
+See <a href="../configuring-npm/package-json.html"><code>package.json</code></a>.</li>
+<li>link:
+Links your current working code into Node's path, so that you don't have to reinstall every time you make a change.
+Use <a href="../commands/npm-link.html"><code>npm link</code></a> to do this.</li>
+<li>install:
+It's a good idea to install things if you don't need the symbolic link.
+Especially, installing other peoples code from the registry is done via <a href="../commands/npm-install.html"><code>npm install</code></a></li>
+<li>adduser:
+Create an account or log in.
+When you do this, npm will store credentials in the user config file.</li>
+<li>publish:
+Use the <a href="../commands/npm-publish.html"><code>npm publish</code></a> command to upload your code to the registry.</li>
+</ul>
+<h4 id="configuration">Configuration</h4>
+<p>npm is extremely configurable.
+It reads its configuration options from 5 places.</p>
+<ul>
+<li>Command line switches:
+Set a config with <code>--key val</code>.
+All keys take a value, even if they are booleans (the config parser doesn't know what the options are at the time of parsing).
+If you do not provide a value (<code>--key</code>) then the option is set to boolean <code>true</code>.</li>
+<li>Environment Variables:
+Set any config by prefixing the name in an environment variable with <code>NPM_CONFIG_</code>.
+For example, <code>export NPM_CONFIG_KEY=val</code>.</li>
+<li>User Configs:
+The file at <code>$HOME/.npmrc</code> is an ini-formatted list of configs.
+If present, it is parsed.
+If the <code>userconfig</code> option is set in the cli or env, that file will be used instead.</li>
+<li>Global Configs:
+The file found at <code>./etc/npmrc</code> (relative to the global prefix will be parsed if it is found.
+See <a href="../commands/npm-prefix.html"><code>npm prefix</code></a> for more info on the global prefix.
+If the <code>globalconfig</code> option is set in the cli, env, or user config, then that file is parsed instead.</li>
+<li>Defaults:
+npm's default configuration options are defined in <code>lib/utils/config/definitions.js</code>.
+These must not be changed.</li>
+</ul>
+<p>See <a href="../using-npm/config.html"><code>config</code></a> for much, much, more information.</p>
+<h3 id="contributions">Contributions</h3>
+<p>Patches welcome!</p>
+<p>If you would like to help, but don't know what to work on, read the <a href="https://github.com/npm/cli/blob/latest/CONTRIBUTING.md">contributing guidelines</a> and check the issues list.</p>
+<h3 id="bugs">Bugs</h3>
+<p>When you find issues, please report them:
+<a href="https://github.com/npm/cli/issues">https://github.com/npm/cli/issues</a></p>
+<p>Please be sure to follow the template and bug reporting guidelines.</p>
+<h3 id="feature-requests">Feature Requests</h3>
+<p>Discuss new feature ideas on our discussion forum:</p>
+<ul>
+<li><a href="https://github.com/orgs/community/discussions/categories/npm">https://github.com/orgs/community/discussions/categories/npm</a></li>
+</ul>
+<p>Or suggest formal RFC proposals:</p>
+<ul>
+<li><a href="https://github.com/npm/rfcs">https://github.com/npm/rfcs</a></li>
+</ul>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-help.html">npm help</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-prefix.html">npm prefix</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/commands/npx.html b/node/node_modules/npm/docs/output/commands/npx.html
new file mode 100644
index 0000000000000000000000000000000000000000..f45eeb36d180beaa78d2f68d49d02628b2bb8093
--- /dev/null
+++ b/node/node_modules/npm/docs/output/commands/npx.html
@@ -0,0 +1,308 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npx</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npx----11130">
+    <span>npx</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Run a command from a local or remote npm package</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#npx-vs-npm-exec"><code>npx</code> vs <code>npm exec</code></a></li><li><a href="#examples">Examples</a></li><li><a href="#compatibility-with-older-npx-versions">Compatibility with Older npx Versions</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npx -- &lt;pkg&gt;[@&lt;version&gt;] [args...]
+npx --package=&lt;pkg&gt;[@&lt;version&gt;] -- &lt;cmd&gt; [args...]
+npx -c '&lt;cmd&gt; [args...]'
+npx --package=foo -c '&lt;cmd&gt; [args...]'
+</code></pre>
+<h3 id="description">Description</h3>
+<p>This command allows you to run an arbitrary command from an npm package (either one installed locally, or fetched remotely), in a similar context as running it via <code>npm run</code>.</p>
+<p>Run this command to execute a package's binary. Any options and arguments after the package name are passed directly to the executed command, not to npx itself. For example, <code>npx create-react-app my-app --template typescript</code> will pass <code>my-app</code> and <code>--template typescript</code> to the <code>create-react-app</code> command. To see what options a specific package accepts, consult that package's documentation (e.g., at npmjs.com or in its repository).</p>
+<p>Whatever packages are specified by the <code>--package</code> option will be provided in the <code>PATH</code> of the executed command, along with any locally installed package executables.
+The <code>--package</code> option may be specified multiple times, to execute the supplied command in an environment where all specified packages are available.</p>
+<p>If any requested packages are not present in the local project dependencies, then they are installed to a folder in the npm cache, which is added to the <code>PATH</code> environment variable in the executed process.
+A prompt is printed (which can be suppressed by providing either <code>--yes</code> or <code>--no</code>).</p>
+<p>Package names provided without a specifier will be matched with whatever version exists in the local project.
+Package names with a specifier will only be considered a match if they have the exact same name and version as the local dependency.</p>
+<p>If no <code>-c</code> or <code>--call</code> option is provided, then the positional arguments are used to generate the command string.
+If no <code>--package</code> options are provided, then npm will attempt to determine the executable name from the package specifier provided as the first positional argument according to the following heuristic:</p>
+<ul>
+<li>If the package has a single entry in its <code>bin</code> field in <code>package.json</code>, or if all entries are aliases of the same command, then that command will be used.</li>
+<li>If the package has multiple <code>bin</code> entries, and one of them matches the unscoped portion of the <code>name</code> field, then that command will be used.</li>
+<li>If this does not result in exactly one option (either because there are no bin entries, or none of them match the <code>name</code> of the package), then
+<code>npm exec</code> exits with an error.</li>
+</ul>
+<p>To run a binary <em>other than</em> the named binary, specify one or more
+<code>--package</code> options, which will prevent npm from inferring the package from the first command argument.</p>
+<h3 id="npx-vs-npm-exec"><code>npx</code> vs <code>npm exec</code></h3>
+<p>When run via the <code>npx</code> binary, all flags and options <em>must</em> be set prior to any positional arguments.
+When run via <code>npm exec</code>, a double-hyphen <code>--</code> flag can be used to suppress npm's parsing of switches and options that should be sent to the executed command.</p>
+<p>For example:</p>
+<pre><code>$ npx foo@latest bar --package=@npmcli/foo
+</code></pre>
+<p>In this case, npm will resolve the <code>foo</code> package name, and run the following command:</p>
+<pre><code>$ foo bar --package=@npmcli/foo
+</code></pre>
+<p>Since the <code>--package</code> option comes <em>after</em> the positional arguments, it is treated as an argument to the executed command.</p>
+<p>In contrast, due to npm's argument parsing logic, running this command is different:</p>
+<pre><code>$ npm exec foo@latest bar --package=@npmcli/foo
+</code></pre>
+<p>In this case, npm will parse the <code>--package</code> option first, resolving the
+<code>@npmcli/foo</code> package.
+Then, it will execute the following command in that context:</p>
+<pre><code>$ foo@latest bar
+</code></pre>
+<p>The double-hyphen character is recommended to explicitly tell npm to stop parsing command line options and switches.
+The following command would thus be equivalent to the <code>npx</code> command above:</p>
+<pre><code>$ npm exec -- foo@latest bar --package=@npmcli/foo
+</code></pre>
+<h3 id="examples">Examples</h3>
+<p>Run the version of <code>tap</code> in the local dependencies, with the provided arguments:</p>
+<pre><code>$ npm exec -- tap --bail test/foo.js
+$ npx tap --bail test/foo.js
+</code></pre>
+<p>Run a command <em>other than</em> the command whose name matches the package name by specifying a <code>--package</code> option:</p>
+<pre><code>$ npm exec --package=foo -- bar --bar-argument
+# ~ or ~
+$ npx --package=foo bar --bar-argument
+</code></pre>
+<p>Run an arbitrary shell script, in the context of the current project:</p>
+<pre><code>$ npm x -c 'eslint &amp;&amp; say "hooray, lint passed"'
+$ npx -c 'eslint &amp;&amp; say "hooray, lint passed"'
+</code></pre>
+<h3 id="compatibility-with-older-npx-versions">Compatibility with Older npx Versions</h3>
+<p>The <code>npx</code> binary was rewritten in npm v7.0.0, and the standalone <code>npx</code> package deprecated at that time.
+<code>npx</code> uses the <code>npm exec</code> command instead of a separate argument parser and install process, with some affordances to maintain backwards compatibility with the arguments it accepted in previous versions.</p>
+<p>This resulted in some shifts in its functionality:</p>
+<ul>
+<li>Any <code>npm</code> config value may be provided.</li>
+<li>To prevent security and user-experience problems from mistyping package names, <code>npx</code> prompts before installing anything.
+Suppress this prompt with the <code>-y</code> or <code>--yes</code> option.</li>
+<li>The <code>--no-install</code> option is deprecated, and will be converted to <code>--no</code>.</li>
+<li>Shell fallback functionality is removed, as it is not advisable.</li>
+<li>The <code>-p</code> argument is a shorthand for <code>--parseable</code> in npm, but shorthand for <code>--package</code> in npx.
+This is maintained, but only for the <code>npx</code> executable.</li>
+<li>The <code>--ignore-existing</code> option is removed.
+Locally installed bins are always present in the executed process <code>PATH</code>.</li>
+<li>The <code>--npm</code> option is removed.
+<code>npx</code> will always use the <code>npm</code> it ships with.</li>
+<li>The <code>--node-arg</code> and <code>-n</code> options have been removed.
+Use <a href="https://nodejs.org/api/cli.html#node_optionsoptions"><code>NODE_OPTIONS</code></a> instead: e.g.,
+<code>NODE_OPTIONS="--trace-warnings --trace-exit" npx foo --random=true</code></li>
+<li>The <code>--always-spawn</code> option is redundant, and thus removed.</li>
+<li>The <code>--shell</code> option is replaced with <code>--script-shell</code>, but maintained in the <code>npx</code> executable for backwards compatibility.</li>
+</ul>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-test.html">npm test</a></li>
+<li><a href="../commands/npm-start.html">npm start</a></li>
+<li><a href="../commands/npm-restart.html">npm restart</a></li>
+<li><a href="../commands/npm-stop.html">npm stop</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../commands/npm-exec.html">npm exec</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npx.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/folders.html b/node/node_modules/npm/docs/output/configuring-npm/folders.html
new file mode 100644
index 0000000000000000000000000000000000000000..1d1bbb261edba16789ce6f99c29cb00b5753e67c
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/folders.html
@@ -0,0 +1,331 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Folders</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----folders----11130">
+    <span>Folders</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Folder structures used by npm</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><ul><li><a href="#tldr">tl;dr</a></li><li><a href="#prefix-configuration">prefix Configuration</a></li><li><a href="#node-modules">Node Modules</a></li><li><a href="#executables">Executables</a></li><li><a href="#man-pages">Man Pages</a></li><li><a href="#cache">Cache</a></li></ul><li><a href="#more-information">More Information</a></li><ul><li><a href="#global-installation">Global Installation</a></li><li><a href="#cycles-conflicts-and-folder-parsimony">Cycles, Conflicts, and Folder Parsimony</a></li><li><a href="#example">Example</a></li><li><a href="#publishing">Publishing</a></li></ul><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>npm puts various things on your computer.
+That's its job.</p>
+<p>This document will tell you what it puts where.</p>
+<h4 id="tldr">tl;dr</h4>
+<ul>
+<li>Local install (default): puts stuff in <code>./node_modules</code> of the current package root.</li>
+<li>Global install (with <code>-g</code>): puts stuff in /usr/local or wherever node is installed.</li>
+<li>Install it <strong>locally</strong> if you're going to <code>require()</code> it.</li>
+<li>Install it <strong>globally</strong> if you're going to run it on the command line.</li>
+<li>If you need both, then install it in both places, or use <code>npm link</code>.</li>
+</ul>
+<h4 id="prefix-configuration">prefix Configuration</h4>
+<p>The <a href="../using-npm/config#prefix.html"><code>prefix</code> config</a> defaults to the location where node is installed.
+On most systems, this is <code>/usr/local</code>.
+On Windows, it's <code>%AppData%\npm</code>.
+On Unix systems, it's one level up, since node is typically installed at <code>{prefix}/bin/node</code> rather than <code>{prefix}/node.exe</code>.</p>
+<p>When the <code>global</code> flag is set, npm installs things into this prefix.
+When it is not set, it uses the root of the current package, or the current working directory if not in a package already.</p>
+<h4 id="node-modules">Node Modules</h4>
+<p>Packages are dropped into the <code>node_modules</code> folder under the <code>prefix</code>.
+When installing locally, this means that you can <code>require("packagename")</code> to load its main module, or <code>require("packagename/lib/path/to/sub/module")</code> to load other modules.</p>
+<p>Global installs on Unix systems go to <code>{prefix}/lib/node_modules</code>.
+Global installs on Windows go to <code>{prefix}/node_modules</code> (that is, no <code>lib</code> folder.)</p>
+<p>Scoped packages are installed the same way, except they are grouped together in a sub-folder of the relevant <code>node_modules</code> folder with the name of that scope prefix by the @ symbol, e.g. <code>npm install @myorg/package</code> would place the package in <code>{prefix}/node_modules/@myorg/package</code>.
+See <a href="../using-npm/scope.html"><code>scope</code></a> for more details.</p>
+<p>If you wish to <code>require()</code> a package, then install it locally.</p>
+<h4 id="executables">Executables</h4>
+<p>When in global mode, executables are linked into <code>{prefix}/bin</code> on Unix, or directly into <code>{prefix}</code> on Windows.
+Ensure that path is in your terminal's <code>PATH</code> environment to run them.</p>
+<p>When in local mode, executables are linked into <code>./node_modules/.bin</code> so that they can be made available to scripts run through npm.
+(For example, so that a test runner will be in the path when you run <code>npm test</code>.)</p>
+<h4 id="man-pages">Man Pages</h4>
+<p>When in global mode, man pages are linked into <code>{prefix}/share/man</code>.</p>
+<p>When in local mode, man pages are not installed.</p>
+<p>Man pages are not installed on Windows systems.</p>
+<h4 id="cache">Cache</h4>
+<p>See <a href="../commands/npm-cache.html"><code>npm cache</code></a>.
+Cache files are stored in <code>~/.npm</code> on Posix, or <code>%LocalAppData%/npm-cache</code> on Windows.</p>
+<p>This is controlled by the <a href="../using-npm/config#cache.html"><code>cache</code> config</a> param.</p>
+<h3 id="more-information">More Information</h3>
+<p>When installing locally, npm first tries to find an appropriate <code>prefix</code> folder.
+This is so that <code>npm install foo@1.2.3</code> will install to the sensible root of your package, even if you happen to have <code>cd</code>ed into some other folder.</p>
+<p>Starting at the $PWD, npm will walk up the folder tree checking for a folder that contains either a <code>package.json</code> file, or a <code>node_modules</code> folder.
+If such a thing is found, then that is treated as the effective "current directory" for the purpose of running npm commands.
+(This behavior is inspired by and similar to git's .git-folder seeking logic when running git commands in a working dir.)</p>
+<p>If no package root is found, then the current folder is used.</p>
+<p>When you run <code>npm install foo@1.2.3</code>, then the package is loaded into the cache, and then unpacked into <code>./node_modules/foo</code>.
+Then, any of foo's dependencies are similarly unpacked into <code>./node_modules/foo/node_modules/...</code>.</p>
+<p>Any bin files are symlinked to <code>./node_modules/.bin/</code>, so that they may be found by npm scripts when necessary.</p>
+<h4 id="global-installation">Global Installation</h4>
+<p>If the <a href="../using-npm/config#global.html"><code>global</code> config</a> is set to true, then npm will install packages "globally".</p>
+<p>For global installation, packages are installed roughly the same way, but using the folders described above.</p>
+<h4 id="cycles-conflicts-and-folder-parsimony">Cycles, Conflicts, and Folder Parsimony</h4>
+<p>Cycles are handled using the property of node's module system that it walks up the directories looking for <code>node_modules</code> folders.
+So, at every stage, if a package is already installed in an ancestor <code>node_modules</code> folder, then it is not installed at the current location.</p>
+<p>Consider the case above, where <code>foo -&gt; bar -&gt; baz</code>.
+Imagine if, in addition to that, baz depended on bar, so you'd have:
+<code>foo -&gt; bar -&gt; baz -&gt; bar -&gt; baz ...</code>.
+However, since the folder structure is: <code>foo/node_modules/bar/node_modules/baz</code>, there's no need to put another copy of bar into <code>.../baz/node_modules</code>, since when baz calls <code>require("bar")</code>, it will get the copy that is installed in <code>foo/node_modules/bar</code>.</p>
+<p>This shortcut is only used if the exact same version would be installed in multiple nested <code>node_modules</code> folders.
+It is still possible to have <code>a/node_modules/b/node_modules/a</code> if the two "a" packages are different versions.
+However, without repeating the exact same package multiple times, an infinite regress will always be prevented.</p>
+<p>Another optimization can be made by installing dependencies at the highest level possible, below the localized "target" folder (hoisting).
+Since version 3, npm hoists dependencies by default.</p>
+<h4 id="example">Example</h4>
+<p>Consider this dependency graph:</p>
+<pre><code class="language-bash">foo
++-- blerg@1.2.5
++-- bar@1.2.3
+|   +-- blerg@1.x (latest=1.3.7)
+|   +-- baz@2.x
+|   |   `-- quux@3.x
+|   |       `-- bar@1.2.3 (cycle)
+|   `-- asdf@*
+`-- baz@1.2.3
+    `-- quux@3.x
+        `-- bar
+</code></pre>
+<p>In this case, we might expect a folder structure like this (with all dependencies hoisted to the highest level possible):</p>
+<pre><code class="language-bash">foo
++-- node_modules
+    +-- blerg (1.2.5) &lt;---[A]
+    +-- bar (1.2.3) &lt;---[B]
+    |   +-- node_modules
+    |       +-- baz (2.0.2) &lt;---[C]
+    +-- asdf (2.3.4)
+    +-- baz (1.2.3) &lt;---[D]
+    +-- quux (3.2.0) &lt;---[E]
+</code></pre>
+<p>Since foo depends directly on <code>bar@1.2.3</code> and <code>baz@1.2.3</code>, those are installed in foo's <code>node_modules</code> folder.</p>
+<p>Even though the latest copy of blerg is 1.3.7, foo has a specific dependency on version 1.2.5.
+So, that gets installed at [A].
+Since the parent installation of blerg satisfies bar's dependency on <code>blerg@1.x</code>, it does not install another copy under [B].</p>
+<p>Bar [B] also has dependencies on baz and asdf.
+Because it depends on <code>baz@2.x</code>, it cannot re-use the <code>baz@1.2.3</code> installed in the parent <code>node_modules</code> folder [D], and must install its own copy [C].
+In order to minimize duplication, npm hoists dependencies to the top level by default, so asdf is installed under [A].</p>
+<p>Underneath bar, the <code>baz -&gt; quux -&gt; bar</code> dependency creates a cycle.
+However, because bar is already in quux's ancestry [B], it does not unpack another copy of bar into that folder.
+Likewise, quux's [E] folder tree is empty, because its dependency on bar is satisfied by the parent folder copy installed at [B].</p>
+<p>For a graphical breakdown of what is installed where, use <code>npm ls</code>.</p>
+<h4 id="publishing">Publishing</h4>
+<p>Upon publishing, npm will look in the <code>node_modules</code> folder.
+If any of the items there are not in the <code>bundleDependencies</code> array, then they will not be included in the package tarball.</p>
+<p>This allows a package maintainer to install all of their dependencies (and dev dependencies) locally, but only re-publish those items that cannot be found elsewhere.
+See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more information.</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-pack.html">npm pack</a></li>
+<li><a href="../commands/npm-cache.html">npm cache</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/folders.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/install.html b/node/node_modules/npm/docs/output/configuring-npm/install.html
new file mode 100644
index 0000000000000000000000000000000000000000..8121b1b373abdc9a541aa824448407f944914695
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/install.html
@@ -0,0 +1,249 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Install</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----install----11130">
+    <span>Install</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Download and install node and npm</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#overview">Overview</a></li><li><a href="#checking-your-version-of-npm-and-nodejs">Checking your version of npm and Node.js</a></li><li><a href="#using-a-node-version-manager-to-install-nodejs-and-npm">Using a Node version manager to install Node.js and npm</a></li><li><a href="#using-a-node-installer-to-install-nodejs-and-npm">Using a Node installer to install Node.js and npm</a></li><ul><li><a href="#macos-or-windows-node-installers">macOS or Windows Node installers</a></li><li><a href="#linux-or-other-operating-systems-node-installers">Linux or other operating systems Node installers</a></li></ul></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>To publish and install packages to and from the public npm registry, you must install Node.js and the npm command line interface using either a Node version manager or a Node installer.
+<strong>We strongly recommend using a Node version manager to install Node.js and npm.</strong> We do not recommend using a
+Node installer, since the Node installation process installs npm in a directory with local permissions and can cause permissions errors when you run npm packages globally.</p>
+<h3 id="overview">Overview</h3>
+<ul>
+<li><a href="#checking-your-version-of-npm-and-nodejs">Checking your version of npm and Node.js</a></li>
+<li><a href="#using-a-node-version-manager-to-install-nodejs-and-npm">Using a Node version manager to install Node.js and npm</a></li>
+<li><a href="#using-a-node-installer-to-install-nodejs-and-npm">Using a Node installer to install Node.js and npm</a></li>
+</ul>
+<h3 id="checking-your-version-of-npm-and-nodejs">Checking your version of npm and Node.js</h3>
+<p>To see if you already have Node.js and npm installed and check the installed version, run the following commands:</p>
+<pre><code>node -v
+npm -v
+</code></pre>
+<h3 id="using-a-node-version-manager-to-install-nodejs-and-npm">Using a Node version manager to install Node.js and npm</h3>
+<p>Node version managers allow you to install and switch between multiple versions of Node.js and npm on your system so you can test your applications on multiple versions of npm to ensure they work for users on different versions.
+You can <a href="https://github.com/search?q=node+version+manager+archived%3Afalse&amp;type=repositories&amp;ref=advsearch">search for them on GitHub</a>.</p>
+<h3 id="using-a-node-installer-to-install-nodejs-and-npm">Using a Node installer to install Node.js and npm</h3>
+<p>If you are unable to use a Node version manager, you can use a Node installer to install both Node.js and npm on your system.</p>
+<ul>
+<li><a href="https://nodejs.org/en/download/">Node.js installer</a></li>
+<li><a href="https://github.com/nodesource/distributions">NodeSource installer</a>.
+If you use Linux, we recommend that you use a NodeSource installer.</li>
+</ul>
+<h4 id="macos-or-windows-node-installers">macOS or Windows Node installers</h4>
+<p>If you're using macOS or Windows, use one of the installers from the <a href="https://nodejs.org/en/download/">Node.js download page</a>.
+Be sure to install the version labeled <strong>LTS</strong>. Other versions have not yet been tested with npm.</p>
+<h4 id="linux-or-other-operating-systems-node-installers">Linux or other operating systems Node installers</h4>
+<p>If you're using Linux or another operating system, use one of the following installers:</p>
+<ul>
+<li><a href="https://github.com/nodesource/distributions">NodeSource installer</a> (recommended)</li>
+<li>One of the installers on the <a href="https://nodejs.org/en/download/">Node.js download page</a></li>
+</ul>
+<p>Or see <a href="https://nodejs.org/en/download/package-manager/">this page</a> to install npm for Linux in the way many Linux developers prefer.</p></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/install.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/npm-global.html b/node/node_modules/npm/docs/output/configuring-npm/npm-global.html
new file mode 100644
index 0000000000000000000000000000000000000000..1d1bbb261edba16789ce6f99c29cb00b5753e67c
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/npm-global.html
@@ -0,0 +1,331 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Folders</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----folders----11130">
+    <span>Folders</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Folder structures used by npm</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><ul><li><a href="#tldr">tl;dr</a></li><li><a href="#prefix-configuration">prefix Configuration</a></li><li><a href="#node-modules">Node Modules</a></li><li><a href="#executables">Executables</a></li><li><a href="#man-pages">Man Pages</a></li><li><a href="#cache">Cache</a></li></ul><li><a href="#more-information">More Information</a></li><ul><li><a href="#global-installation">Global Installation</a></li><li><a href="#cycles-conflicts-and-folder-parsimony">Cycles, Conflicts, and Folder Parsimony</a></li><li><a href="#example">Example</a></li><li><a href="#publishing">Publishing</a></li></ul><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>npm puts various things on your computer.
+That's its job.</p>
+<p>This document will tell you what it puts where.</p>
+<h4 id="tldr">tl;dr</h4>
+<ul>
+<li>Local install (default): puts stuff in <code>./node_modules</code> of the current package root.</li>
+<li>Global install (with <code>-g</code>): puts stuff in /usr/local or wherever node is installed.</li>
+<li>Install it <strong>locally</strong> if you're going to <code>require()</code> it.</li>
+<li>Install it <strong>globally</strong> if you're going to run it on the command line.</li>
+<li>If you need both, then install it in both places, or use <code>npm link</code>.</li>
+</ul>
+<h4 id="prefix-configuration">prefix Configuration</h4>
+<p>The <a href="../using-npm/config#prefix.html"><code>prefix</code> config</a> defaults to the location where node is installed.
+On most systems, this is <code>/usr/local</code>.
+On Windows, it's <code>%AppData%\npm</code>.
+On Unix systems, it's one level up, since node is typically installed at <code>{prefix}/bin/node</code> rather than <code>{prefix}/node.exe</code>.</p>
+<p>When the <code>global</code> flag is set, npm installs things into this prefix.
+When it is not set, it uses the root of the current package, or the current working directory if not in a package already.</p>
+<h4 id="node-modules">Node Modules</h4>
+<p>Packages are dropped into the <code>node_modules</code> folder under the <code>prefix</code>.
+When installing locally, this means that you can <code>require("packagename")</code> to load its main module, or <code>require("packagename/lib/path/to/sub/module")</code> to load other modules.</p>
+<p>Global installs on Unix systems go to <code>{prefix}/lib/node_modules</code>.
+Global installs on Windows go to <code>{prefix}/node_modules</code> (that is, no <code>lib</code> folder.)</p>
+<p>Scoped packages are installed the same way, except they are grouped together in a sub-folder of the relevant <code>node_modules</code> folder with the name of that scope prefix by the @ symbol, e.g. <code>npm install @myorg/package</code> would place the package in <code>{prefix}/node_modules/@myorg/package</code>.
+See <a href="../using-npm/scope.html"><code>scope</code></a> for more details.</p>
+<p>If you wish to <code>require()</code> a package, then install it locally.</p>
+<h4 id="executables">Executables</h4>
+<p>When in global mode, executables are linked into <code>{prefix}/bin</code> on Unix, or directly into <code>{prefix}</code> on Windows.
+Ensure that path is in your terminal's <code>PATH</code> environment to run them.</p>
+<p>When in local mode, executables are linked into <code>./node_modules/.bin</code> so that they can be made available to scripts run through npm.
+(For example, so that a test runner will be in the path when you run <code>npm test</code>.)</p>
+<h4 id="man-pages">Man Pages</h4>
+<p>When in global mode, man pages are linked into <code>{prefix}/share/man</code>.</p>
+<p>When in local mode, man pages are not installed.</p>
+<p>Man pages are not installed on Windows systems.</p>
+<h4 id="cache">Cache</h4>
+<p>See <a href="../commands/npm-cache.html"><code>npm cache</code></a>.
+Cache files are stored in <code>~/.npm</code> on Posix, or <code>%LocalAppData%/npm-cache</code> on Windows.</p>
+<p>This is controlled by the <a href="../using-npm/config#cache.html"><code>cache</code> config</a> param.</p>
+<h3 id="more-information">More Information</h3>
+<p>When installing locally, npm first tries to find an appropriate <code>prefix</code> folder.
+This is so that <code>npm install foo@1.2.3</code> will install to the sensible root of your package, even if you happen to have <code>cd</code>ed into some other folder.</p>
+<p>Starting at the $PWD, npm will walk up the folder tree checking for a folder that contains either a <code>package.json</code> file, or a <code>node_modules</code> folder.
+If such a thing is found, then that is treated as the effective "current directory" for the purpose of running npm commands.
+(This behavior is inspired by and similar to git's .git-folder seeking logic when running git commands in a working dir.)</p>
+<p>If no package root is found, then the current folder is used.</p>
+<p>When you run <code>npm install foo@1.2.3</code>, then the package is loaded into the cache, and then unpacked into <code>./node_modules/foo</code>.
+Then, any of foo's dependencies are similarly unpacked into <code>./node_modules/foo/node_modules/...</code>.</p>
+<p>Any bin files are symlinked to <code>./node_modules/.bin/</code>, so that they may be found by npm scripts when necessary.</p>
+<h4 id="global-installation">Global Installation</h4>
+<p>If the <a href="../using-npm/config#global.html"><code>global</code> config</a> is set to true, then npm will install packages "globally".</p>
+<p>For global installation, packages are installed roughly the same way, but using the folders described above.</p>
+<h4 id="cycles-conflicts-and-folder-parsimony">Cycles, Conflicts, and Folder Parsimony</h4>
+<p>Cycles are handled using the property of node's module system that it walks up the directories looking for <code>node_modules</code> folders.
+So, at every stage, if a package is already installed in an ancestor <code>node_modules</code> folder, then it is not installed at the current location.</p>
+<p>Consider the case above, where <code>foo -&gt; bar -&gt; baz</code>.
+Imagine if, in addition to that, baz depended on bar, so you'd have:
+<code>foo -&gt; bar -&gt; baz -&gt; bar -&gt; baz ...</code>.
+However, since the folder structure is: <code>foo/node_modules/bar/node_modules/baz</code>, there's no need to put another copy of bar into <code>.../baz/node_modules</code>, since when baz calls <code>require("bar")</code>, it will get the copy that is installed in <code>foo/node_modules/bar</code>.</p>
+<p>This shortcut is only used if the exact same version would be installed in multiple nested <code>node_modules</code> folders.
+It is still possible to have <code>a/node_modules/b/node_modules/a</code> if the two "a" packages are different versions.
+However, without repeating the exact same package multiple times, an infinite regress will always be prevented.</p>
+<p>Another optimization can be made by installing dependencies at the highest level possible, below the localized "target" folder (hoisting).
+Since version 3, npm hoists dependencies by default.</p>
+<h4 id="example">Example</h4>
+<p>Consider this dependency graph:</p>
+<pre><code class="language-bash">foo
++-- blerg@1.2.5
++-- bar@1.2.3
+|   +-- blerg@1.x (latest=1.3.7)
+|   +-- baz@2.x
+|   |   `-- quux@3.x
+|   |       `-- bar@1.2.3 (cycle)
+|   `-- asdf@*
+`-- baz@1.2.3
+    `-- quux@3.x
+        `-- bar
+</code></pre>
+<p>In this case, we might expect a folder structure like this (with all dependencies hoisted to the highest level possible):</p>
+<pre><code class="language-bash">foo
++-- node_modules
+    +-- blerg (1.2.5) &lt;---[A]
+    +-- bar (1.2.3) &lt;---[B]
+    |   +-- node_modules
+    |       +-- baz (2.0.2) &lt;---[C]
+    +-- asdf (2.3.4)
+    +-- baz (1.2.3) &lt;---[D]
+    +-- quux (3.2.0) &lt;---[E]
+</code></pre>
+<p>Since foo depends directly on <code>bar@1.2.3</code> and <code>baz@1.2.3</code>, those are installed in foo's <code>node_modules</code> folder.</p>
+<p>Even though the latest copy of blerg is 1.3.7, foo has a specific dependency on version 1.2.5.
+So, that gets installed at [A].
+Since the parent installation of blerg satisfies bar's dependency on <code>blerg@1.x</code>, it does not install another copy under [B].</p>
+<p>Bar [B] also has dependencies on baz and asdf.
+Because it depends on <code>baz@2.x</code>, it cannot re-use the <code>baz@1.2.3</code> installed in the parent <code>node_modules</code> folder [D], and must install its own copy [C].
+In order to minimize duplication, npm hoists dependencies to the top level by default, so asdf is installed under [A].</p>
+<p>Underneath bar, the <code>baz -&gt; quux -&gt; bar</code> dependency creates a cycle.
+However, because bar is already in quux's ancestry [B], it does not unpack another copy of bar into that folder.
+Likewise, quux's [E] folder tree is empty, because its dependency on bar is satisfied by the parent folder copy installed at [B].</p>
+<p>For a graphical breakdown of what is installed where, use <code>npm ls</code>.</p>
+<h4 id="publishing">Publishing</h4>
+<p>Upon publishing, npm will look in the <code>node_modules</code> folder.
+If any of the items there are not in the <code>bundleDependencies</code> array, then they will not be included in the package tarball.</p>
+<p>This allows a package maintainer to install all of their dependencies (and dev dependencies) locally, but only re-publish those items that cannot be found elsewhere.
+See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more information.</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-pack.html">npm pack</a></li>
+<li><a href="../commands/npm-cache.html">npm cache</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/folders.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/npm-json.html b/node/node_modules/npm/docs/output/configuring-npm/npm-json.html
new file mode 100644
index 0000000000000000000000000000000000000000..764628c0d58f0dc1ebd794ba77e3e2e8bd753342
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/npm-json.html
@@ -0,0 +1,1086 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>package.json</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----packagejson----11130">
+    <span>package.json</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Specifics of npm's package.json handling</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#name">name</a></li><li><a href="#version">version</a></li><li><a href="#description2">description</a></li><li><a href="#keywords">keywords</a></li><li><a href="#homepage">homepage</a></li><li><a href="#bugs">bugs</a></li><li><a href="#license">license</a></li><li><a href="#people-fields-author-contributors">people fields: author, contributors</a></li><li><a href="#funding">funding</a></li><li><a href="#files">files</a></li><li><a href="#exports">exports</a></li><li><a href="#main">main</a></li><li><a href="#type">type</a></li><li><a href="#browser">browser</a></li><li><a href="#bin">bin</a></li><li><a href="#man">man</a></li><li><a href="#directories">directories</a></li><ul><li><a href="#directoriesbin">directories.bin</a></li><li><a href="#directoriesman">directories.man</a></li></ul><li><a href="#repository">repository</a></li><li><a href="#scripts">scripts</a></li><li><a href="#gypfile">gypfile</a></li><li><a href="#config">config</a></li><li><a href="#dependencies">dependencies</a></li><ul><li><a href="#urls-as-dependencies">URLs as Dependencies</a></li><li><a href="#git-urls-as-dependencies">Git URLs as Dependencies</a></li><li><a href="#github-urls">GitHub URLs</a></li><li><a href="#local-paths">Local Paths</a></li></ul><li><a href="#devdependencies">devDependencies</a></li><li><a href="#peerdependencies">peerDependencies</a></li><li><a href="#peerdependenciesmeta">peerDependenciesMeta</a></li><li><a href="#bundledependencies">bundleDependencies</a></li><li><a href="#optionaldependencies">optionalDependencies</a></li><li><a href="#overrides">overrides</a></li><ul><li><a href="#replacing-a-dependency-with-a-fork">Replacing a dependency with a fork</a></li></ul><li><a href="#engines">engines</a></li><li><a href="#os">os</a></li><li><a href="#cpu">cpu</a></li><li><a href="#libc">libc</a></li><li><a href="#devengines">devEngines</a></li><li><a href="#private">private</a></li><li><a href="#publishconfig">publishConfig</a></li><li><a href="#workspaces">workspaces</a></li><li><a href="#default-values">DEFAULT VALUES</a></li><li><a href="#see-also">SEE ALSO</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>This document is all you need to know about what's required in your package.json file.
+It must be actual JSON, not just a JavaScript object literal.</p>
+<p>A lot of the behavior described in this document is affected by the config settings described in <a href="../using-npm/config.html"><code>config</code></a>.</p>
+<h3 id="name">name</h3>
+<p>If you plan to publish your package, the <em>most</em> important things in your package.json are the name and version fields as they will be required.
+The name and version together form an identifier that is assumed to be completely unique.
+Changes to the package should come along with changes to the version.
+If you don't plan to publish your package, the name and version fields are optional.</p>
+<p>The name is what your thing is called.</p>
+<p>Some rules:</p>
+<ul>
+<li>The name must be less than or equal to 214 characters.
+This includes the scope for scoped packages.</li>
+<li>The names of scoped packages can begin with a dot or an underscore.
+This is not permitted without a scope.</li>
+<li>New packages must not have uppercase letters in the name.</li>
+<li>The name ends up being part of a URL, an argument on the command line, and a folder name.
+Therefore, the name can't contain any non-URL-safe characters.</li>
+</ul>
+<p>Some tips:</p>
+<ul>
+<li>Don't use the same name as a core Node module.</li>
+<li>Don't put "js" or "node" in the name.
+It's assumed that it's js, since you're writing a package.json file, and you can specify the engine using the "<a href="#engines">engines</a>" field.
+(See below.)</li>
+<li>The name will probably be passed as an argument to require(), so it should be something short, but also reasonably descriptive.</li>
+<li>You may want to check the npm registry to see if there's something by that name already, before you get too attached to it.
+<a href="https://www.npmjs.com/">https://www.npmjs.com/</a></li>
+</ul>
+<p>A name can be optionally prefixed by a scope, e.g. <code>@npm/example</code>.
+See <a href="../using-npm/scope.html"><code>scope</code></a> for more detail.</p>
+<h3 id="version">version</h3>
+<p>If you plan to publish your package, the <em>most</em> important things in your package.json are the name and version fields as they will be required.
+The name and version together form an identifier that is assumed to be completely unique.
+Changes to the package should come along with changes to the version.
+If you don't plan to publish your package, the name and version fields are optional.</p>
+<p>Version must be parseable by <a href="https://github.com/npm/node-semver">node-semver</a>, which is bundled with npm as a dependency.
+(<code>npm install semver</code> to use it yourself.)</p>
+<h3 id="description2">description</h3>
+<p>Put a description in it.
+It's a string.
+This helps people discover your package, as it's listed in <code>npm search</code>.</p>
+<h3 id="keywords">keywords</h3>
+<p>Put keywords in it.
+It's an array of strings.
+This helps people discover your package as it's listed in <code>npm search</code>.</p>
+<p>Example:</p>
+<pre><code class="language-json">"keywords": [
+  "node",
+  "javascript",
+  "npm"
+]
+</code></pre>
+<h3 id="homepage">homepage</h3>
+<p>The URL to the project homepage.</p>
+<p>Example:</p>
+<pre><code class="language-json">"homepage": "https://github.com/npm/example#readme"
+</code></pre>
+<h3 id="bugs">bugs</h3>
+<p>The URL to your project's issue tracker and / or the email address to which issues should be reported.
+These are helpful for people who encounter issues with your package.</p>
+<p>It should look like this:</p>
+<pre><code class="language-json">{
+  "bugs": {
+    "url": "https://github.com/npm/example/issues",
+    "email": "example@npmjs.com"
+  }
+}
+</code></pre>
+<p>You can specify either one or both values.
+If you want to provide only a URL, you can specify the value for "bugs" as a simple string instead of an object.</p>
+<p>If a URL is provided, it will be used by the <code>npm bugs</code> command.</p>
+<h3 id="license">license</h3>
+<p>You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.</p>
+<p>If you're using a common license such as BSD-2-Clause or MIT, add a current SPDX license identifier for the license you're using, like this:</p>
+<pre><code class="language-json">{
+  "license" : "BSD-3-Clause"
+}
+</code></pre>
+<p>You can check <a href="https://spdx.org/licenses/">the full list of SPDX license IDs</a>.
+Ideally, you should pick one that is <a href="https://opensource.org/licenses/">OSI</a> approved.</p>
+<p>If your package is licensed under multiple common licenses, use an <a href="https://spdx.dev/specifications/">SPDX license expression syntax version 2.0 string</a>, like this:</p>
+<pre><code class="language-json">{
+  "license" : "(ISC OR GPL-3.0)"
+}
+</code></pre>
+<p>If you are using a license that hasn't been assigned an SPDX identifier, or if you are using a custom license, use a string value like this one:</p>
+<pre><code class="language-json">{
+  "license" : "SEE LICENSE IN &lt;filename&gt;"
+}
+</code></pre>
+<p>Then include a file named <code>&lt;filename&gt;</code> at the top level of the package.</p>
+<p>Some old packages used license objects or a "licenses" property containing an array of license objects:</p>
+<pre><code class="language-json">// Not valid metadata
+{
+  "license" : {
+    "type" : "ISC",
+    "url" : "https://opensource.org/licenses/ISC"
+  }
+}
+
+// Not valid metadata
+{
+  "licenses" : [
+    {
+      "type": "MIT",
+      "url": "https://www.opensource.org/licenses/mit-license.php"
+    },
+    {
+      "type": "Apache-2.0",
+      "url": "https://opensource.org/licenses/apache2.0.php"
+    }
+  ]
+}
+</code></pre>
+<p>Those styles are now deprecated.
+Instead, use SPDX expressions, like this:</p>
+<pre><code class="language-json">{
+  "license": "ISC"
+}
+</code></pre>
+<pre><code class="language-json">{
+  "license": "(MIT OR Apache-2.0)"
+}
+</code></pre>
+<p>Finally, if you do not wish to grant others the right to use a private or unpublished package under any terms:</p>
+<pre><code class="language-json">{
+  "license": "UNLICENSED"
+}
+</code></pre>
+<p>Consider also setting <code>"private": true</code> to prevent accidental publication.</p>
+<h3 id="people-fields-author-contributors">people fields: author, contributors</h3>
+<p>The "author" is one person.
+"contributors" is an array of people.
+A "person" is an object with a "name" field and optionally "url" and "email", like this:</p>
+<pre><code class="language-json">{
+  "name" : "Barney Rubble",
+  "email" : "barney@npmjs.com",
+  "url" : "http://barnyrubble.npmjs.com/"
+}
+</code></pre>
+<p>Or you can shorten that all into a single string, and npm will parse it for you:</p>
+<pre><code class="language-json">{
+  "author": "Barney Rubble &lt;barney@npmjs.com&gt; (http://barnyrubble.npmjs.com/)"
+}
+</code></pre>
+<p>Both email and url are optional either way.</p>
+<p>npm also sets a top-level "maintainers" field with your npm user info.</p>
+<h3 id="funding">funding</h3>
+<p>You can specify an object containing a URL that provides up-to-date information about ways to help fund development of your package, a string URL, or an array of objects and string URLs:</p>
+<pre><code class="language-json">{
+  "funding": {
+    "type" : "individual",
+    "url" : "http://npmjs.com/donate"
+  }
+}
+</code></pre>
+<pre><code class="language-json">{
+  "funding": {
+    "type" : "patreon",
+    "url" : "https://www.patreon.com/user"
+  }
+}
+</code></pre>
+<pre><code class="language-json">{
+  "funding": "http://npmjs.com/donate"
+}
+</code></pre>
+<pre><code class="language-json">{
+  "funding": [
+    {
+      "type" : "individual",
+      "url" : "http://npmjs.com/donate"
+    },
+    "http://npmjs.com/donate-also",
+    {
+      "type" : "patreon",
+      "url" : "https://www.patreon.com/user"
+    }
+  ]
+}
+</code></pre>
+<p>Users can use the <code>npm fund</code> subcommand to list the <code>funding</code> URLs of all dependencies of their project, direct and indirect.
+A shortcut to visit each funding URL is also available when providing the project name such as:
+<code>npm fund &lt;projectname&gt;</code> (when there are multiple URLs, the first one will be visited)</p>
+<h3 id="files">files</h3>
+<p>The optional <code>files</code> field is an array of file patterns that describes the entries to be included when your package is installed as a dependency.
+File patterns follow a similar syntax to <code>.gitignore</code>, but reversed: including a file, directory, or glob pattern (<code>*</code>, <code>**/*</code>, and such) will make it so that file is included in the tarball when it's packed.
+Omitting the field will make it default to <code>["*"]</code>, which means it will include all files.</p>
+<p>Some special files and directories are also included or excluded regardless of whether they exist in the <code>files</code> array (see below).</p>
+<p>You can also provide a <code>.npmignore</code> file in the root of your package or in subdirectories, which will keep files from being included.
+At the root of your package it will not override the "files" field, but in subdirectories it will.
+The <code>.npmignore</code> file works just like a <code>.gitignore</code>.
+If there is a <code>.gitignore</code> file, and <code>.npmignore</code> is missing, <code>.gitignore</code>'s contents will be used instead.</p>
+<p>Certain files are always included, regardless of settings:</p>
+<ul>
+<li><code>package.json</code></li>
+<li><code>README</code></li>
+<li><code>LICENSE</code> / <code>LICENCE</code></li>
+<li>The file in the "main" field</li>
+<li>The file(s) in the "bin" field</li>
+</ul>
+<p><code>README</code> &amp; <code>LICENSE</code> can have any case and extension.</p>
+<p>Some files are always ignored by default:</p>
+<ul>
+<li><code>*.orig</code></li>
+<li><code>.*.swp</code></li>
+<li><code>.DS_Store</code></li>
+<li><code>._*</code></li>
+<li><code>.git</code></li>
+<li><code>.hg</code></li>
+<li><code>.lock-wscript</code></li>
+<li><code>.npmrc</code></li>
+<li><code>.svn</code></li>
+<li><code>.wafpickle-N</code></li>
+<li><code>CVS</code></li>
+<li><code>config.gypi</code></li>
+<li><code>node_modules</code></li>
+<li><code>npm-debug.log</code></li>
+<li><code>package-lock.json</code> (use <a href="../configuring-npm/npm-shrinkwrap-json.html"><code>npm-shrinkwrap.json</code></a> if you wish it to be published)</li>
+<li><code>pnpm-lock.yaml</code></li>
+<li><code>yarn.lock</code></li>
+<li><code>bun.lockb</code></li>
+</ul>
+<p>Most of these ignored files can be included specifically if included in the <code>files</code> globs.
+Exceptions to this are:</p>
+<ul>
+<li><code>.git</code></li>
+<li><code>.npmrc</code></li>
+<li><code>node_modules</code></li>
+<li><code>package-lock.json</code></li>
+<li><code>pnpm-lock.yaml</code></li>
+<li><code>yarn.lock</code></li>
+<li><code>bun.lockb</code></li>
+</ul>
+<p>These cannot be included.</p>
+<h3 id="exports">exports</h3>
+<p>The "exports" provides a modern alternative to "main" allowing multiple entry points to be defined, conditional entry resolution support between environments, and preventing any other entry points besides those defined in "exports". This encapsulation allows module authors to clearly define the public interface for their package.
+For more details see the <a href="https://nodejs.org/api/packages.html#package-entry-points">node.js documentation on package entry points</a></p>
+<h3 id="main">main</h3>
+<p>The main field is a module ID that is the primary entry point to your program.
+That is, if your package is named <code>foo</code>, and a user installs it, and then does <code>require("foo")</code>, then your main module's exports object will be returned.</p>
+<p>This should be a module relative to the root of your package folder.</p>
+<p>For most modules, it makes the most sense to have a main script and often not much else.</p>
+<p>If <code>main</code> is not set, it defaults to <code>index.js</code> in the package's root folder.</p>
+<h3 id="type">type</h3>
+<p>The <code>type</code> field defines how Node.js should interpret <code>.js</code> files in your package. This field is not used by npm.</p>
+<p>See the <a href="https://nodejs.org/api/packages.html#type">Node.js documentation on the type field</a> for more information.</p>
+<h3 id="browser">browser</h3>
+<p>If your module is meant to be used client-side the browser field should be used instead of the main field.
+This is helpful to hint users that it might rely on primitives that aren't available in Node.js modules.
+(e.g. <code>window</code>)</p>
+<h3 id="bin">bin</h3>
+<p>A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)</p>
+<p>To use this, supply a <code>bin</code> field in your package.json which is a map of command name to local file name.
+When this package is installed globally, that file will be either linked inside the global bins directory or a cmd (Windows Command File) will be created which executes the specified file in the <code>bin</code> field, so it is available to run by <code>name</code> or <code>name.cmd</code> (on Windows PowerShell).
+When this package is installed as a dependency in another package, the file will be linked where it will be available to that package either directly by <code>npm exec</code> or by name in other scripts when invoking them via <code>npm run</code>.</p>
+<p>For example, myapp could have this:</p>
+<pre><code class="language-json">{
+  "bin": {
+    "myapp": "bin/cli.js"
+  }
+}
+</code></pre>
+<p>So, when you install myapp, in case of unix-like OS it'll create a symlink from the <code>cli.js</code> script to <code>/usr/local/bin/myapp</code> and in case of windows it will create a cmd file usually at <code>C:\Users\{Username}\AppData\Roaming\npm\myapp.cmd</code> which runs the <code>cli.js</code> script.</p>
+<p>If you have a single executable, and its name should be the name of the package, then you can just supply it as a string.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": "path/to/program"
+}
+</code></pre>
+<p>would be the same as this:</p>
+<pre><code class="language-json">{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": {
+    "my-program": "path/to/program"
+  }
+}
+</code></pre>
+<p>Please make sure that your file(s) referenced in <code>bin</code> starts with <code>#!/usr/bin/env node</code>; otherwise, the scripts are started without the node executable!</p>
+<p>Note that you can also set the executable files using <a href="#directoriesbin">directories.bin</a>.</p>
+<p>See <a href="../configuring-npm/folders#executables.html">folders</a> for more info on executables.</p>
+<h3 id="man">man</h3>
+<p>Specify either a single file or an array of filenames to put in place for the <code>man</code> program to find.</p>
+<p>If only a single file is provided, then it's installed such that it is the result from <code>man &lt;pkgname&gt;</code>, regardless of its actual filename.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": "./man/doc.1"
+}
+</code></pre>
+<p>would link the <code>./man/doc.1</code> file in such that it is the target for <code>man foo</code></p>
+<p>If the filename doesn't start with the package name, then it's prefixed.
+So, this:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": [
+    "./man/foo.1",
+    "./man/bar.1"
+  ]
+}
+</code></pre>
+<p>will create files to do <code>man foo</code> and <code>man foo-bar</code>.</p>
+<p>Man files must end with a number, and optionally a <code>.gz</code> suffix if they are compressed.
+The number dictates which man section the file is installed into.</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": [
+    "./man/foo.1",
+    "./man/foo.2"
+  ]
+}
+</code></pre>
+<p>will create entries for <code>man foo</code> and <code>man 2 foo</code></p>
+<h3 id="directories">directories</h3>
+<p>The CommonJS <a href="http://wiki.commonjs.org/wiki/Packages/1.0">Packages</a> spec details a few ways that you can indicate the structure of your package using a <code>directories</code> object.
+If you look at <a href="https://registry.npmjs.org/npm/latest">npm's package.json</a>, you'll see that it has directories for doc, lib, and man.</p>
+<p>In the future, this information may be used in other creative ways.</p>
+<h4 id="directoriesbin">directories.bin</h4>
+<p>If you specify a <code>bin</code> directory in <code>directories.bin</code>, all the files in that folder will be added.</p>
+<p>Because of the way the <code>bin</code> directive works, specifying both a <code>bin</code> path and setting <code>directories.bin</code> is an error.
+If you want to specify individual files, use <code>bin</code>, and for all the files in an existing <code>bin</code> directory, use <code>directories.bin</code>.</p>
+<h4 id="directoriesman">directories.man</h4>
+<p>A folder that is full of man pages.
+Sugar to generate a "man" array by walking the folder.</p>
+<h3 id="repository">repository</h3>
+<p>Specify the place where your code lives.
+This is helpful for people who want to contribute.
+If the git repo is on GitHub, then the <code>npm repo</code> command will be able to find you.</p>
+<p>Do it like this:</p>
+<pre><code class="language-json">{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git"
+  }
+}
+</code></pre>
+<p>The URL should be a publicly available (perhaps read-only) URL that can be handed directly to a VCS program without any modification.
+It should not be a URL to an html project page that you put in your browser.
+It's for computers.</p>
+<p>For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for <code>npm install</code>:</p>
+<pre><code class="language-json">{
+  "repository": "npm/example",
+
+  "repository": "github:npm/example",
+
+  "repository": "gist:11081aaa281",
+
+  "repository": "bitbucket:user/repo",
+
+  "repository": "gitlab:user/repo"
+}
+</code></pre>
+<p><strong>Note on normalization:</strong> When you publish a package, npm normalizes the <code>repository</code> field to the full object format with a <code>url</code> property. If you use a shorthand format (like <code>"npm/example"</code>), you'll see a warning during <code>npm publish</code> indicating that the field was auto-corrected. While the shorthand format currently works, it's recommended to use the full object format in your <code>package.json</code> to avoid warnings and ensure future compatibility:</p>
+<pre><code class="language-json">{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/example.git"
+  }
+}
+</code></pre>
+<p>You can run <code>npm pkg fix</code> to automatically convert shorthand formats to the normalized object format.</p>
+<p>If the <code>package.json</code> for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives:</p>
+<pre><code class="language-json">{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git",
+    "directory": "workspaces/libnpmpublish"
+  }
+}
+</code></pre>
+<h3 id="scripts">scripts</h3>
+<p>The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package.
+The key is the lifecycle event, and the value is the command to run at that point.</p>
+<p>See <a href="../using-npm/scripts.html"><code>scripts</code></a> to find out more about writing package scripts.</p>
+<h3 id="gypfile">gypfile</h3>
+<p>If you have a binding.gyp file in the root of your package and you have not defined your own <code>install</code> or <code>preinstall</code> scripts, npm will default to building your module using node-gyp.</p>
+<p>To prevent npm from automatically building your module with node-gyp, set <code>gypfile</code> to <code>false</code>:</p>
+<pre><code class="language-json">{
+  "gypfile": false
+}
+</code></pre>
+<p>This is useful for packages that include native addons but want to handle the build process differently, or packages that have a binding.gyp file but should not be built as a native addon.</p>
+<h3 id="config">config</h3>
+<p>A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades.
+For instance, if a package had the following:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "config": {
+    "port": "8080"
+  }
+}
+</code></pre>
+<p>It could also have a "start" script that referenced the <code>npm_package_config_port</code> environment variable.</p>
+<h3 id="dependencies">dependencies</h3>
+<p>Dependencies are specified in a simple object that maps a package name to a version range.
+The version range is a string which has one or more space-separated descriptors.
+Dependencies can also be identified with a tarball or git URL.</p>
+<p><strong>Please do not put test harnesses or transpilers or other "development" time tools in your <code>dependencies</code> object.</strong>
+See <code>devDependencies</code>, below.</p>
+<p>See <a href="https://github.com/npm/node-semver#versions">semver</a> for more details about specifying version ranges.</p>
+<ul>
+<li><code>version</code> Must match <code>version</code> exactly</li>
+<li><code>&gt;version</code> Must be greater than <code>version</code></li>
+<li><code>&gt;=version</code> etc</li>
+<li><code>&lt;version</code></li>
+<li><code>&lt;=version</code></li>
+<li><code>~version</code> "Approximately equivalent to version"  See <a href="https://github.com/npm/node-semver#versions">semver</a></li>
+<li><code>^version</code> "Compatible with version"  See <a href="https://github.com/npm/node-semver#versions">semver</a></li>
+<li><code>1.2.x</code> 1.2.0, 1.2.1, etc., but not 1.3.0</li>
+<li><code>http://...</code> See 'URLs as Dependencies' below</li>
+<li><code>*</code> Matches any version</li>
+<li><code>""</code> (just an empty string) Same as <code>*</code></li>
+<li><code>version1 - version2</code> Same as <code>&gt;=version1 &lt;=version2</code>.</li>
+<li><code>range1 || range2</code> Passes if either range1 or range2 are satisfied.</li>
+<li><code>git...</code> See 'Git URLs as Dependencies' below</li>
+<li><code>user/repo</code> See 'GitHub URLs' below</li>
+<li><code>tag</code> A specific version tagged and published as <code>tag</code>  See <a href="../commands/npm-dist-tag.html"><code>npm dist-tag</code></a></li>
+<li><code>path/path/path</code> See <a href="#local-paths">Local Paths</a> below</li>
+<li><code>npm:@scope/pkg@version</code> Custom alias for a package See <a href="../using-npm/package-spec#aliases.html"><code>package-spec</code></a></li>
+</ul>
+<p>For example, these are all valid:</p>
+<pre><code class="language-json">{
+  "dependencies": {
+    "foo": "1.0.0 - 2.9999.9999",
+    "bar": "&gt;=1.0.2 &lt;2.1.2",
+    "baz": "&gt;1.0.2 &lt;=2.3.4",
+    "boo": "2.0.1",
+    "qux": "&lt;1.0.0 || &gt;=2.3.1 &lt;2.4.5 || &gt;=2.5.2 &lt;3.0.0",
+    "asd": "http://npmjs.com/example.tar.gz",
+    "til": "~1.2",
+    "elf": "~1.2.3",
+    "two": "2.x",
+    "thr": "3.3.x",
+    "lat": "latest",
+    "dyl": "file:../dyl",
+    "kpg": "npm:pkg@1.0.0"
+  }
+}
+</code></pre>
+<h4 id="urls-as-dependencies">URLs as Dependencies</h4>
+<p>You may specify a tarball URL in place of a version range.</p>
+<p>This tarball will be downloaded and installed locally to your package at install time.</p>
+<h4 id="git-urls-as-dependencies">Git URLs as Dependencies</h4>
+<p>Git URLs are of the form:</p>
+<pre><code class="language-bash">&lt;protocol&gt;://[&lt;user&gt;[:&lt;password&gt;]@]&lt;hostname&gt;[:&lt;port&gt;][:][/]&lt;path&gt;[#&lt;commit-ish&gt; | #semver:&lt;semver&gt;]
+</code></pre>
+<p><code>&lt;protocol&gt;</code> is one of <code>git</code>, <code>git+ssh</code>, <code>git+http</code>, <code>git+https</code>, or <code>git+file</code>.</p>
+<p>If <code>#&lt;commit-ish&gt;</code> is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format <code>#semver:&lt;semver&gt;</code>, <code>&lt;semver&gt;</code> can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither <code>#&lt;commit-ish&gt;</code> or <code>#semver:&lt;semver&gt;</code> is specified, then the default branch is used.</p>
+<p>Examples:</p>
+<pre><code class="language-bash">git+ssh://git@github.com:npm/cli.git#v1.0.27
+git+ssh://git@github.com:npm/cli#semver:^5.0
+git+https://isaacs@github.com/npm/cli.git
+git://github.com/npm/cli.git#v1.0.27
+</code></pre>
+<p>When installing from a <code>git</code> repository, the presence of certain fields in the <code>package.json</code> will cause npm to believe it needs to perform a build.
+To do so your repository will be cloned into a temporary directory, all of its deps installed, relevant scripts run, and the resulting directory packed and installed.</p>
+<p>This flow will occur if your git dependency uses <code>workspaces</code>, or if any of the following scripts are present:</p>
+<ul>
+<li><code>build</code></li>
+<li><code>prepare</code></li>
+<li><code>prepack</code></li>
+<li><code>preinstall</code></li>
+<li><code>install</code></li>
+<li><code>postinstall</code></li>
+</ul>
+<p>If your git repository includes pre-built artifacts, you will likely want to make sure that none of the above scripts are defined, or your dependency will be rebuilt for every installation.</p>
+<h4 id="github-urls">GitHub URLs</h4>
+<p>As of version 1.1.65, you can refer to GitHub URLs as just "foo":
+"user/foo-project".  Just as with git URLs, a <code>commit-ish</code> suffix can be included.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "0.0.0",
+  "dependencies": {
+    "express": "expressjs/express",
+    "mocha": "mochajs/mocha#4727d357ea",
+    "module": "npm/example-github-repo#feature\/branch"
+  }
+}
+</code></pre>
+<h4 id="local-paths">Local Paths</h4>
+<p>As of version 2.0.0 you can provide a path to a local directory that contains a package.
+Local paths can be saved using <code>npm install -S</code> or <code>npm install --save</code>, using any of these forms:</p>
+<pre><code class="language-bash">../foo/bar
+~/foo/bar
+./foo/bar
+/foo/bar
+</code></pre>
+<p>in which case they will be normalized to a relative path and added to your <code>package.json</code>.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "baz",
+  "dependencies": {
+    "bar": "file:../foo/bar"
+  }
+}
+</code></pre>
+<p>This feature is helpful for local offline development and creating tests that require npm installing where you don't want to hit an external server, but should not be used when publishing your package to the public registry.</p>
+<p><em>note</em>: Packages linked by local path will not have their own dependencies installed when <code>npm install</code> is run.
+You must run <code>npm install</code> from inside the local path itself.</p>
+<h3 id="devdependencies">devDependencies</h3>
+<p>If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.</p>
+<p>In this case, it's best to map these additional items in a <code>devDependencies</code> object.</p>
+<p>These things will be installed when doing <code>npm link</code> or <code>npm install</code> from the root of a package, and can be managed like any other npm configuration param.
+See <a href="../using-npm/config.html"><code>config</code></a> for more on the topic.</p>
+<p>For build steps that are not platform-specific, such as compiling CoffeeScript or other languages to JavaScript, use the <code>prepare</code> script to do this, and make the required package a devDependency.</p>
+<p>For example:</p>
+<pre><code class="language-json">{
+  "name": "@npm/ethopia-waza",
+  "description": "a delightfully fruity coffee varietal",
+  "version": "1.2.3",
+  "devDependencies": {
+    "coffee-script": "~1.6.3"
+  },
+  "scripts": {
+    "prepare": "coffee -o lib/ -c src/waza.coffee"
+  },
+  "main": "lib/waza.js"
+}
+</code></pre>
+<p>The <code>prepare</code> script will be run before publishing, so that users can consume the functionality without requiring them to compile it themselves.
+In dev mode (ie, locally running <code>npm install</code>), it'll run this script as well, so that you can test it easily.</p>
+<h3 id="peerdependencies">peerDependencies</h3>
+<p>In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a <code>require</code> of this host.
+This is usually referred to as a <em>plugin</em>. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.</p>
+<p>For example:</p>
+<pre><code class="language-json">{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x"
+  }
+}
+</code></pre>
+<p>This ensures your package <code>@npm/tea-latte</code> can be installed <em>along</em> with the second major version of the host package <code>@npm/tea</code> only.
+<code>npm install tea-latte</code> could possibly yield the following dependency graph:</p>
+<pre><code class="language-bash">├── @npm/tea-latte@1.3.5
+└── @npm/tea@2.2.0
+</code></pre>
+<p>In npm versions 3 through 6, <code>peerDependencies</code> were not automatically installed, and would raise a warning if an invalid version of the peer dependency was found in the tree.
+As of npm v7, peerDependencies <em>are</em> installed by default.</p>
+<p>Trying to install another plugin with a conflicting requirement may cause an error if the tree cannot be resolved correctly.
+For this reason, make sure your plugin requirement is as broad as possible, and not to lock it down to specific patch versions.</p>
+<p>Assuming the host complies with <a href="https://semver.org/">semver</a>, only changes in the host package's major version will break your plugin.
+Thus, if you've worked with every 1.x version of the host package, use <code>"^1.0"</code> or <code>"1.x"</code> to express this.
+If you depend on features introduced in 1.5.2, use <code>"^1.5.2"</code>.</p>
+<h3 id="peerdependenciesmeta">peerDependenciesMeta</h3>
+<p>The <code>peerDependenciesMeta</code> field serves to provide npm more information on how your peer dependencies are to be used.
+Specifically, it allows peer dependencies to be marked as optional.
+Npm will not automatically install optional peer dependencies.
+This allows you to integrate and interact with a variety of host packages without requiring all of them to be installed.</p>
+<p>For example:</p>
+<pre><code class="language-json">{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x",
+    "@npm/soy-milk": "1.2"
+  },
+  "peerDependenciesMeta": {
+    "@npm/soy-milk": {
+      "optional": true
+    }
+  }
+}
+</code></pre>
+<h3 id="bundledependencies">bundleDependencies</h3>
+<p>This defines an array of package names that will be bundled when publishing the package.</p>
+<p>In cases where you need to preserve npm packages locally or have them available through a single file download, you can bundle the packages in a tarball file by specifying the package names in the <code>bundleDependencies</code> array and executing <code>npm pack</code>.</p>
+<p>For example:</p>
+<p>If we define a package.json like this:</p>
+<pre><code class="language-json">{
+  "name": "@npm/awesome-web-framework",
+  "version": "1.0.0",
+  "bundleDependencies": [
+    "@npm/renderized",
+    "@npm/super-streams"
+  ]
+}
+</code></pre>
+<p>we can obtain <code>@npm/awesome-web-framework-1.0.0.tgz</code> file by running <code>npm pack</code>.
+This file contains the dependencies <code>@npm/renderized</code> and <code>@npm/super-streams</code> which can be installed in a new project by executing <code>npm install awesome-web-framework-1.0.0.tgz</code>.
+Note that the package names do not include any versions, as that information is specified in <code>dependencies</code>.</p>
+<p>If this is spelled <code>"bundledDependencies"</code>, then that is also honored.</p>
+<p>Alternatively, <code>"bundleDependencies"</code> can be defined as a boolean value.
+A value of <code>true</code> will bundle all dependencies, a value of <code>false</code> will bundle none.</p>
+<h3 id="optionaldependencies">optionalDependencies</h3>
+<p>If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the <code>optionalDependencies</code> object.
+This is a map of package name to version or URL, just like the <code>dependencies</code> object.
+The difference is that build failures do not cause installation to fail.
+Running <code>npm install --omit=optional</code> will prevent these dependencies from being installed.</p>
+<p>It is still your program's responsibility to handle the lack of the dependency.
+For example, something like this:</p>
+<pre><code class="language-js">try {
+  var foo = require('@npm/foo')
+  var fooVersion = require('@npm/foo/package.json').version
+} catch (er) {
+  foo = null
+}
+if ( notGoodFooVersion(fooVersion) ) {
+  foo = null
+}
+
+// .. then later in your program ..
+
+if (foo) {
+  foo.doFooThings()
+}
+</code></pre>
+<p>Entries in <code>optionalDependencies</code> will override entries of the same name in <code>dependencies</code>, so it's usually best to only put in one place.</p>
+<h3 id="overrides">overrides</h3>
+<p>If you need to make specific changes to dependencies of your dependencies, for example replacing the version of a dependency with a known security issue, replacing an existing dependency with a fork, or making sure that the same version of a package is used everywhere, then you may add an override.</p>
+<p>Overrides provide a way to replace a package in your dependency tree with another version, or another package entirely.
+These changes can be scoped as specific or as vague as desired.</p>
+<p>Overrides are only considered in the root <code>package.json</code> file for a project.
+Overrides in installed dependencies (including <a href="../using-npm/workspaces.html">workspaces</a>) are not considered in dependency tree resolution.
+Published packages may dictate their resolutions by pinning dependencies or using an <a href="../configuring-npm/npm-shrinkwrap-json.html"><code>npm-shrinkwrap.json</code></a> file.</p>
+<p>To make sure the package <code>@npm/foo</code> is always installed as version <code>1.0.0</code> no matter what version your dependencies rely on:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/foo": "1.0.0"
+  }
+}
+</code></pre>
+<p>The above is a short hand notation, the full object form can be used to allow overriding a package itself as well as a child of the package.
+This will cause <code>@npm/foo</code> to always be <code>1.0.0</code> while also making <code>@npm/bar</code> at any depth beyond <code>@npm/foo</code> also <code>1.0.0</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/foo": {
+      ".": "1.0.0",
+      "@npm/bar": "1.0.0"
+    }
+  }
+}
+</code></pre>
+<p>To only override <code>@npm/foo</code> to be <code>1.0.0</code> when it's a child (or grandchild, or great grandchild, etc) of the package <code>@npm/bar</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/bar": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+</code></pre>
+<p>Keys can be nested to any arbitrary length.
+To override <code>@npm/foo</code> only when it's a child of <code>@npm/bar</code> and only when <code>@npm/bar</code> is a child of <code>@npm/baz</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/baz": {
+      "@npm/bar": {
+        "@npm/foo": "1.0.0"
+      }
+    }
+  }
+}
+</code></pre>
+<p>The key of an override can also include a version, or range of versions.
+To override <code>@npm/foo</code> to <code>1.0.0</code>, but only when it's a child of <code>@npm/bar@2.0.0</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/bar@2.0.0": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+</code></pre>
+<p>You may not set an override for a package that you directly depend on unless both the dependency and the override itself share the exact same spec.
+To make this limitation easier to deal with, overrides may also be defined as a reference to a spec for a direct dependency by prefixing the name of the package you wish the version to match with a <code>$</code>.</p>
+<pre><code class="language-json">{
+  "dependencies": {
+    "@npm/foo": "^1.0.0"
+  },
+  "overrides": {
+    // BAD, will throw an EOVERRIDE error
+    // "foo": "^2.0.0"
+    // GOOD, specs match so override is allowed
+    // "foo": "^1.0.0"
+    // BEST, the override is defined as a reference to the dependency
+    "@npm/foo": "$foo",
+    // the referenced package does not need to match the overridden one
+    "@npm/bar": "$foo"
+  }
+}
+</code></pre>
+<h4 id="replacing-a-dependency-with-a-fork">Replacing a dependency with a fork</h4>
+<p>You can replace a package with a different package or fork using several methods:</p>
+<p><strong>Using the <code>npm:</code> prefix to replace with a different package name:</strong></p>
+<pre><code class="language-json">{
+  "overrides": {
+    "package-name": "npm:@scope/forked-package@1.0.0"
+  }
+}
+</code></pre>
+<p><strong>Using a GitHub repository (supports branches, tags, or commit hashes):</strong></p>
+<pre><code class="language-json">{
+  "overrides": {
+    "package-name": "github:username/repo#branch-name"
+  }
+}
+</code></pre>
+<p><strong>Using a local file path:</strong></p>
+<pre><code class="language-json">{
+  "overrides": {
+    "package-name": "file:../local-fork"
+  }
+}
+</code></pre>
+<p>These replacement methods work for both top-level overrides and nested overrides.
+For example, to replace a transitive dependency with a fork:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "parent-package": {
+      "vulnerable-dep": "github:username/patched-fork#v2.0.1"
+    }
+  }
+}
+</code></pre>
+<h3 id="engines">engines</h3>
+<p>You can specify the version of node that your stuff works on:</p>
+<pre><code class="language-json">{
+  "engines": {
+    "node": "&gt;=0.10.3 &lt;15"
+  }
+}
+</code></pre>
+<p>And, like with dependencies, if you don't specify the version (or if you specify "*" as the version), then any version of node will do.</p>
+<p>You can also use the "engines" field to specify which versions of npm are capable of properly installing your program.
+For example:</p>
+<pre><code class="language-json">{
+  "engines": {
+    "npm": "~1.0.20"
+  }
+}
+</code></pre>
+<p>Unless the user has set the <a href="../using-npm/config#engine-strict.html"><code>engine-strict</code> config</a> flag, this field is advisory only and will only produce warnings when your package is installed as a dependency.</p>
+<h3 id="os">os</h3>
+<p>You can specify which operating systems your module will run on:</p>
+<pre><code class="language-json">{
+  "os": [
+    "darwin",
+    "linux"
+  ]
+}
+</code></pre>
+<p>You can also block instead of allowing operating systems, just prepend the blocked os with a '!':</p>
+<pre><code class="language-json">{
+  "os": [
+    "!win32"
+  ]
+}
+</code></pre>
+<p>The host operating system is determined by <code>process.platform</code></p>
+<p>It is allowed to both block and allow an item, although there isn't any good reason to do this.</p>
+<h3 id="cpu">cpu</h3>
+<p>If your code only runs on certain cpu architectures, you can specify which ones.</p>
+<pre><code class="language-json">{
+  "cpu": [
+    "x64",
+    "ia32"
+  ]
+}
+</code></pre>
+<p>Like the <code>os</code> option, you can also block architectures:</p>
+<pre><code class="language-json">{
+  "cpu": [
+    "!arm",
+    "!mips"
+  ]
+}
+</code></pre>
+<p>The host architecture is determined by <code>process.arch</code></p>
+<h3 id="libc">libc</h3>
+<p>If your code only runs or builds in certain versions of libc, you can specify which ones.
+This field only applies if <code>os</code> is <code>linux</code>.</p>
+<pre><code class="language-json">{
+  "os": "linux",
+  "libc": "glibc"
+}
+</code></pre>
+<h3 id="devengines">devEngines</h3>
+<p>The <code>devEngines</code> field aids engineers working on a codebase to all be using the same tooling.</p>
+<p>You can specify a <code>devEngines</code> property in your <code>package.json</code> which will run before <code>install</code>, <code>ci</code>, and <code>run</code> commands.</p>
+<blockquote>
+<p>Note: <code>engines</code> and <code>devEngines</code> differ in object shape.
+They also function very differently.
+<code>engines</code> is designed to alert the user when a dependency uses a different npm or node version than the project it's being used in, whereas <code>devEngines</code> is used to alert people interacting with the source code of a project.</p>
+</blockquote>
+<p>The supported keys under the <code>devEngines</code> property are <code>cpu</code>, <code>os</code>, <code>libc</code>, <code>runtime</code>, and <code>packageManager</code>.
+Each property can be an object or an array of objects.
+Objects must contain <code>name</code>, and optionally can specify <code>version</code>, and <code>onFail</code>.
+<code>onFail</code> can be <code>warn</code>, <code>error</code>, or <code>ignore</code>, and if left undefined is of the same value as <code>error</code>.
+<code>npm</code> will assume that you're running with <code>node</code>.
+Here's an example of a project that will fail if the environment is not <code>node</code> and <code>npm</code>.
+If you set <code>runtime.name</code> or <code>packageManager.name</code> to any other string, it will fail within the npm CLI.</p>
+<pre><code class="language-json">{
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "onFail": "error"
+    }
+  }
+}
+</code></pre>
+<h3 id="private">private</h3>
+<p>If you set <code>"private": true</code> in your package.json, then npm will refuse to publish it.</p>
+<p>This is a way to prevent accidental publication of private repositories.
+If you would like to ensure that a given package is only ever published to a specific registry (for example, an internal registry), then use the <code>publishConfig</code> dictionary described below to override the <code>registry</code> config param at publish-time.</p>
+<h3 id="publishconfig">publishConfig</h3>
+<p>This is a set of config values that will be used at publish-time.
+It's especially handy if you want to set the tag, registry or access, so that you can ensure that a given package is not tagged with "latest", published to the global public registry or that a scoped module is private by default.</p>
+<p>See <a href="../using-npm/config.html"><code>config</code></a> to see the list of config options that can be overridden.</p>
+<h3 id="workspaces">workspaces</h3>
+<p>The optional <code>workspaces</code> field is an array of file patterns that describes locations within the local file system that the install client should look up to find each <a href="../using-npm/workspaces.html">workspace</a> that needs to be symlinked to the top level <code>node_modules</code> folder.</p>
+<p>It can describe either the direct paths of the folders to be used as workspaces or it can define globs that will resolve to these same folders.</p>
+<p>In the following example, all folders located inside the folder <code>./packages</code> will be treated as workspaces as long as they have valid <code>package.json</code> files inside them:</p>
+<pre><code class="language-json">{
+  "name": "workspace-example",
+  "workspaces": [
+    "./packages/*"
+  ]
+}
+</code></pre>
+<p>See <a href="../using-npm/workspaces.html"><code>workspaces</code></a> for more examples.</p>
+<h3 id="default-values">DEFAULT VALUES</h3>
+<p>npm will default some values based on package contents.</p>
+<ul>
+<li>
+<p><code>"scripts": {"start": "node server.js"}</code></p>
+<p>If there is a <code>server.js</code> file in the root of your package, then npm will default the <code>start</code> command to <code>node server.js</code>.</p>
+</li>
+<li>
+<p><code>"scripts":{"install": "node-gyp rebuild"}</code></p>
+<p>If there is a <code>binding.gyp</code> file in the root of your package and you have not defined an <code>install</code> or <code>preinstall</code> script, npm will default the <code>install</code> command to compile using node-gyp.</p>
+</li>
+<li>
+<p><code>"contributors": [...]</code></p>
+<p>If there is an <code>AUTHORS</code> file in the root of your package, npm will treat each line as a <code>Name &lt;email&gt; (url)</code> format, where email and url are optional.
+Lines which start with a <code>#</code> or are blank, will be ignored.</p>
+</li>
+</ul>
+<h3 id="see-also">SEE ALSO</h3>
+<ul>
+<li><a href="https://github.com/npm/node-semver#versions">semver</a></li>
+<li><a href="../using-npm/workspaces.html">workspaces</a></li>
+<li><a href="../commands/npm-init.html">npm init</a></li>
+<li><a href="../commands/npm-version.html">npm version</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../commands/npm-help.html">npm help</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-uninstall.html">npm uninstall</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/package-json.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html b/node/node_modules/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html
new file mode 100644
index 0000000000000000000000000000000000000000..f94a29004610a2708be9218e3b6fd5602d40e512
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html
@@ -0,0 +1,229 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-shrinkwrap.json</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-shrinkwrapjson----11130">
+    <span>npm-shrinkwrap.json</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">A publishable lockfile</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p><code>npm-shrinkwrap.json</code> is a file created by <a href="../commands/npm-shrinkwrap.html"><code>npm shrinkwrap</code></a>.
+It is identical to <code>package-lock.json</code>, with one major caveat: Unlike <code>package-lock.json</code>,
+<code>npm-shrinkwrap.json</code> may be included when publishing a package.</p>
+<p>The recommended use-case for <code>npm-shrinkwrap.json</code> is applications deployed through the publishing process on the registry: for example, daemons and command-line tools intended as global installs or <code>devDependencies</code>.
+It's strongly discouraged for library authors to publish this file, since that would prevent end users from having control over transitive dependency updates.</p>
+<p>If both <code>package-lock.json</code> and <code>npm-shrinkwrap.json</code> are present in a package root, <code>npm-shrinkwrap.json</code> will be preferred over the <code>package-lock.json</code> file.</p>
+<p>For full details and description of the <code>npm-shrinkwrap.json</code> file format, refer to the manual page for <a href="../configuring-npm/package-lock-json.html">package-lock.json</a>.</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-shrinkwrap.html">npm shrinkwrap</a></li>
+<li><a href="../configuring-npm/package-lock-json.html">package-lock.json</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/npm-shrinkwrap-json.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/npmrc.html b/node/node_modules/npm/docs/output/configuring-npm/npmrc.html
new file mode 100644
index 0000000000000000000000000000000000000000..3366920b72d5ce95d990efc2fa2ddf5f48ac61c5
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/npmrc.html
@@ -0,0 +1,347 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>.npmrc</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npmrc----11130">
+    <span>.npmrc</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">The npm config files</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#files">Files</a></li><ul><li><a href="#comments">Comments</a></li><li><a href="#per-project-config-file">Per-project config file</a></li><li><a href="#per-user-config-file">Per-user config file</a></li><li><a href="#global-config-file">Global config file</a></li><li><a href="#built-in-config-file">Built-in config file</a></li></ul><li><a href="#auth-related-configuration">Auth related configuration</a></li><li><a href="#unsupported-custom-configuration-keys">Unsupported Custom Configuration Keys</a></li><li><a href="#custom--third-party-config-keys">Custom / third-party config keys</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>npm gets its config settings from the command line, environment variables, and <code>npmrc</code> files.</p>
+<p>The <code>npm config</code> command can be used to update and edit the contents of the user and global npmrc files.</p>
+<p>For a list of available configuration options, see <a href="../using-npm/config.html">config</a>.</p>
+<h3 id="files">Files</h3>
+<p>The four relevant files are:</p>
+<ul>
+<li>per-project config file (<code>/path/to/my/project/.npmrc</code>)</li>
+<li>per-user config file (<code>~/.npmrc</code>)</li>
+<li>global config file (<code>$PREFIX/etc/npmrc</code>)</li>
+<li>npm builtin config file (<code>/path/to/npm/npmrc</code>)</li>
+</ul>
+<p>All npm config files are an ini-formatted list of <code>key = value</code> parameters.
+Environment variables can be replaced using <code>${VARIABLE_NAME}</code>.
+By default if the variable is not defined, it is left unreplaced.
+By adding <code>?</code> after variable name they can be forced to evaluate to an empty string instead.
+For example:</p>
+<pre><code class="language-bash">cache = ${HOME}/.npm-packages
+node-options = "${NODE_OPTIONS?} --use-system-ca"
+</code></pre>
+<p>Each of these files is loaded, and config options are resolved in priority order.
+For example, a setting in the userconfig file would override the setting in the globalconfig file.</p>
+<p>Array values are specified by adding "[]" after the key name.
+For example:</p>
+<pre><code class="language-bash">key[] = "first value"
+key[] = "second value"
+</code></pre>
+<h4 id="comments">Comments</h4>
+<p>Lines in <code>.npmrc</code> files are interpreted as comments when they begin with a
+<code>;</code> or <code>#</code> character.
+<code>.npmrc</code> files are parsed by
+<a href="https://github.com/npm/ini">npm/ini</a>, which specifies this comment syntax.</p>
+<p>For example:</p>
+<pre><code class="language-bash"># last modified: 01 Jan 2016
+; Set a new registry for a scoped package
+@myscope:registry=https://mycustomregistry.example.org
+</code></pre>
+<h4 id="per-project-config-file">Per-project config file</h4>
+<p>When working locally in a project, a <code>.npmrc</code> file in the root of the project (ie, a sibling of <code>node_modules</code> and <code>package.json</code>) will set config values specific to this project.</p>
+<p>Note that this only applies to the root of the project that you're running npm in.
+It has no effect when your module is published.
+For example, you can't publish a module that forces itself to install globally, or in a different location.</p>
+<p>Additionally, this file is not read in global mode, such as when running <code>npm install -g</code>.</p>
+<h4 id="per-user-config-file">Per-user config file</h4>
+<p><code>$HOME/.npmrc</code> (or the <code>userconfig</code> param, if set in the environment or on the command line)</p>
+<h4 id="global-config-file">Global config file</h4>
+<p><code>$PREFIX/etc/npmrc</code> (or the <code>globalconfig</code> param, if set above): This file is an ini-file formatted list of <code>key = value</code> parameters.
+Environment variables can be replaced as above.</p>
+<h4 id="built-in-config-file">Built-in config file</h4>
+<p><code>path/to/npm/itself/npmrc</code></p>
+<p>This is an unchangeable "builtin" configuration file that npm keeps consistent across updates.
+Set fields in here using the <code>./configure</code> script that comes with npm.
+This is primarily for distribution maintainers to override default configs in a standard and consistent manner.</p>
+<h3 id="auth-related-configuration">Auth related configuration</h3>
+<p>The settings <code>_auth</code>, <code>_authToken</code>, <code>username</code>, <code>_password</code>, <code>certfile</code>, and <code>keyfile</code> must all be scoped to a specific registry.
+This ensures that <code>npm</code> will never send credentials to the wrong host.</p>
+<p>The full list is:</p>
+<ul>
+<li><code>_auth</code> (base64 authentication string)</li>
+<li><code>_authToken</code> (authentication token)</li>
+<li><code>username</code></li>
+<li><code>_password</code></li>
+<li><code>email</code></li>
+<li><code>cafile</code> (path to certificate authority file)</li>
+<li><code>certfile</code> (path to certificate file)</li>
+<li><code>keyfile</code> (path to key file)</li>
+</ul>
+<p>In order to scope these values, they must be prefixed by a URI fragment.
+If the credential is meant for any request to a registry on a single host, the scope may look like <code>//registry.npmjs.org/:</code>.
+If it must be scoped to a specific path on the host that path may also be provided, such as
+<code>//my-custom-registry.org/unique/path:</code>.</p>
+<h3 id="unsupported-custom-configuration-keys">Unsupported Custom Configuration Keys</h3>
+<p>Starting in npm v11.2.0, npm warns when unknown configuration keys are defined in <code>.npmrc</code>. In a future major version of npm, these unknown keys may no longer be accepted.</p>
+<p>Only configuration keys that npm officially supports are recognized. Custom keys intended for third-party tools (for example, <code>electron-builder</code>) should not be placed in <code>.npmrc</code>.</p>
+<p>If you need package-level configuration for use in scripts, use the <code>config</code> field in your <code>package.json</code> instead:</p>
+<pre><code class="language-json">{
+  "name": "my-package",
+  "config": {
+    "mirror": "https://example.com/"
+  }
+}
+
+</code></pre>
+<p>Values defined in <code>package.json#config</code> are exposed to scripts as environment variables prefixed with <code>npm_package_config_</code>. For example:</p>
+<pre><code>npm_package_config_mirror
+</code></pre>
+<p>If you need to pass arguments to a script command, use <code>--</code> to separate npm arguments from script arguments:</p>
+<pre><code>npm run build -- --customFlag
+</code></pre>
+<p>Using environment variables is also recommended for cross-platform configuration instead of defining unsupported keys in <code>.npmrc</code>.</p>
+<pre><code>; bad config
+_authToken=MYTOKEN
+
+; good config
+@myorg:registry=https://somewhere-else.com/myorg
+@another:registry=https://somewhere-else.com/another
+//registry.npmjs.org/:_authToken=MYTOKEN
+
+; would apply to both @myorg and @another
+//somewhere-else.com/:_authToken=MYTOKEN
+
+; would apply only to @myorg
+//somewhere-else.com/myorg/:_authToken=MYTOKEN1
+
+; would apply only to @another
+//somewhere-else.com/another/:_authToken=MYTOKEN2
+</code></pre>
+<h3 id="custom--third-party-config-keys">Custom / third-party config keys</h3>
+<p>npm only recognizes its own <a href="../using-npm/config.html">configuration options</a>.
+If your <code>.npmrc</code> contains keys that are not part of npm's config definitions
+(for example, <code>electron_mirror</code> or <code>sass_binary_site</code>), npm will emit a
+warning:</p>
+<pre><code>warn Unknown user config "electron_mirror".
+This will stop working in the next major version of npm.
+</code></pre>
+<p>These keys were historically tolerated but are not officially supported.
+A future major version of npm will treat unknown top-level keys as errors.</p>
+<p>Some tools (such as <code>@electron/get</code> or <code>node-sass</code>) read their own
+configuration from environment variables or from <code>.npmrc</code> by convention.
+You can set these values as environment variables instead:</p>
+<pre><code class="language-bash">export ELECTRON_MIRROR="https://mirrorexample.npmjs.org/mirrors/electron/"
+export ELECTRON_CUSTOM_DIR="{{ version }}"
+</code></pre>
+<p>Environment variables are the most portable approach and work regardless
+of <code>.npmrc</code> format.</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm.html">npm</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/npmrc.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/package-json.html b/node/node_modules/npm/docs/output/configuring-npm/package-json.html
new file mode 100644
index 0000000000000000000000000000000000000000..764628c0d58f0dc1ebd794ba77e3e2e8bd753342
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/package-json.html
@@ -0,0 +1,1086 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>package.json</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----packagejson----11130">
+    <span>package.json</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Specifics of npm's package.json handling</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#name">name</a></li><li><a href="#version">version</a></li><li><a href="#description2">description</a></li><li><a href="#keywords">keywords</a></li><li><a href="#homepage">homepage</a></li><li><a href="#bugs">bugs</a></li><li><a href="#license">license</a></li><li><a href="#people-fields-author-contributors">people fields: author, contributors</a></li><li><a href="#funding">funding</a></li><li><a href="#files">files</a></li><li><a href="#exports">exports</a></li><li><a href="#main">main</a></li><li><a href="#type">type</a></li><li><a href="#browser">browser</a></li><li><a href="#bin">bin</a></li><li><a href="#man">man</a></li><li><a href="#directories">directories</a></li><ul><li><a href="#directoriesbin">directories.bin</a></li><li><a href="#directoriesman">directories.man</a></li></ul><li><a href="#repository">repository</a></li><li><a href="#scripts">scripts</a></li><li><a href="#gypfile">gypfile</a></li><li><a href="#config">config</a></li><li><a href="#dependencies">dependencies</a></li><ul><li><a href="#urls-as-dependencies">URLs as Dependencies</a></li><li><a href="#git-urls-as-dependencies">Git URLs as Dependencies</a></li><li><a href="#github-urls">GitHub URLs</a></li><li><a href="#local-paths">Local Paths</a></li></ul><li><a href="#devdependencies">devDependencies</a></li><li><a href="#peerdependencies">peerDependencies</a></li><li><a href="#peerdependenciesmeta">peerDependenciesMeta</a></li><li><a href="#bundledependencies">bundleDependencies</a></li><li><a href="#optionaldependencies">optionalDependencies</a></li><li><a href="#overrides">overrides</a></li><ul><li><a href="#replacing-a-dependency-with-a-fork">Replacing a dependency with a fork</a></li></ul><li><a href="#engines">engines</a></li><li><a href="#os">os</a></li><li><a href="#cpu">cpu</a></li><li><a href="#libc">libc</a></li><li><a href="#devengines">devEngines</a></li><li><a href="#private">private</a></li><li><a href="#publishconfig">publishConfig</a></li><li><a href="#workspaces">workspaces</a></li><li><a href="#default-values">DEFAULT VALUES</a></li><li><a href="#see-also">SEE ALSO</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>This document is all you need to know about what's required in your package.json file.
+It must be actual JSON, not just a JavaScript object literal.</p>
+<p>A lot of the behavior described in this document is affected by the config settings described in <a href="../using-npm/config.html"><code>config</code></a>.</p>
+<h3 id="name">name</h3>
+<p>If you plan to publish your package, the <em>most</em> important things in your package.json are the name and version fields as they will be required.
+The name and version together form an identifier that is assumed to be completely unique.
+Changes to the package should come along with changes to the version.
+If you don't plan to publish your package, the name and version fields are optional.</p>
+<p>The name is what your thing is called.</p>
+<p>Some rules:</p>
+<ul>
+<li>The name must be less than or equal to 214 characters.
+This includes the scope for scoped packages.</li>
+<li>The names of scoped packages can begin with a dot or an underscore.
+This is not permitted without a scope.</li>
+<li>New packages must not have uppercase letters in the name.</li>
+<li>The name ends up being part of a URL, an argument on the command line, and a folder name.
+Therefore, the name can't contain any non-URL-safe characters.</li>
+</ul>
+<p>Some tips:</p>
+<ul>
+<li>Don't use the same name as a core Node module.</li>
+<li>Don't put "js" or "node" in the name.
+It's assumed that it's js, since you're writing a package.json file, and you can specify the engine using the "<a href="#engines">engines</a>" field.
+(See below.)</li>
+<li>The name will probably be passed as an argument to require(), so it should be something short, but also reasonably descriptive.</li>
+<li>You may want to check the npm registry to see if there's something by that name already, before you get too attached to it.
+<a href="https://www.npmjs.com/">https://www.npmjs.com/</a></li>
+</ul>
+<p>A name can be optionally prefixed by a scope, e.g. <code>@npm/example</code>.
+See <a href="../using-npm/scope.html"><code>scope</code></a> for more detail.</p>
+<h3 id="version">version</h3>
+<p>If you plan to publish your package, the <em>most</em> important things in your package.json are the name and version fields as they will be required.
+The name and version together form an identifier that is assumed to be completely unique.
+Changes to the package should come along with changes to the version.
+If you don't plan to publish your package, the name and version fields are optional.</p>
+<p>Version must be parseable by <a href="https://github.com/npm/node-semver">node-semver</a>, which is bundled with npm as a dependency.
+(<code>npm install semver</code> to use it yourself.)</p>
+<h3 id="description2">description</h3>
+<p>Put a description in it.
+It's a string.
+This helps people discover your package, as it's listed in <code>npm search</code>.</p>
+<h3 id="keywords">keywords</h3>
+<p>Put keywords in it.
+It's an array of strings.
+This helps people discover your package as it's listed in <code>npm search</code>.</p>
+<p>Example:</p>
+<pre><code class="language-json">"keywords": [
+  "node",
+  "javascript",
+  "npm"
+]
+</code></pre>
+<h3 id="homepage">homepage</h3>
+<p>The URL to the project homepage.</p>
+<p>Example:</p>
+<pre><code class="language-json">"homepage": "https://github.com/npm/example#readme"
+</code></pre>
+<h3 id="bugs">bugs</h3>
+<p>The URL to your project's issue tracker and / or the email address to which issues should be reported.
+These are helpful for people who encounter issues with your package.</p>
+<p>It should look like this:</p>
+<pre><code class="language-json">{
+  "bugs": {
+    "url": "https://github.com/npm/example/issues",
+    "email": "example@npmjs.com"
+  }
+}
+</code></pre>
+<p>You can specify either one or both values.
+If you want to provide only a URL, you can specify the value for "bugs" as a simple string instead of an object.</p>
+<p>If a URL is provided, it will be used by the <code>npm bugs</code> command.</p>
+<h3 id="license">license</h3>
+<p>You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.</p>
+<p>If you're using a common license such as BSD-2-Clause or MIT, add a current SPDX license identifier for the license you're using, like this:</p>
+<pre><code class="language-json">{
+  "license" : "BSD-3-Clause"
+}
+</code></pre>
+<p>You can check <a href="https://spdx.org/licenses/">the full list of SPDX license IDs</a>.
+Ideally, you should pick one that is <a href="https://opensource.org/licenses/">OSI</a> approved.</p>
+<p>If your package is licensed under multiple common licenses, use an <a href="https://spdx.dev/specifications/">SPDX license expression syntax version 2.0 string</a>, like this:</p>
+<pre><code class="language-json">{
+  "license" : "(ISC OR GPL-3.0)"
+}
+</code></pre>
+<p>If you are using a license that hasn't been assigned an SPDX identifier, or if you are using a custom license, use a string value like this one:</p>
+<pre><code class="language-json">{
+  "license" : "SEE LICENSE IN &lt;filename&gt;"
+}
+</code></pre>
+<p>Then include a file named <code>&lt;filename&gt;</code> at the top level of the package.</p>
+<p>Some old packages used license objects or a "licenses" property containing an array of license objects:</p>
+<pre><code class="language-json">// Not valid metadata
+{
+  "license" : {
+    "type" : "ISC",
+    "url" : "https://opensource.org/licenses/ISC"
+  }
+}
+
+// Not valid metadata
+{
+  "licenses" : [
+    {
+      "type": "MIT",
+      "url": "https://www.opensource.org/licenses/mit-license.php"
+    },
+    {
+      "type": "Apache-2.0",
+      "url": "https://opensource.org/licenses/apache2.0.php"
+    }
+  ]
+}
+</code></pre>
+<p>Those styles are now deprecated.
+Instead, use SPDX expressions, like this:</p>
+<pre><code class="language-json">{
+  "license": "ISC"
+}
+</code></pre>
+<pre><code class="language-json">{
+  "license": "(MIT OR Apache-2.0)"
+}
+</code></pre>
+<p>Finally, if you do not wish to grant others the right to use a private or unpublished package under any terms:</p>
+<pre><code class="language-json">{
+  "license": "UNLICENSED"
+}
+</code></pre>
+<p>Consider also setting <code>"private": true</code> to prevent accidental publication.</p>
+<h3 id="people-fields-author-contributors">people fields: author, contributors</h3>
+<p>The "author" is one person.
+"contributors" is an array of people.
+A "person" is an object with a "name" field and optionally "url" and "email", like this:</p>
+<pre><code class="language-json">{
+  "name" : "Barney Rubble",
+  "email" : "barney@npmjs.com",
+  "url" : "http://barnyrubble.npmjs.com/"
+}
+</code></pre>
+<p>Or you can shorten that all into a single string, and npm will parse it for you:</p>
+<pre><code class="language-json">{
+  "author": "Barney Rubble &lt;barney@npmjs.com&gt; (http://barnyrubble.npmjs.com/)"
+}
+</code></pre>
+<p>Both email and url are optional either way.</p>
+<p>npm also sets a top-level "maintainers" field with your npm user info.</p>
+<h3 id="funding">funding</h3>
+<p>You can specify an object containing a URL that provides up-to-date information about ways to help fund development of your package, a string URL, or an array of objects and string URLs:</p>
+<pre><code class="language-json">{
+  "funding": {
+    "type" : "individual",
+    "url" : "http://npmjs.com/donate"
+  }
+}
+</code></pre>
+<pre><code class="language-json">{
+  "funding": {
+    "type" : "patreon",
+    "url" : "https://www.patreon.com/user"
+  }
+}
+</code></pre>
+<pre><code class="language-json">{
+  "funding": "http://npmjs.com/donate"
+}
+</code></pre>
+<pre><code class="language-json">{
+  "funding": [
+    {
+      "type" : "individual",
+      "url" : "http://npmjs.com/donate"
+    },
+    "http://npmjs.com/donate-also",
+    {
+      "type" : "patreon",
+      "url" : "https://www.patreon.com/user"
+    }
+  ]
+}
+</code></pre>
+<p>Users can use the <code>npm fund</code> subcommand to list the <code>funding</code> URLs of all dependencies of their project, direct and indirect.
+A shortcut to visit each funding URL is also available when providing the project name such as:
+<code>npm fund &lt;projectname&gt;</code> (when there are multiple URLs, the first one will be visited)</p>
+<h3 id="files">files</h3>
+<p>The optional <code>files</code> field is an array of file patterns that describes the entries to be included when your package is installed as a dependency.
+File patterns follow a similar syntax to <code>.gitignore</code>, but reversed: including a file, directory, or glob pattern (<code>*</code>, <code>**/*</code>, and such) will make it so that file is included in the tarball when it's packed.
+Omitting the field will make it default to <code>["*"]</code>, which means it will include all files.</p>
+<p>Some special files and directories are also included or excluded regardless of whether they exist in the <code>files</code> array (see below).</p>
+<p>You can also provide a <code>.npmignore</code> file in the root of your package or in subdirectories, which will keep files from being included.
+At the root of your package it will not override the "files" field, but in subdirectories it will.
+The <code>.npmignore</code> file works just like a <code>.gitignore</code>.
+If there is a <code>.gitignore</code> file, and <code>.npmignore</code> is missing, <code>.gitignore</code>'s contents will be used instead.</p>
+<p>Certain files are always included, regardless of settings:</p>
+<ul>
+<li><code>package.json</code></li>
+<li><code>README</code></li>
+<li><code>LICENSE</code> / <code>LICENCE</code></li>
+<li>The file in the "main" field</li>
+<li>The file(s) in the "bin" field</li>
+</ul>
+<p><code>README</code> &amp; <code>LICENSE</code> can have any case and extension.</p>
+<p>Some files are always ignored by default:</p>
+<ul>
+<li><code>*.orig</code></li>
+<li><code>.*.swp</code></li>
+<li><code>.DS_Store</code></li>
+<li><code>._*</code></li>
+<li><code>.git</code></li>
+<li><code>.hg</code></li>
+<li><code>.lock-wscript</code></li>
+<li><code>.npmrc</code></li>
+<li><code>.svn</code></li>
+<li><code>.wafpickle-N</code></li>
+<li><code>CVS</code></li>
+<li><code>config.gypi</code></li>
+<li><code>node_modules</code></li>
+<li><code>npm-debug.log</code></li>
+<li><code>package-lock.json</code> (use <a href="../configuring-npm/npm-shrinkwrap-json.html"><code>npm-shrinkwrap.json</code></a> if you wish it to be published)</li>
+<li><code>pnpm-lock.yaml</code></li>
+<li><code>yarn.lock</code></li>
+<li><code>bun.lockb</code></li>
+</ul>
+<p>Most of these ignored files can be included specifically if included in the <code>files</code> globs.
+Exceptions to this are:</p>
+<ul>
+<li><code>.git</code></li>
+<li><code>.npmrc</code></li>
+<li><code>node_modules</code></li>
+<li><code>package-lock.json</code></li>
+<li><code>pnpm-lock.yaml</code></li>
+<li><code>yarn.lock</code></li>
+<li><code>bun.lockb</code></li>
+</ul>
+<p>These cannot be included.</p>
+<h3 id="exports">exports</h3>
+<p>The "exports" provides a modern alternative to "main" allowing multiple entry points to be defined, conditional entry resolution support between environments, and preventing any other entry points besides those defined in "exports". This encapsulation allows module authors to clearly define the public interface for their package.
+For more details see the <a href="https://nodejs.org/api/packages.html#package-entry-points">node.js documentation on package entry points</a></p>
+<h3 id="main">main</h3>
+<p>The main field is a module ID that is the primary entry point to your program.
+That is, if your package is named <code>foo</code>, and a user installs it, and then does <code>require("foo")</code>, then your main module's exports object will be returned.</p>
+<p>This should be a module relative to the root of your package folder.</p>
+<p>For most modules, it makes the most sense to have a main script and often not much else.</p>
+<p>If <code>main</code> is not set, it defaults to <code>index.js</code> in the package's root folder.</p>
+<h3 id="type">type</h3>
+<p>The <code>type</code> field defines how Node.js should interpret <code>.js</code> files in your package. This field is not used by npm.</p>
+<p>See the <a href="https://nodejs.org/api/packages.html#type">Node.js documentation on the type field</a> for more information.</p>
+<h3 id="browser">browser</h3>
+<p>If your module is meant to be used client-side the browser field should be used instead of the main field.
+This is helpful to hint users that it might rely on primitives that aren't available in Node.js modules.
+(e.g. <code>window</code>)</p>
+<h3 id="bin">bin</h3>
+<p>A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)</p>
+<p>To use this, supply a <code>bin</code> field in your package.json which is a map of command name to local file name.
+When this package is installed globally, that file will be either linked inside the global bins directory or a cmd (Windows Command File) will be created which executes the specified file in the <code>bin</code> field, so it is available to run by <code>name</code> or <code>name.cmd</code> (on Windows PowerShell).
+When this package is installed as a dependency in another package, the file will be linked where it will be available to that package either directly by <code>npm exec</code> or by name in other scripts when invoking them via <code>npm run</code>.</p>
+<p>For example, myapp could have this:</p>
+<pre><code class="language-json">{
+  "bin": {
+    "myapp": "bin/cli.js"
+  }
+}
+</code></pre>
+<p>So, when you install myapp, in case of unix-like OS it'll create a symlink from the <code>cli.js</code> script to <code>/usr/local/bin/myapp</code> and in case of windows it will create a cmd file usually at <code>C:\Users\{Username}\AppData\Roaming\npm\myapp.cmd</code> which runs the <code>cli.js</code> script.</p>
+<p>If you have a single executable, and its name should be the name of the package, then you can just supply it as a string.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": "path/to/program"
+}
+</code></pre>
+<p>would be the same as this:</p>
+<pre><code class="language-json">{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": {
+    "my-program": "path/to/program"
+  }
+}
+</code></pre>
+<p>Please make sure that your file(s) referenced in <code>bin</code> starts with <code>#!/usr/bin/env node</code>; otherwise, the scripts are started without the node executable!</p>
+<p>Note that you can also set the executable files using <a href="#directoriesbin">directories.bin</a>.</p>
+<p>See <a href="../configuring-npm/folders#executables.html">folders</a> for more info on executables.</p>
+<h3 id="man">man</h3>
+<p>Specify either a single file or an array of filenames to put in place for the <code>man</code> program to find.</p>
+<p>If only a single file is provided, then it's installed such that it is the result from <code>man &lt;pkgname&gt;</code>, regardless of its actual filename.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": "./man/doc.1"
+}
+</code></pre>
+<p>would link the <code>./man/doc.1</code> file in such that it is the target for <code>man foo</code></p>
+<p>If the filename doesn't start with the package name, then it's prefixed.
+So, this:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": [
+    "./man/foo.1",
+    "./man/bar.1"
+  ]
+}
+</code></pre>
+<p>will create files to do <code>man foo</code> and <code>man foo-bar</code>.</p>
+<p>Man files must end with a number, and optionally a <code>.gz</code> suffix if they are compressed.
+The number dictates which man section the file is installed into.</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": [
+    "./man/foo.1",
+    "./man/foo.2"
+  ]
+}
+</code></pre>
+<p>will create entries for <code>man foo</code> and <code>man 2 foo</code></p>
+<h3 id="directories">directories</h3>
+<p>The CommonJS <a href="http://wiki.commonjs.org/wiki/Packages/1.0">Packages</a> spec details a few ways that you can indicate the structure of your package using a <code>directories</code> object.
+If you look at <a href="https://registry.npmjs.org/npm/latest">npm's package.json</a>, you'll see that it has directories for doc, lib, and man.</p>
+<p>In the future, this information may be used in other creative ways.</p>
+<h4 id="directoriesbin">directories.bin</h4>
+<p>If you specify a <code>bin</code> directory in <code>directories.bin</code>, all the files in that folder will be added.</p>
+<p>Because of the way the <code>bin</code> directive works, specifying both a <code>bin</code> path and setting <code>directories.bin</code> is an error.
+If you want to specify individual files, use <code>bin</code>, and for all the files in an existing <code>bin</code> directory, use <code>directories.bin</code>.</p>
+<h4 id="directoriesman">directories.man</h4>
+<p>A folder that is full of man pages.
+Sugar to generate a "man" array by walking the folder.</p>
+<h3 id="repository">repository</h3>
+<p>Specify the place where your code lives.
+This is helpful for people who want to contribute.
+If the git repo is on GitHub, then the <code>npm repo</code> command will be able to find you.</p>
+<p>Do it like this:</p>
+<pre><code class="language-json">{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git"
+  }
+}
+</code></pre>
+<p>The URL should be a publicly available (perhaps read-only) URL that can be handed directly to a VCS program without any modification.
+It should not be a URL to an html project page that you put in your browser.
+It's for computers.</p>
+<p>For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for <code>npm install</code>:</p>
+<pre><code class="language-json">{
+  "repository": "npm/example",
+
+  "repository": "github:npm/example",
+
+  "repository": "gist:11081aaa281",
+
+  "repository": "bitbucket:user/repo",
+
+  "repository": "gitlab:user/repo"
+}
+</code></pre>
+<p><strong>Note on normalization:</strong> When you publish a package, npm normalizes the <code>repository</code> field to the full object format with a <code>url</code> property. If you use a shorthand format (like <code>"npm/example"</code>), you'll see a warning during <code>npm publish</code> indicating that the field was auto-corrected. While the shorthand format currently works, it's recommended to use the full object format in your <code>package.json</code> to avoid warnings and ensure future compatibility:</p>
+<pre><code class="language-json">{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/example.git"
+  }
+}
+</code></pre>
+<p>You can run <code>npm pkg fix</code> to automatically convert shorthand formats to the normalized object format.</p>
+<p>If the <code>package.json</code> for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives:</p>
+<pre><code class="language-json">{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git",
+    "directory": "workspaces/libnpmpublish"
+  }
+}
+</code></pre>
+<h3 id="scripts">scripts</h3>
+<p>The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package.
+The key is the lifecycle event, and the value is the command to run at that point.</p>
+<p>See <a href="../using-npm/scripts.html"><code>scripts</code></a> to find out more about writing package scripts.</p>
+<h3 id="gypfile">gypfile</h3>
+<p>If you have a binding.gyp file in the root of your package and you have not defined your own <code>install</code> or <code>preinstall</code> scripts, npm will default to building your module using node-gyp.</p>
+<p>To prevent npm from automatically building your module with node-gyp, set <code>gypfile</code> to <code>false</code>:</p>
+<pre><code class="language-json">{
+  "gypfile": false
+}
+</code></pre>
+<p>This is useful for packages that include native addons but want to handle the build process differently, or packages that have a binding.gyp file but should not be built as a native addon.</p>
+<h3 id="config">config</h3>
+<p>A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades.
+For instance, if a package had the following:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "config": {
+    "port": "8080"
+  }
+}
+</code></pre>
+<p>It could also have a "start" script that referenced the <code>npm_package_config_port</code> environment variable.</p>
+<h3 id="dependencies">dependencies</h3>
+<p>Dependencies are specified in a simple object that maps a package name to a version range.
+The version range is a string which has one or more space-separated descriptors.
+Dependencies can also be identified with a tarball or git URL.</p>
+<p><strong>Please do not put test harnesses or transpilers or other "development" time tools in your <code>dependencies</code> object.</strong>
+See <code>devDependencies</code>, below.</p>
+<p>See <a href="https://github.com/npm/node-semver#versions">semver</a> for more details about specifying version ranges.</p>
+<ul>
+<li><code>version</code> Must match <code>version</code> exactly</li>
+<li><code>&gt;version</code> Must be greater than <code>version</code></li>
+<li><code>&gt;=version</code> etc</li>
+<li><code>&lt;version</code></li>
+<li><code>&lt;=version</code></li>
+<li><code>~version</code> "Approximately equivalent to version"  See <a href="https://github.com/npm/node-semver#versions">semver</a></li>
+<li><code>^version</code> "Compatible with version"  See <a href="https://github.com/npm/node-semver#versions">semver</a></li>
+<li><code>1.2.x</code> 1.2.0, 1.2.1, etc., but not 1.3.0</li>
+<li><code>http://...</code> See 'URLs as Dependencies' below</li>
+<li><code>*</code> Matches any version</li>
+<li><code>""</code> (just an empty string) Same as <code>*</code></li>
+<li><code>version1 - version2</code> Same as <code>&gt;=version1 &lt;=version2</code>.</li>
+<li><code>range1 || range2</code> Passes if either range1 or range2 are satisfied.</li>
+<li><code>git...</code> See 'Git URLs as Dependencies' below</li>
+<li><code>user/repo</code> See 'GitHub URLs' below</li>
+<li><code>tag</code> A specific version tagged and published as <code>tag</code>  See <a href="../commands/npm-dist-tag.html"><code>npm dist-tag</code></a></li>
+<li><code>path/path/path</code> See <a href="#local-paths">Local Paths</a> below</li>
+<li><code>npm:@scope/pkg@version</code> Custom alias for a package See <a href="../using-npm/package-spec#aliases.html"><code>package-spec</code></a></li>
+</ul>
+<p>For example, these are all valid:</p>
+<pre><code class="language-json">{
+  "dependencies": {
+    "foo": "1.0.0 - 2.9999.9999",
+    "bar": "&gt;=1.0.2 &lt;2.1.2",
+    "baz": "&gt;1.0.2 &lt;=2.3.4",
+    "boo": "2.0.1",
+    "qux": "&lt;1.0.0 || &gt;=2.3.1 &lt;2.4.5 || &gt;=2.5.2 &lt;3.0.0",
+    "asd": "http://npmjs.com/example.tar.gz",
+    "til": "~1.2",
+    "elf": "~1.2.3",
+    "two": "2.x",
+    "thr": "3.3.x",
+    "lat": "latest",
+    "dyl": "file:../dyl",
+    "kpg": "npm:pkg@1.0.0"
+  }
+}
+</code></pre>
+<h4 id="urls-as-dependencies">URLs as Dependencies</h4>
+<p>You may specify a tarball URL in place of a version range.</p>
+<p>This tarball will be downloaded and installed locally to your package at install time.</p>
+<h4 id="git-urls-as-dependencies">Git URLs as Dependencies</h4>
+<p>Git URLs are of the form:</p>
+<pre><code class="language-bash">&lt;protocol&gt;://[&lt;user&gt;[:&lt;password&gt;]@]&lt;hostname&gt;[:&lt;port&gt;][:][/]&lt;path&gt;[#&lt;commit-ish&gt; | #semver:&lt;semver&gt;]
+</code></pre>
+<p><code>&lt;protocol&gt;</code> is one of <code>git</code>, <code>git+ssh</code>, <code>git+http</code>, <code>git+https</code>, or <code>git+file</code>.</p>
+<p>If <code>#&lt;commit-ish&gt;</code> is provided, it will be used to clone exactly that commit.
+If the commit-ish has the format <code>#semver:&lt;semver&gt;</code>, <code>&lt;semver&gt;</code> can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency.
+If neither <code>#&lt;commit-ish&gt;</code> or <code>#semver:&lt;semver&gt;</code> is specified, then the default branch is used.</p>
+<p>Examples:</p>
+<pre><code class="language-bash">git+ssh://git@github.com:npm/cli.git#v1.0.27
+git+ssh://git@github.com:npm/cli#semver:^5.0
+git+https://isaacs@github.com/npm/cli.git
+git://github.com/npm/cli.git#v1.0.27
+</code></pre>
+<p>When installing from a <code>git</code> repository, the presence of certain fields in the <code>package.json</code> will cause npm to believe it needs to perform a build.
+To do so your repository will be cloned into a temporary directory, all of its deps installed, relevant scripts run, and the resulting directory packed and installed.</p>
+<p>This flow will occur if your git dependency uses <code>workspaces</code>, or if any of the following scripts are present:</p>
+<ul>
+<li><code>build</code></li>
+<li><code>prepare</code></li>
+<li><code>prepack</code></li>
+<li><code>preinstall</code></li>
+<li><code>install</code></li>
+<li><code>postinstall</code></li>
+</ul>
+<p>If your git repository includes pre-built artifacts, you will likely want to make sure that none of the above scripts are defined, or your dependency will be rebuilt for every installation.</p>
+<h4 id="github-urls">GitHub URLs</h4>
+<p>As of version 1.1.65, you can refer to GitHub URLs as just "foo":
+"user/foo-project".  Just as with git URLs, a <code>commit-ish</code> suffix can be included.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "foo",
+  "version": "0.0.0",
+  "dependencies": {
+    "express": "expressjs/express",
+    "mocha": "mochajs/mocha#4727d357ea",
+    "module": "npm/example-github-repo#feature\/branch"
+  }
+}
+</code></pre>
+<h4 id="local-paths">Local Paths</h4>
+<p>As of version 2.0.0 you can provide a path to a local directory that contains a package.
+Local paths can be saved using <code>npm install -S</code> or <code>npm install --save</code>, using any of these forms:</p>
+<pre><code class="language-bash">../foo/bar
+~/foo/bar
+./foo/bar
+/foo/bar
+</code></pre>
+<p>in which case they will be normalized to a relative path and added to your <code>package.json</code>.
+For example:</p>
+<pre><code class="language-json">{
+  "name": "baz",
+  "dependencies": {
+    "bar": "file:../foo/bar"
+  }
+}
+</code></pre>
+<p>This feature is helpful for local offline development and creating tests that require npm installing where you don't want to hit an external server, but should not be used when publishing your package to the public registry.</p>
+<p><em>note</em>: Packages linked by local path will not have their own dependencies installed when <code>npm install</code> is run.
+You must run <code>npm install</code> from inside the local path itself.</p>
+<h3 id="devdependencies">devDependencies</h3>
+<p>If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.</p>
+<p>In this case, it's best to map these additional items in a <code>devDependencies</code> object.</p>
+<p>These things will be installed when doing <code>npm link</code> or <code>npm install</code> from the root of a package, and can be managed like any other npm configuration param.
+See <a href="../using-npm/config.html"><code>config</code></a> for more on the topic.</p>
+<p>For build steps that are not platform-specific, such as compiling CoffeeScript or other languages to JavaScript, use the <code>prepare</code> script to do this, and make the required package a devDependency.</p>
+<p>For example:</p>
+<pre><code class="language-json">{
+  "name": "@npm/ethopia-waza",
+  "description": "a delightfully fruity coffee varietal",
+  "version": "1.2.3",
+  "devDependencies": {
+    "coffee-script": "~1.6.3"
+  },
+  "scripts": {
+    "prepare": "coffee -o lib/ -c src/waza.coffee"
+  },
+  "main": "lib/waza.js"
+}
+</code></pre>
+<p>The <code>prepare</code> script will be run before publishing, so that users can consume the functionality without requiring them to compile it themselves.
+In dev mode (ie, locally running <code>npm install</code>), it'll run this script as well, so that you can test it easily.</p>
+<h3 id="peerdependencies">peerDependencies</h3>
+<p>In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a <code>require</code> of this host.
+This is usually referred to as a <em>plugin</em>. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.</p>
+<p>For example:</p>
+<pre><code class="language-json">{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x"
+  }
+}
+</code></pre>
+<p>This ensures your package <code>@npm/tea-latte</code> can be installed <em>along</em> with the second major version of the host package <code>@npm/tea</code> only.
+<code>npm install tea-latte</code> could possibly yield the following dependency graph:</p>
+<pre><code class="language-bash">├── @npm/tea-latte@1.3.5
+└── @npm/tea@2.2.0
+</code></pre>
+<p>In npm versions 3 through 6, <code>peerDependencies</code> were not automatically installed, and would raise a warning if an invalid version of the peer dependency was found in the tree.
+As of npm v7, peerDependencies <em>are</em> installed by default.</p>
+<p>Trying to install another plugin with a conflicting requirement may cause an error if the tree cannot be resolved correctly.
+For this reason, make sure your plugin requirement is as broad as possible, and not to lock it down to specific patch versions.</p>
+<p>Assuming the host complies with <a href="https://semver.org/">semver</a>, only changes in the host package's major version will break your plugin.
+Thus, if you've worked with every 1.x version of the host package, use <code>"^1.0"</code> or <code>"1.x"</code> to express this.
+If you depend on features introduced in 1.5.2, use <code>"^1.5.2"</code>.</p>
+<h3 id="peerdependenciesmeta">peerDependenciesMeta</h3>
+<p>The <code>peerDependenciesMeta</code> field serves to provide npm more information on how your peer dependencies are to be used.
+Specifically, it allows peer dependencies to be marked as optional.
+Npm will not automatically install optional peer dependencies.
+This allows you to integrate and interact with a variety of host packages without requiring all of them to be installed.</p>
+<p>For example:</p>
+<pre><code class="language-json">{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x",
+    "@npm/soy-milk": "1.2"
+  },
+  "peerDependenciesMeta": {
+    "@npm/soy-milk": {
+      "optional": true
+    }
+  }
+}
+</code></pre>
+<h3 id="bundledependencies">bundleDependencies</h3>
+<p>This defines an array of package names that will be bundled when publishing the package.</p>
+<p>In cases where you need to preserve npm packages locally or have them available through a single file download, you can bundle the packages in a tarball file by specifying the package names in the <code>bundleDependencies</code> array and executing <code>npm pack</code>.</p>
+<p>For example:</p>
+<p>If we define a package.json like this:</p>
+<pre><code class="language-json">{
+  "name": "@npm/awesome-web-framework",
+  "version": "1.0.0",
+  "bundleDependencies": [
+    "@npm/renderized",
+    "@npm/super-streams"
+  ]
+}
+</code></pre>
+<p>we can obtain <code>@npm/awesome-web-framework-1.0.0.tgz</code> file by running <code>npm pack</code>.
+This file contains the dependencies <code>@npm/renderized</code> and <code>@npm/super-streams</code> which can be installed in a new project by executing <code>npm install awesome-web-framework-1.0.0.tgz</code>.
+Note that the package names do not include any versions, as that information is specified in <code>dependencies</code>.</p>
+<p>If this is spelled <code>"bundledDependencies"</code>, then that is also honored.</p>
+<p>Alternatively, <code>"bundleDependencies"</code> can be defined as a boolean value.
+A value of <code>true</code> will bundle all dependencies, a value of <code>false</code> will bundle none.</p>
+<h3 id="optionaldependencies">optionalDependencies</h3>
+<p>If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the <code>optionalDependencies</code> object.
+This is a map of package name to version or URL, just like the <code>dependencies</code> object.
+The difference is that build failures do not cause installation to fail.
+Running <code>npm install --omit=optional</code> will prevent these dependencies from being installed.</p>
+<p>It is still your program's responsibility to handle the lack of the dependency.
+For example, something like this:</p>
+<pre><code class="language-js">try {
+  var foo = require('@npm/foo')
+  var fooVersion = require('@npm/foo/package.json').version
+} catch (er) {
+  foo = null
+}
+if ( notGoodFooVersion(fooVersion) ) {
+  foo = null
+}
+
+// .. then later in your program ..
+
+if (foo) {
+  foo.doFooThings()
+}
+</code></pre>
+<p>Entries in <code>optionalDependencies</code> will override entries of the same name in <code>dependencies</code>, so it's usually best to only put in one place.</p>
+<h3 id="overrides">overrides</h3>
+<p>If you need to make specific changes to dependencies of your dependencies, for example replacing the version of a dependency with a known security issue, replacing an existing dependency with a fork, or making sure that the same version of a package is used everywhere, then you may add an override.</p>
+<p>Overrides provide a way to replace a package in your dependency tree with another version, or another package entirely.
+These changes can be scoped as specific or as vague as desired.</p>
+<p>Overrides are only considered in the root <code>package.json</code> file for a project.
+Overrides in installed dependencies (including <a href="../using-npm/workspaces.html">workspaces</a>) are not considered in dependency tree resolution.
+Published packages may dictate their resolutions by pinning dependencies or using an <a href="../configuring-npm/npm-shrinkwrap-json.html"><code>npm-shrinkwrap.json</code></a> file.</p>
+<p>To make sure the package <code>@npm/foo</code> is always installed as version <code>1.0.0</code> no matter what version your dependencies rely on:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/foo": "1.0.0"
+  }
+}
+</code></pre>
+<p>The above is a short hand notation, the full object form can be used to allow overriding a package itself as well as a child of the package.
+This will cause <code>@npm/foo</code> to always be <code>1.0.0</code> while also making <code>@npm/bar</code> at any depth beyond <code>@npm/foo</code> also <code>1.0.0</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/foo": {
+      ".": "1.0.0",
+      "@npm/bar": "1.0.0"
+    }
+  }
+}
+</code></pre>
+<p>To only override <code>@npm/foo</code> to be <code>1.0.0</code> when it's a child (or grandchild, or great grandchild, etc) of the package <code>@npm/bar</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/bar": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+</code></pre>
+<p>Keys can be nested to any arbitrary length.
+To override <code>@npm/foo</code> only when it's a child of <code>@npm/bar</code> and only when <code>@npm/bar</code> is a child of <code>@npm/baz</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/baz": {
+      "@npm/bar": {
+        "@npm/foo": "1.0.0"
+      }
+    }
+  }
+}
+</code></pre>
+<p>The key of an override can also include a version, or range of versions.
+To override <code>@npm/foo</code> to <code>1.0.0</code>, but only when it's a child of <code>@npm/bar@2.0.0</code>:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "@npm/bar@2.0.0": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+</code></pre>
+<p>You may not set an override for a package that you directly depend on unless both the dependency and the override itself share the exact same spec.
+To make this limitation easier to deal with, overrides may also be defined as a reference to a spec for a direct dependency by prefixing the name of the package you wish the version to match with a <code>$</code>.</p>
+<pre><code class="language-json">{
+  "dependencies": {
+    "@npm/foo": "^1.0.0"
+  },
+  "overrides": {
+    // BAD, will throw an EOVERRIDE error
+    // "foo": "^2.0.0"
+    // GOOD, specs match so override is allowed
+    // "foo": "^1.0.0"
+    // BEST, the override is defined as a reference to the dependency
+    "@npm/foo": "$foo",
+    // the referenced package does not need to match the overridden one
+    "@npm/bar": "$foo"
+  }
+}
+</code></pre>
+<h4 id="replacing-a-dependency-with-a-fork">Replacing a dependency with a fork</h4>
+<p>You can replace a package with a different package or fork using several methods:</p>
+<p><strong>Using the <code>npm:</code> prefix to replace with a different package name:</strong></p>
+<pre><code class="language-json">{
+  "overrides": {
+    "package-name": "npm:@scope/forked-package@1.0.0"
+  }
+}
+</code></pre>
+<p><strong>Using a GitHub repository (supports branches, tags, or commit hashes):</strong></p>
+<pre><code class="language-json">{
+  "overrides": {
+    "package-name": "github:username/repo#branch-name"
+  }
+}
+</code></pre>
+<p><strong>Using a local file path:</strong></p>
+<pre><code class="language-json">{
+  "overrides": {
+    "package-name": "file:../local-fork"
+  }
+}
+</code></pre>
+<p>These replacement methods work for both top-level overrides and nested overrides.
+For example, to replace a transitive dependency with a fork:</p>
+<pre><code class="language-json">{
+  "overrides": {
+    "parent-package": {
+      "vulnerable-dep": "github:username/patched-fork#v2.0.1"
+    }
+  }
+}
+</code></pre>
+<h3 id="engines">engines</h3>
+<p>You can specify the version of node that your stuff works on:</p>
+<pre><code class="language-json">{
+  "engines": {
+    "node": "&gt;=0.10.3 &lt;15"
+  }
+}
+</code></pre>
+<p>And, like with dependencies, if you don't specify the version (or if you specify "*" as the version), then any version of node will do.</p>
+<p>You can also use the "engines" field to specify which versions of npm are capable of properly installing your program.
+For example:</p>
+<pre><code class="language-json">{
+  "engines": {
+    "npm": "~1.0.20"
+  }
+}
+</code></pre>
+<p>Unless the user has set the <a href="../using-npm/config#engine-strict.html"><code>engine-strict</code> config</a> flag, this field is advisory only and will only produce warnings when your package is installed as a dependency.</p>
+<h3 id="os">os</h3>
+<p>You can specify which operating systems your module will run on:</p>
+<pre><code class="language-json">{
+  "os": [
+    "darwin",
+    "linux"
+  ]
+}
+</code></pre>
+<p>You can also block instead of allowing operating systems, just prepend the blocked os with a '!':</p>
+<pre><code class="language-json">{
+  "os": [
+    "!win32"
+  ]
+}
+</code></pre>
+<p>The host operating system is determined by <code>process.platform</code></p>
+<p>It is allowed to both block and allow an item, although there isn't any good reason to do this.</p>
+<h3 id="cpu">cpu</h3>
+<p>If your code only runs on certain cpu architectures, you can specify which ones.</p>
+<pre><code class="language-json">{
+  "cpu": [
+    "x64",
+    "ia32"
+  ]
+}
+</code></pre>
+<p>Like the <code>os</code> option, you can also block architectures:</p>
+<pre><code class="language-json">{
+  "cpu": [
+    "!arm",
+    "!mips"
+  ]
+}
+</code></pre>
+<p>The host architecture is determined by <code>process.arch</code></p>
+<h3 id="libc">libc</h3>
+<p>If your code only runs or builds in certain versions of libc, you can specify which ones.
+This field only applies if <code>os</code> is <code>linux</code>.</p>
+<pre><code class="language-json">{
+  "os": "linux",
+  "libc": "glibc"
+}
+</code></pre>
+<h3 id="devengines">devEngines</h3>
+<p>The <code>devEngines</code> field aids engineers working on a codebase to all be using the same tooling.</p>
+<p>You can specify a <code>devEngines</code> property in your <code>package.json</code> which will run before <code>install</code>, <code>ci</code>, and <code>run</code> commands.</p>
+<blockquote>
+<p>Note: <code>engines</code> and <code>devEngines</code> differ in object shape.
+They also function very differently.
+<code>engines</code> is designed to alert the user when a dependency uses a different npm or node version than the project it's being used in, whereas <code>devEngines</code> is used to alert people interacting with the source code of a project.</p>
+</blockquote>
+<p>The supported keys under the <code>devEngines</code> property are <code>cpu</code>, <code>os</code>, <code>libc</code>, <code>runtime</code>, and <code>packageManager</code>.
+Each property can be an object or an array of objects.
+Objects must contain <code>name</code>, and optionally can specify <code>version</code>, and <code>onFail</code>.
+<code>onFail</code> can be <code>warn</code>, <code>error</code>, or <code>ignore</code>, and if left undefined is of the same value as <code>error</code>.
+<code>npm</code> will assume that you're running with <code>node</code>.
+Here's an example of a project that will fail if the environment is not <code>node</code> and <code>npm</code>.
+If you set <code>runtime.name</code> or <code>packageManager.name</code> to any other string, it will fail within the npm CLI.</p>
+<pre><code class="language-json">{
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "onFail": "error"
+    }
+  }
+}
+</code></pre>
+<h3 id="private">private</h3>
+<p>If you set <code>"private": true</code> in your package.json, then npm will refuse to publish it.</p>
+<p>This is a way to prevent accidental publication of private repositories.
+If you would like to ensure that a given package is only ever published to a specific registry (for example, an internal registry), then use the <code>publishConfig</code> dictionary described below to override the <code>registry</code> config param at publish-time.</p>
+<h3 id="publishconfig">publishConfig</h3>
+<p>This is a set of config values that will be used at publish-time.
+It's especially handy if you want to set the tag, registry or access, so that you can ensure that a given package is not tagged with "latest", published to the global public registry or that a scoped module is private by default.</p>
+<p>See <a href="../using-npm/config.html"><code>config</code></a> to see the list of config options that can be overridden.</p>
+<h3 id="workspaces">workspaces</h3>
+<p>The optional <code>workspaces</code> field is an array of file patterns that describes locations within the local file system that the install client should look up to find each <a href="../using-npm/workspaces.html">workspace</a> that needs to be symlinked to the top level <code>node_modules</code> folder.</p>
+<p>It can describe either the direct paths of the folders to be used as workspaces or it can define globs that will resolve to these same folders.</p>
+<p>In the following example, all folders located inside the folder <code>./packages</code> will be treated as workspaces as long as they have valid <code>package.json</code> files inside them:</p>
+<pre><code class="language-json">{
+  "name": "workspace-example",
+  "workspaces": [
+    "./packages/*"
+  ]
+}
+</code></pre>
+<p>See <a href="../using-npm/workspaces.html"><code>workspaces</code></a> for more examples.</p>
+<h3 id="default-values">DEFAULT VALUES</h3>
+<p>npm will default some values based on package contents.</p>
+<ul>
+<li>
+<p><code>"scripts": {"start": "node server.js"}</code></p>
+<p>If there is a <code>server.js</code> file in the root of your package, then npm will default the <code>start</code> command to <code>node server.js</code>.</p>
+</li>
+<li>
+<p><code>"scripts":{"install": "node-gyp rebuild"}</code></p>
+<p>If there is a <code>binding.gyp</code> file in the root of your package and you have not defined an <code>install</code> or <code>preinstall</code> script, npm will default the <code>install</code> command to compile using node-gyp.</p>
+</li>
+<li>
+<p><code>"contributors": [...]</code></p>
+<p>If there is an <code>AUTHORS</code> file in the root of your package, npm will treat each line as a <code>Name &lt;email&gt; (url)</code> format, where email and url are optional.
+Lines which start with a <code>#</code> or are blank, will be ignored.</p>
+</li>
+</ul>
+<h3 id="see-also">SEE ALSO</h3>
+<ul>
+<li><a href="https://github.com/npm/node-semver#versions">semver</a></li>
+<li><a href="../using-npm/workspaces.html">workspaces</a></li>
+<li><a href="../commands/npm-init.html">npm init</a></li>
+<li><a href="../commands/npm-version.html">npm version</a></li>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../commands/npm-help.html">npm help</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-uninstall.html">npm uninstall</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/package-json.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/configuring-npm/package-lock-json.html b/node/node_modules/npm/docs/output/configuring-npm/package-lock-json.html
new file mode 100644
index 0000000000000000000000000000000000000000..9780091ee8c88114056640aaadda423b27b5ff6b
--- /dev/null
+++ b/node/node_modules/npm/docs/output/configuring-npm/package-lock-json.html
@@ -0,0 +1,391 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>package-lock.json</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----package-lockjson----11130">
+    <span>package-lock.json</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">A manifestation of the manifest</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#package-lockjson-vs-npm-shrinkwrapjson"><code>package-lock.json</code> vs <code>npm-shrinkwrap.json</code></a></li><li><a href="#hidden-lockfiles">Hidden Lockfiles</a></li><li><a href="#handling-old-lockfiles">Handling Old Lockfiles</a></li><li><a href="#file-format">File Format</a></li><ul><li><a href="#name"><code>name</code></a></li><li><a href="#version"><code>version</code></a></li><li><a href="#lockfileversion"><code>lockfileVersion</code></a></li><li><a href="#packages"><code>packages</code></a></li><li><a href="#dependencies">dependencies</a></li></ul><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p><code>package-lock.json</code> is automatically generated for any operations where npm modifies either the <code>node_modules</code> tree, or <code>package.json</code>.
+It describes the exact tree that was generated, such that subsequent installs are able to generate identical trees, regardless of intermediate dependency updates.</p>
+<p>This file is intended to be committed into source repositories, and serves various purposes:</p>
+<ul>
+<li>
+<p>Describe a single representation of a dependency tree such that teammates, deployments, and continuous integration are guaranteed to install exactly the same dependencies.</p>
+</li>
+<li>
+<p>Provide a facility for users to "time-travel" to previous states of <code>node_modules</code> without having to commit the directory itself.</p>
+</li>
+<li>
+<p>Facilitate greater visibility of tree changes through readable source control diffs.</p>
+</li>
+<li>
+<p>Optimize the installation process by allowing npm to skip repeated metadata resolutions for previously-installed packages.</p>
+</li>
+<li>
+<p>As of npm v7, lockfiles include enough information to gain a complete picture of the package tree, reducing the need to read <code>package.json</code> files, and allowing for significant performance improvements.</p>
+</li>
+</ul>
+<p>When <code>npm</code> creates or updates <code>package-lock.json</code>, it will infer line endings and indentation from <code>package.json</code> so that the formatting of both files matches.</p>
+<h3 id="package-lockjson-vs-npm-shrinkwrapjson"><code>package-lock.json</code> vs <code>npm-shrinkwrap.json</code></h3>
+<p>Both of these files have the same format, and perform similar functions in the root of a project.</p>
+<p>The difference is that <code>package-lock.json</code> cannot be published, and it will be ignored if found in any place other than the root project.</p>
+<p>In contrast, <a href="../configuring-npm/npm-shrinkwrap-json.html">npm-shrinkwrap.json</a> allows publication, and defines the dependency tree from the point encountered.
+This is not recommended unless deploying a CLI tool or otherwise using the publication process for producing production packages.</p>
+<p>If both <code>package-lock.json</code> and <code>npm-shrinkwrap.json</code> are present in the root of a project, <code>npm-shrinkwrap.json</code> will take precedence and <code>package-lock.json</code> will be ignored.</p>
+<h3 id="hidden-lockfiles">Hidden Lockfiles</h3>
+<p>In order to avoid processing the <code>node_modules</code> folder repeatedly, npm as of v7 uses a "hidden" lockfile present in <code>node_modules/.package-lock.json</code>.
+This contains information about the tree, and is used in lieu of reading the entire <code>node_modules</code> hierarchy provided that the following conditions are met:</p>
+<ul>
+<li>All package folders it references exist in the <code>node_modules</code> hierarchy.</li>
+<li>No package folders exist in the <code>node_modules</code> hierarchy that are not listed in the lockfile.</li>
+<li>The modified time of the file is at least as recent as all of the package folders it references.</li>
+</ul>
+<p>That is, the hidden lockfile will only be relevant if it was created as part of the most recent update to the package tree.
+If another CLI mutates the tree in any way, this will be detected, and the hidden lockfile will be ignored.</p>
+<p>Note that it <em>is</em> possible to manually change the <em>contents</em> of a package in such a way that the modified time of the package folder is unaffected.
+For example, if you add a file to <code>node_modules/foo/lib/bar.js</code>, then the modified time on <code>node_modules/foo</code> will not reflect this change.
+If you are manually editing files in <code>node_modules</code>, it is generally best to delete the file at <code>node_modules/.package-lock.json</code>.</p>
+<p>As the hidden lockfile is ignored by older npm versions, it does not contain the backwards compatibility affordances present in "normal" lockfiles.
+That is, it is <code>lockfileVersion: 3</code>, rather than <code>lockfileVersion: 2</code>.</p>
+<h3 id="handling-old-lockfiles">Handling Old Lockfiles</h3>
+<p>When npm detects a lockfile from npm v6 or before during the package installation process, it is automatically updated to fetch missing information from either the <code>node_modules</code> tree or (in the case of empty <code>node_modules</code> trees or very old lockfile formats) the npm registry.</p>
+<h3 id="file-format">File Format</h3>
+<h4 id="name"><code>name</code></h4>
+<p>The name of the package this is a package-lock for.
+This will match what's in <code>package.json</code>.</p>
+<h4 id="version"><code>version</code></h4>
+<p>The version of the package this is a package-lock for.
+This will match what's in <code>package.json</code>.</p>
+<h4 id="lockfileversion"><code>lockfileVersion</code></h4>
+<p>An integer version, starting at <code>1</code> with the version number of this document whose semantics were used when generating this <code>package-lock.json</code>.</p>
+<p>Note that the file format changed significantly in npm v7 to track information that would have otherwise required looking in <code>node_modules</code> or the npm registry.
+Lockfiles generated by npm v7 will contain <code>lockfileVersion: 2</code>.</p>
+<ul>
+<li>No version provided: an "ancient" shrinkwrap file from a version of npm prior to npm v5.</li>
+<li><code>1</code>: The lockfile version used by npm v5 and v6.</li>
+<li><code>2</code>: The lockfile version used by npm v7 and v8. Backwards compatible to v1 lockfiles.</li>
+<li><code>3</code>: The lockfile version used by npm v9 and above.
+Backwards compatible to npm v7.</li>
+</ul>
+<p>npm will always attempt to get whatever data it can out of a lockfile, even if it is not a version that it was designed to support.</p>
+<h4 id="packages"><code>packages</code></h4>
+<p>This is an object that maps package locations to an object containing the information about that package.</p>
+<p>The root project is typically listed with a key of <code>""</code>, and all other packages are listed with their relative paths from the root project folder.</p>
+<p>Package descriptors have the following fields:</p>
+<ul>
+<li>
+<p>version: The version found in <code>package.json</code></p>
+</li>
+<li>
+<p>resolved: The place where the package was actually resolved from.
+In the case of packages fetched from the registry, this will be a url to a tarball.
+In the case of git dependencies, this will be the full git url with commit sha.
+In the case of link dependencies, this will be the location of the link target.
+<code>registry.npmjs.org</code> is a magic value meaning "the currently configured registry".</p>
+</li>
+<li>
+<p>integrity: A <code>sha512</code> or <code>sha1</code> <a href="https://w3c.github.io/webappsec/specs/subresourceintegrity/">Standard Subresource Integrity</a> string for the artifact that was unpacked in this location.</p>
+</li>
+<li>
+<p>link: A flag to indicate that this is a symbolic link.
+If this is present, no other fields are specified, since the link target will also be included in the lockfile.</p>
+</li>
+<li>
+<p>dev, optional, devOptional: If the package is strictly part of the
+<code>devDependencies</code> tree, then <code>dev</code> will be true.
+If it is strictly part of the <code>optionalDependencies</code> tree, then <code>optional</code> will be set.
+If it is both a <code>dev</code> dependency <em>and</em> an <code>optional</code> dependency of a non-dev dependency, then <code>devOptional</code> will be set.
+(An <code>optional</code> dependency of a <code>dev</code> dependency will have both <code>dev</code> and <code>optional</code> set.)</p>
+</li>
+<li>
+<p>inBundle: A flag to indicate that the package is a bundled dependency.</p>
+</li>
+<li>
+<p>hasInstallScript: A flag to indicate that the package has a <code>preinstall</code>, <code>install</code>, or <code>postinstall</code> script.</p>
+</li>
+<li>
+<p>hasShrinkwrap: A flag to indicate that the package has an <code>npm-shrinkwrap.json</code> file.</p>
+</li>
+<li>
+<p>bin, license, engines, dependencies, optionalDependencies: fields from <code>package.json</code></p>
+</li>
+<li>
+<p>os: An array of operating systems this package is compatible with, as specified in <code>package.json</code>. This field is included when the package specifies OS restrictions.</p>
+</li>
+<li>
+<p>cpu: An array of CPU architectures this package is compatible with, as specified in <code>package.json</code>. This field is included when the package specifies CPU restrictions.</p>
+</li>
+<li>
+<p>funding: Funding information for the package, as specified in <code>package.json</code>. This field contains details about how to support the package maintainers.</p>
+</li>
+</ul>
+<h4 id="dependencies">dependencies</h4>
+<p>Legacy data for supporting versions of npm that use <code>lockfileVersion: 1</code>.
+This is a mapping of package names to dependency objects.
+Because the object structure is strictly hierarchical, symbolic link dependencies are somewhat challenging to represent in some cases.</p>
+<p>npm v7 ignores this section entirely if a <code>packages</code> section is present, but does keep it up to date in order to support switching between npm v6 and npm v7.</p>
+<p>Dependency objects have the following fields:</p>
+<ul>
+<li>
+<p>version: a specifier that varies depending on the nature of the package, and is usable in fetching a new copy of it.
+Note that for peer dependencies that are not installed, or optional dependencies that are not installed, this field may be omitted.</p>
+<ul>
+<li>bundled dependencies: Regardless of source, this is a version number that is purely for informational purposes.</li>
+<li>registry sources: This is a version number.
+(eg, <code>1.2.3</code>)</li>
+<li>git sources: This is a git specifier with resolved committish.
+(eg, <code>git+https://example.com/foo/bar#115311855adb0789a0466714ed48a1499ffea97e</code>)</li>
+<li>http tarball sources: This is the URL of the tarball.
+(eg, <code>https://example.com/example-1.3.0.tgz</code>)</li>
+<li>local tarball sources: This is the file URL of the tarball.
+(eg <code>file:///opt/storage/example-1.3.0.tgz</code>)</li>
+<li>local link sources: This is the file URL of the link.
+(eg <code>file:libs/our-module</code>)</li>
+</ul>
+<p><strong>Note:</strong> The <code>version</code> field may be omitted for certain types of dependencies, such as optional peer dependencies that are not installed. In these cases, only metadata fields like <code>dev</code>, <code>optional</code>, and <code>peer</code> will be present.</p>
+</li>
+<li>
+<p>integrity: A <code>sha512</code> or <code>sha1</code> <a href="https://w3c.github.io/webappsec/specs/subresourceintegrity/">Standard Subresource Integrity</a> string for the artifact that was unpacked in this location.
+For git dependencies, this is the commit sha.</p>
+</li>
+<li>
+<p>resolved: For registry sources this is path of the tarball relative to the registry URL.
+If the tarball URL isn't on the same server as the registry URL then this is a complete URL.
+<code>registry.npmjs.org</code> is a magic value meaning "the currently configured registry".</p>
+</li>
+<li>
+<p>bundled:  If true, this is the bundled dependency and will be installed by the parent module.
+When installing, this module will be extracted from the parent module during the extract phase, not installed as a separate dependency.</p>
+</li>
+<li>
+<p>dev: If true then this dependency is either a development dependency ONLY of the top level module or a transitive dependency of one.
+This is false for dependencies that are both a development dependency of the top level and a transitive dependency of a non-development dependency of the top level.</p>
+</li>
+<li>
+<p>optional: If true then this dependency is either an optional dependency ONLY of the top level module or a transitive dependency of one.
+This is false for dependencies that are both an optional dependency of the top level and a transitive dependency of a non-optional dependency of the top level.</p>
+</li>
+<li>
+<p>requires: This is a mapping of module name to version.
+This is a list of everything this module requires, regardless of where it will be installed.
+The version should match via normal matching rules a dependency either in our <code>dependencies</code> or in a level higher than us.</p>
+</li>
+<li>
+<p>dependencies: The dependencies of this dependency, exactly as at the top level.</p>
+</li>
+</ul>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-shrinkwrap.html">npm shrinkwrap</a></li>
+<li><a href="../configuring-npm/npm-shrinkwrap-json.html">npm-shrinkwrap.json</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/configuring-npm/package-lock-json.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/config.html b/node/node_modules/npm/docs/output/using-npm/config.html
new file mode 100644
index 0000000000000000000000000000000000000000..5a5d965d294b64ea3a234ab23e5f2ea208691292
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/config.html
@@ -0,0 +1,1801 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Config</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----config----11130">
+    <span>Config</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">About npm configuration</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><ul><li><a href="#command-line-flags">Command Line Flags</a></li><li><a href="#environment-variables">Environment Variables</a></li><li><a href="#npmrc-files">npmrc Files</a></li><li><a href="#default-configs">Default Configs</a></li></ul><li><a href="#shorthands-and-other-cli-niceties">Shorthands and Other CLI Niceties</a></li><li><a href="#config-settings">Config Settings</a></li><ul><li><a href="#auth"><code>_auth</code></a></li><li><a href="#access"><code>access</code></a></li><li><a href="#all"><code>all</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-same-version"><code>allow-same-version</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#audit-level"><code>audit-level</code></a></li><li><a href="#auth-type"><code>auth-type</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#browser"><code>browser</code></a></li><li><a href="#bypass-2fa"><code>bypass-2fa</code></a></li><li><a href="#ca"><code>ca</code></a></li><li><a href="#cache"><code>cache</code></a></li><li><a href="#cafile"><code>cafile</code></a></li><li><a href="#call"><code>call</code></a></li><li><a href="#cidr"><code>cidr</code></a></li><li><a href="#color"><code>color</code></a></li><li><a href="#commit-hooks"><code>commit-hooks</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#depth"><code>depth</code></a></li><li><a href="#description2"><code>description</code></a></li><li><a href="#diff"><code>diff</code></a></li><li><a href="#diff-dst-prefix"><code>diff-dst-prefix</code></a></li><li><a href="#diff-ignore-all-space"><code>diff-ignore-all-space</code></a></li><li><a href="#diff-name-only"><code>diff-name-only</code></a></li><li><a href="#diff-no-prefix"><code>diff-no-prefix</code></a></li><li><a href="#diff-src-prefix"><code>diff-src-prefix</code></a></li><li><a href="#diff-text"><code>diff-text</code></a></li><li><a href="#diff-unified"><code>diff-unified</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#editor"><code>editor</code></a></li><li><a href="#engine-strict"><code>engine-strict</code></a></li><li><a href="#expect-result-count"><code>expect-result-count</code></a></li><li><a href="#expect-results"><code>expect-results</code></a></li><li><a href="#expires"><code>expires</code></a></li><li><a href="#fetch-retries"><code>fetch-retries</code></a></li><li><a href="#fetch-retry-factor"><code>fetch-retry-factor</code></a></li><li><a href="#fetch-retry-maxtimeout"><code>fetch-retry-maxtimeout</code></a></li><li><a href="#fetch-retry-mintimeout"><code>fetch-retry-mintimeout</code></a></li><li><a href="#fetch-timeout"><code>fetch-timeout</code></a></li><li><a href="#force"><code>force</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#format-package-lock"><code>format-package-lock</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#git"><code>git</code></a></li><li><a href="#git-tag-version"><code>git-tag-version</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#globalconfig"><code>globalconfig</code></a></li><li><a href="#heading"><code>heading</code></a></li><li><a href="#https-proxy"><code>https-proxy</code></a></li><li><a href="#if-present"><code>if-present</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#include-attestations"><code>include-attestations</code></a></li><li><a href="#include-staged"><code>include-staged</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#init-author-email"><code>init-author-email</code></a></li><li><a href="#init-author-name"><code>init-author-name</code></a></li><li><a href="#init-author-url"><code>init-author-url</code></a></li><li><a href="#init-license"><code>init-license</code></a></li><li><a href="#init-module"><code>init-module</code></a></li><li><a href="#init-private"><code>init-private</code></a></li><li><a href="#init-type"><code>init-type</code></a></li><li><a href="#init-version"><code>init-version</code></a></li><li><a href="#install-links"><code>install-links</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#legacy-peer-deps"><code>legacy-peer-deps</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#link"><code>link</code></a></li><li><a href="#local-address"><code>local-address</code></a></li><li><a href="#location"><code>location</code></a></li><li><a href="#lockfile-version"><code>lockfile-version</code></a></li><li><a href="#loglevel"><code>loglevel</code></a></li><li><a href="#logs-dir"><code>logs-dir</code></a></li><li><a href="#logs-max"><code>logs-max</code></a></li><li><a href="#long"><code>long</code></a></li><li><a href="#maxsockets"><code>maxsockets</code></a></li><li><a href="#message"><code>message</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#name"><code>name</code></a></li><li><a href="#node-gyp"><code>node-gyp</code></a></li><li><a href="#node-options"><code>node-options</code></a></li><li><a href="#noproxy"><code>noproxy</code></a></li><li><a href="#offline"><code>offline</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#omit-lockfile-registry-resolved"><code>omit-lockfile-registry-resolved</code></a></li><li><a href="#orgs"><code>orgs</code></a></li><li><a href="#orgs-permission"><code>orgs-permission</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#pack-destination"><code>pack-destination</code></a></li><li><a href="#package"><code>package</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#packages"><code>packages</code></a></li><li><a href="#packages-all"><code>packages-all</code></a></li><li><a href="#packages-and-scopes-permission"><code>packages-and-scopes-permission</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#password"><code>password</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#prefer-offline"><code>prefer-offline</code></a></li><li><a href="#prefer-online"><code>prefer-online</code></a></li><li><a href="#prefix"><code>prefix</code></a></li><li><a href="#preid"><code>preid</code></a></li><li><a href="#progress"><code>progress</code></a></li><li><a href="#provenance"><code>provenance</code></a></li><li><a href="#provenance-file"><code>provenance-file</code></a></li><li><a href="#proxy"><code>proxy</code></a></li><li><a href="#read-only"><code>read-only</code></a></li><li><a href="#rebuild-bundle"><code>rebuild-bundle</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#replace-registry-host"><code>replace-registry-host</code></a></li><li><a href="#save"><code>save</code></a></li><li><a href="#save-bundle"><code>save-bundle</code></a></li><li><a href="#save-dev"><code>save-dev</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#save-optional"><code>save-optional</code></a></li><li><a href="#save-peer"><code>save-peer</code></a></li><li><a href="#save-prefix"><code>save-prefix</code></a></li><li><a href="#save-prod"><code>save-prod</code></a></li><li><a href="#sbom-format"><code>sbom-format</code></a></li><li><a href="#sbom-type"><code>sbom-type</code></a></li><li><a href="#scope"><code>scope</code></a></li><li><a href="#scopes"><code>scopes</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li><li><a href="#searchexclude"><code>searchexclude</code></a></li><li><a href="#searchlimit"><code>searchlimit</code></a></li><li><a href="#searchopts"><code>searchopts</code></a></li><li><a href="#searchstaleness"><code>searchstaleness</code></a></li><li><a href="#shell"><code>shell</code></a></li><li><a href="#sign-git-commit"><code>sign-git-commit</code></a></li><li><a href="#sign-git-tag"><code>sign-git-tag</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#strict-ssl"><code>strict-ssl</code></a></li><li><a href="#tag"><code>tag</code></a></li><li><a href="#tag-version-prefix"><code>tag-version-prefix</code></a></li><li><a href="#timing"><code>timing</code></a></li><li><a href="#token-description"><code>token-description</code></a></li><li><a href="#umask"><code>umask</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#update-notifier"><code>update-notifier</code></a></li><li><a href="#usage"><code>usage</code></a></li><li><a href="#user-agent"><code>user-agent</code></a></li><li><a href="#userconfig"><code>userconfig</code></a></li><li><a href="#version"><code>version</code></a></li><li><a href="#versions"><code>versions</code></a></li><li><a href="#viewer"><code>viewer</code></a></li><li><a href="#which"><code>which</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#workspaces-update"><code>workspaces-update</code></a></li><li><a href="#yes"><code>yes</code></a></li><li><a href="#also"><code>also</code></a></li><li><a href="#cache-max"><code>cache-max</code></a></li><li><a href="#cache-min"><code>cache-min</code></a></li><li><a href="#cert"><code>cert</code></a></li><li><a href="#dev"><code>dev</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#initauthoremail"><code>init.author.email</code></a></li><li><a href="#initauthorname"><code>init.author.name</code></a></li><li><a href="#initauthorurl"><code>init.author.url</code></a></li><li><a href="#initlicense"><code>init.license</code></a></li><li><a href="#initmodule"><code>init.module</code></a></li><li><a href="#initversion"><code>init.version</code></a></li><li><a href="#key"><code>key</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#only"><code>only</code></a></li><li><a href="#optional"><code>optional</code></a></li><li><a href="#production"><code>production</code></a></li><li><a href="#shrinkwrap"><code>shrinkwrap</code></a></li></ul><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>This article details npm configuration in general.
+To learn about the <code>config</code> command, see <a href="../commands/npm-config.html"><code>npm config</code></a>.</p>
+<p>npm gets its configuration values from the following sources, sorted by priority:</p>
+<h4 id="command-line-flags">Command Line Flags</h4>
+<p>Putting <code>--foo bar</code> on the command line sets the <code>foo</code> configuration parameter to <code>"bar"</code>.
+A <code>--</code> argument tells the cli parser to stop reading flags.
+Using <code>--flag</code> without specifying any value will set the value to <code>true</code>.</p>
+<p>Example: <code>--flag1 --flag2</code> will set both configuration parameters to <code>true</code>, while <code>--flag1 --flag2 bar</code> will set <code>flag1</code> to <code>true</code>, and <code>flag2</code> to <code>bar</code>.
+Finally, <code>--flag1 --flag2 -- bar</code> will set both configuration parameters to <code>true</code>, and the <code>bar</code> is taken as a command argument.</p>
+<p><strong>Common examples:</strong></p>
+<ul>
+<li><code>npm install --prefix /path/to/dir</code> - Runs npm commands in a different directory without changing the current working directory</li>
+<li><code>npm install --global</code> - Installs packages globally (shorthand: <code>-g</code>)</li>
+<li><code>npm install --save-dev</code> - Saves to devDependencies (shorthand: <code>-D</code>)</li>
+</ul>
+<p>Any configuration option documented in the <a href="#config-settings">Config Settings</a> section below can be set via command line flags using <code>--option-name value</code> syntax.</p>
+<h4 id="environment-variables">Environment Variables</h4>
+<p>Any environment variables that start with <code>npm_config_</code> will be interpreted as a configuration parameter.
+For example, putting <code>npm_config_foo=bar</code> in your environment will set the <code>foo</code> configuration parameter to <code>bar</code>.
+Any environment configurations that are not given a value will be given the value of <code>true</code>.
+Config values are case-insensitive, so <code>NPM_CONFIG_FOO=bar</code> will work the same.
+However, please note that inside <a href="../using-npm/scripts.html"><code>scripts</code></a> npm will set its own environment variables and Node will prefer those lowercase versions over any uppercase ones that you might set.
+For details see <a href="https://github.com/npm/npm/issues/14528">this issue</a>.</p>
+<p>Notice that you need to use underscores instead of dashes, so <code>--allow-same-version</code> would become <code>npm_config_allow_same_version=true</code>.</p>
+<p><strong>Important:</strong> When defining custom configuration keys in <code>.npmrc</code> files, use hyphens instead of underscores (e.g., <code>custom-key=value</code>). This ensures they can be overridden by environment variables, since npm automatically converts underscores to hyphens when reading environment variables. Keys with underscores in <code>.npmrc</code> files cannot be overridden via environment variables.</p>
+<h4 id="npmrc-files">npmrc Files</h4>
+<p>The four relevant files are:</p>
+<ul>
+<li>per-project configuration file (<code>/path/to/my/project/.npmrc</code>)</li>
+<li>per-user configuration file (defaults to <code>$HOME/.npmrc</code>; configurable via CLI option <code>--userconfig</code> or environment variable <code>$NPM_CONFIG_USERCONFIG</code>)</li>
+<li>global configuration file (defaults to <code>$PREFIX/etc/npmrc</code>; configurable via CLI option <code>--globalconfig</code> or environment variable <code>$NPM_CONFIG_GLOBALCONFIG</code>)</li>
+<li>npm's built-in configuration file (<code>/path/to/npm/npmrc</code>)</li>
+</ul>
+<p>See <a href="../configuring-npm/npmrc.html">npmrc</a> for more details.</p>
+<h4 id="default-configs">Default Configs</h4>
+<p>Run <code>npm config ls -l</code> to see a set of configuration parameters that are internal to npm, and are defaults if nothing else is specified.</p>
+<h3 id="shorthands-and-other-cli-niceties">Shorthands and Other CLI Niceties</h3>
+<p>The following shorthands are parsed on the command-line:</p>
+<ul>
+<li><code>-a</code>: <code>--all</code></li>
+<li><code>--enjoy-by</code>: <code>--before</code></li>
+<li><code>-c</code>: <code>--call</code></li>
+<li><code>--desc</code>: <code>--description</code></li>
+<li><code>-f</code>: <code>--force</code></li>
+<li><code>-g</code>: <code>--global</code></li>
+<li><code>--iwr</code>: <code>--include-workspace-root</code></li>
+<li><code>-L</code>: <code>--location</code></li>
+<li><code>-d</code>: <code>--loglevel info</code></li>
+<li><code>-s</code>: <code>--loglevel silent</code></li>
+<li><code>--silent</code>: <code>--loglevel silent</code></li>
+<li><code>--ddd</code>: <code>--loglevel silly</code></li>
+<li><code>--dd</code>: <code>--loglevel verbose</code></li>
+<li><code>--verbose</code>: <code>--loglevel verbose</code></li>
+<li><code>-q</code>: <code>--loglevel warn</code></li>
+<li><code>--quiet</code>: <code>--loglevel warn</code></li>
+<li><code>-l</code>: <code>--long</code></li>
+<li><code>-m</code>: <code>--message</code></li>
+<li><code>--local</code>: <code>--no-global</code></li>
+<li><code>-n</code>: <code>--no-yes</code></li>
+<li><code>--no</code>: <code>--no-yes</code></li>
+<li><code>-p</code>: <code>--parseable</code></li>
+<li><code>--porcelain</code>: <code>--parseable</code></li>
+<li><code>-C</code>: <code>--prefix</code></li>
+<li><code>--readonly</code>: <code>--read-only</code></li>
+<li><code>--reg</code>: <code>--registry</code></li>
+<li><code>-S</code>: <code>--save</code></li>
+<li><code>-B</code>: <code>--save-bundle</code></li>
+<li><code>-D</code>: <code>--save-dev</code></li>
+<li><code>-E</code>: <code>--save-exact</code></li>
+<li><code>-O</code>: <code>--save-optional</code></li>
+<li><code>-P</code>: <code>--save-prod</code></li>
+<li><code>-?</code>: <code>--usage</code></li>
+<li><code>-h</code>: <code>--usage</code></li>
+<li><code>-H</code>: <code>--usage</code></li>
+<li><code>--help</code>: <code>--usage</code></li>
+<li><code>-v</code>: <code>--version</code></li>
+<li><code>-w</code>: <code>--workspace</code></li>
+<li><code>--ws</code>: <code>--workspaces</code></li>
+<li><code>-y</code>: <code>--yes</code></li>
+</ul>
+<p>If the specified configuration param resolves unambiguously to a known configuration parameter, then it is expanded to that configuration parameter.
+For example:</p>
+<pre><code class="language-bash">npm ls --par
+# same as:
+npm ls --parseable
+</code></pre>
+<p>If multiple single-character shorthands are strung together, and the resulting combination is unambiguously not some other configuration param, then it is expanded to its various component pieces.
+For example:</p>
+<pre><code class="language-bash">npm ls -gpld
+# same as:
+npm ls --global --parseable --long --loglevel info
+</code></pre>
+<h3 id="config-settings">Config Settings</h3>
+<h4 id="auth"><code>_auth</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>A basic-auth string to use when authenticating against the npm registry.
+This will ONLY be used to authenticate against the npm registry. For other
+registries you will need to scope it like "//other-registry.tld/:_auth"</p>
+<p>Warning: This should generally not be set via a command-line option. It is
+safer to use a registry-provided authentication bearer token stored in the
+~/.npmrc file by running <code>npm login</code>.</p>
+<h4 id="access"><code>access</code></h4>
+<ul>
+<li>Default: 'public' for new packages, existing packages it will not change the
+current level</li>
+<li>Type: null, "restricted", or "public"</li>
+</ul>
+<p>If you do not want your scoped package to be publicly viewable (and
+installable) set <code>--access=restricted</code>.</p>
+<p>Unscoped packages cannot be set to <code>restricted</code>.</p>
+<p>Note: This defaults to not changing the current access level for existing
+packages. Specifying a value of <code>restricted</code> or <code>public</code> during publish will
+change the access for an existing package the same way that <code>npm access set status</code> would.</p>
+<h4 id="all"><code>all</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When running <code>npm outdated</code> and <code>npm ls</code>, setting <code>--all</code> will show all
+outdated or installed packages, rather than only those directly depended
+upon by the current project.</p>
+<h4 id="allow-git"><code>allow-git</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from git references. That
+is, dependencies that point to a git repo instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed.</p>
+<p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
+prevents any git dependencies from being fetched and installed. <code>root</code> only
+allows git dependencies defined in your project's package.json to be fetched
+installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-same-version"><code>allow-same-version</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prevents throwing an error when <code>npm version</code> is used to set the new version
+to the same value as the current version.</p>
+<h4 id="audit"><code>audit</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" submit audit reports alongside the current npm command to the
+default registry and all registries configured for scopes. See the
+documentation for <a href="../commands/npm-audit.html"><code>npm audit</code></a> for details on what is
+submitted.</p>
+<h4 id="audit-level"><code>audit-level</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "info", "low", "moderate", "high", "critical", or "none"</li>
+</ul>
+<p>The minimum level of vulnerability for <code>npm audit</code> to exit with a non-zero
+exit code.</p>
+<h4 id="auth-type"><code>auth-type</code></h4>
+<ul>
+<li>Default: "web"</li>
+<li>Type: "legacy" or "web"</li>
+</ul>
+<p>What authentication strategy to use with <code>login</code>. Note that if an <code>otp</code>
+config is given, this value will always be set to <code>legacy</code>.</p>
+<h4 id="before"><code>before</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Date</li>
+</ul>
+<p>If passed to <code>npm install</code>, will rebuild the npm tree such that only
+versions that were available <strong>on or before</strong> the given date are installed.
+If there are no versions available for the current set of dependencies, the
+command will error.</p>
+<p>If the requested version is a <code>dist-tag</code> and the given tag does not pass the
+<code>--before</code> filter, the most recent version less than or equal to that tag
+will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
+<code>latest</code> is <code>2.0</code>.</p>
+<p>This config cannot be used with: <code>min-release-age</code></p>
+<h4 id="bin-links"><code>bin-links</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tells npm to create symlinks (or <code>.cmd</code> shims on Windows) for package
+executables.</p>
+<p>Set to false to have it not do this. This can be used to work around the
+fact that some file systems don't support symlinks, even on ostensibly Unix
+systems.</p>
+<h4 id="browser"><code>browser</code></h4>
+<ul>
+<li>Default: macOS: <code>"open"</code>, Windows: <code>"start"</code>, Others: <code>"xdg-open"</code></li>
+<li>Type: null, Boolean, or String</li>
+</ul>
+<p>The browser that is called by npm commands to open websites.</p>
+<p>Set to <code>false</code> to suppress browser behavior and instead print urls to
+terminal.</p>
+<p>Set to <code>true</code> to use default system URL opener.</p>
+<h4 id="bypass-2fa"><code>bypass-2fa</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, setting this
+to true will allow the token to bypass two-factor authentication. This is
+useful for automation and CI/CD workflows.</p>
+<h4 id="ca"><code>ca</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>The Certificate Authority signing certificate that is trusted for SSL
+connections to the registry. Values should be in PEM format (Windows calls
+it "Base-64 encoded X.509 (.CER)") with newlines replaced by the string
+"\n". For example:</p>
+<pre><code class="language-ini">ca="-----BEGIN CERTIFICATE-----\nXXXX\nXXXX\n-----END CERTIFICATE-----"
+</code></pre>
+<p>Set to <code>null</code> to only allow "known" registrars, or to a specific CA cert to
+trust only that specific signing authority.</p>
+<p>Multiple CAs can be trusted by specifying an array of certificates:</p>
+<pre><code class="language-ini">ca[]="..."
+ca[]="..."
+</code></pre>
+<p>See also the <code>strict-ssl</code> config.</p>
+<h4 id="cache"><code>cache</code></h4>
+<ul>
+<li>Default: Windows: <code>%LocalAppData%\npm-cache</code>, Posix: <code>~/.npm</code></li>
+<li>Type: Path</li>
+</ul>
+<p>The location of npm's cache directory.</p>
+<h4 id="cafile"><code>cafile</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: Path</li>
+</ul>
+<p>A path to a file containing one or multiple Certificate Authority signing
+certificates. Similar to the <code>ca</code> setting, but allows for multiple CA's, as
+well as for the CA information to be stored in a file on disk.</p>
+<h4 id="call"><code>call</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>Optional companion option for <code>npm exec</code>, <code>npx</code> that allows for specifying a
+custom command to be run along with the installed packages.</p>
+<pre><code class="language-bash">npm exec --package yo --package generator-node --call "yo node"
+</code></pre>
+<h4 id="cidr"><code>cidr</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>This is a list of CIDR address to be used when configuring limited access
+tokens with the <code>npm token create</code> command.</p>
+<h4 id="color"><code>color</code></h4>
+<ul>
+<li>Default: true unless the NO_COLOR environ is set to something other than '0'</li>
+<li>Type: "always" or Boolean</li>
+</ul>
+<p>If false, never shows colors. If <code>"always"</code> then always shows colors. If
+true, then only prints color codes for tty file descriptors.</p>
+<h4 id="commit-hooks"><code>commit-hooks</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run git commit hooks when using the <code>npm version</code> command.</p>
+<h4 id="cpu"><code>cpu</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override CPU architecture of native modules to install. Acceptable values
+are same as <code>cpu</code> field of package.json, which comes from <code>process.arch</code>.</p>
+<h4 id="depth"><code>depth</code></h4>
+<ul>
+<li>Default: <code>Infinity</code> if <code>--all</code> is set; otherwise, <code>0</code></li>
+<li>Type: null or Number</li>
+</ul>
+<p>The depth to go when recursing packages for <code>npm ls</code>.</p>
+<p>If not set, <code>npm ls</code> will show only the immediate dependencies of the root
+project. If <code>--all</code> is set, then npm will show all dependencies by default.</p>
+<h4 id="description2"><code>description</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show the description in <code>npm search</code></p>
+<h4 id="diff"><code>diff</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Define arguments to compare in <code>npm diff</code>.</p>
+<h4 id="diff-dst-prefix"><code>diff-dst-prefix</code></h4>
+<ul>
+<li>Default: "b/"</li>
+<li>Type: String</li>
+</ul>
+<p>Destination prefix to be used in <code>npm diff</code> output.</p>
+<h4 id="diff-ignore-all-space"><code>diff-ignore-all-space</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Ignore whitespace when comparing lines in <code>npm diff</code>.</p>
+<h4 id="diff-name-only"><code>diff-name-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prints only filenames when using <code>npm diff</code>.</p>
+<h4 id="diff-no-prefix"><code>diff-no-prefix</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Do not show any source or destination prefix in <code>npm diff</code> output.</p>
+<p>Note: this causes <code>npm diff</code> to ignore the <code>--diff-src-prefix</code> and
+<code>--diff-dst-prefix</code> configs.</p>
+<h4 id="diff-src-prefix"><code>diff-src-prefix</code></h4>
+<ul>
+<li>Default: "a/"</li>
+<li>Type: String</li>
+</ul>
+<p>Source prefix to be used in <code>npm diff</code> output.</p>
+<h4 id="diff-text"><code>diff-text</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Treat all files as text in <code>npm diff</code>.</p>
+<h4 id="diff-unified"><code>diff-unified</code></h4>
+<ul>
+<li>Default: 3</li>
+<li>Type: Number</li>
+</ul>
+<p>The number of lines of context to print in <code>npm diff</code>.</p>
+<h4 id="dry-run"><code>dry-run</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Indicates that you don't want npm to make any changes and that it should
+only report what it would have done. This can be passed into any of the
+commands that modify your local installation, eg, <code>install</code>, <code>update</code>,
+<code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and <code>publish</code>.</p>
+<p>Note: This is NOT honored by other network related commands, eg <code>dist-tags</code>,
+<code>owner</code>, etc.</p>
+<h4 id="editor"><code>editor</code></h4>
+<ul>
+<li>Default: The EDITOR or VISUAL environment variables, or
+'%SYSTEMROOT%\notepad.exe' on Windows, or 'vi' on Unix systems</li>
+<li>Type: String</li>
+</ul>
+<p>The command to run for <code>npm edit</code> and <code>npm config edit</code>.</p>
+<h4 id="engine-strict"><code>engine-strict</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, then npm will stubbornly refuse to install (or even consider
+installing) any package that claims to not be compatible with the current
+Node.js version.</p>
+<p>This can be overridden by setting the <code>--force</code> flag.</p>
+<h4 id="expect-result-count"><code>expect-result-count</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>Tells to expect a specific number of results from the command.</p>
+<p>This config cannot be used with: <code>expect-results</code></p>
+<h4 id="expect-results"><code>expect-results</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Tells npm whether or not to expect results from the command. Can be either
+true (expect some results) or false (expect no results).</p>
+<p>This config cannot be used with: <code>expect-result-count</code></p>
+<h4 id="expires"><code>expires</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this sets the
+expiration in days. If not specified, the server will determine the default
+expiration.</p>
+<h4 id="fetch-retries"><code>fetch-retries</code></h4>
+<ul>
+<li>Default: 2</li>
+<li>Type: Number</li>
+</ul>
+<p>The "retries" config for the <code>retry</code> module to use when fetching packages
+from the registry.</p>
+<p>npm will retry idempotent read requests to the registry in the case of
+network failures or 5xx HTTP errors.</p>
+<h4 id="fetch-retry-factor"><code>fetch-retry-factor</code></h4>
+<ul>
+<li>Default: 10</li>
+<li>Type: Number</li>
+</ul>
+<p>The "factor" config for the <code>retry</code> module to use when fetching packages.</p>
+<h4 id="fetch-retry-maxtimeout"><code>fetch-retry-maxtimeout</code></h4>
+<ul>
+<li>Default: 60000 (1 minute)</li>
+<li>Type: Number</li>
+</ul>
+<p>The "maxTimeout" config for the <code>retry</code> module to use when fetching
+packages.</p>
+<h4 id="fetch-retry-mintimeout"><code>fetch-retry-mintimeout</code></h4>
+<ul>
+<li>Default: 10000 (10 seconds)</li>
+<li>Type: Number</li>
+</ul>
+<p>The "minTimeout" config for the <code>retry</code> module to use when fetching
+packages.</p>
+<h4 id="fetch-timeout"><code>fetch-timeout</code></h4>
+<ul>
+<li>Default: 300000 (5 minutes)</li>
+<li>Type: Number</li>
+</ul>
+<p>The maximum amount of time to wait for HTTP requests to complete.</p>
+<h4 id="force"><code>force</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Removes various protections against unfortunate side effects, common
+mistakes, unnecessary performance degradation, and malicious input.</p>
+<ul>
+<li>Allow clobbering non-npm files in global installs.</li>
+<li>Allow the <code>npm version</code> command to work on an unclean git repository.</li>
+<li>Allow deleting the cache folder with <code>npm cache clean</code>.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of npm.</li>
+<li>Allow installing packages that have an <code>engines</code> declaration requiring a
+different version of <code>node</code>, even if <code>--engine-strict</code> is enabled.</li>
+<li>Allow <code>npm audit fix</code> to install modules outside your stated dependency
+range (including SemVer-major changes).</li>
+<li>Allow unpublishing all versions of a published package.</li>
+<li>Allow conflicting peerDependencies to be installed in the root project.</li>
+<li>Implicitly set <code>--yes</code> during <code>npm init</code>.</li>
+<li>Allow clobbering existing values in <code>npm pkg</code></li>
+<li>Allow unpublishing of entire packages (not just a single version).</li>
+</ul>
+<p>If you don't have a clear idea of what you want to do, it is strongly
+recommended that you do not use this option!</p>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<ul>
+<li>Default: <code>false</code> unless when using <code>npm pack</code> or <code>npm publish</code> where it
+defaults to <code>true</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Run all build scripts (ie, <code>preinstall</code>, <code>install</code>, and <code>postinstall</code>)
+scripts for installed packages in the foreground process, sharing standard
+input, output, and error with the main npm process.</p>
+<p>Note that this will generally make installs run slower, and be much noisier,
+but can be useful for debugging.</p>
+<h4 id="format-package-lock"><code>format-package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Format <code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> as a human readable
+file.</p>
+<h4 id="fund"><code>fund</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When "true" displays the message at the end of each <code>npm install</code>
+acknowledging the number of dependencies looking for funding. See <a href="../commands/npm-fund.html"><code>npm fund</code></a> for details.</p>
+<h4 id="git"><code>git</code></h4>
+<ul>
+<li>Default: "git"</li>
+<li>Type: String</li>
+</ul>
+<p>The command to use for git commands. If git is installed on the computer,
+but is not in the <code>PATH</code>, then set this to the full path to the git binary.</p>
+<h4 id="git-tag-version"><code>git-tag-version</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Tag the commit when using the <code>npm version</code> command. Setting this to false
+results in no commit being made at all.</p>
+<h4 id="global"><code>global</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Operates in "global" mode, so that packages are installed into the <code>prefix</code>
+folder instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="globalconfig"><code>globalconfig</code></h4>
+<ul>
+<li>Default: The global --prefix setting plus 'etc/npmrc'. For example,
+'/usr/local/etc/npmrc'</li>
+<li>Type: Path</li>
+</ul>
+<p>The config file to read for global config options.</p>
+<h4 id="heading"><code>heading</code></h4>
+<ul>
+<li>Default: "npm"</li>
+<li>Type: String</li>
+</ul>
+<p>The string that starts all the debugging log output.</p>
+<h4 id="https-proxy"><code>https-proxy</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or URL</li>
+</ul>
+<p>A proxy to use for outgoing https requests. If the <code>HTTPS_PROXY</code> or
+<code>https_proxy</code> or <code>HTTP_PROXY</code> or <code>http_proxy</code> environment variables are set,
+proxy settings will be honored by the underlying <code>make-fetch-happen</code>
+library.</p>
+<h4 id="if-present"><code>if-present</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm will not exit with an error code when <code>run</code> is invoked for a
+script that isn't defined in the <code>scripts</code> section of <code>package.json</code>. This
+option can be used when it's desirable to optionally run a script when it's
+present and fail if the script fails. This is useful, for example, when
+running scripts that may only apply for some builds in an otherwise generic
+CI setup.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, npm does not run scripts specified in package.json files.</p>
+<p>Note that commands explicitly intended to run a particular script, such as
+<code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
+run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
+run any pre- or post-scripts.</p>
+<h4 id="include"><code>include</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: "prod", "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Option that allows for defining which types of dependencies to install.</p>
+<p>This is the inverse of <code>--omit=&lt;type&gt;</code>.</p>
+<p>Dependency types specified in <code>--include</code> will not be omitted, regardless of
+the order in which omit/include are specified on the command-line.</p>
+<h4 id="include-attestations"><code>include-attestations</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When used with <code>npm audit signatures --json</code>, includes the full sigstore
+attestation bundles in the JSON output for each verified package. The
+bundles contain DSSE envelopes, verification material, and transparency log
+entries.</p>
+<h4 id="include-staged"><code>include-staged</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Allow installing "staged" published packages, as defined by <a href="https://github.com/npm/rfcs/pull/92">npm RFC PR
+#92</a>.</p>
+<p>This is experimental, and not implemented by the npm public registry.</p>
+<h4 id="include-workspace-root"><code>include-workspace-root</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Include the workspace root when workspaces are enabled for a command.</p>
+<p>When false, specifying individual workspaces via the <code>workspace</code> config, or
+all workspaces via the <code>workspaces</code> flag, will cause npm to operate only on
+the specified workspaces, and not on the root project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="init-author-email"><code>init-author-email</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package author's email.</p>
+<h4 id="init-author-name"><code>init-author-name</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package author's name.</p>
+<h4 id="init-author-url"><code>init-author-url</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: "" or URL</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package author's
+homepage.</p>
+<h4 id="init-license"><code>init-license</code></h4>
+<ul>
+<li>Default: "ISC"</li>
+<li>Type: String</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package license.</p>
+<h4 id="init-module"><code>init-module</code></h4>
+<ul>
+<li>Default: "~/.npm-init.js"</li>
+<li>Type: Path</li>
+</ul>
+<p>A module that will be loaded by the <code>npm init</code> command. See the
+documentation for the
+<a href="https://github.com/npm/init-package-json">init-package-json</a> module for
+more information, or <a href="../commands/npm-init.html">npm init</a>.</p>
+<h4 id="init-private"><code>init-private</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>The value <code>npm init</code> should use by default for the package's private flag.</p>
+<h4 id="init-type"><code>init-type</code></h4>
+<ul>
+<li>Default: "commonjs"</li>
+<li>Type: String</li>
+</ul>
+<p>The value that <code>npm init</code> should use by default for the package.json type
+field.</p>
+<h4 id="init-version"><code>init-version</code></h4>
+<ul>
+<li>Default: "1.0.0"</li>
+<li>Type: SemVer string</li>
+</ul>
+<p>The value that <code>npm init</code> should use by default for the package version
+number, if not already set in package.json.</p>
+<h4 id="install-links"><code>install-links</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set file: protocol dependencies will be packed and installed as regular
+dependencies instead of creating a symlink. This option has no effect on
+workspaces.</p>
+<h4 id="install-strategy"><code>install-strategy</code></h4>
+<ul>
+<li>Default: "hoisted"</li>
+<li>Type: "hoisted", "nested", "shallow", or "linked"</li>
+</ul>
+<p>Sets the strategy for installing packages in node_modules. hoisted
+(default): Install non-duplicated in top-level, and duplicated as necessary
+within directory structure. nested: (formerly --legacy-bundling) install in
+place, no hoisting. shallow (formerly --global-style) only install direct
+deps at top-level. linked: (experimental) install in node_modules/.store,
+link in place, unhoisted.</p>
+<h4 id="json"><code>json</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to output JSON data, rather than the normal output.</p>
+<ul>
+<li>In <code>npm pkg set</code> it enables parsing set values with JSON.parse() before
+saving them to your <code>package.json</code>.</li>
+</ul>
+<p>Not supported by all npm commands.</p>
+<h4 id="legacy-peer-deps"><code>legacy-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Causes npm to completely ignore <code>peerDependencies</code> when building a package
+tree, as in npm versions 3 through 6.</p>
+<p>If a package cannot be installed because of overly strict <code>peerDependencies</code>
+that collide, it provides a way to move forward resolving the situation.</p>
+<p>This differs from <code>--omit=peer</code>, in that <code>--omit=peer</code> will avoid unpacking
+<code>peerDependencies</code> on disk, but will still design a tree such that
+<code>peerDependencies</code> <em>could</em> be unpacked in a correct place.</p>
+<p>Use of <code>legacy-peer-deps</code> is not recommended, as it will not enforce the
+<code>peerDependencies</code> contract that meta-dependencies may rely on.</p>
+<h4 id="libc"><code>libc</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override libc of native modules to install. Acceptable values are same as
+<code>libc</code> field of package.json</p>
+<h4 id="link"><code>link</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Used with <code>npm ls</code>, limiting output to only those packages that are linked.</p>
+<h4 id="local-address"><code>local-address</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: IP Address</li>
+</ul>
+<p>The IP address of the local interface to use when making connections to the
+npm registry. Must be IPv4 in versions of Node prior to 0.12.</p>
+<h4 id="location"><code>location</code></h4>
+<ul>
+<li>Default: "user" unless <code>--global</code> is passed, which will also set this value
+to "global"</li>
+<li>Type: "global", "user", or "project"</li>
+</ul>
+<p>When passed to <code>npm config</code> this refers to which config file to use.</p>
+<p>When set to "global" mode, packages are installed into the <code>prefix</code> folder
+instead of the current working directory. See
+<a href="../configuring-npm/folders.html">folders</a> for more on the differences in behavior.</p>
+<ul>
+<li>packages are installed into the <code>{prefix}/lib/node_modules</code> folder, instead
+of the current working directory.</li>
+<li>bin files are linked to <code>{prefix}/bin</code></li>
+<li>man pages are linked to <code>{prefix}/share/man</code></li>
+</ul>
+<h4 id="lockfile-version"><code>lockfile-version</code></h4>
+<ul>
+<li>Default: Version 3 if no lockfile, auto-converting v1 lockfiles to v3;
+otherwise, maintain current lockfile version.</li>
+<li>Type: null, 1, 2, 3, "1", "2", or "3"</li>
+</ul>
+<p>Set the lockfile format version to be used in package-lock.json and
+npm-shrinkwrap-json files. Possible options are:</p>
+<p>1: The lockfile version used by npm versions 5 and 6. Lacks some data that
+is used during the install, resulting in slower and possibly less
+deterministic installs. Prevents lockfile churn when interoperating with
+older npm versions.</p>
+<p>2: The default lockfile version used by npm version 7 and 8. Includes both
+the version 1 lockfile data and version 3 lockfile data, for maximum
+determinism and interoperability, at the expense of more bytes on disk.</p>
+<p>3: Only the new lockfile information introduced in npm version 7. Smaller on
+disk than lockfile version 2, but not interoperable with older npm versions.
+Ideal if all users are on npm version 7 and higher.</p>
+<h4 id="loglevel"><code>loglevel</code></h4>
+<ul>
+<li>Default: "notice"</li>
+<li>Type: "silent", "error", "warn", "notice", "http", "info", "verbose", or
+"silly"</li>
+</ul>
+<p>What level of logs to report. All logs are written to a debug log, with the
+path to that file printed if the execution of a command fails.</p>
+<p>Any logs of a higher level than the setting are shown. The default is
+"notice".</p>
+<p>See also the <code>foreground-scripts</code> config.</p>
+<h4 id="logs-dir"><code>logs-dir</code></h4>
+<ul>
+<li>Default: A directory named <code>_logs</code> inside the cache</li>
+<li>Type: null or Path</li>
+</ul>
+<p>The location of npm's log directory. See <a href="../using-npm/logging.html"><code>npm logging</code></a>
+for more information.</p>
+<h4 id="logs-max"><code>logs-max</code></h4>
+<ul>
+<li>Default: 10</li>
+<li>Type: Number</li>
+</ul>
+<p>The maximum number of log files to store.</p>
+<p>If set to 0, no log files will be written for the current run.</p>
+<h4 id="long"><code>long</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show extended information in <code>ls</code>, <code>search</code>, and <code>help-search</code>.</p>
+<h4 id="maxsockets"><code>maxsockets</code></h4>
+<ul>
+<li>Default: 15</li>
+<li>Type: Number</li>
+</ul>
+<p>The maximum number of connections to use per origin (protocol/host/port
+combination).</p>
+<h4 id="message"><code>message</code></h4>
+<ul>
+<li>Default: "%s"</li>
+<li>Type: String</li>
+</ul>
+<p>Commit message which is used by <code>npm version</code> when creating version commit.</p>
+<p>Any "%s" in the message will be replaced with the version number.</p>
+<h4 id="min-release-age"><code>min-release-age</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If set, npm will build the npm tree such that only versions that were
+available more than the given number of days ago will be installed. If there
+are no versions available for the current set of dependencies, the command
+will error.</p>
+<p>This flag is a complement to <code>before</code>, which accepts an exact date instead
+of a relative number of days.</p>
+<p>This config cannot be used with: <code>before</code></p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="name"><code>name</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this sets the
+name/description for the token.</p>
+<h4 id="node-gyp"><code>node-gyp</code></h4>
+<ul>
+<li>Default: The path to the node-gyp bin that ships with npm</li>
+<li>Type: Path</li>
+</ul>
+<p>This is the location of the "node-gyp" bin. By default it uses one that
+ships with npm itself.</p>
+<p>You can use this config to specify your own "node-gyp" to run when it is
+required to build a package.</p>
+<h4 id="node-options"><code>node-options</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Options to pass through to Node.js via the <code>NODE_OPTIONS</code> environment
+variable. This does not impact how npm itself is executed but it does impact
+how lifecycle scripts are called.</p>
+<h4 id="noproxy"><code>noproxy</code></h4>
+<ul>
+<li>Default: The value of the NO_PROXY environment variable</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Domain extensions that should bypass any proxies.</p>
+<p>Also accepts a comma-delimited string.</p>
+<h4 id="offline"><code>offline</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Force offline mode: no network requests will be done during install. To
+allow the CLI to fill in missing cache data, see <code>--prefer-offline</code>.</p>
+<h4 id="omit"><code>omit</code></h4>
+<ul>
+<li>Default: 'dev' if the <code>NODE_ENV</code> environment variable is set to
+'production'; otherwise, empty.</li>
+<li>Type: "dev", "optional", or "peer" (can be set multiple times)</li>
+</ul>
+<p>Dependency types to omit from the installation tree on disk.</p>
+<p>Note that these dependencies <em>are</em> still resolved and added to the
+<code>package-lock.json</code> or <code>npm-shrinkwrap.json</code> file. They are just not
+physically installed on disk.</p>
+<p>If a package type appears in both the <code>--include</code> and <code>--omit</code> lists, then
+it will be included.</p>
+<p>If the resulting omit list includes <code>'dev'</code>, then the <code>NODE_ENV</code> environment
+variable will be set to <code>'production'</code> for all lifecycle scripts.</p>
+<h4 id="omit-lockfile-registry-resolved"><code>omit-lockfile-registry-resolved</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>This option causes npm to create lock files without a <code>resolved</code> key for
+registry dependencies. Subsequent installs will need to resolve tarball
+endpoints with the configured registry, likely resulting in a longer install
+time.</p>
+<h4 id="orgs"><code>orgs</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this limits
+the token access to specific organizations.</p>
+<h4 id="orgs-permission"><code>orgs-permission</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "read-only", "read-write", or "no-access"</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, sets the
+permission level for organizations. Options are "read-only", "read-write",
+or "no-access".</p>
+<h4 id="os"><code>os</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Override OS of native modules to install. Acceptable values are same as <code>os</code>
+field of package.json, which comes from <code>process.platform</code>.</p>
+<h4 id="otp"><code>otp</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>This is a one-time password from a two-factor authenticator. It's needed
+when publishing or changing package permissions with <code>npm access</code>.</p>
+<p>If not set, and a registry response fails with a challenge for a one-time
+password, npm will prompt on the command line for one.</p>
+<h4 id="pack-destination"><code>pack-destination</code></h4>
+<ul>
+<li>Default: "."</li>
+<li>Type: String</li>
+</ul>
+<p>Directory in which <code>npm pack</code> will save tarballs.</p>
+<h4 id="package"><code>package</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>The package or packages to install for <a href="../commands/npm-exec.html"><code>npm exec</code></a></p>
+<h4 id="package-lock"><code>package-lock</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to false, then ignore <code>package-lock.json</code> files when installing. This
+will also prevent <em>writing</em> <code>package-lock.json</code> if <code>save</code> is true.</p>
+<h4 id="package-lock-only"><code>package-lock-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the current operation will only use the <code>package-lock.json</code>,
+ignoring <code>node_modules</code>.</p>
+<p>For <code>update</code> this means only the <code>package-lock.json</code> will be updated,
+instead of checking <code>node_modules</code> and downloading dependencies.</p>
+<p>For <code>list</code> this means the output will be based on the tree described by the
+<code>package-lock.json</code>, rather than the contents of <code>node_modules</code>.</p>
+<h4 id="packages"><code>packages</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this limits
+the token access to specific packages.</p>
+<h4 id="packages-all"><code>packages-all</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, grants the
+token access to all packages instead of limiting to specific packages.</p>
+<h4 id="packages-and-scopes-permission"><code>packages-and-scopes-permission</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "read-only", "read-write", or "no-access"</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, sets the
+permission level for packages and scopes. Options are "read-only",
+"read-write", or "no-access".</p>
+<h4 id="parseable"><code>parseable</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Output parseable results from commands that write to standard output. For
+<code>npm search</code>, this will be tab-separated table format.</p>
+<h4 id="password"><code>password</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Password for authentication. Can be provided via command line when creating
+tokens, though it's generally safer to be prompted for it.</p>
+<h4 id="prefer-dedupe"><code>prefer-dedupe</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Prefer to deduplicate packages if possible, rather than choosing a newer
+version of a dependency.</p>
+<h4 id="prefer-offline"><code>prefer-offline</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, staleness checks for cached data will be bypassed, but missing data
+will be requested from the server. To force full offline mode, use
+<code>--offline</code>.</p>
+<h4 id="prefer-online"><code>prefer-online</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, staleness checks for cached data will be forced, making the CLI
+look for updates immediately even for fresh package data.</p>
+<h4 id="prefix"><code>prefix</code></h4>
+<ul>
+<li>Default: In global mode, the folder where the node executable is installed.
+Otherwise, the nearest parent folder containing either a package.json file
+or a node_modules folder.</li>
+<li>Type: Path</li>
+</ul>
+<p>The location to install global items. If set on the command line, then it
+forces non-global commands to run in the specified folder.</p>
+<h4 id="preid"><code>preid</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>The "prerelease identifier" to use as a prefix for the "prerelease" part of
+a semver. Like the <code>rc</code> in <code>1.2.0-rc.8</code>.</p>
+<h4 id="progress"><code>progress</code></h4>
+<ul>
+<li>Default: <code>true</code> when not in CI and both stderr and stdout are TTYs and not
+in a dumb terminal</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to <code>true</code>, npm will display a progress bar during time intensive
+operations, if <code>process.stderr</code> and <code>process.stdout</code> are a TTY.</p>
+<p>Set to <code>false</code> to suppress the progress bar.</p>
+<h4 id="provenance"><code>provenance</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When publishing from a supported cloud CI/CD system, the package will be
+publicly linked to where it was built and published from.</p>
+<p>This config cannot be used with: <code>provenance-file</code></p>
+<h4 id="provenance-file"><code>provenance-file</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: Path</li>
+</ul>
+<p>When publishing, the provenance bundle at the given path will be used.</p>
+<p>This config cannot be used with: <code>provenance</code></p>
+<h4 id="proxy"><code>proxy</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, false, or URL</li>
+</ul>
+<p>A proxy to use for outgoing http requests. If the <code>HTTP_PROXY</code> or
+<code>http_proxy</code> environment variables are set, proxy settings will be honored
+by the underlying <code>request</code> library.</p>
+<h4 id="read-only"><code>read-only</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>This is used to mark a token as unable to publish when configuring limited
+access tokens with the <code>npm token create</code> command.</p>
+<h4 id="rebuild-bundle"><code>rebuild-bundle</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Rebuild bundled dependencies after installation.</p>
+<h4 id="registry"><code>registry</code></h4>
+<ul>
+<li>Default: "<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</li>
+<li>Type: URL</li>
+</ul>
+<p>The base URL of the npm registry.</p>
+<h4 id="replace-registry-host"><code>replace-registry-host</code></h4>
+<ul>
+<li>Default: "npmjs"</li>
+<li>Type: "npmjs", "never", "always", or String</li>
+</ul>
+<p>Defines behavior for replacing the registry host in a lockfile with the
+configured registry.</p>
+<p>The default behavior is to replace package dist URLs from the default
+registry (<a href="https://registry.npmjs.org">https://registry.npmjs.org</a>) to the configured registry. If set to
+"never", then use the registry value. If set to "always", then replace the
+registry host with the configured host every time.</p>
+<p>You may also specify a bare hostname (e.g., "registry.npmjs.org").</p>
+<h4 id="save"><code>save</code></h4>
+<ul>
+<li>Default: <code>true</code> unless when using <code>npm update</code> where it defaults to <code>false</code></li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a <code>package.json</code> file as dependencies.</p>
+<p>When used with the <code>npm rm</code> command, removes the dependency from
+<code>package.json</code>.</p>
+<p>Will also prevent writing to <code>package-lock.json</code> if set to <code>false</code>.</p>
+<h4 id="save-bundle"><code>save-bundle</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If a package would be saved at install time by the use of <code>--save</code>,
+<code>--save-dev</code>, or <code>--save-optional</code>, then also put it in the
+<code>bundleDependencies</code> list.</p>
+<p>Ignored if <code>--save-peer</code> is set, since peerDependencies cannot be bundled.</p>
+<h4 id="save-dev"><code>save-dev</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a package.json file as <code>devDependencies</code>.</p>
+<p>This config cannot be used with: <code>save-optional</code>, <code>save-peer</code>, <code>save-prod</code></p>
+<h4 id="save-exact"><code>save-exact</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Dependencies saved to package.json will be configured with an exact version
+rather than using npm's default semver range operator.</p>
+<h4 id="save-optional"><code>save-optional</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a package.json file as <code>optionalDependencies</code>.</p>
+<p>This config cannot be used with: <code>save-dev</code>, <code>save-peer</code>, <code>save-prod</code></p>
+<h4 id="save-peer"><code>save-peer</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages to a package.json file as <code>peerDependencies</code></p>
+<p>This config cannot be used with: <code>save-dev</code>, <code>save-optional</code>, <code>save-prod</code></p>
+<h4 id="save-prefix"><code>save-prefix</code></h4>
+<ul>
+<li>Default: "^"</li>
+<li>Type: String</li>
+</ul>
+<p>Configure how versions of packages installed to a package.json file via
+<code>--save</code> or <code>--save-dev</code> get prefixed.</p>
+<p>For example if a package has version <code>1.2.3</code>, by default its version is set
+to <code>^1.2.3</code> which allows minor upgrades for that package, but after <code>npm config set save-prefix='~'</code> it would be set to <code>~1.2.3</code> which only allows
+patch upgrades.</p>
+<h4 id="save-prod"><code>save-prod</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Save installed packages into <code>dependencies</code> specifically. This is useful if
+a package already exists in <code>devDependencies</code> or <code>optionalDependencies</code>, but
+you want to move it to be a non-optional production dependency.</p>
+<p>This is the default behavior if <code>--save</code> is true, and neither <code>--save-dev</code>
+or <code>--save-optional</code> are true.</p>
+<p>This config cannot be used with: <code>save-dev</code>, <code>save-optional</code>, <code>save-peer</code></p>
+<h4 id="sbom-format"><code>sbom-format</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: "cyclonedx" or "spdx"</li>
+</ul>
+<p>SBOM format to use when generating SBOMs.</p>
+<h4 id="sbom-type"><code>sbom-type</code></h4>
+<ul>
+<li>Default: "library"</li>
+<li>Type: "library", "application", or "framework"</li>
+</ul>
+<p>The type of package described by the generated SBOM. For SPDX, this is the
+value for the <code>primaryPackagePurpose</code> field. For CycloneDX, this is the
+value for the <code>type</code> field.</p>
+<h4 id="scope"><code>scope</code></h4>
+<ul>
+<li>Default: the scope of the current project, if any, or ""</li>
+<li>Type: String</li>
+</ul>
+<p>Associate an operation with a scope for a scoped registry.</p>
+<p>Useful when logging in to or out of a private registry:</p>
+<pre><code># log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+</code></pre>
+<p>This will cause <code>@mycorp</code> to be mapped to the registry for future
+installation of packages specified according to the pattern
+<code>@mycorp/package</code>.</p>
+<p>This will also cause <code>npm init</code> to create a scoped package.</p>
+<pre><code># accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+</code></pre>
+<h4 id="scopes"><code>scopes</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String (can be set multiple times)</li>
+</ul>
+<p>When creating a Granular Access Token with <code>npm token create</code>, this limits
+the token access to specific scopes. Provide a scope name (with or without @
+prefix).</p>
+<h4 id="script-shell"><code>script-shell</code></h4>
+<ul>
+<li>Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows</li>
+<li>Type: null or String</li>
+</ul>
+<p>The shell to use for scripts run with the <code>npm exec</code>, <code>npm run</code> and <code>npm init &lt;package-spec&gt;</code> commands.</p>
+<h4 id="searchexclude"><code>searchexclude</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>Space-separated options that limit the results from search.</p>
+<h4 id="searchlimit"><code>searchlimit</code></h4>
+<ul>
+<li>Default: 20</li>
+<li>Type: Number</li>
+</ul>
+<p>Number of items to limit search results to. Will not apply at all to legacy
+searches.</p>
+<h4 id="searchopts"><code>searchopts</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+</ul>
+<p>Space-separated options that are always passed to search.</p>
+<h4 id="searchstaleness"><code>searchstaleness</code></h4>
+<ul>
+<li>Default: 900</li>
+<li>Type: Number</li>
+</ul>
+<p>The age of the cache, in seconds, before another registry request is made if
+using legacy search endpoint.</p>
+<h4 id="shell"><code>shell</code></h4>
+<ul>
+<li>Default: SHELL environment variable, or "bash" on Posix, or "cmd.exe" on
+Windows</li>
+<li>Type: String</li>
+</ul>
+<p>The shell to run for the <code>npm explore</code> command.</p>
+<h4 id="sign-git-commit"><code>sign-git-commit</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, then the <code>npm version</code> command will commit the new package
+version using <code>-S</code> to add a signature.</p>
+<p>Note that git requires you to have set up GPG keys in your git configs for
+this to work properly.</p>
+<h4 id="sign-git-tag"><code>sign-git-tag</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, then the <code>npm version</code> command will tag the version using
+<code>-s</code> to add a signature.</p>
+<p>Note that git requires you to have set up GPG keys in your git configs for
+this to work properly.</p>
+<h4 id="strict-peer-deps"><code>strict-peer-deps</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to <code>true</code>, and <code>--legacy-peer-deps</code> is not set, then <em>any</em>
+conflicting <code>peerDependencies</code> will be treated as an install failure, even
+if npm could reasonably guess the appropriate resolution based on non-peer
+dependency relationships.</p>
+<p>By default, conflicting <code>peerDependencies</code> deep in the dependency graph will
+be resolved using the nearest non-peer dependency specification, even if
+doing so will result in some packages receiving a peer dependency outside
+the range set in their package's <code>peerDependencies</code> object.</p>
+<p>When such an override is performed, a warning is printed, explaining the
+conflict and the packages involved. If <code>--strict-peer-deps</code> is set, then
+this warning is treated as a failure.</p>
+<h4 id="strict-ssl"><code>strict-ssl</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Whether or not to do SSL key validation when making requests to the registry
+via https.</p>
+<p>See also the <code>ca</code> config.</p>
+<h4 id="tag"><code>tag</code></h4>
+<ul>
+<li>Default: "latest"</li>
+<li>Type: String</li>
+</ul>
+<p>If you ask npm to install a package and don't tell it a specific version,
+then it will install the specified tag.</p>
+<p>It is the tag added to the package@version specified in the <code>npm dist-tag add</code> command, if no explicit tag is given.</p>
+<p>When used by the <code>npm diff</code> command, this is the tag used to fetch the
+tarball that will be compared with the local files by default.</p>
+<p>If used in the <code>npm publish</code> command, this is the tag that will be added to
+the package submitted to the registry.</p>
+<h4 id="tag-version-prefix"><code>tag-version-prefix</code></h4>
+<ul>
+<li>Default: "v"</li>
+<li>Type: String</li>
+</ul>
+<p>If set, alters the prefix used when tagging a new version when performing a
+version increment using <code>npm version</code>. To remove the prefix altogether, set
+it to the empty string: <code>""</code>.</p>
+<p>Because other tools may rely on the convention that npm version tags look
+like <code>v1.0.0</code>, <em>only use this property if it is absolutely necessary</em>. In
+particular, use care when overriding this setting for public packages.</p>
+<h4 id="timing"><code>timing</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, writes timing information to a process specific json file in the
+cache or <code>logs-dir</code>. The file name ends with <code>-timing.json</code>.</p>
+<p>You can quickly view it with this <a href="https://npm.im/json">json</a> command line:
+<code>cat ~/.npm/_logs/*-timing.json | npm exec -- json -g</code>.</p>
+<p>Timing information will also be reported in the terminal. To suppress this
+while still writing the timing file, use <code>--silent</code>.</p>
+<h4 id="token-description"><code>token-description</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+</ul>
+<p>Description text for the token when using <code>npm token create</code>.</p>
+<h4 id="umask"><code>umask</code></h4>
+<ul>
+<li>Default: 0</li>
+<li>Type: Octal numeric string in range 0000..0777 (0..511)</li>
+</ul>
+<p>The "umask" value to use when setting the file creation mode on files and
+folders.</p>
+<p>Folders and executables are given a mode which is <code>0o777</code> masked against
+this value. Other files are given a mode which is <code>0o666</code> masked against
+this value.</p>
+<p>Note that the underlying system will <em>also</em> apply its own umask value to
+files and folders that are created, and npm does not circumvent this, but
+rather adds the <code>--umask</code> config to it.</p>
+<p>Thus, the effective default umask value on most POSIX systems is 0o22,
+meaning that folders and executables are created with a mode of 0o755 and
+other files are created with a mode of 0o644.</p>
+<h4 id="unicode"><code>unicode</code></h4>
+<ul>
+<li>Default: false on windows, true on mac/unix systems with a unicode locale,
+as defined by the <code>LC_ALL</code>, <code>LC_CTYPE</code>, or <code>LANG</code> environment variables.</li>
+<li>Type: Boolean</li>
+</ul>
+<p>When set to true, npm uses unicode characters in the tree output. When
+false, it uses ascii characters instead of unicode glyphs.</p>
+<h4 id="update-notifier"><code>update-notifier</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Set to false to suppress the update notification when using an older version
+of npm than the latest.</p>
+<h4 id="usage"><code>usage</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>Show short usage output about the command specified.</p>
+<h4 id="user-agent"><code>user-agent</code></h4>
+<ul>
+<li>Default: "npm/{npm-version} node/{node-version} {platform} {arch}
+workspaces/{workspaces} {ci}"</li>
+<li>Type: String</li>
+</ul>
+<p>Sets the User-Agent request header. The following fields are replaced with
+their actual counterparts:</p>
+<ul>
+<li><code>{npm-version}</code> - The npm version in use</li>
+<li><code>{node-version}</code> - The Node.js version in use</li>
+<li><code>{platform}</code> - The value of <code>process.platform</code></li>
+<li><code>{arch}</code> - The value of <code>process.arch</code></li>
+<li><code>{workspaces}</code> - Set to <code>true</code> if the <code>workspaces</code> or <code>workspace</code> options
+are set.</li>
+<li><code>{ci}</code> - The value of the <code>ci-name</code> config, if set, prefixed with <code>ci/</code>, or
+an empty string if <code>ci-name</code> is empty.</li>
+</ul>
+<h4 id="userconfig"><code>userconfig</code></h4>
+<ul>
+<li>Default: "~/.npmrc"</li>
+<li>Type: Path</li>
+</ul>
+<p>The location of user-level configuration settings.</p>
+<p>This may be overridden by the <code>npm_config_userconfig</code> environment variable
+or the <code>--userconfig</code> command line option, but may <em>not</em> be overridden by
+settings in the <code>globalconfig</code> file.</p>
+<h4 id="version"><code>version</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, output the npm version and exit successfully.</p>
+<p>Only relevant when specified explicitly on the command line.</p>
+<h4 id="versions"><code>versions</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If true, output the npm version as well as node's <code>process.versions</code> map and
+the version in the current working directory's <code>package.json</code> file if one
+exists, and exit successfully.</p>
+<p>Only relevant when specified explicitly on the command line.</p>
+<h4 id="viewer"><code>viewer</code></h4>
+<ul>
+<li>Default: "man" on Posix, "browser" on Windows</li>
+<li>Type: String</li>
+</ul>
+<p>The program to use to view help content.</p>
+<p>Set to <code>"browser"</code> to view html help content in the default web browser.</p>
+<h4 id="which"><code>which</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Number</li>
+</ul>
+<p>If there are multiple funding sources, which 1-indexed source URL to open.</p>
+<h4 id="workspace"><code>workspace</code></h4>
+<ul>
+<li>Default:</li>
+<li>Type: String (can be set multiple times)</li>
+</ul>
+<p>Enable running a command in the context of the configured workspaces of the
+current project while filtering by running only the workspaces defined by
+this configuration option.</p>
+<p>Valid values for the <code>workspace</code> config are either:</p>
+<ul>
+<li>Workspace names</li>
+<li>Path to a workspace directory</li>
+<li>Path to a parent workspace directory (will result in selecting all
+workspaces within that folder)</li>
+</ul>
+<p>When set for the <code>npm init</code> command, this may be set to the folder of a
+workspace which does not yet exist, to create the folder and set it up as a
+brand new workspace within the project.</p>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces"><code>workspaces</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Set to true to run the command in the context of <strong>all</strong> configured
+workspaces.</p>
+<p>Explicitly setting this to false will cause commands like <code>install</code> to
+ignore workspaces altogether. When not set explicitly:</p>
+<ul>
+<li>Commands that operate on the <code>node_modules</code> tree (install, update, etc.)
+will link workspaces into the <code>node_modules</code> folder. - Commands that do
+other things (test, exec, publish, etc.) will operate on the root project,
+<em>unless</em> one or more workspaces are specified in the <code>workspace</code> config.</li>
+</ul>
+<p>This value is not exported to the environment for child processes.</p>
+<h4 id="workspaces-update"><code>workspaces-update</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+</ul>
+<p>If set to true, the npm cli will run an update after operations that may
+possibly change the workspaces installed to the <code>node_modules</code> folder.</p>
+<h4 id="yes"><code>yes</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+</ul>
+<p>Automatically answer "yes" to any prompts that npm might print on the
+command line.</p>
+<h4 id="also"><code>also</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "dev", or "development"</li>
+<li>DEPRECATED: Please use --include=dev instead.</li>
+</ul>
+<p>When set to <code>dev</code> or <code>development</code>, this is an alias for <code>--include=dev</code>.</p>
+<h4 id="cache-max"><code>cache-max</code></h4>
+<ul>
+<li>Default: Infinity</li>
+<li>Type: Number</li>
+<li>DEPRECATED: This option has been deprecated in favor of <code>--prefer-online</code></li>
+</ul>
+<p><code>--cache-max=0</code> is an alias for <code>--prefer-online</code></p>
+<h4 id="cache-min"><code>cache-min</code></h4>
+<ul>
+<li>Default: 0</li>
+<li>Type: Number</li>
+<li>DEPRECATED: This option has been deprecated in favor of <code>--prefer-offline</code>.</li>
+</ul>
+<p><code>--cache-min=9999 (or bigger)</code> is an alias for <code>--prefer-offline</code>.</p>
+<h4 id="cert"><code>cert</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+<li>DEPRECATED: <code>key</code> and <code>cert</code> are no longer used for most registry
+operations. Use registry scoped <code>keyfile</code> and <code>certfile</code> instead. Example:
+//other-registry.tld/:keyfile=/path/to/key.pem
+//other-registry.tld/:certfile=/path/to/cert.crt</li>
+</ul>
+<p>A client certificate to pass when accessing the registry. Values should be
+in PEM format (Windows calls it "Base-64 encoded X.509 (.CER)") with
+newlines replaced by the string "\n". For example:</p>
+<pre><code class="language-ini">cert="-----BEGIN CERTIFICATE-----\nXXXX\nXXXX\n-----END CERTIFICATE-----"
+</code></pre>
+<p>It is <em>not</em> the path to a certificate file, though you can set a
+registry-scoped "certfile" path like
+"//other-registry.tld/:certfile=/path/to/cert.pem".</p>
+<h4 id="dev"><code>dev</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: Please use --include=dev instead.</li>
+</ul>
+<p>Alias for <code>--include=dev</code>.</p>
+<h4 id="global-style"><code>global-style</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=shallow</code></li>
+</ul>
+<p>Only install direct dependencies in the top level <code>node_modules</code>, but hoist
+on deeper dependencies. Sets <code>--install-strategy=shallow</code>.</p>
+<h4 id="initauthoremail"><code>init.author.email</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+<li>DEPRECATED: Use <code>--init-author-email</code> instead.</li>
+</ul>
+<p>Alias for <code>--init-author-email</code></p>
+<h4 id="initauthorname"><code>init.author.name</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: String</li>
+<li>DEPRECATED: Use <code>--init-author-name</code> instead.</li>
+</ul>
+<p>Alias for <code>--init-author-name</code></p>
+<h4 id="initauthorurl"><code>init.author.url</code></h4>
+<ul>
+<li>Default: ""</li>
+<li>Type: "" or URL</li>
+<li>DEPRECATED: Use <code>--init-author-url</code> instead.</li>
+</ul>
+<p>Alias for <code>--init-author-url</code></p>
+<h4 id="initlicense"><code>init.license</code></h4>
+<ul>
+<li>Default: "ISC"</li>
+<li>Type: String</li>
+<li>DEPRECATED: Use <code>--init-license</code> instead.</li>
+</ul>
+<p>Alias for <code>--init-license</code></p>
+<h4 id="initmodule"><code>init.module</code></h4>
+<ul>
+<li>Default: "~/.npm-init.js"</li>
+<li>Type: Path</li>
+<li>DEPRECATED: Use <code>--init-module</code> instead.</li>
+</ul>
+<p>Alias for <code>--init-module</code></p>
+<h4 id="initversion"><code>init.version</code></h4>
+<ul>
+<li>Default: "1.0.0"</li>
+<li>Type: SemVer string</li>
+<li>DEPRECATED: Use <code>--init-version</code> instead.</li>
+</ul>
+<p>Alias for <code>--init-version</code></p>
+<h4 id="key"><code>key</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or String</li>
+<li>DEPRECATED: <code>key</code> and <code>cert</code> are no longer used for most registry
+operations. Use registry scoped <code>keyfile</code> and <code>certfile</code> instead. Example:
+//other-registry.tld/:keyfile=/path/to/key.pem
+//other-registry.tld/:certfile=/path/to/cert.crt</li>
+</ul>
+<p>A client key to pass when accessing the registry. Values should be in PEM
+format with newlines replaced by the string "\n". For example:</p>
+<pre><code class="language-ini">key="-----BEGIN PRIVATE KEY-----\nXXXX\nXXXX\n-----END PRIVATE KEY-----"
+</code></pre>
+<p>It is <em>not</em> the path to a key file, though you can set a registry-scoped
+"keyfile" path like "//other-registry.tld/:keyfile=/path/to/key.pem".</p>
+<h4 id="legacy-bundling"><code>legacy-bundling</code></h4>
+<ul>
+<li>Default: false</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: This option has been deprecated in favor of
+<code>--install-strategy=nested</code></li>
+</ul>
+<p>Instead of hoisting package installs in <code>node_modules</code>, install packages in
+the same manner that they are depended on. This may cause very deep
+directory structures and duplicate package installs as there is no
+de-duplicating. Sets <code>--install-strategy=nested</code>.</p>
+<h4 id="only"><code>only</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null, "prod", or "production"</li>
+<li>DEPRECATED: Use <code>--omit=dev</code> to omit dev dependencies from the install.</li>
+</ul>
+<p>When set to <code>prod</code> or <code>production</code>, this is an alias for <code>--omit=dev</code>.</p>
+<h4 id="optional"><code>optional</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+<li>DEPRECATED: Use <code>--omit=optional</code> to exclude optional dependencies, or
+<code>--include=optional</code> to include them.</li>
+</ul>
+<p>Default value does install optional deps unless otherwise omitted.</p>
+<p>Alias for --include=optional or --omit=optional</p>
+<h4 id="production"><code>production</code></h4>
+<ul>
+<li>Default: null</li>
+<li>Type: null or Boolean</li>
+<li>DEPRECATED: Use <code>--omit=dev</code> instead.</li>
+</ul>
+<p>Alias for <code>--omit=dev</code></p>
+<h4 id="shrinkwrap"><code>shrinkwrap</code></h4>
+<ul>
+<li>Default: true</li>
+<li>Type: Boolean</li>
+<li>DEPRECATED: Use the --package-lock setting instead.</li>
+</ul>
+<p>Alias for --package-lock</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../configuring-npm/folders.html">npm folders</a></li>
+<li><a href="../commands/npm.html">npm</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/config.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/dependency-selectors.html b/node/node_modules/npm/docs/output/using-npm/dependency-selectors.html
new file mode 100644
index 0000000000000000000000000000000000000000..6bfd62f84bf809269d25e350a4306eb02c23197f
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/dependency-selectors.html
@@ -0,0 +1,425 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Dependency Selectors</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----dependency-selectors----11130">
+    <span>Dependency Selectors</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Dependency Selector Syntax &amp; Querying</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>The <a href="../commands/npm-query.html"><code>npm query</code></a> command exposes a new dependency selector syntax (informed by &amp; respecting many aspects of the <a href="https://dev.w3.org/csswg/selectors4/#relational">CSS Selectors 4 Spec</a>) which:</p>
+<ul>
+<li>Standardizes the shape of, &amp; querying of, dependency graphs with a robust object model, metadata &amp; selector syntax</li>
+<li>Leverages existing, known language syntax &amp; operators from CSS to make disparate package information broadly accessible</li>
+<li>Unlocks the ability to answer complex, multi-faceted questions about dependencies, their relationships &amp; associative metadata</li>
+<li>Consolidates redundant logic of similar query commands in <code>npm</code> (ex.
+<code>npm fund</code>, <code>npm ls</code>, <code>npm outdated</code>, <code>npm audit</code> ...)</li>
+</ul>
+<h3 id="dependency-selector-syntax">Dependency Selector Syntax</h3>
+<h4 id="overview">Overview:</h4>
+<ul>
+<li>there is no "type" or "tag" selectors (ex.
+<code>div, h1, a</code>) as a dependency/target is the only type of <code>Node</code> that can be queried</li>
+<li>the term "dependencies" is in reference to any <code>Node</code> found in a <code>tree</code> returned by <code>Arborist</code></li>
+</ul>
+<h4 id="combinators">Combinators</h4>
+<ul>
+<li><code>&gt;</code> direct descendant/child</li>
+<li><code> </code> any descendant/child</li>
+<li><code>~</code> sibling</li>
+</ul>
+<h4 id="selectors">Selectors</h4>
+<ul>
+<li><code>*</code> universal selector</li>
+<li><code>#&lt;name&gt;</code> dependency selector (equivalent to <code>[name="..."]</code>)</li>
+<li><code>#&lt;name&gt;@&lt;version&gt;</code> (equivalent to <code>[name=&lt;name&gt;]:semver(&lt;version&gt;)</code>)</li>
+<li><code>,</code> selector list delimiter</li>
+<li><code>.</code> dependency type selector</li>
+<li><code>:</code> pseudo selector</li>
+</ul>
+<h4 id="dependency-type-selectors">Dependency Type Selectors</h4>
+<ul>
+<li><code>.prod</code> dependency found in the <code>dependencies</code> section of <code>package.json</code>, or is a child of said dependency</li>
+<li><code>.dev</code> dependency found in the <code>devDependencies</code> section of <code>package.json</code>, or is a child of said dependency</li>
+<li><code>.optional</code> dependency found in the <code>optionalDependencies</code> section of <code>package.json</code>, or has <code>"optional": true</code> set in its entry in the <code>peerDependenciesMeta</code> section of <code>package.json</code>, or a child of said dependency</li>
+<li><code>.peer</code> dependency found in the <code>peerDependencies</code> section of <code>package.json</code></li>
+<li><code>.workspace</code> dependency found in the <a href="https://docs.npmjs.com/cli/v8/using-npm/workspaces"><code>workspaces</code></a> section of <code>package.json</code></li>
+<li><code>.bundled</code> dependency found in the <code>bundleDependencies</code> section of <code>package.json</code>, or is a child of said dependency</li>
+</ul>
+<h4 id="pseudo-selectors">Pseudo Selectors</h4>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/:not"><code>:not(&lt;selector&gt;)</code></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/:has"><code>:has(&lt;selector&gt;)</code></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/:is"><code>:is(&lt;selector list&gt;)</code></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/:root"><code>:root</code></a> matches the root node/dependency</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/:scope"><code>:scope</code></a> matches node/dependency it was queried against</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/:empty"><code>:empty</code></a> when a dependency has no dependencies</li>
+<li><a href="https://docs.npmjs.com/cli/v8/configuring-npm/package-json#private"><code>:private</code></a> when a dependency is private</li>
+<li><code>:link</code> when a dependency is linked (for instance, workspaces or packages manually <a href="https://docs.npmjs.com/cli/v8/commands/npm-link"><code>linked</code></a></li>
+<li><code>:deduped</code> when a dependency has been deduped (note that this does <em>not</em> always mean the dependency has been hoisted to the root of node_modules)</li>
+<li><code>:overridden</code> when a dependency has been overridden</li>
+<li><code>:extraneous</code> when a dependency exists but is not defined as a dependency of any node</li>
+<li><code>:invalid</code> when a dependency version is out of its ancestors specified range</li>
+<li><code>:missing</code> when a dependency is not found on disk</li>
+<li><code>:semver(&lt;spec&gt;, [selector], [function])</code> match a valid <a href="https://github.com/npm/node-semver"><code>node-semver</code></a> version or range to a selector</li>
+<li><code>:path(&lt;path&gt;)</code> <a href="https://www.npmjs.com/package/glob">glob</a> matching based on dependencies path relative to the project</li>
+<li><code>:type(&lt;type&gt;)</code> <a href="https://github.com/npm/npm-package-arg#result-object">based on currently recognized types</a>.  You can also use the aggregate type of <code>registry</code> for any registry dependency (e.g. tag, version, range, alias)</li>
+<li><code>:outdated(&lt;type&gt;)</code> when a dependency is outdated</li>
+<li><code>:vuln(&lt;selector&gt;)</code> when a dependency has a known vulnerability</li>
+</ul>
+<h5 id="semverspec-selector-function"><code>:semver(&lt;spec&gt;, [selector], [function])</code></h5>
+<p>The <code>:semver()</code> pseudo selector allows comparing fields from each node's <code>package.json</code> using <a href="https://github.com/npm/node-semver#readme">semver</a> methods.
+It accepts up to 3 parameters, all but the first of which are optional.</p>
+<ul>
+<li><code>spec</code> a semver version or range</li>
+<li><code>selector</code> an attribute selector for each node (default <code>[version]</code>)</li>
+<li><code>function</code> a semver method to apply, one of: <code>satisfies</code>, <code>intersects</code>, <code>subset</code>, <code>gt</code>, <code>gte</code>, <code>gtr</code>, <code>lt</code>, <code>lte</code>, <code>ltr</code>, <code>eq</code>, <code>neq</code> or the special function <code>infer</code> (default <code>infer</code>)</li>
+</ul>
+<p>When the special <code>infer</code> function is used the <code>spec</code> and the actual value from the node are compared.
+If both are versions, according to <code>semver.valid()</code>, <code>eq</code> is used.
+If both values are ranges, according to <code>!semver.valid()</code>, <code>intersects</code> is used.
+If the values are mixed types <code>satisfies</code> is used.</p>
+<p>Some examples:</p>
+<ul>
+<li><code>:semver(^1.0.0)</code> returns every node that has a <code>version</code> satisfied by the provided range <code>^1.0.0</code></li>
+<li><code>:semver(16.0.0, :attr(engines, [node]))</code> returns every node which has an <code>engines.node</code> property satisfying the version <code>16.0.0</code></li>
+<li><code>:semver(1.0.0, [version], lt)</code> every node with a <code>version</code> less than <code>1.0.0</code></li>
+</ul>
+<h5 id="outdatedtype"><code>:outdated(&lt;type&gt;)</code></h5>
+<p>The <code>:outdated</code> pseudo selector retrieves data from the registry and returns information about which of your dependencies are outdated.
+The type parameter may be one of the following:</p>
+<ul>
+<li><code>any</code> (default) a version exists that is greater than the current one</li>
+<li><code>in-range</code> a version exists that is greater than the current one, and satisfies at least one if its parent's dependencies</li>
+<li><code>out-of-range</code> a version exists that is greater than the current one, does not satisfy at least one of its parent's dependencies</li>
+<li><code>major</code> a version exists that is a semver major greater than the current one</li>
+<li><code>minor</code> a version exists that is a semver minor greater than the current one</li>
+<li><code>patch</code> a version exists that is a semver patch greater than the current one</li>
+</ul>
+<p>In addition to the filtering performed by the pseudo selector, some extra data is added to the resulting objects.
+The following data can be found under the <code>queryContext</code> property of each node.</p>
+<ul>
+<li><code>versions</code> an array of every available version of the given node</li>
+<li><code>outdated.inRange</code> an array of objects, each with a <code>from</code> and <code>versions</code>, where <code>from</code> is the on-disk location of the node that depends on the current node and <code>versions</code> is an array of all available versions that satisfies that dependency.
+This is only populated if <code>:outdated(in-range)</code> is used.</li>
+<li><code>outdated.outOfRange</code> an array of objects, identical in shape to <code>inRange</code>, but where the <code>versions</code> array is every available version that does not satisfy the dependency.
+This is only populated if <code>:outdated(out-of-range)</code> is used.</li>
+</ul>
+<p>Some examples:</p>
+<ul>
+<li><code>:root &gt; :outdated(major)</code> returns every direct dependency that has a new semver major release</li>
+<li><code>.prod:outdated(in-range)</code> returns production dependencies that have a new release that satisfies at least one of its parent's dependencies</li>
+</ul>
+<h5 id="vuln"><code>:vuln</code></h5>
+<p>The <code>:vuln</code> pseudo selector retrieves data from the registry and returns information about which if your dependencies has a known vulnerability.
+Only dependencies whose current version matches a vulnerability will be returned.
+For example if you have <code>semver@7.6.0</code> in your tree, a vulnerability for <code>semver</code> which affects versions <code>&lt;=6.3.1</code> will not match.</p>
+<p>You can also filter results by certain attributes in advisories.
+Currently that includes <code>severity</code> and <code>cwe</code>.
+Note that severity filtering is done per severity, it does not include severities "higher" or "lower" than the one specified.</p>
+<p>In addition to the filtering performed by the pseudo selector, info about each relevant advisory will be added to the <code>queryContext</code> attribute of each node under the <code>advisories</code> attribute.</p>
+<p>Some examples:</p>
+<ul>
+<li><code>:root &gt; .prod:vuln</code> returns direct production dependencies with any known vulnerability</li>
+<li><code>:vuln([severity=high])</code> returns only dependencies with a vulnerability with a <code>high</code> severity.</li>
+<li><code>:vuln([severity=high],[severity=moderate])</code> returns only dependencies with a vulnerability with a <code>high</code>  or <code>moderate</code> severity.</li>
+<li><code>:vuln([cwe=1333])</code> returns only dependencies with a vulnerability that includes CWE-1333 (ReDoS)</li>
+</ul>
+<h4 id="attribute-selectors"><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors">Attribute Selectors</a></h4>
+<p>The attribute selector evaluates the key/value pairs in <code>package.json</code> if they are <code>String</code>s.</p>
+<ul>
+<li><code>[]</code> attribute selector (ie.
+existence of attribute)</li>
+<li><code>[attribute=value]</code> attribute value is equivalent...</li>
+<li><code>[attribute~=value]</code> attribute value contains word...</li>
+<li><code>[attribute*=value]</code> attribute value contains string...</li>
+<li><code>[attribute|=value]</code> attribute value is equal to or starts with...</li>
+<li><code>[attribute^=value]</code> attribute value starts with...</li>
+<li><code>[attribute$=value]</code> attribute value ends with...</li>
+</ul>
+<h4 id="array--object-attribute-selectors"><code>Array</code> &amp; <code>Object</code> Attribute Selectors</h4>
+<p>The generic <code>:attr()</code> pseudo selector standardizes a pattern which can be used for attribute selection of <code>Object</code>s, <code>Array</code>s or <code>Arrays</code> of <code>Object</code>s accessible via <code>Arborist</code>'s <code>Node.package</code> metadata.
+This allows for iterative attribute selection beyond top-level <code>String</code> evaluation.
+The last argument passed to <code>:attr()</code> must be an <code>attribute</code> selector or a nested <code>:attr()</code>.
+See examples below:</p>
+<h4 id="objects"><code>Objects</code></h4>
+<pre><code class="language-css">/* return dependencies that have a `scripts.test` containing `"tap"` */
+*:attr(scripts, [test~=tap])
+</code></pre>
+<h4 id="nested-objects">Nested <code>Objects</code></h4>
+<p>Nested objects are expressed as sequential arguments to <code>:attr()</code>.</p>
+<pre><code class="language-css">/* return dependencies that have a [testling config](https://ci.testling.com/guide/advanced_configuration) for opera browsers */
+*:attr(testling, browsers, [~=opera])
+</code></pre>
+<h4 id="arrays"><code>Arrays</code></h4>
+<p><code>Array</code>s specifically uses a special/reserved <code>.</code> character in place of a typical attribute name.
+<code>Arrays</code> also support exact <code>value</code> matching when a <code>String</code> is passed to the selector.</p>
+<h5 id="example-of-an-array-attribute-selection">Example of an <code>Array</code> Attribute Selection:</h5>
+<pre><code class="language-css">/* removes the distinction between properties &amp; arrays */
+/* ie. we'd have to check the property &amp; iterate to match selection */
+*:attr([keywords^=react])
+*:attr(contributors, :attr([name~=Jordan]))
+</code></pre>
+<h5 id="example-of-an-array-matching-directly-to-a-value">Example of an <code>Array</code> matching directly to a value:</h5>
+<pre><code class="language-css">/* return dependencies that have the exact keyword "react" */
+/* this is equivalent to `*:keywords([value="react"])` */
+*:attr([keywords=react])
+</code></pre>
+<h5 id="example-of-an-array-of-objects">Example of an <code>Array</code> of <code>Object</code>s:</h5>
+<pre><code class="language-css">/* returns */
+*:attr(contributors, [email=ruyadorno@github.com])
+</code></pre>
+<h3 id="groups">Groups</h3>
+<p>Dependency groups are defined by the package relationships to their ancestors (ie.
+the dependency types that are defined in <code>package.json</code>).
+This approach is user-centric as the ecosystem has been taught to think about dependencies in these groups first-and-foremost.
+Dependencies are allowed to be included in multiple groups (ex.
+a <code>prod</code> dependency may also be a <code>dev</code> dependency (in that it's also required by another <code>dev</code> dependency) &amp; may also be <code>bundled</code> - a selector for that type of dependency would look like: <code>*.prod.dev.bundled</code>).</p>
+<ul>
+<li><code>.prod</code></li>
+<li><code>.dev</code></li>
+<li><code>.optional</code></li>
+<li><code>.peer</code></li>
+<li><code>.bundled</code></li>
+<li><code>.workspace</code></li>
+</ul>
+<p>Please note that currently <code>workspace</code> deps are always <code>prod</code> dependencies.
+Additionally the <code>.root</code> dependency is also considered a <code>prod</code> dependency.</p>
+<h3 id="programmatic-usage">Programmatic Usage</h3>
+<ul>
+<li><code>Arborist</code>'s <code>Node</code> Class has a <code>.querySelectorAll()</code> method
+<ul>
+<li>this method will return a filtered, flattened dependency Arborist <code>Node</code> list based on a valid query selector</li>
+</ul>
+</li>
+</ul>
+<pre><code class="language-js">const Arborist = require('@npmcli/arborist')
+const arb = new Arborist({})
+</code></pre>
+<pre><code class="language-js">// root-level
+arb.loadActual().then(async (tree) =&gt; {
+  // query all production dependencies
+  const results = await tree.querySelectorAll('.prod')
+  console.log(results)
+})
+</code></pre>
+<pre><code class="language-js">// iterative
+arb.loadActual().then(async (tree) =&gt; {
+  // query for the deduped version of react
+  const results = await tree.querySelectorAll('#react:not(:deduped)')
+  // query the deduped react for git deps
+  const deps = await results[0].querySelectorAll(':type(git)')
+  console.log(deps)
+})
+</code></pre>
+<h2 id="see-also">See Also</h2>
+<ul>
+<li><a href="../commands/npm-query.html">npm query</a></li>
+<li><a href="https://npm.im/@npmcli/arborist">@npmcli/arborist</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/dependency-selectors.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/developers.html b/node/node_modules/npm/docs/output/using-npm/developers.html
new file mode 100644
index 0000000000000000000000000000000000000000..207c9b505394633858a320b4225f818fabd80371
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/developers.html
@@ -0,0 +1,375 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Developers</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----developers----11130">
+    <span>Developers</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Developer guide</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#about-these-documents">About These Documents</a></li><li><a href="#what-is-a-package">What is a Package</a></li><li><a href="#the-packagejson-file">The package.json File</a></li><li><a href="#keeping-files-out-of-your-package">Keeping files <em>out</em> of your Package</a></li><ul><li><a href="#testing-whether-your-npmignore-or-files-config-works">Testing whether your <code>.npmignore</code> or <code>files</code> config works</a></li></ul><li><a href="#link-packages">Link Packages</a></li><li><a href="#before-publishing-make-sure-your-package-installs-and-works">Before Publishing: Make Sure Your Package Installs and Works</a></li><li><a href="#create-a-user-account">Create a User Account</a></li><li><a href="#publish-your-package">Publish your Package</a></li><li><a href="#brag-about-it">Brag about it</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>So, you've decided to use npm to develop (and maybe publish/deploy) your project.</p>
+<p>Fantastic!</p>
+<p>There are a few things that you need to do above the simple steps that your users will do to install your program.</p>
+<h3 id="about-these-documents">About These Documents</h3>
+<p>These are man pages.
+If you install npm, you should be able to then do <code>man npm-thing</code> to get the documentation on a particular topic, or <code>npm help thing</code> to see the same information.</p>
+<h3 id="what-is-a-package">What is a Package</h3>
+<p>A package is:</p>
+<ul>
+<li>a) a folder containing a program described by a package.json file</li>
+<li>b) a gzipped tarball containing (a)</li>
+<li>c) a url that resolves to (b)</li>
+<li>d) a <code>&lt;name&gt;@&lt;version&gt;</code> that is published on the registry with (c)</li>
+<li>e) a <code>&lt;name&gt;@&lt;tag&gt;</code> that points to (d)</li>
+<li>f) a <code>&lt;name&gt;</code> that has a "latest" tag satisfying (e)</li>
+<li>g) a <code>git</code> url that, when cloned, results in (a).</li>
+</ul>
+<p>Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).</p>
+<p>Git urls can be of the form:</p>
+<pre><code class="language-bash">git://github.com/user/project.git#commit-ish
+git+ssh://user@hostname:project.git#commit-ish
+git+http://user@hostname/project/blah.git#commit-ish
+git+https://user@hostname/project/blah.git#commit-ish
+</code></pre>
+<p>The <code>commit-ish</code> can be any tag, sha, or branch which can be supplied as an argument to <code>git checkout</code>.
+The default is whatever the repository uses as its default branch.</p>
+<h3 id="the-packagejson-file">The package.json File</h3>
+<p>You need to have a <code>package.json</code> file in the root of your project to do much of anything with npm.
+That is basically the whole interface.</p>
+<p>See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for details about what goes in that file.
+At the very least, you need:</p>
+<ul>
+<li>
+<p>name: This should be a string that identifies your project.
+Please do not use the name to specify that it runs on node, or is in JavaScript.
+You can use the "engines" field to explicitly state the versions of node (or whatever else) that your program requires, and it's pretty well assumed that it's JavaScript.</p>
+<p>It does not necessarily need to match your github repository name.</p>
+<p>So, <code>node-foo</code> and <code>bar-js</code> are bad names.
+<code>foo</code> or <code>bar</code> are better.</p>
+</li>
+<li>
+<p>version: A semver-compatible version.</p>
+</li>
+<li>
+<p>engines: Specify the versions of node (or whatever else) that your program runs on.
+The node API changes a lot, and there may be bugs or new functionality that you depend on.
+Be explicit.</p>
+</li>
+<li>
+<p>author: Take some credit.</p>
+</li>
+<li>
+<p>scripts: If you have a special compilation or installation script, then you should put it in the <code>scripts</code> object.
+You should definitely have at least a basic smoke-test command as the "scripts.test" field.
+See <a href="../using-npm/scripts.html">scripts</a>.</p>
+</li>
+<li>
+<p>main: If you have a single module that serves as the entry point to your program (like what the "foo" package gives you at require("foo")), then you need to specify that in the "main" field.</p>
+</li>
+<li>
+<p>directories: This is an object mapping names to folders.
+The best ones to include are "lib" and "doc", but if you use "man" to specify a folder full of man pages, they'll get installed just like these ones.</p>
+</li>
+</ul>
+<p>You can use <code>npm init</code> in the root of your package in order to get you started with a pretty basic package.json file.
+See <a href="../commands/npm-init.html"><code>npm init</code></a> for more info.</p>
+<h3 id="keeping-files-out-of-your-package">Keeping files <em>out</em> of your Package</h3>
+<p>Use a <code>.npmignore</code> file to keep stuff out of your package.
+If there's no <code>.npmignore</code> file, but there <em>is</em> a <code>.gitignore</code> file, then npm will ignore the stuff matched by the <code>.gitignore</code> file.
+If you <em>want</em> to include something that is excluded by your <code>.gitignore</code> file, you can create an empty <code>.npmignore</code> file to override it.
+Like <code>git</code>, <code>npm</code> looks for <code>.npmignore</code> and <code>.gitignore</code> files in all subdirectories of your package, not only the root directory.</p>
+<p><code>.npmignore</code> files follow the <a href="https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring">same pattern rules</a> as <code>.gitignore</code> files:</p>
+<ul>
+<li>Blank lines or lines starting with <code>#</code> are ignored.</li>
+<li>Standard glob patterns work.</li>
+<li>You can end patterns with a forward slash <code>/</code> to specify a directory.</li>
+<li>You can negate a pattern by starting it with an exclamation point <code>!</code>.</li>
+</ul>
+<p>By default, some paths and files are ignored, so there's no need to add them to <code>.npmignore</code> explicitly.
+Some examples are:</p>
+<ul>
+<li><code>.*.swp</code></li>
+<li><code>._*</code></li>
+<li><code>.DS_Store</code></li>
+<li><code>.git</code></li>
+<li><code>.gitignore</code></li>
+<li><code>.hg</code></li>
+<li><code>.npmignore</code></li>
+<li><code>.npmrc</code></li>
+<li><code>.lock-wscript</code></li>
+<li><code>.svn</code></li>
+<li><code>.wafpickle-*</code></li>
+<li><code>config.gypi</code></li>
+<li><code>CVS</code></li>
+<li><code>npm-debug.log</code></li>
+</ul>
+<p>Additionally, everything in <code>node_modules</code> is ignored, except for bundled dependencies.
+npm automatically handles this for you, so don't bother adding <code>node_modules</code> to <code>.npmignore</code>.</p>
+<p>The following paths and files are never ignored, so adding them to <code>.npmignore</code> is pointless:</p>
+<ul>
+<li><code>package.json</code></li>
+<li><code>README</code> (and its variants)</li>
+<li><code>LICENSE</code> / <code>LICENCE</code></li>
+</ul>
+<p>If, given the structure of your project, you find <code>.npmignore</code> to be a maintenance headache, you might instead try populating the <code>files</code> property of <code>package.json</code>, which is an array of file or directory names that should be included in your package.
+Sometimes manually picking which items to allow is easier to manage than building a block list.</p>
+<p>See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more info on what can and can't be ignored.</p>
+<h4 id="testing-whether-your-npmignore-or-files-config-works">Testing whether your <code>.npmignore</code> or <code>files</code> config works</h4>
+<p>If you want to double check that your package will include only the files you intend it to when published, you can run the <code>npm pack</code> command locally which will generate a tarball in the working directory, the same way it does for publishing.</p>
+<h3 id="link-packages">Link Packages</h3>
+<p><code>npm link</code> is designed to install a development package and see the changes in real time without having to keep re-installing it.
+(You do need to either re-link or <code>npm rebuild -g</code> to update compiled packages, of course.)</p>
+<p>More info at <a href="../commands/npm-link.html"><code>npm link</code></a>.</p>
+<h3 id="before-publishing-make-sure-your-package-installs-and-works">Before Publishing: Make Sure Your Package Installs and Works</h3>
+<p><strong>This is important.</strong></p>
+<p>If you cannot install it locally, you'll have problems trying to publish it.
+Or, worse yet, you'll be able to publish it, but you'll be publishing a broken or pointless package.
+So don't do that.</p>
+<p>In the root of your package, do this:</p>
+<pre><code class="language-bash">npm install . -g
+</code></pre>
+<p>That'll show you that it's working.
+If you'd rather just create a symlink package that points to your working directory, then do this:</p>
+<pre><code class="language-bash">npm link
+</code></pre>
+<p>Use <code>npm ls -g</code> to see if it's there.</p>
+<p>To test a local install, go into some other folder, and then do:</p>
+<pre><code class="language-bash">cd ../some-other-folder
+npm install ../my-package
+</code></pre>
+<p>to install it locally into the node_modules folder in that other place.</p>
+<p>Then go into the node-repl, and try using require("my-thing") to bring in your module's main module.</p>
+<h3 id="create-a-user-account">Create a User Account</h3>
+<p>Create a user with the adduser command.
+It works like this:</p>
+<pre><code class="language-bash">npm adduser
+</code></pre>
+<p>and then follow the prompts.</p>
+<p>This is documented better in <a href="../commands/npm-adduser.html">npm adduser</a>.</p>
+<h3 id="publish-your-package">Publish your Package</h3>
+<p>This part's easy.
+In the root of your folder, do this:</p>
+<pre><code class="language-bash">npm publish
+</code></pre>
+<p>You can give publish a url to a tarball, or a filename of a tarball, or a path to a folder.</p>
+<p>Note that pretty much <strong>everything in that folder will be exposed</strong> by default.
+So, if you have secret stuff in there, use a <code>.npmignore</code> file to list out the globs to ignore, or publish from a fresh checkout.</p>
+<h3 id="brag-about-it">Brag about it</h3>
+<p>Send emails, write blogs, blab in IRC.</p>
+<p>Tell the world how easy it is to install your program!</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm.html">npm</a></li>
+<li><a href="../commands/npm-init.html">npm init</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../using-npm/scripts.html">npm scripts</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-adduser.html">npm adduser</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/developers.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/logging.html b/node/node_modules/npm/docs/output/using-npm/logging.html
new file mode 100644
index 0000000000000000000000000000000000000000..6e31c3df9483c4159f83a721edb60ae546f9af57
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/logging.html
@@ -0,0 +1,284 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Logging</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----logging----11130">
+    <span>Logging</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Why, What &amp; How we Log</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#setting-log-file-location">Setting Log File Location</a></li><li><a href="#setting-log-levels">Setting Log Levels</a></li><ul><li><a href="#loglevel"><code>loglevel</code></a></li><ul><li><a href="#aliases">Aliases</a></li></ul><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li></ul><li><a href="#timing-information">Timing Information</a></li><li><a href="#registry-response-headers">Registry Response Headers</a></li><ul><li><a href="#npm-notice"><code>npm-notice</code></a></li></ul><li><a href="#logs-and-sensitive-information">Logs and Sensitive Information</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>The <code>npm</code> CLI has various mechanisms for showing different levels of information back to end-users for certain commands, configurations &amp; environments.</p>
+<h3 id="setting-log-file-location">Setting Log File Location</h3>
+<p>All logs are written to a debug log, with the path to that file printed if the execution of a command fails.</p>
+<p>The default location of the logs directory is a directory named <code>_logs</code> inside the npm cache.
+This can be changed with the <code>logs-dir</code> config option.</p>
+<p>For example, if you wanted to write all your logs to the current working directory, you could run: <code>npm install --logs-dir=.</code>.
+This is especially helpful in debugging a specific <code>npm</code> issue as you can run a command multiple times with different config values and then diff all the log files.</p>
+<p>Log files will be removed from the <code>logs-dir</code> when the number of log files exceeds <code>logs-max</code>, with the oldest logs being deleted first.</p>
+<p>To turn off logs completely set <code>--logs-max=0</code>.</p>
+<h3 id="setting-log-levels">Setting Log Levels</h3>
+<h4 id="loglevel"><code>loglevel</code></h4>
+<p><code>loglevel</code> is a global argument/config that can be set to determine the type of information to be displayed.</p>
+<p>The default value of <code>loglevel</code> is <code>"notice"</code> but there are several levels/types of logs available, including:</p>
+<ul>
+<li><code>"silent"</code></li>
+<li><code>"error"</code></li>
+<li><code>"warn"</code></li>
+<li><code>"notice"</code></li>
+<li><code>"http"</code></li>
+<li><code>"info"</code></li>
+<li><code>"verbose"</code></li>
+<li><code>"silly"</code></li>
+</ul>
+<p>All logs pertaining to a level preceding the current setting will be shown.</p>
+<h5 id="aliases">Aliases</h5>
+<p>The log levels listed above have various corresponding aliases, including:</p>
+<ul>
+<li><code>-d</code>: <code>--loglevel info</code></li>
+<li><code>--dd</code>: <code>--loglevel verbose</code></li>
+<li><code>--verbose</code>: <code>--loglevel verbose</code></li>
+<li><code>--ddd</code>: <code>--loglevel silly</code></li>
+<li><code>-q</code>: <code>--loglevel warn</code></li>
+<li><code>--quiet</code>: <code>--loglevel warn</code></li>
+<li><code>-s</code>: <code>--loglevel silent</code></li>
+<li><code>--silent</code>: <code>--loglevel silent</code></li>
+</ul>
+<h4 id="foreground-scripts"><code>foreground-scripts</code></h4>
+<p>The <code>npm</code> CLI began hiding the output of lifecycle scripts for <code>npm install</code> as of <code>v7</code>.
+Notably, this means you will not see logs/output from packages that may be using "install scripts" to display information back to you or from your own project's scripts defined in <code>package.json</code>.
+If you'd like to change this behavior &amp; log this output you can set <code>foreground-scripts</code> to <code>true</code>.</p>
+<h3 id="timing-information">Timing Information</h3>
+<p>The <a href="../using-npm/config#timing.html"><code>--timing</code> config</a> can be set which does a few things:</p>
+<ol>
+<li>Always shows the full path to the debug log regardless of command exit status</li>
+<li>Write timing information to a process specific timing file in the cache or <code>logs-dir</code></li>
+<li>Output timing information to the terminal</li>
+</ol>
+<p>This file contains a <code>timers</code> object where the keys are an identifier for the portion of the process being timed and the value is the number of milliseconds it took to complete.</p>
+<p>Sometimes it is helpful to get timing information without outputting anything to the terminal.
+For example, the performance might be affected by writing to the terminal.
+In this case you can use
+<code>--timing --silent</code> which will still write the timing file, but not output anything to the terminal while running.</p>
+<h3 id="registry-response-headers">Registry Response Headers</h3>
+<h4 id="npm-notice"><code>npm-notice</code></h4>
+<p>The <code>npm</code> CLI reads from &amp; logs any <code>npm-notice</code> headers that are returned from the configured registry.
+This mechanism can be used by third-party registries to provide useful information when network-dependent requests occur.</p>
+<p>This header is not cached, and will not be logged if the request is served from the cache.</p>
+<h3 id="logs-and-sensitive-information">Logs and Sensitive Information</h3>
+<p>The <code>npm</code> CLI makes a best effort to redact the following from terminal output and log files:</p>
+<ul>
+<li>Passwords inside basic auth URLs</li>
+<li>npm tokens</li>
+</ul>
+<p>However, this behavior should not be relied on to keep all possible sensitive information redacted.
+If you are concerned about secrets in your log file or terminal output, you can use <code>--loglevel=silent</code> and <code>--logs-max=0</code> to ensure no logs are written to your terminal or filesystem.</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../using-npm/config.html">config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/logging.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/orgs.html b/node/node_modules/npm/docs/output/using-npm/orgs.html
new file mode 100644
index 0000000000000000000000000000000000000000..21deb5eaf1a826e32c58efe43d62d0f8f1709737
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/orgs.html
@@ -0,0 +1,294 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Organizations</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----organizations----11130">
+    <span>Organizations</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Working with teams &amp; organizations</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#team-admins-create-teams">Team Admins create teams</a></li><li><a href="#publish-a-package-and-adjust-package-access">Publish a package and adjust package access</a></li><li><a href="#monitor-your-package-access">Monitor your package access</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>There are three levels of org users:</p>
+<ol>
+<li>Super admin, controls billing &amp; adding people to the org.</li>
+<li>Team admin, manages team membership &amp; package access.</li>
+<li>Developer, works on packages they are given access to.</li>
+</ol>
+<p>The super admin is the only person who can add users to the org because it impacts the monthly bill.
+The super admin will use the website to manage membership.
+Every org has a <code>developers</code> team that all users are automatically added to.</p>
+<p>The team admin is the person who manages team creation, team membership, and package access for teams.
+The team admin grants package access to teams, not individuals.</p>
+<p>The developer will be able to access packages based on the teams they are on.
+Access is either read-write or read-only.</p>
+<p>There are two main commands:</p>
+<ol>
+<li><code>npm team</code> see <a href="../commands/npm-team.html">npm team</a> for more details</li>
+<li><code>npm access</code> see <a href="../commands/npm-access.html">npm access</a> for more details</li>
+</ol>
+<h3 id="team-admins-create-teams">Team Admins create teams</h3>
+<ul>
+<li>Check who you’ve added to your org:</li>
+</ul>
+<pre><code class="language-bash">npm team ls &lt;org&gt;:developers
+</code></pre>
+<ul>
+<li>
+<p>Each org is automatically given a <code>developers</code> team, so you can see the whole list of team members in your org.
+This team automatically gets read-write access to all packages, but you can change that with the <code>access</code> command.</p>
+</li>
+<li>
+<p>Create a new team:</p>
+</li>
+</ul>
+<pre><code class="language-bash">npm team create &lt;org:team&gt;
+</code></pre>
+<ul>
+<li>Add members to that team:</li>
+</ul>
+<pre><code class="language-bash">npm team add &lt;org:team&gt; &lt;user&gt;
+</code></pre>
+<h3 id="publish-a-package-and-adjust-package-access">Publish a package and adjust package access</h3>
+<ul>
+<li>In package directory, run</li>
+</ul>
+<pre><code class="language-bash">npm init --scope=&lt;org&gt;
+</code></pre>
+<p>to scope it for your org &amp; publish as usual</p>
+<ul>
+<li>Grant access:</li>
+</ul>
+<pre><code class="language-bash">npm access grant &lt;read-only|read-write&gt; &lt;org:team&gt; [&lt;package&gt;]
+</code></pre>
+<ul>
+<li>Revoke access:</li>
+</ul>
+<pre><code class="language-bash">npm access revoke &lt;org:team&gt; [&lt;package&gt;]
+</code></pre>
+<h3 id="monitor-your-package-access">Monitor your package access</h3>
+<ul>
+<li>See what org packages a team member can access:</li>
+</ul>
+<pre><code class="language-bash">npm access list packages &lt;org&gt; &lt;user&gt;
+</code></pre>
+<ul>
+<li>See packages available to a specific team:</li>
+</ul>
+<pre><code class="language-bash">npm access list packages &lt;org:team&gt;
+</code></pre>
+<ul>
+<li>Check which teams are collaborating on a package:</li>
+</ul>
+<pre><code class="language-bash">npm access list collaborators &lt;pkg&gt;
+</code></pre>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-team.html">npm team</a></li>
+<li><a href="../commands/npm-access.html">npm access</a></li>
+<li><a href="../using-npm/scope.html">npm scope</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/orgs.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/package-spec.html b/node/node_modules/npm/docs/output/using-npm/package-spec.html
new file mode 100644
index 0000000000000000000000000000000000000000..fe3c0b3bb2ad64c2093bd170e4353484404a6413
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/package-spec.html
@@ -0,0 +1,295 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Package spec</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----package-spec----11130">
+    <span>Package spec</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Package name specifier</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#package-name">Package name</a></li><li><a href="#aliases">Aliases</a></li><li><a href="#folders">Folders</a></li><li><a href="#tarballs">Tarballs</a></li><li><a href="#git-urls">git urls</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>Commands like <code>npm install</code> and the dependency sections in the <code>package.json</code> use a package name specifier.
+This can be many different things that all refer to a "package".  Examples include a package name, git url, tarball, or local directory.
+These will generally be referred to as <code>&lt;package-spec&gt;</code> in the help output for the npm commands that use this package name specifier.</p>
+<h3 id="package-name">Package name</h3>
+<ul>
+<li><code>[&lt;@scope&gt;/]&lt;pkg&gt;</code></li>
+<li><code>[&lt;@scope&gt;/]&lt;pkg&gt;@&lt;tag&gt;</code></li>
+<li><code>[&lt;@scope&gt;/]&lt;pkg&gt;@&lt;version&gt;</code></li>
+<li><code>[&lt;@scope&gt;/]&lt;pkg&gt;@&lt;version range&gt;</code></li>
+</ul>
+<p>Refers to a package by name, with or without a scope, and optionally tag, version, or version range.
+This is typically used in combination with the <a href="../using-npm/config#registry.html">registry</a> config to refer to a package in a registry.</p>
+<p>Examples:</p>
+<ul>
+<li><code>npm</code></li>
+<li><code>@npmcli/arborist</code></li>
+<li><code>@npmcli/arborist@latest</code></li>
+<li><code>npm@6.13.1</code></li>
+<li><code>npm@^4.0.0</code></li>
+</ul>
+<h3 id="aliases">Aliases</h3>
+<ul>
+<li><code>&lt;alias&gt;@npm:&lt;name&gt;</code></li>
+</ul>
+<p>Primarily used by commands like <code>npm install</code> and in the dependency sections in the <code>package.json</code>, this refers to a package by an alias.
+The <code>&lt;alias&gt;</code> is the name of the package as it is reified in the <code>node_modules</code> folder, and the <code>&lt;name&gt;</code> refers to a package name as found in the configured registry.</p>
+<p>See <code>Package name</code> above for more info on referring to a package by name, and <a href="../using-npm/config#registry.html">registry</a> for configuring which registry is used when referring to a package by name.</p>
+<p>Examples:</p>
+<ul>
+<li><code>semver@npm:@npmcli/semver-with-patch</code></li>
+<li><code>semver@npm:semver@7.2.2</code></li>
+<li><code>semver@npm:semver@legacy</code></li>
+</ul>
+<h3 id="folders">Folders</h3>
+<ul>
+<li><code>&lt;folder&gt;</code></li>
+</ul>
+<p>This refers to a package on the local filesystem.
+Specifically this is a folder with a <code>package.json</code> file in it.
+This <em>should</em> always be prefixed with a <code>/</code> or <code>./</code> (or your OS equivalent) to reduce confusion.
+npm currently will parse a string with more than one <code>/</code> in it as a folder, but this is legacy behavior that may be removed in a future version.</p>
+<p>Examples:</p>
+<ul>
+<li><code>./my-package</code></li>
+<li><code>/opt/npm/my-package</code></li>
+</ul>
+<h3 id="tarballs">Tarballs</h3>
+<ul>
+<li><code>&lt;tarball file&gt;</code></li>
+<li><code>&lt;tarball url&gt;</code></li>
+</ul>
+<p>Examples:</p>
+<ul>
+<li><code>./my-package.tgz</code></li>
+<li><code>https://registry.npmjs.org/semver/-/semver-1.0.0.tgz</code></li>
+</ul>
+<p>Refers to a package in a tarball format, either on the local filesystem or remotely via url.
+This is the format that packages exist in when uploaded to a registry.</p>
+<h3 id="git-urls">git urls</h3>
+<ul>
+<li><code>&lt;git:// url&gt;</code></li>
+<li><code>&lt;github username&gt;/&lt;github project&gt;</code></li>
+</ul>
+<p>Refers to a package in a git repo.
+This can be a full git url, git shorthand, or a username/package on GitHub.
+You can specify a git tag, branch, or other git ref by appending <code>#ref</code>.</p>
+<p>Examples:</p>
+<ul>
+<li><code>https://github.com/npm/cli.git</code></li>
+<li><code>git@github.com:npm/cli.git</code></li>
+<li><code>git+ssh://git@github.com/npm/cli#v6.0.0</code></li>
+<li><code>github:npm/cli#HEAD</code></li>
+<li><code>npm/cli#c12ea07</code></li>
+</ul>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="https://npm.im/npm-package-arg">npm-package-arg</a></li>
+<li><a href="../using-npm/scope.html">scope</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/package-spec.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/registry.html b/node/node_modules/npm/docs/output/using-npm/registry.html
new file mode 100644
index 0000000000000000000000000000000000000000..ea1c6a8dde9fc36b99d205ddbe85b36af200a991
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/registry.html
@@ -0,0 +1,255 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Registry</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----registry----11130">
+    <span>Registry</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">The JavaScript Package Registry</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#does-npm-send-any-information-about-me-back-to-the-registry">Does npm send any information about me back to the registry?</a></li><li><a href="#how-can-i-prevent-my-package-from-being-published-in-the-official-registry">How can I prevent my package from being published in the official registry?</a></li><li><a href="#where-can-i-find-my-and-others-published-packages">Where can I find my (and others') published packages?</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>To resolve packages by name and version, npm talks to a registry website that implements the CommonJS Package Registry specification for reading package info.</p>
+<p>npm is configured to use the <strong>npm public registry</strong> at
+<a href="https://registry.npmjs.org">https://registry.npmjs.org</a> by default.
+Use of the npm public registry is subject to terms of use available at <a href="https://docs.npmjs.com/policies/terms">https://docs.npmjs.com/policies/terms</a>.</p>
+<p>You can configure npm to use any compatible registry you like, and even run your own registry.
+Use of someone else's registry may be governed by their terms of use.</p>
+<p>npm's package registry implementation supports several write APIs as well, to allow for publishing packages and managing user account information.</p>
+<p>The registry URL used is determined by the scope of the package (see <a href="../using-npm/scope.html"><code>scope</code></a>.
+If no scope is specified, the default registry is used, which is supplied by the <a href="../using-npm/config#registry.html"><code>registry</code> config</a> parameter.
+See <a href="../commands/npm-config.html"><code>npm config</code></a>, <a href="../configuring-npm/npmrc.html"><code>npmrc</code></a>, and <a href="../using-npm/config.html"><code>config</code></a> for more on managing npm's configuration.
+Authentication configuration such as auth tokens and certificates are configured specifically scoped to an individual registry.
+See <a href="../configuring-npm/npmrc#auth-related-configuration.html">Auth Related Configuration</a></p>
+<p>When the default registry is used in a package-lock or shrinkwrap it has the special meaning of "the currently configured registry". If you create a lock file while using the default registry you can switch to another registry and npm will install packages from the new registry, but if you create a lock file while using a custom registry packages will be installed from that registry even after you change to another registry.</p>
+<h3 id="does-npm-send-any-information-about-me-back-to-the-registry">Does npm send any information about me back to the registry?</h3>
+<p>Yes.</p>
+<p>When making requests of the registry npm adds two headers with information about your environment:</p>
+<ul>
+<li><code>Npm-Scope</code> – If your project is scoped, this header will contain its scope.
+In the future npm hopes to build registry features that use this information to allow you to customize your experience for your organization.</li>
+<li><code>Npm-In-CI</code> – Set to "true" if npm believes this install is running in a continuous integration environment, "false" otherwise.
+This is detected by looking for the following environment variables: <code>CI</code>, <code>TDDIUM</code>,
+<code>JENKINS_URL</code>, <code>bamboo.buildKey</code>.
+If you'd like to learn more you may find the <a href="https://github.com/npm/npm-registry-client/pull/129">original PR</a> interesting.
+This is used to gather better metrics on how npm is used by humans, versus build farms.</li>
+</ul>
+<p>The npm registry does not try to correlate the information in these headers with any authenticated accounts that may be used in the same requests.</p>
+<h3 id="how-can-i-prevent-my-package-from-being-published-in-the-official-registry">How can I prevent my package from being published in the official registry?</h3>
+<p>Set <code>"private": true</code> in your <code>package.json</code> to prevent it from being published at all, or
+<code>"publishConfig":{"registry":"http://my-internal-registry.local"}</code>
+to force it to be published only to your internal/private registry.</p>
+<p>See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more info on what goes in the package.json file.</p>
+<h3 id="where-can-i-find-my-and-others-published-packages">Where can I find my (and others') published packages?</h3>
+<p><a href="https://www.npmjs.com/">https://www.npmjs.com/</a></p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-config.html">npm config</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+<li><a href="../configuring-npm/npmrc.html">npmrc</a></li>
+<li><a href="../using-npm/developers.html">npm developers</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/registry.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/removal.html b/node/node_modules/npm/docs/output/using-npm/removal.html
new file mode 100644
index 0000000000000000000000000000000000000000..989e67c0338f26065626dd5fec846c27ef0a684e
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/removal.html
@@ -0,0 +1,245 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Removal</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----removal----11130">
+    <span>Removal</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Cleaning the slate</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#more-severe-uninstalling">More Severe Uninstalling</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<p>So sad to see you go.</p>
+<pre><code class="language-bash">sudo npm uninstall npm -g
+</code></pre>
+<p>Or, if that fails, please proceed to more severe uninstalling methods.</p>
+<h3 id="more-severe-uninstalling">More Severe Uninstalling</h3>
+<p>Usually, the above instructions are sufficient.
+That will remove npm, but leave behind anything you've installed.</p>
+<p>If that doesn't work, or if you require more drastic measures, continue reading.</p>
+<p>Note that this is only necessary for globally-installed packages.
+Local installs are completely contained within a project's <code>node_modules</code> folder.
+Delete that folder, and everything is gone unless a package's install script is particularly ill-behaved.</p>
+<p>This assumes that you installed node and npm in the default place.
+If you configured node with a different <code>--prefix</code>, or installed npm with a different prefix setting, then adjust the paths accordingly, replacing
+<code>/usr/local</code> with your install prefix.</p>
+<p>To remove everything npm-related manually:</p>
+<pre><code class="language-bash">rm -rf /usr/local/{lib/node{,/.npm,_modules},bin,share/man}/npm*
+</code></pre>
+<p>If you installed things <em>with</em> npm, then your best bet is to uninstall them with npm first, and then install them again once you have a proper install.
+This can help find any symlinks that are lying around:</p>
+<pre><code class="language-bash">ls -laF /usr/local/{lib/node{,/.npm},bin,share/man} | grep npm
+</code></pre>
+<p>Prior to version 0.3, npm used shim files for executables and node modules.
+To track those down, you can do the following:</p>
+<pre><code class="language-bash">find /usr/local/{lib/node,bin} -exec grep -l npm \{\} \; ;
+</code></pre>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-uninstall.html">npm uninstall</a></li>
+<li><a href="../commands/npm-prune.html">npm prune</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/removal.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/scope.html b/node/node_modules/npm/docs/output/using-npm/scope.html
new file mode 100644
index 0000000000000000000000000000000000000000..91aad31d83d33e980073c06bc3b00acb9caa30c4
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/scope.html
@@ -0,0 +1,290 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Scope</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----scope----11130">
+    <span>Scope</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Scoped packages</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#installing-scoped-packages">Installing scoped packages</a></li><li><a href="#requiring-scoped-packages">Requiring scoped packages</a></li><li><a href="#publishing-scoped-packages">Publishing scoped packages</a></li><ul><li><a href="#publishing-public-scoped-packages-to-the-primary-npm-registry">Publishing public scoped packages to the primary npm registry</a></li><li><a href="#publishing-private-scoped-packages-to-the-npm-registry">Publishing private scoped packages to the npm registry</a></li></ul><li><a href="#associating-a-scope-with-a-registry">Associating a scope with a registry</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>All npm packages have a name.
+Some package names also have a scope.
+A scope follows the usual rules for package names (URL-safe characters, no leading dots or underscores).
+When used in package names, scopes are preceded by an <code>@</code> symbol and followed by a slash, e.g.</p>
+<pre><code class="language-bash">@somescope/somepackagename
+</code></pre>
+<p>Scopes are a way of grouping related packages together, and also affect a few things about the way npm treats the package.</p>
+<p>Each npm user/organization has their own scope, and only you can add packages in your scope.
+This means you don't have to worry about someone taking your package name ahead of you.
+Thus it is also a good way to signal official packages for organizations.</p>
+<p>Scoped packages can be published and installed as of <code>npm@2</code> and are supported by the primary npm registry.
+Unscoped packages can depend on scoped packages and vice versa.
+The npm client is backwards-compatible with unscoped registries, so it can be used to work with scoped and unscoped registries at the same time.</p>
+<h3 id="installing-scoped-packages">Installing scoped packages</h3>
+<p>Scoped packages are installed to a sub-folder of the regular installation folder, e.g. if your other packages are installed in <code>node_modules/packagename</code>, scoped modules will be installed in <code>node_modules/@myorg/packagename</code>.
+The scope folder (<code>@myorg</code>) is simply the name of the scope preceded by an <code>@</code> symbol, and can contain any number of scoped packages.</p>
+<p>A scoped package is installed by referencing it by name, preceded by an
+<code>@</code> symbol, in <code>npm install</code>:</p>
+<pre><code class="language-bash">npm install @myorg/mypackage
+</code></pre>
+<p>Or in <code>package.json</code>:</p>
+<pre><code class="language-json">"dependencies": {
+  "@myorg/mypackage": "^1.3.0"
+}
+</code></pre>
+<p>Note that if the <code>@</code> symbol is omitted, in either case, npm will instead attempt to install from GitHub; see <a href="../commands/npm-install.html"><code>npm install</code></a>.</p>
+<h3 id="requiring-scoped-packages">Requiring scoped packages</h3>
+<p>Because scoped packages are installed into a scope folder, you have to include the name of the scope when requiring them in your code, e.g.</p>
+<pre><code class="language-javascript">require('@myorg/mypackage')
+</code></pre>
+<p>There is nothing special about the way Node treats scope folders.
+This simply requires the <code>mypackage</code> module in the folder named <code>@myorg</code>.</p>
+<h3 id="publishing-scoped-packages">Publishing scoped packages</h3>
+<p>Scoped packages can be published from the CLI as of <code>npm@2</code> and can be published to any registry that supports them, including the primary npm registry.</p>
+<p>(As of 2015-04-19, and with npm 2.0 or better, the primary npm registry
+<strong>does</strong> support scoped packages.)</p>
+<p>If you wish, you may associate a scope with a registry; see below.</p>
+<h4 id="publishing-public-scoped-packages-to-the-primary-npm-registry">Publishing public scoped packages to the primary npm registry</h4>
+<p>Publishing to a scope, you have two options:</p>
+<ul>
+<li>Publishing to your user scope (example: <code>@username/module</code>)</li>
+<li>Publishing to an organization scope (example: <code>@org/module</code>)</li>
+</ul>
+<p>If publishing a public module to an organization scope, you must first either create an organization with the name of the scope that you'd like to publish to or be added to an existing organization with the appropriate permissions.
+For example, if you'd like to publish to <code>@org</code>, you would  need to create the <code>org</code> organization on npmjs.com prior to trying to publish.</p>
+<p>Scoped packages are not public by default.
+You will need to specify
+<code>--access public</code> with the initial <code>npm publish</code> command.
+This will publish the package and set access to <code>public</code> as if you had run <code>npm access public</code> after publishing.
+You do not need to do this when publishing new versions of an existing scoped package.</p>
+<h4 id="publishing-private-scoped-packages-to-the-npm-registry">Publishing private scoped packages to the npm registry</h4>
+<p>To publish a private scoped package to the npm registry, you must have an <a href="https://docs.npmjs.com/private-modules/intro">npm Private Modules</a> account.</p>
+<p>You can then publish the module with <code>npm publish</code> or <code>npm publish --access restricted</code>, and it will be present in the npm registry, with restricted access.
+You can then change the access permissions, if desired, with <code>npm access</code> or on the npmjs.com website.</p>
+<h3 id="associating-a-scope-with-a-registry">Associating a scope with a registry</h3>
+<p>Scopes can be associated with a separate registry.
+This allows you to seamlessly use a mix of packages from the primary npm registry and one or more private registries, such as <a href="https://github.com/features/packages">GitHub Packages</a> or the open source <a href="https://verdaccio.org">Verdaccio</a> project.</p>
+<p>You can associate a scope with a registry at login, e.g.</p>
+<pre><code class="language-bash">npm login --registry=http://reg.example.com --scope=@myco
+</code></pre>
+<p>Scopes have a many-to-one relationship with registries: one registry can host multiple scopes, but a scope only ever points to one registry.</p>
+<p>You can also associate a scope with a registry using <code>npm config</code>:</p>
+<pre><code class="language-bash">npm config set @myco:registry=http://reg.example.com
+</code></pre>
+<p>Once a scope is associated with a registry, any <code>npm install</code> for a package with that scope will request packages from that registry instead.
+Any
+<code>npm publish</code> for a package name that contains the scope will be published to
+that registry instead.</p>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-access.html">npm access</a></li>
+<li><a href="../using-npm/registry.html">npm registry</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/scope.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/scripts.html b/node/node_modules/npm/docs/output/using-npm/scripts.html
new file mode 100644
index 0000000000000000000000000000000000000000..3a4f64fe67c0e66d8748aab98133d82f6d476a71
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/scripts.html
@@ -0,0 +1,533 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Scripts</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----scripts----11130">
+    <span>Scripts</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">How npm handles the "scripts" field</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#pre--post-scripts">Pre &amp; Post Scripts</a></li><li><a href="#life-cycle-scripts">Life Cycle Scripts</a></li><ul><li><a href="#prepare-and-prepublish">Prepare and Prepublish</a></li><li><a href="#dependencies">Dependencies</a></li></ul><li><a href="#life-cycle-operation-order">Life Cycle Operation Order</a></li><ul><li><a href="#npm-cache-add"><a href="../commands/npm-cache.html"><code>npm cache add</code></a></a></li><li><a href="#npm-ci"><a href="../commands/npm-ci.html"><code>npm ci</code></a></a></li><li><a href="#npm-diff"><a href="../commands/npm-diff.html"><code>npm diff</code></a></a></li><li><a href="#npm-install"><a href="../commands/npm-install.html"><code>npm install</code></a></a></li><li><a href="#npm-pack"><a href="../commands/npm-pack.html"><code>npm pack</code></a></a></li><li><a href="#npm-publish"><a href="../commands/npm-publish.html"><code>npm publish</code></a></a></li><li><a href="#npm-rebuild"><a href="../commands/npm-rebuild.html"><code>npm rebuild</code></a></a></li><li><a href="#npm-restart"><a href="../commands/npm-restart.html"><code>npm restart</code></a></a></li><li><a href="#npm-run-user-defined"><a href="../commands/npm-run.html"><code>npm run &lt;user defined&gt;</code></a></a></li><li><a href="#npm-start"><a href="../commands/npm-start.html"><code>npm start</code></a></a></li><li><a href="#npm-stop"><a href="../commands/npm-stop.html"><code>npm stop</code></a></a></li><li><a href="#npm-test"><a href="../commands/npm-test.html"><code>npm test</code></a></a></li><li><a href="#npm-version"><a href="../commands/npm-version.html"><code>npm version</code></a></a></li><li><a href="#a-note-on-a-lack-of-npm-uninstall-scripts">A Note on a lack of <a href="../commands/npm-uninstall.html"><code>npm uninstall</code></a> scripts</a></li></ul><li><a href="#working-directory-for-scripts">Working Directory for Scripts</a></li><ul><li><a href="#historical-behavior-in-older-npm-versions">Historical Behavior in Older npm Versions</a></li></ul><li><a href="#environment">Environment</a></li><ul><li><a href="#path">path</a></li><li><a href="#packagejson-vars">package.json vars</a></li><li><a href="#current-lifecycle-event">current lifecycle event</a></li></ul><li><a href="#examples">Examples</a></li><li><a href="#exiting">Exiting</a></li><li><a href="#best-practices">Best Practices</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p>The <code>"scripts"</code> property of your <code>package.json</code> file supports a number of built-in scripts and their preset life cycle events as well as arbitrary scripts.
+These all can be executed by running <code>npm run &lt;stage&gt;</code>.
+<em>Pre</em> and <em>post</em> commands with matching names will be run for those as well (e.g.
+<code>premyscript</code>,
+<code>myscript</code>, <code>postmyscript</code>).
+Scripts from dependencies can be run with <code>npm explore &lt;pkg&gt; -- npm run &lt;stage&gt;</code>.</p>
+<h3 id="pre--post-scripts">Pre &amp; Post Scripts</h3>
+<p>To create "pre" or "post" scripts for any scripts defined in the
+<code>"scripts"</code> section of the <code>package.json</code>, simply create another script
+<em>with a matching name</em> and add "pre" or "post" to the beginning of them.</p>
+<pre><code class="language-json">{
+  "scripts": {
+    "precompress": "{{ executes BEFORE the `compress` script }}",
+    "compress": "{{ run command to compress files }}",
+    "postcompress": "{{ executes AFTER `compress` script }}"
+  }
+}
+</code></pre>
+<p>In this example <code>npm run compress</code> would execute these scripts as described.</p>
+<h3 id="life-cycle-scripts">Life Cycle Scripts</h3>
+<p>There are some special life cycle scripts that happen only in certain situations.
+These scripts happen in addition to the <code>pre&lt;event&gt;</code>, <code>post&lt;event&gt;</code>, and
+<code>&lt;event&gt;</code> scripts.</p>
+<ul>
+<li><code>prepare</code>, <code>prepublish</code>, <code>prepublishOnly</code>, <code>prepack</code>, <code>postpack</code>, <code>dependencies</code></li>
+</ul>
+<p><strong>prepare</strong> (since <code>npm@4.0.0</code>)</p>
+<ul>
+<li>
+<p>Runs BEFORE the package is packed, i.e.
+during <code>npm publish</code> and <code>npm pack</code></p>
+</li>
+<li>
+<p>Runs on local <code>npm install</code> without package arguments (runs with flags like <code>--production</code> or <code>--omit=dev</code>, but does not run when installing specific packages like <code>npm install express</code>)</p>
+</li>
+<li>
+<p>Runs AFTER <code>prepublishOnly</code> and <code>prepack</code>, but BEFORE <code>postpack</code></p>
+</li>
+<li>
+<p>Runs for a package if it's being installed as a link through <code>npm install &lt;folder&gt;</code></p>
+</li>
+<li>
+<p>NOTE: If a package being installed through git contains a <code>prepare</code> script, its <code>dependencies</code> and <code>devDependencies</code> will be installed, and the prepare script will be run, before the package is packaged and installed.</p>
+</li>
+<li>
+<p>As of <code>npm@7</code> these scripts run in the background.
+To see the output, run with: <code>--foreground-scripts</code>.</p>
+</li>
+<li>
+<p><strong>In workspaces, prepare scripts run concurrently</strong> across all packages. If you have interdependent packages where one must build before another, consider using <code>--foreground-scripts</code> (which can be set in <code>.npmrc</code> with <code>foreground-scripts=true</code>) to run scripts sequentially, or structure your build differently.</p>
+</li>
+</ul>
+<p><strong>prepublish</strong> (DEPRECATED)</p>
+<ul>
+<li>Does not run during <code>npm publish</code>, but does run during <code>npm ci</code> and <code>npm install</code>.
+See below for more info.</li>
+</ul>
+<p><strong>prepublishOnly</strong></p>
+<ul>
+<li>Runs BEFORE the package is prepared and packed, ONLY on <code>npm publish</code>.</li>
+</ul>
+<p><strong>prepack</strong></p>
+<ul>
+<li>Runs BEFORE a tarball is packed (on "<code>npm pack</code>", "<code>npm publish</code>", and when installing a git dependency).</li>
+<li>NOTE: "<code>npm run pack</code>" is NOT the same as "<code>npm pack</code>". "<code>npm run pack</code>" is an arbitrary user defined script name, whereas, "<code>npm pack</code>" is a CLI defined command.</li>
+</ul>
+<p><strong>postpack</strong></p>
+<ul>
+<li>Runs AFTER the tarball has been generated but before it is moved to its final destination (if at all, publish does not save the tarball locally)</li>
+</ul>
+<p><strong>dependencies</strong></p>
+<ul>
+<li>Runs AFTER any operations that modify the <code>node_modules</code> directory IF changes occurred.</li>
+<li>Does NOT run in global mode</li>
+</ul>
+<h4 id="prepare-and-prepublish">Prepare and Prepublish</h4>
+<p><strong>Deprecation Note: prepublish</strong></p>
+<p>Since <code>npm@1.1.71</code>, the npm CLI has run the <code>prepublish</code> script for both <code>npm publish</code> and <code>npm install</code>, because it's a convenient way to prepare a package for use (some common use cases are described in the section below).
+It has also turned out to be, in practice, <a href="https://github.com/npm/npm/issues/10074">very confusing</a>.
+As of <code>npm@4.0.0</code>, a new event has been introduced, <code>prepare</code>, that preserves this existing behavior.
+A <em>new</em> event, <code>prepublishOnly</code> has been added as a transitional strategy to allow users to avoid the confusing behavior of existing npm versions and only run on <code>npm publish</code> (for instance, running the tests one last time to ensure they're in good shape).</p>
+<p>See <a href="https://github.com/npm/npm/issues/10074">https://github.com/npm/npm/issues/10074</a> for a much lengthier justification, with further reading, for this change.</p>
+<p><strong>Use Cases</strong></p>
+<p>Use a <code>prepare</code> script to perform build tasks that are platform-independent and need to run before your package is used.
+This includes tasks such as:</p>
+<ul>
+<li>Compiling TypeScript or other source code into JavaScript.</li>
+<li>Creating minified versions of JavaScript source code.</li>
+<li>Fetching remote resources that your package will use.</li>
+</ul>
+<p>Running these build tasks in the <code>prepare</code> script ensures they happen once, in a single place, reducing complexity and variability.
+Additionally, this means that:</p>
+<ul>
+<li>You can depend on build tools as <code>devDependencies</code>, and thus your users don't need to have them installed.</li>
+<li>You don't need to include minifiers in your package, reducing the size for your users.</li>
+<li>You don't need to rely on your users having <code>curl</code> or <code>wget</code> or other system tools on the target machines.</li>
+</ul>
+<h4 id="dependencies">Dependencies</h4>
+<p>The <code>dependencies</code> script is run any time an <code>npm</code> command causes changes to the <code>node_modules</code> directory.
+It is run AFTER the changes have been applied and the <code>package.json</code> and <code>package-lock.json</code> files have been updated.</p>
+<h3 id="life-cycle-operation-order">Life Cycle Operation Order</h3>
+<h4 id="npm-cache-add"><a href="../commands/npm-cache.html"><code>npm cache add</code></a></h4>
+<ul>
+<li><code>prepare</code></li>
+</ul>
+<h4 id="npm-ci"><a href="../commands/npm-ci.html"><code>npm ci</code></a></h4>
+<ul>
+<li><code>preinstall</code></li>
+<li><code>install</code></li>
+<li><code>postinstall</code></li>
+<li><code>prepublish</code></li>
+<li><code>preprepare</code></li>
+<li><code>prepare</code></li>
+<li><code>postprepare</code></li>
+</ul>
+<p>These all run after the actual installation of modules into
+<code>node_modules</code>, in order, with no internal actions happening in between</p>
+<h4 id="npm-diff"><a href="../commands/npm-diff.html"><code>npm diff</code></a></h4>
+<ul>
+<li><code>prepare</code></li>
+</ul>
+<h4 id="npm-install"><a href="../commands/npm-install.html"><code>npm install</code></a></h4>
+<p>These also run when you run <code>npm install -g &lt;pkg-name&gt;</code></p>
+<ul>
+<li><code>preinstall</code></li>
+<li><code>install</code></li>
+<li><code>postinstall</code></li>
+<li><code>prepublish</code></li>
+<li><code>preprepare</code></li>
+<li><code>prepare</code></li>
+<li><code>postprepare</code></li>
+</ul>
+<p>If there is a <code>binding.gyp</code> file in the root of your package and you haven't defined your own <code>install</code> or <code>preinstall</code> scripts, npm will default the <code>install</code> command to compile using node-gyp via <code>node-gyp rebuild</code></p>
+<p>These are run from the scripts of <code>&lt;pkg-name&gt;</code></p>
+<h4 id="npm-pack"><a href="../commands/npm-pack.html"><code>npm pack</code></a></h4>
+<ul>
+<li><code>prepack</code></li>
+<li><code>prepare</code></li>
+<li><code>postpack</code></li>
+</ul>
+<h4 id="npm-publish"><a href="../commands/npm-publish.html"><code>npm publish</code></a></h4>
+<ul>
+<li><code>prepublishOnly</code></li>
+<li><code>prepack</code></li>
+<li><code>prepare</code></li>
+<li><code>postpack</code></li>
+<li><code>publish</code></li>
+<li><code>postpublish</code></li>
+</ul>
+<h4 id="npm-rebuild"><a href="../commands/npm-rebuild.html"><code>npm rebuild</code></a></h4>
+<ul>
+<li><code>preinstall</code></li>
+<li><code>install</code></li>
+<li><code>postinstall</code></li>
+<li><code>prepare</code></li>
+</ul>
+<p><code>prepare</code> is only run if the current directory is a symlink (e.g.
+with linked packages)</p>
+<h4 id="npm-restart"><a href="../commands/npm-restart.html"><code>npm restart</code></a></h4>
+<p>If there is a <code>restart</code> script defined, these events are run; otherwise,
+<code>stop</code> and <code>start</code> are both run if present, including their <code>pre</code> and <code>post</code> iterations)</p>
+<ul>
+<li><code>prerestart</code></li>
+<li><code>restart</code></li>
+<li><code>postrestart</code></li>
+</ul>
+<h4 id="npm-run-user-defined"><a href="../commands/npm-run.html"><code>npm run &lt;user defined&gt;</code></a></h4>
+<ul>
+<li><code>pre&lt;user-defined&gt;</code></li>
+<li><code>&lt;user-defined&gt;</code></li>
+<li><code>post&lt;user-defined&gt;</code></li>
+</ul>
+<h4 id="npm-start"><a href="../commands/npm-start.html"><code>npm start</code></a></h4>
+<ul>
+<li><code>prestart</code></li>
+<li><code>start</code></li>
+<li><code>poststart</code></li>
+</ul>
+<p>If there is a <code>server.js</code> file in the root of your package, then npm will default the <code>start</code> command to <code>node server.js</code>.
+<code>prestart</code> and <code>poststart</code> will still run in this case.</p>
+<h4 id="npm-stop"><a href="../commands/npm-stop.html"><code>npm stop</code></a></h4>
+<ul>
+<li><code>prestop</code></li>
+<li><code>stop</code></li>
+<li><code>poststop</code></li>
+</ul>
+<h4 id="npm-test"><a href="../commands/npm-test.html"><code>npm test</code></a></h4>
+<ul>
+<li><code>pretest</code></li>
+<li><code>test</code></li>
+<li><code>posttest</code></li>
+</ul>
+<h4 id="npm-version"><a href="../commands/npm-version.html"><code>npm version</code></a></h4>
+<ul>
+<li><code>preversion</code></li>
+<li><code>version</code></li>
+<li><code>postversion</code></li>
+</ul>
+<h4 id="a-note-on-a-lack-of-npm-uninstall-scripts">A Note on a lack of <a href="../commands/npm-uninstall.html"><code>npm uninstall</code></a> scripts</h4>
+<p>While npm v6 had <code>uninstall</code> lifecycle scripts, npm v7 does not.
+Removal of a package can happen for a wide variety of reasons, and there's no clear way to currently give the script enough context to be useful.</p>
+<p>Reasons for a package removal include:</p>
+<ul>
+<li>a user directly uninstalled this package</li>
+<li>a user uninstalled a dependent package and so this dependency is being uninstalled</li>
+<li>a user uninstalled a dependent package but another package also depends on this version</li>
+<li>this version has been merged as a duplicate with another version</li>
+<li>etc.</li>
+</ul>
+<p>Due to the lack of necessary context, <code>uninstall</code> lifecycle scripts are not implemented and will not function.</p>
+<h3 id="working-directory-for-scripts">Working Directory for Scripts</h3>
+<p>Scripts are always run from the root of the package folder, regardless of what the current working directory is when <code>npm</code> is invoked.
+This means your scripts can reliably assume they are running in the package root.</p>
+<p>If you want your script to behave differently based on the directory you were in when you ran <code>npm</code>, you can use the <code>INIT_CWD</code> environment variable, which holds the full path you were in when you ran <code>npm run</code>.</p>
+<h4 id="historical-behavior-in-older-npm-versions">Historical Behavior in Older npm Versions</h4>
+<p>For npm v6 and earlier, scripts were generally run from the root of the package, but there were rare cases and bugs in older versions where this was not guaranteed.
+If your package must support very old npm versions, you may wish to add a safeguard in your scripts (for example, by checking process.cwd()).</p>
+<p>For more details, see:</p>
+<ul>
+<li><a href="https://github.com/npm/cli/releases/tag/v7.0.0">npm v7 release notes</a></li>
+<li><a href="https://github.com/npm/npm/issues/12356">Discussion about script working directory reliability in npm v6 and earlier</a></li>
+</ul>
+<h3 id="environment">Environment</h3>
+<p>Package scripts run in an environment where many pieces of information are made available regarding the setup of npm and the current state of the process.</p>
+<h4 id="path">path</h4>
+<p>If you depend on modules that define executable scripts, like test suites, then those executables will be added to the <code>PATH</code> for executing the scripts.
+So, if your package.json has this:</p>
+<pre><code class="language-json">{
+  "name" : "foo",
+  "dependencies" : {
+    "bar" : "0.1.x"
+  },
+  "scripts": {
+    "start" : "bar ./test"
+  }
+}
+</code></pre>
+<p>then you could run <code>npm start</code> to execute the <code>bar</code> script, which is exported into the <code>node_modules/.bin</code> directory on <code>npm install</code>.</p>
+<h4 id="packagejson-vars">package.json vars</h4>
+<p>npm sets the following environment variables from the package.json:</p>
+<ul>
+<li><code>npm_package_name</code> - The package name</li>
+<li><code>npm_package_version</code> - The package version</li>
+<li><code>npm_package_bin_*</code> - Each executable defined in the bin field</li>
+<li><code>npm_package_engines_*</code> - Each engine defined in the engines field</li>
+<li><code>npm_package_config_*</code> - Each config value defined in the config field</li>
+<li><code>npm_package_json</code> - The full path to the package.json file</li>
+</ul>
+<p>Additionally, for install scripts (<code>preinstall</code>, <code>install</code>, <code>postinstall</code>), npm sets these environment variables:</p>
+<ul>
+<li><code>npm_package_resolved</code> - The resolved URL for the package</li>
+<li><code>npm_package_integrity</code> - The integrity hash for the package</li>
+<li><code>npm_package_optional</code> - Set to <code>"true"</code> if the package is optional</li>
+<li><code>npm_package_dev</code> - Set to <code>"true"</code> if the package is a dev dependency</li>
+<li><code>npm_package_peer</code> - Set to <code>"true"</code> if the package is a peer dependency</li>
+<li><code>npm_package_dev_optional</code> - Set to <code>"true"</code> if the package is both dev and optional</li>
+</ul>
+<p>For example, if you had <code>{"name":"foo", "version":"1.2.5"}</code> in your package.json file, then your package scripts would have the <code>npm_package_name</code> environment variable set to "foo", and the <code>npm_package_version</code> set to "1.2.5". You can access these variables in your code with <code>process.env.npm_package_name</code> and <code>process.env.npm_package_version</code>.</p>
+<p><strong>Note:</strong> In npm 7 and later, most package.json fields are no longer provided as environment variables. Scripts that need access to other package.json fields should read the package.json file directly. The <code>npm_package_json</code> environment variable provides the path to the file for this purpose.</p>
+<p>See <a href="../configuring-npm/package-json.html"><code>package.json</code></a> for more on package configs.</p>
+<h4 id="current-lifecycle-event">current lifecycle event</h4>
+<p>Lastly, the <code>npm_lifecycle_event</code> environment variable is set to whichever stage of the cycle is being executed.
+So, you could have a single script used for different parts of the process which switches based on what's currently happening.</p>
+<p>Objects are flattened following this format, so if you had
+<code>{"scripts":{"install":"foo.js"}}</code> in your package.json, then you'd see this in the script:</p>
+<pre><code class="language-bash">process.env.npm_package_scripts_install === "foo.js"
+</code></pre>
+<h3 id="examples">Examples</h3>
+<p>For example, if your package.json contains this:</p>
+<pre><code class="language-json">{
+  "scripts" : {
+    "prepare" : "scripts/build.js",
+    "test" : "scripts/test.js"
+  }
+}
+</code></pre>
+<p>then <code>scripts/build.js</code> will be called for the prepare stage of the lifecycle, and you can check the
+<code>npm_lifecycle_event</code> environment variable if your script needs to behave differently in different contexts.</p>
+<p>If you want to run build commands, you can do so.
+This works just fine:</p>
+<pre><code class="language-json">{
+  "scripts" : {
+    "prepare" : "npm run build",
+    "build" : "tsc",
+    "test" : "jest"
+  }
+}
+</code></pre>
+<h3 id="exiting">Exiting</h3>
+<p>Scripts are run by passing the line as a script argument to <code>/bin/sh</code> on POSIX systems or <code>cmd.exe</code> on Windows.
+You can control which shell is used by setting the <a href="../using-npm/config#script-shell.html"><code>script-shell</code></a> configuration option.</p>
+<p>If the script exits with a code other than 0, then this will abort the process.</p>
+<p>Note that these script files don't have to be Node.js or even JavaScript programs.
+They just have to be some kind of executable file.</p>
+<h3 id="best-practices">Best Practices</h3>
+<ul>
+<li>Don't exit with a non-zero error code unless you <em>really</em> mean it.
+If the failure is minor or only will prevent some optional features, then it's better to just print a warning and exit successfully.</li>
+<li>Try not to use scripts to do what npm can do for you.
+Read through <a href="../configuring-npm/package-json.html"><code>package.json</code></a> to see all the things that you can specify and enable by simply describing your package appropriately.
+In general, this will lead to a more robust and consistent state.</li>
+<li>Inspect the env to determine where to put things.
+For instance, if the <code>NPM_CONFIG_BINROOT</code> environment variable is set to <code>/home/user/bin</code>, then don't try to install executables into <code>/usr/local/bin</code>.
+The user probably set it up that way for a reason.</li>
+<li>Don't prefix your script commands with "sudo".  If root permissions are required for some reason, then it'll fail with that error, and the user will sudo the npm command in question.</li>
+<li>Don't use <code>install</code>.
+Use a <code>.gyp</code> file for compilation, and <code>prepare</code> for anything else.
+You should almost never have to explicitly set a preinstall or install script.
+If you are doing this, please consider if there is another option.
+The only valid use of <code>install</code> or <code>preinstall</code> scripts is for compilation which must be done on the target architecture.</li>
+</ul>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../configuring-npm/package-json.html">package.json</a></li>
+<li><a href="../using-npm/developers.html">npm developers</a></li>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/scripts.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/docs/output/using-npm/workspaces.html b/node/node_modules/npm/docs/output/using-npm/workspaces.html
new file mode 100644
index 0000000000000000000000000000000000000000..8ab893bfe872db4b10a4fd106e2d741001d9499f
--- /dev/null
+++ b/node/node_modules/npm/docs/output/using-npm/workspaces.html
@@ -0,0 +1,352 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>Workspaces</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----workspaces----11130">
+    <span>Workspaces</span>
+    <span class="version">@11.13.0</span>
+</h1>
+<span class="description">Working with workspaces</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><li><a href="#defining-workspaces">Defining workspaces</a></li><li><a href="#getting-started-with-workspaces">Getting started with workspaces</a></li><li><a href="#adding-dependencies-to-a-workspace">Adding dependencies to a workspace</a></li><li><a href="#using-workspaces">Using workspaces</a></li><li><a href="#running-commands-in-the-context-of-workspaces">Running commands in the context of workspaces</a></li><li><a href="#ignoring-missing-scripts">Ignoring missing scripts</a></li><li><a href="#see-also">See also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="description">Description</h3>
+<p><strong>Workspaces</strong> is a generic term that refers to the set of features in the npm cli that provides support for managing multiple packages from your local file system from within a singular top-level, root package.</p>
+<p>This set of features makes up for a much more streamlined workflow handling linked packages from the local file system.
+It automates the linking process as part of <code>npm install</code> and removes the need to manually use <code>npm link</code> in order to add references to packages that should be symlinked into the current <code>node_modules</code> folder.</p>
+<p>We also refer to these packages being auto-symlinked during <code>npm install</code> as a single <strong>workspace</strong>, meaning it's a nested package within the current local file system that is explicitly defined in the <a href="../configuring-npm/package-json#workspaces.html"><code>package.json</code></a>
+<code>workspaces</code> configuration.</p>
+<h3 id="defining-workspaces">Defining workspaces</h3>
+<p>Workspaces are usually defined via the <code>workspaces</code> property of the <a href="../configuring-npm/package-json#workspaces.html"><code>package.json</code></a> file, e.g:</p>
+<pre><code class="language-json">{
+  "name": "my-workspaces-powered-project",
+  "workspaces": [
+    "packages/a"
+  ]
+}
+</code></pre>
+<p>Given the above <code>package.json</code> example living at a current working directory <code>.</code> that contains a folder named <code>packages/a</code> that itself contains a <code>package.json</code> inside it, defining a Node.js package, e.g:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+</code></pre>
+<p>The expected result once running <code>npm install</code> in this current working directory <code>.</code> is that the folder <code>packages/a</code> will get symlinked to the <code>node_modules</code> folder of the current working dir.</p>
+<p>Below is a post <code>npm install</code> example, given that same previous example structure of files and folders:</p>
+<pre><code>.
++-- node_modules
+|  `-- a -&gt; ../packages/a
++-- package-lock.json
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+</code></pre>
+<h3 id="getting-started-with-workspaces">Getting started with workspaces</h3>
+<p>You may automate the required steps to define a new workspace using <a href="../commands/npm-init.html">npm init</a>.
+For example in a project that already has a <code>package.json</code> defined you can run:</p>
+<pre><code>npm init -w ./packages/a
+</code></pre>
+<p>This command will create the missing folders and a new <code>package.json</code> file (if needed) while also making sure to properly configure the
+<code>"workspaces"</code> property of your root project <code>package.json</code>.</p>
+<h3 id="adding-dependencies-to-a-workspace">Adding dependencies to a workspace</h3>
+<p>It's possible to directly add/remove/update dependencies of your workspaces using the <a href="../using-npm/config#workspace.html"><code>workspace</code> config</a>.</p>
+<p>For example, assuming the following structure:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- b
+       `-- package.json
+</code></pre>
+<p>If you want to add a dependency named <code>abbrev</code> from the registry as a dependency of your workspace <strong>a</strong>, you may use the workspace config to tell the npm installer that package should be added as a dependency of the provided workspace:</p>
+<pre><code>npm install abbrev -w a
+</code></pre>
+<p><strong>Adding a workspace as a dependency of another workspace:</strong></p>
+<p>The same approach works when adding one workspace as a dependency of another.
+If you want to add workspace <strong>b</strong> as a dependency of workspace <strong>a</strong>, run:</p>
+<pre><code>npm install b -w a
+</code></pre>
+<p>npm will detect that <strong>b</strong> is a workspace and automatically symlink it rather
+than fetching it from the registry. The resulting entry in workspace <strong>a</strong>'s
+<code>package.json</code> will use a standard version range:</p>
+<pre><code class="language-json">{
+  "dependencies": {
+    "b": "^1.0.0"
+  }
+}
+</code></pre>
+<p>Note: other installing commands such as <code>uninstall</code>, <code>ci</code>, etc will also respect the provided <code>workspace</code> configuration.</p>
+<h3 id="using-workspaces">Using workspaces</h3>
+<p>Given the <a href="https://nodejs.org/dist/latest-v14.x/docs/api/modules.html#modules_all_together">specifics of how Node.js handles module resolution</a> it's possible to consume any defined workspace by its declared <code>package.json</code> <code>name</code>.
+Continuing from the example defined above, let's also create a Node.js script that will require the workspace <code>a</code> example module, e.g:</p>
+<pre><code>// ./packages/a/index.js
+module.exports = 'a'
+
+// ./lib/index.js
+const moduleA = require('a')
+console.log(moduleA) // -&gt; a
+</code></pre>
+<p>When running it with:</p>
+<p><code>node lib/index.js</code></p>
+<p>This demonstrates how the nature of <code>node_modules</code> resolution allows for
+<strong>workspaces</strong> to enable a portable workflow for requiring each <strong>workspace</strong> in such a way that is also easy to <a href="../commands/npm-publish.html">publish</a> these nested workspaces to be consumed elsewhere.</p>
+<h3 id="running-commands-in-the-context-of-workspaces">Running commands in the context of workspaces</h3>
+<p>You can use the <code>workspace</code> configuration option to run commands in the context of a configured workspace.
+Additionally, if your current directory is in a workspace, the <code>workspace</code> configuration is implicitly set, and <code>prefix</code> is set to the root workspace.</p>
+<p>Following is a quick example on how to use the <code>npm run</code> command in the context of nested workspaces.
+For a project containing multiple workspaces, e.g:</p>
+<pre><code>.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- b
+       `-- package.json
+</code></pre>
+<p>By running a command using the <code>workspace</code> option, it's possible to run the given command in the context of that specific workspace.
+e.g:</p>
+<pre><code>npm run test --workspace=a
+</code></pre>
+<p>You could also run the command within the workspace.</p>
+<pre><code>cd packages/a &amp;&amp; npm run test
+</code></pre>
+<p>Either will run the <code>test</code> script defined within the
+<code>./packages/a/package.json</code> file.</p>
+<p>Please note that you can also specify this argument multiple times in the command-line in order to target multiple workspaces, e.g:</p>
+<pre><code>npm run test --workspace=a --workspace=b
+</code></pre>
+<p>Or run the command for each workspace within the 'packages' folder:</p>
+<pre><code>npm run test --workspace=packages
+</code></pre>
+<p>It's also possible to use the <code>workspaces</code> (plural) configuration option to enable the same behavior but running that command in the context of <strong>all</strong> configured workspaces.
+e.g:</p>
+<pre><code>npm run test --workspaces
+</code></pre>
+<p>Will run the <code>test</code> script in both <code>./packages/a</code> and <code>./packages/b</code>.</p>
+<p>Commands will be run in each workspace in the order they appear in your <code>package.json</code></p>
+<pre><code>{
+  "workspaces": [ "packages/a", "packages/b" ]
+}
+</code></pre>
+<p>Order of run is different with:</p>
+<pre><code>{
+  "workspaces": [ "packages/b", "packages/a" ]
+}
+</code></pre>
+<h3 id="ignoring-missing-scripts">Ignoring missing scripts</h3>
+<p>It is not required for all of the workspaces to implement scripts run with the <code>npm run</code> command.</p>
+<p>By running the command with the <code>--if-present</code> flag, npm will ignore workspaces missing target script.</p>
+<pre><code>npm run test --workspaces --if-present
+</code></pre>
+<h3 id="see-also">See also</h3>
+<ul>
+<li><a href="../commands/npm-install.html">npm install</a></li>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-run.html">npm run</a></li>
+<li><a href="../using-npm/config.html">config</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/using-npm/workspaces.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/node/node_modules/npm/lib/cli/entry.js b/node/node_modules/npm/lib/cli/entry.js
new file mode 100644
index 0000000000000000000000000000000000000000..6965ffb7b7bd0c14d4e88db529e51af2dd69d766
--- /dev/null
+++ b/node/node_modules/npm/lib/cli/entry.js
@@ -0,0 +1,72 @@
+// Separated out for easier unit testing
+module.exports = async (process, validateEngines) => {
+  // set it here so that regardless of what happens later, we don't leak any private CLI configs to other programs
+  process.title = 'npm'
+
+  // Patch the global fs module here at the app level
+  require('graceful-fs').gracefulify(require('node:fs'))
+
+  const satisfies = require('semver/functions/satisfies')
+  const ExitHandler = require('./exit-handler.js')
+  const exitHandler = new ExitHandler({ process })
+  const Npm = require('../npm.js')
+  const npm = new Npm()
+  exitHandler.setNpm(npm)
+
+  // only log node and npm paths in argv initially since argv can contain sensitive info. a cleaned version will be logged later
+  const { log, output } = require('proc-log')
+  log.verbose('cli', process.argv.slice(0, 2).join(' '))
+  log.info('using', 'npm@%s', npm.version)
+  log.info('using', 'node@%s', process.version)
+
+  // At this point we've required a few files and can be pretty sure we don't contain invalid syntax for this version of node.
+  // It's possible a lazy require would, but that's unlikely enough that it's not worth catching anymore and we attach the more important exit handlers.
+  validateEngines.off()
+  exitHandler.registerUncaughtHandlers()
+
+  // It is now safe to log a warning if they are using a version of node that is not going to fail on syntax errors but is still unsupported and untested and might not work reliably.
+  // This is safe to use the logger now which we want since this will show up in the error log too.
+  if (!satisfies(validateEngines.node, validateEngines.engines)) {
+    log.warn('cli', validateEngines.unsupportedMessage)
+  }
+
+  // Now actually fire up npm and run the command.
+  // This is how to use npm programmatically:
+  try {
+    const { exec, command, args } = await npm.load()
+
+    if (!exec) {
+      return exitHandler.exit()
+    }
+
+    if (!command) {
+      output.standard(npm.usage)
+      process.exitCode = 1
+      return exitHandler.exit()
+    }
+
+    // Options are prefixed by a hyphen-minus (-, \u2d).
+    // Other dash-type chars look similar but are invalid.
+    const nonDashArgs = npm.argv.filter(a => /^[\u2010-\u2015\u2212\uFE58\uFE63\uFF0D]/.test(a))
+    if (nonDashArgs.length) {
+      log.error(
+        'arg',
+        'Argument starts with non-ascii dash, this is probably invalid:',
+        require('@npmcli/redact').redactLog(nonDashArgs.join(', '))
+      )
+    }
+
+    const execPromise = npm.exec(command, args)
+
+    // this is async but we don't await it, since its ok if it doesnt finish before the command finishes running.
+    // it uses command and argv so it must be initiated here, after the command name is set
+    const updateNotifier = require('./update-notifier.js')
+    // eslint-disable-next-line promise/catch-or-return
+    updateNotifier(npm).then((msg) => (npm.updateNotification = msg))
+
+    await execPromise
+    return exitHandler.exit()
+  } catch (err) {
+    return exitHandler.exit(err)
+  }
+}
diff --git a/node/node_modules/npm/lib/cli/exit-handler.js b/node/node_modules/npm/lib/cli/exit-handler.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd016b5af73717275afca6bec408f669f7a99ae5
--- /dev/null
+++ b/node/node_modules/npm/lib/cli/exit-handler.js
@@ -0,0 +1,168 @@
+const { log, output, META } = require('proc-log')
+const { errorMessage, getExitCodeFromError } = require('../utils/error-message.js')
+
+class ExitHandler {
+  #npm = null
+  #process = null
+  #exited = false
+  #exitErrorMessage = false
+
+  #noNpmError = false
+
+  get #hasNpm () {
+    return !!this.#npm
+  }
+
+  get #loaded () {
+    return !!this.#npm?.loaded
+  }
+
+  get #showExitErrorMessage () {
+    if (!this.#loaded) {
+      return false
+    }
+    if (!this.#exited) {
+      return true
+    }
+    return this.#exitErrorMessage
+  }
+
+  get #notLoadedOrExited () {
+    return !this.#loaded && !this.#exited
+  }
+
+  setNpm (npm) {
+    this.#npm = npm
+  }
+
+  constructor ({ process }) {
+    this.#process = process
+    this.#process.on('exit', this.#handleProcessExitAndReset)
+  }
+
+  registerUncaughtHandlers () {
+    this.#process.on('uncaughtException', this.#handleExit)
+    this.#process.on('unhandledRejection', this.#handleExit)
+  }
+
+  exit (err) {
+    this.#handleExit(err)
+  }
+
+  #handleProcessExitAndReset = (code) => {
+    this.#handleProcessExit(code)
+
+    // Reset all the state. This is only relevant for tests since in reality the process fully exits here.
+    this.#process.off('exit', this.#handleProcessExitAndReset)
+    this.#process.off('uncaughtException', this.#handleExit)
+    this.#process.off('unhandledRejection', this.#handleExit)
+    if (this.#loaded) {
+      this.#npm.unload()
+    }
+    this.#npm = null
+    this.#exited = false
+    this.#exitErrorMessage = false
+  }
+
+  #handleProcessExit (code) {
+    const numCode = Number(code) || 0
+    // Always exit w/ a non-zero code if exit handler was not called
+    const exitCode = this.#exited ? numCode : (numCode || 1)
+    this.#process.exitCode = exitCode
+
+    if (this.#notLoadedOrExited) {
+      // Exit handler was not called and npm was not loaded so we have to log something
+      this.#logConsoleError(new Error(`Process exited unexpectedly with code: ${exitCode}`))
+      return
+    }
+
+    if (this.#logNoNpmError()) {
+      return
+    }
+
+    const os = require('node:os')
+    log.verbose('cwd', this.#process.cwd())
+    log.verbose('os', `${os.type()} ${os.release()}`)
+    log.verbose('node', this.#process.version)
+    log.verbose('npm ', `v${this.#npm.version}`)
+
+    // only show the notification if it finished
+    if (typeof this.#npm.updateNotification === 'string') {
+      log.notice('', this.#npm.updateNotification, { [META]: true, force: true })
+    }
+
+    if (!this.#exited) {
+      log.error('', 'Exit handler never called!')
+      log.error('', 'This is an error with npm itself. Please report this error at:')
+      log.error('', '  <https://github.com/npm/cli/issues>')
+      if (this.#npm.silent) {
+        output.error('')
+      }
+    }
+
+    log.verbose('exit', exitCode)
+
+    if (exitCode) {
+      log.verbose('code', exitCode)
+    } else {
+      log.info('ok')
+    }
+
+    if (this.#showExitErrorMessage) {
+      log.error('', this.#npm.exitErrorMessage())
+    }
+  }
+
+  #logConsoleError (err) {
+    // Run our error message formatters on all errors even if we have no npm or an unloaded npm.
+    // This will clean the error and possible return a formatted message about EACCESS or something.
+    const { summary, detail } = errorMessage(err, this.#npm)
+    const formatted = [...new Set([...summary, ...detail].flat().filter(Boolean))].join('\n')
+    // If we didn't get anything from the formatted message then just display the full stack
+    // eslint-disable-next-line no-console
+    console.error(formatted === err.message ? err.stack : formatted)
+  }
+
+  #logNoNpmError (err) {
+    if (this.#hasNpm) {
+      return false
+    }
+    // Make sure we only log this error once
+    if (!this.#noNpmError) {
+      this.#noNpmError = true
+      this.#logConsoleError(
+        new Error(`Exit prior to setting npm in exit handler`, err ? { cause: err } : {})
+      )
+    }
+    return true
+  }
+
+  #handleExit = (err) => {
+    this.#exited = true
+
+    // No npm at all
+    if (this.#logNoNpmError(err)) {
+      return this.#process.exit(this.#process.exitCode || getExitCodeFromError(err) || 1)
+    }
+
+    // npm was never loaded but we still might have a config loading error or something similar that we can run through the error message formatter to give the user a clue as to what happened.
+    if (!this.#loaded) {
+      this.#logConsoleError(new Error('Exit prior to config file resolving', { cause: err }))
+      return this.#process.exit(this.#process.exitCode || getExitCodeFromError(err) || 1)
+    }
+
+    this.#exitErrorMessage = err?.suppressError === true ? false : !!err
+
+    // Prefer the exit code of the error, then the current process exit code, then set it to 1 if we still have an error.
+    // Otherwise, we call process.exit with undefined so that it can determine the final exit code
+    const exitCode = err?.exitCode ?? this.#process.exitCode ?? (err ? 1 : undefined)
+
+    // explicitly call process.exit now so we don't hang on things like the update notifier
+    // also flush stdout/err beforehand because process.exit doesn't wait for that to happen.
+    this.#process.stderr.write('', () => this.#process.stdout.write('', () => {
+      this.#process.exit(exitCode)
+    }))
+  }
+}
+
+module.exports = ExitHandler
diff --git a/node/node_modules/npm/lib/cli/update-notifier.js b/node/node_modules/npm/lib/cli/update-notifier.js
new file mode 100644
index 0000000000000000000000000000000000000000..a879a5d9119d44e86b0ad465ee0071f6afcffb4d
--- /dev/null
+++ b/node/node_modules/npm/lib/cli/update-notifier.js
@@ -0,0 +1,115 @@
+// print a banner telling the user to upgrade npm to latest but not in CI, and not if we're doing that already.
+
+const ciInfo = require('ci-info')
+const gt = require('semver/functions/gt')
+const gte = require('semver/functions/gte')
+const parse = require('semver/functions/parse')
+const { stat, writeFile } = require('node:fs/promises')
+const { resolve } = require('node:path')
+
+// update check frequency
+const DAILY = 1000 * 60 * 60 * 24
+const WEEKLY = DAILY * 7
+
+// don't put it in the _cacache folder, just in npm's cache
+const lastCheckedFile = npm => resolve(npm.flatOptions.cache, '../_update-notifier-last-checked')
+
+// Actual check for updates. This is a separate function so that we only load this if we are doing the actual update
+const updateCheck = async (npm, spec, version, current) => {
+  const pacote = require('pacote')
+
+  const mani = await pacote.manifest(`npm@${spec}`, {
+    // always prefer latest, even if doing --tag=whatever on the cmd
+    defaultTag: 'latest',
+    ...npm.flatOptions,
+    cache: false,
+  }).catch(() => null)
+
+  // if pacote failed, give up
+  if (!mani) {
+    return null
+  }
+
+  const latest = mani.version
+
+  // if the current version is *greater* than latest, we're on a 'next' and should get the updates from that release train.
+  // Note that this isn't another http request over the network, because the packument will be cached by pacote from previous request.
+  if (gt(version, latest) && spec === '*') {
+    return updateNotifier(npm, `^${version}`)
+  }
+
+  // if we already have something >= the desired spec, then we're done
+  if (gte(version, latest)) {
+    return null
+  }
+
+  const chalk = npm.logChalk
+
+  // ok! notify the user about this update they should get.
+  // The message is saved for printing at process exit so it will not get lost in any other messages being printed as part of the command.
+  const update = parse(mani.version)
+  const type = update.major !== current.major ? 'major'
+    : update.minor !== current.minor ? 'minor'
+    : update.patch !== current.patch ? 'patch'
+    : 'prerelease'
+  const typec = type === 'major' ? 'red'
+    : type === 'minor' ? 'yellow'
+    : 'cyan'
+  const message = [
+    '',
+    `New ${chalk[typec](type)} version of npm available! ${chalk[typec](current)} -> ${chalk.blue(latest)}`,
+    `Changelog: ${chalk.blue(`https://github.com/npm/cli/releases/tag/v${latest}`)}`,
+    `To update run: ${chalk.underline(`npm install -g npm@${latest}`)}`,
+    '',
+  ].join('\n')
+
+  return message
+}
+
+const updateNotifier = async (npm, spec = '*') => {
+  // if we're on a prerelease train, then updates are coming fast check for a new one daily.
+  // otherwise, weekly.
+  const { version } = npm
+  const current = parse(version)
+
+  // if we're on a beta train, always get the next beta
+  if (current.prerelease.length) {
+    spec = `^${version}`
+  }
+
+  // while on a beta train, get updates daily
+  const duration = current.prerelease.length ? DAILY : WEEKLY
+
+  const t = new Date(Date.now() - duration)
+  // if we don't have a file, then definitely check it.
+  const st = await stat(lastCheckedFile(npm)).catch(() => ({ mtime: t - 1 }))
+
+  // if we've already checked within the specified duration, don't check again
+  if (!(t > st.mtime)) {
+    return null
+  }
+
+  // intentional.  do not await this.  it's a best-effort update.
+  // if this fails, it's ok.
+  // might be using /dev/null as the cache or something weird like that.
+  writeFile(lastCheckedFile(npm), '').catch(() => {})
+
+  return updateCheck(npm, spec, version, current)
+}
+
+module.exports = async npm => {
+  if (
+    // opted out
+    !npm.config.get('update-notifier')
+    // global npm update
+    || (npm.flatOptions.global &&
+      ['install', 'update'].includes(npm.command) &&
+      npm.argv.some(arg => /^npm(@|$)/.test(arg)))
+    // CI
+    || ciInfo.isCI
+  ) {
+    return null
+  }
+
+  return updateNotifier(npm)
+}
diff --git a/node/node_modules/npm/lib/cli/validate-engines.js b/node/node_modules/npm/lib/cli/validate-engines.js
new file mode 100644
index 0000000000000000000000000000000000000000..c656a5c0013487d0279e87d071d6171fa3317d5f
--- /dev/null
+++ b/node/node_modules/npm/lib/cli/validate-engines.js
@@ -0,0 +1,43 @@
+// This is separate to indicate that it should contain code we expect to work in all versions of node >= 6.
+// This is a best effort to catch syntax errors to give users a good error message if they are using a node version that doesn't allow syntax we are using such as private properties, etc.
+// This file is linted with ecmaVersion=6 so we don't use invalid syntax, which is set in the .eslintrc.local.json file
+
+const { engines: { node: engines }, version } = require('../../package.json')
+const npm = `v${version}`
+
+module.exports = (process, getCli) => {
+  const node = process.version
+
+  const unsupportedMessage = `npm ${npm} does not support Node.js ${node}. This version of npm supports the following node versions: \`${engines}\`. You can find the latest version at https://nodejs.org/.`
+
+  const brokenMessage = `ERROR: npm ${npm} is known not to run on Node.js ${node}.  This version of npm supports the following node versions: \`${engines}\`. You can find the latest version at https://nodejs.org/.`
+
+  // coverage ignored because this is only hit in very unsupported node versions and it's a best effort attempt to show something nice in those cases
+  /* istanbul ignore next */
+  const syntaxErrorHandler = (err) => {
+    if (err instanceof SyntaxError) {
+      // eslint-disable-next-line no-console
+      console.error(`${brokenMessage}\n\nERROR:`)
+      // eslint-disable-next-line no-console
+      console.error(err)
+      return process.exit(1)
+    }
+    throw err
+  }
+
+  process.on('uncaughtException', syntaxErrorHandler)
+  process.on('unhandledRejection', syntaxErrorHandler)
+
+  // require this only after setting up the error handlers
+  const cli = getCli()
+  return cli(process, {
+    node,
+    npm,
+    engines,
+    unsupportedMessage,
+    off: () => {
+      process.off('uncaughtException', syntaxErrorHandler)
+      process.off('unhandledRejection', syntaxErrorHandler)
+    },
+  })
+}
diff --git a/node/node_modules/npm/lib/commands/access.js b/node/node_modules/npm/lib/commands/access.js
new file mode 100644
index 0000000000000000000000000000000000000000..21e5cd12253f7f94db12b8b1a1bc3b59eec69c08
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/access.js
@@ -0,0 +1,226 @@
+const libnpmaccess = require('libnpmaccess')
+const npa = require('npm-package-arg')
+const { output } = require('proc-log')
+const pkgJson = require('@npmcli/package-json')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { otplease } = require('../utils/auth.js')
+const getIdentity = require('../utils/get-identity.js')
+const BaseCommand = require('../base-cmd.js')
+
+const commands = [
+  'get',
+  'grant',
+  'list',
+  'revoke',
+  'set',
+]
+
+const setCommands = [
+  'status=public',
+  'status=private',
+  'mfa=none',
+  'mfa=publish',
+  'mfa=automation',
+  '2fa=none',
+  '2fa=publish',
+  '2fa=automation',
+]
+
+class Access extends BaseCommand {
+  static description = 'Set access level on published packages'
+  static name = 'access'
+  static params = [
+    'json',
+    'otp',
+    'registry',
+  ]
+
+  static usage = [
+    'list packages [<user>|<scope>|<scope:team>] [<package>]',
+    'list collaborators [<package> [<user>]]',
+    'get status [<package>]',
+    'set status=public|private [<package>]',
+    'set mfa=none|publish|automation [<package>]',
+    'grant <read-only|read-write> <scope:team> [<package>]',
+    'revoke <scope:team> [<package>]',
+  ]
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      return commands
+    }
+
+    if (argv.length === 3) {
+      switch (argv[2]) {
+        case 'grant':
+          return ['read-only', 'read-write']
+        case 'revoke':
+          return []
+        case 'list':
+        case 'ls':
+          return ['packages', 'collaborators']
+        case 'get':
+          return ['status']
+        case 'set':
+          return setCommands
+        default:
+          throw new Error(argv[2] + ' not recognized')
+      }
+    }
+  }
+
+  async exec ([cmd, subcmd, ...args]) {
+    if (!cmd) {
+      throw this.usageError()
+    }
+    if (!commands.includes(cmd)) {
+      throw this.usageError(`${cmd} is not a valid access command`)
+    }
+    // All commands take at least one more parameter so we can do this check up front
+    if (!subcmd) {
+      throw this.usageError()
+    }
+
+    switch (cmd) {
+      case 'grant':
+        if (!['read-only', 'read-write'].includes(subcmd)) {
+          throw this.usageError('grant must be either `read-only` or `read-write`')
+        }
+        if (!args[0]) {
+          throw this.usageError('`<scope:team>` argument is required')
+        }
+        return this.#grant(subcmd, args[0], args[1])
+      case 'revoke':
+        return this.#revoke(subcmd, args[0])
+      case 'list':
+      case 'ls':
+        if (subcmd === 'packages') {
+          return this.#listPackages(args[0], args[1])
+        }
+        if (subcmd === 'collaborators') {
+          return this.#listCollaborators(args[0], args[1])
+        }
+        throw this.usageError(`list ${subcmd} is not a valid access command`)
+      case 'get':
+        if (subcmd !== 'status') {
+          throw this.usageError(`get ${subcmd} is not a valid access command`)
+        }
+        return this.#getStatus(args[0])
+      case 'set':
+        if (!setCommands.includes(subcmd)) {
+          throw this.usageError(`set ${subcmd} is not a valid access command`)
+        }
+        return this.#set(subcmd, args[0])
+    }
+  }
+
+  async #grant (permissions, scope, pkg) {
+    await otplease(this.npm, this.npm.flatOptions, async (opts) => {
+      await libnpmaccess.setPermissions(scope, pkg, permissions, opts)
+    })
+  }
+
+  async #revoke (scope, pkg) {
+    await otplease(this.npm, this.npm.flatOptions, async (opts) => {
+      await libnpmaccess.removePermissions(scope, pkg, opts)
+    })
+  }
+
+  async #listPackages (owner, pkg) {
+    if (!owner) {
+      owner = await getIdentity(this.npm, this.npm.flatOptions)
+    }
+    const pkgs = await libnpmaccess.getPackages(owner, this.npm.flatOptions)
+    this.#output(pkgs, pkg)
+  }
+
+  async #listCollaborators (pkg, user) {
+    const pkgName = await this.#getPackage(pkg, false)
+    const collabs = await libnpmaccess.getCollaborators(pkgName, this.npm.flatOptions)
+    this.#output(collabs, user)
+  }
+
+  async #getStatus (pkg) {
+    const pkgName = await this.#getPackage(pkg, false)
+    const visibility = await libnpmaccess.getVisibility(pkgName, this.npm.flatOptions)
+    this.#output({ [pkgName]: visibility.public ? 'public' : 'private' })
+  }
+
+  async #set (subcmd, pkg) {
+    const [subkey, subval] = subcmd.split('=')
+    switch (subkey) {
+      case 'mfa':
+      case '2fa':
+        return this.#setMfa(pkg, subval)
+      case 'status':
+        return this.#setStatus(pkg, subval)
+    }
+  }
+
+  async #setMfa (pkg, level) {
+    const pkgName = await this.#getPackage(pkg, false)
+    await otplease(this.npm, this.npm.flatOptions, (opts) => {
+      return libnpmaccess.setMfa(pkgName, level, opts)
+    })
+  }
+
+  async #setStatus (pkg, status) {
+    // only scoped packages can have their access changed
+    const pkgName = await this.#getPackage(pkg, true)
+    if (status === 'private') {
+      status = 'restricted'
+    }
+    await otplease(this.npm, this.npm.flatOptions, (opts) => {
+      return libnpmaccess.setAccess(pkgName, status, opts)
+    })
+    return this.#getStatus(pkgName)
+  }
+
+  async #getPackage (name, requireScope) {
+    if (!name) {
+      try {
+        const { content } = await pkgJson.normalize(this.npm.prefix)
+        name = content.name
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          throw Object.assign(new Error('no package name given and no package.json found'), {
+            code: 'ENOENT',
+          })
+        } else {
+          throw err
+        }
+      }
+    }
+
+    const spec = npa(name)
+    if (requireScope && !spec.scope) {
+      throw this.usageError('This command is only available for scoped packages.')
+    }
+    return name
+  }
+
+  #output (items, limiter) {
+    const outputs = {}
+    const lookup = {
+      __proto__: null,
+      read: 'read-only',
+      write: 'read-write',
+    }
+    for (const item in items) {
+      const val = items[item]
+      outputs[item] = lookup[val] || val
+    }
+    if (this.npm.config.get('json')) {
+      output.buffer(outputs)
+    } else {
+      for (const item of Object.keys(outputs).sort(localeCompare)) {
+        if (!limiter || limiter === item) {
+          output.standard(`${item}: ${outputs[item]}`)
+        }
+      }
+    }
+  }
+}
+
+module.exports = Access
diff --git a/node/node_modules/npm/lib/commands/adduser.js b/node/node_modules/npm/lib/commands/adduser.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e1ab40b64b004e4a814f4a4088b8f6baf42e158
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/adduser.js
@@ -0,0 +1,50 @@
+const { log, output } = require('proc-log')
+const { redactLog: replaceInfo } = require('@npmcli/redact')
+const auth = require('../utils/auth.js')
+const BaseCommand = require('../base-cmd.js')
+
+class AddUser extends BaseCommand {
+  static description = 'Add a registry user account'
+  static name = 'adduser'
+  static params = [
+    'registry',
+    'scope',
+    'auth-type',
+  ]
+
+  async exec () {
+    const scope = this.npm.config.get('scope')
+    let registry = this.npm.config.get('registry')
+
+    if (scope) {
+      const scopedRegistry = this.npm.config.get(`${scope}:registry`)
+      const cliRegistry = this.npm.config.get('registry', 'cli')
+      if (scopedRegistry && !cliRegistry) {
+        registry = scopedRegistry
+      }
+    }
+
+    const creds = this.npm.config.getCredentialsByURI(registry)
+
+    log.notice('', `Log in on ${replaceInfo(registry)}`)
+
+    const { message, newCreds } = await auth.adduser(this.npm, {
+      ...this.npm.flatOptions,
+      creds,
+      registry,
+    })
+
+    this.npm.config.delete('_token', 'user') // prevent legacy pollution
+    this.npm.config.setCredentialsByURI(registry, newCreds)
+
+    if (scope) {
+      this.npm.config.set(scope + ':registry', registry, 'user')
+    }
+
+    await this.npm.config.save('user')
+
+    output.standard(message)
+  }
+}
+
+module.exports = AddUser
diff --git a/node/node_modules/npm/lib/commands/audit.js b/node/node_modules/npm/lib/commands/audit.js
new file mode 100644
index 0000000000000000000000000000000000000000..c446e812cfd8e48d21bdfec1b2bcf27fab099f90
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/audit.js
@@ -0,0 +1,122 @@
+const npmAuditReport = require('npm-audit-report')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+const auditError = require('../utils/audit-error.js')
+const { log, output } = require('proc-log')
+const reifyFinish = require('../utils/reify-finish.js')
+const VerifySignatures = require('../utils/verify-signatures.js')
+
+class Audit extends ArboristWorkspaceCmd {
+  static description = 'Run a security audit'
+  static name = 'audit'
+  static params = [
+    'audit-level',
+    'dry-run',
+    'force',
+    'json',
+    'package-lock-only',
+    'package-lock',
+    'omit',
+    'include',
+    'foreground-scripts',
+    'ignore-scripts',
+    'include-attestations',
+    ...super.params,
+  ]
+
+  static usage = ['[fix|signatures]']
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+
+    if (argv.length === 2) {
+      return ['fix', 'signatures']
+    }
+
+    switch (argv[2]) {
+      case 'fix':
+      case 'signatures':
+        return []
+      default:
+        throw Object.assign(new Error(`${argv[2]} not recognized`), {
+          code: 'EUSAGE',
+        })
+    }
+  }
+
+  async exec (args) {
+    if (args[0] === 'signatures') {
+      await this.auditSignatures()
+    } else {
+      await this.auditAdvisories(args)
+    }
+  }
+
+  async auditAdvisories (args) {
+    const fix = args[0] === 'fix'
+    if (this.npm.config.get('package-lock') === false && fix) {
+      throw this.usageError('fix cannot be used without a package-lock')
+    }
+    const reporter = this.npm.config.get('json') ? 'json' : 'detail'
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      audit: true,
+      path: this.npm.prefix,
+      reporter,
+      workspaces: this.workspaceNames,
+    }
+
+    const arb = new Arborist(opts)
+    await arb.audit({ fix })
+    if (fix) {
+      await reifyFinish(this.npm, arb)
+    } else {
+      // will throw if there's an error, because this is an audit command
+      auditError(this.npm, arb.auditReport)
+      const result = npmAuditReport(arb.auditReport, {
+        ...opts,
+        chalk: this.npm.chalk,
+      })
+      process.exitCode = process.exitCode || result.exitCode
+      output.standard(result.report)
+    }
+  }
+
+  async auditSignatures () {
+    if (this.npm.global) {
+      throw Object.assign(
+        new Error('`npm audit signatures` does not support global packages'), {
+          code: 'EAUDITGLOBAL',
+        }
+      )
+    }
+
+    log.verbose('audit', 'loading installed dependencies')
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      path: this.npm.prefix,
+      workspaces: this.workspaceNames,
+    }
+
+    const arb = new Arborist(opts)
+    const tree = await arb.loadActual()
+    let filterSet = new Set()
+    if (opts.workspaces && opts.workspaces.length) {
+      filterSet =
+        arb.workspaceDependencySet(
+          tree,
+          opts.workspaces,
+          this.npm.flatOptions.includeWorkspaceRoot
+        )
+    } else if (!this.npm.flatOptions.workspacesEnabled) {
+      filterSet =
+        arb.excludeWorkspacesDependencySet(tree)
+    }
+
+    const verify = new VerifySignatures(tree, filterSet, this.npm, { ...opts })
+    await verify.run()
+  }
+}
+
+module.exports = Audit
diff --git a/node/node_modules/npm/lib/commands/bugs.js b/node/node_modules/npm/lib/commands/bugs.js
new file mode 100644
index 0000000000000000000000000000000000000000..11af01e582e7cb04cb7a567ed18a1d8064c9ff3f
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/bugs.js
@@ -0,0 +1,34 @@
+const PackageUrlCmd = require('../package-url-cmd.js')
+
+class Bugs extends PackageUrlCmd {
+  static description = 'Report bugs for a package in a web browser'
+  static name = 'bugs'
+
+  getUrl (spec, mani) {
+    if (mani.bugs) {
+      if (typeof mani.bugs === 'string') {
+        return mani.bugs
+      }
+
+      if (typeof mani.bugs === 'object' && mani.bugs.url) {
+        return mani.bugs.url
+      }
+
+      if (typeof mani.bugs === 'object' && mani.bugs.email) {
+        return `mailto:${mani.bugs.email}`
+      }
+    }
+
+    // try to get it from the repo, if possible
+    const info = this.hostedFromMani(mani)
+    const infoUrl = info?.bugs()
+    if (infoUrl) {
+      return infoUrl
+    }
+
+    // just send them to the website, hopefully that has some info!
+    return `https://www.npmjs.com/package/${mani.name}`
+  }
+}
+
+module.exports = Bugs
diff --git a/node/node_modules/npm/lib/commands/cache.js b/node/node_modules/npm/lib/commands/cache.js
new file mode 100644
index 0000000000000000000000000000000000000000..f6e85e0d8ab936a7404f7a6bb0cafd828329f540
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/cache.js
@@ -0,0 +1,363 @@
+const fs = require('node:fs/promises')
+const { join } = require('node:path')
+const cacache = require('cacache')
+const pacote = require('pacote')
+const semver = require('semver')
+const npa = require('npm-package-arg')
+const jsonParse = require('json-parse-even-better-errors')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { log, output } = require('proc-log')
+const PkgJson = require('@npmcli/package-json')
+const abbrev = require('abbrev')
+const BaseCommand = require('../base-cmd.js')
+
+const searchCachePackage = async (path, parsed, cacheKeys) => {
+  const searchMFH = new RegExp(`^make-fetch-happen:request-cache:.*(?<!/[@a-zA-Z]+)/${parsed.name}/-/(${parsed.name}[^/]+.tgz)$`)
+  const searchPack = new RegExp(`^make-fetch-happen:request-cache:.*/${parsed.escapedName}$`)
+  const results = new Set()
+  cacheKeys = new Set(cacheKeys)
+  for (const key of cacheKeys) {
+    // match on the public key registry url format
+    if (searchMFH.test(key)) {
+      // extract the version from the filename
+      const filename = key.match(searchMFH)[1]
+      const noExt = filename.slice(0, -4)
+      const noScope = `${parsed.name.split('/').pop()}-`
+      const ver = noExt.slice(noScope.length)
+      if (semver.satisfies(ver, parsed.rawSpec)) {
+        results.add(key)
+      }
+      continue
+    }
+    // is this key a packument?
+    if (!searchPack.test(key)) {
+      continue
+    }
+
+    results.add(key)
+    let packument, details
+    try {
+      details = await cacache.get(path, key)
+      packument = jsonParse(details.data)
+    } catch {
+      // if we couldn't parse the packument, abort
+      continue
+    }
+    if (!packument.versions || typeof packument.versions !== 'object') {
+      continue
+    }
+
+    // assuming this is a packument
+    for (const ver of Object.keys(packument.versions)) {
+      if (semver.satisfies(ver, parsed.rawSpec)) {
+        if (packument.versions[ver].dist &&
+          typeof packument.versions[ver].dist === 'object' &&
+          packument.versions[ver].dist.tarball !== undefined &&
+          cacheKeys.has(`make-fetch-happen:request-cache:${packument.versions[ver].dist.tarball}`)
+        ) {
+          results.add(`make-fetch-happen:request-cache:${packument.versions[ver].dist.tarball}`)
+        }
+      }
+    }
+  }
+  return results
+}
+
+class Cache extends BaseCommand {
+  static description = 'Manipulates packages and npx cache'
+  static name = 'cache'
+  static params = ['cache']
+  static usage = [
+    'add <package-spec>',
+    'clean [<key>]',
+    'ls [<name>@<version>]',
+    'verify',
+    'npx ls',
+    'npx rm [<key>...]',
+    'npx info <key>...',
+  ]
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      return ['add', 'clean', 'verify', 'ls', 'npx']
+    }
+
+    // TODO - eventually...
+    switch (argv[2]) {
+      case 'verify':
+      case 'clean':
+      case 'add':
+      case 'ls':
+        return []
+    }
+  }
+
+  async exec (args) {
+    const cmd = args.shift()
+    switch (cmd) {
+      case 'rm': case 'clear': case 'clean':
+        return await this.clean(args)
+      case 'add':
+        return await this.add(args)
+      case 'verify': case 'check':
+        return await this.verify()
+      case 'ls':
+        return await this.ls(args)
+      case 'npx':
+        return await this.npx(args)
+      default:
+        throw this.usageError()
+    }
+  }
+
+  // npm cache npx
+  async npx ([cmd, ...keys]) {
+    switch (cmd) {
+      case 'ls':
+        return await this.npxLs(keys)
+      case 'rm':
+        return await this.npxRm(keys)
+      case 'info':
+        return await this.npxInfo(keys)
+      default:
+        throw this.usageError()
+    }
+  }
+
+  // npm cache clean [spec]*
+  async clean (args) {
+    // this is a derived value
+    const cachePath = this.npm.flatOptions.cache
+    if (args.length === 0) {
+      if (!this.npm.config.get('force')) {
+        throw new Error(`As of npm@5, the npm cache self-heals from corruption issues by treating integrity mismatches as cache misses.
+As a result, data extracted from the cache is guaranteed to be valid.
+If you want to make sure everything is consistent, use \`npm cache verify\` instead.
+Deleting the cache can only make npm go slower, and is not likely to correct any problems you may be encountering!
+
+On the other hand, if you're debugging an issue with the installer, or race conditions that depend on the timing of writing to an empty cache, you can use \`npm install --cache /tmp/empty-cache\` to use a temporary cache instead of removing the actual one.
+
+If you're sure you want to delete the entire cache, rerun this command with --force.`)
+      }
+      return fs.rm(cachePath, { recursive: true, force: true })
+    }
+    for (const key of args) {
+      let entry
+      try {
+        entry = await cacache.get(cachePath, key)
+      } catch {
+        log.warn('cache', `Not Found: ${key}`)
+        break
+      }
+      output.standard(`Deleted: ${key}`)
+      await cacache.rm.entry(cachePath, key)
+      // XXX this could leave other entries without content!
+      await cacache.rm.content(cachePath, entry.integrity)
+    }
+  }
+
+  // npm cache add <tarball-url>...
+  // npm cache add <pkg> <ver>...
+  // npm cache add <tarball>...
+  // npm cache add <folder>...
+  async add (args) {
+    log.silly('cache add', 'args', args)
+    if (args.length === 0) {
+      throw this.usageError('First argument to `add` is required')
+    }
+
+    await Promise.all(args.map(async spec => {
+      log.silly('cache add', 'spec', spec)
+      // we ask pacote for the thing, and then just throw the data away so that it tee-pipes it into the cache like it does for a normal request.
+      await pacote.tarball.stream(spec, stream => {
+        stream.resume()
+        return stream.promise()
+      }, { ...this.npm.flatOptions, _isRoot: true })
+
+      await pacote.manifest(spec, {
+        ...this.npm.flatOptions,
+        fullMetadata: true,
+        _isRoot: true,
+      })
+    }))
+  }
+
+  async verify () {
+    // this is a derived value
+    const cachePath = this.npm.flatOptions.cache
+    const prefix = cachePath.indexOf(process.env.HOME) === 0
+      ? `~${cachePath.slice(process.env.HOME.length)}`
+      : cachePath
+    const stats = await cacache.verify(cachePath)
+    output.standard(`Cache verified and compressed (${prefix})`)
+    output.standard(`Content verified: ${stats.verifiedContent} (${stats.keptSize} bytes)`)
+    if (stats.badContentCount) {
+      output.standard(`Corrupted content removed: ${stats.badContentCount}`)
+    }
+    if (stats.reclaimedCount) {
+      output.standard(`Content garbage-collected: ${stats.reclaimedCount} (${stats.reclaimedSize} bytes)`)
+    }
+    if (stats.missingContent) {
+      output.standard(`Missing content: ${stats.missingContent}`)
+    }
+    output.standard(`Index entries: ${stats.totalEntries}`)
+    output.standard(`Finished in ${stats.runTime.total / 1000}s`)
+  }
+
+  // npm cache ls [<spec> ...]
+  async ls (specs) {
+    // This is a derived value
+    const { cache: cachePath } = this.npm.flatOptions
+    const cacheKeys = Object.keys(await cacache.ls(cachePath))
+    if (specs.length > 0) {
+      // get results for each package spec specified
+      const results = new Set()
+      for (const spec of specs) {
+        const parsed = npa(spec)
+        if (parsed.rawSpec !== '' && parsed.type === 'tag') {
+          throw this.usageError('Cannot list cache keys for a tagged package.')
+        }
+        const keySet = await searchCachePackage(cachePath, parsed, cacheKeys)
+        for (const key of keySet) {
+          results.add(key)
+        }
+      }
+      [...results].sort(localeCompare).forEach(key => output.standard(key))
+      return
+    }
+    cacheKeys.sort(localeCompare).forEach(key => output.standard(key))
+  }
+
+  async #npxCache (keys = []) {
+    // This is a derived value
+    const { npxCache } = this.npm.flatOptions
+    let dirs
+    try {
+      dirs = await fs.readdir(npxCache, { encoding: 'utf-8' })
+    } catch {
+      output.standard('npx cache does not exist')
+      return
+    }
+    const cache = {}
+    const { default: pMap } = await import('p-map')
+    await pMap(dirs, async e => {
+      const pkgPath = join(npxCache, e)
+      cache[e] = {
+        hash: e,
+        path: pkgPath,
+        valid: false,
+      }
+      try {
+        const pkgJson = await PkgJson.load(pkgPath)
+        cache[e].package = pkgJson.content
+        cache[e].valid = true
+      } catch {
+        // Defaults to not valid already
+      }
+    }, { concurrency: 20 })
+    if (!keys.length) {
+      return cache
+    }
+    const result = {}
+    const abbrevs = abbrev(Object.keys(cache))
+    for (const key of keys) {
+      if (!abbrevs[key]) {
+        throw this.usageError(`Invalid npx key ${key}`)
+      }
+      result[abbrevs[key]] = cache[abbrevs[key]]
+    }
+    return result
+  }
+
+  async npxLs () {
+    const cache = await this.#npxCache()
+    for (const key in cache) {
+      const { hash, valid, package: pkg } = cache[key]
+      let result = `${hash}:`
+      if (!valid) {
+        result = `${result} (empty/invalid)`
+      } else if (pkg?._npx) {
+        result = `${result} ${pkg._npx.packages.join(', ')}`
+      } else {
+        result = `${result} (unknown)`
+      }
+      output.standard(result)
+    }
+  }
+
+  async npxRm (keys) {
+    if (!keys.length) {
+      if (!this.npm.config.get('force')) {
+        throw this.usageError('Please use --force to remove entire npx cache')
+      }
+      const { npxCache } = this.npm.flatOptions
+      if (!this.npm.config.get('dry-run')) {
+        return fs.rm(npxCache, { recursive: true, force: true })
+      }
+    }
+
+    const cache = await this.#npxCache(keys)
+    for (const key in cache) {
+      const { path: cachePath } = cache[key]
+      output.standard(`Removing npx key at ${cachePath}`)
+      if (!this.npm.config.get('dry-run')) {
+        await fs.rm(cachePath, { recursive: true })
+      }
+    }
+  }
+
+  async npxInfo (keys) {
+    const chalk = this.npm.chalk
+    if (!keys.length) {
+      throw this.usageError()
+    }
+    const cache = await this.#npxCache(keys)
+    const Arborist = require('@npmcli/arborist')
+    for (const key in cache) {
+      const { hash, path, package: pkg } = cache[key]
+      let valid = cache[key].valid
+      const results = []
+      try {
+        if (valid) {
+          const arb = new Arborist({ path })
+          const tree = await arb.loadVirtual()
+          if (pkg._npx) {
+            results.push('packages:')
+            for (const p of pkg._npx.packages) {
+              const parsed = npa(p)
+              if (parsed.type === 'directory') {
+                // in the tree the spec is relative, even if the dependency spec is absolute, so we can't find it by name or spec.
+                results.push(`- ${chalk.cyan(p)}`)
+              } else {
+                results.push(`- ${chalk.cyan(p)} (${chalk.blue(tree.children.get(parsed.name).pkgid)})`)
+              }
+            }
+          } else {
+            results.push('packages: (unknown)')
+            results.push(`dependencies:`)
+            for (const dep in pkg.dependencies) {
+              const child = tree.children.get(dep)
+              if (child.isLink) {
+                results.push(`- ${chalk.cyan(child.realpath)}`)
+              } else {
+                results.push(`- ${chalk.cyan(child.pkgid)}`)
+              }
+            }
+          }
+        }
+      } catch (ex) {
+        valid = false
+      }
+      const v = valid ? chalk.green('valid') : chalk.red('invalid')
+      output.standard(`${v} npx cache entry with key ${chalk.blue(hash)}`)
+      output.standard(`location: ${chalk.blue(path)}`)
+      if (valid) {
+        output.standard(results.join('\n'))
+      }
+      output.standard()
+    }
+  }
+}
+
+module.exports = Cache
diff --git a/node/node_modules/npm/lib/commands/ci.js b/node/node_modules/npm/lib/commands/ci.js
new file mode 100644
index 0000000000000000000000000000000000000000..782beea2d4b60c8117ebe5e99068840eb9d40bfb
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/ci.js
@@ -0,0 +1,127 @@
+const reifyFinish = require('../utils/reify-finish.js')
+const runScript = require('@npmcli/run-script')
+const fs = require('node:fs/promises')
+const path = require('node:path')
+const { log, time } = require('proc-log')
+const validateLockfile = require('../utils/validate-lockfile.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+const getWorkspaces = require('../utils/get-workspaces.js')
+
+class CI extends ArboristWorkspaceCmd {
+  static description = 'Clean install a project'
+  static name = 'ci'
+
+  // These are in the order they will show up in when running "-h"
+  static params = [
+    'install-strategy',
+    'legacy-bundling',
+    'global-style',
+    'omit',
+    'include',
+    'strict-peer-deps',
+    'foreground-scripts',
+    'ignore-scripts',
+    'allow-git',
+    'audit',
+    'bin-links',
+    'fund',
+    'dry-run',
+    ...super.params,
+  ]
+
+  async exec () {
+    if (this.npm.global) {
+      throw Object.assign(new Error('`npm ci` does not work for global packages'), {
+        code: 'ECIGLOBAL',
+      })
+    }
+
+    const dryRun = this.npm.config.get('dry-run')
+    const ignoreScripts = this.npm.config.get('ignore-scripts')
+    const where = this.npm.prefix
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      packageLock: true, // npm ci should never skip lock files
+      path: where,
+      save: false, // npm ci should never modify the lockfile or package.json
+      workspaces: this.workspaceNames,
+    }
+
+    // generate an inventory from the virtual tree in the lockfile
+    const virtualArb = new Arborist(opts)
+    try {
+      await virtualArb.loadVirtual()
+    } catch (err) {
+      log.verbose('loadVirtual', err.stack)
+      const msg =
+        'The `npm ci` command can only install with an existing package-lock.json or\n' +
+        'npm-shrinkwrap.json with lockfileVersion >= 1. Run an install with npm@5 or\n' +
+        'later to generate a package-lock.json file, then try again.'
+      throw this.usageError(msg)
+    }
+    const virtualInventory = new Map(virtualArb.virtualTree.inventory)
+
+    // Now we make our real Arborist.
+    // We need a new one because the virtual tree fromt the lockfile can have extraneous dependencies in it that won't install on this platform
+    const arb = new Arborist(opts)
+    await arb.buildIdealTree()
+
+    // Verifies that the packages from the ideal tree will match the same versions that are present in the virtual tree (lock file).
+    const errors = validateLockfile(virtualInventory, arb.idealTree.inventory)
+    if (errors.length) {
+      throw this.usageError(
+        '`npm ci` can only install packages when your package.json and package-lock.json or npm-shrinkwrap.json are in sync. ' +
+        'Please update your lock file with `npm install` before continuing.\n\n' +
+        errors.join('\n')
+      )
+    }
+
+    if (!dryRun) {
+      const workspacePaths = await getWorkspaces([], {
+        path: this.npm.localPrefix,
+        includeWorkspaceRoot: true,
+      })
+
+      // Only remove node_modules after we've successfully loaded the virtual tree and validated the lockfile
+      await time.start('npm-ci:rm', async () => {
+        return await Promise.all([...workspacePaths.values()].map(async modulePath => {
+          const fullPath = path.join(modulePath, 'node_modules')
+          // get the list of entries so we can skip the glob for performance
+          const entries = await fs.readdir(fullPath, null).catch(() => [])
+          return Promise.all(entries.map(folder => {
+            return fs.rm(path.join(fullPath, folder), { force: true, recursive: true })
+          }))
+        }))
+      })
+    }
+
+    await arb.reify(opts)
+
+    // run the same set of scripts that `npm install` runs.
+    if (!ignoreScripts) {
+      const scripts = [
+        'preinstall',
+        'install',
+        'postinstall',
+        'prepublish', // XXX should we remove this finally??
+        'preprepare',
+        'prepare',
+        'postprepare',
+      ]
+      const scriptShell = this.npm.config.get('script-shell') || undefined
+      for (const event of scripts) {
+        await runScript({
+          path: where,
+          args: [],
+          scriptShell,
+          stdio: 'inherit',
+          event,
+        })
+      }
+    }
+    await reifyFinish(this.npm, arb)
+  }
+}
+
+module.exports = CI
diff --git a/node/node_modules/npm/lib/commands/completion.js b/node/node_modules/npm/lib/commands/completion.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d664d291acc1eb78c0863d1c7bb50358bee0b33
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/completion.js
@@ -0,0 +1,329 @@
+// Each command has a completion function that takes an options object and a cb The callback gets called with an error and an array of possible completions.
+// The options object is built up based on the environment variables set by zsh or bash when calling a function for completion, based on the cursor position and the command line thus far.
+// These are:
+// COMP_CWORD: the index of the "word" in the command line being completed
+// COMP_LINE: the full command line thus far as a string
+// COMP_POINT: the cursor index at the point of triggering completion
+//
+// We parse the command line with nopt, like npm does, and then create an options object containing:
+// words: array of words in the command line
+// w: the index of the word being completed (ie, COMP_CWORD)
+// word: the word being completed
+// line: the COMP_LINE
+// lineLength
+// point: the COMP_POINT, usually equal to line length, but not always, eg if the user has pressed the left-arrow to complete an earlier word
+// partialLine: the line up to the point
+// partialWord: the word being completed (which might be ''), up to the point
+// conf: a nopt parse of the command line
+//
+// When the implementation completion method returns its list of strings, and arrays of strings, we filter that by any that start with the partialWord, since only those can possibly be valid matches.
+//
+// Matches are wrapped with ' to escape them, if necessary, and then printed one per line for the shell completion method to consume in IFS=$'\n' mode as an array.
+
+const fs = require('node:fs/promises')
+const nopt = require('nopt')
+const { resolve } = require('node:path')
+const { output } = require('proc-log')
+const Npm = require('../npm.js')
+const { definitions, shorthands } = require('@npmcli/config/lib/definitions')
+const { commands, aliases, deref } = require('../utils/cmd-list.js')
+const { isWindowsShell } = require('../utils/is-windows.js')
+const BaseCommand = require('../base-cmd.js')
+
+const fileExists = (file) => fs.stat(file).then(s => s.isFile()).catch(() => false)
+
+class Completion extends BaseCommand {
+  static description = 'Tab Completion for npm'
+  static name = 'completion'
+  // Completion command uses args differently - they represent the command line being completed, not actual arguments to this command, so we use an empty definitions object to prevent flag validation
+  static definitions = []
+
+  // completion for the completion command
+  static async completion (opts) {
+    if (opts.w > 2) {
+      return
+    }
+
+    const [bashExists, zshExists] = await Promise.all([
+      fileExists(resolve(process.env.HOME, '.bashrc')),
+      fileExists(resolve(process.env.HOME, '.zshrc')),
+    ])
+    const out = []
+    if (zshExists) {
+      out.push(['>>', '~/.zshrc'])
+    }
+
+    if (bashExists) {
+      out.push(['>>', '~/.bashrc'])
+    }
+
+    return out
+  }
+
+  async exec (args) {
+    if (isWindowsShell) {
+      const msg = 'npm completion supported only in MINGW / Git bash on Windows'
+      throw Object.assign(new Error(msg), {
+        code: 'ENOTSUP',
+      })
+    }
+
+    const { COMP_CWORD, COMP_LINE, COMP_POINT, COMP_FISH } = process.env
+
+    // if the COMP_* isn't in the env, then just dump the script.
+    if (COMP_CWORD === undefined || COMP_LINE === undefined || COMP_POINT === undefined) {
+      return dumpScript(resolve(this.npm.npmRoot, 'lib', 'utils', 'completion.sh'))
+    }
+
+    // ok we're actually looking at the envs and outputting the suggestions get the partial line and partial word, if the point isn't at the end.
+    // ie, tabbing at: npm foo b|ar
+    const w = +COMP_CWORD
+    const line = COMP_LINE
+    // Use COMP_LINE to get words if args doesn't include flags (e.g., in tests)
+    const hasFlags = line.includes(' -') && !args.some(arg => arg.startsWith('-'))
+    const words = (hasFlags ? line.split(/\s+/) : args).map(unescape)
+    const word = words[w] || ''
+    const point = +COMP_POINT
+    const partialLine = line.slice(0, point)
+    const partialWords = words.slice(0, w)
+
+    // figure out where in that last word the point is.
+    const partialWordRaw = args[w] || ''
+    let i = partialWordRaw.length
+    while (partialWordRaw.slice(0, i) !== partialLine.slice(-1 * i) && i > 0) {
+      i--
+    }
+
+    const partialWord = unescape(partialWordRaw.slice(0, i))
+    partialWords.push(partialWord)
+
+    const opts = {
+      isFish: COMP_FISH === 'true',
+      words,
+      w,
+      word,
+      line,
+      lineLength: line.length,
+      point,
+      partialLine,
+      partialWords,
+      partialWord,
+      raw: args,
+    }
+
+    // try to find the npm command and subcommand early for flag completion this helps with custom command definitions from subcommands
+    const types = Object.entries(definitions).reduce((acc, [key, def]) => {
+      acc[key] = def.type
+      return acc
+    }, {})
+    const parsed = opts.conf =
+      nopt(types, shorthands, partialWords.slice(0, -1), 0)
+    const cmd = parsed.argv.remain[1]
+    const subCmd = parsed.argv.remain[2]
+
+    if (partialWords.slice(0, -1).indexOf('--') === -1) {
+      if (word && word.charAt(0) === '-') {
+        return this.wrap(opts, configCompl(opts, cmd, subCmd, this.npm))
+      }
+
+      if (words[w - 1] &&
+        words[w - 1].charAt(0) === '-' &&
+        !isFlag(words[w - 1], cmd, subCmd, this.npm)) {
+        // awaiting a value for a non-bool config.
+        // don't even try to do this for now
+        return this.wrap(opts, configValueCompl(opts))
+      }
+    }
+
+    // check if there's a command already.
+    if (!cmd) {
+      return this.wrap(opts, cmdCompl(opts, this.npm))
+    }
+
+    Object.keys(parsed).forEach(k => this.npm.config.set(k, parsed[k]))
+
+    // at this point, if words[1] is some kind of npm command, then complete on it.
+    // otherwise, do nothing
+    try {
+      const { completion } = Npm.cmd(cmd)
+      if (completion) {
+        const comps = await completion(opts, this.npm)
+        return this.wrap(opts, comps)
+      }
+    } catch {
+      // it wasn't a valid command, so do nothing
+    }
+  }
+
+  // The command should respond with an array.
+  // Loop over that, wrapping quotes around any that have spaces, and writing them to stdout.
+  // If any of the items are arrays, then join them with a space.
+  // e.g. returning ['a', 'b c', ['d', 'e']] would allow it to expand to: 'a', 'b c', or 'd' 'e'
+  wrap (opts, compls) {
+    if (opts.partialWord) {
+      compls = compls.filter(c => c.startsWith(opts.partialWord))
+    }
+
+    if (compls.length > 0) {
+      output.standard(compls.join('\n'))
+    }
+  }
+}
+
+const dumpScript = async (p) => {
+  const d = (await fs.readFile(p, 'utf8')).replace(/^#!.*?\n/, '')
+  await new Promise((res, rej) => {
+    let done = false
+    process.stdout.on('error', er => {
+      if (done) {
+        return
+      }
+
+      done = true
+
+      // Darwin is a pain sometimes.
+      //
+      // This is necessary because the "source" or "." program in bash on OS X closes its file argument before reading from it, meaning that you get exactly 1 write, which will work most of the time, and will always raise an EPIPE.
+      //
+      // Really, one should not be tossing away EPIPE errors, or any errors, so casually.
+      // But, without this, `. <(npm completion)` can never ever work on OS X.
+      // TODO Ignoring coverage, see 'non EPIPE errors cause failures' test.
+      /* istanbul ignore next */
+      if (er.errno === 'EPIPE') {
+        res()
+      } else {
+        rej(er)
+      }
+    })
+
+    process.stdout.write(d, () => {
+      if (done) {
+        return
+      }
+
+      done = true
+      res()
+    })
+  })
+}
+
+const unescape = w => w.charAt(0) === '\'' ? w.replace(/^'|'$/g, '')
+  : w.replace(/\\ /g, ' ')
+
+// Helper to get custom definitions from a command/subcommand
+const getCustomDefinitions = (cmd, subCmd) => {
+  if (!cmd) {
+    return []
+  }
+
+  try {
+    const command = Npm.cmd(cmd)
+
+    // Check if the command has subcommands
+    if (subCmd && command.subcommands && command.subcommands[subCmd]) {
+      const subcommand = command.subcommands[subCmd]
+      // All subcommands have definitions
+      return subcommand.definitions
+    }
+
+    // Check if the command itself has definitions
+    if (command.definitions) {
+      return command.definitions
+    }
+  } catch {
+    // Command not found or no definitions
+  }
+
+  return []
+}
+
+// Helper to get all config names including aliases from custom definitions
+const getCustomConfigNames = (customDefs) => {
+  const names = new Set()
+  for (const def of customDefs) {
+    names.add(def.key)
+    if (def.alias && Array.isArray(def.alias)) {
+      def.alias.forEach(a => names.add(a))
+    }
+  }
+  return [...names]
+}
+
+// the current word has a dash.
+// Return the config names with the same number of dashes as the current word has.
+const configCompl = (opts, cmd, subCmd, npm) => {
+  const word = opts.word
+  const split = word.match(/^(-+)((?:no-)*)(.*)$/)
+  const dashes = split[1]
+  const no = split[2]
+
+  // Get custom definitions from the command/subcommand
+  const customDefs = getCustomDefinitions(cmd, subCmd, npm)
+  const customNames = getCustomConfigNames(customDefs)
+
+  // If there are custom definitions, return only those (new feature)
+  // Otherwise, return empty array (historical behavior - no global flag completion)
+  if (customNames.length > 0) {
+    const flags = customNames.filter(name => isFlag(name, cmd, subCmd, npm))
+    return customNames.map(c => dashes + c)
+      .concat(flags.map(f => dashes + (no || 'no-') + f))
+  }
+
+  return []
+}
+
+// expand with the valid values of various config values.
+// not yet implemented.
+const configValueCompl = () => []
+
+// check if the thing is a flag or not.
+const isFlag = (word, cmd, subCmd, npm) => {
+  // shorthands never take args.
+  const split = word.match(/^(-*)((?:no-)+)?(.*)$/)
+  const no = split[2]
+  const conf = split[3]
+
+  // Check custom definitions first
+  const customDefs = getCustomDefinitions(cmd, subCmd, npm)
+
+  // Check if conf is in custom definitions or is an alias
+  let customDef = customDefs.find(d => d.key === conf)
+  if (!customDef) {
+    // Check if conf is an alias for any of the custom definitions
+    for (const def of customDefs) {
+      if (def.alias && Array.isArray(def.alias) && def.alias.includes(conf)) {
+        customDef = def
+        break
+      }
+    }
+  }
+
+  if (customDef) {
+    const { type } = customDef
+    return no ||
+      type === Boolean ||
+      (Array.isArray(type) && type.includes(Boolean))
+  }
+
+  // No custom definitions found, should not reach here in normal flow since configCompl returns empty array when no custom defs exist
+  return false
+}
+
+// complete against the npm commands
+// if they all resolve to the same thing, just return the thing it already is
+const cmdCompl = (opts) => {
+  const allCommands = commands.concat(Object.keys(aliases))
+  const matches = allCommands.filter(c => c.startsWith(opts.partialWord))
+  if (!matches.length) {
+    return matches
+  }
+
+  const derefs = new Set([...matches.map(c => deref(c))])
+  if (derefs.size === 1) {
+    return [...derefs]
+  }
+
+  return allCommands
+}
+
+module.exports = Completion
diff --git a/node/node_modules/npm/lib/commands/config.js b/node/node_modules/npm/lib/commands/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..5c5f1db40bda28cc5731f7237e5a31e81b981432
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/config.js
@@ -0,0 +1,414 @@
+const { mkdir, readFile, writeFile } = require('node:fs/promises')
+const { dirname, resolve } = require('node:path')
+const { spawn } = require('node:child_process')
+const { EOL } = require('node:os')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const pkgJson = require('@npmcli/package-json')
+const { defaults, definitions, nerfDarts, proxyEnv } = require('@npmcli/config/lib/definitions')
+const { log, output } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+const { redact } = require('@npmcli/redact')
+
+// These are the config values to swap with "protected".
+// It does not catch every single sensitive thing a user may put in the npmrc file but it gets the common ones.
+// This is distinct from nerfDarts because that is used to validate valid configs during "npm config set", and folks may have old invalid entries lying around in a config file that we still want to protect when running "npm config list"
+// This is a more general list of values to consider protected.
+// You cannot "npm config get" them, and they will not display during "npm config list"
+const protected = [
+  'auth',
+  'authToken',
+  'certfile',
+  'email',
+  'keyfile',
+  'password',
+  'username',
+]
+
+// take an array of `[key, value, k2=v2, k3, v3, ...]` and turn into { key: value, k2: v2, k3: v3 }
+const keyValues = args => {
+  const kv = {}
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i].split('=')
+    const key = arg.shift()
+    const val = arg.length ? arg.join('=')
+      : i < args.length - 1 ? args[++i]
+      : ''
+    kv[key.trim()] = val.trim()
+  }
+  return kv
+}
+
+const isProtected = (k) => {
+  // _password
+  if (k.startsWith('_')) {
+    return true
+  }
+  if (protected.includes(k)) {
+    return true
+  }
+  // //localhost:8080/:_password
+  if (k.startsWith('//')) {
+    if (k.includes(':_')) {
+      return true
+    }
+    // //registry:_authToken or //registry:authToken
+    for (const p of protected) {
+      if (k.endsWith(`:${p}`) || k.endsWith(`:_${p}`)) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// Private fields are either protected or they can redacted info
+const isPrivate = (k, v) => isProtected(k) || redact(v) !== v
+
+const displayVar = (k, v) =>
+  `${k} = ${isProtected(k, v) ? '(protected)' : JSON.stringify(redact(v))}`
+
+class Config extends BaseCommand {
+  static description = 'Manage the npm configuration files'
+  static name = 'config'
+  static usage = [
+    'set <key>=<value> [<key>=<value> ...]',
+    'get [<key> [<key> ...]]',
+    'delete <key> [<key> ...]',
+    'list [--json]',
+    'edit',
+    'fix',
+  ]
+
+  static params = [
+    'json',
+    'global',
+    'editor',
+    'location',
+    'long',
+  ]
+
+  static ignoreImplicitWorkspace = false
+
+  static skipConfigValidation = true
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv[1] !== 'config') {
+      argv.unshift('config')
+    }
+
+    if (argv.length === 2) {
+      const cmds = ['get', 'set', 'delete', 'ls', 'rm', 'edit', 'fix']
+      if (opts.partialWord !== 'l') {
+        cmds.push('list')
+      }
+
+      return cmds
+    }
+
+    const action = argv[2]
+    switch (action) {
+      case 'set':
+        // TODO: complete with valid values, if possible.
+        if (argv.length > 3) {
+          return []
+        }
+
+        // fallthrough
+        /* eslint no-fallthrough:0 */
+      case 'get':
+      case 'delete':
+      case 'rm':
+        return Object.keys(definitions)
+      case 'edit':
+      case 'list':
+      case 'ls':
+      case 'fix':
+      default:
+        return []
+    }
+  }
+
+  async exec ([action, ...args]) {
+    switch (action) {
+      case 'set':
+        await this.set(args)
+        break
+      case 'get':
+        await this.get(args)
+        break
+      case 'delete':
+      case 'rm':
+      case 'del':
+        await this.del(args)
+        break
+      case 'list':
+      case 'ls':
+        await (this.npm.flatOptions.json ? this.listJson() : this.list())
+        break
+      case 'edit':
+        await this.edit()
+        break
+      case 'fix':
+        await this.fix()
+        break
+      default:
+        throw this.usageError()
+    }
+  }
+
+  async set (args) {
+    if (!args.length) {
+      throw this.usageError()
+    }
+
+    const where = this.npm.flatOptions.location
+    for (const [key, val] of Object.entries(keyValues(args))) {
+      log.info('config', 'set %j %j', key, val)
+      const baseKey = key.split(':').pop()
+      if (!this.npm.config.definitions[baseKey] && !nerfDarts.includes(baseKey)) {
+        throw new Error(`\`${baseKey}\` is not a valid npm option`)
+      }
+      const deprecated = this.npm.config.definitions[baseKey]?.deprecated
+      if (deprecated) {
+        throw new Error(
+          `The \`${baseKey}\` option is deprecated, and cannot be set in this way${deprecated}`
+        )
+      }
+
+      if (val === '') {
+        this.npm.config.delete(key, where)
+      } else {
+        this.npm.config.set(key, val, where)
+      }
+
+      if (!this.npm.config.validate(where)) {
+        log.warn('config', 'omitting invalid config values')
+      }
+    }
+
+    await this.npm.config.save(where)
+  }
+
+  async get (keys) {
+    if (!keys.length) {
+      return this.list()
+    }
+
+    const out = []
+    for (const key of keys) {
+      const val = this.npm.config.get(key)
+      if (isPrivate(key, val)) {
+        throw new Error(`The ${key} option is protected, and cannot be retrieved in this way`)
+      }
+
+      const pref = keys.length > 1 ? `${key}=` : ''
+      out.push(pref + val)
+    }
+    output.standard(out.join('\n'))
+  }
+
+  async del (keys) {
+    if (!keys.length) {
+      throw this.usageError()
+    }
+
+    const where = this.npm.flatOptions.location
+    for (const key of keys) {
+      this.npm.config.delete(key, where)
+    }
+    await this.npm.config.save(where)
+  }
+
+  async edit () {
+    const ini = require('ini')
+    const e = this.npm.flatOptions.editor
+    const where = this.npm.flatOptions.location
+    const file = this.npm.config.data.get(where).source
+
+    // save first, just to make sure it's synced up
+    // this also removes all the comments from the last time we edited it.
+    await this.npm.config.save(where)
+
+    const data = (
+      await readFile(file, 'utf8').catch(() => '')
+    ).replace(/\r\n/g, '\n')
+    const entries = Object.entries(defaults)
+    const defData = entries.reduce((str, [key, val]) => {
+      const obj = { [key]: val }
+      const i = ini.stringify(obj)
+        .replace(/\r\n/g, '\n') // normalizes output from ini.stringify
+        .replace(/\n$/m, '')
+        .replace(/^/g, '; ')
+        .replace(/\n/g, '\n; ')
+        .split('\n')
+      return str + '\n' + i
+    }, '')
+
+    const tmpData = `;;;;
+; npm ${where}config file: ${file}
+; this is a simple ini-formatted file
+; lines that start with semi-colons are comments
+; run \`npm help 7 config\` for documentation of the various options
+;
+; Configs like \`@scope:registry\` map a scope to a given registry url.
+;
+; Configs like \`//<hostname>/:_authToken\` are auth that is restricted
+; to the registry host specified.
+
+${data.split('\n').sort(localeCompare).join('\n').trim()}
+
+;;;;
+; all available options shown below with default values
+;;;;
+
+${defData}
+`.split('\n').join(EOL)
+    await mkdir(dirname(file), { recursive: true })
+    await writeFile(file, tmpData, 'utf8')
+    await new Promise((res, rej) => {
+      const [bin, ...args] = e.split(/\s+/)
+      const editor = spawn(bin, [...args, file], { stdio: 'inherit' })
+      editor.on('exit', (code) => {
+        if (code) {
+          return rej(new Error(`editor process exited with code: ${code}`))
+        }
+        return res()
+      })
+    })
+  }
+
+  async fix () {
+    let problems
+
+    try {
+      this.npm.config.validate()
+      return // if validate doesn't throw we have nothing to do
+    } catch (err) {
+      // coverage skipped because we don't need to test rethrowing errors
+      // istanbul ignore next
+      if (err.code !== 'ERR_INVALID_AUTH') {
+        throw err
+      }
+
+      problems = err.problems
+    }
+
+    if (!this.npm.config.isDefault('location')) {
+      problems = problems.filter((problem) => {
+        return problem.where === this.npm.config.get('location')
+      })
+    }
+
+    this.npm.config.repair(problems)
+    const locations = []
+
+    output.standard('The following configuration problems have been repaired:\n')
+    const summary = problems.map(({ action, from, to, key, where }) => {
+      // coverage disabled for else branch because it is intentionally omitted
+      // istanbul ignore else
+      if (action === 'rename') {
+        // we keep track of which configs were modified here so we know what to save later
+        locations.push(where)
+        return `~ \`${from}\` renamed to \`${to}\` in ${where} config`
+      } else if (action === 'delete') {
+        locations.push(where)
+        return `- \`${key}\` deleted from ${where} config`
+      }
+    }).join('\n')
+    output.standard(summary)
+
+    return await Promise.all(locations.map((location) => this.npm.config.save(location)))
+  }
+
+  async list () {
+    const msg = []
+    // long does not have a flattener
+    const long = this.npm.config.get('long')
+    for (const [where, { data, source }] of this.npm.config.data.entries()) {
+      if (where === 'default' && !long) {
+        continue
+      }
+
+      const entries = Object.entries(data).sort(([a], [b]) => localeCompare(a, b))
+      if (!entries.length) {
+        continue
+      }
+
+      msg.push(`; "${where}" config from ${source}`, '')
+      for (const [k, v] of entries) {
+        const display = displayVar(k, v)
+        const src = this.npm.config.find(k)
+        msg.push(src === where ? display : `; ${display} ; overridden by ${src}`)
+        msg.push()
+      }
+      msg.push('')
+    }
+
+    if (!long) {
+      const envVars = []
+
+      const foundEnvVars = new Set()
+      for (const key of Object.keys(process.env)) {
+        const lowerKey = key.toLowerCase()
+        if (proxyEnv.includes(lowerKey) && !foundEnvVars.has(lowerKey)) {
+          foundEnvVars.add(lowerKey)
+          envVars.push(`; ${key} = ${JSON.stringify(process.env[key])}`)
+        }
+      }
+
+      if (envVars.length > 0) {
+        msg.push('; environment-related config', '')
+        msg.push(...envVars)
+        msg.push('')
+      }
+
+      msg.push(
+        `; node bin location = ${process.execPath}`,
+        `; node version = ${process.version}`,
+        `; npm local prefix = ${this.npm.localPrefix}`,
+        `; npm version = ${this.npm.version}`,
+        `; cwd = ${process.cwd()}`,
+        `; HOME = ${process.env.HOME}`,
+        '; Run `npm config ls -l` to show all defaults.'
+      )
+      msg.push('')
+    }
+
+    if (!this.npm.global) {
+      const { content } = await pkgJson.normalize(this.npm.prefix).catch(() => ({ content: {} }))
+
+      if (content.publishConfig) {
+        for (const key in content.publishConfig) {
+          this.npm.config.checkUnknown('publishConfig', key)
+        }
+        const pkgPath = resolve(this.npm.prefix, 'package.json')
+        msg.push(`; "publishConfig" from ${pkgPath}`)
+        msg.push('; This set of config values will be used at publish-time.', '')
+        const entries = Object.entries(content.publishConfig)
+          .sort(([a], [b]) => localeCompare(a, b))
+        for (const [k, value] of entries) {
+          msg.push(displayVar(k, value))
+        }
+        msg.push('')
+      }
+    }
+
+    output.standard(msg.join('\n').trim())
+  }
+
+  async listJson () {
+    const publicConf = {}
+    for (const key in this.npm.config.list[0]) {
+      const value = this.npm.config.get(key)
+      if (isPrivate(key, value)) {
+        continue
+      }
+
+      publicConf[key] = value
+    }
+    output.buffer(publicConf)
+  }
+}
+
+module.exports = Config
diff --git a/node/node_modules/npm/lib/commands/dedupe.js b/node/node_modules/npm/lib/commands/dedupe.js
new file mode 100644
index 0000000000000000000000000000000000000000..da5e2db56145426c2bef73f50cbe221b017f11ea
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/dedupe.js
@@ -0,0 +1,51 @@
+const reifyFinish = require('../utils/reify-finish.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+// dedupe duplicated packages, or find them in the tree
+class Dedupe extends ArboristWorkspaceCmd {
+  static description = 'Reduce duplication in the package tree'
+  static name = 'dedupe'
+  static params = [
+    'install-strategy',
+    'legacy-bundling',
+    'global-style',
+    'strict-peer-deps',
+    'package-lock',
+    'omit',
+    'include',
+    'ignore-scripts',
+    'allow-git',
+    'audit',
+    'bin-links',
+    'fund',
+    'dry-run',
+    ...super.params,
+  ]
+
+  async exec () {
+    if (this.npm.global) {
+      const er = new Error('`npm dedupe` does not work in global mode.')
+      er.code = 'EDEDUPEGLOBAL'
+      throw er
+    }
+
+    const dryRun = this.npm.config.get('dry-run')
+    const where = this.npm.prefix
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      path: where,
+      dryRun,
+      // Saving during dedupe would only update if one of your direct dependencies was also duplicated somewhere in your tree.
+      // It would be confusing if running this were to also update your package.json.
+      // In order to reduce potential confusion we set this to false.
+      save: false,
+      workspaces: this.workspaceNames,
+    }
+    const arb = new Arborist(opts)
+    await arb.dedupe(opts)
+    await reifyFinish(this.npm, arb)
+  }
+}
+
+module.exports = Dedupe
diff --git a/node/node_modules/npm/lib/commands/deprecate.js b/node/node_modules/npm/lib/commands/deprecate.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f5f98dd40ec8dea49410fe6a1c40ecc31fba6a9
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/deprecate.js
@@ -0,0 +1,86 @@
+const npmFetch = require('npm-registry-fetch')
+const { otplease } = require('../utils/auth.js')
+const npa = require('npm-package-arg')
+const { log } = require('proc-log')
+const semver = require('semver')
+const getIdentity = require('../utils/get-identity.js')
+const libaccess = require('libnpmaccess')
+const BaseCommand = require('../base-cmd.js')
+
+class Deprecate extends BaseCommand {
+  static description = 'Deprecate a version of a package'
+  static name = 'deprecate'
+  static usage = ['<package-spec> <message>']
+  static params = [
+    'registry',
+    'otp',
+    'dry-run',
+  ]
+
+  static ignoreImplicitWorkspace = true
+
+  static async completion (opts, npm) {
+    if (opts.conf.argv.remain.length > 1) {
+      return []
+    }
+
+    const username = await getIdentity(npm, npm.flatOptions)
+    const packages = await libaccess.getPackages(username, npm.flatOptions)
+    return Object.keys(packages)
+      .filter((name) =>
+        packages[name] === 'write' &&
+        (opts.conf.argv.remain.length === 0 ||
+          name.startsWith(opts.conf.argv.remain[0])))
+  }
+
+  async exec ([pkg, msg]) {
+    // msg == null because '' is a valid value, it indicates undeprecate
+    if (!pkg || msg == null) {
+      throw this.usageError()
+    }
+
+    // fetch the data and make sure it exists.
+    const p = npa(pkg)
+    const spec = p.rawSpec === '*' ? '*' : p.fetchSpec
+
+    if (semver.validRange(spec, true) === null) {
+      throw new Error(`invalid version range: ${spec}`)
+    }
+
+    const uri = '/' + p.escapedName
+    const packument = await npmFetch.json(uri, {
+      ...this.npm.flatOptions,
+      spec: p,
+      query: { write: true },
+    })
+
+    const versions = Object.keys(packument.versions)
+      .filter(v => semver.satisfies(v, spec, { includePrerelease: true }))
+
+    const dryRun = this.npm.config.get('dry-run')
+
+    if (versions.length) {
+      for (const v of versions) {
+        packument.versions[v].deprecated = msg
+        if (msg) {
+          log.notice(`deprecating ${packument.name}@${v} with message "${msg}"`)
+        } else {
+          log.notice(`undeprecating ${packument.name}@${v}`)
+        }
+      }
+      if (!dryRun) {
+        return otplease(this.npm, this.npm.flatOptions, opts => npmFetch(uri, {
+          ...opts,
+          spec: p,
+          method: 'PUT',
+          body: packument,
+          ignoreBody: true,
+        }))
+      }
+    } else {
+      log.warn('deprecate', 'No version found for', p.rawSpec)
+    }
+  }
+}
+
+module.exports = Deprecate
diff --git a/node/node_modules/npm/lib/commands/diff.js b/node/node_modules/npm/lib/commands/diff.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8a3ac52559b223ee6d183beb6cd663f6b2cc646
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/diff.js
@@ -0,0 +1,280 @@
+const { resolve } = require('node:path')
+const semver = require('semver')
+const libnpmdiff = require('libnpmdiff')
+const npa = require('npm-package-arg')
+const pacote = require('pacote')
+const pickManifest = require('npm-pick-manifest')
+const { log, output } = require('proc-log')
+const pkgJson = require('@npmcli/package-json')
+const BaseCommand = require('../base-cmd.js')
+
+class Diff extends BaseCommand {
+  static description = 'The registry diff command'
+  static name = 'diff'
+  static usage = [
+    '[...<paths>]',
+  ]
+
+  static params = [
+    'diff',
+    'diff-name-only',
+    'diff-unified',
+    'diff-ignore-all-space',
+    'diff-no-prefix',
+    'diff-src-prefix',
+    'diff-dst-prefix',
+    'diff-text',
+    'global',
+    'tag',
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  async exec (args) {
+    const specs = this.npm.config.get('diff').filter(d => d)
+    if (specs.length > 2) {
+      throw this.usageError(`Can't use more than two --diff arguments.`)
+    }
+
+    // execWorkspaces may have set this already
+    if (!this.prefix) {
+      this.prefix = this.npm.prefix
+    }
+
+    // this is the "top" directory, one up from node_modules in global mode we have to walk one up from globalDir because our node_modules is sometimes under ./lib, and in global mode we're only ever walking through node_modules (because we will have been given a package name already)
+    if (this.npm.global) {
+      this.top = resolve(this.npm.globalDir, '..')
+    } else {
+      this.top = this.prefix
+    }
+
+    const [a, b] = await this.retrieveSpecs(specs)
+    log.info('diff', { src: a, dst: b })
+
+    const res = await libnpmdiff([a, b], {
+      ...this.npm.flatOptions,
+      diffFiles: args,
+      where: this.top,
+    })
+    return output.standard(res)
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+    for (const workspacePath of this.workspacePaths) {
+      this.top = workspacePath
+      this.prefix = workspacePath
+      await this.exec(args)
+    }
+  }
+
+  // get the package name from the packument at `path`
+  // throws if no packument is present OR if it does not have `name` attribute
+  async packageName () {
+    let name
+    try {
+      const { content: pkg } = await pkgJson.normalize(this.prefix)
+      name = pkg.name
+    } catch {
+      log.verbose('diff', 'could not read project dir package.json')
+    }
+
+    if (!name) {
+      throw this.usageError('Needs multiple arguments to compare or run from a project dir.')
+    }
+
+    return name
+  }
+
+  async retrieveSpecs ([a, b]) {
+    if (a && b) {
+      const specs = await this.convertVersionsToSpecs([a, b])
+      return this.findVersionsByPackageName(specs)
+    }
+
+    // no arguments, defaults to comparing cwd to its latest published registry version
+    if (!a) {
+      const pkgName = await this.packageName()
+      return [
+        `${pkgName}@${this.npm.config.get('tag')}`,
+        `file:${this.prefix}`,
+      ]
+    }
+
+    // single argument, used to compare wanted versions of an installed dependency or to compare the cwd to a published version
+    let noPackageJson
+    let pkgName
+    try {
+      const { content: pkg } = await pkgJson.normalize(this.prefix)
+      pkgName = pkg.name
+    } catch {
+      log.verbose('diff', 'could not read project dir package.json')
+      noPackageJson = true
+    }
+
+    const missingPackageJson =
+      this.usageError('Needs multiple arguments to compare or run from a project dir.')
+
+    // using a valid semver range, that means it should just diff the cwd against a published version to the registry using the same project name and the provided semver range
+    if (semver.validRange(a)) {
+      if (!pkgName) {
+        throw missingPackageJson
+      }
+      return [
+        `${pkgName}@${a}`,
+        `file:${this.prefix}`,
+      ]
+    }
+
+    // when using a single package name as arg and it's part of the current install tree, then retrieve the current installed version and compare it against the same value `npm outdated` would suggest you to update to
+    const spec = npa(a)
+    if (spec.registry) {
+      let actualTree
+      let node
+      const Arborist = require('@npmcli/arborist')
+      try {
+        const opts = {
+          ...this.npm.flatOptions,
+          path: this.top,
+        }
+        const arb = new Arborist(opts)
+        actualTree = await arb.loadActual(opts)
+        node = actualTree &&
+          actualTree.inventory.query('name', spec.name)
+            .values().next().value
+      } catch {
+        log.verbose('diff', 'failed to load actual install tree')
+      }
+
+      if (!node || !node.name || !node.package || !node.package.version) {
+        if (noPackageJson) {
+          throw missingPackageJson
+        }
+        return [
+          `${spec.name}@${spec.fetchSpec}`,
+          `file:${this.prefix}`,
+        ]
+      }
+
+      const tryRootNodeSpec = () =>
+        (actualTree && actualTree.edgesOut.get(spec.name) || {}).spec
+
+      const tryAnySpec = () => {
+        for (const edge of node.edgesIn) {
+          return edge.spec
+        }
+      }
+
+      const aSpec = `file:${node.realpath}`
+
+      // finds what version of the package to compare against
+      // if an exact version or tag was passed than it should use that
+      // otherwise, work from the top of the arborist tree to find the original semver range declared in the package that depends on the package.
+      let bSpec
+      if (spec.rawSpec !== '*') {
+        bSpec = spec.rawSpec
+      } else {
+        const bTargetVersion =
+          tryRootNodeSpec()
+          || tryAnySpec()
+
+        // figure out what to compare against
+        // follows same logic to npm outdated "Wanted" results
+        const packument = await pacote.packument(spec, {
+          ...this.npm.flatOptions,
+          preferOnline: true,
+          _isRoot: true,
+        })
+        bSpec = pickManifest(
+          packument,
+          bTargetVersion,
+          { ...this.npm.flatOptions }
+        ).version
+      }
+
+      return [
+        `${spec.name}@${aSpec}`,
+        `${spec.name}@${bSpec}`,
+      ]
+    } else if (spec.type === 'directory') {
+      return [
+        `file:${spec.fetchSpec}`,
+        `file:${this.prefix}`,
+      ]
+    } else {
+      throw this.usageError(`Spec type ${spec.type} not supported.`)
+    }
+  }
+
+  async convertVersionsToSpecs ([a, b]) {
+    const semverA = semver.validRange(a)
+    const semverB = semver.validRange(b)
+
+    // both specs are semver versions, assume current project dir name
+    if (semverA && semverB) {
+      let pkgName
+      try {
+        const { content: pkg } = await pkgJson.normalize(this.prefix)
+        pkgName = pkg.name
+      } catch {
+        log.verbose('diff', 'could not read project dir package.json')
+      }
+
+      if (!pkgName) {
+        throw this.usageError('Needs to be run from a project dir in order to diff two versions.')
+      }
+
+      return [`${pkgName}@${a}`, `${pkgName}@${b}`]
+    }
+
+    // otherwise uses the name from the other arg to figure out the spec.name of what to compare
+    if (!semverA && semverB) {
+      return [a, `${npa(a).name}@${b}`]
+    }
+
+    if (semverA && !semverB) {
+      return [`${npa(b).name}@${a}`, b]
+    }
+
+    // no valid semver ranges used
+    return [a, b]
+  }
+
+  async findVersionsByPackageName (specs) {
+    let actualTree
+    const Arborist = require('@npmcli/arborist')
+    try {
+      const opts = {
+        ...this.npm.flatOptions,
+        path: this.top,
+      }
+      const arb = new Arborist(opts)
+      actualTree = await arb.loadActual(opts)
+    } catch {
+      log.verbose('diff', 'failed to load actual install tree')
+    }
+
+    return specs.map(i => {
+      const spec = npa(i)
+      if (spec.rawSpec !== '*') {
+        return i
+      }
+
+      const node = actualTree
+        && actualTree.inventory.query('name', spec.name)
+          .values().next().value
+
+      const res = !node || !node.package || !node.package.version
+        ? spec.fetchSpec
+        : `file:${node.realpath}`
+
+      return `${spec.name}@${res}`
+    })
+  }
+}
+
+module.exports = Diff
diff --git a/node/node_modules/npm/lib/commands/dist-tag.js b/node/node_modules/npm/lib/commands/dist-tag.js
new file mode 100644
index 0000000000000000000000000000000000000000..e21c86f2affee058ab4465ed336e6ad9cde43808
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/dist-tag.js
@@ -0,0 +1,207 @@
+const npa = require('npm-package-arg')
+const npmFetch = require('npm-registry-fetch')
+const semver = require('semver')
+const { log, output } = require('proc-log')
+const { otplease } = require('../utils/auth.js')
+const pkgJson = require('@npmcli/package-json')
+const BaseCommand = require('../base-cmd.js')
+
+class DistTag extends BaseCommand {
+  static description = 'Modify package distribution tags'
+  static params = ['workspace', 'workspaces', 'include-workspace-root']
+  static name = 'dist-tag'
+  static usage = [
+    'add <package-spec (with version)> [<tag>]',
+    'rm <package-spec> <tag>',
+    'ls [<package-spec>]',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      return ['add', 'rm', 'ls']
+    }
+
+    switch (argv[2]) {
+      default:
+        return []
+    }
+  }
+
+  async exec ([cmdName, pkg, tag]) {
+    const opts = {
+      ...this.npm.flatOptions,
+    }
+
+    if (['add', 'a', 'set', 's'].includes(cmdName)) {
+      return this.add(pkg, tag, opts)
+    }
+
+    if (['rm', 'r', 'del', 'd', 'remove'].includes(cmdName)) {
+      return this.remove(pkg, tag, opts)
+    }
+
+    if (['ls', 'l', 'sl', 'list'].includes(cmdName)) {
+      return this.list(pkg, opts)
+    }
+
+    if (!pkg) {
+      // when only using the pkg name the default behavior should be listing the existing tags
+      return this.list(cmdName, opts)
+    } else {
+      throw this.usageError()
+    }
+  }
+
+  async execWorkspaces ([cmdName, pkg, tag]) {
+    // cmdName is some form of list
+    // pkg is one of:
+    // - unset
+    // - .
+    // - .@version
+    if (['ls', 'l', 'sl', 'list'].includes(cmdName) && (!pkg || pkg === '.' || /^\.@/.test(pkg))) {
+      return this.listWorkspaces()
+    }
+
+    // pkg is unset
+    // cmdName is one of:
+    // - unset
+    // - .
+    // - .@version
+    if (!pkg && (!cmdName || cmdName === '.' || /^\.@/.test(cmdName))) {
+      return this.listWorkspaces()
+    }
+
+    // anything else is just a regular dist-tag command
+    // so we fall back to the non-workspaces implementation
+    log.warn('dist-tag', 'Ignoring workspaces for specified package')
+    return this.exec([cmdName, pkg, tag])
+  }
+
+  async add (spec, tag, opts) {
+    spec = npa(spec || '')
+    const version = spec.rawSpec
+    const defaultTag = tag || this.npm.config.get('tag')
+
+    log.verbose('dist-tag add', defaultTag, 'to', spec.name + '@' + version)
+
+    // make sure new spec with tag is valid, this will throw if invalid
+    npa(`${spec.name}@${defaultTag}`)
+
+    if (!spec.name || !version || !defaultTag) {
+      throw this.usageError('must provide a spec with a name and version, and a tag to add')
+    }
+
+    const t = defaultTag.trim()
+
+    if (semver.validRange(t)) {
+      throw new Error('Tag name must not be a valid SemVer range: ' + t)
+    }
+
+    const tags = await this.fetchTags(spec, opts)
+    if (tags[t] === version) {
+      log.warn('dist-tag add', t, 'is already set to version', version)
+      return
+    }
+    tags[t] = version
+    const url =
+      `/-/package/${spec.escapedName}/dist-tags/${encodeURIComponent(t)}`
+    const reqOpts = {
+      ...opts,
+      method: 'PUT',
+      body: JSON.stringify(version),
+      headers: {
+        'content-type': 'application/json',
+      },
+      spec,
+    }
+    await otplease(this.npm, reqOpts, o => npmFetch(url, o))
+    output.standard(`+${t}: ${spec.name}@${version}`)
+  }
+
+  async remove (spec, tag, opts) {
+    spec = npa(spec || '')
+    log.verbose('dist-tag del', tag, 'from', spec.name)
+
+    if (!spec.name) {
+      throw this.usageError()
+    }
+
+    const tags = await this.fetchTags(spec, opts)
+    if (!tags[tag]) {
+      log.info('dist-tag del', tag, 'is not a dist-tag on', spec.name)
+      throw new Error(tag + ' is not a dist-tag on ' + spec.name)
+    }
+    const version = tags[tag]
+    delete tags[tag]
+    const url =
+      `/-/package/${spec.escapedName}/dist-tags/${encodeURIComponent(tag)}`
+    const reqOpts = {
+      ...opts,
+      method: 'DELETE',
+      spec,
+    }
+    await otplease(this.npm, reqOpts, o => npmFetch(url, o))
+    output.standard(`-${tag}: ${spec.name}@${version}`)
+  }
+
+  async list (spec, opts) {
+    if (!spec) {
+      if (this.npm.global) {
+        throw this.usageError()
+      }
+      const { content: { name } } = await pkgJson.normalize(this.npm.prefix)
+      if (!name) {
+        throw this.usageError()
+      }
+
+      return this.list(name, opts)
+    }
+    spec = npa(spec)
+
+    try {
+      const tags = await this.fetchTags(spec, opts)
+      const msg =
+        Object.keys(tags).map(k => `${k}: ${tags[k]}`).sort().join('\n')
+      output.standard(msg)
+      return tags
+    } catch (err) {
+      log.error('dist-tag ls', "Couldn't get dist-tag data for", spec)
+      throw err
+    }
+  }
+
+  async listWorkspaces () {
+    await this.setWorkspaces()
+
+    for (const name of this.workspaceNames) {
+      try {
+        output.standard(`${name}:`)
+        await this.list(npa(name), this.npm.flatOptions)
+      } catch {
+        // set the exitCode directly, but ignore the error since it will have already been logged by this.list()
+        process.exitCode = 1
+      }
+    }
+  }
+
+  async fetchTags (spec, opts) {
+    const data = await npmFetch.json(
+      `/-/package/${spec.escapedName}/dist-tags`,
+      { ...opts, 'prefer-online': true, spec }
+    )
+    if (data && typeof data === 'object') {
+      delete data._etag
+    }
+    if (!data || !Object.keys(data).length) {
+      throw new Error('No dist-tags found for ' + spec.name)
+    }
+
+    return data
+  }
+}
+
+module.exports = DistTag
diff --git a/node/node_modules/npm/lib/commands/docs.js b/node/node_modules/npm/lib/commands/docs.js
new file mode 100644
index 0000000000000000000000000000000000000000..de2492833690d26e1c73592a361e2eca992ccf07
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/docs.js
@@ -0,0 +1,21 @@
+const PackageUrlCmd = require('../package-url-cmd.js')
+
+class Docs extends PackageUrlCmd {
+  static description = 'Open documentation for a package in a web browser'
+  static name = 'docs'
+
+  getUrl (spec, mani) {
+    if (mani.homepage) {
+      return mani.homepage
+    }
+
+    const info = this.hostedFromMani(mani)
+    if (info) {
+      return info.docs()
+    }
+
+    return `https://www.npmjs.com/package/${mani.name}`
+  }
+}
+
+module.exports = Docs
diff --git a/node/node_modules/npm/lib/commands/doctor.js b/node/node_modules/npm/lib/commands/doctor.js
new file mode 100644
index 0000000000000000000000000000000000000000..255f71f9717683f00a4bf706abb3bfdde0bb4024
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/doctor.js
@@ -0,0 +1,343 @@
+const cacache = require('cacache')
+const { access, lstat, readdir, constants: { R_OK, W_OK, X_OK } } = require('node:fs/promises')
+const npmFetch = require('make-fetch-happen')
+const which = require('which')
+const pacote = require('pacote')
+const { resolve } = require('node:path')
+const semver = require('semver')
+const { log, output } = require('proc-log')
+const ping = require('../utils/ping.js')
+const { defaults } = require('@npmcli/config/lib/definitions')
+const BaseCommand = require('../base-cmd.js')
+
+const maskLabel = mask => {
+  const label = []
+  if (mask & R_OK) {
+    label.push('readable')
+  }
+
+  if (mask & W_OK) {
+    label.push('writable')
+  }
+
+  if (mask & X_OK) {
+    label.push('executable')
+  }
+
+  return label.join(', ')
+}
+
+const checks = [
+  {
+    // Ping is left in as a legacy command but is listed as "connection" to make more sense to more people
+    groups: ['connection', 'ping', 'registry'],
+    title: 'Connecting to the registry',
+    cmd: 'checkPing',
+  }, {
+    groups: ['versions'],
+    title: 'Checking npm version',
+    cmd: 'getLatestNpmVersion',
+  }, {
+    groups: ['versions'],
+    title: 'Checking node version',
+    cmd: 'getLatestNodejsVersion',
+  }, {
+    groups: ['registry'],
+    title: 'Checking configured npm registry',
+    cmd: 'checkNpmRegistry',
+  }, {
+    groups: ['environment'],
+    title: 'Checking for git executable in PATH',
+    cmd: 'getGitPath',
+  }, {
+    groups: ['environment'],
+    title: 'Checking for global bin folder in PATH',
+    cmd: 'getBinPath',
+  }, {
+    groups: ['permissions', 'cache'],
+    title: 'Checking permissions on cached files (this may take awhile)',
+    cmd: 'checkCachePermission',
+    windows: false,
+  }, {
+    groups: ['permissions'],
+    title: 'Checking permissions on local node_modules (this may take awhile)',
+    cmd: 'checkLocalModulesPermission',
+    windows: false,
+  }, {
+    groups: ['permissions'],
+    title: 'Checking permissions on global node_modules (this may take awhile)',
+    cmd: 'checkGlobalModulesPermission',
+    windows: false,
+  }, {
+    groups: ['permissions'],
+    title: 'Checking permissions on local bin folder',
+    cmd: 'checkLocalBinPermission',
+    windows: false,
+  }, {
+    groups: ['permissions'],
+    title: 'Checking permissions on global bin folder',
+    cmd: 'checkGlobalBinPermission',
+    windows: false,
+  }, {
+    groups: ['cache'],
+    title: 'Verifying cache contents (this may take awhile)',
+    cmd: 'verifyCachedFiles',
+    windows: false,
+  },
+  // TODO:
+  // group === 'dependencies'?
+  //   - ensure arborist.loadActual() runs without errors and no invalid edges
+  //   - ensure package-lock.json matches loadActual()
+  //   - verify loadActual without hidden lock file matches hidden lockfile
+  // group === '???'
+  //   - verify all local packages have bins linked
+  // What is the fix for these?
+]
+
+class Doctor extends BaseCommand {
+  static description = 'Check the health of your npm environment'
+  static name = 'doctor'
+  static params = ['registry']
+  static ignoreImplicitWorkspace = false
+  static usage = [`[${checks.flatMap(s => s.groups)
+    .filter((value, index, self) => self.indexOf(value) === index && value !== 'ping')
+    .join('] [')}]`]
+
+  async exec (args) {
+    log.info('doctor', 'Running checkup')
+    let allOk = true
+
+    const actions = this.actions(args)
+
+    const chalk = this.npm.chalk
+    for (const { title, cmd } of actions) {
+      this.output(title)
+      // TODO when we have an in progress indicator that could go here
+      let result
+      try {
+        result = await this[cmd]()
+        this.output(`${chalk.green('Ok')}${result ? `\n${result}` : ''}\n`)
+      } catch (err) {
+        allOk = false
+        this.output(`${chalk.red('Not ok')}\n${chalk.cyan(err)}\n`)
+      }
+    }
+
+    if (!allOk) {
+      if (this.npm.silent) {
+        throw new Error('Some problems found. Check logs or disable silent mode for recommendations.')
+      } else {
+        throw new Error('Some problems found. See above for recommendations.')
+      }
+    }
+  }
+
+  async checkPing () {
+    log.info('doctor', 'Pinging registry')
+    try {
+      await ping({ ...this.npm.flatOptions, retry: false })
+      return ''
+    } catch (er) {
+      if (/^E\d{3}$/.test(er.code || '')) {
+        throw er.code.slice(1) + ' ' + er.message
+      } else {
+        throw er.message
+      }
+    }
+  }
+
+  async getLatestNpmVersion () {
+    log.info('doctor', 'Getting npm package information')
+    const latest = (await pacote.manifest('npm@latest', this.npm.flatOptions)).version
+    if (semver.gte(this.npm.version, latest)) {
+      return `current: v${this.npm.version}, latest: v${latest}`
+    } else {
+      throw `Use npm v${latest}`
+    }
+  }
+
+  async getLatestNodejsVersion () {
+    // XXX get the latest in the current major as well
+    const current = process.version
+    const currentRange = `^${current}`
+    const url = 'https://nodejs.org/dist/index.json'
+    log.info('doctor', 'Getting Node.js release information')
+    const res = await npmFetch(url, { method: 'GET', ...this.npm.flatOptions })
+    const data = await res.json()
+    let maxCurrent = '0.0.0'
+    let maxLTS = '0.0.0'
+    for (const { lts, version } of data) {
+      if (lts && semver.gt(version, maxLTS)) {
+        maxLTS = version
+      }
+
+      if (semver.satisfies(version, currentRange) && semver.gt(version, maxCurrent)) {
+        maxCurrent = version
+      }
+    }
+    const recommended = semver.gt(maxCurrent, maxLTS) ? maxCurrent : maxLTS
+    if (semver.gte(process.version, recommended)) {
+      return `current: ${current}, recommended: ${recommended}`
+    } else {
+      throw `Use node ${recommended} (current: ${current})`
+    }
+  }
+
+  async getBinPath () {
+    log.info('doctor', 'getBinPath', 'Finding npm global bin in your PATH')
+    if (!process.env.PATH.includes(this.npm.globalBin)) {
+      throw new Error(`Add ${this.npm.globalBin} to your $PATH`)
+    }
+    return this.npm.globalBin
+  }
+
+  async checkCachePermission () {
+    return this.checkFilesPermission(this.npm.cache, true, R_OK)
+  }
+
+  async checkLocalModulesPermission () {
+    return this.checkFilesPermission(this.npm.localDir, true, R_OK | W_OK, true)
+  }
+
+  async checkGlobalModulesPermission () {
+    return this.checkFilesPermission(this.npm.globalDir, false, R_OK)
+  }
+
+  async checkLocalBinPermission () {
+    return this.checkFilesPermission(this.npm.localBin, false, R_OK | W_OK | X_OK, true)
+  }
+
+  async checkGlobalBinPermission () {
+    return this.checkFilesPermission(this.npm.globalBin, false, X_OK)
+  }
+
+  async checkFilesPermission (root, shouldOwn, mask, missingOk) {
+    let ok = true
+
+    try {
+      const uid = process.getuid()
+      const gid = process.getgid()
+      const files = new Set([root])
+      for (const f of files) {
+        const st = await lstat(f).catch(er => {
+          // if it can't be missing, or if it can and the error wasn't that it was missing
+          if (!missingOk || er.code !== 'ENOENT') {
+            ok = false
+            log.warn('doctor', 'checkFilesPermission', 'error getting info for ' + f)
+          }
+        })
+
+        if (!st) {
+          continue
+        }
+
+        if (shouldOwn && (uid !== st.uid || gid !== st.gid)) {
+          log.warn('doctor', 'checkFilesPermission', 'should be owner of ' + f)
+          ok = false
+        }
+
+        if (!st.isDirectory() && !st.isFile()) {
+          continue
+        }
+
+        try {
+          await access(f, mask)
+        } catch {
+          ok = false
+          const msg = `Missing permissions on ${f} (expect: ${maskLabel(mask)})`
+          log.error('doctor', 'checkFilesPermission', msg)
+          continue
+        }
+
+        if (st.isDirectory()) {
+          const entries = await readdir(f).catch(() => {
+            ok = false
+            log.warn('doctor', 'checkFilesPermission', 'error reading directory ' + f)
+            return []
+          })
+          for (const entry of entries) {
+            files.add(resolve(f, entry))
+          }
+        }
+      }
+    } finally {
+      if (!ok) {
+        throw (
+          `Check the permissions of files in ${root}` +
+          (shouldOwn ? ' (should be owned by current user)' : '')
+        )
+      } else {
+        return ''
+      }
+    }
+  }
+
+  async getGitPath () {
+    log.info('doctor', 'Finding git in your PATH')
+    return await which('git').catch(er => {
+      log.warn('doctor', 'getGitPath', er)
+      throw new Error("Install git and ensure it's in your PATH.")
+    })
+  }
+
+  async verifyCachedFiles () {
+    log.info('doctor', 'verifyCachedFiles', 'Verifying the npm cache')
+
+    const stats = await cacache.verify(this.npm.flatOptions.cache)
+    const { badContentCount, reclaimedCount, missingContent, reclaimedSize } = stats
+    if (badContentCount || reclaimedCount || missingContent) {
+      if (badContentCount) {
+        log.warn('doctor', 'verifyCachedFiles', `Corrupted content removed: ${badContentCount}`)
+      }
+
+      if (reclaimedCount) {
+        log.warn(
+          'doctor',
+          'verifyCachedFiles',
+          `Content garbage-collected: ${reclaimedCount} (${reclaimedSize} bytes)`
+        )
+      }
+
+      if (missingContent) {
+        log.warn('doctor', 'verifyCachedFiles', `Missing content: ${missingContent}`)
+      }
+
+      log.warn('doctor', 'verifyCachedFiles', 'Cache issues have been fixed')
+    }
+    log.info(
+      'doctor',
+      'verifyCachedFiles',
+        `Verification complete. Stats: ${JSON.stringify(stats, null, 2)}`
+    )
+    return `verified ${stats.verifiedContent} tarballs`
+  }
+
+  async checkNpmRegistry () {
+    if (this.npm.flatOptions.registry !== defaults.registry) {
+      throw `Try \`npm config set registry=${defaults.registry}\``
+    } else {
+      return `using default registry (${defaults.registry})`
+    }
+  }
+
+  output (...args) {
+    // TODO display layer should do this
+    if (!this.npm.silent) {
+      output.standard(...args)
+    }
+  }
+
+  actions (params) {
+    return checks.filter(subcmd => {
+      if (process.platform === 'win32' && subcmd.windows === false) {
+        return false
+      }
+      if (params.length) {
+        return params.some(param => subcmd.groups.includes(param))
+      }
+      return true
+    })
+  }
+}
+
+module.exports = Doctor
diff --git a/node/node_modules/npm/lib/commands/edit.js b/node/node_modules/npm/lib/commands/edit.js
new file mode 100644
index 0000000000000000000000000000000000000000..4308af2cfcf0f346d7e393cdca69c8bba5bb3127
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/edit.js
@@ -0,0 +1,62 @@
+const { resolve } = require('node:path')
+const { lstat } = require('node:fs/promises')
+const cp = require('node:child_process')
+const completion = require('../utils/installed-shallow.js')
+const BaseCommand = require('../base-cmd.js')
+
+const splitPackageNames = (path) => path.split('/')
+// combine scoped parts
+  .reduce((parts, part) => {
+    if (parts.length === 0) {
+      return [part]
+    }
+
+    const lastPart = parts[parts.length - 1]
+    // check if previous part is the first part of a scoped package
+    if (lastPart[0] === '@' && !lastPart.includes('/')) {
+      parts[parts.length - 1] += '/' + part
+    } else {
+      parts.push(part)
+    }
+
+    return parts
+  }, [])
+  .join('/node_modules/')
+  .replace(/(\/node_modules)+/, '/node_modules')
+
+// npm edit <pkg>
+// open the package folder in the $EDITOR
+class Edit extends BaseCommand {
+  static description = 'Edit an installed package'
+  static name = 'edit'
+  static usage = ['<pkg>[/<subpkg>...]']
+  static params = ['editor']
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts, npm) {
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    if (args.length !== 1) {
+      throw this.usageError()
+    }
+
+    const path = splitPackageNames(args[0])
+    const dir = resolve(this.npm.dir, path)
+
+    await lstat(dir)
+    await new Promise((res, rej) => {
+      const [bin, ...spawnArgs] = this.npm.config.get('editor').split(/\s+/)
+      const editor = cp.spawn(bin, [...spawnArgs, dir], { stdio: 'inherit' })
+      editor.on('exit', async (code) => {
+        if (code) {
+          return rej(new Error(`editor process exited with code: ${code}`))
+        }
+        await this.npm.exec('rebuild', [dir]).then(res).catch(rej)
+      })
+    })
+  }
+}
+
+module.exports = Edit
diff --git a/node/node_modules/npm/lib/commands/exec.js b/node/node_modules/npm/lib/commands/exec.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b59199498c93c0755189a569e3cbb71f135650d
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/exec.js
@@ -0,0 +1,107 @@
+const { resolve } = require('node:path')
+const libexec = require('libnpmexec')
+const BaseCommand = require('../base-cmd.js')
+
+class Exec extends BaseCommand {
+  static description = 'Run a command from a local or remote npm package'
+  static params = [
+    'package',
+    'call',
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+  ]
+
+  static name = 'exec'
+  static usage = [
+    '-- <pkg>[@<version>] [args...]',
+    '--package=<pkg>[@<version>] -- <cmd> [args...]',
+    '-c \'<cmd> [args...]\'',
+    '--package=foo -c \'<cmd> [args...]\'',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+  static isShellout = true
+
+  async exec (args) {
+    return this.callExec(args)
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+
+    for (const [name, path] of this.workspaces) {
+      const locationMsg =
+        `in workspace ${this.npm.chalk.green(name)} at location:\n${this.npm.chalk.dim(path)}`
+      await this.callExec(args, { name, locationMsg, runPath: path })
+    }
+  }
+
+  async callExec (args, { name, locationMsg, runPath } = {}) {
+    let localBin = this.npm.localBin
+    let pkgPath = this.npm.localPrefix
+
+    // This is where libnpmexec will actually run the scripts from
+    if (!runPath) {
+      runPath = process.cwd()
+    } else {
+      // We have to consider if the workspace has its own separate versions libnpmexec will walk up to localDir after looking here
+      localBin = resolve(this.npm.localDir, name, 'node_modules', '.bin')
+      // We also need to look for `bin` entries in the workspace package.json
+      // libnpmexec will NOT look in the project root for the bin entry
+      pkgPath = runPath
+    }
+
+    const call = this.npm.config.get('call')
+    let globalPath
+    const {
+      flatOptions,
+      globalBin,
+      globalDir,
+      chalk,
+    } = this.npm
+    const scriptShell = this.npm.config.get('script-shell') || undefined
+    const packages = this.npm.config.get('package')
+    const yes = this.npm.config.get('yes')
+    // --prefix sets both of these to the same thing, meaning the global prefix is invalid (i.e. no lib/node_modules).
+    // This is not a trivial thing to untangle and fix so we work around it here.
+    if (this.npm.localPrefix !== this.npm.globalPrefix) {
+      globalPath = resolve(globalDir, '..')
+    }
+
+    if (call && args.length) {
+      throw this.usageError()
+    }
+
+    return libexec({
+      ...flatOptions,
+      // we explicitly set packageLockOnly to false because if it's true when we try to install a missing package, we won't actually install it
+      packageLockOnly: false,
+      // what the user asked to run args[0] is run by default
+      args: [...args], // copy args so they don't get mutated
+      // specify a custom command to be run instead of args[0]
+      call,
+      chalk,
+      // where to look for bins globally, if a file matches call or args[0] it is called
+      globalBin,
+      // where to look for packages globally, if a package matches call or args[0] it is called
+      globalPath,
+      // where to look for bins locally, if a file matches call or args[0] it is called
+      localBin,
+      locationMsg,
+      // packages that need to be installed
+      packages,
+      // path where node_modules is
+      path: this.npm.localPrefix,
+      // where to look for package.json#bin entries first
+      pkgPath,
+      // cwd to run from
+      runPath,
+      scriptShell,
+      yes,
+    })
+  }
+}
+
+module.exports = Exec
diff --git a/node/node_modules/npm/lib/commands/explain.js b/node/node_modules/npm/lib/commands/explain.js
new file mode 100644
index 0000000000000000000000000000000000000000..2539b264fdf3eb6db0a0cd39ccc5ea6241185c7f
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/explain.js
@@ -0,0 +1,128 @@
+const { explainNode } = require('../utils/explain-dep.js')
+const npa = require('npm-package-arg')
+const semver = require('semver')
+const { relative, resolve } = require('node:path')
+const validName = require('validate-npm-package-name')
+const { output } = require('proc-log')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Explain extends ArboristWorkspaceCmd {
+  static description = 'Explain installed packages'
+  static name = 'explain'
+  static usage = ['<package-spec>']
+  static params = [
+    'json',
+    'workspace',
+  ]
+
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts, npm) {
+    const completion = require('../utils/installed-deep.js')
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    if (!args.length) {
+      throw this.usageError()
+    }
+
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({ path: this.npm.prefix, ...this.npm.flatOptions })
+    const tree = await arb.loadActual()
+
+    if (this.npm.flatOptions.workspacesEnabled
+      && this.workspaceNames
+      && this.workspaceNames.length
+    ) {
+      this.filterSet = arb.workspaceDependencySet(tree, this.workspaceNames)
+    } else if (!this.npm.flatOptions.workspacesEnabled) {
+      this.filterSet =
+        arb.excludeWorkspacesDependencySet(tree)
+    }
+
+    const nodes = new Set()
+    for (const arg of args) {
+      for (const node of this.getNodes(tree, arg)) {
+        const filteredOut = this.filterSet
+          && this.filterSet.size > 0
+          && !this.filterSet.has(node)
+        if (!filteredOut) {
+          nodes.add(node)
+        }
+      }
+    }
+    if (nodes.size === 0) {
+      throw new Error(`No dependencies found matching ${args.join(', ')}`)
+    }
+
+    const expls = []
+    for (const node of nodes) {
+      const { extraneous, dev, optional, devOptional, peer, inBundle, overridden } = node
+      const expl = node.explain()
+      if (extraneous) {
+        expl.extraneous = true
+      } else {
+        expl.dev = dev
+        expl.optional = optional
+        expl.devOptional = devOptional
+        expl.peer = peer
+        expl.bundled = inBundle
+        expl.overridden = overridden
+      }
+      expls.push(expl)
+    }
+
+    if (this.npm.flatOptions.json) {
+      output.buffer(expls)
+    } else {
+      output.standard(expls.map(expl => {
+        return explainNode(expl, Infinity, this.npm.chalk)
+      }).join('\n\n'))
+    }
+  }
+
+  getNodes (tree, arg) {
+    // if it's just a name, return packages by that name
+    const { validForOldPackages: valid } = validName(arg)
+    if (valid) {
+      return tree.inventory.query('packageName', arg)
+    }
+
+    // if it's a location, get that node
+    const maybeLoc = arg.replace(/\\/g, '/').replace(/(?<!\/)\/+$/, '')
+    const nodeByLoc = tree.inventory.get(maybeLoc)
+    if (nodeByLoc) {
+      return [nodeByLoc]
+    }
+
+    // maybe a path to a node_modules folder
+    const maybePath = relative(this.npm.prefix, resolve(maybeLoc))
+      .replace(/\\/g, '/').replace(/(?<!\/)\/+$/, '')
+    const nodeByPath = tree.inventory.get(maybePath)
+    if (nodeByPath) {
+      return [nodeByPath]
+    }
+
+    // otherwise, try to select all matching nodes
+    try {
+      return this.getNodesByVersion(tree, arg)
+    } catch {
+      return []
+    }
+  }
+
+  getNodesByVersion (tree, arg) {
+    const spec = npa(arg, this.npm.prefix)
+    if (spec.type !== 'version' && spec.type !== 'range') {
+      return []
+    }
+
+    return tree.inventory.filter(node => {
+      return node.package.name === spec.name &&
+        semver.satisfies(node.package.version, spec.rawSpec)
+    })
+  }
+}
+
+module.exports = Explain
diff --git a/node/node_modules/npm/lib/commands/explore.js b/node/node_modules/npm/lib/commands/explore.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ae9ec0fda96aa1a71bc02476e8b24ac5e0c4f24
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/explore.js
@@ -0,0 +1,70 @@
+const pkgJson = require('@npmcli/package-json')
+const runScript = require('@npmcli/run-script')
+const { join, relative } = require('node:path')
+const { log, output } = require('proc-log')
+const completion = require('../utils/installed-shallow.js')
+const BaseCommand = require('../base-cmd.js')
+
+// npm explore <pkg>[@<version>]
+// open a subshell to the package folder.
+class Explore extends BaseCommand {
+  static description = 'Browse an installed package'
+  static name = 'explore'
+  static usage = ['<pkg> [ -- <command>]']
+  static params = ['shell']
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts, npm) {
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    if (args.length < 1 || !args[0]) {
+      throw this.usageError()
+    }
+
+    const pkgname = args.shift()
+
+    // detect and prevent any .. shenanigans
+    const path = join(this.npm.dir, join('/', pkgname))
+    if (relative(path, this.npm.dir) === '') {
+      throw this.usageError()
+    }
+
+    // run as if running a script named '_explore', which we set to either the set of arguments, or the shell config, and let @npmcli/run-script handle all the escaping and PATH setup stuff.
+
+    const { content: pkg } = await pkgJson.normalize(path).catch(er => {
+      log.error('explore', `It doesn't look like ${pkgname} is installed.`)
+      throw er
+    })
+
+    const { shell } = this.npm.flatOptions
+    pkg.scripts = {
+      ...(pkg.scripts || {}),
+      _explore: args.join(' ').trim() || shell,
+    }
+
+    if (!args.length) {
+      output.standard(`\nExploring ${path}\nType 'exit' or ^D when finished\n`)
+    }
+
+    return runScript({
+      ...this.npm.flatOptions,
+      pkg,
+      path,
+      event: '_explore',
+      stdio: 'inherit',
+    }).catch(er => {
+      process.exitCode = typeof er.code === 'number' && er.code !== 0 ? er.code
+        : 1
+        // if it's not an exit error, or non-interactive, throw it
+      const isProcExit = er.message === 'command failed' &&
+          (typeof er.code === 'number' || /^SIG/.test(er.signal || ''))
+      if (args.length || !isProcExit) {
+        throw er
+      }
+    })
+  }
+}
+
+module.exports = Explore
diff --git a/node/node_modules/npm/lib/commands/find-dupes.js b/node/node_modules/npm/lib/commands/find-dupes.js
new file mode 100644
index 0000000000000000000000000000000000000000..54e80885ecc8f093d2ad187db1056b5240adacc1
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/find-dupes.js
@@ -0,0 +1,27 @@
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class FindDupes extends ArboristWorkspaceCmd {
+  static description = 'Find duplication in the package tree'
+  static name = 'find-dupes'
+  static params = [
+    'install-strategy',
+    'legacy-bundling',
+    'global-style',
+    'strict-peer-deps',
+    'package-lock',
+    'omit',
+    'include',
+    'ignore-scripts',
+    'audit',
+    'bin-links',
+    'fund',
+    ...super.params,
+  ]
+
+  async exec () {
+    this.npm.config.set('dry-run', true)
+    return this.npm.exec('dedupe', [])
+  }
+}
+
+module.exports = FindDupes
diff --git a/node/node_modules/npm/lib/commands/fund.js b/node/node_modules/npm/lib/commands/fund.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a567a057f5c942405a494238f4d1bb48f838710
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/fund.js
@@ -0,0 +1,215 @@
+const archy = require('archy')
+const pacote = require('pacote')
+const semver = require('semver')
+const { output } = require('proc-log')
+const npa = require('npm-package-arg')
+const { depth } = require('treeverse')
+const { readTree: getFundingInfo, normalizeFunding, isValidFunding } = require('libnpmfund')
+const { openUrl } = require('../utils/open-url.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+const getPrintableName = ({ name, version }) => {
+  const printableVersion = version ? `@${version}` : ''
+  return `${name}${printableVersion}`
+}
+
+const errCode = (msg, code) => Object.assign(new Error(msg), { code })
+
+class Fund extends ArboristWorkspaceCmd {
+  static description = 'Retrieve funding information'
+  static name = 'fund'
+  static params = ['json', 'browser', 'unicode', 'workspace', 'which']
+  static usage = ['[<package-spec>]']
+
+  // XXX: maybe worth making this generic for all commands?
+  usageMessage (paramsObj = {}) {
+    let msg = `\`npm ${this.constructor.name}`
+    const params = Object.entries(paramsObj)
+    if (params.length) {
+      msg += ` ${this.constructor.usage}`
+    }
+    for (const [key, value] of params) {
+      msg += ` --${key}=${value}`
+    }
+    return `${msg}\``
+  }
+
+  static async completion (opts, npm) {
+    const completion = require('../utils/installed-deep.js')
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    const spec = args[0]
+
+    let fundingSourceNumber = this.npm.config.get('which')
+    if (fundingSourceNumber != null) {
+      fundingSourceNumber = parseInt(fundingSourceNumber, 10)
+      if (isNaN(fundingSourceNumber) || fundingSourceNumber < 1) {
+        throw errCode(
+          `${this.usageMessage({ which: 'fundingSourceNumber' })} must be given a positive integer`,
+          'EFUNDNUMBER'
+        )
+      }
+    }
+
+    if (this.npm.global) {
+      throw errCode(
+        `${this.usageMessage()} does not support global packages`,
+        'EFUNDGLOBAL'
+      )
+    }
+
+    const where = this.npm.prefix
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({ ...this.npm.flatOptions, path: where })
+    const tree = await arb.loadActual()
+
+    if (spec) {
+      await this.openFundingUrl({
+        path: where,
+        tree,
+        spec,
+        fundingSourceNumber,
+      })
+      return
+    }
+
+    // TODO: add !workspacesEnabled option handling to libnpmfund
+    const fundingInfo = getFundingInfo(tree, {
+      ...this.flatOptions,
+      Arborist,
+      workspaces: this.workspaceNames,
+    })
+
+    if (this.npm.config.get('json')) {
+      output.buffer(fundingInfo)
+    } else {
+      output.standard(this.printHuman(fundingInfo))
+    }
+  }
+
+  printHuman (fundingInfo) {
+    const unicode = this.npm.config.get('unicode')
+    const seenUrls = new Map()
+
+    const tree = obj => archy(obj, '', { unicode })
+
+    const result = depth({
+      tree: fundingInfo,
+
+      // composes human readable package name and creates a new archy item for readable output
+      visit: ({ name, version, funding }) => {
+        const [fundingSource] = [].concat(normalizeFunding(funding)).filter(isValidFunding)
+        const { url } = fundingSource || {}
+        const pkgRef = getPrintableName({ name, version })
+
+        if (!url) {
+          return { label: pkgRef }
+        }
+        let item
+        if (seenUrls.has(url)) {
+          item = seenUrls.get(url)
+          item.label += `${this.npm.chalk.dim(',')} ${pkgRef}`
+          return null
+        }
+        item = {
+          label: tree({
+            label: this.npm.chalk.blue(url),
+            nodes: [pkgRef],
+          }).trim(),
+        }
+
+        // stacks all packages together under the same item
+        seenUrls.set(url, item)
+        return item
+      },
+
+      // puts child nodes back into returned archy output while also filtering out missing items
+      leave: (item, children) => {
+        if (item) {
+          item.nodes = children.filter(Boolean)
+        }
+
+        return item
+      },
+
+      // turns tree-like object return by libnpmfund into children to be properly read by treeverse
+      getChildren: node =>
+        Object.keys(node.dependencies || {}).map(key => ({
+          name: key,
+          ...node.dependencies[key],
+        })),
+    })
+
+    const res = tree(result)
+    return res
+  }
+
+  async openFundingUrl ({ path, tree, spec, fundingSourceNumber }) {
+    const arg = npa(spec, path)
+
+    const retrievePackageMetadata = () => {
+      if (arg.type === 'directory') {
+        if (tree.path === arg.fetchSpec) {
+          // matches cwd, e.g: npm fund .
+          return tree.package
+        } else {
+          // matches any file path within current arborist inventory
+          for (const item of tree.inventory.values()) {
+            if (item.path === arg.fetchSpec) {
+              return item.package
+            }
+          }
+        }
+      } else {
+        // tries to retrieve a package from arborist inventory by matching resulted package name from the provided spec
+        const [item] = [...tree.inventory.query('name', arg.name)]
+          .filter(i => semver.valid(i.package.version))
+          .sort((a, b) => semver.rcompare(a.package.version, b.package.version))
+
+        if (item) {
+          return item.package
+        }
+      }
+    }
+
+    const { funding } =
+      retrievePackageMetadata() ||
+      (await pacote.manifest(arg, this.npm.flatOptions).catch(() => ({})))
+
+    const validSources = [].concat(normalizeFunding(funding)).filter(isValidFunding)
+
+    if (!validSources.length) {
+      throw errCode(`No valid funding method available for: ${spec}`, 'ENOFUND')
+    }
+
+    const fundSource = fundingSourceNumber
+      ? validSources[fundingSourceNumber - 1]
+      : validSources.length === 1 ? validSources[0]
+      : null
+
+    if (fundSource) {
+      return openUrl(this.npm, ...this.urlMessage(fundSource))
+    }
+
+    const ambiguousUrlMsg = [
+      ...validSources.map((s, i) => `${i + 1}: ${this.urlMessage(s).reverse().join(': ')}`),
+      `Run ${this.usageMessage({ which: '1' })}` +
+      ', for example, to open the first funding URL listed in that package',
+    ]
+    if (fundingSourceNumber) {
+      ambiguousUrlMsg.unshift(`--which=${fundingSourceNumber} is not a valid index`)
+    }
+    output.standard(ambiguousUrlMsg.join('\n'))
+  }
+
+  urlMessage (source) {
+    const { type, url } = source
+    const typePrefix = type ? `${type} funding` : 'Funding'
+    const message = `${typePrefix} available at the following URL`
+    return [url, message]
+  }
+}
+
+module.exports = Fund
diff --git a/node/node_modules/npm/lib/commands/get.js b/node/node_modules/npm/lib/commands/get.js
new file mode 100644
index 0000000000000000000000000000000000000000..1bbd6ca376adae7e770fdc2692636b39b37cc96d
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/get.js
@@ -0,0 +1,21 @@
+const Npm = require('../npm.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Get extends BaseCommand {
+  static description = 'Get a value from the npm configuration'
+  static name = 'get'
+  static usage = ['[<key> ...] (See `npm config`)']
+  static params = ['long']
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts) {
+    const Config = Npm.cmd('config')
+    return Config.completion(opts)
+  }
+
+  async exec (args) {
+    return this.npm.exec('config', ['get'].concat(args))
+  }
+}
+
+module.exports = Get
diff --git a/node/node_modules/npm/lib/commands/help-search.js b/node/node_modules/npm/lib/commands/help-search.js
new file mode 100644
index 0000000000000000000000000000000000000000..e4e7f27bb7b10bcf03fee0b860f5db9a65325928
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/help-search.js
@@ -0,0 +1,194 @@
+const { readFile } = require('node:fs/promises')
+const path = require('node:path')
+const { glob } = require('glob')
+const { output } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+
+const globify = pattern => pattern.split('\\').join('/')
+
+class HelpSearch extends BaseCommand {
+  static description = 'Search npm help documentation'
+  static name = 'help-search'
+  static usage = ['<text>']
+  static params = ['long']
+
+  async exec (args) {
+    if (!args.length) {
+      throw this.usageError()
+    }
+
+    const docPath = path.resolve(this.npm.npmRoot, 'docs/content')
+    let files = await glob(`${globify(docPath)}/*/*.md`)
+    // preserve glob@8 behavior
+    files = files.sort((a, b) => a.localeCompare(b, 'en'))
+    const data = await this.readFiles(files)
+    const results = await this.searchFiles(args, data)
+    const formatted = this.formatResults(args, results)
+    if (!formatted.trim()) {
+      output.standard(`No matches in help for: ${args.join(' ')}\n`)
+    } else {
+      output.standard(formatted)
+    }
+  }
+
+  async readFiles (files) {
+    const res = {}
+    await Promise.all(files.map(async file => {
+      res[file] = (await readFile(file, 'utf8'))
+        .replace(/^---\n(.*\n)*?---\n/, '').trim()
+    }))
+    return res
+  }
+
+  async searchFiles (args, data) {
+    const results = []
+    for (const [file, content] of Object.entries(data)) {
+      const lowerCase = content.toLowerCase()
+      // skip if no matches at all
+      if (!args.some(a => lowerCase.includes(a.toLowerCase()))) {
+        continue
+      }
+
+      const lines = content.split(/\n+/)
+
+      // if a line has a search term, then skip it and the next line.
+      // if the next line has a search term, then skip all 3
+      // otherwise, set the line to null
+      // finally, remove the nulls
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i]
+        const nextLine = lines[i + 1]
+        let match = false
+        if (nextLine) {
+          match = args.some(a =>
+            nextLine.toLowerCase().includes(a.toLowerCase()))
+          if (match) {
+            // skip over the next line, and the line after it.
+            i += 2
+            continue
+          }
+        }
+
+        match = args.some(a => line.toLowerCase().includes(a.toLowerCase()))
+
+        if (match) {
+          // skip over the next line
+          i++
+          continue
+        }
+
+        lines[i] = null
+      }
+
+      // now squish any string of nulls into a single null
+      const pruned = lines.reduce((l, r) => {
+        if (!(r === null && l[l.length - 1] === null)) {
+          l.push(r)
+        }
+
+        return l
+      }, [])
+
+      if (pruned[pruned.length - 1] === null) {
+        pruned.pop()
+      }
+
+      if (pruned[0] === null) {
+        pruned.shift()
+      }
+
+      // now count how many args were found
+      const found = {}
+      let totalHits = 0
+      for (const line of pruned) {
+        for (const arg of args) {
+          const hit = (line || '').toLowerCase()
+            .split(arg.toLowerCase()).length - 1
+
+          if (hit > 0) {
+            found[arg] = (found[arg] || 0) + hit
+            totalHits += hit
+          }
+        }
+      }
+
+      const cmd = 'npm help ' +
+        path.basename(file, '.md').replace(/^npm-/, '')
+      results.push({
+        file,
+        cmd,
+        lines: pruned,
+        found: Object.keys(found),
+        hits: found,
+        totalHits,
+      })
+    }
+
+    // sort results by number of results found, then by number of hits then by number of matching lines
+
+    // coverage is ignored here because the contents of results are nondeterministic due to either glob or readFiles or Object.entries
+    return results.sort(/* istanbul ignore next */ (a, b) =>
+      a.found.length > b.found.length ? -1
+      : a.found.length < b.found.length ? 1
+      : a.totalHits > b.totalHits ? -1
+      : a.totalHits < b.totalHits ? 1
+      : a.lines.length > b.lines.length ? -1
+      : a.lines.length < b.lines.length ? 1
+      : 0).slice(0, 10)
+  }
+
+  formatResults (args, results) {
+    const cols = Math.min(process.stdout.columns || Infinity, 80) + 1
+
+    const formattedOutput = results.map(res => {
+      const out = [res.cmd]
+      const r = Object.keys(res.hits)
+        .map(k => `${k}:${res.hits[k]}`)
+        .sort((a, b) => a > b ? 1 : -1)
+        .join(' ')
+
+      out.push(' '.repeat((Math.max(1, cols - out.join(' ').length - r.length - 1))))
+      out.push(r)
+
+      if (!this.npm.config.get('long')) {
+        return out.join('')
+      }
+
+      out.unshift('\n\n')
+      out.push('\n')
+      out.push('-'.repeat(cols - 1) + '\n')
+      res.lines.forEach((line, i) => {
+        if (line === null || i > 3) {
+          return
+        }
+
+        const highlightLine = []
+        for (const arg of args) {
+          const finder = line.toLowerCase().split(arg.toLowerCase())
+          let p = 0
+          for (const f of finder) {
+            highlightLine.push(line.slice(p, p + f.length))
+            const word = line.slice(p + f.length, p + f.length + arg.length)
+            highlightLine.push(this.npm.chalk.blue(word))
+            p += f.length + arg.length
+          }
+        }
+        out.push(highlightLine.join('') + '\n')
+      })
+
+      return out.join('')
+    }).join('\n')
+
+    const finalOut = results.length && !this.npm.config.get('long')
+      ? 'Top hits for ' + (args.map(JSON.stringify).join(' ')) + '\n' +
+      '—'.repeat(cols - 1) + '\n' +
+      formattedOutput + '\n' +
+      '—'.repeat(cols - 1) + '\n' +
+      '(run with -l or --long to see more context)'
+      : formattedOutput
+
+    return finalOut.trim()
+  }
+}
+
+module.exports = HelpSearch
diff --git a/node/node_modules/npm/lib/commands/help.js b/node/node_modules/npm/lib/commands/help.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c130b291794f0032f24eb97aedd9bbd4b2aa607
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/help.js
@@ -0,0 +1,113 @@
+const spawn = require('@npmcli/promise-spawn')
+const path = require('node:path')
+const { openUrl } = require('../utils/open-url.js')
+const { glob } = require('glob')
+const { output, input } = require('proc-log')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { deref } = require('../utils/cmd-list.js')
+const BaseCommand = require('../base-cmd.js')
+
+const globify = pattern => pattern.split('\\').join('/')
+
+// Strips out the number from foo.7 or foo.7. or foo.7.tgz
+// We don't currently compress our man pages but if we ever did this would seamlessly continue supporting it
+const manNumberRegex = /\.(\d+)(\.[^/\\]*)?$/
+// hardcoded names for man sections
+// XXX: these are used in the docs workspace and should be exported from npm so section names can changed more easily
+const manSectionNames = {
+  1: 'commands',
+  5: 'configuring-npm',
+  7: 'using-npm',
+}
+
+class Help extends BaseCommand {
+  static description = 'Get help on npm'
+  static name = 'help'
+  static usage = ['<term> [<terms..>]']
+  static params = ['viewer']
+
+  static async completion (opts, npm) {
+    if (opts.conf.argv.remain.length > 2) {
+      return []
+    }
+    const g = path.resolve(npm.npmRoot, 'man/man[0-9]/*.[0-9]')
+    let files = await glob(globify(g))
+    // preserve glob@8 behavior
+    files = files.sort((a, b) => a.localeCompare(b, 'en'))
+
+    return Object.keys(files.reduce(function (acc, file) {
+      file = path.basename(file).replace(/\.[0-9]+$/, '')
+      file = file.replace(/^npm-/, '')
+      acc[file] = true
+      return acc
+    }, { help: true }))
+  }
+
+  async exec (args) {
+    // By default we search all of our man subdirectories, but if the user has asked for a specific one we limit the search to just there
+    const manSearch = /^\d+$/.test(args[0]) ? `man${args.shift()}` : 'man*'
+
+    if (!args.length) {
+      return output.standard(this.npm.usage)
+    }
+
+    // npm help foo bar baz: search topics
+    if (args.length > 1) {
+      return this.helpSearch(args)
+    }
+
+    // `npm help package.json`
+    const arg = (deref(args[0]) || args[0]).replace('.json', '-json')
+
+    // find either section.n or npm-section.n
+    const f = globify(path.resolve(this.npm.npmRoot, `man/${manSearch}/?(npm-)${arg}.[0-9]*`))
+
+    const [man] = await glob(f).then(r => r.sort((a, b) => {
+      // Because the glob is (subtly) different from manNumberRegex, we can't rely on it passing.
+      const aManNumberMatch = a.match(manNumberRegex)?.[1] || 999
+      const bManNumberMatch = b.match(manNumberRegex)?.[1] || 999
+      if (aManNumberMatch !== bManNumberMatch) {
+        return aManNumberMatch - bManNumberMatch
+      }
+      return localeCompare(a, b)
+    }))
+
+    return man ? this.viewMan(man) : this.helpSearch(args)
+  }
+
+  helpSearch (args) {
+    return this.npm.exec('help-search', args)
+  }
+
+  async viewMan (man) {
+    const viewer = this.npm.config.get('viewer')
+
+    if (viewer === 'browser') {
+      return openUrl(this.npm, this.htmlMan(man), 'help available at the following URL', true)
+    }
+
+    let args = ['man', [man]]
+    if (viewer === 'woman') {
+      args = ['emacsclient', ['-e', `(woman-find-file '${man}')`]]
+    }
+
+    try {
+      await input.start(() => spawn(...args, { stdio: 'inherit' }))
+    } catch (err) {
+      if (err.code) {
+        throw new Error(`help process exited with code: ${err.code}`)
+      } else {
+        throw err
+      }
+    }
+  }
+
+  // Returns the path to the html version of the man page
+  htmlMan (man) {
+    const sect = manSectionNames[man.match(manNumberRegex)[1]]
+    const f = path.basename(man).replace(manNumberRegex, '')
+    return 'file:///' + path.resolve(this.npm.npmRoot, `docs/output/${sect}/${f}.html`)
+  }
+}
+
+module.exports = Help
diff --git a/node/node_modules/npm/lib/commands/init.js b/node/node_modules/npm/lib/commands/init.js
new file mode 100644
index 0000000000000000000000000000000000000000..c777075440f62f91a44074377c7c9d32c78dc608
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/init.js
@@ -0,0 +1,240 @@
+const { statSync } = require('node:fs')
+const { relative, resolve } = require('node:path')
+const { mkdir } = require('node:fs/promises')
+const initJson = require('init-package-json')
+const npa = require('npm-package-arg')
+const libexec = require('libnpmexec')
+const mapWorkspaces = require('@npmcli/map-workspaces')
+const PackageJson = require('@npmcli/package-json')
+const { log, output, input } = require('proc-log')
+const updateWorkspaces = require('../utils/update-workspaces.js')
+const BaseCommand = require('../base-cmd.js')
+
+const posixPath = p => p.split('\\').join('/')
+
+class Init extends BaseCommand {
+  static description = 'Create a package.json file'
+  static params = [
+    'init-author-name',
+    'init-author-url',
+    'init-license',
+    'init-module',
+    'init-type',
+    'init-version',
+    'init-private',
+    'yes',
+    'force',
+    'scope',
+    'workspace',
+    'workspaces',
+    'workspaces-update',
+    'include-workspace-root',
+  ]
+
+  static name = 'init'
+  static usage = [
+    '<package-spec> (same as `npx create-<package-spec>`)',
+    '<@scope> (same as `npx <@scope>/create`)',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  async exec (args) {
+    // npm exec style
+    if (args.length) {
+      return await this.execCreate(args)
+    }
+
+    // no args, uses classic init-package-json boilerplate
+    await this.template()
+  }
+
+  async execWorkspaces (args) {
+    // if the root package is uninitiated, take care of it first
+    if (this.npm.flatOptions.includeWorkspaceRoot) {
+      await this.exec(args)
+    }
+
+    // reads package.json for the top-level folder first
+    // by doing this we ensure the command throw if no package.json is found before trying to create a workspace package.json file or its folders
+    const { content: pkg } = await PackageJson.normalize(this.npm.localPrefix).catch(err => {
+      if (err.code === 'ENOENT') {
+        log.warn('init', 'Missing package.json. Try with `--include-workspace-root`.')
+      }
+      throw err
+    })
+
+    // these are workspaces that are being created, so we can't use this.setWorkspaces()
+    const filters = this.npm.config.get('workspace')
+    const wPath = filterArg => resolve(this.npm.localPrefix, filterArg)
+
+    const workspacesPaths = []
+    // npm-exec style, runs in the context of each workspace filter
+    if (args.length) {
+      for (const filterArg of filters) {
+        const path = wPath(filterArg)
+        await mkdir(path, { recursive: true })
+        workspacesPaths.push(path)
+        await this.execCreate(args, path)
+        await this.setWorkspace(pkg, path)
+      }
+      return
+    }
+
+    // no args, uses classic init-package-json boilerplate
+    for (const filterArg of filters) {
+      const path = wPath(filterArg)
+      await mkdir(path, { recursive: true })
+      workspacesPaths.push(path)
+      await this.template(path)
+      await this.setWorkspace(pkg, path)
+    }
+
+    // reify packages once all workspaces have been initialized
+    await this.update(workspacesPaths)
+  }
+
+  async execCreate (args, runPath = process.cwd()) {
+    const [initerName, ...otherArgs] = args
+    let packageName = initerName
+
+    // Only a scope, possibly with a version
+    if (/^@[^/]+$/.test(initerName)) {
+      const [, scope, version] = initerName.split('@')
+      packageName = `@${scope}/create`
+      if (version) {
+        packageName = `${packageName}@${version}`
+      }
+    } else {
+      const req = npa(initerName)
+      if (req.type === 'git' && req.hosted) {
+        const { user, project } = req.hosted
+        packageName = initerName.replace(`${user}/${project}`, `${user}/create-${project}`)
+      } else if (req.registry) {
+        packageName = `${req.name.replace(/^(@[^/]+\/)?/, '$1create-')}@${req.rawSpec}`
+      } else {
+        throw Object.assign(new Error(
+          'Unrecognized initializer: ' + initerName +
+          '\nFor more package binary executing power check out `npx`:' +
+          '\nhttps://docs.npmjs.com/cli/commands/npx'
+        ), { code: 'EUNSUPPORTED' })
+      }
+    }
+
+    const newArgs = [packageName, ...otherArgs]
+    const {
+      flatOptions,
+      localBin,
+      globalBin,
+      chalk,
+    } = this.npm
+    const scriptShell = this.npm.config.get('script-shell') || undefined
+    const yes = this.npm.config.get('yes')
+
+    // only send the init-private flag if it is set
+    const opts = { ...flatOptions }
+    if (this.npm.config.isDefault('init-private')) {
+      delete opts.initPrivate
+    }
+
+    await libexec({
+      ...opts,
+      args: newArgs,
+      localBin,
+      globalBin,
+      output,
+      chalk,
+      path: this.npm.localPrefix,
+      runPath,
+      scriptShell,
+      yes,
+    })
+  }
+
+  async template (path = process.cwd()) {
+    const initFile = this.npm.config.get('init-module')
+    if (!this.npm.config.get('yes') && !this.npm.config.get('force')) {
+      output.standard([
+        'This utility will walk you through creating a package.json file.',
+        'It only covers the most common items, and tries to guess sensible defaults.',
+        '',
+        'See `npm help init` for definitive documentation on these fields and exactly what they do.',
+        '',
+        'Use `npm install <pkg>` afterwards to install a package and save it as a dependency in the package.json file.',
+        '',
+        'Press ^C at any time to quit.',
+      ].join('\n'))
+    }
+
+    try {
+      const data = await input.read(() => initJson(path, initFile, this.npm.config))
+      log.silly('package data', data)
+      return data
+    } catch (er) {
+      if (er.message === 'canceled') {
+        output.flush()
+        log.warn('init', 'canceled')
+      } else {
+        throw er
+      }
+    }
+  }
+
+  async setWorkspace (pkg, workspacePath) {
+    const workspaces = await mapWorkspaces({ cwd: this.npm.localPrefix, pkg })
+
+    // skip setting workspace if current package.json glob already satisfies it
+    for (const wPath of workspaces.values()) {
+      if (wPath === workspacePath) {
+        return
+      }
+    }
+
+    // if a create-pkg didn't generate a package.json at the workspace folder level, it might not be recognized as a workspace by mapWorkspaces, so we're just going to avoid touching the top-level package.json
+    try {
+      statSync(resolve(workspacePath, 'package.json'))
+    } catch {
+      return
+    }
+
+    const pkgJson = await PackageJson.load(this.npm.localPrefix)
+
+    pkgJson.update({
+      workspaces: [
+        ...(pkgJson.content.workspaces || []),
+        posixPath(relative(this.npm.localPrefix, workspacePath)),
+      ],
+    })
+
+    await pkgJson.save()
+  }
+
+  async update (workspacesPaths) {
+    // translate workspaces paths into an array containing workspaces names
+    const workspaces = []
+    for (const path of workspacesPaths) {
+      const { content: { name } } = await PackageJson.normalize(path).catch(() => ({ content: {} }))
+
+      if (name) {
+        workspaces.push(name)
+      }
+    }
+
+    const {
+      config,
+      flatOptions,
+      localPrefix,
+    } = this.npm
+
+    await updateWorkspaces({
+      config,
+      flatOptions,
+      localPrefix,
+      npm: this.npm,
+      workspaces,
+    })
+  }
+}
+
+module.exports = Init
diff --git a/node/node_modules/npm/lib/commands/install-ci-test.js b/node/node_modules/npm/lib/commands/install-ci-test.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb09deb02009595f0dd0e7abfdca4cb294da4bf2
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/install-ci-test.js
@@ -0,0 +1,13 @@
+const CI = require('./ci.js')
+
+class InstallCITest extends CI {
+  static description = 'Install a project with a clean slate and run tests'
+  static name = 'install-ci-test'
+
+  async exec (args) {
+    await this.npm.exec('ci', args)
+    return this.npm.exec('test', [])
+  }
+}
+
+module.exports = InstallCITest
diff --git a/node/node_modules/npm/lib/commands/install-test.js b/node/node_modules/npm/lib/commands/install-test.js
new file mode 100644
index 0000000000000000000000000000000000000000..c572060c63a281940897cb4adb19db540b082b48
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/install-test.js
@@ -0,0 +1,13 @@
+const Install = require('./install.js')
+
+class InstallTest extends Install {
+  static description = 'Install package(s) and run tests'
+  static name = 'install-test'
+
+  async exec (args) {
+    await this.npm.exec('install', args)
+    return this.npm.exec('test', [])
+  }
+}
+
+module.exports = InstallTest
diff --git a/node/node_modules/npm/lib/commands/install.js b/node/node_modules/npm/lib/commands/install.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf9aaa186d23f962c92fe328e5444ce30bd56a76
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/install.js
@@ -0,0 +1,172 @@
+const { readdir } = require('node:fs/promises')
+const { resolve, join } = require('node:path')
+const { log } = require('proc-log')
+const runScript = require('@npmcli/run-script')
+const pacote = require('pacote')
+const checks = require('npm-install-checks')
+const reifyFinish = require('../utils/reify-finish.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Install extends ArboristWorkspaceCmd {
+  static description = 'Install a package'
+  static name = 'install'
+
+  // These are in the order they will show up in when running "-h" If adding to this list, consider adding also to ci.js
+  static params = [
+    'save',
+    'save-exact',
+    'global',
+    'install-strategy',
+    'legacy-bundling',
+    'global-style',
+    'omit',
+    'include',
+    'strict-peer-deps',
+    'prefer-dedupe',
+    'package-lock',
+    'package-lock-only',
+    'foreground-scripts',
+    'ignore-scripts',
+    'allow-git',
+    'audit',
+    'before',
+    'min-release-age',
+    'bin-links',
+    'fund',
+    'dry-run',
+    'cpu',
+    'os',
+    'libc',
+    ...super.params,
+  ]
+
+  static usage = ['[<package-spec> ...]']
+
+  static async completion (opts) {
+    const { partialWord } = opts
+    // install can complete to a folder with a package.json, or any package.
+    // if it has a slash, then it's gotta be a folder
+    // if it starts with https?://, then just give up, because it's a url
+    if (/^https?:\/\//.test(partialWord)) {
+      // do not complete to URLs
+      return []
+    }
+
+    if (/\//.test(partialWord)) {
+      // Complete fully to folder if there is exactly one match and it is a folder containing a package.json file.
+      // If that is not the case we return 0 matches, which will trigger the default bash complete.
+      const lastSlashIdx = partialWord.lastIndexOf('/')
+      const partialName = partialWord.slice(lastSlashIdx + 1)
+      const partialPath = partialWord.slice(0, lastSlashIdx) || '/'
+
+      const isDirMatch = async sibling => {
+        if (sibling.slice(0, partialName.length) !== partialName) {
+          return false
+        }
+
+        try {
+          const contents = await readdir(join(partialPath, sibling))
+          const result = (contents.indexOf('package.json') !== -1)
+          return result
+        } catch {
+          return false
+        }
+      }
+
+      try {
+        const siblings = await readdir(partialPath)
+        const matches = []
+        for (const sibling of siblings) {
+          if (await isDirMatch(sibling)) {
+            matches.push(sibling)
+          }
+        }
+        if (matches.length === 1) {
+          return [join(partialPath, matches[0])]
+        }
+        // no matches
+        return []
+      } catch {
+        return [] // invalid dir: no matching
+      }
+    }
+    // Note: there used to be registry completion here, but it stopped making sense somewhere around 50,000 packages on the registry
+  }
+
+  async exec (args) {
+    // the /path/to/node_modules/..
+    const globalTop = resolve(this.npm.globalDir, '..')
+    const ignoreScripts = this.npm.config.get('ignore-scripts')
+    const isGlobalInstall = this.npm.global
+    const where = isGlobalInstall ? globalTop : this.npm.prefix
+    const forced = this.npm.config.get('force')
+    const scriptShell = this.npm.config.get('script-shell') || undefined
+
+    // be very strict about engines when trying to update npm itself
+    const npmInstall = args.find(arg => arg.startsWith('npm@') || arg === 'npm')
+    if (isGlobalInstall && npmInstall) {
+      const npmOptions = this.npm.flatOptions
+      const npmManifest = await pacote.manifest(npmInstall, npmOptions)
+      try {
+        checks.checkEngine(npmManifest, npmManifest.version, process.version)
+      } catch (e) {
+        if (forced) {
+          log.warn(
+            'install',
+            `Forcing global npm install with incompatible version ${npmManifest.version} into node ${process.version}`
+          )
+        } else {
+          throw e
+        }
+      }
+    }
+
+    // don't try to install the prefix into itself
+    args = args.filter(a => resolve(a) !== this.npm.prefix)
+
+    // `npm i -g` => "install this package globally"
+    if (isGlobalInstall && !args.length) {
+      args = ['.']
+    }
+
+    // throw usage error if trying to install empty package name to global space, e.g: `npm i -g ""`
+    if (where === globalTop && !args.every(Boolean)) {
+      throw this.usageError()
+    }
+
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      auditLevel: null,
+      path: where,
+      add: args,
+      workspaces: this.workspaceNames,
+    }
+    const arb = new Arborist(opts)
+    await arb.reify(opts)
+
+    if (!args.length && !isGlobalInstall && !ignoreScripts) {
+      const scripts = [
+        'preinstall',
+        'install',
+        'postinstall',
+        'prepublish', // XXX(npm9) should we remove this finally??
+        'preprepare',
+        'prepare',
+        'postprepare',
+      ]
+      for (const event of scripts) {
+        await runScript({
+          path: where,
+          args: [],
+          scriptShell,
+          stdio: 'inherit',
+          event,
+        })
+      }
+    }
+    await reifyFinish(this.npm, arb)
+  }
+}
+
+module.exports = Install
diff --git a/node/node_modules/npm/lib/commands/link.js b/node/node_modules/npm/lib/commands/link.js
new file mode 100644
index 0000000000000000000000000000000000000000..c97ec5ae0d41766b1419ecc7d6199658bcf1d055
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/link.js
@@ -0,0 +1,185 @@
+const { readdir } = require('node:fs/promises')
+const { resolve } = require('node:path')
+const npa = require('npm-package-arg')
+const pkgJson = require('@npmcli/package-json')
+const semver = require('semver')
+const reifyFinish = require('../utils/reify-finish.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Link extends ArboristWorkspaceCmd {
+  static description = 'Symlink a package folder'
+  static name = 'link'
+  static usage = [
+    '[<package-spec>]',
+  ]
+
+  static params = [
+    'save',
+    'save-exact',
+    'global',
+    'install-strategy',
+    'legacy-bundling',
+    'global-style',
+    'strict-peer-deps',
+    'package-lock',
+    'omit',
+    'include',
+    'ignore-scripts',
+    'allow-git',
+    'audit',
+    'bin-links',
+    'fund',
+    'dry-run',
+    ...super.params,
+  ]
+
+  static async completion (opts, npm) {
+    const dir = npm.globalDir
+    const files = await readdir(dir)
+    return files.filter(f => !/^[._-]/.test(f))
+  }
+
+  async exec (args) {
+    if (this.npm.global) {
+      throw Object.assign(
+        new Error(
+          'link should never be --global.\n' +
+          'Please re-run this command with --local'
+        ),
+        { code: 'ELINKGLOBAL' }
+      )
+    }
+    // install-links is implicitly false when running `npm link`
+    this.npm.config.set('install-links', false)
+
+    // link with no args: symlink the folder to the global location
+    // link with package arg: symlink the global to the local
+    args = args.filter(a => resolve(a) !== this.npm.prefix)
+    return args.length
+      ? this.linkInstall(args)
+      : this.linkPkg()
+  }
+
+  async linkInstall (args) {
+    // load current packages from the global space, and then add symlinks installs locally
+    const globalTop = resolve(this.npm.globalDir, '..')
+    const Arborist = require('@npmcli/arborist')
+    const globalOpts = {
+      ...this.npm.flatOptions,
+      Arborist,
+      path: globalTop,
+      global: true,
+      prune: false,
+    }
+    const globalArb = new Arborist(globalOpts)
+
+    // get only current top-level packages from the global space
+    const globals = await globalArb.loadActual({
+      filter: (node, kid) =>
+        !node.isRoot || args.some(a => npa(a).name === kid),
+    })
+
+    // any extra arg that is missing from the current global space should be reified there first
+    const missing = this.missingArgsFromTree(globals, args)
+    if (missing.length) {
+      await globalArb.reify({
+        ...globalOpts,
+        add: missing,
+      })
+    }
+
+    // get a list of module names that should be linked in the local prefix
+    const names = []
+    for (const a of args) {
+      const arg = npa(a)
+      if (arg.type === 'directory') {
+        const { content } = await pkgJson.normalize(arg.fetchSpec)
+        names.push(content.name)
+      } else {
+        names.push(arg.name)
+      }
+    }
+
+    // npm link should not save=true by default unless you're using any of --save-dev or other types
+    const save =
+      Boolean(
+        (this.npm.config.find('save') !== 'default' &&
+        this.npm.config.get('save')) ||
+        this.npm.config.get('save-optional') ||
+        this.npm.config.get('save-peer') ||
+        this.npm.config.get('save-dev') ||
+        this.npm.config.get('save-prod')
+      )
+    // create a new arborist instance for the local prefix and
+    // reify all the pending names as symlinks there
+    const localArb = new Arborist({
+      ...this.npm.flatOptions,
+      prune: false,
+      path: this.npm.prefix,
+      save,
+    })
+    await localArb.reify({
+      ...this.npm.flatOptions,
+      prune: false,
+      path: this.npm.prefix,
+      add: names.map(l => `file:${resolve(globalTop, 'node_modules', l)}`),
+      save,
+      workspaces: this.workspaceNames,
+    })
+
+    await reifyFinish(this.npm, localArb)
+  }
+
+  async linkPkg () {
+    const wsp = this.workspacePaths
+    const paths = wsp && wsp.length ? wsp : [this.npm.prefix]
+    const add = paths.map(path => `file:${path}`)
+    const globalTop = resolve(this.npm.globalDir, '..')
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({
+      ...this.npm.flatOptions,
+      Arborist,
+      path: globalTop,
+      global: true,
+    })
+    await arb.reify({
+      add,
+    })
+    await reifyFinish(this.npm, arb)
+  }
+
+  // Returns a list of items that can't be fulfilled by things found in the current arborist inventory
+  missingArgsFromTree (tree, args) {
+    if (tree.isLink) {
+      return this.missingArgsFromTree(tree.target, args)
+    }
+
+    const foundNodes = []
+    const missing = args.filter(a => {
+      const arg = npa(a)
+      const nodes = tree.children.values()
+      const argFound = [...nodes].every(node => {
+        // TODO: write tests for unmatching version specs
+        // this is hard to test atm but should be simple once we have a mocked registry again
+        if (arg.name !== node.name /* istanbul ignore next */ || (
+          arg.version &&
+          /* istanbul ignore next */
+          !semver.satisfies(node.version, arg.version)
+        )) {
+          foundNodes.push(node)
+          return true
+        }
+      })
+      return argFound
+    })
+
+    // remote nodes from the loaded tree in order to avoid dropping them later when reifying
+    for (const node of foundNodes) {
+      node.parent = null
+    }
+
+    return missing
+  }
+}
+
+module.exports = Link
diff --git a/node/node_modules/npm/lib/commands/ll.js b/node/node_modules/npm/lib/commands/ll.js
new file mode 100644
index 0000000000000000000000000000000000000000..c405eebf0f5da2c5f38bfbbb0ebec3da34204fe8
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/ll.js
@@ -0,0 +1,13 @@
+const LS = require('./ls.js')
+
+class LL extends LS {
+  static name = 'll'
+  static usage = ['[[<@scope>/]<pkg> ...]']
+
+  async exec (args) {
+    this.npm.config.set('long', true)
+    return super.exec(args)
+  }
+}
+
+module.exports = LL
diff --git a/node/node_modules/npm/lib/commands/login.js b/node/node_modules/npm/lib/commands/login.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c32729760c6a3046d1ae241a77b7eda5ea0752b
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/login.js
@@ -0,0 +1,50 @@
+const { log, output } = require('proc-log')
+const { redactLog: replaceInfo } = require('@npmcli/redact')
+const auth = require('../utils/auth.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Login extends BaseCommand {
+  static description = 'Login to a registry user account'
+  static name = 'login'
+  static params = [
+    'registry',
+    'scope',
+    'auth-type',
+  ]
+
+  async exec () {
+    const scope = this.npm.config.get('scope')
+    let registry = this.npm.config.get('registry')
+
+    if (scope) {
+      const scopedRegistry = this.npm.config.get(`${scope}:registry`)
+      const cliRegistry = this.npm.config.get('registry', 'cli')
+      if (scopedRegistry && !cliRegistry) {
+        registry = scopedRegistry
+      }
+    }
+
+    const creds = this.npm.config.getCredentialsByURI(registry)
+
+    log.notice('', `Log in on ${replaceInfo(registry)}`)
+
+    const { message, newCreds } = await auth.login(this.npm, {
+      ...this.npm.flatOptions,
+      creds,
+      registry,
+    })
+
+    this.npm.config.delete('_token', 'user') // prevent legacy pollution
+    this.npm.config.setCredentialsByURI(registry, newCreds)
+
+    if (scope) {
+      this.npm.config.set(scope + ':registry', registry, 'user')
+    }
+
+    await this.npm.config.save('user')
+
+    output.standard(message)
+  }
+}
+
+module.exports = Login
diff --git a/node/node_modules/npm/lib/commands/logout.js b/node/node_modules/npm/lib/commands/logout.js
new file mode 100644
index 0000000000000000000000000000000000000000..8bab8009f65fa2e068c0e053593a3767d5d31f46
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/logout.js
@@ -0,0 +1,50 @@
+const npmFetch = require('npm-registry-fetch')
+const { getAuth } = npmFetch
+const { log } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+
+class Logout extends BaseCommand {
+  static description = 'Log out of the registry'
+  static name = 'logout'
+  static params = [
+    'registry',
+    'scope',
+  ]
+
+  async exec () {
+    const registry = this.npm.config.get('registry')
+    const scope = this.npm.config.get('scope')
+    const regRef = scope ? `${scope}:registry` : 'registry'
+    const reg = this.npm.config.get(regRef) || registry
+
+    const auth = getAuth(reg, this.npm.flatOptions)
+
+    const level = this.npm.config.find(`${auth.regKey}:${auth.authKey}`)
+
+    // find the config level and only delete from there
+    if (auth.token) {
+      log.verbose('logout', `clearing token for ${reg}`)
+      await npmFetch(`/-/user/token/${encodeURIComponent(auth.token)}`, {
+        ...this.npm.flatOptions,
+        registry: reg,
+        method: 'DELETE',
+        ignoreBody: true,
+      })
+    } else if (auth.isBasicAuth) {
+      log.verbose('logout', `clearing user credentials for ${reg}`)
+    } else {
+      const msg = `not logged in to ${reg}, so can't log out!`
+      throw Object.assign(new Error(msg), { code: 'ENEEDAUTH' })
+    }
+
+    if (scope) {
+      this.npm.config.delete(regRef, level)
+    }
+
+    this.npm.config.clearCredentialsByURI(reg, level)
+
+    await this.npm.config.save(level)
+  }
+}
+
+module.exports = Logout
diff --git a/node/node_modules/npm/lib/commands/ls.js b/node/node_modules/npm/lib/commands/ls.js
new file mode 100644
index 0000000000000000000000000000000000000000..1befb1e0a41f91330c62ff4db5eaa07b72174b26
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/ls.js
@@ -0,0 +1,588 @@
+const { resolve, relative, sep } = require('node:path')
+const archy = require('archy')
+const { breadth } = require('treeverse')
+const npa = require('npm-package-arg')
+const { output } = require('proc-log')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+
+const relativePrefix = `.${sep}`
+
+const _depth = Symbol('depth')
+const _dedupe = Symbol('dedupe')
+const _filteredBy = Symbol('filteredBy')
+const _include = Symbol('include')
+const _invalid = Symbol('invalid')
+const _name = Symbol('name')
+const _missing = Symbol('missing')
+const _parent = Symbol('parent')
+const _problems = Symbol('problems')
+const _required = Symbol('required')
+const _type = Symbol('type')
+
+class LS extends ArboristWorkspaceCmd {
+  static description = 'List installed packages'
+  static name = 'ls'
+  static usage = ['<package-spec>']
+  static params = [
+    'all',
+    'json',
+    'long',
+    'parseable',
+    'global',
+    'depth',
+    'omit',
+    'include',
+    'link',
+    'package-lock-only',
+    'unicode',
+    ...super.params,
+  ]
+
+  static async completion (opts, npm) {
+    const completion = require('../utils/installed-deep.js')
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    const all = this.npm.config.get('all')
+    const chalk = this.npm.chalk
+    const depth = this.npm.config.get('depth')
+    const global = this.npm.global
+    const json = this.npm.config.get('json')
+    const link = this.npm.config.get('link')
+    const long = this.npm.config.get('long')
+    const omit = this.npm.flatOptions.omit
+    const parseable = this.npm.config.get('parseable')
+    const unicode = this.npm.config.get('unicode')
+    const packageLockOnly = this.npm.config.get('package-lock-only')
+    const workspacesEnabled = this.npm.flatOptions.workspacesEnabled
+    const installStrategy = this.npm.flatOptions.installStrategy
+
+    const path = global ? resolve(this.npm.globalDir, '..') : this.npm.prefix
+
+    const Arborist = require('@npmcli/arborist')
+
+    const arb = new Arborist({
+      global,
+      ...this.npm.flatOptions,
+      legacyPeerDeps: false,
+      path,
+    })
+    const tree = await this.initTree({ arb, args, packageLockOnly })
+
+    // filters by workspaces nodes when using -w <workspace-name>
+    // We only have to filter the first layer of edges, so we don't explore anything that isn't part of the selected workspace set.
+    let wsNodes
+    if (this.workspaceNames && this.workspaceNames.length) {
+      wsNodes = arb.workspaceNodes(tree, this.workspaceNames)
+    }
+    const filterBySelectedWorkspaces = edge => {
+      if (!workspacesEnabled
+        && edge.from.isProjectRoot
+        && edge.to.isWorkspace
+      ) {
+        return false
+      }
+
+      if (!wsNodes || !wsNodes.length) {
+        return true
+      }
+
+      if (this.npm.flatOptions.includeWorkspaceRoot
+          && edge.to && !edge.to.isWorkspace) {
+        return true
+      }
+
+      if (edge.from.isProjectRoot) {
+        return (edge.to
+          && edge.to.isWorkspace
+          && wsNodes.includes(edge.to.target))
+      }
+
+      return true
+    }
+
+    const seenItems = new Set()
+    const seenNodes = new Map()
+    const problems = new Set()
+
+    // defines special handling of printed depth when filtering with args
+    const filterDefaultDepth = depth === null ? Infinity : depth
+    const depthToPrint = (all || args.length)
+      ? filterDefaultDepth
+      : (depth || 0)
+
+    // add root node of tree to list of seenNodes
+    seenNodes.set(tree.path, tree)
+
+    // tree traversal happens here, using treeverse.breadth
+    const result = await breadth({
+      tree,
+      // recursive method, `node` is going to be the current elem (starting from the `tree` obj) that was just visited in the `visit` method below `nodeResult` is going to be the returned `item` from `visit`
+      getChildren (node, nodeResult) {
+        const seenPaths = new Set()
+        const workspace = node.isWorkspace
+        const currentDepth = workspace ? 0 : node[_depth]
+        const shouldSkipChildren =
+          !(node instanceof Arborist.Node) || (currentDepth > depthToPrint)
+        return (shouldSkipChildren)
+          ? []
+          : [...(node.target).edgesOut.values()]
+            .filter(filterBySelectedWorkspaces)
+            .filter(currentDepth === 0 ? filterByEdgesTypes({
+              link,
+              omit,
+            }) : () => true)
+            .filter(installStrategy === 'linked'
+              ? filterLinkedStrategyEdges({ node, currentDepth })
+              : () => true)
+            .map(mapEdgesToNodes({ seenPaths }))
+            .concat(appendExtraneousChildren({ node, seenPaths }))
+            .sort(sortAlphabetically)
+            .map(augmentNodesWithMetadata({
+              args,
+              currentDepth,
+              nodeResult,
+              seenNodes,
+            }))
+      },
+      // visit each `node` of the `tree`, returning an `item` - these are the elements that will be used to build the final output
+      visit (node) {
+        node[_problems] = getProblems(node, { global })
+
+        const item = json
+          ? getJsonOutputItem(node, { global, long })
+          : parseable
+            ? null
+            : getHumanOutputItem(node, { args, chalk, global, long })
+
+        // loop through list of node problems to add them to global list
+        if (node[_include]) {
+          for (const problem of node[_problems]) {
+            problems.add(problem)
+          }
+        }
+
+        seenItems.add(item)
+
+        // return a promise so we don't blow the stack
+        return Promise.resolve(item)
+      },
+    })
+
+    // handle the special case of a broken package.json in the root folder
+    const [rootError] = tree.errors.filter(e =>
+      e.code === 'EJSONPARSE' && e.path === resolve(path, 'package.json'))
+
+    if (json) {
+      output.buffer(jsonOutput({ path, problems, result, rootError, seenItems }))
+    } else {
+      output.standard(parseable
+        ? parseableOutput({ seenNodes, global, long })
+        : humanOutput({ chalk, result, seenItems, unicode })
+      )
+    }
+
+    // if filtering items, should exit with error code on no results
+    if (result && !result[_include] && args.length) {
+      process.exitCode = 1
+    }
+
+    if (rootError) {
+      throw Object.assign(
+        new Error('Failed to parse root package.json'),
+        { code: 'EJSONPARSE' }
+      )
+    }
+
+    const shouldThrow = problems.size &&
+      ![...problems].every(problem => problem.startsWith('extraneous:'))
+
+    if (shouldThrow) {
+      throw Object.assign(
+        new Error([...problems].join('\n')),
+        { code: 'ELSPROBLEMS' }
+      )
+    }
+  }
+
+  async initTree ({ arb, args, packageLockOnly }) {
+    const tree = await (
+      packageLockOnly
+        ? arb.loadVirtual()
+        : arb.loadActual()
+    )
+
+    tree[_include] = args.length === 0
+    tree[_depth] = 0
+
+    return tree
+  }
+}
+
+module.exports = LS
+
+const isGitNode = (node) => {
+  if (!node.resolved) {
+    return
+  }
+
+  try {
+    const { type } = npa(node.resolved)
+    return type === 'git' || type === 'hosted'
+  } catch {
+    return false
+  }
+}
+
+const isOptional = (node) =>
+  node[_type] === 'optional' || node[_type] === 'peerOptional'
+
+const isExtraneous = (node, { global }) =>
+  node.extraneous && !global
+
+const getProblems = (node, { global }) => {
+  const problems = new Set()
+
+  if (node[_missing] && !isOptional(node)) {
+    problems.add(`missing: ${node.pkgid}, required by ${node[_missing]}`)
+  }
+
+  if (node[_invalid]) {
+    problems.add(`invalid: ${node.pkgid} ${node.path}`)
+  }
+
+  if (isExtraneous(node, { global })) {
+    problems.add(`extraneous: ${node.pkgid} ${node.path}`)
+  }
+
+  return problems
+}
+
+// annotates _parent and _include metadata into the resulting item obj allowing for filtering out results during output
+const augmentItemWithIncludeMetadata = (node, item) => {
+  item[_parent] = node[_parent]
+  item[_include] = node[_include]
+
+  // append current item to its parent.nodes which is the structure expected by archy in order to print tree
+  if (node[_include]) {
+    // includes all ancestors of included node
+    let p = node[_parent]
+    while (p) {
+      p[_include] = true
+      p = p[_parent]
+    }
+  }
+
+  return item
+}
+
+const getHumanOutputItem = (node, { args, chalk, global, long }) => {
+  const { pkgid, path } = node
+  const workspacePkgId = chalk.blueBright(pkgid)
+  let printable = node.isWorkspace ? workspacePkgId : pkgid
+
+  // special formatting for top-level package name
+  if (node.isRoot) {
+    const hasNoPackageJson = !Object.keys(node.package).length
+    if (hasNoPackageJson || global) {
+      printable = path
+    } else {
+      printable += `${long ? '\n' : ' '}${path}`
+    }
+  }
+
+  // TODO there is a LOT of overlap with lib/utils/explain-dep.js here
+
+  const highlightDepName = args.length && node[_filteredBy]
+  const missingColor = isOptional(node)
+    ? chalk.yellow
+    : chalk.red
+  const missingMsg = `UNMET ${isOptional(node) ? 'OPTIONAL ' : ''}DEPENDENCY`
+  const targetLocation = node.root
+    ? relative(node.root.realpath, node.realpath)
+    : node.targetLocation
+  const invalid = node[_invalid]
+    ? `invalid: ${node[_invalid]}`
+    : ''
+  const label =
+    (
+      node[_missing]
+        ? missingColor(missingMsg) + ' '
+        : ''
+    ) +
+    `${highlightDepName ? chalk.yellow(printable) : printable}` +
+    (
+      node[_dedupe]
+        ? ' ' + chalk.dim('deduped')
+        : ''
+    ) +
+    (
+      invalid
+        ? ' ' + chalk.red(invalid)
+        : ''
+    ) +
+    (
+      isExtraneous(node, { global })
+        ? ' ' + chalk.red('extraneous')
+        : ''
+    ) +
+    (
+      node.overridden
+        ? ' ' + chalk.dim('overridden')
+        : ''
+    ) +
+    (isGitNode(node) ? ` (${node.resolved})` : '') +
+    (node.isLink ? ` -> ${relativePrefix}${targetLocation}` : '') +
+    (long ? `\n${node.package.description || ''}` : '')
+
+  return augmentItemWithIncludeMetadata(node, { label, nodes: [] })
+}
+
+const getJsonOutputItem = (node, { global, long }) => {
+  const item = {}
+
+  if (node.version) {
+    item.version = node.version
+  }
+
+  if (node.resolved) {
+    item.resolved = node.resolved
+  }
+
+  // if the node is the project root, do not add the overridden flag.
+  // the project root can't be overridden anyway, and if we add the flag it causes undesirable behavior when `npm ls --json` is ran in an empty directory since we end up printing an object with only an overridden prop
+  if (!node.isProjectRoot) {
+    item.overridden = node.overridden
+  }
+
+  item[_name] = node.name
+
+  // special formatting for top-level package name
+  const hasPackageJson =
+    node && node.package && Object.keys(node.package).length
+  if (node.isRoot && hasPackageJson) {
+    item.name = node.package.name || node.name
+  }
+
+  if (long && !node[_missing]) {
+    item.name = item[_name]
+    const { dependencies, ...packageInfo } = node.package
+    Object.assign(item, packageInfo)
+    item.extraneous = false
+    item.path = node.path
+    item._dependencies = {
+      ...node.package.dependencies,
+      ...node.package.optionalDependencies,
+    }
+    item.devDependencies = node.package.devDependencies || {}
+    item.peerDependencies = node.package.peerDependencies || {}
+  }
+
+  // augment json output items with extra metadata
+  if (isExtraneous(node, { global })) {
+    item.extraneous = true
+  }
+
+  if (node[_invalid]) {
+    item.invalid = node[_invalid]
+  }
+
+  if (node[_missing] && !isOptional(node)) {
+    item.required = node[_required]
+    item.missing = true
+  }
+  if (node[_include] && node[_problems] && node[_problems].size) {
+    item.problems = [...node[_problems]]
+  }
+
+  return augmentItemWithIncludeMetadata(node, item)
+}
+
+// In linked strategy, two types of edges produce false UNMET DEPENDENCYs:
+// 1. Workspace edges for undeclared workspaces: the lockfile records edges from root to ALL workspaces, but only declared workspaces are hoisted to root/node_modules in linked mode.  Undeclared ones are intentionally absent.
+// 2. Dev edges on non-root packages: store package link targets have no parent in the node tree, so they are treated as "top" nodes and their devDependencies are loaded as edges.  Those devDeps are never installed.
+const filterLinkedStrategyEdges = ({ node, currentDepth }) => {
+  const declaredDeps = new Set(Object.keys(Object.assign({},
+    node.target.package.dependencies,
+    node.target.package.devDependencies,
+    node.target.package.optionalDependencies,
+    node.target.package.peerDependencies
+  )))
+
+  return (edge) => {
+    // Skip workspace edges for undeclared workspaces at root level
+    if (currentDepth === 0 && edge.type === 'workspace' && edge.missing) {
+      if (!declaredDeps.has(edge.name)) {
+        return false
+      }
+    }
+
+    // Skip dev edges for non-root packages (store packages)
+    if (currentDepth > 0 && edge.dev) {
+      return false
+    }
+
+    return true
+  }
+}
+
+const filterByEdgesTypes = ({ link, omit }) => (edge) => {
+  for (const omitType of omit) {
+    if (edge[omitType]) {
+      return false
+    }
+  }
+  return link ? edge.to && edge.to.isLink : true
+}
+
+const appendExtraneousChildren = ({ node, seenPaths }) =>
+  // extraneous children are not represented
+  // in edges out, so here we add them to the list:
+  [...node.children.values()]
+    .filter(i => !seenPaths.has(i.path) && i.extraneous)
+
+const mapEdgesToNodes = ({ seenPaths }) => (edge) => {
+  let node = edge.to
+
+  // if the edge is linking to a missing node, we go ahead and create a new obj that will represent the missing node
+  if (edge.missing || (edge.optional && !node)) {
+    const { name, spec } = edge
+    const pkgid = `${name}@${spec}`
+    node = { name, pkgid, [_missing]: edge.from.pkgid }
+  }
+
+  // keeps track of a set of seen paths to avoid the edge case in which a tree item would appear twice given that it's a children of an extraneous item
+  // so it's marked extraneous but it will ALSO show up in edgesOuts of its parent so it ends up as two diff nodes if we don't track it
+  if (node.path) {
+    seenPaths.add(node.path)
+  }
+
+  node[_required] = edge.spec || '*'
+  node[_type] = edge.type
+
+  if (edge.invalid) {
+    const spec = JSON.stringify(node[_required])
+    const from = edge.from.location || 'the root project'
+    node[_invalid] = (node[_invalid] ? node[_invalid] + ', ' : '') +
+      (`${spec} from ${from}`)
+  }
+
+  return node
+}
+
+const filterByPositionalArgs = (args, { node }) =>
+  args.length > 0 ? args.some(
+    (spec) => (node.satisfies && node.satisfies(spec))
+  ) : true
+
+const augmentNodesWithMetadata = ({
+  args,
+  currentDepth,
+  nodeResult,
+  seenNodes,
+}) => (node) => {
+  // if the original edge was a deduped dep, treeverse will fail to revisit that node in tree traversal logic, so we make it so that we have a diff obj for deduped nodes:
+  if (seenNodes.has(node.path)) {
+    const { realpath, root } = node
+    const targetLocation = root ? relative(root.realpath, realpath)
+      : node.targetLocation
+    node = {
+      name: node.name,
+      version: node.version,
+      pkgid: node.pkgid,
+      package: node.package,
+      path: node.path,
+      isLink: node.isLink,
+      realpath: node.realpath,
+      targetLocation,
+      [_type]: node[_type],
+      [_invalid]: node[_invalid],
+      [_missing]: node[_missing],
+      // if it's missing, it's not deduped, it's just missing
+      [_dedupe]: !node[_missing],
+    }
+  } else {
+    // keeps track of already seen nodes in order to check for dedupes
+    seenNodes.set(node.path, node)
+  }
+
+  // _parent is going to be a ref to a treeverse-visited node (returned from getHumanOutputItem, getJsonOutputItem, etc) so that we have an easy shortcut to place new nodes in their right place during tree traversal
+  node[_parent] = nodeResult
+  // _include is the property that allow us to filter based on position args
+  // e.g: `npm ls foo`, `npm ls simple-output@2`
+  // _filteredBy is used to apply extra color info to the item that was used in args in order to filter
+  node[_filteredBy] = node[_include] =
+    filterByPositionalArgs(args, { node: seenNodes.get(node.path) })
+  // _depth keeps track of how many levels deep tree traversal currently is so that we can `npm ls --depth=1`
+  node[_depth] = currentDepth + 1
+
+  return node
+}
+
+const sortAlphabetically = ({ pkgid: a }, { pkgid: b }) => localeCompare(a, b)
+
+const humanOutput = ({ chalk, result, seenItems, unicode }) => {
+  // we need to traverse the entire tree in order to determine which items should be included (since a nested transitive included dep will make it so that all its ancestors should be displayed)
+  // here is where we put items in their expected place for archy output
+  for (const item of seenItems) {
+    if (item[_include] && item[_parent]) {
+      item[_parent].nodes.push(item)
+    }
+  }
+
+  if (!result.nodes.length) {
+    result.nodes = ['(empty)']
+  }
+
+  const archyOutput = archy(result, '', { unicode })
+  return chalk.reset(archyOutput)
+}
+
+const jsonOutput = ({ path, problems, result, rootError, seenItems }) => {
+  if (problems.size) {
+    result.problems = [...problems]
+  }
+
+  if (rootError) {
+    result.problems = [
+      ...(result.problems || []),
+      ...[`error in ${path}: Failed to parse root package.json`],
+    ]
+    result.invalid = true
+  }
+
+  // we need to traverse the entire tree in order to determine which items should be included (since a nested transitive included dep will make it so that all its ancestors should be displayed)
+  // here is where we put items in their expected place for json output
+  for (const item of seenItems) {
+    // append current item to its parent item.dependencies obj in order to provide a json object structure that represents the installed tree
+    if (item[_include] && item[_parent]) {
+      if (!item[_parent].dependencies) {
+        item[_parent].dependencies = {}
+      }
+
+      item[_parent].dependencies[item[_name]] = item
+    }
+  }
+
+  return result
+}
+
+const parseableOutput = ({ global, long, seenNodes }) => {
+  let out = ''
+  for (const node of seenNodes.values()) {
+    if (node.path && node[_include]) {
+      out += node.path
+      if (long) {
+        out += `:${node.pkgid}`
+        out += node.path !== node.realpath ? `:${node.realpath}` : ''
+        out += isExtraneous(node, { global }) ? ':EXTRANEOUS' : ''
+        out += node[_invalid] ? ':INVALID' : ''
+        out += node.overridden ? ':OVERRIDDEN' : ''
+      }
+      out += '\n'
+    }
+  }
+  return out.trim()
+}
diff --git a/node/node_modules/npm/lib/commands/org.js b/node/node_modules/npm/lib/commands/org.js
new file mode 100644
index 0000000000000000000000000000000000000000..21af23228bd579f11376ed56c8fa89b10c84d67c
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/org.js
@@ -0,0 +1,148 @@
+const liborg = require('libnpmorg')
+const { otplease } = require('../utils/auth.js')
+const BaseCommand = require('../base-cmd.js')
+const { output } = require('proc-log')
+
+class Org extends BaseCommand {
+  static description = 'Manage orgs'
+  static name = 'org'
+  static usage = [
+    'set orgname username [developer | admin | owner]',
+    'rm orgname username',
+    'ls orgname [<username>]',
+  ]
+
+  static params = ['registry', 'otp', 'json', 'parseable']
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      return ['set', 'rm', 'ls']
+    }
+
+    switch (argv[2]) {
+      case 'ls':
+      case 'add':
+      case 'rm':
+      case 'set':
+        return []
+      default:
+        throw new Error(argv[2] + ' not recognized')
+    }
+  }
+
+  async exec ([cmd, orgname, username, role]) {
+    return otplease(this.npm, {
+      ...this.npm.flatOptions,
+    }, opts => {
+      switch (cmd) {
+        case 'add':
+        case 'set':
+          return this.set(orgname, username, role, opts)
+        case 'rm':
+          return this.rm(orgname, username, opts)
+        case 'ls':
+          return this.ls(orgname, username, opts)
+        default:
+          throw this.usageError()
+      }
+    })
+  }
+
+  async set (org, user, role, opts) {
+    role = role || 'developer'
+    if (!org) {
+      throw new Error('First argument `orgname` is required.')
+    }
+
+    if (!user) {
+      throw new Error('Second argument `username` is required.')
+    }
+
+    if (!['owner', 'admin', 'developer'].find(x => x === role)) {
+      throw new Error(
+        'Third argument `role` must be one of `owner`, `admin`, or `developer`, with `developer` being the default value if omitted.'
+      )
+    }
+
+    const memDeets = await liborg.set(org, user, role, opts)
+    if (opts.json) {
+      output.standard(JSON.stringify(memDeets, null, 2))
+    } else if (opts.parseable) {
+      output.standard(['org', 'orgsize', 'user', 'role'].join('\t'))
+      output.standard(
+        [memDeets.org.name, memDeets.org.size, memDeets.user, memDeets.role].join('\t')
+      )
+    } else if (!this.npm.silent) {
+      output.standard(
+        `Added ${memDeets.user} as ${memDeets.role} to ${memDeets.org.name}. You now have ${
+            memDeets.org.size
+          } member${memDeets.org.size === 1 ? '' : 's'} in this org.`
+      )
+    }
+
+    return memDeets
+  }
+
+  async rm (org, user, opts) {
+    if (!org) {
+      throw new Error('First argument `orgname` is required.')
+    }
+
+    if (!user) {
+      throw new Error('Second argument `username` is required.')
+    }
+
+    await liborg.rm(org, user, opts)
+    const roster = await liborg.ls(org, opts)
+    user = user.replace(/^[~@]?/, '')
+    org = org.replace(/^[~@]?/, '')
+    const userCount = Object.keys(roster).length
+    if (opts.json) {
+      output.buffer({
+        user,
+        org,
+        userCount,
+        deleted: true,
+      })
+    } else if (opts.parseable) {
+      output.standard(['user', 'org', 'userCount', 'deleted'].join('\t'))
+      output.standard([user, org, userCount, true].join('\t'))
+    } else if (!this.npm.silent) {
+      output.standard(
+        `Successfully removed ${user} from ${org}. You now have ${userCount} member${userCount === 1 ? '' : 's'} in this org.`
+      )
+    }
+  }
+
+  async ls (org, user, opts) {
+    if (!org) {
+      throw new Error('First argument `orgname` is required.')
+    }
+
+    let roster = await liborg.ls(org, opts)
+    if (user) {
+      const newRoster = {}
+      if (roster[user]) {
+        newRoster[user] = roster[user]
+      }
+
+      roster = newRoster
+    }
+    if (opts.json) {
+      output.buffer(roster)
+    } else if (opts.parseable) {
+      output.standard(['user', 'role'].join('\t'))
+      Object.keys(roster).forEach(u => {
+        output.standard([u, roster[u]].join('\t'))
+      })
+    } else if (!this.npm.silent) {
+      const chalk = this.npm.chalk
+      for (const u of Object.keys(roster).sort()) {
+        output.standard(`${u} - ${chalk.cyan(roster[u])}`)
+      }
+    }
+  }
+}
+
+module.exports = Org
diff --git a/node/node_modules/npm/lib/commands/outdated.js b/node/node_modules/npm/lib/commands/outdated.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe87482f058f6ea3b3a390aaf30a8f1ab3ba306b
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/outdated.js
@@ -0,0 +1,285 @@
+const { resolve } = require('node:path')
+const { stripVTControlCharacters } = require('node:util')
+const pacote = require('pacote')
+const table = require('text-table')
+const npa = require('npm-package-arg')
+const pickManifest = require('npm-pick-manifest')
+const { output } = require('proc-log')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+const safeNpa = (spec) => {
+  try {
+    return npa(spec)
+  } catch {
+    return null
+  }
+}
+
+// This string is load bearing and is shared with Arborist
+const MISSING = 'MISSING'
+
+class Outdated extends ArboristWorkspaceCmd {
+  static description = 'Check for outdated packages'
+  static name = 'outdated'
+  static usage = ['[<package-spec> ...]']
+  static params = [
+    'all',
+    'json',
+    'long',
+    'parseable',
+    'global',
+    'workspace',
+    'before',
+  ]
+
+  #tree
+  #list = []
+  #edges = new Set()
+  #filterSet
+
+  async exec (args) {
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({
+      ...this.npm.flatOptions,
+      path: this.npm.global ? resolve(this.npm.globalDir, '..') : this.npm.prefix,
+    })
+    this.#tree = await arb.loadActual()
+
+    if (this.workspaceNames?.length) {
+      this.#filterSet = arb.workspaceDependencySet(
+        this.#tree,
+        this.workspaceNames,
+        this.npm.flatOptions.includeWorkspaceRoot
+      )
+    } else if (!this.npm.flatOptions.workspacesEnabled) {
+      this.#filterSet = arb.excludeWorkspacesDependencySet(this.#tree)
+    }
+
+    if (args.length) {
+      for (const arg of args) {
+        // specific deps
+        this.#getEdges(this.#tree.inventory.query('name', arg), 'edgesIn')
+      }
+    } else {
+      if (this.npm.config.get('all')) {
+        // all deps in tree
+        this.#getEdges(this.#tree.inventory.values(), 'edgesOut')
+      }
+      // top-level deps
+      this.#getEdges()
+    }
+
+    await Promise.all([...this.#edges].map((e) => this.#getOutdatedInfo(e)))
+
+    // sorts list alphabetically by name and then dependent
+    const outdated = this.#list
+      .sort((a, b) => localeCompare(a.name, b.name) || localeCompare(a.dependent, b.dependent))
+
+    if (outdated.length) {
+      process.exitCode = 1
+    }
+
+    if (this.npm.config.get('json')) {
+      output.buffer(this.#json(outdated))
+      return
+    }
+
+    const res = this.npm.config.get('parseable')
+      ? this.#parseable(outdated)
+      : this.#pretty(outdated)
+
+    if (res) {
+      output.standard(res)
+    }
+  }
+
+  #getEdges (nodes, type) {
+    // when no nodes are provided then it should only read direct deps from the root node and its workspaces direct dependencies
+    if (!nodes) {
+      this.#getEdgesOut(this.#tree)
+      this.#getWorkspacesEdges()
+      return
+    }
+
+    for (const node of nodes) {
+      if (type === 'edgesOut') {
+        this.#getEdgesOut(node)
+      } else {
+        this.#getEdgesIn(node)
+      }
+    }
+  }
+
+  #getEdgesIn (node) {
+    for (const edge of node.edgesIn) {
+      this.#trackEdge(edge)
+    }
+  }
+
+  #getEdgesOut (node) {
+    // TODO: normalize usage of edges and avoid looping through nodes here
+    const edges = this.npm.global ? node.children.values() : node.edgesOut.values()
+    for (const edge of edges) {
+      this.#trackEdge(edge)
+    }
+  }
+
+  #trackEdge (edge) {
+    if (edge.from && this.#filterSet?.size > 0 && !this.#filterSet.has(edge.from.target)) {
+      return
+    }
+    this.#edges.add(edge)
+  }
+
+  #getWorkspacesEdges () {
+    if (this.npm.global) {
+      return
+    }
+
+    for (const edge of this.#tree.edgesOut.values()) {
+      if (edge?.to?.target?.isWorkspace) {
+        this.#getEdgesOut(edge.to.target)
+      }
+    }
+  }
+
+  async #getPackument (spec) {
+    return pacote.packument(spec, {
+      ...this.npm.flatOptions,
+      fullMetadata: this.npm.config.get('long'),
+      preferOnline: true,
+    })
+  }
+
+  async #getOutdatedInfo (edge) {
+    const alias = safeNpa(edge.spec)?.subSpec
+    const spec = npa(alias ? alias.name : edge.name)
+    const node = edge.to || edge
+    const { path, location, package: { version: current } = {} } = node
+
+    const type = edge.optional ? 'optionalDependencies'
+      : edge.peer ? 'peerDependencies'
+      : edge.dev ? 'devDependencies'
+      : 'dependencies'
+
+    for (const omitType of this.npm.flatOptions.omit) {
+      if (node[omitType]) {
+        return
+      }
+    }
+
+    // deps different from prod not currently on disk are not included in the output
+    if (edge.error === MISSING && type !== 'dependencies') {
+      return
+    }
+
+    // if it's not a range, version, or tag, skip it
+    if (!safeNpa(`${edge.name}@${edge.spec}`)?.registry) {
+      return null
+    }
+
+    try {
+      const packument = await this.#getPackument(spec)
+      const expected = alias ? alias.fetchSpec : edge.spec
+      const wanted = pickManifest(packument, expected, this.npm.flatOptions)
+      const latest = pickManifest(packument, '*', this.npm.flatOptions)
+      if (!current || current !== wanted.version || wanted.version !== latest.version) {
+        this.#list.push({
+          name: alias ? edge.spec.replace('npm', edge.name) : edge.name,
+          path,
+          type,
+          current,
+          location,
+          wanted: wanted.version,
+          latest: latest.version,
+          workspaceDependent: edge.from?.isWorkspace ? edge.from.pkgid : null,
+          dependedByLocation: edge.from?.name
+            ? edge.from?.location
+            : 'global',
+          dependent: edge.from?.name ?? 'global',
+          homepage: packument.homepage,
+        })
+      }
+    } catch (err) {
+      // silently catch and ignore ETARGET, E403 & E404 errors
+      // deps are just skipped
+      if (!['ETARGET', 'E403', 'E404'].includes(err.code)) {
+        throw err
+      }
+    }
+  }
+
+  // formatting functions
+
+  #pretty (list) {
+    if (!list.length) {
+      return
+    }
+
+    const long = this.npm.config.get('long')
+    const { bold, yellow, red, cyan, blue } = this.npm.chalk
+
+    return table([
+      [
+        'Package',
+        'Current',
+        'Wanted',
+        'Latest',
+        'Location',
+        'Depended by',
+        ...long ? ['Package Type', 'Homepage', 'Depended By Location'] : [],
+      ].map(h => bold.underline(h)),
+      ...list.map((d) => [
+        d.current === d.wanted ? yellow(d.name) : red(d.name),
+        d.current ?? 'MISSING',
+        cyan(d.wanted),
+        blue(d.latest),
+        d.location ?? '-',
+        d.workspaceDependent ? blue(d.workspaceDependent) : d.dependent,
+        ...long ? [d.type, blue(d.homepage ?? ''), d.dependedByLocation] : [],
+      ]),
+    ], {
+      align: ['l', 'r', 'r', 'r', 'l'],
+      stringLength: s => stripVTControlCharacters(s).length,
+    })
+  }
+
+  // --parseable creates output like this:
+  // <fullpath>:<name@wanted>:<name@installed>:<name@latest>:<dependedby>
+  #parseable (list) {
+    return list.map(d => [
+      d.path,
+      `${d.name}@${d.wanted}`,
+      d.current ? `${d.name}@${d.current}` : 'MISSING',
+      `${d.name}@${d.latest}`,
+      d.dependent,
+      ...this.npm.config.get('long') ? [d.type, d.homepage, d.dependedByLocation] : [],
+    ].join(':')).join('\n')
+  }
+
+  #json (list) {
+    // TODO(BREAKING_CHANGE): this should just return an array.
+    // It's a list and turning it into an object with keys is lossy since multiple items in the list could have the same key. For now we hack that by only changing top level values into arrays if they have multiple outdated items
+    return list.reduce((acc, d) => {
+      const dep = {
+        current: d.current,
+        wanted: d.wanted,
+        latest: d.latest,
+        dependent: d.dependent,
+        location: d.path,
+        ...this.npm.config.get('long') ? {
+          type: d.type,
+          homepage: d.homepage,
+          dependedByLocation: d.dependedByLocation } : {},
+      }
+      acc[d.name] = acc[d.name]
+        // If this item already has an outdated dep then we turn it into an array
+        ? (Array.isArray(acc[d.name]) ? acc[d.name] : [acc[d.name]]).concat(dep)
+        : dep
+      return acc
+    }, {})
+  }
+}
+
+module.exports = Outdated
diff --git a/node/node_modules/npm/lib/commands/owner.js b/node/node_modules/npm/lib/commands/owner.js
new file mode 100644
index 0000000000000000000000000000000000000000..f056dd004b9bc6b097ce8bac702317638c5f7e4f
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/owner.js
@@ -0,0 +1,241 @@
+const npa = require('npm-package-arg')
+const npmFetch = require('npm-registry-fetch')
+const pacote = require('pacote')
+const { log, output } = require('proc-log')
+const { otplease } = require('../utils/auth.js')
+const pkgJson = require('@npmcli/package-json')
+const BaseCommand = require('../base-cmd.js')
+const { redact } = require('@npmcli/redact')
+
+const readJson = async (path) => {
+  try {
+    const { content } = await pkgJson.normalize(path)
+    return content
+  } catch {
+    return {}
+  }
+}
+
+class Owner extends BaseCommand {
+  static description = 'Manage package owners'
+  static name = 'owner'
+  static params = [
+    'registry',
+    'otp',
+    'workspace',
+    'workspaces',
+  ]
+
+  static usage = [
+    'add <user> <package-spec>',
+    'rm <user> <package-spec>',
+    'ls <package-spec>',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts, npm) {
+    const argv = opts.conf.argv.remain
+    if (argv.length > 3) {
+      return []
+    }
+
+    if (argv[1] !== 'owner') {
+      argv.unshift('owner')
+    }
+
+    if (argv.length === 2) {
+      return ['add', 'rm', 'ls']
+    }
+
+    // reaches registry in order to autocomplete rm
+    if (argv[2] === 'rm') {
+      if (npm.global) {
+        return []
+      }
+      const { name } = await readJson(npm.prefix)
+      if (!name) {
+        return []
+      }
+
+      const spec = npa(name)
+      const data = await pacote.packument(spec, {
+        ...npm.flatOptions,
+        fullMetadata: true,
+        _isRoot: true,
+      })
+      if (data && data.maintainers && data.maintainers.length) {
+        return data.maintainers.map(m => m.name)
+      }
+    }
+    return []
+  }
+
+  async exec ([action, ...args]) {
+    if (action === 'ls' || action === 'list') {
+      await this.ls(args[0])
+    } else if (action === 'add') {
+      await this.changeOwners(args[0], args[1], 'add')
+    } else if (action === 'rm' || action === 'remove') {
+      await this.changeOwners(args[0], args[1], 'rm')
+    } else {
+      throw this.usageError()
+    }
+  }
+
+  async execWorkspaces ([action, ...args]) {
+    await this.setWorkspaces()
+    // ls pkg or owner add/rm package
+    if ((action === 'ls' && args.length > 0) || args.length > 1) {
+      const implicitWorkspaces = this.npm.config.get('workspace', 'default')
+      if (implicitWorkspaces.length === 0) {
+        log.warn(`Ignoring specified workspace(s)`)
+      }
+      return this.exec([action, ...args])
+    }
+
+    for (const [name] of this.workspaces) {
+      if (action === 'ls' || action === 'list') {
+        await this.ls(name)
+      } else if (action === 'add') {
+        await this.changeOwners(args[0], name, 'add')
+      } else if (action === 'rm' || action === 'remove') {
+        await this.changeOwners(args[0], name, 'rm')
+      } else {
+        throw this.usageError()
+      }
+    }
+  }
+
+  async ls (pkg) {
+    pkg = await this.getPkg(this.npm.prefix, pkg)
+    const spec = npa(pkg)
+
+    try {
+      const packumentOpts = {
+        ...this.npm.flatOptions,
+        fullMetadata:
+        true,
+        preferOnline: true,
+        _isRoot: true,
+      }
+      const { maintainers } = await pacote.packument(spec, packumentOpts)
+      if (!maintainers || !maintainers.length) {
+        output.standard('no admin found')
+      } else {
+        output.standard(maintainers.map(m => `${m.name} <${m.email}>`).join('\n'))
+      }
+    } catch (err) {
+      log.error('owner ls', "Couldn't get owner data", redact(pkg))
+      throw err
+    }
+  }
+
+  async getPkg (prefix, pkg) {
+    if (!pkg) {
+      if (this.npm.global) {
+        throw this.usageError()
+      }
+      const { name } = await readJson(prefix)
+      if (!name) {
+        throw this.usageError()
+      }
+
+      return name
+    }
+    return pkg
+  }
+
+  async changeOwners (user, pkg, addOrRm) {
+    if (!user) {
+      throw this.usageError()
+    }
+
+    pkg = await this.getPkg(this.npm.prefix, pkg)
+    log.verbose(`owner ${addOrRm}`, '%s to %s', user, pkg)
+
+    const spec = npa(pkg)
+    const uri = `/-/user/org.couchdb.user:${encodeURIComponent(user)}`
+    let u
+
+    try {
+      u = await npmFetch.json(uri, this.npm.flatOptions)
+    } catch (err) {
+      log.error('owner mutate', `Error getting user data for ${user}`)
+      throw err
+    }
+
+    // normalize user data
+    u = { name: u.name, email: u.email }
+
+    const data = await pacote.packument(spec, {
+      ...this.npm.flatOptions,
+      fullMetadata: true,
+      preferOnline: true,
+      _isRoot: true,
+    })
+
+    const owners = data.maintainers || []
+    let maintainers
+    if (addOrRm === 'add') {
+      const existing = owners.find(o => o.name === u.name)
+      if (existing) {
+        log.info(
+          'owner add',
+          `Already a package owner: ${existing.name} <${existing.email}>`
+        )
+        return
+      }
+      maintainers = [
+        ...owners,
+        u,
+      ]
+    } else {
+      maintainers = owners.filter(o => o.name !== u.name)
+
+      if (maintainers.length === owners.length) {
+        log.info('owner rm', 'Not a package owner: ' + u.name)
+        return false
+      }
+
+      if (!maintainers.length) {
+        throw Object.assign(
+          new Error(
+            'Cannot remove all owners of a package. Add someone else first.'
+          ),
+          { code: 'EOWNERRM' }
+        )
+      }
+    }
+
+    const dataPath = `/${spec.escapedName}/-rev/${encodeURIComponent(data._rev)}`
+    try {
+      const res = await otplease(this.npm, this.npm.flatOptions, opts => {
+        return npmFetch.json(dataPath, {
+          ...opts,
+          method: 'PUT',
+          body: {
+            _id: data._id,
+            _rev: data._rev,
+            maintainers,
+          },
+          spec,
+        })
+      })
+      if (addOrRm === 'add') {
+        output.standard(`+ ${user} (${spec.name})`)
+      } else {
+        output.standard(`- ${user} (${spec.name})`)
+      }
+      return res
+    } catch (err) {
+      throw Object.assign(
+        new Error('Failed to update package: ' + JSON.stringify(err.message)),
+        { code: 'EOWNERMUTATE' }
+      )
+    }
+  }
+}
+
+module.exports = Owner
diff --git a/node/node_modules/npm/lib/commands/pack.js b/node/node_modules/npm/lib/commands/pack.js
new file mode 100644
index 0000000000000000000000000000000000000000..90fcf92f544705c39c06059e8575fe949d7f2d05
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/pack.js
@@ -0,0 +1,89 @@
+const pacote = require('pacote')
+const libpack = require('libnpmpack')
+const npa = require('npm-package-arg')
+const { log, output } = require('proc-log')
+const { getContents, logTar } = require('../utils/tar.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Pack extends BaseCommand {
+  static description = 'Create a tarball from a package'
+  static name = 'pack'
+  static params = [
+    'dry-run',
+    'json',
+    'pack-destination',
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+    'ignore-scripts',
+  ]
+
+  static usage = ['<package-spec>']
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  async exec (args) {
+    if (args.length === 0) {
+      args = ['.']
+    }
+
+    const unicode = this.npm.config.get('unicode')
+    const json = this.npm.config.get('json')
+
+    const Arborist = require('@npmcli/arborist')
+    // Get the manifests and filenames first so we can bail early on manifest errors before making any tarballs
+    const manifests = []
+    for (const arg of args) {
+      const spec = npa(arg)
+      const manifest = await pacote.manifest(spec, {
+        ...this.npm.flatOptions,
+        Arborist,
+        preferOnline: true,
+        _isRoot: true,
+      })
+      if (!manifest._id) {
+        throw new Error('Invalid package, must have name and version')
+      }
+      manifests.push({ arg, manifest })
+    }
+
+    // Load tarball names up for printing afterward to isolate from the noise generated during packing
+    const tarballs = []
+    for (const { arg, manifest } of manifests) {
+      const tarballData = await libpack(arg, {
+        ...this.npm.flatOptions,
+        foregroundScripts: this.npm.config.isDefault('foreground-scripts')
+          ? true
+          : this.npm.config.get('foreground-scripts'),
+        preferOnline: true,
+        prefix: this.npm.localPrefix,
+        workspaces: this.workspacePaths,
+      })
+      tarballs.push(await getContents(manifest, tarballData))
+    }
+
+    for (const [index, tar] of Object.entries(tarballs)) {
+      // XXX(BREAKING_CHANGE): publish outputs a json object with package names as keys.
+      // Pack should do the same here instead of an array
+      logTar(tar, { unicode, json, key: index })
+      if (!json) {
+        output.standard(tar.filename.replace(/^@/, '').replace(/\//, '-'))
+      }
+    }
+  }
+
+  async execWorkspaces (args) {
+    // If they either ask for nothing, or explicitly include '.' in the args, we effectively translate that into each workspace requested
+    const useWorkspaces = args.length === 0 || args.includes('.')
+
+    if (!useWorkspaces) {
+      log.warn('Ignoring workspaces for specified package(s)')
+      return this.exec(args)
+    }
+
+    await this.setWorkspaces()
+    return this.exec([...this.workspacePaths, ...args.filter(a => a !== '.')])
+  }
+}
+
+module.exports = Pack
diff --git a/node/node_modules/npm/lib/commands/ping.js b/node/node_modules/npm/lib/commands/ping.js
new file mode 100644
index 0000000000000000000000000000000000000000..988fbcaec421555b160c4dfee71d4e73b4ba137a
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/ping.js
@@ -0,0 +1,30 @@
+const { redact } = require('@npmcli/redact')
+const { log, output } = require('proc-log')
+const pingUtil = require('../utils/ping.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Ping extends BaseCommand {
+  static description = 'Ping npm registry'
+  static params = ['registry']
+  static name = 'ping'
+
+  async exec () {
+    const cleanRegistry = redact(this.npm.config.get('registry'))
+    log.notice('PING', cleanRegistry)
+    const start = Date.now()
+    const details = await pingUtil({ ...this.npm.flatOptions })
+    const time = Date.now() - start
+    log.notice('PONG', `${time}ms`)
+    if (this.npm.config.get('json')) {
+      output.buffer({
+        registry: cleanRegistry,
+        time,
+        details,
+      })
+    } else if (Object.keys(details).length) {
+      log.notice('PONG', JSON.stringify(details, null, 2))
+    }
+  }
+}
+
+module.exports = Ping
diff --git a/node/node_modules/npm/lib/commands/pkg.js b/node/node_modules/npm/lib/commands/pkg.js
new file mode 100644
index 0000000000000000000000000000000000000000..486af5bb5d242836a8181fff40d2648f0553a820
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/pkg.js
@@ -0,0 +1,127 @@
+const { output } = require('proc-log')
+const PackageJson = require('@npmcli/package-json')
+const BaseCommand = require('../base-cmd.js')
+const Queryable = require('../utils/queryable.js')
+
+class Pkg extends BaseCommand {
+  static description = 'Manages your package.json'
+  static name = 'pkg'
+  static usage = [
+    'set <key>=<value> [<key>=<value> ...]',
+    'get [<key> [<key> ...]]',
+    'delete <key> [<key> ...]',
+    'set [<array>[<index>].<key>=<value> ...]',
+    'set [<array>[].<key>=<value> ...]',
+    'fix',
+  ]
+
+  static params = [
+    'force',
+    'json',
+    'workspace',
+    'workspaces',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  async exec (args, { path = this.npm.localPrefix, workspace } = {}) {
+    if (this.npm.global) {
+      throw Object.assign(
+        new Error(`There's no package.json file to manage on global mode`),
+        { code: 'EPKGGLOBAL' }
+      )
+    }
+
+    const [cmd, ..._args] = args
+    switch (cmd) {
+      case 'get':
+        return this.get(_args, { path, workspace })
+      case 'set':
+        return this.set(_args, { path, workspace }).then(p => p.save())
+      case 'delete':
+        return this.delete(_args, { path, workspace }).then(p => p.save())
+      case 'fix':
+        return PackageJson.fix(path).then(p => p.save())
+      default:
+        throw this.usageError()
+    }
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+    for (const [workspace, path] of this.workspaces.entries()) {
+      await this.exec(args, { path, workspace })
+    }
+  }
+
+  async get (args, { path, workspace }) {
+    this.npm.config.set('json', true)
+    const pkgJson = await PackageJson.load(path)
+
+    let result = pkgJson.content
+
+    if (args.length) {
+      result = new Queryable(result).query(args)
+      // in case there's only a single argument and a single result from the query just prints that one element to stdout.
+      // TODO(BREAKING_CHANGE): much like other places where we unwrap single item arrays this should go away.
+      // it makes the behavior unknown for users who don't already know the shape of the data.
+      if (Object.keys(result).length === 1 && args.length === 1) {
+        result = result[args]
+      }
+    }
+
+    // The display layer is responsible for calling JSON.stringify on the result
+    // TODO: https://github.com/npm/cli/issues/5508 a raw mode has been requested similar to jq -r.
+    // If that was added then this method should no longer set `json:true` all the time
+    output.buffer(workspace ? { [workspace]: result } : result)
+  }
+
+  async set (args, { path }) {
+    const setError = () =>
+      this.usageError('npm pkg set expects a key=value pair of args.')
+
+    if (!args.length) {
+      throw setError()
+    }
+
+    const force = this.npm.config.get('force')
+    const json = this.npm.config.get('json')
+    const pkgJson = await PackageJson.load(path)
+    const q = new Queryable(pkgJson.content)
+    for (const arg of args) {
+      const [key, ...rest] = arg.split('=')
+      const value = rest.join('=')
+      if (!key || !value) {
+        throw setError()
+      }
+
+      q.set(key, json ? JSON.parse(value) : value, { force })
+    }
+
+    return pkgJson.update(q.toJSON())
+  }
+
+  async delete (args, { path }) {
+    const setError = () =>
+      this.usageError('npm pkg delete expects key args.')
+
+    if (!args.length) {
+      throw setError()
+    }
+
+    const pkgJson = await PackageJson.load(path)
+    const q = new Queryable(pkgJson.content)
+    for (const key of args) {
+      if (!key) {
+        throw setError()
+      }
+
+      q.delete(key)
+    }
+
+    return pkgJson.update(q.toJSON())
+  }
+}
+
+module.exports = Pkg
diff --git a/node/node_modules/npm/lib/commands/prefix.js b/node/node_modules/npm/lib/commands/prefix.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d1d89c5ca3662fbdc66e8cd9df6b1b94d6846c2
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/prefix.js
@@ -0,0 +1,14 @@
+const { output } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+
+class Prefix extends BaseCommand {
+  static description = 'Display prefix'
+  static name = 'prefix'
+  static params = ['global']
+
+  async exec () {
+    return output.standard(this.npm.prefix)
+  }
+}
+
+module.exports = Prefix
diff --git a/node/node_modules/npm/lib/commands/profile.js b/node/node_modules/npm/lib/commands/profile.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea5de9508092aeef932294c32a9e10445d211cbe
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/profile.js
@@ -0,0 +1,366 @@
+const { inspect } = require('node:util')
+const { URL } = require('node:url')
+const { log, output } = require('proc-log')
+const { get, set, createToken } = require('npm-profile')
+const qrcodeTerminal = require('qrcode-terminal')
+const { otplease } = require('../utils/auth.js')
+const readUserInfo = require('../utils/read-user-info.js')
+const BaseCommand = require('../base-cmd.js')
+
+const qrcode = url =>
+  new Promise((resolve) => qrcodeTerminal.generate(url, resolve))
+
+const knownProfileKeys = [
+  'name',
+  'email',
+  'two-factor auth',
+  'fullname',
+  'homepage',
+  'freenode',
+  'twitter',
+  'github',
+  'created',
+  'updated',
+]
+
+const writableProfileKeys = [
+  'email',
+  'password',
+  'fullname',
+  'homepage',
+  'freenode',
+  'twitter',
+  'github',
+]
+
+class Profile extends BaseCommand {
+  static description = 'Change settings on your registry profile'
+  static name = 'profile'
+  static usage = [
+    'enable-2fa [auth-only|auth-and-writes]',
+    'disable-2fa',
+    'get [<key>]',
+    'set <key> <value>',
+  ]
+
+  static params = [
+    'registry',
+    'json',
+    'parseable',
+    'otp',
+  ]
+
+  static async completion (opts) {
+    var argv = opts.conf.argv.remain
+
+    if (!argv[2]) {
+      return ['enable-2fa', 'disable-2fa', 'get', 'set']
+    }
+
+    switch (argv[2]) {
+      case 'enable-2fa':
+      case 'enable-tfa':
+        return ['auth-and-writes', 'auth-only']
+
+      case 'disable-2fa':
+      case 'disable-tfa':
+      case 'get':
+      case 'set':
+        return []
+      default:
+        throw new Error(argv[2] + ' not recognized')
+    }
+  }
+
+  async exec (args) {
+    if (args.length === 0) {
+      throw this.usageError()
+    }
+
+    const [subcmd, ...opts] = args
+
+    switch (subcmd) {
+      case 'enable-2fa':
+      case 'enable-tfa':
+      case 'enable2fa':
+      case 'enabletfa':
+        return this.enable2fa(opts)
+      case 'disable-2fa':
+      case 'disable-tfa':
+      case 'disable2fa':
+      case 'disabletfa':
+        return this.disable2fa()
+      case 'get':
+        return this.get(opts)
+      case 'set':
+        return this.set(opts)
+      default:
+        throw new Error('Unknown profile command: ' + subcmd)
+    }
+  }
+
+  async get (args) {
+    const tfa = 'two-factor auth'
+    const info = await get({ ...this.npm.flatOptions })
+
+    if (!info.cidr_whitelist) {
+      delete info.cidr_whitelist
+    }
+
+    if (this.npm.config.get('json')) {
+      output.buffer(info)
+      return
+    }
+
+    // clean up and format key/values for output
+    const cleaned = {}
+    for (const key of knownProfileKeys) {
+      cleaned[key] = info[key] || ''
+    }
+
+    const unknownProfileKeys = Object.keys(info).filter((k) => !(k in cleaned))
+    for (const key of unknownProfileKeys) {
+      cleaned[key] = info[key] || ''
+    }
+
+    delete cleaned.tfa
+    delete cleaned.email_verified
+    cleaned.email += info.email_verified ? ' (verified)' : '(unverified)'
+
+    if (info.tfa && !info.tfa.pending) {
+      cleaned[tfa] = info.tfa.mode
+    } else {
+      cleaned[tfa] = 'disabled'
+    }
+
+    if (args.length) {
+      const values = args // comma or space separated
+        .join(',')
+        .split(/,/)
+        .filter((arg) => arg.trim() !== '')
+        .map((arg) => cleaned[arg])
+        .join('\t')
+      output.standard(values)
+    } else {
+      if (this.npm.config.get('parseable')) {
+        for (const key of Object.keys(info)) {
+          if (key === 'tfa') {
+            output.standard(`${key}\t${cleaned[tfa]}`)
+          } else {
+            output.standard(`${key}\t${info[key]}`)
+          }
+        }
+      } else {
+        for (const [key, value] of Object.entries(cleaned)) {
+          output.standard(`${key}: ${value}`)
+        }
+      }
+    }
+  }
+
+  async set (args) {
+    const conf = { ...this.npm.flatOptions }
+    const prop = (args[0] || '').toLowerCase().trim()
+
+    let value = args.length > 1 ? args.slice(1).join(' ') : null
+
+    const readPasswords = async () => {
+      const newpassword = await readUserInfo.password('New password: ')
+      const confirmedpassword = await readUserInfo.password('       Again:     ')
+
+      if (newpassword !== confirmedpassword) {
+        log.warn('profile', 'Passwords do not match, please try again.')
+        return readPasswords()
+      }
+
+      return newpassword
+    }
+
+    if (prop !== 'password' && value === null) {
+      throw new Error('npm profile set <prop> <value>')
+    }
+
+    if (prop === 'password' && value !== null) {
+      throw new Error(
+        'npm profile set password\n' +
+        'Do not include your current or new passwords on the command line.')
+    }
+
+    if (writableProfileKeys.indexOf(prop) === -1) {
+      throw new Error(`"${prop}" is not a property we can set. ` +
+        `Valid properties are: ` + writableProfileKeys.join(', '))
+    }
+
+    if (prop === 'password') {
+      const current = await readUserInfo.password('Current password: ')
+      const newpassword = await readPasswords()
+
+      value = { old: current, new: newpassword }
+    }
+
+    // FIXME: Work around to not clear everything other than what we're setting
+    const user = await get(conf)
+    const newUser = {}
+
+    for (const key of writableProfileKeys) {
+      newUser[key] = user[key]
+    }
+
+    newUser[prop] = value
+
+    const result = await otplease(this.npm, conf, c => set(newUser, c))
+
+    if (this.npm.config.get('json')) {
+      output.buffer({ [prop]: result[prop] })
+    } else if (this.npm.config.get('parseable')) {
+      output.standard(prop + '\t' + result[prop])
+    } else if (result[prop] != null) {
+      output.standard('Set', prop, 'to', result[prop])
+    } else {
+      output.standard('Set', prop)
+    }
+  }
+
+  async enable2fa (args) {
+    const conf = { ...this.npm.flatOptions }
+
+    if (args.length > 1) {
+      throw new Error('npm profile enable-2fa [auth-and-writes|auth-only]')
+    }
+
+    const mode = args[0] || 'auth-and-writes'
+    if (mode !== 'auth-only' && mode !== 'auth-and-writes') {
+      throw new Error(
+        `Invalid two-factor authentication mode "${mode}".\n` +
+        'Valid modes are:\n' +
+        '  auth-only - Require two-factor authentication only when logging in\n' +
+        '  auth-and-writes - Require two-factor authentication when logging in ' +
+        'AND when publishing'
+      )
+    }
+
+    if (this.npm.config.get('json') || this.npm.config.get('parseable')) {
+      throw new Error(
+        'Enabling two-factor authentication is an interactive operation and ' +
+        (this.npm.config.get('json') ? 'JSON' : 'parseable') + ' output mode is not available'
+      )
+    }
+
+    const userInfo = await get(conf)
+
+    if (!userInfo?.tfa?.pending && userInfo?.tfa?.mode === mode) {
+      output.standard('Two factor authentication is already enabled and set to ' + mode)
+      return
+    }
+
+    const info = {
+      tfa: {
+        mode,
+      },
+    }
+
+    // if they're using legacy auth currently then we have to update them to a bearer token before continuing.
+    const creds = this.npm.config.getCredentialsByURI(this.npm.config.get('registry'))
+    const auth = {}
+
+    if (creds.token) {
+      auth.token = creds.token
+    } else if (creds.username) {
+      auth.basic = { username: creds.username, password: creds.password }
+    } else if (creds.auth) {
+      const basic = Buffer.from(creds.auth, 'base64').toString().split(':', 2)
+      auth.basic = { username: basic[0], password: basic[1] }
+    }
+
+    if (!auth.basic && !auth.token) {
+      throw new Error(
+        'You need to be logged in to registry ' +
+        `${this.npm.config.get('registry')} in order to enable 2fa`
+      )
+    }
+
+    if (auth.basic) {
+      log.info('profile', 'Updating authentication to bearer token')
+      const result = await createToken(
+        auth.basic.password, false, [], { ...this.npm.flatOptions }
+      )
+
+      if (!result.token) {
+        throw new Error(`Your registry ${this.npm.config.get('registry')} does not seem to support bearer tokens. Bearer tokens are required for two-factor authentication.`)
+      }
+
+      this.npm.config.setCredentialsByURI(
+        this.npm.config.get('registry'),
+        { token: result.token }
+      )
+      await this.npm.config.save('user')
+    }
+
+    log.notice('profile', 'Enabling two factor authentication for ' + mode)
+    const password = await readUserInfo.password()
+    info.tfa.password = password
+
+    if (userInfo && userInfo.tfa && userInfo.tfa.pending) {
+      log.info('profile', 'Resetting two-factor authentication')
+      await set({ tfa: { password, mode: 'disable' } }, conf)
+    }
+
+    log.info('profile', 'Setting two-factor authentication to ' + mode)
+    const challenge = await otplease(this.npm, conf, o => set(info, o))
+
+    if (challenge.tfa && challenge.tfa.mode) {
+      output.standard('Two factor authentication mode changed to: ' + mode)
+      return
+    }
+
+    const badResponse = typeof challenge.tfa !== 'string'
+      || !/^otpauth:[/][/]/.test(challenge.tfa)
+    if (badResponse) {
+      throw new Error(`Unknown error enabling two-factor authentication. Expected otpauth URL, got: ${inspect(challenge.tfa)}`)
+    }
+
+    const otpauth = new URL(challenge.tfa)
+    const secret = otpauth.searchParams.get('secret')
+    const code = await qrcode(challenge.tfa)
+
+    output.standard('Scan into your authenticator app:\n' + code + '\n Or enter code:', secret)
+
+    const interactiveOTP = await readUserInfo.otp('And an OTP code from your authenticator: ')
+
+    log.info('profile', 'Finalizing two-factor authentication')
+
+    const result = await set({ tfa: [interactiveOTP] }, conf)
+
+    output.standard('2FA successfully enabled. Below are your recovery codes, please print these out.')
+    output.standard('You will need these to recover access to your account if you lose your authentication device.')
+
+    for (const tfaCode of result.tfa) {
+      output.standard('\t' + tfaCode)
+    }
+  }
+
+  async disable2fa () {
+    const opts = { ...this.npm.flatOptions }
+    const info = await get(opts)
+
+    if (!info.tfa || info.tfa.pending) {
+      output.standard('Two factor authentication not enabled.')
+      return
+    }
+
+    const password = await readUserInfo.password()
+
+    log.info('profile', 'disabling tfa')
+    await otplease(this.npm, opts, o => set({ tfa: { password: password, mode: 'disable' } }, o))
+
+    if (this.npm.config.get('json')) {
+      output.buffer({ tfa: false })
+    } else if (this.npm.config.get('parseable')) {
+      output.standard('tfa\tfalse')
+    } else {
+      output.standard('Two factor authentication disabled.')
+    }
+  }
+}
+
+module.exports = Profile
diff --git a/node/node_modules/npm/lib/commands/prune.js b/node/node_modules/npm/lib/commands/prune.js
new file mode 100644
index 0000000000000000000000000000000000000000..243f9d229559fac8de5b5c8909ee7565c72a3605
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/prune.js
@@ -0,0 +1,33 @@
+const reifyFinish = require('../utils/reify-finish.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Prune extends ArboristWorkspaceCmd {
+  static description = 'Remove extraneous packages'
+  static name = 'prune'
+  static params = [
+    'omit',
+    'include',
+    'dry-run',
+    'json',
+    'foreground-scripts',
+    'ignore-scripts',
+    ...super.params,
+  ]
+
+  static usage = ['[[<@scope>/]<pkg>...]']
+
+  async exec () {
+    const where = this.npm.prefix
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      path: where,
+      workspaces: this.workspaceNames,
+    }
+    const arb = new Arborist(opts)
+    await arb.prune(opts)
+    await reifyFinish(this.npm, arb)
+  }
+}
+
+module.exports = Prune
diff --git a/node/node_modules/npm/lib/commands/publish.js b/node/node_modules/npm/lib/commands/publish.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9d7c8c213ee1f66c0ad5b2a63358a81f2ec0b14
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/publish.js
@@ -0,0 +1,277 @@
+const { log, output } = require('proc-log')
+const semver = require('semver')
+const pack = require('libnpmpack')
+const libpub = require('libnpmpublish').publish
+const runScript = require('@npmcli/run-script')
+const pacote = require('pacote')
+const npa = require('npm-package-arg')
+const npmFetch = require('npm-registry-fetch')
+const { redactLog: replaceInfo } = require('@npmcli/redact')
+const { otplease } = require('../utils/auth.js')
+const { getContents, logTar } = require('../utils/tar.js')
+// for historical reasons, publishConfig in package.json can contain ANY config keys that npm supports in .npmrc files and elsewhere.
+// We *may* want to revisit this at some point, and have a minimal set that's a SemVer-major change that ought to get a RFC written on it.
+const { flatten } = require('@npmcli/config/lib/definitions')
+const pkgJson = require('@npmcli/package-json')
+const BaseCommand = require('../base-cmd.js')
+const { oidc } = require('../../lib/utils/oidc.js')
+
+class Publish extends BaseCommand {
+  static description = 'Publish a package'
+  static name = 'publish'
+  static params = [
+    'tag',
+    'access',
+    'dry-run',
+    'otp',
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+    'provenance',
+  ]
+
+  static usage = ['<package-spec>']
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  async exec (args) {
+    if (args.length === 0) {
+      args = ['.']
+    }
+    if (args.length !== 1) {
+      throw this.usageError()
+    }
+
+    await this.#publish(args)
+  }
+
+  async execWorkspaces (args) {
+    const useWorkspaces = args.length === 0 || args.includes('.')
+    if (!useWorkspaces) {
+      log.warn('Ignoring workspaces for specified package(s)')
+      return this.exec(args)
+    }
+    await this.setWorkspaces()
+
+    for (const [name, workspace] of this.workspaces.entries()) {
+      try {
+        await this.#publish([workspace], { workspace: name })
+      } catch (err) {
+        if (err.code !== 'EPRIVATE') {
+          throw err
+        }
+        log.warn('publish', `Skipping workspace ${this.npm.chalk.cyan(name)}, marked as ${this.npm.chalk.bold('private')}`)
+      }
+    }
+  }
+
+  async #publish (args, { workspace } = {}) {
+    log.verbose('publish', replaceInfo(args))
+
+    const unicode = this.npm.config.get('unicode')
+    const dryRun = this.npm.config.get('dry-run')
+    const json = this.npm.config.get('json')
+    const defaultTag = this.npm.config.get('tag')
+    const ignoreScripts = this.npm.config.get('ignore-scripts')
+    const { silent } = this.npm
+
+    if (semver.validRange(defaultTag)) {
+      throw new Error('Tag name must not be a valid SemVer range: ' + defaultTag.trim())
+    }
+
+    const opts = { ...this.npm.flatOptions, progress: false }
+
+    // you can publish name@version, ./foo.tgz, etc even though the default is the 'file:.' cwd.
+    const spec = npa(args[0])
+    let manifest = await this.#getManifest(spec, opts)
+
+    // only run scripts for directory type publishes
+    if (spec.type === 'directory' && !ignoreScripts) {
+      await runScript({
+        event: 'prepublishOnly',
+        path: spec.fetchSpec,
+        stdio: 'inherit',
+        pkg: manifest,
+      })
+    }
+
+    // we pass dryRun: true to libnpmpack so it doesn't write the file to disk
+    const tarballData = await pack(spec, {
+      ...opts,
+      foregroundScripts: this.npm.config.isDefault('foreground-scripts')
+        ? true
+        : this.npm.config.get('foreground-scripts'),
+      dryRun: true,
+      prefix: this.npm.localPrefix,
+      workspaces: this.workspacePaths,
+    })
+    const pkgContents = await getContents(manifest, tarballData)
+    const logPkg = () => logTar(pkgContents, { unicode, json, key: workspace })
+
+    // The purpose of re-reading the manifest is in case it changed, so that we send the latest and greatest thing to the registry note that publishConfig might have changed as well!
+    manifest = await this.#getManifest(spec, opts, true)
+    const force = this.npm.config.get('force')
+    const isDefaultTag = this.npm.config.isDefault('tag') && !manifest.publishConfig?.tag
+
+    if (!force) {
+      const isPreRelease = Boolean(semver.parse(manifest.version).prerelease.length)
+      if (isPreRelease && isDefaultTag) {
+        throw new Error('You must specify a tag using --tag when publishing a prerelease version.')
+      }
+    }
+
+    // If we are not in JSON mode then we show the user the contents of the tarball before it is published so they can see it while their otp is pending
+    if (!json) {
+      logPkg()
+    }
+
+    const resolved = npa.resolve(manifest.name, manifest.version)
+
+    // make sure tag is valid, this will throw if invalid
+    npa(`${manifest.name}@${defaultTag}`)
+
+    const registry = npmFetch.pickRegistry(resolved, opts)
+
+    await oidc({ packageName: manifest.name, registry, opts, config: this.npm.config })
+
+    const creds = this.npm.config.getCredentialsByURI(registry)
+    const noCreds = !(creds.token || creds.username || creds.certfile && creds.keyfile)
+    const outputRegistry = replaceInfo(registry)
+
+    // if a workspace package is marked private then we skip it
+    if (workspace && manifest.private) {
+      throw Object.assign(
+        new Error(`This package has been marked as private
+  Remove the 'private' field from the package.json to publish it.`),
+        { code: 'EPRIVATE' }
+      )
+    }
+
+    if (noCreds) {
+      const msg = `This command requires you to be logged in to ${outputRegistry}`
+      if (dryRun) {
+        log.warn('', `${msg} (dry-run)`)
+      } else {
+        throw Object.assign(new Error(msg), { code: 'ENEEDAUTH' })
+      }
+    }
+
+    if (!force) {
+      const { highestVersion, versions } = await this.#registryVersions(resolved, registry)
+      /* eslint-disable-next-line max-len */
+      const highestVersionIsGreater = !!highestVersion && semver.gte(highestVersion, manifest.version)
+
+      if (versions.includes(manifest.version)) {
+        throw new Error(`You cannot publish over the previously published versions: ${manifest.version}.`)
+      }
+
+      if (highestVersionIsGreater && isDefaultTag) {
+        throw new Error(`Cannot implicitly apply the "latest" tag because previously published version ${highestVersion} is higher than the new version ${manifest.version}. You must specify a tag using --tag.`)
+      }
+    }
+
+    const access = opts.access === null ? 'default' : opts.access
+    let msg = `Publishing to ${outputRegistry} with tag ${defaultTag} and ${access} access`
+    if (dryRun) {
+      msg = `${msg} (dry-run)`
+    }
+
+    log.notice('', msg)
+
+    if (!dryRun) {
+      await otplease(this.npm, opts, o => libpub(manifest, tarballData, o))
+    }
+
+    // In json mode we don't log until the publish has completed as this will add it to the output only if completes successfully
+    if (json) {
+      logPkg()
+    }
+
+    if (spec.type === 'directory' && !ignoreScripts) {
+      await runScript({
+        event: 'publish',
+        path: spec.fetchSpec,
+        stdio: 'inherit',
+        pkg: manifest,
+      })
+
+      await runScript({
+        event: 'postpublish',
+        path: spec.fetchSpec,
+        stdio: 'inherit',
+        pkg: manifest,
+      })
+    }
+
+    if (!json && !silent) {
+      output.standard(`+ ${pkgContents.id}`)
+    }
+  }
+
+  async #registryVersions (spec, registry) {
+    try {
+      const packument = await pacote.packument(spec, {
+        ...this.npm.flatOptions,
+        preferOnline: true,
+        registry,
+        _isRoot: true,
+      })
+      if (typeof packument?.versions === 'undefined') {
+        return { versions: [], highestVersion: null }
+      }
+      const ordered = Object.keys(packument?.versions)
+        .flatMap(v => {
+          const s = new semver.SemVer(v)
+          if ((s.prerelease.length > 0) || packument.versions[v].deprecated) {
+            return []
+          }
+          return s
+        })
+        .sort((a, b) => b.compare(a))
+      const highestVersion = ordered.length >= 1 ? ordered[0].version : null
+      const versions = ordered.map(v => v.version)
+      return { versions, highestVersion }
+    } catch (e) {
+      return { versions: [], highestVersion: null }
+    }
+  }
+
+  // if it's a directory, read it from the file system
+  // otherwise, get the full metadata from whatever it is
+  // XXX can't pacote read the manifest from a directory?
+  async #getManifest (spec, opts, logWarnings = false) {
+    let manifest
+    if (spec.type === 'directory') {
+      const changes = []
+      const pkg = await pkgJson.fix(spec.fetchSpec, { changes })
+      if (changes.length && logWarnings) {
+        log.warn('publish', 'npm auto-corrected some errors in your package.json when publishing.  Please run "npm pkg fix" to address these errors.')
+        log.warn('publish', `errors corrected:\n${changes.join('\n')}`)
+      }
+      // Prepare is the special function for publishing, different than normalize
+      const { content } = await pkg.prepare()
+      manifest = content
+    } else {
+      manifest = await pacote.manifest(spec, {
+        ...opts,
+        fullmetadata: true,
+        fullReadJson: true,
+      })
+    }
+    if (manifest.publishConfig) {
+      const cliFlags = this.npm.config.data.get('cli').raw
+      // Filter out properties set in CLI flags to prioritize them over corresponding `publishConfig` settings
+      const filteredPublishConfig = Object.fromEntries(
+        Object.entries(manifest.publishConfig).filter(([key]) => !(key in cliFlags)))
+      if (logWarnings) {
+        for (const key in filteredPublishConfig) {
+          this.npm.config.checkUnknown('publishConfig', key)
+        }
+      }
+      flatten(filteredPublishConfig, opts)
+    }
+    return manifest
+  }
+}
+
+module.exports = Publish
diff --git a/node/node_modules/npm/lib/commands/query.js b/node/node_modules/npm/lib/commands/query.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9cd2129e96eba41a4aff43d184e19615a08621e
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/query.js
@@ -0,0 +1,139 @@
+const { resolve } = require('node:path')
+const BaseCommand = require('../base-cmd.js')
+const { log, output } = require('proc-log')
+
+class QuerySelectorItem {
+  constructor (node) {
+    // all enumerable properties from the target
+    Object.assign(this, node.target.package)
+
+    // append extra info
+    this.pkgid = node.target.pkgid
+    this.location = node.target.location
+    this.path = node.target.path
+    this.realpath = node.target.realpath
+    this.resolved = node.target.resolved
+    this.from = []
+    this.to = []
+    this.dev = node.target.dev
+    this.inBundle = node.target.inBundle
+    this.deduped = this.from.length > 1
+    this.overridden = node.overridden
+    this.queryContext = node.queryContext
+    for (const edge of node.target.edgesIn) {
+      this.from.push(edge.from.location)
+    }
+    for (const [, edge] of node.target.edgesOut) {
+      if (edge.to) {
+        this.to.push(edge.to.location)
+      }
+    }
+  }
+}
+
+class Query extends BaseCommand {
+  #response = [] // response is the query response
+  #seen = new Set() // paths we've seen so we can keep response deduped
+
+  static description = 'Retrieve a filtered list of packages'
+  static name = 'query'
+  static usage = ['<selector>']
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  static params = [
+    'global',
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+    'package-lock-only',
+    'expect-results',
+  ]
+
+  constructor (...args) {
+    super(...args)
+    this.npm.config.set('json', true)
+  }
+
+  async exec (args) {
+    const packageLockOnly = this.npm.config.get('package-lock-only')
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({
+      ...this.npm.flatOptions,
+      // one dir up from wherever node_modules lives
+      path: resolve(this.npm.dir, '..'),
+      forceActual: !packageLockOnly,
+    })
+    let tree
+    if (packageLockOnly) {
+      try {
+        tree = await arb.loadVirtual()
+      } catch (err) {
+        log.verbose('loadVirtual', err.stack)
+        throw this.usageError(
+          'A package lock or shrinkwrap file is required in package-lock-only mode'
+        )
+      }
+    } else {
+      tree = await arb.loadActual()
+    }
+    await this.#queryTree(tree, args[0])
+    this.#output()
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+    const packageLockOnly = this.npm.config.get('package-lock-only')
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({
+      ...this.npm.flatOptions,
+      path: this.npm.prefix,
+      forceActual: !packageLockOnly,
+    })
+    let tree
+    if (packageLockOnly) {
+      try {
+        tree = await arb.loadVirtual()
+      } catch (err) {
+        log.verbose('loadVirtual', err.stack)
+        throw this.usageError(
+          'A package lock or shrinkwrap file is required in package-lock-only mode'
+        )
+      }
+    } else {
+      tree = await arb.loadActual()
+    }
+    for (const path of this.workspacePaths) {
+      const wsTree = path === tree.root.path
+        ? tree // --includes-workspace-root
+        : await tree.querySelectorAll(`.workspace:path(${path})`).then(r => r[0]?.target)
+      if (wsTree) {
+        await this.#queryTree(wsTree, args[0])
+      }
+    }
+    this.#output()
+  }
+
+  #output () {
+    this.checkExpected(this.#response.length)
+    output.buffer(this.#response)
+  }
+
+  // builds a normalized inventory
+  async #queryTree (tree, arg) {
+    const items = await tree.querySelectorAll(arg, this.npm.flatOptions)
+    for (const node of items) {
+      const { location } = node.target
+      if (!location || !this.#seen.has(location)) {
+        const item = new QuerySelectorItem(node)
+        this.#response.push(item)
+        if (location) {
+          this.#seen.add(item.location)
+        }
+      }
+    }
+  }
+}
+
+module.exports = Query
diff --git a/node/node_modules/npm/lib/commands/rebuild.js b/node/node_modules/npm/lib/commands/rebuild.js
new file mode 100644
index 0000000000000000000000000000000000000000..801c5e19db6a6db9a34bc16c685e2354433fdc29
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/rebuild.js
@@ -0,0 +1,82 @@
+const { resolve } = require('node:path')
+const { output } = require('proc-log')
+const npa = require('npm-package-arg')
+const semver = require('semver')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Rebuild extends ArboristWorkspaceCmd {
+  static description = 'Rebuild a package'
+  static name = 'rebuild'
+  static params = [
+    'global',
+    'bin-links',
+    'foreground-scripts',
+    'ignore-scripts',
+    ...super.params,
+  ]
+
+  static usage = ['[<package-spec>] ...]']
+
+  static async completion (opts, npm) {
+    const completion = require('../utils/installed-deep.js')
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    const globalTop = resolve(this.npm.globalDir, '..')
+    const where = this.npm.global ? globalTop : this.npm.prefix
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist({
+      ...this.npm.flatOptions,
+      path: where,
+      // TODO when extending ReifyCmd
+      // workspaces: this.workspaceNames,
+    })
+
+    if (args.length) {
+      // get the set of nodes matching the name that we want rebuilt
+      const tree = await arb.loadActual()
+      const specs = args.map(arg => {
+        const spec = npa(arg)
+        if (spec.rawSpec === '*') {
+          return spec
+        }
+
+        if (spec.type !== 'range' && spec.type !== 'version' && spec.type !== 'directory') {
+          throw new Error('`npm rebuild` only supports SemVer version/range specifiers')
+        }
+
+        return spec
+      })
+      const nodes = tree.inventory.filter(node => this.isNode(specs, node))
+
+      await arb.rebuild({ nodes })
+    } else {
+      await arb.rebuild()
+    }
+
+    output.standard('rebuilt dependencies successfully')
+  }
+
+  isNode (specs, node) {
+    return specs.some(spec => {
+      if (spec.type === 'directory') {
+        return node.path === spec.fetchSpec
+      }
+
+      if (spec.name !== node.name) {
+        return false
+      }
+
+      if (spec.rawSpec === '' || spec.rawSpec === '*') {
+        return true
+      }
+
+      const { version } = node.package
+      // TODO: add tests for a package with missing version
+      return semver.satisfies(version, spec.fetchSpec)
+    })
+  }
+}
+
+module.exports = Rebuild
diff --git a/node/node_modules/npm/lib/commands/repo.js b/node/node_modules/npm/lib/commands/repo.js
new file mode 100644
index 0000000000000000000000000000000000000000..572e51710e843e03b0ac8e5eda308fa4c415403f
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/repo.js
@@ -0,0 +1,55 @@
+const { URL } = require('node:url')
+const PackageUrlCmd = require('../package-url-cmd.js')
+
+class Repo extends PackageUrlCmd {
+  static description = 'Open package repository page in the browser'
+  static name = 'repo'
+
+  getUrl (spec, mani) {
+    const r = mani.repository
+    const rurl = !r ? null
+      : typeof r === 'string' ? r
+      : typeof r === 'object' && typeof r.url === 'string' ? r.url
+      : null
+
+    if (!rurl) {
+      throw Object.assign(new Error('no repository'), {
+        pkgid: spec,
+      })
+    }
+
+    const info = this.hostedFromMani(mani)
+    const url = info ?
+      info.browse(mani.repository.directory) : unknownHostedUrl(rurl)
+
+    if (!url) {
+      throw Object.assign(new Error('no repository: could not get url'), {
+        pkgid: spec,
+      })
+    }
+    return url
+  }
+}
+
+module.exports = Repo
+
+const unknownHostedUrl = url => {
+  try {
+    const {
+      protocol,
+      hostname,
+      pathname,
+    } = new URL(url)
+
+    /* istanbul ignore next - URL ctor should prevent this */
+    if (!protocol || !hostname) {
+      return null
+    }
+
+    const proto = /(git\+)http:$/.test(protocol) ? 'http:' : 'https:'
+    const path = pathname.replace(/\.git$/, '')
+    return `${proto}//${hostname}${path}`
+  } catch {
+    return null
+  }
+}
diff --git a/node/node_modules/npm/lib/commands/restart.js b/node/node_modules/npm/lib/commands/restart.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d20973919643f7dad5904e34c3d6c6f14e6ce56
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/restart.js
@@ -0,0 +1,13 @@
+const LifecycleCmd = require('../lifecycle-cmd.js')
+
+// This ends up calling run(['restart', ...args])
+class Restart extends LifecycleCmd {
+  static description = 'Restart a package'
+  static name = 'restart'
+  static params = [
+    'ignore-scripts',
+    'script-shell',
+  ]
+}
+
+module.exports = Restart
diff --git a/node/node_modules/npm/lib/commands/root.js b/node/node_modules/npm/lib/commands/root.js
new file mode 100644
index 0000000000000000000000000000000000000000..cabddb38881e01ba2e76638dff0237901949e6b8
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/root.js
@@ -0,0 +1,14 @@
+const { output } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+
+class Root extends BaseCommand {
+  static description = 'Display npm root'
+  static name = 'root'
+  static params = ['global']
+
+  async exec () {
+    output.standard(this.npm.dir)
+  }
+}
+
+module.exports = Root
diff --git a/node/node_modules/npm/lib/commands/run.js b/node/node_modules/npm/lib/commands/run.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc018c700e2ba1f497fc539ae4092d806552dc56
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/run.js
@@ -0,0 +1,222 @@
+const { output } = require('proc-log')
+const pkgJson = require('@npmcli/package-json')
+const BaseCommand = require('../base-cmd.js')
+const { getError } = require('../utils/error-message.js')
+const { outputError } = require('../utils/output-error.js')
+
+class RunScript extends BaseCommand {
+  static description = 'Run arbitrary package scripts'
+  static params = [
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+    'if-present',
+    'ignore-scripts',
+    'foreground-scripts',
+    'script-shell',
+  ]
+
+  static name = 'run'
+  static usage = ['<command> [-- <args>]']
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+  static isShellout = true
+  static checkDevEngines = true
+
+  static async completion (opts, npm) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      const workspacePrefixes = npm.config.get('workspace', 'default')
+      const localPrefix = workspacePrefixes.length
+        ? workspacePrefixes[0]
+        : npm.localPrefix
+      const { content: { scripts = {} } } = await pkgJson.normalize(localPrefix)
+        .catch(() => ({ content: {} }))
+      if (opts.isFish) {
+        return Object.keys(scripts).map(s => `${s}\t${scripts[s].slice(0, 30)}`)
+      }
+      return Object.keys(scripts)
+    }
+  }
+
+  async exec (args) {
+    if (args.length) {
+      await this.#run(args, { path: this.npm.localPrefix })
+    } else {
+      await this.#list(this.npm.localPrefix)
+    }
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+
+    const ws = [...this.workspaces.entries()]
+    for (const [workspace, path] of ws) {
+      const last = path === ws.at(-1)[1]
+
+      if (!args.length) {
+        const newline = await this.#list(path, { workspace })
+        if (newline && !last) {
+          output.standard()
+        }
+        continue
+      }
+
+      const pkg = await pkgJson.normalize(path).then(p => p.content)
+      try {
+        await this.#run(args, { path, pkg, workspace })
+      } catch (e) {
+        const err = getError(e, { npm: this.npm, command: null })
+        outputError({
+          ...err,
+          error: [
+            ['', `Lifecycle script \`${args[0]}\` failed with error:`],
+            ...err.error,
+            ['workspace', pkg._id || pkg.name],
+            ['location', path],
+          ],
+        })
+        process.exitCode = err.exitCode
+        if (!last) {
+          output.error('')
+        }
+      }
+    }
+  }
+
+  async #run ([event, ...args], { path, pkg, workspace }) {
+    const runScript = require('@npmcli/run-script')
+
+    pkg ??= await pkgJson.normalize(path).then(p => p.content)
+
+    const { scripts = {} } = pkg
+
+    if (event === 'restart' && !scripts.restart) {
+      scripts.restart = 'npm stop --if-present && npm start'
+    } else if (event === 'env' && !scripts.env) {
+      const { isWindowsShell } = require('../utils/is-windows.js')
+      scripts.env = isWindowsShell ? 'SET' : 'env'
+    }
+
+    pkg.scripts = scripts
+
+    if (
+      !Object.prototype.hasOwnProperty.call(scripts, event) &&
+      !(event === 'start' && (await runScript.isServerPackage(path)))
+    ) {
+      if (this.npm.config.get('if-present')) {
+        return
+      }
+
+      const suggestions = require('../utils/did-you-mean.js')(pkg, event)
+      const wsArg = workspace && path !== this.npm.localPrefix
+        ? ` --workspace=${pkg._id || pkg.name}`
+        : ''
+      throw new Error([
+        `Missing script: "${event}"${suggestions}`,
+        '',
+        'To see a list of scripts, run:',
+        `  npm run${wsArg}`,
+      ].join('\n'))
+    }
+
+    // positional args only added to the main event, not pre/post
+    const events = [[event, args]]
+    if (!this.npm.config.get('ignore-scripts')) {
+      if (scripts[`pre${event}`]) {
+        events.unshift([`pre${event}`, []])
+      }
+
+      if (scripts[`post${event}`]) {
+        events.push([`post${event}`, []])
+      }
+    }
+
+    for (const [ev, evArgs] of events) {
+      await runScript({
+        args: evArgs,
+        event: ev,
+        nodeGyp: this.npm.config.get('node-gyp'),
+        path,
+        pkg,
+        // || undefined is because runScript will be unhappy with the default null value
+        scriptShell: this.npm.config.get('script-shell') || undefined,
+        stdio: 'inherit',
+      })
+    }
+  }
+
+  async #list (path, { workspace } = {}) {
+    const { scripts = {}, name, _id } = await pkgJson.normalize(path).then(p => p.content)
+    const scriptEntries = Object.entries(scripts)
+
+    if (this.npm.silent) {
+      return
+    }
+
+    if (this.npm.config.get('json')) {
+      output.buffer(workspace ? { [workspace]: scripts } : scripts)
+      return
+    }
+
+    if (!scriptEntries.length) {
+      return
+    }
+
+    if (this.npm.config.get('parseable')) {
+      output.standard(scriptEntries
+        .map((s) => (workspace ? [workspace, ...s] : s).join(':'))
+        .join('\n')
+        .trim())
+      return
+    }
+
+    const cmdList = [
+      'prepare', 'prepublishOnly',
+      'prepack', 'postpack',
+      'dependencies',
+      'preinstall', 'install', 'postinstall',
+      'prepublish', 'publish', 'postpublish',
+      'prerestart', 'restart', 'postrestart',
+      'prestart', 'start', 'poststart',
+      'prestop', 'stop', 'poststop',
+      'pretest', 'test', 'posttest',
+      'preuninstall', 'uninstall', 'postuninstall',
+      'preversion', 'version', 'postversion',
+    ]
+    const [cmds, runScripts] = scriptEntries.reduce((acc, s) => {
+      acc[cmdList.includes(s[0]) ? 0 : 1].push(s)
+      return acc
+    }, [[], []])
+
+    const { reset, bold, cyan, dim, blue } = this.npm.chalk
+    const pkgId = `in ${cyan(_id || name)}`
+    const title = (t) => reset(bold(t))
+
+    if (cmds.length) {
+      output.standard(`${title('Lifecycle scripts')} included ${pkgId}:`)
+      for (const [k, v] of cmds) {
+        output.standard(`  ${k}`)
+        output.standard(`    ${dim(v)}`)
+      }
+    }
+
+    if (runScripts.length) {
+      const via = `via \`${blue('npm run')}\`:`
+      if (!cmds.length) {
+        output.standard(`${title('Scripts')} available ${pkgId} ${via}`)
+      } else {
+        output.standard(`available ${via}`)
+      }
+      for (const [k, v] of runScripts) {
+        output.standard(`  ${k}`)
+        output.standard(`    ${dim(v)}`)
+      }
+    }
+
+    // Return true to indicate that something was output for this path that should be separated from others
+    return true
+  }
+}
+
+module.exports = RunScript
diff --git a/node/node_modules/npm/lib/commands/sbom.js b/node/node_modules/npm/lib/commands/sbom.js
new file mode 100644
index 0000000000000000000000000000000000000000..84bc515d75267394b1f99738a8f25cbcaf1baf58
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/sbom.js
@@ -0,0 +1,130 @@
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const BaseCommand = require('../base-cmd.js')
+const { log, output, META } = require('proc-log')
+const { cyclonedxOutput } = require('../utils/sbom-cyclonedx.js')
+const { spdxOutput } = require('../utils/sbom-spdx.js')
+
+const SBOM_FORMATS = ['cyclonedx', 'spdx']
+
+class SBOM extends BaseCommand {
+  #response = {} // response is the sbom response
+
+  static description = 'Generate a Software Bill of Materials (SBOM)'
+  static name = 'sbom'
+  static workspaces = true
+
+  static params = [
+    'omit',
+    'package-lock-only',
+    'sbom-format',
+    'sbom-type',
+    'workspace',
+    'workspaces',
+  ]
+
+  async exec () {
+    const sbomFormat = this.npm.config.get('sbom-format')
+    const packageLockOnly = this.npm.config.get('package-lock-only')
+
+    if (!sbomFormat) {
+      throw this.usageError(`Must specify --sbom-format flag with one of: ${SBOM_FORMATS.join(', ')}.`)
+    }
+
+    const opts = {
+      ...this.npm.flatOptions,
+      path: this.npm.prefix,
+      forceActual: true,
+    }
+    const Arborist = require('@npmcli/arborist')
+    const arb = new Arborist(opts)
+
+    const tree = packageLockOnly ? await arb.loadVirtual(opts).catch(() => {
+      throw this.usageError('A package lock or shrinkwrap file is required in package-lock-only mode')
+    }) : await arb.loadActual(opts)
+
+    // Collect the list of selected workspaces in the project
+    const wsNodes = this.workspaceNames?.length
+      ? arb.workspaceNodes(tree, this.workspaceNames)
+      : null
+
+    // Build the selector and query the tree for the list of nodes
+    const selector = this.#buildSelector({ wsNodes })
+    log.info('sbom', `Using dependency selector: ${selector}`)
+    const items = await tree.querySelectorAll(selector)
+
+    const errors = items.flatMap(node => detectErrors(node))
+    if (errors.length) {
+      throw Object.assign(new Error([...new Set(errors)].join('\n')), {
+        code: 'ESBOMPROBLEMS',
+      })
+    }
+
+    // Populate the response with the list of unique nodes (sorted by location)
+    this.#buildResponse(items.sort((a, b) => localeCompare(a.location, b.location)))
+
+    // TODO(BREAKING_CHANGE): all sbom output is in json mode but setting it before any of the errors will cause those to be thrown in json mode.
+    this.npm.config.set('json', true)
+    output.standard(JSON.stringify(this.#response, null, 2), { [META]: true, redact: false })
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+    return this.exec(args)
+  }
+
+  // Build the selector from all of the specified filter options
+  #buildSelector ({ wsNodes }) {
+    let selector
+    const omit = this.npm.flatOptions.omit
+    const workspacesEnabled = this.npm.flatOptions.workspacesEnabled
+
+    // If omit is specified, omit all nodes and their children which match the specified selectors
+    const omits = omit.reduce((acc, o) => `${acc}:not(.${o})`, '')
+
+    if (!workspacesEnabled) {
+      // If workspaces are disabled, omit all workspace nodes and their children
+      selector = `:root > :not(.workspace)${omits},:root > :not(.workspace) *${omits},:extraneous`
+    } else if (wsNodes && wsNodes.length > 0) {
+      // If one or more workspaces are selected, select only those workspaces and their children
+      selector = wsNodes.map(ws => `#${ws.name},#${ws.name} *${omits}`).join(',')
+    } else {
+      selector = `:root *${omits},:extraneous`
+    }
+
+    // Always include the root node
+    return `:root,${selector}`
+  }
+
+  // builds a normalized inventory
+  #buildResponse (items) {
+    const sbomFormat = this.npm.config.get('sbom-format')
+    const packageType = this.npm.config.get('sbom-type')
+    const packageLockOnly = this.npm.config.get('package-lock-only')
+
+    this.#response = sbomFormat === 'cyclonedx'
+      ? cyclonedxOutput({ npm: this.npm, nodes: items, packageType, packageLockOnly })
+      : spdxOutput({ npm: this.npm, nodes: items, packageType })
+  }
+}
+
+const detectErrors = (node) => {
+  const errors = []
+
+  // Look for missing dependencies (that are NOT optional), or invalid dependencies
+  for (const edge of node.edgesOut.values()) {
+    if (edge.missing && !(edge.type === 'optional' || edge.type === 'peerOptional')) {
+      errors.push(`missing: ${edge.name}@${edge.spec}, required by ${edge.from.pkgid}`)
+    }
+
+    if (edge.invalid) {
+      /* istanbul ignore next */
+      const spec = edge.spec || '*'
+      const from = edge.from.pkgid
+      errors.push(`invalid: ${edge.to.pkgid}, ${spec} required by ${from}`)
+    }
+  }
+
+  return errors
+}
+
+module.exports = SBOM
diff --git a/node/node_modules/npm/lib/commands/search.js b/node/node_modules/npm/lib/commands/search.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d2e3b4d66f10d3a458bc26074dc08ce8b4726d3
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/search.js
@@ -0,0 +1,70 @@
+const Pipeline = require('minipass-pipeline')
+const libSearch = require('libnpmsearch')
+const { log, output } = require('proc-log')
+const formatSearchStream = require('../utils/format-search-stream.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Search extends BaseCommand {
+  static description = 'Search for packages'
+  static name = 'search'
+  static params = [
+    'json',
+    'color',
+    'parseable',
+    'description',
+    'searchlimit',
+    'searchopts',
+    'searchexclude',
+    'registry',
+    'prefer-online',
+    'prefer-offline',
+    'offline',
+  ]
+
+  static usage = ['<search term> [<search term> ...]']
+
+  async exec (args) {
+    const opts = {
+      ...this.npm.flatOptions,
+      ...this.npm.flatOptions.search,
+      include: args.map(s => s.toLowerCase()).filter(Boolean),
+      exclude: this.npm.flatOptions.search.exclude.split(/\s+/),
+    }
+
+    if (opts.include.length === 0) {
+      throw new Error('search must be called with arguments')
+    }
+
+    // Used later to figure out whether we had any packages go out
+    let anyOutput = false
+
+    // Grab a configured output stream that will spit out packages in the desired format.
+    const outputStream = formatSearchStream({
+      args, // --searchinclude options are not highlighted
+      ...opts,
+      npm: this.npm,
+    })
+
+    log.silly('search', 'searching packages')
+    const p = new Pipeline(
+      libSearch.stream(opts.include, opts),
+      outputStream
+    )
+
+    p.on('data', chunk => {
+      if (!anyOutput) {
+        anyOutput = true
+      }
+      output.standard(chunk.toString('utf8'))
+    })
+
+    await p.promise()
+    if (!anyOutput && !this.npm.config.get('json') && !this.npm.config.get('parseable')) {
+      output.standard('No matches found for ' + (args.map(JSON.stringify).join(' ')))
+    }
+
+    log.silly('search', 'search completed')
+  }
+}
+
+module.exports = Search
diff --git a/node/node_modules/npm/lib/commands/set.js b/node/node_modules/npm/lib/commands/set.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf54ba070affa175d8cc26454a4a376e6474a3ea
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/set.js
@@ -0,0 +1,24 @@
+const Npm = require('../npm.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Set extends BaseCommand {
+  static description = 'Set a value in the npm configuration'
+  static name = 'set'
+  static usage = ['<key>=<value> [<key>=<value> ...] (See `npm config`)']
+  static params = ['global', 'location']
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts) {
+    const Config = Npm.cmd('config')
+    return Config.completion(opts)
+  }
+
+  async exec (args) {
+    if (!args.length) {
+      throw this.usageError()
+    }
+    return this.npm.exec('config', ['set'].concat(args))
+  }
+}
+
+module.exports = Set
diff --git a/node/node_modules/npm/lib/commands/shrinkwrap.js b/node/node_modules/npm/lib/commands/shrinkwrap.js
new file mode 100644
index 0000000000000000000000000000000000000000..447bb3c8ef997fb8e99f03a90e5a848c39445a3c
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/shrinkwrap.js
@@ -0,0 +1,70 @@
+const { resolve, basename } = require('node:path')
+const { unlink } = require('node:fs/promises')
+const { log } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+
+class Shrinkwrap extends BaseCommand {
+  static description = 'Lock down dependency versions for publication'
+  static name = 'shrinkwrap'
+  static ignoreImplicitWorkspace = false
+
+  async exec () {
+    // if has a npm-shrinkwrap.json, nothing to do
+    // if has a package-lock.json, rename to npm-shrinkwrap.json
+    // if has neither, load the actual tree and save that as npm-shrinkwrap.json
+    //
+    // loadVirtual, fall back to loadActual
+    // rename shrinkwrap file type, and tree.meta.save()
+    if (this.npm.global) {
+      const er = new Error('`npm shrinkwrap` does not work for global packages')
+      er.code = 'ESHRINKWRAPGLOBAL'
+      throw er
+    }
+
+    const Arborist = require('@npmcli/arborist')
+    const path = this.npm.prefix
+    const sw = resolve(path, 'npm-shrinkwrap.json')
+    const arb = new Arborist({ ...this.npm.flatOptions, path })
+    const tree = await arb.loadVirtual().catch(() => arb.loadActual())
+    const { meta } = tree
+    const newFile = meta.hiddenLockfile || !meta.loadedFromDisk
+    const oldFilename = meta.filename
+    const notSW = !newFile && basename(oldFilename) !== 'npm-shrinkwrap.json'
+
+    // The computed lockfile version of a hidden lockfile is always 3 even if the actual value of the property is a different.
+    // When shrinkwrap is run with only a hidden lockfile we want to set the shrinkwrap lockfile version as whatever was explicitly requested with a fallback to the actual value from the hidden
+    // lockfile.
+    if (meta.hiddenLockfile) {
+      meta.lockfileVersion = arb.options.lockfileVersion ||
+        meta.originalLockfileVersion
+    }
+    meta.hiddenLockfile = false
+    meta.filename = sw
+    await meta.save()
+
+    const updatedVersion = meta.originalLockfileVersion !== meta.lockfileVersion
+      ? meta.lockfileVersion
+      : null
+
+    if (newFile) {
+      let message = 'created a lockfile as npm-shrinkwrap.json'
+      if (updatedVersion) {
+        message += ` with version ${updatedVersion}`
+      }
+      log.notice('', message)
+    } else if (notSW) {
+      await unlink(oldFilename)
+      let message = 'package-lock.json has been renamed to npm-shrinkwrap.json'
+      if (updatedVersion) {
+        message += ` and updated to version ${updatedVersion}`
+      }
+      log.notice('', message)
+    } else if (updatedVersion) {
+      log.notice('', `npm-shrinkwrap.json updated to version ${updatedVersion}`)
+    } else {
+      log.notice('', 'npm-shrinkwrap.json up to date')
+    }
+  }
+}
+
+module.exports = Shrinkwrap
diff --git a/node/node_modules/npm/lib/commands/star.js b/node/node_modules/npm/lib/commands/star.js
new file mode 100644
index 0000000000000000000000000000000000000000..06c6826c62cde7c69a371daa9b1f8120a5a00101
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/star.js
@@ -0,0 +1,72 @@
+const npmFetch = require('npm-registry-fetch')
+const npa = require('npm-package-arg')
+const { log, output } = require('proc-log')
+const getIdentity = require('../utils/get-identity')
+const BaseCommand = require('../base-cmd.js')
+
+class Star extends BaseCommand {
+  static description = 'Mark your favorite packages'
+  static name = 'star'
+  static usage = ['[<package-spec>...]']
+  static params = [
+    'registry',
+    'unicode',
+    'otp',
+  ]
+
+  static ignoreImplicitWorkspace = false
+
+  async exec (args) {
+    if (!args.length) {
+      throw this.usageError()
+    }
+
+    // if we're unstarring, then show an empty star image
+    // otherwise, show the full star image
+    const unicode = this.npm.config.get('unicode')
+    const full = unicode ? '\u2605 ' : '(*)'
+    const empty = unicode ? '\u2606 ' : '( )'
+    const show = this.name === 'star' ? full : empty
+
+    const pkgs = args.map(npa)
+    const username = await getIdentity(this.npm, this.npm.flatOptions)
+
+    for (const pkg of pkgs) {
+      const fullData = await npmFetch.json(pkg.escapedName, {
+        ...this.npm.flatOptions,
+        spec: pkg,
+        query: { write: true },
+        preferOnline: true,
+      })
+
+      const body = {
+        _id: fullData._id,
+        _rev: fullData._rev,
+        users: fullData.users || {},
+      }
+
+      if (this.name === 'star') {
+        log.info('star', 'starring', body._id)
+        body.users[username] = true
+        log.verbose('star', 'starring', body)
+      } else {
+        delete body.users[username]
+        log.info('unstar', 'unstarring', body._id)
+        log.verbose('unstar', 'unstarring', body)
+      }
+
+      const data = await npmFetch.json(pkg.escapedName, {
+        ...this.npm.flatOptions,
+        spec: pkg,
+        method: 'PUT',
+        body,
+      })
+
+      output.standard(show + ' ' + pkg.name)
+      log.verbose('star', data)
+      return data
+    }
+  }
+}
+
+module.exports = Star
diff --git a/node/node_modules/npm/lib/commands/stars.js b/node/node_modules/npm/lib/commands/stars.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb219677489874f44619c8b705c8c40ef5921d6e
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/stars.js
@@ -0,0 +1,39 @@
+const npmFetch = require('npm-registry-fetch')
+const { log, output } = require('proc-log')
+const getIdentity = require('../utils/get-identity.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Stars extends BaseCommand {
+  static description = 'View packages marked as favorites'
+  static name = 'stars'
+  static usage = ['[<user>]']
+  static params = ['registry']
+  static ignoreImplicitWorkspace = false
+
+  async exec ([user]) {
+    try {
+      if (!user) {
+        user = await getIdentity(this.npm, this.npm.flatOptions)
+      }
+
+      const { rows } = await npmFetch.json('/-/_view/starredByUser', {
+        ...this.npm.flatOptions,
+        query: { key: `"${user}"` },
+      })
+      if (rows.length === 0) {
+        log.warn('stars', 'user has not starred any packages')
+      }
+
+      for (const row of rows) {
+        output.standard(row.value)
+      }
+    } catch (err) {
+      if (err.code === 'ENEEDAUTH') {
+        log.warn('stars', 'auth is required to look up your username')
+      }
+      throw err
+    }
+  }
+}
+
+module.exports = Stars
diff --git a/node/node_modules/npm/lib/commands/start.js b/node/node_modules/npm/lib/commands/start.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc7634273c85feb9fd1550a680840c3b36abd6c1
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/start.js
@@ -0,0 +1,13 @@
+const LifecycleCmd = require('../lifecycle-cmd.js')
+
+// This ends up calling run(['start', ...args])
+class Start extends LifecycleCmd {
+  static description = 'Start a package'
+  static name = 'start'
+  static params = [
+    'ignore-scripts',
+    'script-shell',
+  ]
+}
+
+module.exports = Start
diff --git a/node/node_modules/npm/lib/commands/stop.js b/node/node_modules/npm/lib/commands/stop.js
new file mode 100644
index 0000000000000000000000000000000000000000..714bac7ee552191c0935a63a6b94e8880594eba9
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/stop.js
@@ -0,0 +1,13 @@
+const LifecycleCmd = require('../lifecycle-cmd.js')
+
+// This ends up calling run(['stop', ...args])
+class Stop extends LifecycleCmd {
+  static description = 'Stop a package'
+  static name = 'stop'
+  static params = [
+    'ignore-scripts',
+    'script-shell',
+  ]
+}
+
+module.exports = Stop
diff --git a/node/node_modules/npm/lib/commands/team.js b/node/node_modules/npm/lib/commands/team.js
new file mode 100644
index 0000000000000000000000000000000000000000..444a6a8e4ef640642dbd2907c62e2b237000fe4c
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/team.js
@@ -0,0 +1,158 @@
+const libteam = require('libnpmteam')
+const { output } = require('proc-log')
+const { otplease } = require('../utils/auth.js')
+
+const BaseCommand = require('../base-cmd.js')
+class Team extends BaseCommand {
+  static description = 'Manage organization teams and team memberships'
+  static name = 'team'
+  static usage = [
+    'create <scope:team> [--otp <otpcode>]',
+    'destroy <scope:team> [--otp <otpcode>]',
+    'add <scope:team> <user> [--otp <otpcode>]',
+    'rm <scope:team> <user> [--otp <otpcode>]',
+    'ls <scope>|<scope:team>',
+  ]
+
+  static params = [
+    'registry',
+    'otp',
+    'parseable',
+    'json',
+  ]
+
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts) {
+    const { conf: { argv: { remain: argv } } } = opts
+    const subcommands = ['create', 'destroy', 'add', 'rm', 'ls']
+
+    if (argv.length === 2) {
+      return subcommands
+    }
+
+    if (subcommands.includes(argv[2])) {
+      return []
+    }
+
+    throw new Error(argv[2] + ' not recognized')
+  }
+
+  async exec ([cmd, entity = '', user = '']) {
+    // Entities are in the format <scope>:<team>
+    // XXX: "description" option to libnpmteam is used as a description of the team, but in npm's options
+    // this is a boolean meaning "show the description in npm search output".
+    // Hence its being set to null here.
+    await otplease(this.npm, { ...this.npm.flatOptions }, opts => {
+      entity = entity.replace(/^@/, '')
+      switch (cmd) {
+        case 'create': return this.create(entity, opts)
+        case 'destroy': return this.destroy(entity, opts)
+        case 'add': return this.add(entity, user, opts)
+        case 'rm': return this.rm(entity, user, opts)
+        case 'ls': {
+          const match = entity.match(/[^:]+:.+/)
+          if (match) {
+            return this.listUsers(entity, opts)
+          } else {
+            return this.listTeams(entity, opts)
+          }
+        }
+        default:
+          throw this.usageError()
+      }
+    })
+  }
+
+  async create (entity, opts) {
+    await libteam.create(entity, opts)
+    if (opts.json) {
+      output.buffer({
+        created: true,
+        team: entity,
+      })
+    } else if (opts.parseable) {
+      output.standard(`${entity}\tcreated`)
+    } else if (!this.npm.silent) {
+      output.standard(`+@${entity}`)
+    }
+  }
+
+  async destroy (entity, opts) {
+    await libteam.destroy(entity, opts)
+    if (opts.json) {
+      output.buffer({
+        deleted: true,
+        team: entity,
+      })
+    } else if (opts.parseable) {
+      output.standard(`${entity}\tdeleted`)
+    } else if (!this.npm.silent) {
+      output.standard(`-@${entity}`)
+    }
+  }
+
+  async add (entity, user, opts) {
+    await libteam.add(user, entity, opts)
+    if (opts.json) {
+      output.buffer({
+        added: true,
+        team: entity,
+        user,
+      })
+    } else if (opts.parseable) {
+      output.standard(`${user}\t${entity}\tadded`)
+    } else if (!this.npm.silent) {
+      output.standard(`${user} added to @${entity}`)
+    }
+  }
+
+  async rm (entity, user, opts) {
+    await libteam.rm(user, entity, opts)
+    if (opts.json) {
+      output.buffer({
+        removed: true,
+        team: entity,
+        user,
+      })
+    } else if (opts.parseable) {
+      output.standard(`${user}\t${entity}\tremoved`)
+    } else if (!this.npm.silent) {
+      output.standard(`${user} removed from @${entity}`)
+    }
+  }
+
+  async listUsers (entity, opts) {
+    const users = (await libteam.lsUsers(entity, opts)).sort()
+    if (opts.json) {
+      output.buffer(users)
+    } else if (opts.parseable) {
+      output.standard(users.join('\n'))
+    } else if (!this.npm.silent) {
+      const plural = users.length === 1 ? '' : 's'
+      const more = users.length === 0 ? '' : ':'
+      output.standard(`@${entity} has ${users.length} user${plural}${more}`)
+      for (const user of users) {
+        output.standard(user)
+      }
+    }
+  }
+
+  async listTeams (entity, opts) {
+    const teams = (await libteam.lsTeams(entity, opts)).sort()
+    if (opts.json) {
+      output.buffer(teams)
+    } else if (opts.parseable) {
+      output.standard(teams.join('\n'))
+    } else if (!this.npm.silent) {
+      const plural = teams.length === 1 ? '' : 's'
+      const more = teams.length === 0 ? '' : ':'
+      output.standard(`@${entity} has ${teams.length} team${plural}${more}`)
+      for (const team of teams) {
+        output.standard(`@${team}`)
+      }
+    }
+  }
+}
+
+module.exports = Team
diff --git a/node/node_modules/npm/lib/commands/test.js b/node/node_modules/npm/lib/commands/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d26e12ec143f3108a83ca242e1547c505f1d72a
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/test.js
@@ -0,0 +1,13 @@
+const LifecycleCmd = require('../lifecycle-cmd.js')
+
+// This ends up calling run(['test', ...args])
+class Test extends LifecycleCmd {
+  static description = 'Test a package'
+  static name = 'test'
+  static params = [
+    'ignore-scripts',
+    'script-shell',
+  ]
+}
+
+module.exports = Test
diff --git a/node/node_modules/npm/lib/commands/token.js b/node/node_modules/npm/lib/commands/token.js
new file mode 100644
index 0000000000000000000000000000000000000000..d34d0e7b918657a6eec79ef4cff9dfcc5559294a
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/token.js
@@ -0,0 +1,281 @@
+const { log, output, META } = require('proc-log')
+const fetch = require('npm-registry-fetch')
+const { otplease } = require('../utils/auth.js')
+const readUserInfo = require('../utils/read-user-info.js')
+const BaseCommand = require('../base-cmd.js')
+
+async function paginate (href, opts, items = []) {
+  while (href) {
+    const result = await fetch.json(href, opts)
+    items = items.concat(result.objects)
+    href = result.urls.next
+  }
+  return items
+}
+
+class Token extends BaseCommand {
+  static description = 'Manage your authentication tokens'
+  static name = 'token'
+  static usage = ['list', 'revoke <id|token>', 'create']
+  static params = ['name',
+    'token-description',
+    'expires',
+    'packages',
+    'packages-all',
+    'scopes',
+    'orgs',
+    'packages-and-scopes-permission',
+    'orgs-permission',
+    'cidr',
+    'bypass-2fa',
+    'password',
+    'registry',
+    'otp',
+    'read-only',
+  ]
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    const subcommands = ['list', 'revoke', 'create']
+    if (argv.length === 2) {
+      return subcommands
+    }
+
+    if (subcommands.includes(argv[2])) {
+      return []
+    }
+
+    throw new Error(argv[2] + ' not recognized')
+  }
+
+  async exec (args) {
+    if (args.length === 0) {
+      return this.list()
+    }
+    switch (args[0]) {
+      case 'list':
+      case 'ls':
+        return this.list()
+      case 'rm':
+      case 'delete':
+      case 'revoke':
+      case 'remove':
+        return this.rm(args.slice(1))
+      case 'create':
+        return this.create(args.slice(1))
+      default:
+        throw this.usageError(`${args[0]} is not a recognized subcommand.`)
+    }
+  }
+
+  async list () {
+    const json = this.npm.config.get('json')
+    const parseable = this.npm.config.get('parseable')
+    log.info('token', 'getting list')
+    const tokens = await paginate('/-/npm/v1/tokens', this.npm.flatOptions)
+    if (json) {
+      output.buffer(tokens)
+      return
+    }
+    if (parseable) {
+      output.standard(['key', 'token', 'created', 'readonly', 'CIDR whitelist'].join('\t'))
+      tokens.forEach(token => {
+        output.standard(
+          [
+            token.key,
+            token.token,
+            token.created,
+            token.readonly ? 'true' : 'false',
+            token.cidr_whitelist ? token.cidr_whitelist.join(',') : '',
+          ].join('\t')
+        )
+      })
+      return
+    }
+    this.generateTokenIds(tokens, 6)
+    const chalk = this.npm.chalk
+    for (const token of tokens) {
+      const created = String(token.created).slice(0, 10)
+      output.standard(`${chalk.blue('Token')} ${token.token}… with id ${chalk.cyan(token.id)} created ${created}`)
+      if (token.cidr_whitelist) {
+        output.standard(`with IP whitelist: ${chalk.green(token.cidr_whitelist.join(','))}`)
+      }
+      output.standard()
+    }
+  }
+
+  async rm (args) {
+    if (args.length === 0) {
+      throw this.usageError('`<tokenKey>` argument is required.')
+    }
+
+    const json = this.npm.config.get('json')
+    const parseable = this.npm.config.get('parseable')
+    const toRemove = []
+    log.info('token', `removing ${toRemove.length} tokens`)
+    const tokens = await paginate('/-/npm/v1/tokens', this.npm.flatOptions)
+    for (const id of args) {
+      const matches = tokens.filter(token => token.key.indexOf(id) === 0)
+      if (matches.length === 1) {
+        toRemove.push(matches[0].key)
+      } else if (matches.length > 1) {
+        throw new Error(
+          `Token ID "${id}" was ambiguous, a new token may have been created since you last ran \`npm token list\`.`
+        )
+      } else {
+        const tokenMatches = tokens.some(t => id.indexOf(t.token) === 0)
+        if (!tokenMatches) {
+          throw new Error(`Unknown token id or value "${id}".`)
+        }
+
+        toRemove.push(id)
+      }
+    }
+    for (const tokenKey of toRemove) {
+      await otplease(this.npm, this.npm.flatOptions, opts =>
+        fetch(`/-/npm/v1/tokens/token/${tokenKey}`, {
+          ...opts,
+          method: 'DELETE',
+          ignoreBody: true,
+        })
+      )
+    }
+    if (json) {
+      output.buffer(toRemove)
+    } else if (parseable) {
+      output.standard(toRemove.join('\t'))
+    } else {
+      output.standard('Removed ' + toRemove.length + ' token' + (toRemove.length !== 1 ? 's' : ''))
+    }
+  }
+
+  async create () {
+    const json = this.npm.config.get('json')
+    const parseable = this.npm.config.get('parseable')
+    const cidr = this.npm.config.get('cidr')
+    const name = this.npm.config.get('name')
+    const tokenDescription = this.npm.config.get('token-description')
+    const expires = this.npm.config.get('expires')
+    const packages = this.npm.config.get('packages')
+    const packagesAll = this.npm.config.get('packages-all')
+    const scopes = this.npm.config.get('scopes')
+    const orgs = this.npm.config.get('orgs')
+    const packagesAndScopesPermission = this.npm.config.get('packages-and-scopes-permission')
+    const orgsPermission = this.npm.config.get('orgs-permission')
+    const bypassTwoFactor = this.npm.config.get('bypass-2fa')
+    let password = this.npm.config.get('password')
+
+    const validCIDR = await this.validateCIDRList(cidr)
+
+    /* istanbul ignore if - skip testing read input */
+    if (!password) {
+      password = await readUserInfo.password()
+    }
+
+    const tokenData = {
+      name: name,
+      password: password,
+    }
+
+    if (tokenDescription) {
+      tokenData.description = tokenDescription
+    }
+
+    if (packages?.length > 0) {
+      tokenData.packages = packages
+    }
+    if (packagesAll) {
+      tokenData.packages_all = true
+    }
+    if (scopes?.length > 0) {
+      tokenData.scopes = scopes
+    }
+    if (orgs?.length > 0) {
+      tokenData.orgs = orgs
+    }
+
+    if (packagesAndScopesPermission) {
+      tokenData.packages_and_scopes_permission = packagesAndScopesPermission
+    }
+    if (orgsPermission) {
+      tokenData.orgs_permission = orgsPermission
+    }
+
+    // Add expiration in days
+    if (expires) {
+      tokenData.expires = parseInt(expires, 10)
+    }
+
+    // Add optional fields
+    if (validCIDR?.length > 0) {
+      tokenData.cidr_whitelist = validCIDR
+    }
+    if (bypassTwoFactor) {
+      tokenData.bypass_2fa = true
+    }
+
+    log.info('token', 'creating')
+    const result = await otplease(this.npm, this.npm.flatOptions, opts =>
+      fetch.json('/-/npm/v1/tokens', {
+        ...opts,
+        method: 'POST',
+        body: tokenData,
+      })
+    )
+    delete result.key
+    delete result.updated
+    if (json) {
+      output.buffer(result)
+    } else if (parseable) {
+      Object.keys(result).forEach(k => output.standard(k + '\t' + result[k]))
+    } else {
+      const chalk = this.npm.chalk
+      output.standard(`Created token ${result.token}`, { [META]: true, redact: false })
+      if (result.cidr_whitelist?.length) {
+        output.standard(`with IP whitelist: ${chalk.green(result.cidr_whitelist.join(','))}`)
+      }
+      if (result.expires) {
+        output.standard(`expires: ${result.expires}`)
+      }
+    }
+  }
+
+  invalidCIDRError (msg) {
+    return Object.assign(new Error(msg), { code: 'EINVALIDCIDR' })
+  }
+
+  generateTokenIds (tokens, minLength) {
+    for (const token of tokens) {
+      token.id = token.key
+      for (let ii = minLength; ii < token.key.length; ++ii) {
+        const match = tokens.some(
+          ot => ot !== token && ot.key.slice(0, ii) === token.key.slice(0, ii)
+        )
+        if (!match) {
+          token.id = token.key.slice(0, ii)
+          break
+        }
+      }
+    }
+  }
+
+  async validateCIDRList (cidrs) {
+    const { v4: isCidrV4, v6: isCidrV6 } = await import('is-cidr')
+    const maybeList = [].concat(cidrs).filter(Boolean)
+    const list = maybeList.length === 1 ? maybeList[0].split(/,\s*/) : maybeList
+    for (const cidr of list) {
+      if (isCidrV6(cidr)) {
+        throw this.invalidCIDRError(
+          `CIDR whitelist can only contain IPv4 addresses, ${cidr} is IPv6`
+        )
+      }
+
+      if (!isCidrV4(cidr)) {
+        throw this.invalidCIDRError(`CIDR whitelist contains invalid CIDR entry: ${cidr}`)
+      }
+    }
+    return list
+  }
+}
+
+module.exports = Token
diff --git a/node/node_modules/npm/lib/commands/trust/circleci.js b/node/node_modules/npm/lib/commands/trust/circleci.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d5259807b2b5c469993a492490f6783b646e936
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/trust/circleci.js
@@ -0,0 +1,179 @@
+const Definition = require('@npmcli/config/lib/definitions/definition.js')
+const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
+const TrustCommand = require('../../trust-cmd.js')
+
+// UUID validation regex
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+class TrustCircleCI extends TrustCommand {
+  static description = 'Create a trusted relationship between a package and CircleCI'
+  static name = 'circleci'
+  static positionals = 1 // expects at most 1 positional (package name)
+  static providerName = 'CircleCI'
+  static providerEntity = 'CircleCI pipeline'
+
+  static usage = [
+    '[package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [-y|--yes]',
+  ]
+
+  static definitions = [
+    new Definition('org-id', {
+      default: null,
+      type: String,
+      required: true,
+      description: 'CircleCI organization UUID',
+    }),
+    new Definition('project-id', {
+      default: null,
+      type: String,
+      required: true,
+      description: 'CircleCI project UUID',
+    }),
+    new Definition('pipeline-definition-id', {
+      default: null,
+      type: String,
+      required: true,
+      description: 'CircleCI pipeline definition UUID',
+    }),
+    new Definition('vcs-origin', {
+      default: null,
+      type: String,
+      required: true,
+      description: "CircleCI repository origin in format 'provider/owner/repo'",
+    }),
+    new Definition('context-id', {
+      default: null,
+      type: [null, String, Array],
+      description: 'CircleCI context UUID to match',
+    }),
+    // globals are alphabetical
+    globalDefinitions['dry-run'],
+    globalDefinitions.json,
+    globalDefinitions.registry,
+    globalDefinitions.yes,
+  ]
+
+  validateUuid (value, fieldName) {
+    if (!UUID_REGEX.test(value)) {
+      throw new Error(`${fieldName} must be a valid UUID`)
+    }
+  }
+
+  validateVcsOrigin (value) {
+    // Expected format: provider/owner/repo (e.g., github.com/owner/repo, bitbucket.org/owner/repo)
+    if (value.includes('://')) {
+      throw new Error("vcs-origin must not include a scheme (e.g., use 'github.com/owner/repo' not 'https://github.com/owner/repo')")
+    }
+    const parts = value.split('/')
+    if (parts.length < 3) {
+      throw new Error("vcs-origin must be in format 'provider/owner/repo'")
+    }
+  }
+
+  // Generate a URL from vcs-origin (e.g., github.com/npm/repo -> https://github.com/npm/repo)
+  getVcsOriginUrl (vcsOrigin) {
+    if (!vcsOrigin) {
+      return null
+    }
+    // vcs-origin format: github.com/owner/repo or bitbucket.org/owner/repo
+    return `https://${vcsOrigin}`
+  }
+
+  static optionsToBody (options) {
+    const { orgId, projectId, pipelineDefinitionId, vcsOrigin, contextIds } = options
+    const trustConfig = {
+      type: 'circleci',
+      claims: {
+        'oidc.circleci.com/org-id': orgId,
+        'oidc.circleci.com/project-id': projectId,
+        'oidc.circleci.com/pipeline-definition-id': pipelineDefinitionId,
+        'oidc.circleci.com/vcs-origin': vcsOrigin,
+      },
+    }
+    if (contextIds && contextIds.length > 0) {
+      trustConfig.claims['oidc.circleci.com/context-ids'] = contextIds
+    }
+    return trustConfig
+  }
+
+  static bodyToOptions (body) {
+    return {
+      ...(body.id) && { id: body.id },
+      ...(body.type) && { type: body.type },
+      ...(body.claims?.['oidc.circleci.com/org-id']) && { orgId: body.claims['oidc.circleci.com/org-id'] },
+      ...(body.claims?.['oidc.circleci.com/project-id']) && { projectId: body.claims['oidc.circleci.com/project-id'] },
+      ...(body.claims?.['oidc.circleci.com/pipeline-definition-id']) && {
+        pipelineDefinitionId: body.claims['oidc.circleci.com/pipeline-definition-id'],
+      },
+      ...(body.claims?.['oidc.circleci.com/vcs-origin']) && { vcsOrigin: body.claims['oidc.circleci.com/vcs-origin'] },
+      ...(body.claims?.['oidc.circleci.com/context-ids']) && { contextIds: body.claims['oidc.circleci.com/context-ids'] },
+    }
+  }
+
+  // Override flagsToOptions since CircleCI doesn't use file/entity pattern
+  async flagsToOptions ({ positionalArgs, flags }) {
+    const content = await this.optionalPkgJson()
+    const pkgName = positionalArgs[0] || content.name
+
+    if (!pkgName) {
+      throw new Error('Package name must be specified either as an argument or in package.json file')
+    }
+
+    const orgId = flags['org-id']
+    const projectId = flags['project-id']
+    const pipelineDefinitionId = flags['pipeline-definition-id']
+    const vcsOrigin = flags['vcs-origin']
+    const contextIds = flags['context-id']
+
+    // Validate required flags
+    if (!orgId) {
+      throw new Error('org-id is required')
+    }
+    if (!projectId) {
+      throw new Error('project-id is required')
+    }
+    if (!pipelineDefinitionId) {
+      throw new Error('pipeline-definition-id is required')
+    }
+    if (!vcsOrigin) {
+      throw new Error('vcs-origin is required')
+    }
+
+    // Validate formats
+    this.validateUuid(orgId, 'org-id')
+    this.validateUuid(projectId, 'project-id')
+    this.validateUuid(pipelineDefinitionId, 'pipeline-definition-id')
+    this.validateVcsOrigin(vcsOrigin)
+    if (contextIds?.length > 0) {
+      for (const contextId of contextIds) {
+        this.validateUuid(contextId, 'context-id')
+      }
+    }
+
+    return {
+      values: {
+        package: pkgName,
+        orgId,
+        projectId,
+        pipelineDefinitionId,
+        vcsOrigin,
+        ...(contextIds?.length > 0 && { contextIds }),
+      },
+      fromPackageJson: {},
+      warnings: [],
+      urls: {
+        package: this.getFrontendUrl({ pkgName }),
+        vcsOrigin: this.getVcsOriginUrl(vcsOrigin),
+      },
+    }
+  }
+
+  async exec (positionalArgs, flags) {
+    await this.createConfigCommand({
+      positionalArgs,
+      flags,
+    })
+  }
+}
+
+module.exports = TrustCircleCI
diff --git a/node/node_modules/npm/lib/commands/trust/github.js b/node/node_modules/npm/lib/commands/trust/github.js
new file mode 100644
index 0000000000000000000000000000000000000000..d417820f2a0e61e4e583bb1012a70e333810a20a
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/trust/github.js
@@ -0,0 +1,104 @@
+const Definition = require('@npmcli/config/lib/definitions/definition.js')
+const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
+const TrustCommand = require('../../trust-cmd.js')
+const path = require('node:path')
+
+class TrustGitHub extends TrustCommand {
+  static description = 'Create a trusted relationship between a package and GitHub Actions'
+  static name = 'github'
+  static positionals = 1 // expects at most 1 positional (package name)
+  static providerName = 'GitHub Actions'
+  static providerEntity = 'GitHub repository'
+  static providerFile = 'GitHub Actions Workflow'
+  static providerHostname = 'https://github.com'
+
+  // entity means project / repository
+  static entityKey = 'repository'
+
+  static usage = [
+    '[package] --file [--repo|--repository] [--env|--environment] [-y|--yes]',
+  ]
+
+  static definitions = [
+    new Definition('file', {
+      default: null,
+      type: String,
+      required: true,
+      description: 'Name of workflow file within a repositories .GitHub folder (must end in yaml, yml)',
+    }),
+    new Definition('repository', {
+      default: null,
+      type: String,
+      description: 'Name of the repository in the format owner/repo',
+      alias: ['repo'],
+    }),
+    new Definition('environment', {
+      default: null,
+      type: String,
+      description: 'CI environment name',
+      alias: ['env'],
+    }),
+    // globals are alphabetical
+    globalDefinitions['dry-run'],
+    globalDefinitions.json,
+    globalDefinitions.registry,
+    globalDefinitions.yes,
+  ]
+
+  getEntityUrl ({ providerHostname, file, entity }) {
+    if (file) {
+      return new URL(`${entity}/blob/HEAD/.github/workflows/${file}`, providerHostname).toString()
+    }
+    return new URL(entity, providerHostname).toString()
+  }
+
+  validateEntity (entity) {
+    if (entity.split('/').length !== 2) {
+      throw new Error(`${this.constructor.providerEntity} must be specified in the format owner/repository`)
+    }
+  }
+
+  validateFile (file) {
+    if (file !== path.basename(file)) {
+      throw new Error('GitHub Actions workflow must be just a file not a path')
+    }
+  }
+
+  static optionsToBody (options) {
+    const { file, repository, environment } = options
+    const trustConfig = {
+      type: 'github',
+      claims: {
+        repository,
+        workflow_ref: {
+          file,
+        },
+        ...(environment) && { environment },
+      },
+    }
+    return trustConfig
+  }
+
+  // Convert API response body to options
+  static bodyToOptions (body) {
+    const file = body.claims?.workflow_ref?.file
+    const repository = body.claims?.repository
+    const environment = body.claims?.environment
+    return {
+      ...(body.id) && { id: body.id },
+      ...(body.type) && { type: body.type },
+      ...(file) && { file },
+      ...(repository) && { repository },
+      ...(environment) && { environment },
+    }
+  }
+
+  async exec (positionalArgs, flags) {
+    await this.createConfigCommand({
+      positionalArgs,
+      flags,
+    })
+  }
+}
+
+module.exports = TrustGitHub
diff --git a/node/node_modules/npm/lib/commands/trust/gitlab.js b/node/node_modules/npm/lib/commands/trust/gitlab.js
new file mode 100644
index 0000000000000000000000000000000000000000..74a4ed5dd54aafe88f00c5c22977c2261edf32db
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/trust/gitlab.js
@@ -0,0 +1,105 @@
+const Definition = require('@npmcli/config/lib/definitions/definition.js')
+const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
+const TrustCommand = require('../../trust-cmd.js')
+const path = require('node:path')
+
+class TrustGitLab extends TrustCommand {
+  static description = 'Create a trusted relationship between a package and GitLab CI/CD'
+  static name = 'gitlab'
+  static positionals = 1 // expects at most 1 positional (package name)
+  static providerName = 'GitLab CI/CD'
+  static providerEntity = 'GitLab project'
+  static providerFile = 'GitLab CI/CD Pipeline'
+  static providerHostname = 'https://gitlab.com'
+
+  // entity means project / repository
+  static entityKey = 'project'
+
+  static usage = [
+    '[package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]',
+  ]
+
+  static definitions = [
+    new Definition('file', {
+      default: null,
+      type: String,
+      required: true,
+      description: 'Name of pipeline file (e.g., .gitlab-ci.yml)',
+    }),
+    new Definition('project', {
+      default: null,
+      type: String,
+      description: 'Name of the project in the format group/project or group/subgroup/project',
+    }),
+    new Definition('environment', {
+      default: null,
+      type: String,
+      description: 'CI environment name',
+      alias: ['env'],
+    }),
+    // globals are alphabetical
+    globalDefinitions['dry-run'],
+    globalDefinitions.json,
+    globalDefinitions.registry,
+    globalDefinitions.yes,
+  ]
+
+  getEntityUrl ({ providerHostname, file, entity }) {
+    if (file) {
+      return new URL(`${entity}/-/blob/HEAD/${file}`, providerHostname).toString()
+    }
+    return new URL(entity, providerHostname).toString()
+  }
+
+  validateEntity (entity) {
+    if (entity.split('/').length < 2) {
+      throw new Error(`${this.constructor.providerEntity} must be specified in the format group/project or group/subgroup/project`)
+    }
+  }
+
+  validateFile (file) {
+    if (file !== path.basename(file)) {
+      throw new Error('GitLab CI/CD pipeline file must be just a file not a path')
+    }
+  }
+
+  static optionsToBody (options) {
+    const { file, project, environment } = options
+    const trustConfig = {
+      type: 'gitlab',
+      claims: {
+        project_path: project,
+        // this looks off, but this is correct
+        /** The ref path to the top-level pipeline definition, for example, gitlab.example.com/my-group/my-project//.gitlab-ci.yml@refs/heads/main. Introduced in GitLab 16.2. This claim is null unless the pipeline definition is located in the same project. */
+        ci_config_ref_uri: {
+          file,
+        },
+        ...(environment) && { environment },
+      },
+    }
+    return trustConfig
+  }
+
+  // Convert API response body to options
+  static bodyToOptions (body) {
+    const file = body.claims?.ci_config_ref_uri?.file
+    const project = body.claims?.project_path
+    const environment = body.claims?.environment
+    return {
+      ...(body.id) && { id: body.id },
+      ...(body.type) && { type: body.type },
+      ...(file) && { file },
+      ...(project) && { project },
+      ...(environment) && { environment },
+    }
+  }
+
+  async exec (positionalArgs, flags) {
+    await this.createConfigCommand({
+      positionalArgs,
+      flags,
+    })
+  }
+}
+
+module.exports = TrustGitLab
diff --git a/node/node_modules/npm/lib/commands/trust/index.js b/node/node_modules/npm/lib/commands/trust/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e76ff65486aeb81dfbebca6eb7aaf2194ba2bc89
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/trust/index.js
@@ -0,0 +1,25 @@
+const BaseCommand = require('../../base-cmd.js')
+
+class Trust extends BaseCommand {
+  static description = 'Create a trusted relationship between a package and a OIDC provider'
+  static name = 'trust'
+  static usage = null
+
+  static subcommands = {
+    github: require('./github.js'),
+    gitlab: require('./gitlab.js'),
+    circleci: require('./circleci.js'),
+    list: require('./list.js'),
+    revoke: require('./revoke.js'),
+  }
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      return Object.keys(Trust.subcommands)
+    }
+    return []
+  }
+}
+
+module.exports = Trust
diff --git a/node/node_modules/npm/lib/commands/trust/list.js b/node/node_modules/npm/lib/commands/trust/list.js
new file mode 100644
index 0000000000000000000000000000000000000000..1baa795206f2a98ae108d7229c6ccbe54c31b63b
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/trust/list.js
@@ -0,0 +1,50 @@
+const { otplease } = require('../../utils/auth.js')
+const npmFetch = require('npm-registry-fetch')
+const npa = require('npm-package-arg')
+const TrustCircleCI = require('./circleci.js')
+const TrustGithub = require('./github.js')
+const TrustGitlab = require('./gitlab.js')
+const TrustCommand = require('../../trust-cmd.js')
+const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
+
+class TrustList extends TrustCommand {
+  static description = 'List trusted relationships for a package'
+  static name = 'list'
+  static positionals = 1 // expects at most 1 positional (package name)
+
+  static usage = [
+    '[package]',
+  ]
+
+  static definitions = [
+    globalDefinitions.json,
+    globalDefinitions.registry,
+  ]
+
+  static bodyToOptions (body) {
+    if (body.type === 'circleci') {
+      return TrustCircleCI.bodyToOptions(body)
+    } else if (body.type === 'github') {
+      return TrustGithub.bodyToOptions(body)
+    } else if (body.type === 'gitlab') {
+      return TrustGitlab.bodyToOptions(body)
+    }
+    return TrustCommand.bodyToOptions(body)
+  }
+
+  async exec (positionalArgs) {
+    const packageName = positionalArgs[0] || (await this.optionalPkgJson()).name
+    if (!packageName) {
+      throw new Error('Package name must be specified either as an argument or in the package.json file')
+    }
+    const spec = npa(packageName)
+    const uri = `/-/package/${spec.escapedName}/trust`
+    const body = await otplease(this.npm, this.npm.flatOptions, opts => npmFetch.json(uri, {
+      ...opts,
+      method: 'GET',
+    }))
+    this.displayResponseBody({ body, packageName })
+  }
+}
+
+module.exports = TrustList
diff --git a/node/node_modules/npm/lib/commands/trust/revoke.js b/node/node_modules/npm/lib/commands/trust/revoke.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf4c23ac84aa2a8cb99311e1659b042537fd9a20
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/trust/revoke.js
@@ -0,0 +1,52 @@
+const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
+const Definition = require('@npmcli/config/lib/definitions/definition.js')
+const { otplease } = require('../../utils/auth.js')
+const npmFetch = require('npm-registry-fetch')
+const npa = require('npm-package-arg')
+const TrustCommand = require('../../trust-cmd.js')
+
+class TrustRevoke extends TrustCommand {
+  static description = 'Revoke a trusted relationship for a package'
+  static name = 'revoke'
+  static positionals = 1 // expects at most 1 positional (package name)
+
+  static usage = [
+    '[package] --id=<trust-id>',
+  ]
+
+  static definitions = [
+    new Definition('id', {
+      default: null,
+      type: String,
+      description: 'ID of the trusted relationship to revoke',
+      required: true,
+    }),
+    globalDefinitions['dry-run'],
+    globalDefinitions.registry,
+  ]
+
+  async exec (positionalArgs, flags) {
+    const dryRun = this.config.get('dry-run')
+    const pkgName = positionalArgs[0] || (await this.optionalPkgJson()).name
+    if (!pkgName) {
+      throw new Error('Package name must be specified either as an argument or in the package.json file')
+    }
+    const { id } = flags
+    if (!id) {
+      throw new Error('ID of the trusted relationship to revoke must be specified with the --id option')
+    }
+    this.dialogue`Attempting to revoke trusted configuration for package ${pkgName} with id ${id}`
+    if (dryRun) {
+      return
+    }
+    const spec = npa(pkgName)
+    const uri = `/-/package/${spec.escapedName}/trust/${encodeURIComponent(id)}`
+    await otplease(this.npm, this.npm.flatOptions, opts => npmFetch(uri, {
+      ...opts,
+      method: 'DELETE',
+    }))
+    this.dialogue`Revoked trusted configuration for package ${pkgName} with id ${id}`
+  }
+}
+
+module.exports = TrustRevoke
diff --git a/node/node_modules/npm/lib/commands/undeprecate.js b/node/node_modules/npm/lib/commands/undeprecate.js
new file mode 100644
index 0000000000000000000000000000000000000000..13f40eb206590dd37b2efd818fe7d29116567c96
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/undeprecate.js
@@ -0,0 +1,13 @@
+const Deprecate = require('./deprecate.js')
+
+class Undeprecate extends Deprecate {
+  static description = 'Undeprecate a version of a package'
+  static name = 'undeprecate'
+  static usage = ['<package-spec>']
+
+  async exec ([pkg]) {
+    return super.exec([pkg, ''])
+  }
+}
+
+module.exports = Undeprecate
diff --git a/node/node_modules/npm/lib/commands/uninstall.js b/node/node_modules/npm/lib/commands/uninstall.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee91bd3491cb077b9673b0d2bb786ca0cea8df64
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/uninstall.js
@@ -0,0 +1,54 @@
+const { resolve } = require('node:path')
+const pkgJson = require('@npmcli/package-json')
+const reifyFinish = require('../utils/reify-finish.js')
+const completion = require('../utils/installed-shallow.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Uninstall extends ArboristWorkspaceCmd {
+  static description = 'Remove a package'
+  static name = 'uninstall'
+  static params = ['save', 'global', ...super.params]
+  static usage = ['[<@scope>/]<pkg>...']
+  static ignoreImplicitWorkspace = false
+
+  static async completion (opts, npm) {
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    if (!args.length) {
+      if (!this.npm.global) {
+        throw new Error('Must provide a package name to remove')
+      } else {
+        try {
+          const { content: pkg } = await pkgJson.normalize(this.npm.localPrefix)
+          args.push(pkg.name)
+        } catch (er) {
+          if (er.code !== 'ENOENT' && er.code !== 'ENOTDIR') {
+            throw er
+          } else {
+            throw this.usageError()
+          }
+        }
+      }
+    }
+
+    // the /path/to/node_modules/..
+    const path = this.npm.global
+      ? resolve(this.npm.globalDir, '..')
+      : this.npm.localPrefix
+
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      path,
+      rm: args,
+      workspaces: this.workspaceNames,
+    }
+    const arb = new Arborist(opts)
+    await arb.reify(opts)
+    await reifyFinish(this.npm, arb)
+  }
+}
+
+module.exports = Uninstall
diff --git a/node/node_modules/npm/lib/commands/unpublish.js b/node/node_modules/npm/lib/commands/unpublish.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ba0608fb71e8e8725f8e0aedbbc395024b825db
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/unpublish.js
@@ -0,0 +1,163 @@
+const libaccess = require('libnpmaccess')
+const libunpub = require('libnpmpublish').unpublish
+const npa = require('npm-package-arg')
+const pacote = require('pacote')
+const { output, log } = require('proc-log')
+const pkgJson = require('@npmcli/package-json')
+const { flatten } = require('@npmcli/config/lib/definitions')
+const getIdentity = require('../utils/get-identity.js')
+const { otplease } = require('../utils/auth.js')
+const BaseCommand = require('../base-cmd.js')
+
+const LAST_REMAINING_VERSION_ERROR = 'Refusing to delete the last version of the package. It will block from republishing a new version for 24 hours.\nRun with --force to do this.'
+
+class Unpublish extends BaseCommand {
+  static description = 'Remove a package from the registry'
+  static name = 'unpublish'
+  static params = ['dry-run', 'force', 'workspace', 'workspaces']
+  static usage = ['[<package-spec>]']
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  static async getKeysOfVersions (name, opts) {
+    const packument = await pacote.packument(name, {
+      ...opts,
+      spec: name,
+      query: { write: true },
+      _isRoot: true,
+    })
+    return Object.keys(packument.versions)
+  }
+
+  static async completion (args, npm) {
+    const { partialWord, conf } = args
+
+    if (conf.argv.remain.length >= 3) {
+      return []
+    }
+
+    const opts = { ...npm.flatOptions }
+    const username = await getIdentity(npm, { ...opts }).catch(() => null)
+    if (!username) {
+      return []
+    }
+
+    const access = await libaccess.getPackages(username, opts)
+    // do a bit of filtering at this point, so that we don't need to fetch versions for more than one thing, but also don't accidentally unpublish a whole project
+    let pkgs = Object.keys(access)
+    if (!partialWord || !pkgs.length) {
+      return pkgs
+    }
+
+    const pp = npa(partialWord).name
+    pkgs = pkgs.filter(p => !p.indexOf(pp))
+    if (pkgs.length > 1) {
+      return pkgs
+    }
+
+    const versions = await Unpublish.getKeysOfVersions(pkgs[0], opts)
+    if (!versions.length) {
+      return pkgs
+    } else {
+      return versions.map(v => `${pkgs[0]}@${v}`)
+    }
+  }
+
+  async exec (args, { localPrefix } = {}) {
+    if (args.length > 1) {
+      throw this.usageError()
+    }
+
+    // workspace mode
+    if (!localPrefix) {
+      localPrefix = this.npm.localPrefix
+    }
+
+    const force = this.npm.config.get('force')
+    const { silent } = this.npm
+    const dryRun = this.npm.config.get('dry-run')
+
+    let spec
+    if (args.length) {
+      spec = npa(args[0])
+      if (spec.type !== 'version' && spec.rawSpec !== '*') {
+        throw this.usageError('Can only unpublish a single version, or the entire project.\nTags and ranges are not supported.')
+      }
+    }
+
+    log.silly('unpublish', 'args[0]', args[0])
+    log.silly('unpublish', 'spec', spec)
+
+    if (spec?.rawSpec === '*' && !force) {
+      throw this.usageError('Refusing to delete entire project.\nRun with --force to do this.')
+    }
+
+    const opts = { ...this.npm.flatOptions }
+
+    let manifest
+    try {
+      const { content } = await pkgJson.prepare(localPrefix)
+      manifest = content
+    } catch (err) {
+      if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
+        if (!spec) {
+          // We needed a local package.json to figure out what package to unpublish
+          throw this.usageError()
+        }
+      } else {
+        // folks should know if ANY local package.json had a parsing error.
+        // They may be relying on `publishConfig` to be loading and we don't want to ignore errors in that case.
+        throw err
+      }
+    }
+
+    let pkgVersion // for cli output
+    if (spec) {
+      pkgVersion = spec.type === 'version' ? `@${spec.rawSpec}` : ''
+    } else {
+      spec = npa.resolve(manifest.name, manifest.version)
+      log.verbose('unpublish', manifest)
+      pkgVersion = manifest.version ? `@${manifest.version}` : ''
+      if (!manifest.version && !force) {
+        throw this.usageError('Refusing to delete entire project.\nRun with --force to do this.')
+      }
+    }
+
+    // If localPrefix has a package.json with a name that matches the package being unpublished, load up the publishConfig
+    if (manifest?.name === spec.name && manifest.publishConfig) {
+      const cliFlags = this.npm.config.data.get('cli').raw
+      // Filter out properties set in CLI flags to prioritize them over corresponding `publishConfig` settings
+      const filteredPublishConfig = Object.fromEntries(
+        Object.entries(manifest.publishConfig).filter(([key]) => !(key in cliFlags)))
+      for (const key in filteredPublishConfig) {
+        this.npm.config.checkUnknown('publishConfig', key)
+      }
+      flatten(filteredPublishConfig, opts)
+    }
+
+    const versions = await Unpublish.getKeysOfVersions(spec.name, opts)
+    if (versions.length === 1 && spec.rawSpec === versions[0] && !force) {
+      throw this.usageError(LAST_REMAINING_VERSION_ERROR)
+    }
+    if (versions.length === 1) {
+      pkgVersion = ''
+    }
+
+    if (!dryRun) {
+      await otplease(this.npm, opts, o => libunpub(spec, o))
+    }
+    if (!silent) {
+      output.standard(`- ${spec.name}${pkgVersion}`)
+    }
+  }
+
+  async execWorkspaces (args) {
+    await this.setWorkspaces()
+
+    for (const path of this.workspacePaths) {
+      await this.exec(args, { localPrefix: path })
+    }
+  }
+}
+
+module.exports = Unpublish
diff --git a/node/node_modules/npm/lib/commands/unstar.js b/node/node_modules/npm/lib/commands/unstar.js
new file mode 100644
index 0000000000000000000000000000000000000000..e152e9bad4cf09960c0d2e286fc0804a509160fe
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/unstar.js
@@ -0,0 +1,8 @@
+const Star = require('./star.js')
+
+class Unstar extends Star {
+  static description = 'Remove an item from your favorite packages'
+  static name = 'unstar'
+}
+
+module.exports = Unstar
diff --git a/node/node_modules/npm/lib/commands/update.js b/node/node_modules/npm/lib/commands/update.js
new file mode 100644
index 0000000000000000000000000000000000000000..d30411bc6b79425a35ecf85c2f53b698b5abed1a
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/update.js
@@ -0,0 +1,66 @@
+const path = require('node:path')
+const { log } = require('proc-log')
+const reifyFinish = require('../utils/reify-finish.js')
+const ArboristWorkspaceCmd = require('../arborist-cmd.js')
+
+class Update extends ArboristWorkspaceCmd {
+  static description = 'Update packages'
+  static name = 'update'
+
+  static params = [
+    'save',
+    'global',
+    'install-strategy',
+    'legacy-bundling',
+    'global-style',
+    'omit',
+    'include',
+    'strict-peer-deps',
+    'package-lock',
+    'foreground-scripts',
+    'ignore-scripts',
+    'audit',
+    'before',
+    'bin-links',
+    'fund',
+    'dry-run',
+    ...super.params,
+  ]
+
+  static usage = ['[<pkg>...]']
+
+  static async completion (opts, npm) {
+    const completion = require('../utils/installed-deep.js')
+    return completion(npm, opts)
+  }
+
+  async exec (args) {
+    const update = args.length === 0 ? true : args
+    const global = path.resolve(this.npm.globalDir, '..')
+    const where = this.npm.global ? global : this.npm.prefix
+
+    // In the context of `npm update` the save config value should default to `false`
+    const save = this.npm.config.isDefault('save')
+      ? false
+      : this.npm.config.get('save')
+
+    if (this.npm.config.get('depth')) {
+      log.warn('update', 'The --depth option no longer has any effect. See RFC0019.\n' +
+        'https://github.com/npm/rfcs/blob/latest/implemented/0019-remove-update-depth-option.md')
+    }
+
+    const Arborist = require('@npmcli/arborist')
+    const opts = {
+      ...this.npm.flatOptions,
+      path: where,
+      save,
+      workspaces: this.workspaceNames,
+    }
+    const arb = new Arborist(opts)
+
+    await arb.reify({ ...opts, update })
+    await reifyFinish(this.npm, arb)
+  }
+}
+
+module.exports = Update
diff --git a/node/node_modules/npm/lib/commands/version.js b/node/node_modules/npm/lib/commands/version.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c4b9dd30ee972db8dfd6756d15dc0824382f4db
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/version.js
@@ -0,0 +1,152 @@
+const { resolve } = require('node:path')
+const { readFile } = require('node:fs/promises')
+const { output } = require('proc-log')
+const BaseCommand = require('../base-cmd.js')
+
+class Version extends BaseCommand {
+  static description = 'Bump a package version'
+  static name = 'version'
+  static params = [
+    'allow-same-version',
+    'commit-hooks',
+    'git-tag-version',
+    'json',
+    'preid',
+    'sign-git-tag',
+    'save',
+    'workspace',
+    'workspaces',
+    'workspaces-update',
+    'include-workspace-root',
+    'ignore-scripts',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+
+  static usage = ['[<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease | from-git]']
+
+  static async completion (opts) {
+    const {
+      conf: {
+        argv: { remain },
+      },
+    } = opts
+    if (remain.length > 2) {
+      return []
+    }
+
+    return [
+      'major',
+      'minor',
+      'patch',
+      'premajor',
+      'preminor',
+      'prepatch',
+      'prerelease',
+      'from-git',
+    ]
+  }
+
+  async exec (args) {
+    switch (args.length) {
+      case 0:
+        return this.list()
+      case 1:
+        return this.change(args)
+      default:
+        throw this.usageError()
+    }
+  }
+
+  async execWorkspaces (args) {
+    switch (args.length) {
+      case 0:
+        return this.listWorkspaces()
+      case 1:
+        return this.changeWorkspaces(args)
+      default:
+        throw this.usageError()
+    }
+  }
+
+  async change (args) {
+    const libnpmversion = require('libnpmversion')
+    const prefix = this.npm.config.get('tag-version-prefix')
+    const version = await libnpmversion(args[0], {
+      ...this.npm.flatOptions,
+      path: this.npm.prefix,
+    })
+    return output.standard(`${prefix}${version}`)
+  }
+
+  async changeWorkspaces (args) {
+    const updateWorkspaces = require('../utils/update-workspaces.js')
+    const libnpmversion = require('libnpmversion')
+    const prefix = this.npm.config.get('tag-version-prefix')
+    const {
+      config,
+      flatOptions,
+      localPrefix,
+    } = this.npm
+    await this.setWorkspaces()
+    const updatedWorkspaces = []
+    for (const [name, path] of this.workspaces) {
+      output.standard(name)
+      const version = await libnpmversion(args[0], {
+        ...flatOptions,
+        'git-tag-version': false,
+        path,
+      })
+      updatedWorkspaces.push(name)
+      output.standard(`${prefix}${version}`)
+    }
+    return updateWorkspaces({
+      config,
+      flatOptions,
+      localPrefix,
+      npm: this.npm,
+      workspaces: updatedWorkspaces,
+    })
+  }
+
+  async list (results = {}) {
+    const pj = resolve(this.npm.prefix, 'package.json')
+
+    const pkg = await readFile(pj, 'utf8')
+      .then(data => JSON.parse(data))
+      .catch(() => ({}))
+
+    if (pkg.name && pkg.version) {
+      results[pkg.name] = pkg.version
+    }
+
+    results.npm = this.npm.version
+    for (const [key, version] of Object.entries(process.versions)) {
+      results[key] = version
+    }
+
+    if (this.npm.config.get('json')) {
+      output.buffer(results)
+    } else {
+      output.standard(results)
+    }
+  }
+
+  async listWorkspaces () {
+    const results = {}
+    await this.setWorkspaces()
+    for (const path of this.workspacePaths) {
+      const pj = resolve(path, 'package.json')
+      // setWorkspaces has already parsed package.json so we know it won't error
+      const pkg = await readFile(pj, 'utf8').then(data => JSON.parse(data))
+
+      if (pkg.name && pkg.version) {
+        results[pkg.name] = pkg.version
+      }
+    }
+    return this.list(results)
+  }
+}
+
+module.exports = Version
diff --git a/node/node_modules/npm/lib/commands/view.js b/node/node_modules/npm/lib/commands/view.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ed17fea2fbcdace228d0965fd9d3fc1d57e0399
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/view.js
@@ -0,0 +1,488 @@
+const { readFile } = require('node:fs/promises')
+const jsonParse = require('json-parse-even-better-errors')
+const { log, output, META } = require('proc-log')
+const npa = require('npm-package-arg')
+const { resolve } = require('node:path')
+const formatBytes = require('../utils/format-bytes.js')
+const relativeDate = require('tiny-relative-date')
+const semver = require('semver')
+const { inspect } = require('node:util')
+const { packument } = require('pacote')
+const Queryable = require('../utils/queryable.js')
+const BaseCommand = require('../base-cmd.js')
+const { getError } = require('../utils/error-message.js')
+const { jsonError, outputError } = require('../utils/output-error.js')
+
+const readJson = file => readFile(file, 'utf8').then(jsonParse)
+
+class View extends BaseCommand {
+  static description = 'View registry info'
+  static name = 'view'
+  static params = [
+    'json',
+    'workspace',
+    'workspaces',
+    'include-workspace-root',
+  ]
+
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+  static usage = ['[<package-spec>] [<field>[.subfield]...]']
+
+  static async completion (opts, npm) {
+    if (opts.conf.argv.remain.length <= 2) {
+      // There used to be registry completion here, but it stopped making sense somewhere around 50,000 packages on the registry
+      return
+    }
+    // have the package, get the fields
+    const config = {
+      ...npm.flatOptions,
+      fullMetadata: true,
+      preferOnline: true,
+      _isRoot: true,
+    }
+    const spec = npa(opts.conf.argv.remain[2])
+    const pckmnt = await packument(spec, config)
+    const defaultTag = npm.config.get('tag')
+    const dv = pckmnt.versions[pckmnt['dist-tags'][defaultTag]]
+    pckmnt.versions = Object.keys(pckmnt.versions).sort(semver.compareLoose)
+
+    return getCompletionFields(pckmnt).concat(getCompletionFields(dv))
+  }
+
+  async exec (args) {
+    let { pkg, local, rest } = parseArgs(args)
+
+    if (local) {
+      if (this.npm.global) {
+        throw new Error('Cannot use view command in global mode.')
+      }
+      const dir = this.npm.prefix
+      const manifest = await readJson(resolve(dir, 'package.json'))
+      if (!manifest.name) {
+        throw new Error('Invalid package.json, no "name" field')
+      }
+      // put the version back if it existed
+      pkg = `${manifest.name}${pkg.slice(1)}`
+    }
+
+    await this.#viewPackage(pkg, rest)
+  }
+
+  async execWorkspaces (args) {
+    const { pkg, local, rest } = parseArgs(args)
+
+    if (!local) {
+      log.warn('Ignoring workspaces for specified package(s)')
+      return this.exec([pkg, ...rest])
+    }
+
+    const json = this.npm.config.get('json')
+    await this.setWorkspaces()
+
+    for (const name of this.workspaceNames) {
+      try {
+        await this.#viewPackage(`${name}${pkg.slice(1)}`, rest, { workspace: true })
+      } catch (e) {
+        const err = getError(e, { npm: this.npm, command: this })
+        if (err.code !== 'E404') {
+          throw e
+        }
+        if (json) {
+          output.buffer({ [META]: true, jsonError: { [name]: jsonError(err, this.npm) } })
+        } else {
+          outputError(err)
+        }
+        process.exitCode = err.exitCode
+      }
+    }
+  }
+
+  async #viewPackage (name, args, { workspace } = {}) {
+    const wholePackument = !args.length
+    const json = this.npm.config.get('json')
+
+    // If we are viewing many packages and outputting individual fields then output the name before doing any async activity
+    if (!json && !wholePackument && workspace) {
+      output.standard(`${name}:`)
+    }
+
+    const [pckmnt, data] = await this.#getData(name, args, wholePackument)
+
+    if (!json && wholePackument) {
+      // pretty view (entire packument)
+      for (const v of data) {
+        output.standard(this.#prettyView(pckmnt, Object.values(v)[0][Queryable.ALL]))
+      }
+      return
+    }
+
+    const res = this.#packageOutput(cleanData(data, wholePackument), pckmnt._id)
+    if (res) {
+      if (json) {
+        output.buffer(workspace ? { [name]: res } : res)
+      } else {
+        output.standard(res)
+      }
+    }
+  }
+
+  async #getData (pkg, args) {
+    const spec = npa(pkg)
+
+    const pckmnt = await packument(spec, {
+      ...this.npm.flatOptions,
+      preferOnline: true,
+      fullMetadata: true,
+      _isRoot: true,
+    })
+
+    // get the data about this package
+    let version = this.npm.config.get('tag')
+    // rawSpec is the git url if this is from git
+    if (spec.type !== 'git' && spec.type !== 'directory' && spec.rawSpec !== '*') {
+      version = spec.rawSpec
+    }
+
+    if (pckmnt['dist-tags']?.[version]) {
+      version = pckmnt['dist-tags'][version]
+    }
+
+    if (pckmnt.time?.unpublished) {
+      const u = pckmnt.time.unpublished
+      throw Object.assign(new Error(`Unpublished on ${u.time}`), {
+        statusCode: 404,
+        code: 'E404',
+        pkgid: pckmnt._id,
+      })
+    }
+
+    const versions = pckmnt.versions || {}
+    pckmnt.versions = Object.keys(versions).filter(v => {
+      if (semver.valid(v)) {
+        return true
+      }
+      log.info('view', `Ignoring invalid version: ${v}`)
+      return false
+    }).sort(semver.compareLoose)
+
+    // remove readme unless we asked for it
+    if (args.indexOf('readme') === -1) {
+      delete pckmnt.readme
+    }
+
+    const data = Object.entries(versions)
+      .filter(([v]) => semver.satisfies(v, version, true))
+      .flatMap(([, v]) => {
+        // remove readme unless we asked for it
+        if (args.indexOf('readme') !== -1) {
+          delete v.readme
+        }
+        return showFields({
+          data: pckmnt,
+          version: v,
+          fields: args,
+          json: this.npm.config.get('json'),
+        })
+      })
+
+    // No data has been pushed because no data is matching the specified version
+    if (!data.length && version !== 'latest') {
+      throw Object.assign(new Error(`No match found for version ${version}`), {
+        statusCode: 404,
+        code: 'E404',
+        pkgid: `${pckmnt._id}@${version}`,
+      })
+    }
+
+    return [pckmnt, data]
+  }
+
+  #packageOutput (data, name) {
+    const json = this.npm.config.get('json')
+    const versions = Object.keys(data)
+    const includeVersions = versions.length > 1
+
+    let includeFields
+    const res = versions.flatMap((v) => {
+      const fields = Object.entries(data[v])
+
+      includeFields ||= (fields.length > 1)
+
+      const msg = json ? {} : []
+
+      for (let [f, d] of fields) {
+        d = cleanup(d)
+
+        if (json) {
+          msg[f] = d
+          continue
+        }
+
+        if (includeVersions || includeFields || typeof d !== 'string') {
+          d = inspect(d, {
+            showHidden: false,
+            depth: 5,
+            colors: this.npm.color,
+            maxArrayLength: null,
+          })
+        }
+
+        if (f && includeFields) {
+          f += ' = '
+        }
+
+        msg.push(`${includeVersions ? `${name}@${v} ` : ''}${includeFields ? f : ''}${d}`)
+      }
+
+      return msg
+    })
+
+    if (json) {
+      // TODO(BREAKING_CHANGE): all unwrapping should be removed.
+      // Users should know based on their arguments if they can expect an array or an object.
+      // And this unwrapping can break that assumption.
+      // e.g. `npm view abbrev@^2` should always return an array, but currently since there is only one version matching `^2` this will return a single object instead.
+      const first = Object.keys(res[0] || {})
+      const jsonRes = first.length === 1 ? res.map(m => m[first[0]]) : res
+      if (jsonRes.length === 0) {
+        return
+      }
+      if (jsonRes.length === 1) {
+        return jsonRes[0]
+      }
+      return jsonRes
+    }
+
+    return res.join('\n').trim()
+  }
+
+  #prettyView (packu, manifest) {
+    // More modern, pretty printing of default view
+    const unicode = this.npm.config.get('unicode')
+    const chalk = this.npm.chalk
+    const deps = Object.entries(manifest.dependencies || {}).map(([k, dep]) =>
+      `${chalk.blue(k)}: ${dep}`
+    )
+
+    // Sort dist-tags by publish time when available, then by tag name, keeping `latest` at the top of the list.
+    const distTags = Object.entries(packu['dist-tags'])
+      .sort(([aTag, aVer], [bTag, bVer]) => {
+        const timeMap = packu.time || {}
+        const aTime = aTag === 'latest' ? Infinity : Date.parse(timeMap[aVer] || 0)
+        const bTime = bTag === 'latest' ? Infinity : Date.parse(timeMap[bVer] || 0)
+        if (aTime === bTime) {
+          return aTag > bTag ? -1 : 1
+        }
+        return aTime > bTime ? -1 : 1
+      })
+      .map(([k, t]) => `${chalk.blue(k)}: ${t}`)
+
+    const site = manifest.homepage?.url || manifest.homepage
+    const bins = Object.keys(manifest.bin || {})
+    const licenseField = manifest.license || 'Proprietary'
+    const license = typeof licenseField === 'string'
+      ? licenseField
+      : (licenseField.type || 'Proprietary')
+
+    const res = []
+
+    res.push('')
+    res.push([
+      chalk.underline.cyan(`${manifest.name}@${manifest.version}`),
+      license.toLowerCase().trim() === 'proprietary'
+        ? chalk.red(license)
+        : chalk.green(license),
+      `deps: ${deps.length ? chalk.cyan(deps.length) : chalk.cyan('none')}`,
+      `versions: ${chalk.cyan(packu.versions.length + '')}`,
+    ].join(' | '))
+
+    manifest.description && res.push(manifest.description)
+    if (site) {
+      res.push(chalk.blue(site))
+    }
+
+    manifest.deprecated && res.push(
+      `\n${chalk.redBright('DEPRECATED')}${unicode ? ' ⚠️ ' : '!!'} - ${manifest.deprecated}`
+    )
+
+    if (packu.keywords?.length) {
+      res.push(`\nkeywords: ${
+        packu.keywords.map(k => chalk.cyan(k)).join(', ')
+      }`)
+    }
+
+    if (bins.length) {
+      res.push(`\nbin: ${chalk.cyan(bins.join(', '))}`)
+    }
+
+    res.push('\ndist')
+    res.push(`.tarball: ${chalk.blue(manifest.dist.tarball)}`)
+    res.push(`.shasum: ${chalk.green(manifest.dist.shasum)}`)
+    if (manifest.dist.integrity) {
+      res.push(`.integrity: ${chalk.green(manifest.dist.integrity)}`)
+    }
+    if (manifest.dist.unpackedSize) {
+      res.push(`.unpackedSize: ${chalk.blue(formatBytes(manifest.dist.unpackedSize, true))}`)
+    }
+
+    if (deps.length) {
+      const maxDeps = 24
+      res.push('\ndependencies:')
+      res.push(deps.slice(0, maxDeps).join(', '))
+      if (deps.length > maxDeps) {
+        res.push(chalk.dim(`(...and ${deps.length - maxDeps} more.)`))
+      }
+    }
+
+    if (packu.maintainers?.length) {
+      res.push('\nmaintainers:')
+      packu.maintainers.forEach(u =>
+        res.push(`- ${unparsePerson({
+          name: chalk.blue(u.name),
+          email: chalk.dim(u.email) })}`)
+      )
+    }
+
+    res.push('\ndist-tags:')
+    const maxTags = 5
+    res.push(distTags.slice(0, maxTags).join('\n'))
+    if (distTags.length > maxTags) {
+      res.push(chalk.dim(`(...and ${distTags.length - maxTags} more.)`))
+    }
+
+    const publisher = manifest._npmUser && unparsePerson({
+      name: chalk.blue(manifest._npmUser.name),
+      email: chalk.dim(manifest._npmUser.email),
+    })
+    if (publisher || packu.time) {
+      let publishInfo = 'published'
+      if (packu.time?.[manifest.version]) {
+        publishInfo += ` ${chalk.cyan(relativeDate(packu.time[manifest.version]))}`
+      }
+      if (publisher) {
+        publishInfo += ` by ${publisher}`
+      }
+      res.push('')
+      res.push(publishInfo)
+    }
+
+    return res.join('\n')
+  }
+}
+
+module.exports = View
+
+function parseArgs (args) {
+  if (!args.length) {
+    args = ['.']
+  }
+
+  const pkg = args.shift()
+
+  return {
+    pkg,
+    local: /^\.@/.test(pkg) || pkg === '.',
+    rest: args,
+  }
+}
+
+function cleanData (obj, wholePackument) {
+  // JSON formatted output (JSON or specific attributes from packument)
+  const data = obj.reduce((acc, cur) => {
+    if (cur) {
+      Object.entries(cur).forEach(([k, v]) => {
+        acc[k] ||= {}
+        Object.keys(v).forEach((t) => {
+          acc[k][t] = cur[k][t]
+        })
+      })
+    }
+    return acc
+  }, {})
+
+  if (wholePackument) {
+    const cleaned = Object.entries(data).reduce((acc, [k, v]) => {
+      acc[k] = v[Queryable.ALL]
+      return acc
+    }, {})
+    log.silly('view', cleaned)
+    return cleaned
+  }
+
+  return data
+}
+
+// return whatever was printed
+function showFields ({ data, version, fields, json }) {
+  const o = [data, version].reduce((acc, s) => {
+    Object.entries(s).forEach(([k, v]) => {
+      acc[k] = v
+    })
+    return acc
+  }, {})
+
+  const queryable = new Queryable(o)
+
+  if (!fields.length) {
+    return { [version.version]: queryable.query(Queryable.ALL) }
+  }
+
+  return fields.map((field) => {
+    const s = queryable.query(field, { unwrapSingleItemArrays: !json })
+    if (s) {
+      return { [version.version]: s }
+    }
+  })
+}
+
+function cleanup (data) {
+  if (Array.isArray(data)) {
+    return data.map(cleanup)
+  }
+
+  if (!data || typeof data !== 'object') {
+    return data
+  }
+
+  const keys = Object.keys(data)
+
+  if (keys.length <= 3 && data.name && (
+    (keys.length === 1) ||
+    (keys.length === 3 && data.email && data.url) ||
+    (keys.length === 2 && (data.email || data.url)) ||
+    data.trustedPublisher
+  )) {
+    data = unparsePerson(data)
+  }
+
+  return data
+}
+
+const unparsePerson = (d) =>
+  `${d.name}${d.email ? ` <${d.email}>` : ''}${d.url ? ` (${d.url})` : ''}`
+
+function getCompletionFields (d, f = [], pref = []) {
+  Object.entries(d).forEach(([k, v]) => {
+    if (k.charAt(0) === '_' || k.indexOf('.') !== -1) {
+      return
+    }
+    const p = pref.concat(k).join('.')
+    f.push(p)
+    if (Array.isArray(v)) {
+      v.forEach((val, i) => {
+        const pi = p + '[' + i + ']'
+        if (val && typeof val === 'object') {
+          getCompletionFields(val, f, [p])
+        } else {
+          f.push(pi)
+        }
+      })
+      return
+    }
+    if (typeof v === 'object') {
+      getCompletionFields(v, f, [p])
+    }
+  })
+  return f
+}
diff --git a/node/node_modules/npm/lib/commands/whoami.js b/node/node_modules/npm/lib/commands/whoami.js
new file mode 100644
index 0000000000000000000000000000000000000000..dbeb9160b3d78da022327e6085a92b862a3852d9
--- /dev/null
+++ b/node/node_modules/npm/lib/commands/whoami.js
@@ -0,0 +1,20 @@
+const { output } = require('proc-log')
+const getIdentity = require('../utils/get-identity.js')
+const BaseCommand = require('../base-cmd.js')
+
+class Whoami extends BaseCommand {
+  static description = 'Display npm username'
+  static name = 'whoami'
+  static params = ['registry']
+
+  async exec () {
+    const username = await getIdentity(this.npm, { ...this.npm.flatOptions })
+    if (this.npm.config.get('json')) {
+      output.buffer(username)
+    } else {
+      output.standard(username)
+    }
+  }
+}
+
+module.exports = Whoami
diff --git a/node/node_modules/npm/lib/utils/audit-error.js b/node/node_modules/npm/lib/utils/audit-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..60c8824baa0c9adb85b30c7de43148c7ef5777dc
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/audit-error.js
@@ -0,0 +1,40 @@
+const { log, output } = require('proc-log')
+const { redactLog: replaceInfo } = require('@npmcli/redact')
+
+// Print an error or just nothing if the audit report has an error.
+// This is called by the audit command, and by the reify-output util prints a JSON version of the error if it's --json.
+// Returns 'true' if there was an error, false otherwise.
+
+const auditError = (npm, report) => {
+  if (!report?.error) {
+    return false
+  }
+
+  if (npm.command !== 'audit') {
+    return true
+  }
+
+  const { error } = report
+
+  // ok, we care about it, then
+  log.warn('audit', error.message)
+  const { body: errBody } = error
+  const body = Buffer.isBuffer(errBody) ? errBody.toString() : errBody
+  if (npm.flatOptions.json) {
+    output.buffer({
+      message: error.message,
+      method: error.method,
+      uri: replaceInfo(error.uri),
+      headers: error.headers,
+      statusCode: error.statusCode,
+      body,
+    })
+  } else {
+    output.standard(body)
+  }
+
+  // XXX we should throw a real error here
+  throw 'audit endpoint returned an error'
+}
+
+module.exports = auditError
diff --git a/node/node_modules/npm/lib/utils/auth.js b/node/node_modules/npm/lib/utils/auth.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad1cb61b496515baeaffc8e68a41ef41b843e1e3
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/auth.js
@@ -0,0 +1,108 @@
+const { webAuthOpener, adduserWeb, loginWeb, loginCouch, adduserCouch } = require('npm-profile')
+const { log } = require('proc-log')
+const { createOpener } = require('../utils/open-url.js')
+const read = require('../utils/read-user-info.js')
+
+const otplease = async (npm, opts, fn) => {
+  try {
+    return await fn(opts)
+  } catch (err) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      throw err
+    }
+
+    // web otp
+    if (err.code === 'EOTP' && err.body?.authUrl && err.body?.doneUrl) {
+      const { token: otp } = await webAuthOpener(
+        createOpener(npm, 'Authenticate your account at'),
+        err.body.authUrl,
+        err.body.doneUrl,
+        opts
+      )
+      return await fn({ ...opts, otp })
+    }
+
+    // classic otp
+    if (err.code === 'EOTP' || (err.code === 'E401' && /one-time pass/.test(err.body))) {
+      const otp = await read.otp('This operation requires a one-time password.\nEnter OTP:')
+      return await fn({ ...opts, otp })
+    }
+
+    throw err
+  }
+}
+
+const adduser = async (npm, { creds, ...opts }) => {
+  const authType = npm.config.get('auth-type')
+  let res
+  if (authType === 'web') {
+    try {
+      res = await adduserWeb(createOpener(npm, 'Create your account at'), opts)
+    } catch (err) {
+      if (err.code === 'ENYI') {
+        log.verbose('web add user not supported, trying couch')
+      } else {
+        throw err
+      }
+    }
+  }
+
+  // auth type !== web or ENYI error w/ web adduser
+  if (!res) {
+    const username = await read.username('Username:', creds.username)
+    const password = await read.password('Password:', creds.password)
+    const email = await read.email('Email (this will be public):', creds.email)
+    // npm registry quirk:
+    // If you "add" an existing user with their current password, it's effectively a login, and if that account has otp you'll be prompted for it.
+    res = await otplease(npm, opts, (reqOpts) => adduserCouch(username, email, password, reqOpts))
+  }
+
+  // We don't know the username if it was a web login, all we can reliably log is scope and registry
+  const message = `Logged in${opts.scope ? ` to scope ${opts.scope}` : ''} on ${opts.registry}.`
+
+  log.info('adduser', message)
+
+  return {
+    message,
+    newCreds: { token: res.token },
+  }
+}
+
+const login = async (npm, { creds, ...opts }) => {
+  const authType = npm.config.get('auth-type')
+  let res
+  if (authType === 'web') {
+    try {
+      res = await loginWeb(createOpener(npm, 'Login at'), opts)
+    } catch (err) {
+      if (err.code === 'ENYI') {
+        log.verbose('web login not supported, trying couch')
+      } else {
+        throw err
+      }
+    }
+  }
+
+  // auth type !== web or ENYI error w/ web login
+  if (!res) {
+    const username = await read.username('Username:', creds.username)
+    const password = await read.password('Password:', creds.password)
+    res = await otplease(npm, opts, (reqOpts) => loginCouch(username, password, reqOpts))
+  }
+
+  // We don't know the username if it was a web login, all we can reliably log is scope and registry
+  const message = `Logged in${opts.scope ? ` to scope ${opts.scope}` : ''} on ${opts.registry}.`
+
+  log.info('login', message)
+
+  return {
+    message,
+    newCreds: { token: res.token },
+  }
+}
+
+module.exports = {
+  adduser,
+  login,
+  otplease,
+}
diff --git a/node/node_modules/npm/lib/utils/cmd-list.js b/node/node_modules/npm/lib/utils/cmd-list.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ac79b29d3030c7f2b98857a954b43d59386a03e
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/cmd-list.js
@@ -0,0 +1,179 @@
+const abbrev = require('abbrev')
+
+// These correspond to filenames in lib/commands
+// Please keep this list sorted alphabetically
+const commands = [
+  'access',
+  'adduser',
+  'audit',
+  'bugs',
+  'cache',
+  'ci',
+  'completion',
+  'config',
+  'dedupe',
+  'deprecate',
+  'diff',
+  'dist-tag',
+  'docs',
+  'doctor',
+  'edit',
+  'exec',
+  'explain',
+  'explore',
+  'find-dupes',
+  'fund',
+  'get',
+  'help',
+  'help-search',
+  'init',
+  'install',
+  'install-ci-test',
+  'install-test',
+  'link',
+  'll',
+  'login',
+  'logout',
+  'ls',
+  'org',
+  'outdated',
+  'owner',
+  'pack',
+  'ping',
+  'pkg',
+  'prefix',
+  'profile',
+  'prune',
+  'publish',
+  'query',
+  'rebuild',
+  'repo',
+  'restart',
+  'root',
+  'run',
+  'sbom',
+  'search',
+  'set',
+  'shrinkwrap',
+  'star',
+  'stars',
+  'start',
+  'stop',
+  'team',
+  'test',
+  'token',
+  'trust',
+  'undeprecate',
+  'uninstall',
+  'unpublish',
+  'unstar',
+  'update',
+  'version',
+  'view',
+  'whoami',
+]
+
+// These must resolve to an entry in commands
+const aliases = {
+
+  // aliases
+  author: 'owner',
+  home: 'docs',
+  issues: 'bugs',
+  info: 'view',
+  show: 'view',
+  find: 'search',
+  add: 'install',
+  unlink: 'uninstall',
+  remove: 'uninstall',
+  rm: 'uninstall',
+  r: 'uninstall',
+
+  // short names for common things
+  un: 'uninstall',
+  rb: 'rebuild',
+  list: 'ls',
+  ln: 'link',
+  create: 'init',
+  i: 'install',
+  it: 'install-test',
+  cit: 'install-ci-test',
+  u: 'update',
+  up: 'update',
+  c: 'config',
+  s: 'search',
+  se: 'search',
+  tst: 'test',
+  t: 'test',
+  ddp: 'dedupe',
+  v: 'view',
+  'run-script': 'run',
+  'clean-install': 'ci',
+  'clean-install-test': 'install-ci-test',
+  x: 'exec',
+  why: 'explain',
+  la: 'll',
+  verison: 'version',
+  ic: 'ci',
+
+  // typos
+  innit: 'init',
+  // manually abbrev so that install-test doesn't make insta stop working
+  in: 'install',
+  ins: 'install',
+  inst: 'install',
+  insta: 'install',
+  instal: 'install',
+  isnt: 'install',
+  isnta: 'install',
+  isntal: 'install',
+  isntall: 'install',
+  'install-clean': 'ci',
+  'isntall-clean': 'ci',
+  hlep: 'help',
+  'dist-tags': 'dist-tag',
+  upgrade: 'update',
+  udpate: 'update',
+  rum: 'run',
+  sit: 'install-ci-test',
+  urn: 'run',
+  ogr: 'org',
+  'add-user': 'adduser',
+}
+
+const deref = (c) => {
+  if (!c) {
+    return
+  }
+
+  // Translate camelCase to snake-case (i.e. installTest to install-test)
+  if (c.match(/[A-Z]/)) {
+    c = c.replace(/([A-Z])/g, m => '-' + m.toLowerCase())
+  }
+
+  // if they asked for something exactly we are done
+  if (commands.includes(c)) {
+    return c
+  }
+
+  // if they asked for a direct alias
+  if (aliases[c]) {
+    return aliases[c]
+  }
+
+  const abbrevs = abbrev(commands.concat(Object.keys(aliases)))
+
+  // first deref the abbrev,
+  // if there is one then resolve any aliases so `npm install-cl` will resolve to `install-clean` then to `ci`
+  let a = abbrevs[c]
+  while (aliases[a]) {
+    a = aliases[a]
+  }
+  return a
+}
+
+module.exports = {
+  aliases,
+  commands,
+  deref,
+}
diff --git a/node/node_modules/npm/lib/utils/completion.fish b/node/node_modules/npm/lib/utils/completion.fish
new file mode 100644
index 0000000000000000000000000000000000000000..c83d43a7787c1b02f9eaf2882a7895cef861883b
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/completion.fish
@@ -0,0 +1,40 @@
+# npm completions for Fish shell
+# This script is a work in progress and does not fall under the normal semver contract as the rest of npm.
+
+# __fish_npm_needs_command taken from:
+# https://stackoverflow.com/questions/16657803/creating-autocomplete-script-with-sub-commands
+function __fish_npm_needs_command
+    set -l cmd (commandline -opc)
+
+    if test (count $cmd) -eq 1
+        return 0
+    end
+
+    return 1
+end
+
+# Taken from https://github.com/fish-shell/fish-shell/blob/HEAD/share/completions/npm.fish
+function __fish_complete_npm -d "Complete the commandline using npm's 'completion' tool"
+    # tell npm we are fish shell
+    set -lx COMP_FISH true
+    if command -sq npm
+        # npm completion is bash-centric, so we need to translate fish's "commandline" stuff to bash's $COMP_* stuff
+        # COMP_LINE is an array with the words in the commandline
+        set -lx COMP_LINE (commandline -opc)
+        # COMP_CWORD is the index of the current word in COMP_LINE
+        # bash starts arrays with 0, so subtract 1
+        set -lx COMP_CWORD (math (count $COMP_LINE) - 1)
+        # COMP_POINT is the index of point/cursor when the commandline is viewed as a string
+        set -lx COMP_POINT (commandline -C)
+        # If the cursor is after the last word, the empty token will disappear in the expansion
+        # Readd it
+        if test (commandline -ct) = ""
+            set COMP_CWORD (math $COMP_CWORD + 1)
+            set COMP_LINE $COMP_LINE ""
+        end
+        command npm completion -- $COMP_LINE 2>/dev/null
+    end
+end
+
+# flush out what ships with fish
+complete -e npm
diff --git a/node/node_modules/npm/lib/utils/completion.sh b/node/node_modules/npm/lib/utils/completion.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c7d72ee9663f496886b236530ed54abe1788d25b
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/completion.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+###-begin-npm-completion-###
+#
+# npm command completion script
+#
+# Installation: npm completion >> ~/.bashrc  (or ~/.zshrc)
+# Or, maybe: npm completion > /usr/local/etc/bash_completion.d/npm
+#
+
+if type complete &>/dev/null; then
+  _npm_completion () {
+    local words cword
+    if type _get_comp_words_by_ref &>/dev/null; then
+      _get_comp_words_by_ref -n = -n @ -n : -w words -i cword
+    else
+      cword="$COMP_CWORD"
+      words=("${COMP_WORDS[@]}")
+    fi
+
+    local si="$IFS"
+    if ! IFS=$'\n' COMPREPLY=($(COMP_CWORD="$cword" \
+                           COMP_LINE="$COMP_LINE" \
+                           COMP_POINT="$COMP_POINT" \
+                           npm completion -- "${words[@]}" \
+                           2>/dev/null)); then
+      local ret=$?
+      IFS="$si"
+      return $ret
+    fi
+    IFS="$si"
+    if type __ltrim_colon_completions &>/dev/null; then
+      __ltrim_colon_completions "${words[cword]}"
+    fi
+  }
+  complete -o default -F _npm_completion npm
+elif type compdef &>/dev/null; then
+  _npm_completion() {
+    local si=$IFS
+    compadd -- $(COMP_CWORD=$((CURRENT-1)) \
+                 COMP_LINE=$BUFFER \
+                 COMP_POINT=0 \
+                 npm completion -- "${words[@]}" \
+                 2>/dev/null)
+    IFS=$si
+  }
+  compdef _npm_completion npm
+elif type compctl &>/dev/null; then
+  _npm_completion () {
+    local cword line point words si
+    read -Ac words
+    read -cn cword
+    let cword-=1
+    read -l line
+    read -ln point
+    si="$IFS"
+    if ! IFS=$'\n' reply=($(COMP_CWORD="$cword" \
+                       COMP_LINE="$line" \
+                       COMP_POINT="$point" \
+                       npm completion -- "${words[@]}" \
+                       2>/dev/null)); then
+
+      local ret=$?
+      IFS="$si"
+      return $ret
+    fi
+    IFS="$si"
+  }
+  compctl -K _npm_completion npm
+fi
+###-end-npm-completion-###
diff --git a/node/node_modules/npm/lib/utils/did-you-mean.js b/node/node_modules/npm/lib/utils/did-you-mean.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb96320ceff157a8f2c72b270db6ed8d2f7c75e8
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/did-you-mean.js
@@ -0,0 +1,33 @@
+const Npm = require('../npm')
+const { distance } = require('fastest-levenshtein')
+const { commands } = require('./cmd-list.js')
+
+const runScripts = ['stop', 'start', 'test', 'restart']
+
+const isClose = (scmd, cmd) => distance(scmd, cmd) < scmd.length * 0.4
+
+const didYouMean = (pkg, scmd) => {
+  const { scripts = {}, bin = {} } = pkg || {}
+
+  const best = [
+    ...commands
+      .filter(cmd => isClose(scmd, cmd) && scmd !== cmd)
+      .map(str => [str, Npm.cmd(str).description]),
+    ...Object.keys(scripts)
+      // We would already be suggesting this in `npm x` so omit them here
+      .filter(cmd => isClose(scmd, cmd) && !runScripts.includes(cmd))
+      .map(str => [`run ${str}`, `run the "${str}" package script`]),
+    ...Object.keys(bin)
+      .filter(cmd => isClose(scmd, cmd))
+      .map(str => [`exec ${str}`, `run the "${str}" command from either this or a remote npm package`]),
+  ]
+
+  if (best.length === 0) {
+    return ''
+  }
+
+  return `\n\nDid you mean ${best.length === 1 ? 'this' : 'one of these'}?\n` +
+    best.slice(0, 3).map(([msg, comment]) => `  npm ${msg} # ${comment}`).join('\n')
+}
+
+module.exports = didYouMean
diff --git a/node/node_modules/npm/lib/utils/display.js b/node/node_modules/npm/lib/utils/display.js
new file mode 100644
index 0000000000000000000000000000000000000000..84230aa88713acf8965269d8e8d4e3501cbcd0f2
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/display.js
@@ -0,0 +1,553 @@
+const { log, output, input, META } = require('proc-log')
+const { explain } = require('./explain-eresolve.js')
+const { formatWithOptions } = require('./format')
+
+// This is the general approach to color:
+// Eventually this will be exposed somewhere we can refer to these by name.
+// Foreground colors only. Never set the background color.
+/*
+ * Black # (Don't use)
+ * Red # Danger
+ * Green # Success
+ * Yellow # Warning
+ * Blue # Accent
+ * Magenta # Done
+ * Cyan # Emphasis
+ * White # (Don't use)
+ */
+
+// Translates log levels to chalk colors
+const COLOR_PALETTE = ({ chalk: c }) => ({
+  heading: c.bold,
+  title: c.blueBright,
+  timing: c.magentaBright,
+  // loglevels
+  error: c.red,
+  warn: c.yellow,
+  notice: c.cyanBright,
+  http: c.green,
+  info: c.cyan,
+  verbose: c.blue,
+  silly: c.blue.dim,
+})
+
+const LEVEL_OPTIONS = {
+  silent: {
+    index: 0,
+  },
+  error: {
+    index: 1,
+  },
+  warn: {
+    index: 2,
+  },
+  notice: {
+    index: 3,
+  },
+  http: {
+    index: 4,
+  },
+  info: {
+    index: 5,
+  },
+  verbose: {
+    index: 6,
+  },
+  silly: {
+    index: 7,
+  },
+}
+
+const LEVEL_METHODS = {
+  ...LEVEL_OPTIONS,
+  [log.KEYS.timing]: {
+    show: ({ timing, index }) => !!timing && index !== 0,
+  },
+}
+
+const setBlocking = (stream) => {
+  // Copied from https://github.com/yargs/set-blocking
+  // https://raw.githubusercontent.com/yargs/set-blocking/master/LICENSE.txt
+  /* istanbul ignore next - we trust that this works */
+  if (stream._handle && stream.isTTY && typeof stream._handle.setBlocking === 'function') {
+    stream._handle.setBlocking(true)
+  }
+  return stream
+}
+
+// This is the key that is returned to the user for errors
+const ERROR_KEY = 'error'
+// This is the key producers use to indicate that there is a json error that should be merged into the finished output
+const JSON_ERROR_KEY = 'jsonError'
+
+const isPlainObject = (v) => v && typeof v === 'object' && !Array.isArray(v)
+
+const getArrayOrObject = (items) => {
+  if (items.length) {
+    const foundNonObject = items.find(o => !isPlainObject(o))
+    // Non-objects and arrays cant be merged, so just return the first item
+    if (foundNonObject) {
+      return foundNonObject
+    }
+    // We use objects with 0,1,2,etc keys to merge array
+    if (items.every((o, i) => Object.hasOwn(o, i))) {
+      return Object.assign([], ...items)
+    }
+  }
+  // Otherwise its an object with all object items merged together
+  return Object.assign({}, ...items.filter(o => isPlainObject(o)))
+}
+
+const getJsonBuffer = ({ [JSON_ERROR_KEY]: metaError }, buffer) => {
+  const items = []
+  // meta also contains the meta object passed to flush
+  const errors = metaError ? [metaError] : []
+  // index 1 is the meta, 2 is the logged argument
+  for (const [, { [JSON_ERROR_KEY]: error }, obj] of buffer) {
+    if (obj) {
+      items.push(obj)
+    }
+    if (error) {
+      errors.push(error)
+    }
+  }
+
+  if (!items.length && !errors.length) {
+    return null
+  }
+
+  const res = getArrayOrObject(items)
+
+  // This skips any error checking since we can only set an error property on an object that can be stringified
+  // XXX(BREAKING_CHANGE): remove this in favor of always returning an object with result and error keys
+  if (isPlainObject(res) && errors.length) {
+    // This is not ideal.
+    // JSON output has always been keyed at the root with an `error` key, so we cant change that without it being a breaking change. At the same time some commands output arbitrary keys at the top level of the output, such as package names.
+    // So the output could already have the same key. The choice here is to overwrite it with our error since that is (probably?) more important.
+    // XXX(BREAKING_CHANGE): all json output should be keyed under well known keys, eg `result` and `error`
+    if (res[ERROR_KEY]) {
+      log.warn('', `overwriting existing ${ERROR_KEY} on json output`)
+    }
+    res[ERROR_KEY] = getArrayOrObject(errors)
+  }
+
+  return res
+}
+
+const withMeta = (handler) => (level, ...args) => {
+  let meta = {}
+  const last = args.at(-1)
+  if (last && typeof last === 'object' && Object.hasOwn(last, META)) {
+    meta = args.pop()
+  }
+  return handler(level, meta, ...args)
+}
+
+class Display {
+  #logState = {
+    buffering: true,
+    buffer: [],
+  }
+
+  #outputState = {
+    buffering: true,
+    buffer: [],
+  }
+
+  // colors
+  #noColorChalk
+  #stdoutChalk
+  #stdoutColor
+  #stderrChalk
+  #stderrColor
+  #logColors
+
+  // progress
+  #progress
+
+  // options
+  #command
+  #levelIndex
+  #timing
+  #json
+  #heading
+  #silent
+
+  // display streams
+  #stdout
+  #stderr
+
+  #seenNotices = new Set()
+
+  constructor ({ stdout, stderr }) {
+    this.#stdout = setBlocking(stdout)
+    this.#stderr = setBlocking(stderr)
+
+    // Handlers are set immediately so they can buffer all events
+    process.on('log', this.#logHandler)
+    process.on('output', this.#outputHandler)
+    process.on('input', this.#inputHandler)
+    this.#progress = new Progress({ stream: stderr })
+  }
+
+  off () {
+    process.off('log', this.#logHandler)
+    this.#logState.buffer.length = 0
+    process.off('output', this.#outputHandler)
+    this.#outputState.buffer.length = 0
+    process.off('input', this.#inputHandler)
+    this.#progress.off()
+    this.#seenNotices.clear()
+  }
+
+  get chalk () {
+    return {
+      noColor: this.#noColorChalk,
+      stdout: this.#stdoutChalk,
+      stderr: this.#stderrChalk,
+    }
+  }
+
+  async load ({
+    command,
+    heading,
+    json,
+    loglevel,
+    progress,
+    stderrColor,
+    stdoutColor,
+    timing,
+    unicode,
+  }) {
+    const [{ Chalk }, { createSupportsColor }] = await Promise.all([
+      import('chalk'),
+      import('supports-color'),
+    ])
+    // We get the chalk level based on a null stream, meaning chalk will only use what it knows about the environment to get color support since we already determined in our definitions that we want to show colors.
+    const level = Math.max(createSupportsColor(null).level, 1)
+    this.#noColorChalk = new Chalk({ level: 0 })
+    this.#stdoutColor = stdoutColor
+    this.#stdoutChalk = stdoutColor ? new Chalk({ level }) : this.#noColorChalk
+    this.#stderrColor = stderrColor
+    this.#stderrChalk = stderrColor ? new Chalk({ level }) : this.#noColorChalk
+    this.#logColors = COLOR_PALETTE({ chalk: this.#stderrChalk })
+
+    this.#command = command
+    this.#levelIndex = LEVEL_OPTIONS[loglevel].index
+    this.#timing = timing
+    this.#json = json
+    this.#heading = heading
+    this.#silent = this.#levelIndex <= 0
+
+    // Emit resume event on the logs which will flush output
+    log.resume()
+    output.flush()
+    this.#progress.load({
+      unicode,
+      enabled: !!progress && !this.#silent,
+    })
+  }
+
+  // STREAM WRITES
+
+  // Write formatted and (non-)colorized output to streams
+  #write (stream, options, ...args) {
+    const colors = stream === this.#stdout ? this.#stdoutColor : this.#stderrColor
+    const value = formatWithOptions({ colors, ...options }, ...args)
+    this.#progress.write(() => stream.write(value))
+  }
+
+  // HANDLERS
+
+  // Arrow function assigned to a private class field so it can be passed directly as a listener and still reference "this"
+  #logHandler = withMeta((level, meta, ...args) => {
+    switch (level) {
+      case log.KEYS.resume:
+        this.#logState.buffering = false
+        this.#logState.buffer.forEach((item) => this.#tryWriteLog(...item))
+        this.#logState.buffer.length = 0
+        break
+
+      case log.KEYS.pause:
+        this.#logState.buffering = true
+        break
+
+      default:
+        if (this.#logState.buffering) {
+          this.#logState.buffer.push([level, meta, ...args])
+        } else {
+          this.#tryWriteLog(level, meta, ...args)
+        }
+        break
+    }
+  })
+
+  // Arrow function assigned to a private class field so it can be passed directly as a listener and still reference "this"
+  #outputHandler = withMeta((level, meta, ...args) => {
+    this.#json = typeof meta.json === 'boolean' ? meta.json : this.#json
+    switch (level) {
+      case output.KEYS.flush: {
+        this.#outputState.buffering = false
+        if (this.#json) {
+          const json = getJsonBuffer(meta, this.#outputState.buffer)
+          if (json) {
+            this.#writeOutput(output.KEYS.standard, meta, JSON.stringify(json, null, 2))
+          }
+        } else {
+          this.#outputState.buffer.forEach((item) => this.#writeOutput(...item))
+        }
+        this.#outputState.buffer.length = 0
+        break
+      }
+
+      case output.KEYS.buffer:
+        this.#outputState.buffer.push([output.KEYS.standard, meta, ...args])
+        break
+
+      default:
+        if (this.#outputState.buffering) {
+          this.#outputState.buffer.push([level, meta, ...args])
+        } else {
+          // XXX: Check if the argument looks like a run-script banner.  This should be replaced with proc-log.META in @npmcli/run-script
+          if (typeof args[0] === 'string' && args[0].startsWith('\n> ') && args[0].endsWith('\n')) {
+            if (this.#silent || ['exec', 'explore'].includes(this.#command)) {
+              // Silent mode and some specific commands always hide run script banners
+              break
+            } else if (this.#json) {
+              // In json mode, change output to stderr since we don't want to break json parsing on stdout if the user is piping to jq or something.
+              // XXX: in a future (breaking?) change it might make sense for run-script to always output these banners with proc-log.output.error if we think they align closer with "logging" instead of "output".
+              level = output.KEYS.error
+            }
+          }
+          this.#writeOutput(level, meta, ...args)
+        }
+        break
+    }
+  })
+
+  #inputHandler = withMeta((level, meta, ...args) => {
+    switch (level) {
+      case input.KEYS.start:
+        log.pause()
+        this.#outputState.buffering = true
+        this.#progress.off()
+        break
+
+      case input.KEYS.end: {
+        log.resume()
+        // For silent prompts (like password), add newline to preserve output
+        if (meta?.silent) {
+          output.standard()
+        }
+        output.flush()
+        this.#progress.resume()
+        break
+      }
+
+      case input.KEYS.read: {
+        // The convention when calling input.read is to pass in a single fn that returns the promise to await. Resolve and reject are provided by proc-log.
+        const [res, rej, p] = args
+
+        // Use sequential input management to avoid race condition which causes issues with spinner and adding newlines.
+        input.start()
+
+        return p()
+          .then((result) => {
+            // If user hits enter, process end event and return input.
+            input.end({ [META]: true, silent: meta?.silent })
+            res(result)
+            return result
+          })
+          .catch((error) => {
+            // If user hits ctrl+c, add newline to preserve output.
+            output.standard()
+            input.end()
+            rej(error)
+          })
+      }
+    }
+  })
+
+  // OUTPUT
+
+  #writeOutput (level, meta, ...args) {
+    switch (level) {
+      case output.KEYS.standard:
+        this.#write(this.#stdout, meta, ...args)
+        break
+
+      case output.KEYS.error:
+        this.#write(this.#stderr, meta, ...args)
+        break
+    }
+  }
+
+  // LOGS
+
+  #tryWriteLog (level, meta, ...args) {
+    try {
+      // Also (and this is a really inexcusable kludge), we patch the log.warn() method so that when we see a peerDep override explanation from Arborist, we can replace the object with a highly abbreviated explanation of what's being overridden.
+      // TODO: this could probably be moved to arborist now that display is refactored
+      const [heading, message, expl] = args
+      if (level === log.KEYS.warn && heading === 'ERESOLVE' && expl && typeof expl === 'object') {
+        this.#writeLog(level, meta, heading, message)
+        this.#writeLog(level, meta, '', explain(expl, this.#stderrChalk, 2))
+        return
+      }
+      this.#writeLog(level, meta, ...args)
+    } catch (ex) {
+      try {
+        // if it crashed once, it might again!
+        this.#writeLog(log.KEYS.verbose, meta, '', `attempt to log crashed`, ...args, ex)
+      } catch (ex2) {
+        // This happens if the object has an inspect method that crashes so just console.error with the errors but don't do anything else that might error again.
+        // eslint-disable-next-line no-console
+        console.error(`attempt to log crashed`, ex, ex2)
+      }
+    }
+  }
+
+  #writeLog (level, meta, ...args) {
+    const levelOpts = LEVEL_METHODS[level]
+    const show = levelOpts.show ?? (({ index }) => levelOpts.index <= index)
+    const force = meta.force && !this.#silent
+
+    if (force || show({ index: this.#levelIndex, timing: this.#timing })) {
+      // this mutates the array so we can pass args directly to format later
+      const title = args.shift()
+      const prefix = [
+        this.#logColors.heading(this.#heading),
+        this.#logColors[level](level),
+        title ? this.#logColors.title(title) : null,
+      ]
+      const writeOpts = { prefix }
+      // notice logs typically come from `npm-notice` headers in responses.  Some of them have 2fa login links so we skip redaction.
+      if (level === 'notice') {
+        writeOpts.redact = false
+        // Deduplicate notices within a single command execution, unless in verbose mode
+        if (this.#levelIndex < LEVEL_OPTIONS.verbose.index) {
+          const noticeKey = JSON.stringify([title, ...args])
+          if (this.#seenNotices.has(noticeKey)) {
+            return
+          }
+          this.#seenNotices.add(noticeKey)
+        }
+      }
+      this.#write(this.#stderr, writeOpts, ...args)
+    }
+  }
+}
+
+class Progress {
+  // Taken from https://github.com/sindresorhus/cli-spinners
+  // MIT License
+  // Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+  static dots = { duration: 80, frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] }
+  static lines = { duration: 130, frames: ['-', '\\', '|', '/'] }
+
+  #enabled = false
+  #frameIndex = 0
+  #interval
+  #lastUpdate = 0
+  #spinner
+  #stream
+  // Initial timeout to wait to start rendering
+  #timeout
+  #rendered = false
+
+  // We are rendering if enabled option is set and we are not waiting for the render timeout
+  get #rendering () {
+    return this.#enabled && !this.#timeout
+  }
+
+  // We are spinning if enabled option is set and the render interval has been set
+  get #spinning () {
+    return this.#enabled && this.#interval
+  }
+
+  constructor ({ stream }) {
+    this.#stream = stream
+  }
+
+  load ({ enabled, unicode }) {
+    this.#enabled = enabled
+    this.#spinner = unicode ? Progress.dots : Progress.lines
+    // Wait 200 ms so we don't render the spinner for short durations
+    this.#timeout = setTimeout(() => {
+      this.#timeout = null
+      this.#render()
+    }, 200)
+    // Make sure this timeout does not keep the process open
+    this.#timeout.unref()
+  }
+
+  off () {
+    if (!this.#enabled) {
+      return
+    }
+    clearTimeout(this.#timeout)
+    this.#timeout = null
+    clearInterval(this.#interval)
+    this.#interval = null
+    this.#frameIndex = 0
+    this.#lastUpdate = 0
+    this.#clearSpinner()
+  }
+
+  resume () {
+    this.#render(true)
+  }
+
+  // If we are currently rendering the spinner we clear it before writing our line and then re-render the spinner after.
+  // If not then all we need to do is write the line.
+  write (write) {
+    if (this.#spinning) {
+      this.#clearSpinner()
+    }
+    write()
+    if (this.#spinning) {
+      this.#render()
+    }
+  }
+
+  #render (resuming) {
+    if (!this.#rendering) {
+      return
+    }
+    // We always attempt to render immediately but we only request to move to the next frame if it has been longer than our spinner frame duration since our last update
+    this.#renderFrame(Date.now() - this.#lastUpdate >= this.#spinner.duration, resuming)
+    if (!this.#interval) {
+      this.#interval = setInterval(() => this.#renderFrame(true), this.#spinner.duration)
+      // Make sure this timeout does not keep the process open
+      this.#interval.unref()
+    }
+    this.#interval.refresh()
+  }
+
+  #renderFrame (next, resuming) {
+    if (next) {
+      this.#lastUpdate = Date.now()
+      this.#frameIndex++
+      if (this.#frameIndex >= this.#spinner.frames.length) {
+        this.#frameIndex = 0
+      }
+    }
+    if (!resuming) {
+      this.#clearSpinner()
+    }
+    this.#stream.write(this.#spinner.frames[this.#frameIndex])
+    this.#rendered = true
+  }
+
+  #clearSpinner () {
+    if (!this.#rendered) {
+      return
+    }
+    // Move to the start of the line and clear the rest of the line
+    this.#stream.cursorTo(0)
+    this.#stream.clearLine(1)
+    this.#rendered = false
+  }
+}
+
+module.exports = Display
diff --git a/node/node_modules/npm/lib/utils/error-message.js b/node/node_modules/npm/lib/utils/error-message.js
new file mode 100644
index 0000000000000000000000000000000000000000..096a10233f724828864292f10b894e0949e8f92e
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/error-message.js
@@ -0,0 +1,453 @@
+const { format } = require('node:util')
+const { resolve } = require('node:path')
+const { redactLog: replaceInfo } = require('@npmcli/redact')
+const { log } = require('proc-log')
+
+const errorMessage = (er, npm) => {
+  const summary = []
+  const detail = []
+  const files = []
+  let json
+
+  er.message &&= replaceInfo(er.message)
+  er.stack &&= replaceInfo(er.stack)
+
+  switch (er.code) {
+    case 'ERESOLVE': {
+      const { report } = require('./explain-eresolve.js')
+      summary.push(['ERESOLVE', er.message])
+      detail.push(['', ''])
+      // XXX(display): error messages are logged so we use the logColor since that is based on stderr.
+      // This should be handled solely by the display layer so it could also be printed to stdout if necessary.
+      const { explanation, file } = report(er, npm.logChalk, npm.noColorChalk)
+      detail.push(['', explanation])
+      files.push(['eresolve-report.txt', file])
+      break
+    }
+
+    case 'ENOLOCK': {
+      const cmd = npm.command || ''
+      summary.push([cmd, 'This command requires an existing lockfile.'])
+      detail.push([cmd, 'Try creating one first with: npm i --package-lock-only'])
+      detail.push([cmd, `Original error: ${er.message}`])
+      break
+    }
+
+    case 'ENOAUDIT':
+      summary.push(['audit', er.message])
+      break
+
+    case 'ECONNREFUSED':
+      summary.push(['', er])
+      detail.push(['', [
+        '',
+        `If you are behind a proxy, please make sure that the 'proxy' config is set properly.  See: 'npm help config'`,
+      ].join('\n')])
+      break
+
+    case 'EACCES':
+    case 'EPERM': {
+      const isCachePath =
+        typeof er.path === 'string' && npm.loaded && er.path.startsWith(npm.config.get('cache'))
+      const isCacheDest =
+        typeof er.dest === 'string' && npm.loaded && er.dest.startsWith(npm.config.get('cache'))
+
+      if (process.platform !== 'win32' && (isCachePath || isCacheDest)) {
+        // user probably doesn't need this, but still add it to the debug log
+        log.verbose(er.stack)
+        summary.push(['', [
+          '',
+          'Your cache folder contains root-owned files, due to a bug in previous versions of npm which has since been addressed.',
+          '',
+          'To permanently fix this problem, please run:',
+          `  sudo chown -R ${process.getuid()}:${process.getgid()} "${npm.config.get('cache')}"`,
+        ].join('\n')])
+      } else {
+        summary.push(['', er])
+        detail.push(['', [
+          '',
+          'The operation was rejected by your operating system.',
+          ...process.platform === 'win32' ? [
+            `It's possible that the file was already in use (by a text editor or antivirus), or that you lack permissions to access it.`,
+          ] : [
+            'It is likely you do not have the permissions to access this file as the current user',
+          ],
+          '',
+          'If you believe this might be a permissions issue, please double-check the permissions of the file and its containing directories, or try running the command again as root/Administrator.',
+        ].join('\n')])
+      }
+      break
+    }
+
+    case 'EALLOWGIT':
+      summary.push(['', er.message])
+      detail.push(['', `Refusing to fetch "${er.package}"`])
+      break
+
+    case 'ENOGIT':
+      summary.push(['', er.message])
+      detail.push(['', [
+        '',
+        'Failed using git.',
+        'Please check if you have git installed and in your PATH.',
+      ].join('\n')])
+      break
+
+    case 'EJSONPARSE':
+      // Check whether we ran into a conflict in our own package.json
+      if (er.path === resolve(npm.prefix, 'package.json')) {
+        const { isDiff } = require('parse-conflict-json')
+        const txt = require('node:fs').readFileSync(er.path, 'utf8').replace(/\r\n/g, '\n')
+        if (isDiff(txt)) {
+          detail.push(['', [
+            'Merge conflict detected in your package.json.',
+            '',
+            'Please resolve the package.json conflict and retry.',
+          ].join('\n')])
+          break
+        }
+      }
+      summary.push(['JSON.parse', er.message])
+      detail.push(['JSON.parse', [
+        'Failed to parse JSON data.',
+        'Note: package.json must be actual JSON, not just JavaScript.',
+      ].join('\n')])
+      break
+
+    case 'EOTP':
+    case 'E401':
+      // E401 is for places where we accidentally neglect OTP stuff
+      if (er.code === 'EOTP' || /one-time pass/.test(er.message)) {
+        const authUrl = er.body?.authUrl
+        const doneUrl = er.body?.doneUrl
+        if (authUrl && doneUrl) {
+          json = { authUrl, doneUrl }
+          summary.push(['', 'This operation requires a one-time password.'])
+          detail.push(['', `Open this URL in your browser to authenticate:`])
+          detail.push(['', `  ${authUrl}`])
+          detail.push(['', ''])
+          detail.push(['', `After authenticating, your token can be retrieved from:`])
+          detail.push(['', `  ${doneUrl}`])
+        } else {
+          summary.push(['', 'This operation requires a one-time password from your authenticator.'])
+          detail.push(['', [
+            'You can provide a one-time password by passing --otp=<code> to the command you ran.',
+            'If you already provided a one-time password then it is likely that you either typoed it, or it timed out. Please try again.',
+          ].join('\n')])
+        }
+      } else {
+        // npm ERR! code E401
+        // npm ERR! Unable to authenticate, need: Basic
+        const auth = !er.headers || !er.headers['www-authenticate']
+          ? []
+          : er.headers['www-authenticate'].map(au => au.split(/[,\s]+/))[0]
+
+        if (auth.includes('Bearer')) {
+          summary.push(['',
+            'Unable to authenticate, your authentication token seems to be invalid.',
+          ])
+          detail.push(['', [
+            'To correct this please try logging in again with:',
+            '  npm login',
+          ].join('\n')])
+        } else if (auth.includes('Basic')) {
+          summary.push(['', 'Incorrect or missing password.'])
+          detail.push(['', [
+            'If you were trying to login, change your password, create an authentication token or enable two-factor authentication then that means you likely typed your password in incorrectly.',
+            'Please try again, or recover your password at:',
+            '  https://www.npmjs.com/forgot',
+            '',
+            'If you were doing some other operation then your saved credentials are probably out of date.',
+            'To correct this please try logging in again with:',
+            '  npm login',
+          ].join('\n')])
+        } else {
+          summary.push(['', er.message || er])
+        }
+      }
+      break
+
+    case 'E404':
+      // There's no need to have 404 in the message as well.
+      summary.push(['404', er.message.replace(/^404\s+/, '')])
+      if (er.pkgid && er.pkgid !== '-') {
+        const pkg = er.pkgid.replace(/(?!^)@.*$/, '')
+
+        detail.push(['404', ''])
+        detail.push([
+          '404',
+          '',
+          `The requested resource '${replaceInfo(er.pkgid)}' could not be found or you do not have permission to access it.`,
+        ])
+
+        const nameValidator = require('validate-npm-package-name')
+        const valResult = nameValidator(pkg)
+
+        if (!valResult.validForNewPackages) {
+          detail.push(['404', 'This package name is not valid, because', ''])
+
+          const errorsArray = [...(valResult.errors || []), ...(valResult.warnings || [])]
+          errorsArray.forEach((item, idx) => detail.push(['404', ' ' + (idx + 1) + '. ' + item]))
+        }
+
+        detail.push(['404', ''])
+        detail.push(['404', 'Note that you can also install from a'])
+        detail.push(['404', 'tarball, folder, http url, or git url.'])
+      }
+      break
+
+    case 'EPUBLISHCONFLICT':
+      summary.push(['publish fail', 'Cannot publish over existing version.'])
+      detail.push(['publish fail', `Update the 'version' field in package.json and try again.`])
+      detail.push(['publish fail', ''])
+      detail.push(['publish fail', 'To automatically increment version numbers, see:'])
+      detail.push(['publish fail', '  npm help version'])
+      break
+
+    case 'EISGIT':
+      summary.push(['git', er.message])
+      summary.push(['git', `  ${er.path}`])
+      detail.push(['git', [
+        'Refusing to remove it. Update manually, or move it out of the way first.',
+      ].join('\n')])
+      break
+
+    case 'EBADDEVENGINES': {
+      const { current, required } = er
+      summary.push(['EBADDEVENGINES', er.message])
+      detail.push(['EBADDEVENGINES', { current, required }])
+      break
+    }
+
+    case 'EBADPLATFORM': {
+      const actual = er.current
+      const expected = { ...er.required }
+      const checkedKeys = []
+      for (const key in expected) {
+        if (Array.isArray(expected[key]) && expected[key].length > 0) {
+          expected[key] = expected[key].join(',')
+          checkedKeys.push(key)
+        } else if (expected[key] === undefined ||
+            Array.isArray(expected[key]) && expected[key].length === 0) {
+          delete expected[key]
+          delete actual[key]
+        } else {
+          checkedKeys.push(key)
+        }
+      }
+
+      const longestKey = Math.max(...checkedKeys.map((key) => key.length))
+      const detailEntry = []
+      for (const key of checkedKeys) {
+        const padding = key.length === longestKey
+          ? 1
+          : 1 + (longestKey - key.length)
+
+        // padding + 1 because 'actual' is longer than 'valid'
+        detailEntry.push(`Valid ${key}:${' '.repeat(padding + 1)}${expected[key]}`)
+        detailEntry.push(`Actual ${key}:${' '.repeat(padding)}${actual[key]}`)
+      }
+
+      summary.push(['notsup', format(
+        'Unsupported platform for %s: wanted %j (current: %j)',
+        er.pkgid,
+        expected,
+        actual
+      )])
+      detail.push(['notsup', detailEntry.join('\n')])
+      break
+    }
+
+    case 'EEXIST':
+      summary.push(['', er.message])
+      summary.push(['', 'File exists: ' + (er.dest || er.path)])
+      detail.push(['', 'Remove the existing file and try again, or run npm'])
+      detail.push(['', 'with --force to overwrite files recklessly.'])
+      break
+
+    case 'ENEEDAUTH':
+      summary.push(['need auth', er.message])
+      detail.push(['need auth', 'You need to authorize this machine using `npm adduser`'])
+      break
+
+    case 'ECONNRESET':
+    case 'ENOTFOUND':
+    case 'ETIMEDOUT':
+    case 'ERR_SOCKET_TIMEOUT':
+    case 'EAI_FAIL':
+      summary.push(['network', er.message])
+      detail.push(['network', [
+        'This is a problem related to network connectivity.',
+        'In most cases you are behind a proxy or have bad network settings.',
+        '',
+        `If you are behind a proxy, please make sure that the 'proxy' config is set properly.  See: 'npm help config'`,
+      ].join('\n')])
+      break
+
+    case 'ETARGET':
+      summary.push(['notarget', er.message])
+      detail.push(['notarget', [
+        `In most cases you or one of your dependencies are requesting a package version that doesn't exist.`,
+      ].join('\n')])
+      break
+
+    case 'E403':
+      summary.push(['403', er.message])
+      detail.push(['403', [
+        'In most cases, you or one of your dependencies are requesting a package version that is forbidden by your security policy, or on a server you do not have access to.',
+      ].join('\n')])
+      break
+
+    case 'EBADENGINE':
+      summary.push(['engine', er.message])
+      summary.push(['engine', 'Not compatible with your version of node/npm: ' + er.pkgid])
+      detail.push(['notsup', [
+        'Not compatible with your version of node/npm: ' + er.pkgid,
+        'Required: ' + JSON.stringify(er.required),
+        'Actual:   ' +
+        JSON.stringify({ node: process.version, npm: npm.version }),
+      ].join('\n')])
+      break
+
+    case 'ENOSPC':
+      summary.push(['nospc', er.message])
+      detail.push(['nospc', [
+        'There appears to be insufficient space on your system to finish.',
+        'Clear up some disk space and try again.',
+      ].join('\n')])
+      break
+
+    case 'EROFS':
+      summary.push(['rofs', er.message])
+      detail.push(['rofs', [
+        `Often virtualized file systems, or other file systems that don't support symlinks, give this error.`,
+      ].join('\n')])
+      break
+
+    case 'ENOENT':
+      summary.push(['enoent', er.message])
+      detail.push(['enoent', [
+        'This is related to npm not being able to find a file.',
+        er.file ? `\nCheck if the file '${er.file}' is present.` : '',
+      ].join('\n')])
+      break
+
+    case 'EMISSINGARG':
+    case 'EUNKNOWNTYPE':
+    case 'EINVALIDTYPE':
+    case 'ETOOMANYARGS':
+      summary.push(['typeerror', er.stack])
+      detail.push(['typeerror', [
+        'This is an error with npm itself. Please report this error at:',
+        'https://github.com/npm/cli/issues',
+      ].join('\n')])
+      break
+
+    default:
+      summary.push(['', er.message || er])
+      if (er.cause) {
+        detail.push(['cause', er.cause.message])
+      }
+      if (er.signal) {
+        detail.push(['signal', er.signal])
+      }
+      if (er.cmd && Array.isArray(er.args)) {
+        detail.push(['command', ...[er.cmd, ...er.args.map(replaceInfo)]])
+      }
+      if (er.stdout) {
+        detail.push(['', er.stdout.trim()])
+      }
+      if (er.stderr) {
+        detail.push(['', er.stderr.trim()])
+      }
+      break
+  }
+
+  return {
+    summary,
+    detail,
+    files,
+    json,
+  }
+}
+
+const getExitCodeFromError = (err) => {
+  if (typeof err?.errno === 'number') {
+    return err.errno
+  } else if (typeof err?.code === 'number') {
+    return err.code
+  }
+}
+
+const getError = (err, { npm, command, pkg }) => {
+  // if we got a command that just shells out to something else, then it will presumably print its own errors and exit with a proper status code if there's a problem.
+  // If we got an error with a code=0, then... something else went wrong along the way, so maybe an npm problem?
+  if (command?.constructor?.isShellout && typeof err.code === 'number' && err.code) {
+    return {
+      exitCode: err.code,
+      suppressError: true,
+    }
+  }
+
+  // XXX: we should stop throwing strings
+  if (typeof err === 'string') {
+    return {
+      exitCode: 1,
+      suppressError: true,
+      summary: [['', err]],
+    }
+  }
+
+  // XXX: we should stop throwing other non-errors
+  if (!(err instanceof Error)) {
+    return {
+      exitCode: 1,
+      suppressError: true,
+      summary: [['weird error', err]],
+    }
+  }
+
+  if (err.code === 'EUNKNOWNCOMMAND') {
+    const suggestions = require('./did-you-mean.js')(pkg, err.command)
+    return {
+      exitCode: 1,
+      suppressError: true,
+      standard: [
+        `Unknown command: "${err.command}"`,
+        suggestions,
+        'To see a list of supported npm commands, run:',
+        '  npm help',
+      ],
+    }
+  }
+
+  // Anything after this is not suppressed and gets more logged information
+
+  // add a code to the error if it doesnt have one and mutate some properties so they have redacted information
+  err.code ??= err.message.match(/^(?:Error: )?(E[A-Z]+)/)?.[1]
+  // this mutates the error and redacts stack/message
+  const { summary, detail, files, json } = errorMessage(err, npm)
+
+  return {
+    err,
+    code: err.code,
+    exitCode: getExitCodeFromError(err) || 1,
+    suppressError: false,
+    summary,
+    detail,
+    files,
+    json,
+    verbose: ['type', 'stack', 'statusCode', 'pkgid']
+      .filter(k => err[k])
+      .map(k => [k, replaceInfo(err[k])]),
+    error: ['code', 'syscall', 'file', 'path', 'dest', 'errno']
+      .filter(k => err[k])
+      .map(k => [k, err[k]]),
+  }
+}
+
+module.exports = {
+  getExitCodeFromError,
+  errorMessage,
+  getError,
+}
diff --git a/node/node_modules/npm/lib/utils/explain-dep.js b/node/node_modules/npm/lib/utils/explain-dep.js
new file mode 100644
index 0000000000000000000000000000000000000000..a76d11e224c9b2c3c1138e39b616ba6f9a2af812
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/explain-dep.js
@@ -0,0 +1,116 @@
+const { relative } = require('node:path')
+
+const explainNode = (node, depth, chalk, seen = new Set()) =>
+  printNode(node, chalk) +
+  explainDependents(node, depth, chalk, seen) +
+  explainLinksIn(node, depth, chalk, seen)
+
+const colorType = (type, chalk) => {
+  const style = type === 'extraneous' ? chalk.red
+    : type === 'dev' ? chalk.blue
+    : type === 'optional' ? chalk.magenta
+    : type === 'peer' ? chalk.magentaBright
+    : type === 'bundled' ? chalk.underline.cyan
+    : type === 'workspace' ? chalk.blueBright
+    : type === 'overridden' ? chalk.dim
+    : /* istanbul ignore next */ s => s
+  return style(type)
+}
+
+const printNode = (node, chalk) => {
+  const extra = []
+
+  for (const meta of ['extraneous', 'dev', 'optional', 'peer', 'bundled', 'overridden']) {
+    if (node[meta]) {
+      extra.push(` ${colorType(meta, chalk)}`)
+    }
+  }
+
+  const pkgid = node.isWorkspace
+    ? chalk.blueBright(`${node.name}@${node.version}`)
+    : `${node.name}@${node.version}`
+
+  return `${pkgid}${extra.join('')}` +
+    (node.location ? chalk.dim(`\n${node.location}`) : '')
+}
+
+const explainLinksIn = ({ linksIn }, depth, chalk, seen) => {
+  if (!linksIn || !linksIn.length || depth <= 0) {
+    return ''
+  }
+
+  const messages = linksIn.map(link => explainNode(link, depth - 1, chalk, seen))
+  const str = '\n' + messages.join('\n')
+  return str.split('\n').join('\n  ')
+}
+
+const explainDependents = ({ dependents }, depth, chalk, seen) => {
+  if (!dependents || !dependents.length || depth <= 0) {
+    return ''
+  }
+
+  const max = Math.ceil(depth / 2)
+  const messages = dependents.slice(0, max)
+    .map(edge => explainEdge(edge, depth, chalk, seen))
+
+  // show just the names of the first 5 deps that overflowed the list
+  if (dependents.length > max) {
+    let len = 0
+    const maxLen = 50
+    const showNames = []
+    for (let i = max; i < dependents.length; i++) {
+      const { from: { name: depName = 'the root project' } } = dependents[i]
+      len += depName.length
+      if (len >= maxLen && i < dependents.length - 1) {
+        showNames.push('...')
+        break
+      }
+      showNames.push(depName)
+    }
+    const show = `(${showNames.join(', ')})`
+    messages.push(`${dependents.length - max} more ${show}`)
+  }
+
+  const str = '\n' + messages.join('\n')
+  return str.split('\n').join('\n  ')
+}
+
+const explainEdge = (
+  { name, type, bundled, from, spec, rawSpec, overridden },
+  depth, chalk, seen = new Set()
+) => {
+  let dep = type === 'workspace'
+    ? chalk.bold(relative(from.location, spec.slice('file:'.length)))
+    : `${name}@"${spec}"`
+  if (overridden) {
+    dep = `${colorType('overridden', chalk)} ${dep} (was "${rawSpec}")`
+  }
+
+  const fromMsg = ` from ${explainFrom(from, depth, chalk, seen)}`
+
+  return (type === 'prod' ? '' : `${colorType(type, chalk)} `) +
+    (bundled ? `${colorType('bundled', chalk)} ` : '') +
+    `${dep}${fromMsg}`
+}
+
+const explainFrom = (from, depth, chalk, seen) => {
+  if (!from.name && !from.version) {
+    return 'the root project'
+  }
+
+  // Prevent infinite recursion from cycles in the dependency graph (e.g. linked strategy store nodes). Use stack-based tracking so diamond dependencies (same node reached via different paths) are still explained, but recursive cycles are broken.
+  const nodeId = `${from.name}@${from.version}:${from.location}`
+  if (seen.has(nodeId)) {
+    return printNode(from, chalk)
+  }
+  seen.add(nodeId)
+
+  const result = printNode(from, chalk) +
+    explainDependents(from, depth - 1, chalk, seen) +
+    explainLinksIn(from, depth - 1, chalk, seen)
+
+  seen.delete(nodeId)
+  return result
+}
+
+module.exports = { explainNode, printNode, explainEdge }
diff --git a/node/node_modules/npm/lib/utils/explain-eresolve.js b/node/node_modules/npm/lib/utils/explain-eresolve.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4b7aa527bbda233bf64fc3b52cedca7cbf056d1
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/explain-eresolve.js
@@ -0,0 +1,64 @@
+// this is called when an ERESOLVE error is caught in the exit-handler, or when there's a log.warn('eresolve', msg, explanation), to turn it into a human-intelligible explanation of what's wrong and how to fix.
+const { explainEdge, explainNode, printNode } = require('./explain-dep.js')
+
+// expl is an explanation object that comes from Arborist.
+// Depth is how far we want to want to descend into the object making a report.
+// The full report (ie, depth=Infinity) is always written to the cache folder at ${cache}/eresolve-report.txt along with full json.
+const explain = (expl, chalk, depth) => {
+  const { edge, dep, current, peerConflict, currentEdge } = expl
+
+  const out = []
+  const whileInstalling = dep && dep.whileInstalling ||
+    current && current.whileInstalling ||
+    edge && edge.from && edge.from.whileInstalling
+  if (whileInstalling) {
+    out.push('While resolving: ' + printNode(whileInstalling, chalk))
+  }
+
+  // it "should" be impossible for an ERESOLVE explanation to lack both current and currentEdge, but better to have a less helpful error than a crashing failure.
+  if (current) {
+    out.push('Found: ' + explainNode(current, depth, chalk))
+  } else if (peerConflict && peerConflict.current) {
+    out.push('Found: ' + explainNode(peerConflict.current, depth, chalk))
+  } else if (currentEdge) {
+    out.push('Found: ' + explainEdge(currentEdge, depth, chalk))
+  } else /* istanbul ignore else - should always have one */ if (edge) {
+    out.push('Found: ' + explainEdge(edge, depth, chalk))
+  }
+
+  out.push('\nCould not resolve dependency:\n' +
+    explainEdge(edge, depth, chalk))
+
+  if (peerConflict) {
+    const heading = '\nConflicting peer dependency:'
+    const pc = explainNode(peerConflict.peer, depth, chalk)
+    out.push(heading + ' ' + pc)
+  }
+
+  return out.join('\n')
+}
+
+// generate a full verbose report and tell the user how to fix it
+const report = (expl, chalk, noColorChalk) => {
+  const flags = [
+    expl.strictPeerDeps ? '--no-strict-peer-deps' : '',
+    '--force',
+    '--legacy-peer-deps',
+  ].filter(Boolean)
+
+  const or = (arr) => arr.length <= 2
+    ? arr.join(' or ') :
+    arr.map((v, i, l) => i + 1 === l.length ? `or ${v}` : v).join(', ')
+
+  const fix = `Fix the upstream dependency conflict, or retry this command with ${or(flags)} to accept an incorrect (and potentially broken) dependency resolution.`
+
+  return {
+    explanation: `${explain(expl, chalk, 4)}\n\n${fix}`,
+    file: `# npm resolution error report\n\n${explain(expl, noColorChalk, Infinity)}\n\n${fix}`,
+  }
+}
+
+module.exports = {
+  explain,
+  report,
+}
diff --git a/node/node_modules/npm/lib/utils/format-bytes.js b/node/node_modules/npm/lib/utils/format-bytes.js
new file mode 100644
index 0000000000000000000000000000000000000000..32866df34cfa5a5013e988fe3e5c2400265f371c
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/format-bytes.js
@@ -0,0 +1,29 @@
+// Convert bytes to printable output, for file reporting in tarballs
+// Only supports up to GB because that's way larger than anything the registry supports anyways.
+
+const formatBytes = (bytes, space = true) => {
+  let spacer = ''
+  if (space) {
+    spacer = ' '
+  }
+
+  if (bytes < 1000) {
+    // B
+    return `${bytes}${spacer}B`
+  }
+
+  if (bytes < 999950) {
+    // kB
+    return `${(bytes / 1000).toFixed(1)}${spacer}kB`
+  }
+
+  if (bytes < 999950000) {
+    // MB
+    return `${(bytes / 1000000).toFixed(1)}${spacer}MB`
+  }
+
+  // GB
+  return `${(bytes / 1000000000).toFixed(1)}${spacer}GB`
+}
+
+module.exports = formatBytes
diff --git a/node/node_modules/npm/lib/utils/format-search-stream.js b/node/node_modules/npm/lib/utils/format-search-stream.js
new file mode 100644
index 0000000000000000000000000000000000000000..c92b3c5aab3c29c123562234a8b97c0af9cb6ad4
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/format-search-stream.js
@@ -0,0 +1,175 @@
+const { stripVTControlCharacters: strip } = require('node:util')
+const { Minipass } = require('minipass')
+
+// This module consumes package data in the following format:
+//
+// {
+//   name: String,
+//   description: String,
+//   maintainers: [{ username: String, email: String }],
+//   keywords: String | [String],
+//   version: String,
+//   date: Date // can be null,
+// }
+//
+// The returned stream will format this package data into a byte stream of formatted, displayable output.
+
+function filter (data, exclude) {
+  const words = [data.name]
+    .concat(data.maintainers.map(m => m.username))
+    .concat(data.keywords || [])
+    .map(f => f?.trim?.())
+    .filter(Boolean)
+    .join(' ')
+    .toLowerCase()
+
+  if (exclude.find(pattern => {
+    // Treats both /foo and /foo/ as regex searches
+    if (pattern.startsWith('/')) {
+      if (pattern.endsWith('/')) {
+        pattern = pattern.slice(0, -1)
+      }
+      return words.match(new RegExp(pattern.slice(1)))
+    }
+    return words.includes(pattern)
+  })) {
+    return false
+  }
+
+  return true
+}
+
+module.exports = (opts) => {
+  return opts.json ? new JSONOutputStream(opts) : new TextOutputStream(opts)
+}
+
+class JSONOutputStream extends Minipass {
+  #didFirst = false
+  #exclude
+
+  constructor (opts) {
+    super()
+    this.#exclude = opts.exclude
+  }
+
+  write (obj) {
+    if (!filter(obj, this.#exclude)) {
+      return
+    }
+    if (!this.#didFirst) {
+      super.write('[\n')
+      this.#didFirst = true
+    } else {
+      super.write('\n,\n')
+    }
+
+    return super.write(JSON.stringify(obj))
+  }
+
+  end () {
+    super.write(this.#didFirst ? ']\n' : '\n[]\n')
+    super.end()
+  }
+}
+
+class TextOutputStream extends Minipass {
+  #args
+  #chalk
+  #exclude
+  #parseable
+
+  constructor (opts) {
+    super()
+    // Consider a search for "cowboys" and "boy".
+    // If we highlight "boys" first the "cowboys" string will no longer string match because of the ansi highlighting added to "boys".
+    // If we highlight "boy" second then the ansi reset at the end will make the highlighting only on "cowboy" with a normal "s".
+    // Neither is perfect but at least the first option doesn't do partial highlighting. So, we sort strings smaller to larger
+    this.#args = opts.args
+      .map(s => s.toLowerCase())
+      .filter(Boolean)
+      .sort((a, b) => a.length - b.length)
+    this.#chalk = opts.npm.chalk
+    this.#exclude = opts.exclude
+    this.#parseable = opts.parseable
+  }
+
+  write (data) {
+    if (!filter(data, this.#exclude)) {
+      return
+    }
+    // Normalize
+    const pkg = {
+      authors: data.maintainers.map((m) => `${strip(m.username)}`).join(' '),
+      publisher: strip(data.publisher?.username || ''),
+      date: data.date ? data.date.toISOString().slice(0, 10) : 'prehistoric',
+      description: strip(data.description ?? ''),
+      keywords: [],
+      name: strip(data.name),
+      version: data.version,
+    }
+    if (Array.isArray(data.keywords)) {
+      pkg.keywords = data.keywords.map(strip)
+    } else if (typeof data.keywords === 'string') {
+      pkg.keywords = strip(data.keywords.replace(/[,\s]+/, ' ')).split(' ')
+    }
+
+    let output
+    if (this.#parseable) {
+      output = [pkg.name, pkg.description, pkg.author, pkg.date, pkg.version, pkg.keywords]
+        .filter(Boolean)
+        .map(col => ('' + col).replace(/\t/g, ' ')).join('\t')
+      return super.write(output)
+    }
+
+    const keywords = pkg.keywords.map(k => {
+      if (this.#args.includes(k)) {
+        return this.#chalk.cyan(k)
+      } else {
+        return k
+      }
+    }).join(' ')
+
+    const description = this.#highlight(pkg.description)
+    let name
+    if (this.#args.includes(pkg.name)) {
+      name = this.#chalk.cyan(pkg.name)
+    } else {
+      name = this.#highlight(pkg.name)
+      name = this.#chalk.blue(name)
+    }
+
+    if (description.length) {
+      output = `${name}\n${description}\n`
+    } else {
+      output = `${name}\n`
+    }
+    if (pkg.publisher) {
+      output += `Version ${this.#chalk.blue(pkg.version)} published ${this.#chalk.blue(pkg.date)} by ${this.#chalk.blue(pkg.publisher)}\n`
+    } else {
+      output += `Version ${this.#chalk.blue(pkg.version)} published ${this.#chalk.blue(pkg.date)} by ${this.#chalk.yellow('???')}\n`
+    }
+    output += `Maintainers: ${pkg.authors}\n`
+    if (keywords) {
+      output += `Keywords: ${keywords}\n`
+    }
+    output += `${this.#chalk.blue(`https://npm.im/${pkg.name}`)}\n`
+    return super.write(output)
+  }
+
+  #highlight (input) {
+    let output = input
+    for (const arg of this.#args) {
+      let i = output.toLowerCase().indexOf(arg)
+      while (i > -1) {
+        const highlit = this.#chalk.cyan(output.slice(i, i + arg.length))
+        output = [
+          output.slice(0, i),
+          highlit,
+          output.slice(i + arg.length),
+        ].join('')
+        i = output.toLowerCase().indexOf(arg, i + highlit.length)
+      }
+    }
+    return output
+  }
+}
diff --git a/node/node_modules/npm/lib/utils/format.js b/node/node_modules/npm/lib/utils/format.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d56b23a05dfbc1cffcda8497d051e72c45d5295
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/format.js
@@ -0,0 +1,56 @@
+// All logging goes through here, both to console and log files
+
+const { formatWithOptions: baseFormatWithOptions } = require('node:util')
+const { redactLog } = require('@npmcli/redact')
+
+// These are most assuredly not a mistake
+// https://eslint.org/docs/latest/rules/no-control-regex
+// \x00 through \x1f, \x7f through \x9f, not including \x09 \x0a \x0b \x0d
+/* eslint-disable-next-line no-control-regex */
+const HAS_C01 = /[\x00-\x08\x0c\x0e-\x1f\x7f-\x9f]/
+
+// Allows everything up to '[38;5;255m' in 8 bit notation
+const ALLOWED_SGR = /^\[[0-9;]{0,8}m/
+
+// '[38;5;255m'.length
+const SGR_MAX_LEN = 10
+
+// Strips all ANSI C0 and C1 control characters (except for SGR up to 8 bit)
+function STRIP_C01 (str) {
+  if (!HAS_C01.test(str)) {
+    return str
+  }
+  let result = ''
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i]
+    const code = char.charCodeAt(0)
+    if (!HAS_C01.test(char)) {
+      // Most characters are in this set so continue early if we can
+      result = `${result}${char}`
+    } else if (code === 27 && ALLOWED_SGR.test(str.slice(i + 1, i + SGR_MAX_LEN + 1))) {
+      // \x1b with allowed SGR
+      result = `${result}\x1b`
+    } else if (code <= 31) {
+      // escape all other C0 control characters besides \x7f
+      result = `${result}^${String.fromCharCode(code + 64)}`
+    } else {
+      // hasC01 ensures this is now a C1 control character or \x7f
+      result = `${result}^${String.fromCharCode(code - 64)}`
+    }
+  }
+  return result
+}
+
+const formatWithOptions = ({ prefix: prefixes = [], eol = '\n', redact = true, ...options }, ...args) => {
+  const prefix = prefixes.filter(p => p != null).join(' ')
+  let formatted = STRIP_C01(baseFormatWithOptions(options, ...args))
+  if (redact) {
+    formatted = redactLog(formatted)
+  }
+  // Splitting could be changed to only `\n` once we are sure we only emit unix newlines.
+  // The eol param to this function will put the correct newlines in place for the returned string.
+  const lines = formatted.split(/\r?\n/)
+  return lines.reduce((acc, l) => `${acc}${prefix}${prefix && l ? ' ' : ''}${l}${eol}`, '')
+}
+
+module.exports = { formatWithOptions }
diff --git a/node/node_modules/npm/lib/utils/get-identity.js b/node/node_modules/npm/lib/utils/get-identity.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2480792ec33999c29cacf13cc0b6e964e07bae7
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/get-identity.js
@@ -0,0 +1,25 @@
+const npmFetch = require('npm-registry-fetch')
+
+module.exports = async (npm, opts) => {
+  const { registry } = opts
+
+  // First, check if we have a user/pass-based auth
+  const creds = npm.config.getCredentialsByURI(registry)
+  if (creds.username) {
+    return creds.username
+  }
+
+  // No username, but we have other credentials; fetch the username from registry
+  if (creds.token || creds.certfile && creds.keyfile) {
+    const registryData = await npmFetch.json('/-/whoami', { ...opts })
+    if (typeof registryData?.username === 'string') {
+      return registryData.username
+    }
+  }
+
+  // At this point, even if they have a credentials object, it doesn't have a valid token.
+  throw Object.assign(
+    new Error('This command requires you to be logged in.'),
+    { code: 'ENEEDAUTH' }
+  )
+}
diff --git a/node/node_modules/npm/lib/utils/get-workspaces.js b/node/node_modules/npm/lib/utils/get-workspaces.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef462da3f127dfcae96768ca0ebf44a363bb7fe3
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/get-workspaces.js
@@ -0,0 +1,54 @@
+const { resolve, relative } = require('node:path')
+const mapWorkspaces = require('@npmcli/map-workspaces')
+const { minimatch } = require('minimatch')
+const pkgJson = require('@npmcli/package-json')
+
+// minimatch wants forward slashes only for glob patterns
+const globify = pattern => pattern.split('\\').join('/')
+
+// Returns an Map of paths to workspaces indexed by workspace name
+// { foo => '/path/to/foo' }
+const getWorkspaces = async (filters, { path, includeWorkspaceRoot, relativeFrom }) => {
+  // TODO we need a better error to be bubbled up here if this call fails
+  const { content: pkg } = await pkgJson.normalize(path)
+  const workspaces = await mapWorkspaces({ cwd: path, pkg })
+  let res = new Map()
+  if (includeWorkspaceRoot) {
+    res.set(pkg.name, path)
+  }
+
+  if (!filters.length) {
+    res = new Map([...res, ...workspaces])
+  }
+
+  for (const filterArg of filters) {
+    for (const [workspaceName, workspacePath] of workspaces.entries()) {
+      let relativePath = relative(relativeFrom, workspacePath)
+      if (filterArg.startsWith('./')) {
+        relativePath = `./${relativePath}`
+      }
+      const relativeFilter = relative(path, filterArg)
+      if (filterArg === workspaceName
+        || resolve(relativeFrom, filterArg) === workspacePath
+        || minimatch(relativePath, `${globify(relativeFilter)}/*`)
+        || minimatch(relativePath, `${globify(filterArg)}/*`)
+      ) {
+        res.set(workspaceName, workspacePath)
+      }
+    }
+  }
+
+  if (!res.size) {
+    let msg = '!'
+    if (filters.length) {
+      msg = `:\n ${filters.reduce(
+        (acc, filterArg) => `${acc} --workspace=${filterArg}`, '')}`
+    }
+
+    throw new Error(`No workspaces found${msg}`)
+  }
+
+  return res
+}
+
+module.exports = getWorkspaces
diff --git a/node/node_modules/npm/lib/utils/installed-deep.js b/node/node_modules/npm/lib/utils/installed-deep.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ccf098b91ff6267232620f4755bb827ed2a6ed3
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/installed-deep.js
@@ -0,0 +1,45 @@
+const { resolve } = require('node:path')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+
+const installedDeep = async (npm) => {
+  const Arborist = require('@npmcli/arborist')
+  const {
+    depth,
+    global,
+    prefix,
+    workspacesEnabled,
+  } = npm.flatOptions
+
+  const getValues = (tree) =>
+    [...tree.inventory.values()]
+      .filter(i => i.location !== '' && !i.isRoot)
+      .map(i => {
+        return i
+      })
+      .filter(i => (i.depth - 1) <= depth)
+      .sort((a, b) => (a.depth - b.depth) || localeCompare(a.name, b.name))
+
+  const res = new Set()
+  const gArb = new Arborist({
+    global: true,
+    path: resolve(npm.globalDir, '..'),
+    workspacesEnabled,
+  })
+  const gTree = await gArb.loadActual({ global: true })
+
+  for (const node of getValues(gTree)) {
+    res.add(global ? node.name : [node.name, '-g'])
+  }
+
+  if (!global) {
+    const arb = new Arborist({ global: false, path: prefix, workspacesEnabled })
+    const tree = await arb.loadActual()
+    for (const node of getValues(tree)) {
+      res.add(node.name)
+    }
+  }
+
+  return [...res]
+}
+
+module.exports = installedDeep
diff --git a/node/node_modules/npm/lib/utils/installed-shallow.js b/node/node_modules/npm/lib/utils/installed-shallow.js
new file mode 100644
index 0000000000000000000000000000000000000000..f77fa7e06b32544262e3e8aa5e65d7f8de3c4236
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/installed-shallow.js
@@ -0,0 +1,19 @@
+const { readdirScoped } = require('@npmcli/fs')
+
+const installedShallow = async (npm, opts) => {
+  const names = async global => {
+    const paths = await readdirScoped(global ? npm.globalDir : npm.localDir)
+    return paths.map(p => p.replace(/\\/g, '/'))
+  }
+  const { conf: { argv: { remain } } } = opts
+  if (remain.length > 3) {
+    return null
+  }
+
+  const { global } = npm.flatOptions
+  const locals = global ? [] : await names(false)
+  const globals = (await names(true)).map(n => global ? n : `${n} -g`)
+  return [...locals, ...globals]
+}
+
+module.exports = installedShallow
diff --git a/node/node_modules/npm/lib/utils/is-windows.js b/node/node_modules/npm/lib/utils/is-windows.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2704d22d832b808ccbe54b8ce3417b090f73b06
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/is-windows.js
@@ -0,0 +1,4 @@
+const isWindowsShell = (process.platform === 'win32') &&
+  !/^MINGW(32|64)$/.test(process.env.MSYSTEM) && process.env.TERM !== 'cygwin'
+
+exports.isWindowsShell = isWindowsShell
diff --git a/node/node_modules/npm/lib/utils/log-file.js b/node/node_modules/npm/lib/utils/log-file.js
new file mode 100644
index 0000000000000000000000000000000000000000..6f81b496d4b62b9c1c66219054ea8e6de116af1a
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/log-file.js
@@ -0,0 +1,247 @@
+const os = require('node:os')
+const { join, dirname, basename } = require('node:path')
+const fsMiniPass = require('fs-minipass')
+const fs = require('node:fs/promises')
+const { log } = require('proc-log')
+const { formatWithOptions } = require('./format')
+
+const padZero = (n, length) => n.toString().padStart(length.toString().length, '0')
+
+class LogFiles {
+  // Default to an array so we can buffer
+  // initial writes before we know the cache location
+  #logStream = []
+
+  // We cap log files at a certain number of log events per file.
+  // Note that each log event can write more than one line to the file.
+  // Then we rotate log files once this number of events is reached
+  #MAX_LOGS_PER_FILE = null
+
+  // Now that we write logs continuously we need to have a backstop here for infinite loops that still log.
+  // This is also partially handled by the config.get('max-files') option, but this is a failsafe to prevent runaway log file creation
+  #MAX_FILES_PER_PROCESS = null
+
+  #fileLogCount = 0
+  #totalLogCount = 0
+  #path = null
+  #logsMax = null
+  #files = []
+  #timing = false
+
+  constructor ({
+    maxLogsPerFile = 50_000,
+    maxFilesPerProcess = 5,
+  } = {}) {
+    this.#MAX_LOGS_PER_FILE = maxLogsPerFile
+    this.#MAX_FILES_PER_PROCESS = maxFilesPerProcess
+    this.on()
+  }
+
+  on () {
+    process.on('log', this.#logHandler)
+  }
+
+  off () {
+    process.off('log', this.#logHandler)
+    this.#endStream()
+  }
+
+  load ({ command, path, logsMax = Infinity, timing } = {}) {
+    if (['completion'].includes(command)) {
+      return
+    }
+
+    // dir is user configurable and is required to exist so this can error if the dir is missing or not configured correctly
+    this.#path = path
+    this.#logsMax = logsMax
+    this.#timing = timing
+
+    // Log stream has already ended
+    if (!this.#logStream) {
+      return
+    }
+
+    log.verbose('logfile', `logs-max:${logsMax} dir:${this.#path}`)
+
+    // Write the contents of our array buffer to our new file stream and set that as the new log logstream for future writes
+    // if logs max is 0 then the user does not want a log file
+    if (this.#logsMax > 0) {
+      const initialFile = this.#openLogFile()
+      if (initialFile) {
+        for (const item of this.#logStream) {
+          const formatted = this.#formatLogItem(...item)
+          if (formatted !== null) {
+            initialFile.write(formatted)
+          }
+        }
+        this.#logStream = initialFile
+      }
+    }
+
+    log.verbose('logfile', this.files[0] || 'no logfile created')
+
+    // Kickoff cleaning process, even if we aren't writing a logfile.
+    // This is async but it will always ignore the current logfile
+    // Return the result so it can be awaited in tests
+    return this.#cleanLogs()
+  }
+
+  get files () {
+    return this.#files
+  }
+
+  get #isBuffered () {
+    return Array.isArray(this.#logStream)
+  }
+
+  #endStream (output) {
+    if (this.#logStream && !this.#isBuffered) {
+      this.#logStream.end(output)
+      this.#logStream = null
+    }
+  }
+
+  #logHandler = (level, ...args) => {
+    // Ignore pause and resume events since we write everything to the log file
+    if (level === 'pause' || level === 'resume') {
+      return
+    }
+
+    // If the stream is ended then do nothing
+    if (!this.#logStream) {
+      return
+    }
+
+    if (this.#isBuffered) {
+      // Cant do anything but buffer the output if we don't have a file stream yet
+      this.#logStream.push([level, ...args])
+      return
+    }
+
+    const logOutput = this.#formatLogItem(level, ...args)
+    if (logOutput === null) {
+      return
+    }
+
+    // Open a new log file if we've written too many logs to this one
+    if (this.#fileLogCount >= this.#MAX_LOGS_PER_FILE) {
+      // Write last chunk to the file and close it
+      this.#endStream(logOutput)
+      if (this.#files.length >= this.#MAX_FILES_PER_PROCESS) {
+        // but if its way too many then we just stop listening
+        this.off()
+      } else {
+        // otherwise we are ready for a new file for the next event
+        this.#logStream = this.#openLogFile()
+      }
+    } else {
+      this.#logStream.write(logOutput)
+    }
+  }
+
+  #formatLogItem (level, title, ...args) {
+    // Only right timing logs to logfile if explicitly requests
+    if (level === log.KEYS.timing && !this.#timing) {
+      return null
+    }
+
+    this.#fileLogCount += 1
+    const prefix = [this.#totalLogCount++, level, title || null]
+    return formatWithOptions({ prefix, eol: os.EOL, colors: false }, ...args)
+  }
+
+  #getLogFilePath (count = '') {
+    return `${this.#path}debug-${count}.log`
+  }
+
+  #openLogFile () {
+    // Count in filename will be 0 indexed
+    const count = this.#files.length
+
+    try {
+      // Pad with zeros so that our log files are always sorted properly
+      // We never want to write files ending in `-9.log` and `-10.log` because log file cleaning is done by deleting the oldest.
+      // So in this example `-10.log` would be deleted next.
+      const f = this.#getLogFilePath(padZero(count, this.#MAX_FILES_PER_PROCESS))
+      // Some effort was made to make the async, but we need to write logs during process.on('exit') which has to be synchronous.
+      // So in order to never drop log messages, it is easiest to make it sync all the time and this was measured to be about 1.5% slower for 40k lines of output
+      const logStream = new fsMiniPass.WriteStreamSync(f, { flags: 'a' })
+      if (count > 0) {
+        // Reset file log count if we are opening after our first file
+        this.#fileLogCount = 0
+      }
+      this.#files.push(logStream.path)
+      return logStream
+    } catch (e) {
+      // If the user has a readonly logdir then we don't want to warn this on every command so it should be verbose
+      log.verbose('logfile', `could not be created: ${e}`)
+    }
+  }
+
+  async #cleanLogs () {
+    // module to clean out the old log files this is a best-effort attempt.
+    // if a rm fails, we just log a message about it and move on.
+    // We do return a Promise that succeeds when we've tried to delete everything, just for the benefit of testing this function properly.
+
+    try {
+      const logPath = this.#getLogFilePath()
+      const patternFileName = basename(logPath)
+        // tell glob to only match digits
+        .replace(/\d/g, 'd')
+        // Handle the old (prior to 8.2.0) log file names which did not have a counter suffix
+        .replace('-.log', '')
+
+      let files = await fs.readdir(
+        dirname(logPath), {
+          withFileTypes: true,
+          encoding: 'utf-8',
+        })
+      files = files.sort((a, b) => basename(a.name).localeCompare(basename(b.name), 'en'))
+
+      const logFiles = []
+
+      for (const file of files) {
+        if (!file.isFile()) {
+          continue
+        }
+
+        const genericFileName = file.name.replace(/\d/g, 'd')
+        const filePath = join(dirname(logPath), basename(file.name))
+
+        // Always ignore the currently written files
+        if (
+          genericFileName.includes(patternFileName)
+          && genericFileName.endsWith('.log')
+          && !this.#files.includes(filePath)
+        ) {
+          logFiles.push(filePath)
+        }
+      }
+
+      const toDelete = logFiles.length - this.#logsMax
+
+      if (toDelete <= 0) {
+        return
+      }
+
+      log.silly('logfile', `start cleaning logs, removing ${toDelete} files`)
+
+      for (const file of logFiles.slice(0, toDelete)) {
+        try {
+          await fs.rm(file, { force: true })
+        } catch (e) {
+          log.silly('logfile', 'error removing log file', file, e)
+        }
+      }
+    } catch (e) {
+      // Disable cleanup failure warnings when log writing is disabled
+      if (this.#logsMax > 0) {
+        log.verbose('logfile', 'error cleaning log files', e)
+      }
+    } finally {
+      log.silly('logfile', 'done cleaning log files')
+    }
+  }
+}
+
+module.exports = LogFiles
diff --git a/node/node_modules/npm/lib/utils/npm-usage.js b/node/node_modules/npm/lib/utils/npm-usage.js
new file mode 100644
index 0000000000000000000000000000000000000000..877a5ed04330c91521715ff3db7f2f01c8c1d36d
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/npm-usage.js
@@ -0,0 +1,74 @@
+const { commands } = require('./cmd-list')
+
+const COL_MAX = 60
+const COL_MIN = 24
+const COL_GUTTER = 16
+const INDENT = 4
+
+const indent = (repeat = INDENT) => ' '.repeat(repeat)
+const indentNewline = (repeat) => `\n${indent(repeat)}`
+
+module.exports = (npm) => {
+  const browser = npm.config.get('viewer') === 'browser' ? ' (in a browser)' : ''
+  const allCommands = npm.config.get('long') ? cmdUsages(npm.constructor) : cmdNames()
+
+  return `npm <command>
+
+Usage:
+
+npm install        install all the dependencies in your project
+npm install <foo>  add the <foo> dependency to your project
+npm test           run this project's tests
+npm run <foo>      run the script named <foo>
+npm <command> -h   quick help on <command>
+npm -l             display usage info for all commands
+npm help <term>    search for help on <term>${browser}
+npm help npm       more involved overview${browser}
+
+All commands:
+${allCommands}
+
+Specify configs in the ini-formatted file:
+${indent() + npm.config.get('userconfig')}
+or on the command line via: npm <command> --key=value
+
+More configuration info: npm help config
+Configuration fields: npm help 7 config
+
+npm@${npm.version} ${npm.npmRoot}`
+}
+
+const cmdNames = () => {
+  const out = ['']
+
+  const line = !process.stdout.columns ? COL_MAX
+    : Math.min(COL_MAX, Math.max(process.stdout.columns - COL_GUTTER, COL_MIN))
+
+  let l = 0
+  for (const c of commands) {
+    if (out[l].length + c.length + 2 < line) {
+      out[l] += ', ' + c
+    } else {
+      out[l++] += ','
+      out[l] = c
+    }
+  }
+
+  return indentNewline() + out.join(indentNewline()).slice(2)
+}
+
+const cmdUsages = (Npm) => {
+  // return a string of <command>: <usage>
+  let maxLen = 0
+  const set = []
+  for (const c of commands) {
+    set.push([c, Npm.cmd(c).getUsage(null, false).split('\n')])
+    maxLen = Math.max(maxLen, c.length)
+  }
+
+  return set.map(([name, usageLines]) => {
+    const gutter = indent(maxLen - name.length + 1)
+    const usage = usageLines.join(indentNewline(INDENT + maxLen + 1))
+    return indentNewline() + name + gutter + usage
+  }).join('\n')
+}
diff --git a/node/node_modules/npm/lib/utils/oidc.js b/node/node_modules/npm/lib/utils/oidc.js
new file mode 100644
index 0000000000000000000000000000000000000000..f29ea438d6f4c2172bfb7cf0836d75d44a42c11a
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/oidc.js
@@ -0,0 +1,177 @@
+const { log } = require('proc-log')
+const npmFetch = require('npm-registry-fetch')
+const ciInfo = require('ci-info')
+const fetch = require('make-fetch-happen')
+const npa = require('npm-package-arg')
+const libaccess = require('libnpmaccess')
+
+/**
+ * Handles OpenID Connect (OIDC) token retrieval and exchange for CI environments.
+ *
+ * This function is designed to work in Continuous Integration (CI) environments such as GitHub Actions, GitLab, and CircleCI.
+ * It retrieves an OIDC token from the CI environment, exchanges it for an npm token, and sets the token in the provided configuration for authentication with the npm registry.
+ *
+ * This function is intended to never throw, as it mutates the state of the `opts` and `config` objects on success.
+ * OIDC is always an optional feature, and the function should not throw if OIDC is not configured by the registry.
+ *
+ * @see https://github.com/watson/ci-info for CI environment detection.
+ * @see https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect for GitHub Actions OIDC.
+ * @see https://circleci.com/docs/openid-connect-tokens/ for CircleCI OIDC.
+ */
+async function oidc ({ packageName, registry, opts, config }) {
+  /*
+   * This code should never run when people try to publish locally on their machines.
+   * It is designed to execute only in Continuous Integration (CI) environments.
+   */
+
+  try {
+    if (!(
+      /** @see https://github.com/watson/ci-info/blob/v4.2.0/vendors.json#L152 */
+      ciInfo.GITHUB_ACTIONS ||
+      /** @see https://github.com/watson/ci-info/blob/v4.2.0/vendors.json#L161C13-L161C22 */
+      ciInfo.GITLAB ||
+      /** @see https://github.com/watson/ci-info/blob/v4.2.0/vendors.json#L78 */
+      ciInfo.CIRCLE
+    )) {
+      return undefined
+    }
+
+    /**
+     * Check if the environment variable `NPM_ID_TOKEN` is set.
+     * In GitLab CI, the ID token is provided via an environment variable,
+     * with `NPM_ID_TOKEN` serving as a predefined default. For consistency,
+     * all supported CI environments are expected to support this variable.
+     * In contrast, GitHub Actions uses a request-based approach to retrieve the ID token.
+     * The presence of this token within GitHub Actions will override the request-based approach.
+     * This variable follows the prefix/suffix convention from sigstore (e.g., `SIGSTORE_ID_TOKEN`).
+     * @see https://docs.sigstore.dev/cosign/signing/overview/
+     */
+    let idToken = process.env.NPM_ID_TOKEN
+
+    if (!idToken && ciInfo.GITHUB_ACTIONS) {
+      /**
+       * GitHub Actions provides these environment variables:
+       * - `ACTIONS_ID_TOKEN_REQUEST_URL`: The URL to request the ID token.
+       * - `ACTIONS_ID_TOKEN_REQUEST_TOKEN`: The token to authenticate the request.
+       * Only when a workflow has the following permissions:
+       * ```
+       * permissions:
+       *    id-token: write
+       * ```
+       * @see https://docs.github.com/en/actions/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-cloud-providers#adding-permissions-settings
+       */
+      if (!(
+        process.env.ACTIONS_ID_TOKEN_REQUEST_URL &&
+        process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN
+      )) {
+        log.silly('oidc', 'Skipped because incorrect permissions for id-token within GitHub workflow')
+        return undefined
+      }
+
+      /**
+       * The specification for an audience is `npm:registry.npmjs.org`, where "registry.npmjs.org" can be any supported registry.
+       */
+      const audience = `npm:${new URL(registry).hostname}`
+      const url = new URL(process.env.ACTIONS_ID_TOKEN_REQUEST_URL)
+      url.searchParams.append('audience', audience)
+      const startTime = Date.now()
+      const response = await fetch(url.href, {
+        retry: opts.retry,
+        headers: {
+          Accept: 'application/json',
+          Authorization: `Bearer ${process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN}`,
+        },
+      })
+
+      const elapsedTime = Date.now() - startTime
+
+      log.http(
+        'fetch',
+        `GET ${url.href} ${response.status} ${elapsedTime}ms`
+      )
+
+      const json = await response.json()
+
+      if (!response.ok) {
+        log.verbose('oidc', `Failed to fetch id_token from GitHub: received an invalid response`)
+        return undefined
+      }
+
+      if (!json.value) {
+        log.verbose('oidc', `Failed to fetch id_token from GitHub: missing value`)
+        return undefined
+      }
+
+      idToken = json.value
+    }
+
+    if (!idToken) {
+      log.silly('oidc', 'Skipped because no id_token available')
+      return undefined
+    }
+
+    const parsedRegistry = new URL(registry)
+    const regKey = `//${parsedRegistry.host}${parsedRegistry.pathname}`
+    const authTokenKey = `${regKey}:_authToken`
+
+    const escapedPackageName = npa(packageName).escapedName
+    let response
+    try {
+      response = await npmFetch.json(new URL(`/-/npm/v1/oidc/token/exchange/package/${escapedPackageName}`, registry), {
+        ...opts,
+        [authTokenKey]: idToken, // Use the idToken as the auth token for the request
+        method: 'POST',
+      })
+    } catch (error) {
+      log.verbose('oidc', `Failed token exchange request with body message: ${error?.body?.message || 'Unknown error'}`)
+      return undefined
+    }
+
+    if (!response?.token) {
+      log.verbose('oidc', 'Failed because token exchange was missing the token in the response body')
+      return undefined
+    }
+
+    /*
+     * The "opts" object is a clone of npm.flatOptions and is passed through the `publish` command, eventually reaching `otplease`.
+     * To ensure the token is accessible during the publishing process, it must be directly attached to the `opts` object.
+     * Additionally, the token is required by the "live" configuration or getters within `config`.
+     */
+    opts[authTokenKey] = response.token
+    config.set(authTokenKey, response.token, 'user')
+    log.verbose('oidc', `Successfully retrieved and set token`)
+
+    try {
+      const isDefaultProvenance = config.isDefault('provenance')
+      // CircleCI doesn't support provenance yet, so skip the auto-enable logic
+      if (isDefaultProvenance && !ciInfo.CIRCLE) {
+        const [headerB64, payloadB64] = idToken.split('.')
+        if (headerB64 && payloadB64) {
+          const payloadJson = Buffer.from(payloadB64, 'base64').toString('utf8')
+          const payload = JSON.parse(payloadJson)
+          if (
+            (ciInfo.GITHUB_ACTIONS && payload.repository_visibility === 'public') ||
+            // only set provenance for gitlab if the repo is public and SIGSTORE_ID_TOKEN is available
+            (ciInfo.GITLAB && payload.project_visibility === 'public' && process.env.SIGSTORE_ID_TOKEN)
+          ) {
+            const visibility = await libaccess.getVisibility(packageName, opts)
+            if (visibility?.public) {
+              log.verbose('oidc', `Enabling provenance`)
+              opts.provenance = true
+              config.set('provenance', true, 'user')
+            }
+          }
+        }
+      }
+    } catch (error) {
+      log.verbose('oidc', `Failed to set provenance with message: ${error?.message || 'Unknown error'}`)
+    }
+  } catch (error) {
+    log.verbose('oidc', `Failure with message: ${error?.message || 'Unknown error'}`)
+  }
+  return undefined
+}
+
+module.exports = {
+  oidc,
+}
diff --git a/node/node_modules/npm/lib/utils/open-url.js b/node/node_modules/npm/lib/utils/open-url.js
new file mode 100644
index 0000000000000000000000000000000000000000..80ee4b3e5da3debdd1b1f511e46f555a3edb04b5
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/open-url.js
@@ -0,0 +1,97 @@
+const { open } = require('@npmcli/promise-spawn')
+const { output, input, META } = require('proc-log')
+const { URL } = require('node:url')
+const readline = require('node:readline/promises')
+const { once } = require('node:events')
+
+const assertValidUrl = (url) => {
+  try {
+    if (!/^https?:$/.test(new URL(url).protocol)) {
+      throw new Error()
+    }
+  } catch {
+    throw new Error('Invalid URL: ' + url)
+  }
+}
+
+const outputMsg = (json, title, url) => {
+  if (json) {
+    output.buffer({ title, url })
+  } else {
+    // These urls are sometimes specifically login urls so we have to turn off redaction to standard output
+    output.standard(`${title}:\n${url}`, { [META]: true, redact: false })
+  }
+}
+
+// attempt to open URL in web-browser, print address otherwise:
+const openUrl = async (npm, url, title, isFile) => {
+  url = encodeURI(url)
+  const browser = npm.config.get('browser')
+  const json = npm.config.get('json')
+
+  if (browser === false) {
+    outputMsg(json, title, url)
+    return
+  }
+
+  // We pass this in as true from the help command so we know we don't have to check the protocol
+  if (!isFile) {
+    assertValidUrl(url)
+  }
+
+  try {
+    await input.start(() => open(url, {
+      command: browser === true ? null : browser,
+    }))
+  } catch (err) {
+    if (err.code !== 127) {
+      throw err
+    }
+    outputMsg(json, title, url)
+  }
+}
+
+// Prompt to open URL in browser if possible
+const openUrlPrompt = async (npm, url, title, prompt, { signal }) => {
+  const browser = npm.config.get('browser')
+  const json = npm.config.get('json')
+
+  assertValidUrl(url)
+  outputMsg(json, title, url)
+
+  if (browser === false || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  try {
+    await input.read(() => Promise.race([
+      rl.question(prompt, { signal }),
+      once(rl, 'error'),
+      once(rl, 'SIGINT').then(() => {
+        throw new Error('canceled')
+      }),
+    ]))
+    rl.close()
+    await openUrl(npm, url, 'Browser unavailable. Please open the URL manually')
+  } catch (err) {
+    rl.close()
+    if (err.name !== 'AbortError') {
+      throw err
+    }
+  }
+}
+
+// Rearrange arguments and return a function that takes the two arguments returned from the npm-profile methods that take an opener
+const createOpener = (npm, title, prompt = 'Press ENTER to open in the browser...') =>
+  (url, opts) => openUrlPrompt(npm, url, title, prompt, opts)
+
+module.exports = {
+  openUrl,
+  openUrlPrompt,
+  createOpener,
+}
diff --git a/node/node_modules/npm/lib/utils/output-error.js b/node/node_modules/npm/lib/utils/output-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..20e983187e5bc949c8e8702068835482611fb74e
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/output-error.js
@@ -0,0 +1,30 @@
+const { log, output } = require('proc-log')
+
+const outputError = ({ standard = [], verbose = [], error = [], summary = [], detail = [] }) => {
+  for (const line of standard) {
+    // Each output line is just a single string
+    output.standard(line)
+  }
+  for (const line of verbose) {
+    log.verbose(...line)
+  }
+  for (const line of [...error, ...summary, ...detail]) {
+    log.error(...line)
+  }
+}
+
+const jsonError = (error, npm) => {
+  if (error && npm?.loaded && npm?.config.get('json')) {
+    return {
+      code: error.code,
+      summary: (error.summary || []).map(l => l.slice(1).join(' ')).join('\n').trim(),
+      detail: (error.detail || []).map(l => l.slice(1).join(' ')).join('\n').trim(),
+      ...error.json,
+    }
+  }
+}
+
+module.exports = {
+  outputError,
+  jsonError,
+}
diff --git a/node/node_modules/npm/lib/utils/ping.js b/node/node_modules/npm/lib/utils/ping.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c42cb9ce21d3cf119bd8c6f880b5c0975d77673
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/ping.js
@@ -0,0 +1,6 @@
+// ping the npm registry used by the ping and doctor commands
+const npmFetch = require('npm-registry-fetch')
+module.exports = async (flatOptions) => {
+  const res = await npmFetch('/-/ping', { ...flatOptions, cache: false })
+  return res.json().catch(() => ({}))
+}
diff --git a/node/node_modules/npm/lib/utils/queryable.js b/node/node_modules/npm/lib/utils/queryable.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b5253448ea6b0446b39506a0060fbf5612db833
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/queryable.js
@@ -0,0 +1,287 @@
+const util = require('node:util')
+const _delete = Symbol('delete')
+const _append = Symbol('append')
+
+const sqBracketsMatcher = str => str.match(/(.+)\[([^\]]+)\]\.?(.*)$/)
+
+// replaces any occurrence of an empty-brackets (e.g: []) with a special Symbol(append) to represent it
+// this is going to be useful for the setter method that will push values to the end of the array when finding these
+const replaceAppendSymbols = str => {
+  const matchEmptyBracket = str.match(/^(.*)\[\]\.?(.*)$/)
+
+  if (matchEmptyBracket) {
+    const [, pre, post] = matchEmptyBracket
+    return [...replaceAppendSymbols(pre), _append, post].filter(Boolean)
+  }
+
+  return [str]
+}
+
+const parseKeys = key => {
+  const sqBracketItems = new Set()
+  sqBracketItems.add(_append)
+  const parseSqBrackets = str => {
+    const index = sqBracketsMatcher(str)
+
+    // once we find square brackets, we recursively parse all these
+    if (index) {
+      const preSqBracketPortion = index[1]
+
+      // we want to have a `new String` wrapper here in order to differentiate between multiple occurrences of the same string,
+      // e.g: foo.bar[foo.bar] should split into { foo: { bar: { 'foo.bar': {} } }
+      /* eslint-disable-next-line no-new-wrappers */
+      const foundKey = new String(index[2])
+      const postSqBracketPortion = index[3]
+
+      // we keep track of items found during this step to make sure we don't try to split-separate keys that were defined within square brackets, since the key name itself might contain dots
+      sqBracketItems.add(foundKey)
+
+      // returns an array that contains either dot-separate items (that will be split apart during the next step OR the fully parsed keys read from square brackets
+      // e.g: foo.bar[1.0.0].a.b -> ['foo.bar', '1.0.0', 'a.b']
+      return [
+        ...parseSqBrackets(preSqBracketPortion),
+        foundKey,
+        ...(postSqBracketPortion ? parseSqBrackets(postSqBracketPortion) : []),
+      ]
+    }
+
+    // at the end of parsing, any usage of the special empty-bracket syntax (e.g: foo.array[]) has not yet been parsed
+    // here we'll take care of parsing it and adding a special symbol to represent it in the resulting list of keys
+    return replaceAppendSymbols(str)
+  }
+
+  const res = []
+  // starts by parsing items defined as square brackets
+  // those might be representing properties that have a dot in the name or just array indexes
+  // e.g: foo[1.0.0] or list[0]
+  const sqBracketKeys = parseSqBrackets(key.trim())
+
+  for (const k of sqBracketKeys) {
+    // keys parsed from square brackets should just be added to list of resulting keys as they might have dots as part of the key
+    if (sqBracketItems.has(k)) {
+      res.push(k)
+    } else {
+      // splits the dot-sep property names and add them to the list of keys
+      /* eslint-disable-next-line no-new-wrappers */
+      for (const splitKey of k.split('.')) {
+        res.push(String(splitKey))
+      }
+    }
+  }
+
+  // returns an ordered list of strings in which each entry represents a key in an object defined by the previous entry
+  return res
+}
+
+const getter = ({ data, key }, { unwrapSingleItemArrays = true } = {}) => {
+  // keys are a list in which each entry represents the name of a property that should be walked through the object in order to return the final found value
+  const keys = parseKeys(key)
+  let _data = data
+  let label = ''
+
+  for (const k of keys) {
+    // empty-bracket-shortcut-syntax is not supported on getter
+    if (k === _append) {
+      throw Object.assign(new Error('Empty brackets are not valid syntax for retrieving values.'), {
+        code: 'EINVALIDSYNTAX',
+      })
+    }
+
+    // extra logic to take into account printing array, along with its special syntax in which using a dot-sep property name after an array will expand it's results
+    // e.g: arr.name -> arr[0].name=value, arr[1].name=value, ...
+    const maybeIndex = Number(k)
+    if (Array.isArray(_data) && !Number.isInteger(maybeIndex)) {
+      _data = _data.reduce((acc, i, index) => {
+        acc[`${label}[${index}].${k}`] = i[k]
+        return acc
+      }, {})
+      return _data
+    } else {
+      if (!Object.hasOwn(_data, k)) {
+        return undefined
+      }
+      _data = _data[k]
+    }
+
+    label += k
+  }
+
+  // these are some legacy expectations from the old API consumed by lib/view.js
+  if (unwrapSingleItemArrays && Array.isArray(_data) && _data.length <= 1) {
+    _data = _data[0]
+  }
+
+  return {
+    [key]: _data,
+  }
+}
+
+const setter = ({ data, key, value, force }) => {
+  // setter goes to recursively transform the provided data obj
+  // setting properties from the list of parsed keys
+  // e.g: ['foo', 'bar', 'baz'] -> { foo: { bar: { baz:  {} } }
+  const keys = parseKeys(key)
+  const setKeys = (_data, _key) => {
+    // handles array indexes, converting valid integers to numbers
+    // note that occurrences of Symbol(append) will throw so we just ignore these for now
+    let maybeIndex = Number.NaN
+    try {
+      maybeIndex = Number(_key)
+    } catch {
+      // leave it NaN
+    }
+    if (!Number.isNaN(maybeIndex)) {
+      _key = maybeIndex
+    }
+
+    // creates new array in case key is an index and the array obj is not yet defined
+    const keyIsAnArrayIndex = _key === maybeIndex || _key === _append
+    const dataHasNoItems = !Object.keys(_data).length
+    if (keyIsAnArrayIndex && dataHasNoItems && !Array.isArray(_data)) {
+      _data = []
+    }
+
+    // converting from array to an object is also possible, in case the user is using force mode
+    // we should also convert existing arrays to an empty object if the current _data is an array
+    if (force && Array.isArray(_data) && !keyIsAnArrayIndex) {
+      _data = { ..._data }
+    }
+
+    // the _append key is a special key that is used to represent the empty-bracket notation
+    // e.g: arr[] -> arr[arr.length]
+    if (_key === _append) {
+      if (!Array.isArray(_data)) {
+        throw Object.assign(new Error(`Can't use append syntax in non-Array element`), {
+          code: 'ENOAPPEND',
+        })
+      }
+      _key = _data.length
+    }
+
+    // retrieves the next data object to recursively iterate on
+    // throws if trying to override a literal value or add props to an array
+    const next = () => {
+      const haveContents = !force && _data[_key] != null && value !== _delete
+      const shouldNotOverrideLiteralValue = !(typeof _data[_key] === 'object')
+      // if the next obj to recurse is an array and the next key to be appended to the resulting obj is not an array index, then it should throw since we can't append arbitrary props to arrays
+      const shouldNotAddPropsToArrays =
+        typeof keys[0] !== 'symbol' && Array.isArray(_data[_key]) && Number.isNaN(Number(keys[0]))
+
+      const overrideError = haveContents && shouldNotOverrideLiteralValue
+      if (overrideError) {
+        throw Object.assign(
+          new Error(`Property ${_key} already exists and is not an Array or Object.`),
+          { code: 'EOVERRIDEVALUE' }
+        )
+      }
+
+      const addPropsToArrayError = haveContents && shouldNotAddPropsToArrays
+      if (addPropsToArrayError) {
+        throw Object.assign(new Error(`Can't add property ${key} to an Array.`), {
+          code: 'ENOADDPROP',
+        })
+      }
+
+      return typeof _data[_key] === 'object' ? _data[_key] || {} : {}
+    }
+
+    // sets items from the parsed array of keys as objects, recurses to setKeys in case there are still items to be handled
+    // otherwise, it just sets the original value set by the user
+    if (keys.length) {
+      _data[_key] = setKeys(next(), keys.shift())
+    } else {
+      // handles special deletion cases for obj props / array items
+      if (value === _delete) {
+        if (Array.isArray(_data)) {
+          _data.splice(_key, 1)
+        } else {
+          delete _data[_key]
+        }
+      } else {
+        // finally, sets the value in its right place
+        _data[_key] = value
+      }
+    }
+
+    return _data
+  }
+
+  setKeys(data, keys.shift())
+}
+
+class Queryable {
+  static ALL = ''
+
+  #data = null
+
+  constructor (obj) {
+    if (!obj || typeof obj !== 'object') {
+      throw Object.assign(new Error('Queryable needs an object to query properties from.'), {
+        code: 'ENOQUERYABLEOBJ',
+      })
+    }
+
+    this.#data = obj
+  }
+
+  query (queries, opts) {
+    // this ugly interface here is meant to be a compatibility layer with the legacy API lib/view.js is consuming
+    // if at some point we refactor that command then we can revisit making this nicer
+    if (queries === Queryable.ALL) {
+      return { [Queryable.ALL]: this.#data }
+    }
+
+    const q = query =>
+      getter({
+        data: this.#data,
+        key: query,
+      }, opts)
+
+    if (Array.isArray(queries)) {
+      let res = {}
+      for (const query of queries) {
+        res = { ...res, ...q(query) }
+      }
+      return res
+    } else {
+      return q(queries)
+    }
+  }
+
+  // return the value for a single query if found; otherwise, returns undefined
+  get (query) {
+    const obj = this.query(query)
+    if (obj) {
+      return obj[query]
+    }
+  }
+
+  // creates objects along the way for the provided `query` parameter and assigns `value` to the last property of the query chain
+  set (query, value, { force } = {}) {
+    setter({
+      data: this.#data,
+      key: query,
+      value,
+      force,
+    })
+  }
+
+  // deletes the value of the property found at `query`
+  delete (query) {
+    setter({
+      data: this.#data,
+      key: query,
+      value: _delete,
+    })
+  }
+
+  toJSON () {
+    return this.#data
+  }
+
+  [util.inspect.custom] () {
+    return this.toJSON()
+  }
+}
+
+module.exports = Queryable
diff --git a/node/node_modules/npm/lib/utils/read-user-info.js b/node/node_modules/npm/lib/utils/read-user-info.js
new file mode 100644
index 0000000000000000000000000000000000000000..cdf3eaa164750b03dac5a4a40d1202e7307f9562
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/read-user-info.js
@@ -0,0 +1,69 @@
+const { read: _read } = require('read')
+const userValidate = require('npm-user-validate')
+const { log, input, META } = require('proc-log')
+
+const otpPrompt = `This command requires a one-time password (OTP) from your authenticator app.
+Enter one below. You can also pass one on the command line by appending --otp=123456.
+For more information, see:
+https://docs.npmjs.com/getting-started/using-two-factor-authentication
+Enter OTP: `
+const passwordPrompt = 'npm password: '
+const usernamePrompt = 'npm username: '
+const emailPrompt = 'email (this will be public): '
+
+// Pass options through so we can differentiate between regular and silent prompts
+const read = (options) =>
+  input.read(() => _read(options), { [META]: true, silent: options?.silent })
+
+function readOTP (msg = otpPrompt, otp, isRetry) {
+  if (isRetry && otp && /^[\d ]+$|^[A-Fa-f0-9]{64,64}$/.test(otp)) {
+    return otp.replace(/\s+/g, '')
+  }
+
+  return read({ prompt: msg, default: otp || '' })
+    .then((rOtp) => readOTP(msg, rOtp, true))
+}
+
+function readPassword (msg = passwordPrompt, password, isRetry) {
+  if (isRetry && password) {
+    return password
+  }
+
+  return read({ prompt: msg, silent: true, default: password || '' })
+    .then((rPassword) => readPassword(msg, rPassword, true))
+}
+
+function readUsername (msg = usernamePrompt, username, isRetry) {
+  if (isRetry && username) {
+    const error = userValidate.username(username)
+    if (error) {
+      log.warn(error.message)
+    } else {
+      return Promise.resolve(username.trim())
+    }
+  }
+
+  return read({ prompt: msg, default: username || '' })
+    .then((rUsername) => readUsername(msg, rUsername, true))
+}
+
+function readEmail (msg = emailPrompt, email, isRetry) {
+  if (isRetry && email) {
+    const error = userValidate.email(email)
+    if (error) {
+      log.warn(error.message)
+    } else {
+      return email.trim()
+    }
+  }
+
+  return read({ prompt: msg, default: email || '' })
+    .then((username) => readEmail(msg, username, true))
+}
+
+module.exports = {
+  otp: readOTP,
+  password: readPassword,
+  username: readUsername,
+  email: readEmail,
+}
diff --git a/node/node_modules/npm/lib/utils/reify-finish.js b/node/node_modules/npm/lib/utils/reify-finish.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b806662cabec99817614408d314a6fe94fd2f58
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/reify-finish.js
@@ -0,0 +1,21 @@
+const reifyOutput = require('./reify-output.js')
+const ini = require('ini')
+const { writeFile } = require('node:fs/promises')
+const { resolve } = require('node:path')
+
+const reifyFinish = async (npm, arb) => {
+  // if we are using a builtin config, and just installed npm as a top-level global package, we have to preserve that config.
+  if (arb.options.global) {
+    const npmNode = arb.actualTree.inventory.get('node_modules/npm')
+    if (npmNode) {
+      const builtinConf = npm.config.data.get('builtin')
+      if (!builtinConf.loadError) {
+        const content = ini.stringify(builtinConf.raw).trim() + '\n'
+        await writeFile(resolve(npmNode.path, 'npmrc'), content)
+      }
+    }
+  }
+  reifyOutput(npm, arb)
+}
+
+module.exports = reifyFinish
diff --git a/node/node_modules/npm/lib/utils/reify-output.js b/node/node_modules/npm/lib/utils/reify-output.js
new file mode 100644
index 0000000000000000000000000000000000000000..45763f46431e9efbee8e31a98b8d59eb19cd9533
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/reify-output.js
@@ -0,0 +1,220 @@
+// pass in an arborist object, and it'll output the data about what
+// was done, what was audited, etc.
+//
+// added ## packages, removed ## packages, and audited ## packages in 19.157s
+//
+// 1 package is looking for funding
+//   run `npm fund` for details
+//
+// found 37 vulnerabilities (5 low, 7 moderate, 25 high)
+//   run `npm audit fix` to fix them, or `npm audit` for details
+
+const { log, output } = require('proc-log')
+const { depth } = require('treeverse')
+const ms = require('ms')
+const npmAuditReport = require('npm-audit-report')
+const { readTree: getFundingInfo } = require('libnpmfund')
+const auditError = require('./audit-error.js')
+
+// TODO: output JSON if flatOptions.json is true
+const reifyOutput = (npm, arb) => {
+  const { diff, actualTree } = arb
+
+  // note: fails and crashes if we're running audit fix and there was an error which is a good thing, because there's no point printing all this other stuff in that case!
+  const auditReport = auditError(npm, arb.auditReport) ? null : arb.auditReport
+
+  // don't print any info in --silent mode, but we still need to set the exitCode properly from the audit report, if we have one.
+  if (npm.silent) {
+    getAuditReport(npm, auditReport)
+    return
+  }
+
+  const summary = {
+    add: [],
+    added: 0,
+    // audit gets added later
+    audited: auditReport && !auditReport.error ? actualTree.inventory.size : 0,
+    change: [],
+    changed: 0,
+    funding: 0,
+    remove: [],
+    removed: 0,
+  }
+
+  if (diff) {
+    const showDiff = npm.config.get('dry-run') || npm.config.get('long')
+    const chalk = npm.chalk
+
+    depth({
+      tree: diff,
+      visit: d => {
+        switch (d.action) {
+          case 'REMOVE':
+            if (showDiff) {
+              output.standard(`${chalk.blue('remove')} ${d.actual.name} ${d.actual.package.version}`)
+            }
+            summary.removed++
+            summary.remove.push({
+              name: d.actual.name,
+              version: d.actual.package.version,
+              path: d.actual.path,
+            })
+            break
+          case 'ADD':
+            if (showDiff) {
+              output.standard(`${chalk.green('add')} ${d.ideal.name} ${d.ideal.package.version}`)
+            }
+            if (actualTree.inventory.has(d.ideal)) {
+              summary.added++
+              summary.add.push({
+                name: d.ideal.name,
+                version: d.ideal.package.version,
+                path: d.ideal.path,
+              })
+            }
+            break
+          case 'CHANGE':
+            if (showDiff) {
+              output.standard(`${chalk.cyan('change')} ${d.actual.name} ${d.actual.package.version} => ${d.ideal.package.version}`)
+            }
+            summary.changed++
+            summary.change.push({
+              from: {
+                name: d.actual.name,
+                version: d.actual.package.version,
+                path: d.actual.path,
+              },
+              to: {
+                name: d.ideal.name,
+                version: d.ideal.package.version,
+                path: d.ideal.path,
+              },
+            })
+            break
+          default:
+            return
+        }
+        const node = d.actual || d.ideal
+        log.silly(d.action, node.location)
+      },
+      getChildren: d => d.children,
+    })
+  }
+
+  if (npm.flatOptions.fund) {
+    const fundingInfo = getFundingInfo(actualTree, { countOnly: true })
+    summary.funding = fundingInfo.length
+  }
+
+  if (npm.flatOptions.json) {
+    if (auditReport) {
+      // call this to set the exit code properly
+      getAuditReport(npm, auditReport)
+      summary.audit = npm.command === 'audit' ? auditReport
+        : auditReport.toJSON().metadata
+    }
+    output.buffer(summary)
+  } else {
+    packagesChangedMessage(npm, summary)
+    packagesFundingMessage(npm, summary)
+    printAuditReport(npm, auditReport)
+  }
+}
+
+// if we're running `npm audit fix`, then we print the full audit report at the end if there's still stuff, because it's silly for `npm audit` to tell you to run `npm audit` for details.
+// otherwise, use the summary report.
+// if we get here, we know it's not quiet or json.
+// If the loglevel is silent, then we just run the report to get the exitCode set appropriately.
+const printAuditReport = (npm, report) => {
+  const res = getAuditReport(npm, report)
+  if (!res || !res.report) {
+    return
+  }
+  output.standard(`\n${res.report}`)
+}
+
+const getAuditReport = (npm, report) => {
+  if (!report) {
+    return
+  }
+
+  // when in silent mode, we print nothing.
+  // the JSON output is going to just JSON.stringify() the report object.
+  const reporter = npm.silent ? 'quiet'
+    : npm.flatOptions.json ? 'quiet'
+    : npm.command !== 'audit' ? 'install'
+    : 'detail'
+  const defaultAuditLevel = npm.command !== 'audit' ? 'none' : 'low'
+  const auditLevel = npm.flatOptions.auditLevel || defaultAuditLevel
+
+  const res = npmAuditReport(report, {
+    reporter,
+    ...npm.flatOptions,
+    auditLevel,
+    chalk: npm.chalk,
+  })
+  if (npm.command === 'audit') {
+    process.exitCode = process.exitCode || res.exitCode
+  }
+  return res
+}
+
+const packagesChangedMessage = (npm, { added, removed, changed, audited }) => {
+  const msg = ['\n']
+  if (added === 0 && removed === 0 && changed === 0) {
+    msg.push('up to date')
+    if (audited) {
+      msg.push(', ')
+    }
+  } else {
+    if (added) {
+      msg.push(`added ${added} package${added === 1 ? '' : 's'}`)
+    }
+
+    if (removed) {
+      if (added) {
+        msg.push(', ')
+      }
+
+      if (added && !audited && !changed) {
+        msg.push('and ')
+      }
+
+      msg.push(`removed ${removed} package${removed === 1 ? '' : 's'}`)
+    }
+    if (changed) {
+      if (added || removed) {
+        msg.push(', ')
+      }
+
+      if (!audited && (added || removed)) {
+        msg.push('and ')
+      }
+
+      msg.push(`changed ${changed} package${changed === 1 ? '' : 's'}`)
+    }
+    if (audited) {
+      msg.push(', and ')
+    }
+  }
+  if (audited) {
+    msg.push(`audited ${audited} package${audited === 1 ? '' : 's'}`)
+  }
+
+  msg.push(` in ${ms(Date.now() - npm.started)}`)
+  output.standard(msg.join(''))
+}
+
+const packagesFundingMessage = (npm, { funding }) => {
+  if (!funding) {
+    return
+  }
+
+  output.standard()
+  const pkg = funding === 1 ? 'package' : 'packages'
+  const is = funding === 1 ? 'is' : 'are'
+  output.standard(`${funding} ${pkg} ${is} looking for funding`)
+  output.standard('  run `npm fund` for details')
+}
+
+module.exports = reifyOutput
diff --git a/node/node_modules/npm/lib/utils/sbom-cyclonedx.js b/node/node_modules/npm/lib/utils/sbom-cyclonedx.js
new file mode 100644
index 0000000000000000000000000000000000000000..16d21eeb64d0c73c3e348f3bf2f3b2fda6e2aaf3
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/sbom-cyclonedx.js
@@ -0,0 +1,203 @@
+const crypto = require('node:crypto')
+const parseLicense = require('spdx-expression-parse')
+const PackageJson = require('@npmcli/package-json')
+const npa = require('npm-package-arg')
+const ssri = require('ssri')
+
+const CYCLONEDX_SCHEMA = 'http://cyclonedx.org/schema/bom-1.5.schema.json'
+const CYCLONEDX_FORMAT = 'CycloneDX'
+const CYCLONEDX_SCHEMA_VERSION = '1.5'
+
+const PROP_BUNDLED = 'cdx:npm:package:bundled'
+const PROP_DEVELOPMENT = 'cdx:npm:package:development'
+const PROP_EXTRANEOUS = 'cdx:npm:package:extraneous'
+const PROP_PRIVATE = 'cdx:npm:package:private'
+
+const REF_VCS = 'vcs'
+const REF_WEBSITE = 'website'
+const REF_ISSUE_TRACKER = 'issue-tracker'
+const REF_DISTRIBUTION = 'distribution'
+
+const ALGO_MAP = {
+  sha1: 'SHA-1',
+  sha256: 'SHA-256',
+  sha384: 'SHA-384',
+  sha512: 'SHA-512',
+}
+
+const cyclonedxOutput = ({ npm, nodes, packageType, packageLockOnly }) => {
+  const rootNode = nodes.find(node => node.isRoot)
+  const childNodes = nodes.filter(node => !node.isRoot && !node.isLink)
+  const uuid = crypto.randomUUID()
+
+  // Create list of child nodes w/ unique IDs
+  const childNodeMap = new Map()
+  for (const item of childNodes) {
+    const id = toCyclonedxID(item)
+    if (!childNodeMap.has(id)) {
+      childNodeMap.set(id, item)
+    }
+  }
+  const uniqueChildNodes = Array.from(childNodeMap.values())
+
+  const deps = [rootNode, ...uniqueChildNodes]
+    .map(node => toCyclonedxDependency(node, nodes))
+
+  const bom = {
+    $schema: CYCLONEDX_SCHEMA,
+    bomFormat: CYCLONEDX_FORMAT,
+    specVersion: CYCLONEDX_SCHEMA_VERSION,
+    serialNumber: `urn:uuid:${uuid}`,
+    version: 1,
+    metadata: {
+      timestamp: new Date().toISOString(),
+      lifecycles: [
+        { phase: packageLockOnly ? 'pre-build' : 'build' },
+      ],
+      tools: [
+        {
+          vendor: 'npm',
+          name: 'cli',
+          version: npm.version,
+        },
+      ],
+      component: toCyclonedxItem(rootNode, { packageType }),
+    },
+    components: uniqueChildNodes.map(toCyclonedxItem),
+    dependencies: deps,
+  }
+
+  return bom
+}
+
+const toCyclonedxItem = (node, { packageType }) => {
+  packageType = packageType || 'library'
+
+  // Calculate purl from package spec
+  let spec = npa(node.pkgid)
+  spec = (spec.type === 'alias') ? spec.subSpec : spec
+  const purl = npa.toPurl(spec) + (isGitNode(node) ? `?vcs_url=${node.resolved}` : '')
+
+  if (node.package) {
+    const toNormalize = new PackageJson()
+    toNormalize.fromContent(node.package).normalize({ steps: ['normalizeData'] })
+    node.package = toNormalize.content
+  }
+
+  let license = node.package?.license
+  if (license) {
+    if (typeof license === 'object') {
+      license = license.type
+    }
+  } else if (Array.isArray(node.package?.licenses)) {
+    license = node.package.licenses
+      .map(l => (typeof l === 'object' ? l.type : l))
+      .filter(Boolean)
+      .join(' OR ')
+  }
+
+  let parsedLicense
+  try {
+    parsedLicense = parseLicense(license)
+  } catch {
+    parsedLicense = null
+  }
+
+  const component = {
+    'bom-ref': toCyclonedxID(node),
+    type: packageType,
+    name: node.name,
+    version: node.version,
+    scope: (node.optional || node.devOptional) ? 'optional' : 'required',
+    author: (typeof node.package?.author === 'object')
+      ? node.package.author.name
+      : (node.package?.author || undefined),
+    description: node.package?.description || undefined,
+    purl: purl,
+    properties: [],
+    externalReferences: [],
+  }
+
+  if (node.integrity) {
+    const integrity = ssri.parse(node.integrity, { single: true })
+    component.hashes = [{
+      alg: ALGO_MAP[integrity.algorithm] || /* istanbul ignore next */ 'SHA-512',
+      content: integrity.hexDigest(),
+    }]
+  }
+
+  if (node.dev === true) {
+    component.properties.push(prop(PROP_DEVELOPMENT))
+  }
+
+  if (node.package?.private === true) {
+    component.properties.push(prop(PROP_PRIVATE))
+  }
+
+  if (node.extraneous === true) {
+    component.properties.push(prop(PROP_EXTRANEOUS))
+  }
+
+  if (node.inBundle === true) {
+    component.properties.push(prop(PROP_BUNDLED))
+  }
+
+  if (!node.isLink && node.resolved) {
+    component.externalReferences.push(extRef(REF_DISTRIBUTION, node.resolved))
+  }
+
+  if (node.package?.repository?.url) {
+    component.externalReferences.push(extRef(REF_VCS, node.package.repository.url))
+  }
+
+  if (node.package?.homepage) {
+    component.externalReferences.push(extRef(REF_WEBSITE, node.package.homepage))
+  }
+
+  if (node.package?.bugs?.url) {
+    component.externalReferences.push(extRef(REF_ISSUE_TRACKER, node.package.bugs.url))
+  }
+
+  // If license is a single SPDX license, use the license field
+  if (parsedLicense?.license) {
+    component.licenses = [{ license: { id: parsedLicense.license } }]
+    // If license is a conjunction, use the expression field
+  } else if (parsedLicense?.conjunction) {
+    component.licenses = [{ expression: license }]
+  }
+
+  return component
+}
+
+const toCyclonedxDependency = (node, nodes) => {
+  return {
+    ref: toCyclonedxID(node),
+    dependsOn: [...node.edgesOut.values()]
+      // Filter out edges that are linking to nodes not in the list
+      .filter(edge => nodes.find(n => n === edge.to))
+      .map(edge => toCyclonedxID(edge.to))
+      .filter(id => id),
+  }
+}
+
+const toCyclonedxID = (node) => `${node.packageName}@${node.version}`
+
+const prop = (name) => ({ name, value: 'true' })
+
+const extRef = (type, url) => ({ type, url })
+
+const isGitNode = (node) => {
+  if (!node.resolved) {
+    return
+  }
+
+  try {
+    const { type } = npa(node.resolved)
+    return type === 'git' || type === 'hosted'
+  } catch {
+    /* istanbul ignore next */
+    return false
+  }
+}
+
+module.exports = { cyclonedxOutput }
diff --git a/node/node_modules/npm/lib/utils/sbom-spdx.js b/node/node_modules/npm/lib/utils/sbom-spdx.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e9ea638577365d21e3223721a9108a7da963498
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/sbom-spdx.js
@@ -0,0 +1,199 @@
+
+const crypto = require('node:crypto')
+const PackageJson = require('@npmcli/package-json')
+const npa = require('npm-package-arg')
+const ssri = require('ssri')
+
+const SPDX_SCHEMA_VERSION = 'SPDX-2.3'
+const SPDX_DATA_LICENSE = 'CC0-1.0'
+const SPDX_IDENTIFER = 'SPDXRef-DOCUMENT'
+
+const NO_ASSERTION = 'NOASSERTION'
+
+const REL_DESCRIBES = 'DESCRIBES'
+const REL_PREREQ = 'PREREQUISITE_FOR'
+const REL_OPTIONAL = 'OPTIONAL_DEPENDENCY_OF'
+const REL_DEV = 'DEV_DEPENDENCY_OF'
+const REL_DEP = 'DEPENDENCY_OF'
+
+const REF_CAT_PACKAGE_MANAGER = 'PACKAGE-MANAGER'
+const REF_TYPE_PURL = 'purl'
+
+const spdxOutput = ({ npm, nodes, packageType }) => {
+  const rootNode = nodes.find(node => node.isRoot)
+  const childNodes = nodes.filter(node => !node.isRoot && !node.isLink)
+  const rootID = rootNode.pkgid
+  const uuid = crypto.randomUUID()
+  const ns = `http://spdx.org/spdxdocs/${npa(rootID).escapedName}-${rootNode.version}-${uuid}`
+
+  // Create list of child nodes w/ unique IDs
+  const childNodeMap = new Map()
+  for (const item of childNodes) {
+    const id = toSpdxID(item)
+    if (!childNodeMap.has(id)) {
+      childNodeMap.set(id, item)
+    }
+  }
+  const uniqueChildNodes = Array.from(childNodeMap.values())
+
+  const relationships = []
+  const seen = new Set()
+  for (let node of nodes) {
+    if (node.isLink) {
+      node = node.target
+    }
+
+    if (seen.has(node)) {
+      continue
+    }
+    seen.add(node)
+
+    const rels = [...node.edgesOut.values()]
+      // Filter out edges that are linking to nodes not in the list
+      .filter(edge => nodes.find(n => n === edge.to))
+      .map(edge => toSpdxRelationship(node, edge))
+      .filter(rel => rel)
+
+    relationships.push(...rels)
+  }
+
+  const extraRelationships = nodes.filter(node => node.extraneous)
+    .map(node => toSpdxRelationship(rootNode, { to: node, type: 'optional' }))
+
+  relationships.push(...extraRelationships)
+
+  const bom = {
+    spdxVersion: SPDX_SCHEMA_VERSION,
+    dataLicense: SPDX_DATA_LICENSE,
+    SPDXID: SPDX_IDENTIFER,
+    name: rootID,
+    documentNamespace: ns,
+    creationInfo: {
+      created: new Date().toISOString(),
+      creators: [
+        `Tool: npm/cli-${npm.version}`,
+      ],
+    },
+    documentDescribes: [toSpdxID(rootNode)],
+    packages: [toSpdxItem(rootNode, { packageType }), ...uniqueChildNodes.map(toSpdxItem)],
+    relationships: [
+      {
+        spdxElementId: SPDX_IDENTIFER,
+        relatedSpdxElement: toSpdxID(rootNode),
+        relationshipType: REL_DESCRIBES,
+      },
+      ...relationships,
+    ],
+  }
+
+  return bom
+}
+
+const toSpdxItem = (node, { packageType }) => {
+  const toNormalize = new PackageJson()
+  toNormalize.fromContent(node.package).normalize({ steps: ['normalizeData'] })
+  node.package = toNormalize.content
+
+  // Calculate purl from package spec
+  let spec = npa(node.pkgid)
+  spec = (spec.type === 'alias') ? spec.subSpec : spec
+  const purl = npa.toPurl(spec) + (isGitNode(node) ? `?vcs_url=${node.resolved}` : '')
+
+  /* For workspace nodes, use the location from their linkNode */
+  let location = node.location
+  if (node.isWorkspace && node.linksIn.size > 0) {
+    location = node.linksIn.values().next().value.location
+  }
+
+  let license = node.package?.license
+  if (license) {
+    if (typeof license === 'object') {
+      license = license.type
+    }
+  } else if (Array.isArray(node.package?.licenses)) {
+    license = node.package.licenses
+      .map(l => (typeof l === 'object' ? l.type : l))
+      .filter(Boolean)
+      .join(' OR ')
+  }
+
+  const pkg = {
+    name: node.packageName,
+    SPDXID: toSpdxID(node),
+    versionInfo: node.version,
+    packageFileName: location,
+    description: node.package?.description || undefined,
+    primaryPackagePurpose: packageType ? packageType.toUpperCase() : undefined,
+    downloadLocation: (node.isLink ? undefined : node.resolved) || NO_ASSERTION,
+    filesAnalyzed: false,
+    homepage: node.package?.homepage || NO_ASSERTION,
+    licenseDeclared: license || NO_ASSERTION,
+    externalRefs: [
+      {
+        referenceCategory: REF_CAT_PACKAGE_MANAGER,
+        referenceType: REF_TYPE_PURL,
+        referenceLocator: purl,
+      },
+    ],
+  }
+
+  if (node.integrity) {
+    const integrity = ssri.parse(node.integrity, { single: true })
+    pkg.checksums = [{
+      algorithm: integrity.algorithm.toUpperCase(),
+      checksumValue: integrity.hexDigest(),
+    }]
+  }
+  return pkg
+}
+
+const toSpdxRelationship = (node, edge) => {
+  let type
+  switch (edge.type) {
+    case 'peer':
+      type = REL_PREREQ
+      break
+    case 'optional':
+      type = REL_OPTIONAL
+      break
+    case 'dev':
+      type = REL_DEV
+      break
+    default:
+      type = REL_DEP
+  }
+
+  return {
+    spdxElementId: toSpdxID(edge.to),
+    relatedSpdxElement: toSpdxID(node),
+    relationshipType: type,
+  }
+}
+
+const toSpdxID = (node) => {
+  let name = node.packageName
+
+  // Strip leading @ for scoped packages
+  name = name.replace(/^@/, '')
+
+  // Replace slashes with dots
+  name = name.replace(/\//g, '.')
+
+  return `SPDXRef-Package-${name}-${node.version}`
+}
+
+const isGitNode = (node) => {
+  if (!node.resolved) {
+    return
+  }
+
+  try {
+    const { type } = npa(node.resolved)
+    return type === 'git' || type === 'hosted'
+  } catch {
+    /* istanbul ignore next */
+    return false
+  }
+}
+
+module.exports = { spdxOutput }
diff --git a/node/node_modules/npm/lib/utils/tar.js b/node/node_modules/npm/lib/utils/tar.js
new file mode 100644
index 0000000000000000000000000000000000000000..14ad3db0aeb1bb7c941b96cb701c243fd358aeec
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/tar.js
@@ -0,0 +1,109 @@
+const tar = require('tar')
+const ssri = require('ssri')
+const { log, output } = require('proc-log')
+const formatBytes = require('./format-bytes.js')
+const localeCompare = require('@isaacs/string-locale-compare')('en', {
+  sensitivity: 'case',
+  numeric: true,
+})
+
+const logTar = (tarball, { unicode = false, json, key } = {}) => {
+  if (json) {
+    output.buffer(key == null ? tarball : { [key]: tarball })
+    return
+  }
+  log.notice('')
+  log.notice('', `${unicode ? '📦 ' : 'package:'} ${tarball.name}@${tarball.version}`)
+  log.notice('Tarball Contents')
+  if (tarball.files.length) {
+    log.notice(
+      '',
+      tarball.files.map(f =>
+        /^node_modules\//.test(f.path) ? null : `${formatBytes(f.size, false)} ${f.path}`
+      ).filter(f => f).join('\n')
+    )
+  }
+  if (tarball.bundled.length) {
+    log.notice('Bundled Dependencies')
+    tarball.bundled.forEach(name => log.notice('', name))
+  }
+  log.notice('Tarball Details')
+  log.notice('', `name: ${tarball.name}`)
+  log.notice('', `version: ${tarball.version}`)
+  if (tarball.filename) {
+    log.notice('', `filename: ${tarball.filename}`)
+  }
+  log.notice('', `package size: ${formatBytes(tarball.size)}`)
+  log.notice('', `unpacked size: ${formatBytes(tarball.unpackedSize)}`)
+  log.notice('', `shasum: ${tarball.shasum}`)
+  log.notice('', `integrity: ${tarball.integrity.toString().slice(0, 20)}[...]${tarball.integrity.toString().slice(80)}`)
+  if (tarball.bundled.length) {
+    log.notice('', `bundled deps: ${tarball.bundled.length}`)
+    log.notice('', `bundled files: ${tarball.entryCount - tarball.files.length}`)
+    log.notice('', `own files: ${tarball.files.length}`)
+  }
+  log.notice('', `total files: ${tarball.entryCount}`)
+  log.notice('', '')
+}
+
+const getContents = async (manifest, tarball) => {
+  const files = []
+  const bundled = new Set()
+  let totalEntries = 0
+  let totalEntrySize = 0
+
+  // reads contents of tarball
+  const stream = tar.t({
+    onentry (entry) {
+      totalEntries++
+      totalEntrySize += entry.size
+      const p = entry.path
+      if (p.startsWith('package/node_modules/') && p !== 'package/node_modules/') {
+        const name = p.match(/^package\/node_modules\/((?:@[^/]+\/)?[^/]+)/)[1]
+        bundled.add(name)
+      }
+      files.push({
+        path: entry.path.replace(/^package\//, ''),
+        size: entry.size,
+        mode: entry.mode,
+      })
+    },
+  })
+  stream.end(tarball)
+
+  const integrity = ssri.fromData(tarball, {
+    algorithms: ['sha1', 'sha512'],
+  })
+
+  const comparator = ({ path: a }, { path: b }) => localeCompare(a, b)
+
+  const isUpper = str => {
+    const ch = str.charAt(0)
+    return ch === ch.toUpperCase()
+  }
+
+  const uppers = files.filter(file => isUpper(file.path))
+  const others = files.filter(file => !isUpper(file.path))
+
+  uppers.sort(comparator)
+  others.sort(comparator)
+
+  const shasum = integrity.sha1[0].hexDigest()
+  return {
+    id: manifest._id || `${manifest.name}@${manifest.version}`,
+    name: manifest.name,
+    version: manifest.version,
+    size: tarball.length,
+    unpackedSize: totalEntrySize,
+    shasum,
+    integrity: ssri.parse(integrity.sha512[0]),
+    // @scope/packagename.tgz => scope-packagename.tgz
+    // we can safely use these global replace rules due to npm package naming rules
+    filename: `${manifest.name.replace('@', '').replace('/', '-')}-${manifest.version}.tgz`,
+    files: uppers.concat(others),
+    entryCount: totalEntries,
+    bundled: Array.from(bundled),
+  }
+}
+
+module.exports = { logTar, getContents }
diff --git a/node/node_modules/npm/lib/utils/timers.js b/node/node_modules/npm/lib/utils/timers.js
new file mode 100644
index 0000000000000000000000000000000000000000..3274474000a99d2e389c5e0317a4756fedd6d33a
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/timers.js
@@ -0,0 +1,89 @@
+const EE = require('node:events')
+const fs = require('node:fs')
+const { log, time } = require('proc-log')
+
+const INITIAL_TIMER = 'npm'
+
+class Timers extends EE {
+  #file
+  #timing
+
+  #unfinished = new Map()
+  #finished = {}
+
+  constructor () {
+    super()
+    this.on()
+    time.start(INITIAL_TIMER)
+    this.started = this.#unfinished.get(INITIAL_TIMER)
+  }
+
+  on () {
+    process.on('time', this.#timeHandler)
+  }
+
+  off () {
+    process.off('time', this.#timeHandler)
+  }
+
+  load ({ path, timing } = {}) {
+    this.#timing = timing
+    this.#file = `${path}timing.json`
+  }
+
+  finish (metadata) {
+    time.end(INITIAL_TIMER)
+
+    for (const [name, timer] of this.#unfinished) {
+      log.silly('unfinished npm timer', name, timer)
+    }
+
+    if (!this.#timing) {
+      // Not in timing mode, nothing else to do here
+      return
+    }
+
+    try {
+      this.#writeFile(metadata)
+      log.info('timing', `Timing info written to: ${this.#file}`)
+    } catch (e) {
+      log.warn('timing', `could not write timing file: ${e}`)
+    }
+  }
+
+  #writeFile (metadata) {
+    const globalStart = this.started
+    const globalEnd = this.#finished[INITIAL_TIMER]
+    const content = {
+      metadata,
+      timers: this.#finished,
+      // add any unfinished timers with their relative start/end
+      unfinishedTimers: [...this.#unfinished.entries()].reduce((acc, [name, start]) => {
+        acc[name] = [start - globalStart, globalEnd - globalStart]
+        return acc
+      }, {}),
+    }
+    fs.writeFileSync(this.#file, JSON.stringify(content) + '\n')
+  }
+
+  #timeHandler = (level, name) => {
+    const now = Date.now()
+    switch (level) {
+      case time.KEYS.start:
+        this.#unfinished.set(name, now)
+        break
+      case time.KEYS.end: {
+        if (this.#unfinished.has(name)) {
+          const ms = now - this.#unfinished.get(name)
+          this.#finished[name] = ms
+          this.#unfinished.delete(name)
+          log.timing(name, `Completed in ${ms}ms`)
+        } else {
+          log.silly('timing', `Tried to end timer that doesn't exist: ${name}`)
+        }
+      }
+    }
+  }
+}
+
+module.exports = Timers
diff --git a/node/node_modules/npm/lib/utils/update-workspaces.js b/node/node_modules/npm/lib/utils/update-workspaces.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fc9467d5671a855a63c5f4b04093effb98d21a4
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/update-workspaces.js
@@ -0,0 +1,37 @@
+'use strict'
+
+const reifyFinish = require('../utils/reify-finish.js')
+
+async function updateWorkspaces ({
+  config,
+  flatOptions,
+  localPrefix,
+  npm,
+  workspaces,
+}) {
+  if (!flatOptions.workspacesUpdate || !workspaces.length) {
+    return
+  }
+
+  // default behavior is to not save by default in order to avoid race condition problems when publishing multiple workspaces that have dependencies on one another
+  // it might still be useful in some cases, which then need to set --save
+  const save = config.isDefault('save')
+    ? false
+    : config.get('save')
+
+  // runs a minimalistic reify update, targeting only the workspaces that had version updates and skipping fund/audit/save
+  const opts = {
+    ...flatOptions,
+    audit: false,
+    fund: false,
+    path: localPrefix,
+    save,
+  }
+  const Arborist = require('@npmcli/arborist')
+  const arb = new Arborist(opts)
+
+  await arb.reify({ ...opts, update: workspaces })
+  await reifyFinish(npm, arb)
+}
+
+module.exports = updateWorkspaces
diff --git a/node/node_modules/npm/lib/utils/validate-lockfile.js b/node/node_modules/npm/lib/utils/validate-lockfile.js
new file mode 100644
index 0000000000000000000000000000000000000000..addd6e2944523b70039ff5b3fda6e16b6f0cdf3b
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/validate-lockfile.js
@@ -0,0 +1,29 @@
+// compares the inventory of package items in the tree
+// that is about to be installed (idealTree) with the inventory
+// of items stored in the package-lock file (virtualTree)
+//
+// Returns empty array if no errors found or an array populated
+// with an entry for each validation error found.
+function validateLockfile (virtualTree, idealTree) {
+  const errors = []
+
+  // loops through the inventory of packages resulted by ideal tree,
+  // for each package compares the versions with the version stored in the
+  // package-lock and adds an error to the list in case of mismatches
+  for (const [key, entry] of idealTree.entries()) {
+    const lock = virtualTree.get(key)
+
+    if (!lock) {
+      errors.push(`Missing: ${entry.name}@${entry.version} from lock file`)
+      continue
+    }
+
+    if (entry.version !== lock.version) {
+      errors.push(`Invalid: lock file's ${lock.name}@${lock.version} does ` +
+      `not satisfy ${entry.name}@${entry.version}`)
+    }
+  }
+  return errors
+}
+
+module.exports = validateLockfile
diff --git a/node/node_modules/npm/lib/utils/verify-signatures.js b/node/node_modules/npm/lib/utils/verify-signatures.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3691941dbc64dd84f2eefa10ce83907751c3a43
--- /dev/null
+++ b/node/node_modules/npm/lib/utils/verify-signatures.js
@@ -0,0 +1,392 @@
+const npmFetch = require('npm-registry-fetch')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const npa = require('npm-package-arg')
+const pacote = require('pacote')
+const tufClient = require('@sigstore/tuf')
+const { log, output } = require('proc-log')
+
+const sortAlphabetically = (a, b) => localeCompare(a.name, b.name)
+
+class VerifySignatures {
+  constructor (tree, filterSet, npm, opts) {
+    this.tree = tree
+    this.filterSet = filterSet
+    this.npm = npm
+    this.opts = opts
+    this.keys = new Map()
+    this.invalid = []
+    this.missing = []
+    this.checkedPackages = new Set()
+    this.verified = []
+    this.auditedWithKeysCount = 0
+    this.verifiedSignatureCount = 0
+    this.verifiedAttestationCount = 0
+    this.exitCode = 0
+  }
+
+  async run () {
+    const start = process.hrtime.bigint()
+    const { default: pMap } = await import('p-map')
+
+    // Find all deps in tree
+    const { edges, registries } = this.getEdgesOut(this.tree.inventory.values(), this.filterSet)
+    if (edges.size === 0) {
+      throw new Error('found no installed dependencies to audit')
+    }
+
+    const tuf = await tufClient.initTUF({
+      cachePath: this.opts.tufCache,
+      retry: this.opts.retry,
+      timeout: this.opts.timeout,
+    })
+    await Promise.all([...registries].map(registry => this.setKeys({ registry, tuf })))
+
+    log.verbose('verifying registry signatures')
+    await pMap(edges, (e) => this.getVerifiedInfo(e), { concurrency: 20, stopOnError: true })
+
+    // Didn't find any dependencies that could be verified, e.g. only local deps, missing version, not on a registry etc.
+    if (!this.auditedWithKeysCount && !this.verifiedAttestationCount) {
+      throw new Error('found no dependencies to audit that were installed from ' +
+                      'a supported registry')
+    }
+
+    const invalid = this.invalid.sort(sortAlphabetically)
+    const missing = this.missing.sort(sortAlphabetically)
+
+    const hasNoInvalidOrMissing = invalid.length === 0 && missing.length === 0
+
+    if (!hasNoInvalidOrMissing) {
+      process.exitCode = 1
+    }
+
+    if (this.npm.config.get('json')) {
+      const result = { invalid, missing }
+      if (this.npm.config.get('include-attestations')) {
+        result.verified = this.verified
+      }
+      output.buffer(result)
+      return
+    }
+    const end = process.hrtime.bigint()
+    const elapsed = end - start
+
+    const auditedPlural = this.auditedWithKeysCount > 1 ? 's' : ''
+    const timing = `audited ${this.auditedWithKeysCount} package${auditedPlural} in ` +
+      `${Math.floor(Number(elapsed) / 1e9)}s`
+    output.standard(timing)
+    output.standard()
+
+    const verifiedBold = this.npm.chalk.bold('verified')
+    if (this.verifiedSignatureCount) {
+      if (this.verifiedSignatureCount === 1) {
+        output.standard(`${this.verifiedSignatureCount} package has a ${verifiedBold} registry signature`)
+      } else {
+        output.standard(`${this.verifiedSignatureCount} packages have ${verifiedBold} registry signatures`)
+      }
+      output.standard()
+    }
+
+    if (this.verifiedAttestationCount) {
+      if (this.verifiedAttestationCount === 1) {
+        output.standard(`${this.verifiedAttestationCount} package has a ${verifiedBold} attestation`)
+      } else {
+        output.standard(`${this.verifiedAttestationCount} packages have ${verifiedBold} attestations`)
+      }
+      if (!this.npm.config.get('include-attestations')) {
+        output.standard('(use --json --include-attestations to view attestation details)')
+      }
+      output.standard()
+    }
+
+    if (missing.length) {
+      const missingClr = this.npm.chalk.redBright('missing')
+      if (missing.length === 1) {
+        output.standard(`1 package has a ${missingClr} registry signature but the registry is providing signing keys:`)
+      } else {
+        output.standard(`${missing.length} packages have ${missingClr} registry signatures but the registry is providing signing keys:`)
+      }
+      output.standard()
+      missing.map(m =>
+        output.standard(`${this.npm.chalk.red(`${m.name}@${m.version}`)} (${m.registry})`)
+      )
+    }
+
+    if (invalid.length) {
+      if (missing.length) {
+        output.standard()
+      }
+      const invalidClr = this.npm.chalk.redBright('invalid')
+      // We can have either invalid signatures or invalid provenance
+      const invalidSignatures = this.invalid.filter(i => i.code === 'EINTEGRITYSIGNATURE')
+      if (invalidSignatures.length) {
+        if (invalidSignatures.length === 1) {
+          output.standard(`1 package has an ${invalidClr} registry signature:`)
+        } else {
+          output.standard(`${invalidSignatures.length} packages have ${invalidClr} registry signatures:`)
+        }
+        output.standard()
+        invalidSignatures.map(i =>
+          output.standard(`${this.npm.chalk.red(`${i.name}@${i.version}`)} (${i.registry})`)
+        )
+        output.standard()
+      }
+
+      const invalidAttestations = this.invalid.filter(i => i.code === 'EATTESTATIONVERIFY')
+      if (invalidAttestations.length) {
+        if (invalidAttestations.length === 1) {
+          output.standard(`1 package has an ${invalidClr} attestation:`)
+        } else {
+          output.standard(`${invalidAttestations.length} packages have ${invalidClr} attestations:`)
+        }
+        output.standard()
+        invalidAttestations.map(i =>
+          output.standard(`${this.npm.chalk.red(`${i.name}@${i.version}`)} (${i.registry})`)
+        )
+        output.standard()
+      }
+
+      if (invalid.length === 1) {
+        output.standard(`Someone might have tampered with this package since it was published on the registry!`)
+      } else {
+        output.standard(`Someone might have tampered with these packages since they were published on the registry!`)
+      }
+      output.standard()
+    }
+  }
+
+  getEdgesOut (nodes, filterSet) {
+    const edges = new Set()
+    const registries = new Set()
+    for (const node of nodes) {
+      for (const edge of node.edgesOut.values()) {
+        const filteredOut =
+          edge.from
+            && filterSet
+            && filterSet.size > 0
+            && !filterSet.has(edge.from.target)
+
+        if (!filteredOut) {
+          const spec = this.getEdgeSpec(edge)
+          if (spec) {
+            // Prefetch and cache public keys from used registries
+            registries.add(this.getSpecRegistry(spec))
+          }
+          edges.add(edge)
+        }
+      }
+    }
+    return { edges, registries }
+  }
+
+  async setKeys ({ registry, tuf }) {
+    const { host, pathname } = new URL(registry)
+    // Strip any trailing slashes from pathname
+    const regKey = `${host}${pathname.replace(/\/$/, '')}/keys.json`
+    let keys = await tuf.getTarget(regKey)
+      .then((target) => JSON.parse(target))
+      .then(({ keys: ks }) => ks.map((key) => ({
+        ...key,
+        keyid: key.keyId,
+        pemkey: `-----BEGIN PUBLIC KEY-----\n${key.publicKey.rawBytes}\n-----END PUBLIC KEY-----`,
+        expires: key.publicKey.validFor.end || null,
+      }))).catch(err => {
+        if (err.code === 'TUF_FIND_TARGET_ERROR') {
+          return null
+        } else {
+          throw err
+        }
+      })
+
+    // If keys not found in Sigstore TUF repo, fall back to registry keys API
+    if (!keys) {
+      log.warn(`Fetching verification keys using TUF failed.  Fetching directly from ${registry}.`)
+      keys = await npmFetch.json('/-/npm/v1/keys', {
+        ...this.npm.flatOptions,
+        registry,
+      }).then(({ keys: ks }) => ks.map((key) => ({
+        ...key,
+        pemkey: `-----BEGIN PUBLIC KEY-----\n${key.key}\n-----END PUBLIC KEY-----`,
+      }))).catch(err => {
+        if (err.code === 'E404' || err.code === 'E400') {
+          return null
+        } else {
+          throw err
+        }
+      })
+    }
+
+    if (keys) {
+      this.keys.set(registry, keys)
+    }
+  }
+
+  getEdgeType (edge) {
+    return edge.optional ? 'optionalDependencies'
+      : edge.peer ? 'peerDependencies'
+      : edge.dev ? 'devDependencies'
+      : 'dependencies'
+  }
+
+  getEdgeSpec (edge) {
+    let name = edge.name
+    try {
+      name = npa(edge.spec).subSpec.name
+    } catch {
+      // leave it as edge.name
+    }
+    try {
+      return npa(`${name}@${edge.spec}`)
+    } catch {
+      // Skip packages with invalid spec
+    }
+  }
+
+  buildRegistryConfig (registry) {
+    const keys = this.keys.get(registry) || []
+    const parsedRegistry = new URL(registry)
+    const regKey = `//${parsedRegistry.host}${parsedRegistry.pathname}`
+    return {
+      [`${regKey}:_keys`]: keys,
+    }
+  }
+
+  getSpecRegistry (spec) {
+    return npmFetch.pickRegistry(spec, this.npm.flatOptions)
+  }
+
+  getValidPackageInfo (edge) {
+    const type = this.getEdgeType(edge)
+    // Skip potentially optional packages that are not on disk, as these could
+    // be omitted during install
+    if (edge.error === 'MISSING' && type !== 'dependencies') {
+      return
+    }
+
+    const spec = this.getEdgeSpec(edge)
+    // Skip invalid version requirements
+    if (!spec) {
+      return
+    }
+    const node = edge.to || edge
+    const { version } = node.package || {}
+
+    if (node.isWorkspace || // Skip local workspaces packages
+        !version || // Skip packages that don't have an installed version, e.g. optional dependencies
+        !spec.registry) { // Skip if not from registry, e.g. git package
+      return
+    }
+
+    for (const omitType of this.npm.config.get('omit')) {
+      if (node[omitType]) {
+        return
+      }
+    }
+
+    return {
+      name: spec.name,
+      version,
+      type,
+      location: node.location,
+      registry: this.getSpecRegistry(spec),
+    }
+  }
+
+  async verifySignatures (name, version, registry) {
+    const {
+      _integrity: integrity,
+      _signatures,
+      _attestations,
+      _attestationBundles,
+      _resolved: resolved,
+    } = await pacote.manifest(`${name}@${version}`, {
+      verifySignatures: true,
+      verifyAttestations: true,
+      ...this.buildRegistryConfig(registry),
+      ...this.npm.flatOptions,
+    })
+    const signatures = _signatures || []
+    const result = {
+      integrity,
+      signatures,
+      attestations: _attestations,
+      attestationBundles: _attestationBundles,
+      resolved,
+    }
+    return result
+  }
+
+  async getVerifiedInfo (edge) {
+    const info = this.getValidPackageInfo(edge)
+    if (!info) {
+      return
+    }
+    const { name, version, location, registry, type } = info
+    if (this.checkedPackages.has(location)) {
+      // we already did or are doing this one
+      return
+    }
+    this.checkedPackages.add(location)
+
+    // We only "audit" or verify the signature, or the presence of it, on packages whose registry returns signing keys
+    const keys = this.keys.get(registry) || []
+    if (keys.length) {
+      this.auditedWithKeysCount += 1
+    }
+
+    try {
+      const { integrity, signatures, attestations, attestationBundles, resolved } =
+        await this.verifySignatures(name, version, registry)
+
+      // Currently we only care about missing signatures on registries that provide a public key
+      // We could make this configurable in the future with a strict/paranoid mode
+      if (signatures.length) {
+        this.verifiedSignatureCount += 1
+      } else if (keys.length) {
+        this.missing.push({
+          integrity,
+          location,
+          name,
+          registry,
+          resolved,
+          version,
+        })
+      }
+
+      // Track verified attestations separately to registry signatures, as all packages on registries with signing keys are expected to have registry signatures, but not all packages have provenance and publish attestations.
+      if (attestations) {
+        this.verifiedAttestationCount += 1
+        if (this.npm.config.get('include-attestations')) {
+          this.verified.push({
+            name,
+            version,
+            location,
+            registry,
+            attestations,
+            attestationBundles,
+          })
+        }
+      }
+    } catch (e) {
+      if (e.code === 'EINTEGRITYSIGNATURE' || e.code === 'EATTESTATIONVERIFY') {
+        this.invalid.push({
+          code: e.code,
+          message: e.message,
+          integrity: e.integrity,
+          keyid: e.keyid,
+          location,
+          name,
+          registry,
+          resolved: e.resolved,
+          signature: e.signature,
+          predicateType: e.predicateType,
+          type,
+          version,
+        })
+      } else {
+        throw e
+      }
+    }
+  }
+}
+
+module.exports = VerifySignatures
diff --git a/node/node_modules/npm/man/man1/npm-access.1 b/node/node_modules/npm/man/man1/npm-access.1
new file mode 100644
index 0000000000000000000000000000000000000000..95cab017cc2e9ab3726e8ac31d33076faeb05fc2
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-access.1
@@ -0,0 +1,105 @@
+.TH "NPM-ACCESS" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-access\fR - Set access level on published packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm access list packages \[lB]<user>|<scope>|<scope:team>\[rB] \[lB]<package>\[rB]
+npm access list collaborators \[lB]<package> \[lB]<user>\[rB]\[rB]
+npm access get status \[lB]<package>\[rB]
+npm access set status=public|private \[lB]<package>\[rB]
+npm access set mfa=none|publish|automation \[lB]<package>\[rB]
+npm access grant <read-only|read-write> <scope:team> \[lB]<package>\[rB]
+npm access revoke <scope:team> \[lB]<package>\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Used to set access controls on private packages.
+.P
+For all of the subcommands, \fBnpm access\fR will perform actions on the packages in the current working directory if no package name is passed to the subcommand.
+.RS 0
+.IP \(bu 4
+grant / revoke: Add or remove the ability of users and teams to have read-only or read-write access to a package.
+.RE 0
+
+.SS "Details"
+.P
+\fBnpm access\fR always operates directly on the current registry, configurable from the command line using \fB--registry=<registry url>\fR.
+.P
+Unscoped packages are \fIalways public\fR.
+.P
+Scoped packages \fIdefault to restricted\fR, but you can either publish them as public using \fBnpm publish --access=public\fR, or set their access as public using \fBnpm access set status=public\fR after the initial publish.
+.P
+You must have privileges to set the access of a package:
+.RS 0
+.IP \(bu 4
+You are an owner of an unscoped or scoped package.
+.IP \(bu 4
+You are a member of the team that owns a scope.
+.IP \(bu 4
+You have been given read-write privileges for a package, either as a member of a team or directly as an owner.
+.RE 0
+
+.P
+If you have two-factor authentication enabled then you'll be prompted to provide a second factor, or may use the \fB--otp=...\fR option to specify it on the command line.
+.P
+If your account is not paid, then attempts to publish scoped packages will fail with an HTTP 402 status code (logically enough), unless you use \fB--access=public\fR.
+.P
+Management of teams and team memberships is done with the \fBnpm team\fR command.
+.SS "Configuration"
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+\fB\[rs]fBlibnpmaccess\[rs]fR\fR \fI\(lahttps://npm.im/libnpmaccess\(ra\fR
+.IP \(bu 4
+npm help team
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help registry
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-adduser.1 b/node/node_modules/npm/man/man1/npm-adduser.1
new file mode 100644
index 0000000000000000000000000000000000000000..04d2a53483c3270d2863456c9c40ceede5ee74d6
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-adduser.1
@@ -0,0 +1,93 @@
+.TH "NPM-ADDUSER" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-adduser\fR - Add a registry user account
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm adduser
+
+alias: add-user
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Create a new user in the specified registry, and save the credentials to the \fB.npmrc\fR file. If no registry is specified, the default registry will be used (see npm help registry).
+.P
+When you run \fBnpm adduser\fR, the CLI automatically generates a legacy token of \fBpublish\fR type. For more information, see \fBAbout legacy tokens\fR \fI\(la/about-access-tokens#about-legacy-tokens\(ra\fR.
+.P
+When using \fBlegacy\fR for your \fBauth-type\fR, the username, password, and email are read in from prompts.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBscope\fR"
+.RS 0
+.IP \(bu 4
+Default: the scope of the current project, if any, or ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Associate an operation with a scope for a scoped registry.
+.P
+Useful when logging in to or out of a private registry:
+.P
+.RS 2
+.nf
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+.fi
+.RE
+.P
+This will cause \fB@mycorp\fR to be mapped to the registry for future installation of packages specified according to the pattern \fB@mycorp/package\fR.
+.P
+This will also cause \fBnpm init\fR to create a scoped package.
+.P
+.RS 2
+.nf
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+.fi
+.RE
+.SS "\fBauth-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "web"
+.IP \(bu 4
+Type: "legacy" or "web"
+.RE 0
+
+.P
+What authentication strategy to use with \fBlogin\fR. Note that if an \fBotp\fR config is given, this value will always be set to \fBlegacy\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help token
+.IP \(bu 4
+npm help profile
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-audit.1 b/node/node_modules/npm/man/man1/npm-audit.1
new file mode 100644
index 0000000000000000000000000000000000000000..5eea419287181fe804e46e60c5e9e960457fcb8e
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-audit.1
@@ -0,0 +1,466 @@
+.TH "NPM-AUDIT" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-audit\fR - Run a security audit
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm audit \[lB]fix|signatures\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+The audit command submits a description of the dependencies configured in your project to your default registry and asks for a report of known vulnerabilities. If any vulnerabilities are found, then the impact and appropriate remediation will be calculated. If the \fBfix\fR argument is provided, then remediations will be applied to the package tree.
+.P
+The command will exit with a 0 exit code if no vulnerabilities were found.
+.P
+Note that some vulnerabilities cannot be fixed automatically and will require manual intervention or review. Also note that since \fBnpm audit fix\fR runs a full-fledged \fBnpm install\fR under the hood, all configs that apply to the installer will also apply to \fBnpm install\fR -- so things like \fBnpm audit fix --package-lock-only\fR will work as expected.
+.P
+By default, the audit command will exit with a non-zero code if any vulnerability is found. It may be useful in CI environments to include the \fB--audit-level\fR parameter to specify the minimum vulnerability level that will cause the command to fail. This option does not filter the report output, it simply changes the command's failure threshold.
+.SS "Package lock"
+.P
+By default npm requires a package-lock or shrinkwrap in order to run the audit. You can bypass the package lock with \fB--no-package-lock\fR but be aware the results may be different with every run, since npm will re-build the dependency tree each time.
+.SS "Audit Signatures"
+.P
+To ensure the integrity of packages you download from the public npm registry, or any registry that supports signatures, you can verify the registry signatures of downloaded packages using the npm CLI.
+.P
+Registry signatures can be verified using the following \fBaudit\fR command:
+.P
+.RS 2
+.nf
+$ npm audit signatures
+.fi
+.RE
+.P
+The \fBaudit signatures\fR command will also verify the provenance attestations of downloaded packages. Because provenance attestations are such a new feature, security features may be added to (or changed in) the attestation format over time. To ensure that you're always able to verify attestation signatures check that you're running the latest version of the npm CLI. Please note this often means updating npm beyond the version that ships with Node.js.
+.P
+To include the full sigstore attestation bundles in JSON output, use:
+.P
+.RS 2
+.nf
+$ npm audit signatures --json --include-attestations
+.fi
+.RE
+.P
+This adds a \fBverified\fR array to the JSON output containing the attestation bundles (DSSE envelopes, verification material, and transparency log entries) for each verified package.
+.P
+The npm CLI supports registry signatures and signing keys provided by any registry if the following conventions are followed:
+.RS 0
+.IP 1. 4
+Signatures are provided in the package's \fBpackument\fR in each published version within the \fBdist\fR object:
+.RE 0
+
+.P
+.RS 2
+.nf
+"dist":{
+  "..omitted..": "..omitted..",
+  "signatures": \[lB]{
+    "keyid": "SHA256:{{SHA256_PUBLIC_KEY}}",
+    "sig": "a312b9c3cb4a1b693e8ebac5ee1ca9cc01f2661c14391917dcb111517f72370809..."
+  }\[rB]
+}
+.fi
+.RE
+.P
+See this \fBexample\fR \fI\(lahttps://registry.npmjs.org/light-cycle/1.4.3\(ra\fR of a signed package from the public npm registry.
+.P
+The \fBsig\fR is generated using the following template: \fB${package.name}@${package.version}:${package.dist.integrity}\fR and the \fBkeyid\fR has to match one of the public signing keys below.
+.RS 0
+.IP 2. 4
+Public signing keys are provided at \fBregistry-host.tld/-/npm/v1/keys\fR in the following format:
+.RE 0
+
+.P
+.RS 2
+.nf
+{
+  "keys": \[lB]{
+    "expires": null,
+    "keyid": "SHA256:{{SHA256_PUBLIC_KEY}}",
+    "keytype": "ecdsa-sha2-nistp256",
+    "scheme": "ecdsa-sha2-nistp256",
+    "key": "{{B64_PUBLIC_KEY}}"
+  }\[rB]
+}
+.fi
+.RE
+.P
+Keys response:
+.RS 0
+.IP \(bu 4
+\fBexpires\fR: null or a simplified extended \fBISO 8601 format\fR \fI\(lahttps://en.wikipedia.org/wiki/ISO_8601\(ra\fR: \fBYYYY-MM-DDTHH:mm:ss.sssZ\fR
+.IP \(bu 4
+\fBkeyid\fR: sha256 fingerprint of the public key
+.IP \(bu 4
+\fBkeytype\fR: only \fBecdsa-sha2-nistp256\fR is currently supported by the npm CLI
+.IP \(bu 4
+\fBscheme\fR: only \fBecdsa-sha2-nistp256\fR is currently supported by the npm CLI
+.IP \(bu 4
+\fBkey\fR: base64 encoded public key
+.RE 0
+
+.P
+See this \fBexample key's response from the public npm registry\fR \fI\(lahttps://registry.npmjs.org/-/npm/v1/keys\(ra\fR.
+.SS "Audit Endpoints"
+.P
+There are two audit endpoints that npm may use to fetch vulnerability information: the \fBBulk Advisory\fR endpoint and the \fBQuick Audit\fR endpoint.
+.SS "Bulk Advisory Endpoint"
+.P
+As of version 7, npm uses the much faster \fBBulk Advisory\fR endpoint to optimize the speed of calculating audit results.
+.P
+npm will generate a JSON payload with the name and list of versions of each package in the tree, and POST it to the default configured registry at the path \fB/-/npm/v1/security/advisories/bulk\fR.
+.P
+Any packages in the tree that do not have a \fBversion\fR field in their package.json file will be ignored. If any \fB--omit\fR options are specified (either via the \fB\[rs]fB--omit\[rs]fR config\fR \fI\(la/using-npm/config#omit\(ra\fR, or one of the shorthands such as \fB--production\fR, \fB--only=dev\fR, and so on), then packages will be omitted from the submitted payload as appropriate.
+.P
+If the registry responds with an error, or with an invalid response, then npm will attempt to load advisory data from the \fBQuick Audit\fR endpoint.
+.P
+The expected result will contain a set of advisory objects for each dependency that matches the advisory range. Each advisory object contains a \fBname\fR, \fBurl\fR, \fBid\fR, \fBseverity\fR, \fBvulnerable_versions\fR, and \fBtitle\fR.
+.P
+npm then uses these advisory objects to calculate vulnerabilities and meta-vulnerabilities of the dependencies within the tree.
+.SS "Quick Audit Endpoint"
+.P
+If the \fBBulk Advisory\fR endpoint returns an error, or invalid data, npm will attempt to load advisory data from the \fBQuick Audit\fR endpoint, which is considerably slower in most cases.
+.P
+The full package tree as found in \fBpackage-lock.json\fR is submitted, along with the following pieces of additional metadata:
+.RS 0
+.IP \(bu 4
+\fBnpm_version\fR
+.IP \(bu 4
+\fBnode_version\fR
+.IP \(bu 4
+\fBplatform\fR
+.IP \(bu 4
+\fBarch\fR
+.IP \(bu 4
+\fBnode_env\fR
+.RE 0
+
+.P
+All packages in the tree are submitted to the Quick Audit endpoint. Omitted dependency types are skipped when generating the report.
+.SS "Scrubbing"
+.P
+Out of an abundance of caution, npm versions 5 and 6 would "scrub" any packages from the submitted report if their name contained a \fB/\fR character, so as to avoid leaking the names of potentially private packages or git URLs.
+.P
+However, in practice, this resulted in audits often failing to properly detect meta-vulnerabilities, because the tree would appear to be invalid due to missing dependencies, and prevented the detection of vulnerabilities in package trees that used git dependencies or private modules.
+.P
+This scrubbing has been removed from npm as of version 7.
+.SS "Calculating Meta-Vulnerabilities and Remediations"
+.P
+npm uses the \fB\[rs]fB@npmcli/metavuln-calculator\[rs]fR\fR \fI\(lahttp://npm.im/@npmcli/metavuln-calculator\(ra\fR module to turn a set of security advisories into a set of "vulnerability" objects. A "meta-vulnerability" is a dependency that is vulnerable by virtue of dependence on vulnerable versions of a vulnerable package.
+.P
+For example, if the package \fBfoo\fR is vulnerable in the range \fB>=1.0.2 <2.0.0\fR, and the package \fBbar\fR depends on \fBfoo@^1.1.0\fR, then that version of \fBbar\fR can only be installed by installing a vulnerable version of \fBfoo\fR. In this case, \fBbar\fR is a "metavulnerability".
+.P
+Once metavulnerabilities for a given package are calculated, they are cached in the \fB~/.npm\fR folder and only re-evaluated if the advisory range changes, or a new version of the package is published (in which case, the new version is checked for metavulnerable status as well).
+.P
+If the chain of metavulnerabilities extends all the way to the root project, and it cannot be updated without changing its dependency ranges, then \fBnpm audit fix\fR will require the \fB--force\fR option to apply the remediation. If remediations do not require changes to the dependency ranges, then all vulnerable packages will be updated to a version that does not have an advisory or metavulnerability posted against it.
+.SS "Exit Code"
+.P
+The \fBnpm audit\fR command will exit with a 0 exit code if no vulnerabilities were found. The \fBnpm audit fix\fR command will exit with 0 exit code if no vulnerabilities are found \fIor\fR if the remediation is able to successfully fix all vulnerabilities.
+.P
+If vulnerabilities were found the exit code will depend on the \fB\[rs]fBaudit-level\[rs]fR config\fR \fI\(la/using-npm/config#audit-level\(ra\fR.
+.SS "Examples"
+.P
+Scan your project for vulnerabilities and automatically install any compatible updates to vulnerable dependencies:
+.P
+.RS 2
+.nf
+$ npm audit fix
+.fi
+.RE
+.P
+Run \fBaudit fix\fR without modifying \fBnode_modules\fR, but still updating the pkglock:
+.P
+.RS 2
+.nf
+$ npm audit fix --package-lock-only
+.fi
+.RE
+.P
+Skip updating \fBdevDependencies\fR:
+.P
+.RS 2
+.nf
+$ npm audit fix --only=prod
+.fi
+.RE
+.P
+Have \fBaudit fix\fR install SemVer-major updates to toplevel dependencies, not just SemVer-compatible ones:
+.P
+.RS 2
+.nf
+$ npm audit fix --force
+.fi
+.RE
+.P
+Do a dry run to get an idea of what \fBaudit fix\fR will do, and \fIalso\fR output install information in JSON format:
+.P
+.RS 2
+.nf
+$ npm audit fix --dry-run --json
+.fi
+.RE
+.P
+Scan your project for vulnerabilities and just show the details, without fixing anything:
+.P
+.RS 2
+.nf
+$ npm audit
+.fi
+.RE
+.P
+Get the detailed audit report in JSON format:
+.P
+.RS 2
+.nf
+$ npm audit --json
+.fi
+.RE
+.P
+Fail an audit only if the results include a vulnerability with a level of moderate or higher:
+.P
+.RS 2
+.nf
+$ npm audit --audit-level=moderate
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBaudit-level\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "info", "low", "moderate", "high", "critical", or "none"
+.RE 0
+
+.P
+The minimum level of vulnerability for \fBnpm audit\fR to exit with a non-zero exit code.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBforce\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Removes various protections against unfortunate side effects, common mistakes, unnecessary performance degradation, and malicious input.
+.RS 0
+.IP \(bu 4
+Allow clobbering non-npm files in global installs.
+.IP \(bu 4
+Allow the \fBnpm version\fR command to work on an unclean git repository.
+.IP \(bu 4
+Allow deleting the cache folder with \fBnpm cache clean\fR.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of npm.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of \fBnode\fR, even if \fB--engine-strict\fR is enabled.
+.IP \(bu 4
+Allow \fBnpm audit fix\fR to install modules outside your stated dependency range (including SemVer-major changes).
+.IP \(bu 4
+Allow unpublishing all versions of a published package.
+.IP \(bu 4
+Allow conflicting peerDependencies to be installed in the root project.
+.IP \(bu 4
+Implicitly set \fB--yes\fR during \fBnpm init\fR.
+.IP \(bu 4
+Allow clobbering existing values in \fBnpm pkg\fR
+.IP \(bu 4
+Allow unpublishing of entire packages (not just a single version).
+.RE 0
+
+.P
+If you don't have a clear idea of what you want to do, it is strongly recommended that you do not use this option!
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBinclude-attestations\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When used with \fBnpm audit signatures --json\fR, includes the full sigstore attestation bundles in the JSON output for each verified package. The bundles contain DSSE envelopes, verification material, and transparency log entries.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help config
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-bugs.1 b/node/node_modules/npm/man/man1/npm-bugs.1
new file mode 100644
index 0000000000000000000000000000000000000000..948bb07db7e18b167c7491c60306fcef0d7fb3cc
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-bugs.1
@@ -0,0 +1,115 @@
+.TH "NPM-BUGS" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-bugs\fR - Report bugs for a package in a web browser
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm bugs \[lB]<pkgname> \[lB]<pkgname> ...\[rB]\[rB]
+
+alias: issues
+.fi
+.RE
+.SS "Description"
+.P
+This command tries to guess at the likely location of a package's bug tracker URL or the \fBmailto\fR URL of the support email, and then tries to open it using the \fB\[rs]fB--browser\[rs]fR config\fR \fI\(la/using-npm/config#browser\(ra\fR param. If no package name is provided, it will search for a \fBpackage.json\fR in the current folder and use the \fBname\fR property.
+.SS "Configuration"
+.SS "\fBbrowser\fR"
+.RS 0
+.IP \(bu 4
+Default: macOS: \fB"open"\fR, Windows: \fB"start"\fR, Others: \fB"xdg-open"\fR
+.IP \(bu 4
+Type: null, Boolean, or String
+.RE 0
+
+.P
+The browser that is called by npm commands to open websites.
+.P
+Set to \fBfalse\fR to suppress browser behavior and instead print urls to terminal.
+.P
+Set to \fBtrue\fR to use default system URL opener.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help docs
+.IP \(bu 4
+npm help view
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-cache.1 b/node/node_modules/npm/man/man1/npm-cache.1
new file mode 100644
index 0000000000000000000000000000000000000000..ccad4c0aa4d0babfbafe67b7101c030ba696ac87
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-cache.1
@@ -0,0 +1,95 @@
+.TH "NPM-CACHE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-cache\fR - Manipulates packages cache
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm cache add <package-spec>
+npm cache clean \[lB]<key>\[rB]
+npm cache ls \[lB]<name>@<version>\[rB]
+npm cache verify
+npm cache npx ls
+npm cache npx rm \[lB]<key>...\[rB]
+npm cache npx info <key>...
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Used to add, list, or clean the \fBnpm cache\fR folder. Also used to view info about entries in the \fBnpm exec\fR (aka \fBnpx\fR) cache folder.
+.SS "\fBnpm cache\fR"
+.RS 0
+.IP \(bu 4
+add: Add the specified packages to the local cache. This command is primarily intended to be used internally by npm, but it can provide a way to add data to the local installation cache explicitly.
+.IP \(bu 4
+clean: Delete a single entry or all entries out of the cache folder. Note that this is typically unnecessary, as npm's cache is self-healing and resistant to data corruption issues.
+.IP \(bu 4
+ls: List given entries or all entries in the local cache.
+.IP \(bu 4
+verify: Verify the contents of the cache folder, garbage collecting any unneeded data, and verifying the integrity of the cache index and all cached data.
+.RE 0
+
+.SS "\fBnpm cache npx\fR"
+.RS 0
+.IP \(bu 4
+ls: List all entries in the npx cache.
+.IP \(bu 4
+rm: Remove given entries or all entries from the npx cache.
+.IP \(bu 4
+info: Get detailed information about given entries in the npx cache.
+.RE 0
+
+.SS "Details"
+.P
+npm stores cache data in an opaque directory within the configured \fBcache\fR, named \fB_cacache\fR. This directory is a \fB\[rs]fBcacache\[rs]fR\fR \fI\(lahttp://npm.im/cacache\(ra\fR-based content-addressable cache that stores all http request data as well as other package-related data. This directory is primarily accessed through \fBpacote\fR, the library responsible for all package fetching as of npm@5.
+.P
+All data that passes through the cache is fully verified for integrity on both insertion and extraction. Cache corruption will either trigger an error, or signal to \fBpacote\fR that the data must be refetched, which it will do automatically. For this reason, it should never be necessary to clear the cache for any reason other than reclaiming disk space, thus why \fBclean\fR now requires \fB--force\fR to run.
+.P
+There is currently no method exposed through npm to inspect or directly manage the contents of this cache. In order to access it, \fBcacache\fR must be used directly.
+.P
+npm will not remove data by itself: the cache will grow as new packages are installed.
+.SS "A note about the cache's design"
+.P
+The npm cache is strictly a cache: it should not be relied upon as a persistent and reliable data store for package data. npm makes no guarantee that a previously-cached piece of data will be available later, and will automatically delete corrupted contents. The primary guarantee that the cache makes is that, if it does return data, that data will be exactly the data that was inserted.
+.P
+To run an offline verification of existing cache contents, use \fBnpm cache verify\fR.
+.SS "Configuration"
+.SS "\fBcache\fR"
+.RS 0
+.IP \(bu 4
+Default: Windows: \fB%LocalAppData%\[rs]npm-cache\fR, Posix: \fB~/.npm\fR
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+The location of npm's cache directory.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help pack
+.IP \(bu 4
+npm help exec
+.IP \(bu 4
+https://npm.im/cacache
+.IP \(bu 4
+https://npm.im/pacote
+.IP \(bu 4
+https://npm.im/@npmcli/arborist
+.IP \(bu 4
+https://npm.im/make-fetch-happen
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-ci.1 b/node/node_modules/npm/man/man1/npm-ci.1
new file mode 100644
index 0000000000000000000000000000000000000000..5453ced5d4f83c254cf83b80748f7e62136fe8e7
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-ci.1
@@ -0,0 +1,301 @@
+.TH "NPM-CI" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-ci\fR - Clean install a project
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm ci
+
+aliases: clean-install, ic, install-clean, isntall-clean
+.fi
+.RE
+.SS "Description"
+.P
+This command is similar to npm help install, except it's meant to be used in automated environments such as test platforms, continuous integration, and deployment -- or any situation where you want to make sure you're doing a clean install of your dependencies.
+.P
+The main differences between using \fBnpm install\fR and \fBnpm ci\fR are:
+.RS 0
+.IP \(bu 4
+The project \fBmust\fR have an existing \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR.
+.IP \(bu 4
+If dependencies in the package lock do not match those in \fBpackage.json\fR, \fBnpm ci\fR will exit with an error, instead of updating the package lock.
+.IP \(bu 4
+\fBnpm ci\fR can only install entire projects at a time: individual dependencies cannot be added with this command.
+.IP \(bu 4
+If a \fBnode_modules\fR is already present, it will be automatically removed before \fBnpm ci\fR begins its install.
+.IP \(bu 4
+It will never write to \fBpackage.json\fR or any of the package-locks: installs are essentially frozen.
+.RE 0
+
+.P
+NOTE: If you create your \fBpackage-lock.json\fR file by running \fBnpm install\fR with flags that can affect the shape of your dependency tree, such as \fB--legacy-peer-deps\fR or \fB--install-links\fR, you \fImust\fR provide the same flags to \fBnpm ci\fR or you are likely to encounter errors. An easy way to do this is to run, for example, \fBnpm config set legacy-peer-deps=true --location=project\fR and commit the \fB.npmrc\fR file to your repo.
+.SS "Example"
+.P
+Make sure you have a package-lock and an up-to-date install:
+.P
+.RS 2
+.nf
+$ cd ./my/npm/project
+$ npm install
+added 154 packages in 10s
+$ ls | grep package-lock
+.fi
+.RE
+.P
+Run \fBnpm ci\fR in that project
+.P
+.RS 2
+.nf
+$ npm ci
+added 154 packages in 5s
+.fi
+.RE
+.P
+Configure Travis CI to build using \fBnpm ci\fR instead of \fBnpm install\fR:
+.P
+.RS 2
+.nf
+# .travis.yml
+install:
+- npm ci
+# keep the npm cache around to speed up installs
+cache:
+  directories:
+  - "$HOME/.npm"
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+\fBpackage-lock.json\fR \fI\(la/configuring-npm/package-lock-json\(ra\fR
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-completion.1 b/node/node_modules/npm/man/man1/npm-completion.1
new file mode 100644
index 0000000000000000000000000000000000000000..5cf9f2698fc3483b9902a90e0df0b2689c5ee17b
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-completion.1
@@ -0,0 +1,35 @@
+.TH "NPM-COMPLETION" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-completion\fR - Tab Completion for npm
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm completion
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Enables tab-completion in all npm commands.
+.P
+The synopsis above loads the completions into your current shell. Adding it to your ~/.bashrc or ~/.zshrc will make the completions available everywhere:
+.P
+.RS 2
+.nf
+npm completion >> ~/.bashrc
+npm completion >> ~/.zshrc
+.fi
+.RE
+.P
+You may of course also pipe the output of \fBnpm completion\fR to a file such as \fB/usr/local/etc/bash_completion.d/npm\fR or \fB/etc/bash_completion.d/npm\fR if you have a system that will read that file for you.
+.P
+When \fBCOMP_CWORD\fR, \fBCOMP_LINE\fR, and \fBCOMP_POINT\fR are defined in the environment, \fBnpm completion\fR acts in "plumbing mode", and outputs completions based on the arguments.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help developers
+.IP \(bu 4
+npm help npm
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-config.1 b/node/node_modules/npm/man/man1/npm-config.1
new file mode 100644
index 0000000000000000000000000000000000000000..73791a1da71a3b8508e6c0590437dca580eb0b4b
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-config.1
@@ -0,0 +1,186 @@
+.TH "NPM-CONFIG" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-config\fR - Manage the npm configuration files
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm config set <key>=<value> \[lB]<key>=<value> ...\[rB]
+npm config get \[lB]<key> \[lB]<key> ...\[rB]\[rB]
+npm config delete <key> \[lB]<key> ...\[rB]
+npm config list \[lB]--json\[rB]
+npm config edit
+npm config fix
+
+alias: c
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+npm gets its config settings from the command line, environment variables, \fBnpmrc\fR files, and in some cases, the \fBpackage.json\fR file.
+.P
+See npm help npmrc for more information about the npmrc files.
+.P
+See npm help config for a more thorough explanation of the mechanisms involved, and a full list of config options available.
+.P
+The \fBnpm config\fR command can be used to update and edit the contents of the user and global npmrc files.
+.SS "Sub-commands"
+.P
+Config supports the following sub-commands:
+.SS "set"
+.P
+.RS 2
+.nf
+npm config set key=value \[lB]key=value...\[rB]
+npm set key=value \[lB]key=value...\[rB]
+.fi
+.RE
+.P
+Sets each of the config keys to the value provided. Modifies the user configuration file unless \fB\[rs]fBlocation\[rs]fR\fR \fI\(la/commands/npm-config#location\(ra\fR is passed.
+.P
+If value is omitted, the key will be removed from your config file entirely.
+.P
+Note: for backwards compatibility, \fBnpm config set key value\fR is supported as an alias for \fBnpm config set key=value\fR.
+.SS "get"
+.P
+.RS 2
+.nf
+npm config get \[lB]key ...\[rB]
+npm get \[lB]key ...\[rB]
+.fi
+.RE
+.P
+Echo the config value(s) to stdout.
+.P
+If multiple keys are provided, then the values will be prefixed with the key names.
+.P
+If no keys are provided, then this command behaves the same as \fBnpm config list\fR.
+.SS "list"
+.P
+.RS 2
+.nf
+npm config list
+.fi
+.RE
+.P
+Show all the config settings. Use \fB-l\fR to also show defaults. Use \fB--json\fR to show the settings in json format.
+.SS "delete"
+.P
+.RS 2
+.nf
+npm config delete key \[lB]key ...\[rB]
+.fi
+.RE
+.P
+Deletes the specified keys from all configuration files.
+.SS "edit"
+.P
+.RS 2
+.nf
+npm config edit
+.fi
+.RE
+.P
+Opens the config file in an editor. Use the \fB--global\fR flag to edit the global config.
+.SS "fix"
+.P
+.RS 2
+.nf
+npm config fix
+.fi
+.RE
+.P
+Attempts to repair invalid configuration items. Usually this means attaching authentication config (i.e. \fB_auth\fR, \fB_authToken\fR) to the configured \fBregistry\fR.
+.SS "Configuration"
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBeditor\fR"
+.RS 0
+.IP \(bu 4
+Default: The EDITOR or VISUAL environment variables, or '%SYSTEMROOT%\[rs]notepad.exe' on Windows, or 'vi' on Unix systems
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The command to run for \fBnpm edit\fR and \fBnpm config edit\fR.
+.SS "\fBlocation\fR"
+.RS 0
+.IP \(bu 4
+Default: "user" unless \fB--global\fR is passed, which will also set this value to "global"
+.IP \(bu 4
+Type: "global", "user", or "project"
+.RE 0
+
+.P
+When passed to \fBnpm config\fR this refers to which config file to use.
+.P
+When set to "global" mode, packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help npm
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-dedupe.1 b/node/node_modules/npm/man/man1/npm-dedupe.1
new file mode 100644
index 0000000000000000000000000000000000000000..a5f6a6c99af7e5be1855e44807471e39f47d9b55
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-dedupe.1
@@ -0,0 +1,302 @@
+.TH "NPM-DEDUPE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-dedupe\fR - Reduce duplication in the package tree
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm dedupe
+
+alias: ddp
+.fi
+.RE
+.SS "Description"
+.P
+Searches the local package tree and attempts to simplify the overall structure by moving dependencies further up the tree, where they can be more effectively shared by multiple dependent packages.
+.P
+For example, consider this dependency graph:
+.P
+.RS 2
+.nf
+a
++-- b <-- depends on c@1.0.x
+|   `-- c@1.0.3
+`-- d <-- depends on c@~1.0.9
+    `-- c@1.0.10
+.fi
+.RE
+.P
+In this case, \fBnpm dedupe\fR will transform the tree to:
+.P
+.RS 2
+.nf
+a
++-- b
++-- d
+`-- c@1.0.10
+.fi
+.RE
+.P
+Because of the hierarchical nature of node's module lookup, b and d will both get their dependency met by the single c package at the root level of the tree.
+.P
+In some cases, you may have a dependency graph like this:
+.P
+.RS 2
+.nf
+a
++-- b <-- depends on c@1.0.x
++-- c@1.0.3
+`-- d <-- depends on c@1.x
+    `-- c@1.9.9
+.fi
+.RE
+.P
+During the installation process, the \fBc@1.0.3\fR dependency for \fBb\fR was placed in the root of the tree. Though \fBd\fR's dependency on \fBc@1.x\fR could have been satisfied by \fBc@1.0.3\fR, the newer \fBc@1.9.9\fR dependency was used, because npm favors updates by default, even when doing so causes duplication.
+.P
+Running \fBnpm dedupe\fR will cause npm to note the duplication and re-evaluate, deleting the nested \fBc\fR module, because the one in the root is sufficient.
+.P
+To prefer deduplication over novelty during the installation process, run \fBnpm install --prefer-dedupe\fR or \fBnpm config set prefer-dedupe true\fR.
+.P
+Arguments are ignored. Dedupe always acts on the entire tree.
+.P
+Note that this operation transforms the dependency tree, but will never result in new modules being installed.
+.P
+Using \fBnpm find-dupes\fR will run the command in \fB--dry-run\fR mode.
+.P
+Note: \fBnpm dedupe\fR will never update the semver values of direct dependencies in your project \fBpackage.json\fR, if you want to update values in \fBpackage.json\fR you can run: \fBnpm update --save\fR instead.
+.SS "Configuration"
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help find-dupes
+.IP \(bu 4
+npm help ls
+.IP \(bu 4
+npm help update
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-deprecate.1 b/node/node_modules/npm/man/man1/npm-deprecate.1
new file mode 100644
index 0000000000000000000000000000000000000000..169edf6f82d50efae46ea0a1caf8449979f4fdde
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-deprecate.1
@@ -0,0 +1,85 @@
+.TH "NPM-DEPRECATE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-deprecate\fR - Deprecate a version of a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm deprecate <package-spec> <message>
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+This command will update the npm registry entry for a package, providing a deprecation warning to all who attempt to install it.
+.P
+It works on \fBversion ranges\fR \fI\(lahttps://semver.npmjs.com/\(ra\fR as well as specific versions, so you can do something like this:
+.P
+.RS 2
+.nf
+npm deprecate my-thing@"< 0.2.3" "critical bug fixed in v0.2.3"
+.fi
+.RE
+.P
+SemVer ranges passed to this command are interpreted such that they \fIdo\fR include prerelease versions. For example:
+.P
+.RS 2
+.nf
+npm deprecate my-thing@1.x "1.x is no longer supported"
+.fi
+.RE
+.P
+In this case, a version \fBmy-thing@1.0.0-beta.0\fR will also be deprecated.
+.P
+You must be the package owner to deprecate something. See the \fBowner\fR and \fBadduser\fR help topics.
+.P
+To un-deprecate a package, specify an empty string (\fB""\fR) for the \fBmessage\fR argument. Note that you must use double quotes with no space between them to format an empty string.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help adduser
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-diff.1 b/node/node_modules/npm/man/man1/npm-diff.1
new file mode 100644
index 0000000000000000000000000000000000000000..e4fd4c696948db9adfc0f809491606e268642aec
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-diff.1
@@ -0,0 +1,310 @@
+.TH "NPM-DIFF" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-diff\fR - The registry diff command
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm diff \[lB]...<paths>\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+Similar to its \fBgit diff\fR counterpart, this command will print diff patches of files for packages published to the npm registry.
+.RS 0
+.IP \(bu 4
+\fBnpm diff --diff=<spec-a> --diff=<spec-b>\fR
+.P
+Compares two package versions using their registry specifiers, e.g: \fBnpm diff --diff=pkg@1.0.0 --diff=pkg@^2.0.0\fR. It's also possible to compare across forks of any package, e.g: \fBnpm diff --diff=pkg@1.0.0 --diff=pkg-fork@1.0.0\fR.
+.P
+Any valid spec can be used, so that it's also possible to compare directories or git repositories, e.g: \fBnpm diff --diff=pkg@latest --diff=./packages/pkg\fR
+.P
+Here's an example comparing two different versions of a package named \fBabbrev\fR from the registry:
+.P
+.RS 2
+.nf
+npm diff --diff=abbrev@1.1.0 --diff=abbrev@1.1.1
+.fi
+.RE
+.P
+On success, output looks like:
+.P
+.RS 2
+.nf
+diff --git a/package.json b/package.json
+index v1.1.0..v1.1.1 100644
+--- a/package.json
++++ b/package.json
+@@ -1,6 +1,6 @@
+ {
+   "name": "abbrev",
+-  "version": "1.1.0",
++  "version": "1.1.1",
+   "description": "Like ruby's abbrev module, but in js",
+   "author": "Isaac Z. Schlueter <i@izs.me>",
+   "main": "abbrev.js",
+.fi
+.RE
+.P
+Given the flexible nature of npm specs, you can also target local directories or git repos just like when using \fBnpm install\fR:
+.P
+.RS 2
+.nf
+npm diff --diff=https://github.com/npm/libnpmdiff --diff=./local-path
+.fi
+.RE
+.P
+In the example above we can compare the contents from the package installed from the git repo at \fBgithub.com/npm/libnpmdiff\fR with the contents of the \fB./local-path\fR that contains a valid package, such as a modified copy of the original.
+.IP \(bu 4
+\fBnpm diff\fR (in a package directory, no arguments):
+.P
+If the package is published to the registry, \fBnpm diff\fR will fetch the tarball version tagged as \fBlatest\fR (this value can be configured using the \fBtag\fR option) and proceed to compare the contents of files present in that tarball, with the current files in your local file system.
+.P
+This workflow provides a handy way for package authors to see what package-tracked files have been changed in comparison with the latest published version of that package.
+.IP \(bu 4
+\fBnpm diff --diff=<pkg-name>\fR (in a package directory):
+.P
+When using a single package name (with no version or tag specifier) as an argument, \fBnpm diff\fR will work in a similar way to \fB\[rs]fBnpm-outdated\[rs]fR\fR \fI\(lanpm-outdated\(ra\fR and reach for the registry to figure out what current published version of the package named \fB<pkg-name>\fR will satisfy its dependent declared semver-range. Once that specific version is known \fBnpm diff\fR will print diff patches comparing the current version of \fB<pkg-name>\fR found in the local file system with that specific version returned by the registry.
+.P
+Given a package named \fBabbrev\fR that is currently installed:
+.P
+.RS 2
+.nf
+npm diff --diff=abbrev
+.fi
+.RE
+.P
+That will request from the registry its most up to date version and will print a diff output comparing the currently installed version to this newer one if the version numbers are not the same.
+.IP \(bu 4
+\fBnpm diff --diff=<spec-a>\fR (in a package directory):
+.P
+Similar to using only a single package name, it's also possible to declare a full registry specifier version if you wish to compare the local version of an installed package with the specific version/tag/semver-range provided in \fB<spec-a>\fR.
+.P
+An example: assuming \fBpkg@1.0.0\fR is installed in the current \fBnode_modules\fR folder, running:
+.P
+.RS 2
+.nf
+npm diff --diff=pkg@2.0.0
+.fi
+.RE
+.P
+It will effectively be an alias to \fBnpm diff --diff=pkg@1.0.0 --diff=pkg@2.0.0\fR.
+.IP \(bu 4
+\fBnpm diff --diff=<semver-a> \[lB]--diff=<semver-b>\[rB]\fR (in a package directory):
+.P
+Using \fBnpm diff\fR along with semver-valid version numbers is a shorthand to compare different versions of the current package.
+.P
+It needs to be run from a package directory, such that for a package named \fBpkg\fR running \fBnpm diff --diff=1.0.0 --diff=1.0.1\fR is the same as running \fBnpm diff --diff=pkg@1.0.0 --diff=pkg@1.0.1\fR.
+.P
+If only a single argument \fB<version-a>\fR is provided, then the current local file system is going to be compared against that version.
+.P
+Here's an example comparing two specific versions (published to the configured registry) of the current project directory:
+.P
+.RS 2
+.nf
+npm diff --diff=1.0.0 --diff=1.1.0
+.fi
+.RE
+.RE 0
+
+.P
+Note that tag names are not valid \fB--diff\fR argument values, if you wish to compare to a published tag, you must use the \fBpkg@tagname\fR syntax.
+.SS "Filtering files"
+.P
+It's possible to also specify positional arguments using file names or globs pattern matching in order to limit the result of diff patches to only a subset of files for a given package, e.g:
+.P
+.RS 2
+.nf
+npm diff --diff=pkg@2 ./lib/ CHANGELOG.md
+.fi
+.RE
+.P
+In the example above the diff output is only going to print contents of files located within the folder \fB./lib/\fR and changed lines of code within the \fBCHANGELOG.md\fR file.
+.SS "Configuration"
+.SS "\fBdiff\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Define arguments to compare in \fBnpm diff\fR.
+.SS "\fBdiff-name-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prints only filenames when using \fBnpm diff\fR.
+.SS "\fBdiff-unified\fR"
+.RS 0
+.IP \(bu 4
+Default: 3
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The number of lines of context to print in \fBnpm diff\fR.
+.SS "\fBdiff-ignore-all-space\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Ignore whitespace when comparing lines in \fBnpm diff\fR.
+.SS "\fBdiff-no-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Do not show any source or destination prefix in \fBnpm diff\fR output.
+.P
+Note: this causes \fBnpm diff\fR to ignore the \fB--diff-src-prefix\fR and \fB--diff-dst-prefix\fR configs.
+.SS "\fBdiff-src-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: "a/"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Source prefix to be used in \fBnpm diff\fR output.
+.SS "\fBdiff-dst-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: "b/"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Destination prefix to be used in \fBnpm diff\fR output.
+.SS "\fBdiff-text\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Treat all files as text in \fBnpm diff\fR.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBtag\fR"
+.RS 0
+.IP \(bu 4
+Default: "latest"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+If you ask npm to install a package and don't tell it a specific version, then it will install the specified tag.
+.P
+It is the tag added to the package@version specified in the \fBnpm dist-tag
+add\fR command, if no explicit tag is given.
+.P
+When used by the \fBnpm diff\fR command, this is the tag used to fetch the tarball that will be compared with the local files by default.
+.P
+If used in the \fBnpm publish\fR command, this is the tag that will be added to the package submitted to the registry.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SH "SEE ALSO"
+.RS 0
+.IP \(bu 4
+npm help outdated
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help registry
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-dist-tag.1 b/node/node_modules/npm/man/man1/npm-dist-tag.1
new file mode 100644
index 0000000000000000000000000000000000000000..4b4f4d218d7388c1dc173febcf2649bd8cffbcf8
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-dist-tag.1
@@ -0,0 +1,144 @@
+.TH "NPM-DIST-TAG" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-dist-tag\fR - Modify package distribution tags
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm dist-tag add <package-spec (with version)> \[lB]<tag>\[rB]
+npm dist-tag rm <package-spec> <tag>
+npm dist-tag ls \[lB]<package-spec>\[rB]
+
+alias: dist-tags
+.fi
+.RE
+.SS "Description"
+.P
+Add, remove, and enumerate distribution tags on a package:
+.RS 0
+.IP \(bu 4
+add: Tags the specified version of the package with the specified tag, or the \fB\[rs]fB--tag\[rs]fR config\fR \fI\(la/using-npm/config#tag\(ra\fR if not specified. If you have two-factor authentication on auth-and-writes then you\[cq]ll need to include a one-time password on the command line with \fB--otp <one-time password>\fR, or go through a second factor flow based on your \fBauthtype\fR.
+.IP \(bu 4
+rm: Clear a tag that is no longer in use from the package. If you have two-factor authentication on auth-and-writes then you\[cq]ll need to include a one-time password on the command line with \fB--otp <one-time password>\fR, or go through a second factor flow based on your \fBauthtype\fR
+.IP \(bu 4
+ls: Show all of the dist-tags for a package, defaulting to the package in the current prefix. This is the default action if none is specified.
+.RE 0
+
+.P
+A tag can be used when installing packages as a reference to a version instead of using a specific version number:
+.P
+.RS 2
+.nf
+npm install <name>@<tag>
+.fi
+.RE
+.P
+When installing dependencies, a preferred tagged version may be specified:
+.P
+.RS 2
+.nf
+npm install --tag <tag>
+.fi
+.RE
+.P
+(This also applies to any other commands that resolve and install dependencies, such as \fBnpm dedupe\fR, \fBnpm update\fR, and \fBnpm audit fix\fR.)
+.P
+Publishing a package sets the \fBlatest\fR tag to the published version unless the \fB--tag\fR option is used. For example, \fBnpm publish --tag=beta\fR.
+.P
+By default, \fBnpm install <pkg>\fR (without any \fB@<version>\fR or \fB@<tag>\fR specifier) installs the \fBlatest\fR tag.
+.SS "Purpose"
+.P
+Tags can be used to provide an alias instead of version numbers.
+.P
+For example, a project might choose to have multiple streams of development and use a different tag for each stream, e.g., \fBstable\fR, \fBbeta\fR, \fBdev\fR, \fBcanary\fR.
+.P
+By default, the \fBlatest\fR tag is used by npm to identify the current version of a package, and \fBnpm install <pkg>\fR (without any \fB@<version>\fR or \fB@<tag>\fR specifier) installs the \fBlatest\fR tag. Typically, projects only use the \fBlatest\fR tag for stable release versions, and use other tags for unstable versions such as prereleases.
+.P
+The \fBnext\fR tag is used by some projects to identify the upcoming version.
+.P
+Other than \fBlatest\fR, no tag has any special significance to npm itself.
+.SS "Caveats"
+.P
+This command used to be known as \fBnpm tag\fR, which only created new tags, and so had a different syntax.
+.P
+Tags must share a namespace with version numbers, because they are specified in the same slot: \fBnpm install <pkg>@<version>\fR vs \fBnpm install <pkg>@<tag>\fR.
+.P
+Tags that can be interpreted as valid semver ranges will be rejected. For example, \fBv1.4\fR cannot be used as a tag, because it is interpreted by semver as \fB>=1.4.0 <1.5.0\fR. See \fI\(lahttps://github.com/npm/npm/issues/6082\(ra\fR.
+.P
+The simplest way to avoid semver problems with tags is to use tags that do not begin with a number or the letter \fBv\fR.
+.SS "Configuration"
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help dedupe
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-docs.1 b/node/node_modules/npm/man/man1/npm-docs.1
new file mode 100644
index 0000000000000000000000000000000000000000..0cb4207b5a70012451a6ae317a845d968666522f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-docs.1
@@ -0,0 +1,113 @@
+.TH "NPM-DOCS" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-docs\fR - Open documentation for a package in a web browser
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm docs \[lB]<pkgname> \[lB]<pkgname> ...\[rB]\[rB]
+
+alias: home
+.fi
+.RE
+.SS "Description"
+.P
+This command tries to guess at the likely location of a package's documentation URL, and then tries to open it using the \fB\[rs]fB--browser\[rs]fR config\fR \fI\(la/using-npm/config#browser\(ra\fR param. You can pass multiple package names at once. If no package name is provided, it will search for a \fBpackage.json\fR in the current folder and use the \fBname\fR property.
+.SS "Configuration"
+.SS "\fBbrowser\fR"
+.RS 0
+.IP \(bu 4
+Default: macOS: \fB"open"\fR, Windows: \fB"start"\fR, Others: \fB"xdg-open"\fR
+.IP \(bu 4
+Type: null, Boolean, or String
+.RE 0
+
+.P
+The browser that is called by npm commands to open websites.
+.P
+Set to \fBfalse\fR to suppress browser behavior and instead print urls to terminal.
+.P
+Set to \fBtrue\fR to use default system URL opener.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help view
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-doctor.1 b/node/node_modules/npm/man/man1/npm-doctor.1
new file mode 100644
index 0000000000000000000000000000000000000000..d1b552574ccd33edeb73a671720aab0c33ec0b0a
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-doctor.1
@@ -0,0 +1,82 @@
+.TH "NPM-DOCTOR" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-doctor\fR - Check the health of your npm environment
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm doctor \[lB]connection\[rB] \[lB]registry\[rB] \[lB]versions\[rB] \[lB]environment\[rB] \[lB]permissions\[rB] \[lB]cache\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+\fBnpm doctor\fR runs a set of checks to ensure that your npm installation has what it needs to manage your JavaScript packages. npm is mostly a standalone tool, but it does have some basic requirements that must be met:
+.RS 0
+.IP \(bu 4
+Node.js and git must be executable by npm.
+.IP \(bu 4
+The primary npm registry, \fBregistry.npmjs.com\fR, or another service that uses the registry API, is available.
+.IP \(bu 4
+The directories that npm uses, \fBnode_modules\fR (both locally and globally), exist and can be written by the current user.
+.IP \(bu 4
+The npm cache exists, and the package tarballs within it aren't corrupt.
+.RE 0
+
+.P
+Without all of these working properly, npm may not work properly. Many issues are often attributable to things that are outside npm's code base, so \fBnpm doctor\fR confirms that the npm installation is in a good state.
+.P
+Also, in addition to this, there are also very many issue reports due to using old versions of npm. Since npm is constantly improving, running \fBnpm@latest\fR is better than an old version.
+.P
+\fBnpm doctor\fR verifies the following items in your environment, and if there are any recommended changes, it will display them. By default npm runs all of these checks. You can limit what checks are ran by specifying them as extra arguments.
+.SS "\fBConnecting to the registry\fR"
+.P
+By default, npm installs from the primary npm registry, \fBregistry.npmjs.org\fR. \fBnpm doctor\fR hits a special connection testing endpoint within the registry. This can also be checked with \fBnpm ping\fR. If this check fails, you may be using a proxy that needs to be configured, or may need to talk to your IT staff to get access over HTTPS to \fBregistry.npmjs.org\fR.
+.P
+This check is done against whichever registry you've configured (you can see what that is by running \fBnpm config get registry\fR), and if you're using a private registry that doesn't support the \fB/whoami\fR endpoint supported by the primary registry, this check may fail.
+.SS "\fBChecking npm version\fR"
+.P
+While Node.js may come bundled with a particular version of npm, it's the policy of the CLI team that we recommend all users run \fBnpm@latest\fR if they can. As the CLI is maintained by a small team of contributors, there are only resources for a single line of development, so npm's own long-term support releases typically only receive critical security and regression fixes. The team believes that the latest tested version of npm is almost always likely to be the most functional and defect-free version of npm.
+.SS "\fBChecking node version\fR"
+.P
+For most users, in most circumstances, the best version of Node will be the latest long-term support (LTS) release. Those of you who want access to new ECMAscript features or bleeding-edge changes to Node's standard library may be running a newer version, and some may be required to run an older version of Node because of enterprise change control policies. That's OK! But in general, the npm team recommends that most users run Node.js LTS.
+.SS "\fBChecking configured npm registry\fR"
+.P
+You may be installing from private package registries for your project or company. That's great! Others may be following tutorials or StackOverflow questions in an effort to troubleshoot problems you may be having. Sometimes, this may entail changing the registry you're pointing at. This part of \fBnpm doctor\fR just lets you, and maybe whoever's helping you with support, know that you're not using the default registry.
+.SS "\fBChecking for git executable in PATH\fR"
+.P
+While it's documented in the README, it may not be obvious that npm needs Git installed to do many of the things that it does. Also, in some cases \[en] especially on Windows \[en] you may have Git set up in such a way that it's not accessible via your \fBPATH\fR so that npm can find it. This check ensures that Git is available.
+.SS "Permissions checks"
+.RS 0
+.IP \(bu 4
+Your cache must be readable and writable by the user running npm.
+.IP \(bu 4
+Global package binaries must be writable by the user running npm.
+.IP \(bu 4
+Your local \fBnode_modules\fR path, if you're running \fBnpm doctor\fR with a project directory, must be readable and writable by the user running npm.
+.RE 0
+
+.SS "Validate the checksums of cached packages"
+.P
+When an npm package is published, the publishing process generates a checksum that npm uses at install time to verify that the package didn't get corrupted in transit. \fBnpm doctor\fR uses these checksums to validate the package tarballs in your local cache (you can see where that cache is located with \fBnpm config get cache\fR). In the event that there are corrupt packages in your cache, you should probably run \fBnpm cache clean -f\fR and reset the cache.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help bugs
+.IP \(bu 4
+npm help help
+.IP \(bu 4
+npm help ping
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-edit.1 b/node/node_modules/npm/man/man1/npm-edit.1
new file mode 100644
index 0000000000000000000000000000000000000000..b3d9bf84efcb1717ab216ddf9eaaf365b38d8889
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-edit.1
@@ -0,0 +1,43 @@
+.TH "NPM-EDIT" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-edit\fR - Edit an installed package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm edit <pkg>\[lB]/<subpkg>...\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Selects a dependency in the current project and opens the package folder in the default editor (or whatever you've configured as the npm \fBeditor\fR config -- see \fB\[rs]fBnpm-config\[rs]fR\fR \fI\(lanpm-config\(ra\fR.)
+.P
+After it has been edited, the package is rebuilt so as to pick up any changes in compiled packages.
+.P
+For instance, you can do \fBnpm install connect\fR to install connect into your package, and then \fBnpm edit connect\fR to make a few changes to your locally installed copy.
+.SS "Configuration"
+.SS "\fBeditor\fR"
+.RS 0
+.IP \(bu 4
+Default: The EDITOR or VISUAL environment variables, or '%SYSTEMROOT%\[rs]notepad.exe' on Windows, or 'vi' on Unix systems
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The command to run for \fBnpm edit\fR and \fBnpm config edit\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help explore
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-exec.1 b/node/node_modules/npm/man/man1/npm-exec.1
new file mode 100644
index 0000000000000000000000000000000000000000..cc7e1a419ee7420c81a14f7744253f4990bda1c6
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-exec.1
@@ -0,0 +1,350 @@
+.TH "NPM-EXEC" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-exec\fR - Run a command from a local or remote npm package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm exec -- <pkg>\[lB]@<version>\[rB] \[lB]args...\[rB]
+npm exec --package=<pkg>\[lB]@<version>\[rB] -- <cmd> \[lB]args...\[rB]
+npm exec -c '<cmd> \[lB]args...\[rB]'
+npm exec --package=foo -c '<cmd> \[lB]args...\[rB]'
+
+alias: x
+.fi
+.RE
+.SS "Description"
+.P
+This command allows you to run an arbitrary command from an npm package (either one installed locally, or fetched remotely), in a similar context as running it via \fBnpm run\fR.
+.P
+Run without positional arguments or \fB--call\fR, this allows you to interactively run commands in the same sort of shell environment that \fBpackage.json\fR scripts are run. Interactive mode is not supported in CI environments when standard input is a TTY, to prevent hangs.
+.P
+Whatever packages are specified by the \fB--package\fR option will be provided in the \fBPATH\fR of the executed command, along with any locally installed package executables. The \fB--package\fR option may be specified multiple times, to execute the supplied command in an environment where all specified packages are available.
+.P
+If any requested packages are not present in the local project dependencies, then a prompt is printed, which can be suppressed by providing either \fB--yes\fR or \fB--no\fR. When standard input is not a TTY or a CI environment is detected, \fB--yes\fR is assumed. The requested packages are installed to a folder in the npm cache, which is added to the \fBPATH\fR environment variable in the executed process.
+.P
+Package names provided without a specifier will be matched with whatever version exists in the local project. Package names with a specifier will only be considered a match if they have the exact same name and version as the local dependency.
+.P
+If no \fB-c\fR or \fB--call\fR option is provided, then the positional arguments are used to generate the command string. If no \fB--package\fR options are provided, then npm will attempt to determine the executable name from the package specifier provided as the first positional argument according to the following heuristic:
+.RS 0
+.IP \(bu 4
+If the package has a single entry in its \fBbin\fR field in \fBpackage.json\fR, or if all entries are aliases of the same command, then that command will be used.
+.IP \(bu 4
+If the package has multiple \fBbin\fR entries, and one of them matches the unscoped portion of the \fBname\fR field, then that command will be used.
+.IP \(bu 4
+If this does not result in exactly one option (either because there are no bin entries, or none of them match the \fBname\fR of the package), then \fBnpm exec\fR exits with an error.
+.RE 0
+
+.P
+To run a binary \fIother than\fR the named binary, specify one or more \fB--package\fR options, which will prevent npm from inferring the package from the first command argument.
+.SS "\fBnpx\fR vs \fBnpm exec\fR"
+.P
+When run via the \fBnpx\fR binary, all flags and options \fImust\fR be set prior to any positional arguments. When run via \fBnpm exec\fR, a double-hyphen \fB--\fR flag can be used to suppress npm's parsing of switches and options that should be sent to the executed command.
+.P
+For example:
+.P
+.RS 2
+.nf
+$ npx foo@latest bar --package=@npmcli/foo
+.fi
+.RE
+.P
+In this case, npm will resolve the \fBfoo\fR package name, and run the following command:
+.P
+.RS 2
+.nf
+$ foo bar --package=@npmcli/foo
+.fi
+.RE
+.P
+Since the \fB--package\fR option comes \fIafter\fR the positional arguments, it is treated as an argument to the executed command.
+.P
+In contrast, due to npm's argument parsing logic, running this command is different:
+.P
+.RS 2
+.nf
+$ npm exec foo@latest bar --package=@npmcli/foo
+.fi
+.RE
+.P
+In this case, npm will parse the \fB--package\fR option first, resolving the \fB@npmcli/foo\fR package. Then, it will execute the following command in that context:
+.P
+.RS 2
+.nf
+$ foo@latest bar
+.fi
+.RE
+.P
+The double-hyphen character is recommended to explicitly tell npm to stop parsing command line options and switches. The following command would thus be equivalent to the \fBnpx\fR command above:
+.P
+.RS 2
+.nf
+$ npm exec -- foo@latest bar --package=@npmcli/foo
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBpackage\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+The package or packages to install for npm help exec
+.SS "\fBcall\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Optional companion option for \fBnpm exec\fR, \fBnpx\fR that allows for specifying a custom command to be run along with the installed packages.
+.P
+.RS 2
+.nf
+npm exec --package yo --package generator-node --call "yo node"
+.fi
+.RE
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "Examples"
+.P
+Run the version of \fBtap\fR in the local dependencies, with the provided arguments:
+.P
+.RS 2
+.nf
+$ npm exec -- tap --bail test/foo.js
+$ npx tap --bail test/foo.js
+.fi
+.RE
+.P
+Run a command \fIother than\fR the command whose name matches the package name by specifying a \fB--package\fR option:
+.P
+.RS 2
+.nf
+$ npm exec --package=foo -- bar --bar-argument
+# ~ or ~
+$ npx --package=foo bar --bar-argument
+.fi
+.RE
+.P
+Run an arbitrary shell script, in the context of the current project:
+.P
+.RS 2
+.nf
+$ npm x -c 'eslint && say "hooray, lint passed"'
+$ npx -c 'eslint && say "hooray, lint passed"'
+.fi
+.RE
+.SS "Workspaces support"
+.P
+You may use the \fB\[rs]fBworkspace\[rs]fR\fR \fI\(la/using-npm/config#workspace\(ra\fR or \fB\[rs]fBworkspaces\[rs]fR\fR \fI\(la/using-npm/config#workspaces\(ra\fR configs in order to run an arbitrary command from an npm package (either one installed locally, or fetched remotely) in the context of the specified workspaces. If no positional argument or \fB--call\fR option is provided, it will open an interactive subshell in the context of each of these configured workspaces one at a time.
+.P
+Given a project with configured workspaces, e.g:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   +-- b
+   |   `-- package.json
+   `-- c
+       `-- package.json
+.fi
+.RE
+.P
+Assuming the workspace configuration is properly set up at the root level \fBpackage.json\fR file. e.g:
+.P
+.RS 2
+.nf
+{
+    "workspaces": \[lB] "./packages/*" \[rB]
+}
+.fi
+.RE
+.P
+You can execute an arbitrary command from a package in the context of each of the configured workspaces when using the \fB\[rs]fBworkspaces\[rs]fR config options\fR \fI\(la/using-npm/config#workspace\(ra\fR, in this example we're using \fBeslint\fR to lint any js file found within each workspace folder:
+.P
+.RS 2
+.nf
+npm exec --ws -- eslint ./*.js
+.fi
+.RE
+.SS "Filtering workspaces"
+.P
+It's also possible to execute a command in a single workspace using the \fBworkspace\fR config along with a name or directory path:
+.P
+.RS 2
+.nf
+npm exec --workspace=a -- eslint ./*.js
+.fi
+.RE
+.P
+The \fBworkspace\fR config can also be specified multiple times in order to run a specific script in the context of multiple workspaces. When defining values for the \fBworkspace\fR config in the command line, it also possible to use \fB-w\fR as a shorthand, e.g:
+.P
+.RS 2
+.nf
+npm exec -w a -w b -- eslint ./*.js
+.fi
+.RE
+.P
+This last command will run the \fBeslint\fR command in both \fB./packages/a\fR and \fB./packages/b\fR folders.
+.SS "Compatibility with Older npx Versions"
+.P
+The \fBnpx\fR binary was rewritten in npm v7.0.0, and the standalone \fBnpx\fR package deprecated at that time. \fBnpx\fR uses the \fBnpm exec\fR command instead of a separate argument parser and install process, with some affordances to maintain backwards compatibility with the arguments it accepted in previous versions.
+.P
+This resulted in some shifts in its functionality:
+.RS 0
+.IP \(bu 4
+Any \fBnpm\fR config value may be provided.
+.IP \(bu 4
+To prevent security and user-experience problems from mistyping package names, \fBnpx\fR prompts before installing anything. Suppress this prompt with the \fB-y\fR or \fB--yes\fR option.
+.IP \(bu 4
+The \fB--no-install\fR option is deprecated, and will be converted to \fB--no\fR.
+.IP \(bu 4
+Shell fallback functionality is removed, as it is not advisable.
+.IP \(bu 4
+The \fB-p\fR argument is a shorthand for \fB--parseable\fR in npm, but shorthand for \fB--package\fR in npx. This is maintained, but only for the \fBnpx\fR executable.
+.IP \(bu 4
+The \fB--ignore-existing\fR option is removed. Locally installed bins are always present in the executed process \fBPATH\fR.
+.IP \(bu 4
+The \fB--npm\fR option is removed. \fBnpx\fR will always use the \fBnpm\fR it ships with.
+.IP \(bu 4
+The \fB--node-arg\fR and \fB-n\fR options are removed.
+.IP \(bu 4
+The \fB--always-spawn\fR option is redundant, and thus removed.
+.IP \(bu 4
+The \fB--shell\fR option is replaced with \fB--script-shell\fR, but maintained in the \fBnpx\fR executable for backwards compatibility.
+.RE 0
+
+.SS "A note on caching"
+.P
+The npm cli utilizes its internal package cache when using the package name specified. You can use the following to change how and when the cli uses this cache. See npm help cache for more on how the cache works.
+.SS "prefer-online"
+.P
+Forces staleness checks for packages, making the cli look for updates immediately even if the package is already in the cache.
+.SS "prefer-offline"
+.P
+Bypasses staleness checks for packages. Missing data will still be requested from the server. To force full offline mode, use \fBoffline\fR.
+.SS "offline"
+.P
+Forces full offline mode. Any packages not locally cached will result in an error.
+.SS "workspace"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result to selecting all of the nested workspaces)
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "workspaces"
+.RS 0
+.IP \(bu 4
+Alias: \fB--ws\fR
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+Default: \fBfalse\fR
+.RE 0
+
+.P
+Run scripts in the context of all configured workspaces for the current project.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help test
+.IP \(bu 4
+npm help start
+.IP \(bu 4
+npm help restart
+.IP \(bu 4
+npm help stop
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help workspaces
+.IP \(bu 4
+npm help npx
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-explain.1 b/node/node_modules/npm/man/man1/npm-explain.1
new file mode 100644
index 0000000000000000000000000000000000000000..8ccb9a1467f827b0d7390f2a709fed525f3fb35f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-explain.1
@@ -0,0 +1,118 @@
+.TH "NPM-EXPLAIN" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-explain\fR - Explain installed packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm explain <package-spec>
+
+alias: why
+.fi
+.RE
+.SS "Description"
+.P
+This command will print the chain of dependencies causing a given package to be installed in the current project.
+.P
+If one or more package specs are provided, then only packages matching one of the specifiers will have their relationships explained.
+.P
+The package spec can also refer to a folder within \fB./node_modules\fR
+.P
+For example, running \fBnpm explain glob\fR within npm's source tree will show:
+.P
+.RS 2
+.nf
+glob@7.1.6
+node_modules/glob
+  glob@"^7.1.4" from the root project
+
+glob@7.1.1 dev
+node_modules/tacks/node_modules/glob
+  glob@"^7.0.5" from rimraf@2.6.2
+  node_modules/tacks/node_modules/rimraf
+    rimraf@"^2.6.2" from tacks@1.3.0
+    node_modules/tacks
+      dev tacks@"^1.3.0" from the root project
+.fi
+.RE
+.P
+To explain just the package residing at a specific folder, pass that as the argument to the command. This can be useful when trying to figure out exactly why a given dependency is being duplicated to satisfy conflicting version requirements within the project.
+.P
+.RS 2
+.nf
+$ npm explain node_modules/nyc/node_modules/find-up
+find-up@3.0.0 dev
+node_modules/nyc/node_modules/find-up
+  find-up@"^3.0.0" from nyc@14.1.1
+  node_modules/nyc
+    nyc@"^14.1.1" from tap@14.10.8
+    node_modules/tap
+      dev tap@"^14.10.8" from the root project
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help ls
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help link
+.IP \(bu 4
+npm help prune
+.IP \(bu 4
+npm help outdated
+.IP \(bu 4
+npm help update
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-explore.1 b/node/node_modules/npm/man/man1/npm-explore.1
new file mode 100644
index 0000000000000000000000000000000000000000..a57b00b7fbe1b486c02ba61803d791aae0d1000f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-explore.1
@@ -0,0 +1,49 @@
+.TH "NPM-EXPLORE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-explore\fR - Browse an installed package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm explore <pkg> \[lB] -- <command>\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Spawn a subshell in the directory of the installed package specified.
+.P
+If a command is specified, then it is run in the subshell, which then immediately terminates.
+.P
+This is particularly handy in the case of git submodules in the \fBnode_modules\fR folder:
+.P
+.RS 2
+.nf
+npm explore some-dependency -- git pull origin master
+.fi
+.RE
+.P
+Note that the package is \fInot\fR automatically rebuilt afterwards, so be sure to use \fBnpm rebuild <pkg>\fR if you make any changes.
+.SS "Configuration"
+.SS "\fBshell\fR"
+.RS 0
+.IP \(bu 4
+Default: SHELL environment variable, or "bash" on Posix, or "cmd.exe" on Windows
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The shell to run for the \fBnpm explore\fR command.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help edit
+.IP \(bu 4
+npm help rebuild
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-find-dupes.1 b/node/node_modules/npm/man/man1/npm-find-dupes.1
new file mode 100644
index 0000000000000000000000000000000000000000..fb9d26672c3f4667f061b60bf65f09e95c22b247
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-find-dupes.1
@@ -0,0 +1,225 @@
+.TH "NPM-FIND-DUPES" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-find-dupes\fR - Find duplication in the package tree
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm find-dupes
+.fi
+.RE
+.SS "Description"
+.P
+Runs \fBnpm dedupe\fR in \fB--dry-run\fR mode, making npm only output the duplications, without actually changing the package tree.
+.SS "Configuration"
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help dedupe
+.IP \(bu 4
+npm help ls
+.IP \(bu 4
+npm help update
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-fund.1 b/node/node_modules/npm/man/man1/npm-fund.1
new file mode 100644
index 0000000000000000000000000000000000000000..dc11744ff03ed70ae6a39293f5c8f5a77f24fe53
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-fund.1
@@ -0,0 +1,142 @@
+.TH "NPM-FUND" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-fund\fR - Retrieve funding information
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm fund \[lB]<package-spec>\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This command retrieves information on how to fund the dependencies of a given project. If no package name is provided, it will list all dependencies that are looking for funding in a tree structure, listing the type of funding and the url to visit. If a package name is provided then it tries to open its funding url using the \fB\[rs]fB--browser\[rs]fR config\fR \fI\(la/using-npm/config#browser\(ra\fR param; if there are multiple funding sources for the package, the user will be instructed to pass the \fB--which\fR option to disambiguate.
+.P
+The list will avoid duplicated entries and will stack all packages that share the same url as a single entry. Thus, the list does not have the same shape of the output from \fBnpm ls\fR.
+.SS "Example"
+.SS "Workspaces support"
+.P
+It's possible to filter the results to only include a single workspace and its dependencies using the \fB\[rs]fBworkspace\[rs]fR config\fR \fI\(la/using-npm/config#workspace\(ra\fR option.
+.SS "Example:"
+.P
+Here's an example running \fBnpm fund\fR in a project with a configured workspace \fBa\fR:
+.P
+.RS 2
+.nf
+$ npm fund
+test-workspaces-fund@1.0.0
++-- https://example.com/a
+| | `-- a@1.0.0
+| `-- https://example.com/maintainer
+|     `-- foo@1.0.0
++-- https://example.com/npmcli-funding
+|   `-- @npmcli/test-funding
+`-- https://example.com/org
+    `-- bar@2.0.0
+.fi
+.RE
+.P
+And here is an example of the expected result when filtering only by a specific workspace \fBa\fR in the same project:
+.P
+.RS 2
+.nf
+$ npm fund -w a
+test-workspaces-fund@1.0.0
+`-- https://example.com/a
+  | `-- a@1.0.0
+  `-- https://example.com/maintainer
+      `-- foo@2.0.0
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBbrowser\fR"
+.RS 0
+.IP \(bu 4
+Default: macOS: \fB"open"\fR, Windows: \fB"start"\fR, Others: \fB"xdg-open"\fR
+.IP \(bu 4
+Type: null, Boolean, or String
+.RE 0
+
+.P
+The browser that is called by npm commands to open websites.
+.P
+Set to \fBfalse\fR to suppress browser behavior and instead print urls to terminal.
+.P
+Set to \fBtrue\fR to use default system URL opener.
+.SS "\fBunicode\fR"
+.RS 0
+.IP \(bu 4
+Default: false on windows, true on mac/unix systems with a unicode locale, as defined by the \fBLC_ALL\fR, \fBLC_CTYPE\fR, or \fBLANG\fR environment variables.
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to true, npm uses unicode characters in the tree output. When false, it uses ascii characters instead of unicode glyphs.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBwhich\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If there are multiple funding sources, which 1-indexed source URL to open.
+.SH "SEE ALSO"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help docs
+.IP \(bu 4
+npm help ls
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-get.1 b/node/node_modules/npm/man/man1/npm-get.1
new file mode 100644
index 0000000000000000000000000000000000000000..a21da494db0f77ad1bd5e153c5c5ad8143e66c98
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-get.1
@@ -0,0 +1,31 @@
+.TH "NPM-GET" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-get\fR - Get a value from the npm configuration
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm get \[lB]<key> ...\[rB] (See `npm config`)
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Get a value from the npm configuration
+.SS "Configuration"
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "help config"
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-help-search.1 b/node/node_modules/npm/man/man1/npm-help-search.1
new file mode 100644
index 0000000000000000000000000000000000000000..5375c73622e69aba4df6cda011ae892371213b53
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-help-search.1
@@ -0,0 +1,37 @@
+.TH "NPM-HELP-SEARCH" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-help-search\fR - Search npm help documentation
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm help-search <text>
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+This command will search the npm markdown documentation files for the terms provided, and then list the results, sorted by relevance.
+.P
+If only one result is found, then it will show that help topic.
+.P
+If the argument to \fBnpm help\fR is not a known help topic, then it will call \fBhelp-search\fR. It is rarely if ever necessary to call this command directly.
+.SS "Configuration"
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help npm
+.IP \(bu 4
+npm help help
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-help.1 b/node/node_modules/npm/man/man1/npm-help.1
new file mode 100644
index 0000000000000000000000000000000000000000..2bb65b7ee9850100fb432c43ad512acfc666b48a
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-help.1
@@ -0,0 +1,47 @@
+.TH "NPM-HELP" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-help\fR - Get help on npm
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm help <term> \[lB]<terms..>\[rB]
+
+alias: hlep
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+If supplied a topic, then show the appropriate documentation page.
+.P
+If the topic does not exist, or if multiple terms are provided, then npm will run the \fBhelp-search\fR command to find a match. Note that, if \fBhelp-search\fR finds a single subject, then it will run \fBhelp\fR on that topic, so unique matches are equivalent to specifying a topic name.
+.SS "Configuration"
+.SS "\fBviewer\fR"
+.RS 0
+.IP \(bu 4
+Default: "man" on Posix, "browser" on Windows
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The program to use to view help content.
+.P
+Set to \fB"browser"\fR to view html help content in the default web browser.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help npm
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help help-search
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-init.1 b/node/node_modules/npm/man/man1/npm-init.1
new file mode 100644
index 0000000000000000000000000000000000000000..649f3410978f800591849bc709918cc6cc45ff43
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-init.1
@@ -0,0 +1,393 @@
+.TH "NPM-INIT" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-init\fR - Create a package.json file
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm init <package-spec> (same as `npx create-<package-spec>`)
+npm init <@scope> (same as `npx <@scope>/create`)
+
+aliases: create, innit
+.fi
+.RE
+.SS "Description"
+.P
+\fBnpm init <initializer>\fR can be used to set up a new or existing npm package.
+.P
+\fBinitializer\fR in this case is an npm package named \fBcreate-<initializer>\fR, which will be installed by npm help npm-exec, and then have its main bin executed -- presumably creating or updating \fBpackage.json\fR and running any other initialization-related operations.
+.P
+The init command is transformed to a corresponding \fBnpm exec\fR operation as follows:
+.RS 0
+.IP \(bu 4
+\fBnpm init foo\fR -> \fBnpm exec create-foo\fR
+.IP \(bu 4
+\fBnpm init @usr/foo\fR -> \fBnpm exec @usr/create-foo\fR
+.IP \(bu 4
+\fBnpm init @usr\fR -> \fBnpm exec @usr/create\fR
+.IP \(bu 4
+\fBnpm init @usr@2.0.0\fR -> \fBnpm exec @usr/create@2.0.0\fR
+.IP \(bu 4
+\fBnpm init @usr/foo@2.0.0\fR -> \fBnpm exec @usr/create-foo@2.0.0\fR
+.RE 0
+
+.P
+If the initializer is omitted (by just calling \fBnpm init\fR), init will fall back to legacy init behavior. It will ask you a bunch of questions, and then write a package.json for you. It will attempt to make reasonable guesses based on existing fields, dependencies, and options selected. It is strictly additive, so it will keep any fields and values that were already set. You can also use \fB-y\fR/\fB--yes\fR to skip the questionnaire altogether. If you pass \fB--scope\fR, it will create a scoped package.
+.P
+\fINote:\fR if a user already has the \fBcreate-<initializer>\fR package globally installed, that will be what \fBnpm init\fR uses. If you want npm to use the latest version, or another specific version you must specify it:
+.RS 0
+.IP \(bu 4
+\fBnpm init foo@latest\fR # fetches and runs the latest \fBcreate-foo\fR from the registry
+.IP \(bu 4
+\fBnpm init foo@1.2.3\fR # runs \fBcreate-foo@1.2.3\fR specifically
+.RE 0
+
+.SS "Forwarding additional options"
+.P
+Any additional options will be passed directly to the command, so \fBnpm init foo -- --hello\fR will map to \fBnpm exec -- create-foo --hello\fR.
+.P
+To better illustrate how options are forwarded, here's a more evolved example showing options passed to both the \fBnpm cli\fR and a create package, both following commands are equivalent:
+.RS 0
+.IP \(bu 4
+\fBnpm init foo -y --registry=<url> -- --hello -a\fR
+.IP \(bu 4
+\fBnpm exec -y --registry=<url> -- create-foo --hello -a\fR
+.RE 0
+
+.SS "Examples"
+.P
+Create a new React-based project using \fB\[rs]fBcreate-react-app\[rs]fR\fR \fI\(lahttps://npm.im/create-react-app\(ra\fR:
+.P
+.RS 2
+.nf
+$ npm init react-app ./my-react-app
+.fi
+.RE
+.P
+Create a new \fBesm\fR-compatible package using \fB\[rs]fBcreate-esm\[rs]fR\fR \fI\(lahttps://npm.im/create-esm\(ra\fR:
+.P
+.RS 2
+.nf
+$ mkdir my-esm-lib && cd my-esm-lib
+$ npm init esm --yes
+.fi
+.RE
+.P
+Generate a plain old package.json using legacy init:
+.P
+.RS 2
+.nf
+$ mkdir my-npm-pkg && cd my-npm-pkg
+$ git init
+$ npm init
+.fi
+.RE
+.P
+Generate it without having it ask any questions:
+.P
+.RS 2
+.nf
+$ npm init -y
+.fi
+.RE
+.P
+Set the private flag to \fBtrue\fR in package.json:
+.P
+.RS 2
+.nf
+$ npm init --init-private -y
+.fi
+.RE
+.SS "Workspaces support"
+.P
+It's possible to create a new workspace within your project by using the \fBworkspace\fR config option. When using \fBnpm init -w <dir>\fR the cli will create the folders and boilerplate expected while also adding a reference to your project \fBpackage.json\fR \fB"workspaces": \[lB]\[rB]\fR property in order to make sure that new generated \fBworkspace\fR is properly set up as such.
+.P
+Given a project with no workspaces, e.g:
+.P
+.RS 2
+.nf
+.
++-- package.json
+.fi
+.RE
+.P
+You may generate a new workspace using the legacy init:
+.P
+.RS 2
+.nf
+$ npm init -w packages/a
+.fi
+.RE
+.P
+That will generate a new folder and \fBpackage.json\fR file, while also updating your top-level \fBpackage.json\fR to add the reference to this new workspace:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   `-- a
+       `-- package.json
+.fi
+.RE
+.P
+The workspaces init also supports the \fBnpm init <initializer> -w <dir>\fR syntax, following the same set of rules explained earlier in the initial \fBDescription\fR section of this page. Similar to the previous example of creating a new React-based project using \fB\[rs]fBcreate-react-app\[rs]fR\fR \fI\(lahttps://npm.im/create-react-app\(ra\fR, the following syntax will make sure to create the new react app as a nested \fBworkspace\fR within your project and configure your \fBpackage.json\fR to recognize it as such:
+.P
+.RS 2
+.nf
+npm init -w packages/my-react-app react-app .
+.fi
+.RE
+.P
+This will make sure to generate your react app as expected, one important consideration to have in mind is that \fBnpm exec\fR is going to be run in the context of the newly created folder for that workspace, and that's the reason why in this example the initializer uses the initializer name followed with a dot to represent the current directory in that context, e.g: \fBreact-app .\fR:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- my-react-app
+       +-- README
+       +-- package.json
+       `-- ...
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBinit-author-name\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package author's name.
+.SS "\fBinit-author-url\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: "" or URL
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package author's homepage.
+.SS "\fBinit-license\fR"
+.RS 0
+.IP \(bu 4
+Default: "ISC"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package license.
+.SS "\fBinit-module\fR"
+.RS 0
+.IP \(bu 4
+Default: "~/.npm-init.js"
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+A module that will be loaded by the \fBnpm init\fR command. See the documentation for the \fBinit-package-json\fR \fI\(lahttps://github.com/npm/init-package-json\(ra\fR module for more information, or npm help init.
+.SS "\fBinit-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "commonjs"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value that \fBnpm init\fR should use by default for the package.json type field.
+.SS "\fBinit-version\fR"
+.RS 0
+.IP \(bu 4
+Default: "1.0.0"
+.IP \(bu 4
+Type: SemVer string
+.RE 0
+
+.P
+The value that \fBnpm init\fR should use by default for the package version number, if not already set in package.json.
+.SS "\fBinit-private\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package's private flag.
+.SS "\fByes\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Automatically answer "yes" to any prompts that npm might print on the command line.
+.SS "\fBforce\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Removes various protections against unfortunate side effects, common mistakes, unnecessary performance degradation, and malicious input.
+.RS 0
+.IP \(bu 4
+Allow clobbering non-npm files in global installs.
+.IP \(bu 4
+Allow the \fBnpm version\fR command to work on an unclean git repository.
+.IP \(bu 4
+Allow deleting the cache folder with \fBnpm cache clean\fR.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of npm.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of \fBnode\fR, even if \fB--engine-strict\fR is enabled.
+.IP \(bu 4
+Allow \fBnpm audit fix\fR to install modules outside your stated dependency range (including SemVer-major changes).
+.IP \(bu 4
+Allow unpublishing all versions of a published package.
+.IP \(bu 4
+Allow conflicting peerDependencies to be installed in the root project.
+.IP \(bu 4
+Implicitly set \fB--yes\fR during \fBnpm init\fR.
+.IP \(bu 4
+Allow clobbering existing values in \fBnpm pkg\fR
+.IP \(bu 4
+Allow unpublishing of entire packages (not just a single version).
+.RE 0
+
+.P
+If you don't have a clear idea of what you want to do, it is strongly recommended that you do not use this option!
+.SS "\fBscope\fR"
+.RS 0
+.IP \(bu 4
+Default: the scope of the current project, if any, or ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Associate an operation with a scope for a scoped registry.
+.P
+Useful when logging in to or out of a private registry:
+.P
+.RS 2
+.nf
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+.fi
+.RE
+.P
+This will cause \fB@mycorp\fR to be mapped to the registry for future installation of packages specified according to the pattern \fB@mycorp/package\fR.
+.P
+This will also cause \fBnpm init\fR to create a scoped package.
+.P
+.RS 2
+.nf
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+.fi
+.RE
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces-update\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the npm cli will run an update after operations that may possibly change the workspaces installed to the \fBnode_modules\fR folder.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+\fBinit-package-json module\fR \fI\(lahttp://npm.im/init-package-json\(ra\fR
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help version
+.IP \(bu 4
+npm help scope
+.IP \(bu 4
+npm help exec
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-install-ci-test.1 b/node/node_modules/npm/man/man1/npm-install-ci-test.1
new file mode 100644
index 0000000000000000000000000000000000000000..3b5a865bea080e074806b9dac34060e638fbd9ef
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-install-ci-test.1
@@ -0,0 +1,251 @@
+.TH "NPM-INSTALL-CI-TEST" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-install-ci-test\fR - Install a project with a clean slate and run tests
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm install-ci-test
+
+aliases: cit, clean-install-test, sit
+.fi
+.RE
+.SS "Description"
+.P
+This command runs \fBnpm ci\fR followed immediately by \fBnpm test\fR.
+.SS "Configuration"
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help install-test
+.IP \(bu 4
+npm help ci
+.IP \(bu 4
+npm help test
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-install-test.1 b/node/node_modules/npm/man/man1/npm-install-test.1
new file mode 100644
index 0000000000000000000000000000000000000000..60c7bc220f0b8617e999ef3e24def41f2e0f4185
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-install-test.1
@@ -0,0 +1,388 @@
+.TH "NPM-INSTALL-TEST" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-install-test\fR - Install package(s) and run tests
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm install-test \[lB]<package-spec> ...\[rB]
+
+alias: it
+.fi
+.RE
+.SS "Description"
+.P
+This command runs an \fBnpm install\fR followed immediately by an \fBnpm test\fR. It takes exactly the same arguments as \fBnpm install\fR.
+.SS "Configuration"
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBsave-exact\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Dependencies saved to package.json will be configured with an exact version rather than using npm's default semver range operator.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBprefer-dedupe\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prefer to deduplicate packages if possible, rather than choosing a newer version of a dependency.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbefore\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Date
+.RE 0
+
+.P
+If passed to \fBnpm install\fR, will rebuild the npm tree such that only versions that were available \fBon or before\fR the given date are installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
+.P
+This config cannot be used with: \fBmin-release-age\fR
+.SS "\fBmin-release-age\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
+.P
+This config cannot be used with: \fBbefore\fR
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBcpu\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override CPU architecture of native modules to install. Acceptable values are same as \fBcpu\fR field of package.json, which comes from \fBprocess.arch\fR.
+.SS "\fBos\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override OS of native modules to install. Acceptable values are same as \fBos\fR field of package.json, which comes from \fBprocess.platform\fR.
+.SS "\fBlibc\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override libc of native modules to install. Acceptable values are same as \fBlibc\fR field of package.json
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help install-ci-test
+.IP \(bu 4
+npm help test
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-install.1 b/node/node_modules/npm/man/man1/npm-install.1
new file mode 100644
index 0000000000000000000000000000000000000000..254546ab0d22abb53154bb5bc1474c723d34e4f0
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-install.1
@@ -0,0 +1,832 @@
+.TH "NPM-INSTALL" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-install\fR - Install a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm install \[lB]<package-spec> ...\[rB]
+
+aliases: add, i, in, ins, inst, insta, instal, isnt, isnta, isntal, isntall
+.fi
+.RE
+.SS "Description"
+.P
+This command installs a package and any packages that it depends on. If the package has a package-lock, or an npm shrinkwrap file, or a yarn lock file, the installation of dependencies will be driven by that, respecting the following order of precedence:
+.RS 0
+.IP \(bu 4
+\fBnpm-shrinkwrap.json\fR
+.IP \(bu 4
+\fBpackage-lock.json\fR
+.IP \(bu 4
+\fByarn.lock\fR
+.RE 0
+
+.P
+See \fBpackage-lock.json\fR \fI\(la/configuring-npm/package-lock-json\(ra\fR and npm help shrinkwrap.
+.SS "How \fBnpm install\fR uses \fBpackage-lock.json\fR"
+.P
+When you run \fBnpm install\fR without arguments, npm compares \fBpackage.json\fR and \fBpackage-lock.json\fR:
+.RS 0
+.IP \(bu 4
+\fBIf the lockfile's resolved versions satisfy the \fBpackage.json\fB ranges:\fR npm uses the exact versions from \fBpackage-lock.json\fR to ensure reproducible builds across environments.
+.IP \(bu 4
+\fBIf the ranges don't match:\fR npm resolves new versions that satisfy the \fBpackage.json\fR ranges and updates \fBpackage-lock.json\fR accordingly. This happens when you modify version ranges in \fBpackage.json\fR (e.g., changing \fB^7.0.0\fR to \fB^8.0.0\fR). Note that changing a range within the same major version (e.g., \fB^7.0.0\fR to \fB^7.1.0\fR) will only update the metadata in the lockfile if the currently installed version still satisfies the new range.
+.RE 0
+
+.P
+In essence, \fBpackage-lock.json\fR locks your dependencies to specific versions, but \fBpackage.json\fR is the source of truth for acceptable version ranges. When the lockfile's versions satisfy the \fBpackage.json\fR ranges, the lockfile wins. When they conflict, \fBpackage.json\fR wins and the lockfile is updated.
+.P
+If you want to install packages while ensuring that \fBpackage.json\fR is not modified and that both files are strictly in sync, use npm help ci instead.
+.P
+A \fBpackage\fR is:
+.RS 0
+.IP \(bu 4
+a) a folder containing a program described by a \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR file
+.IP \(bu 4
+b) a gzipped tarball containing (a)
+.IP \(bu 4
+c) a url that resolves to (b)
+.IP \(bu 4
+d) a \fB<name>@<version>\fR that is published on the registry (see npm help registry) with (c)
+.IP \(bu 4
+e) a \fB<name>@<tag>\fR (see npm help dist-tag) that points to (d)
+.IP \(bu 4
+f) a \fB<name>\fR that has a "latest" tag satisfying (e)
+.IP \(bu 4
+g) a \fB<git remote url>\fR that resolves to (a)
+.RE 0
+
+.P
+Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).
+.RS 0
+.IP \(bu 4
+\fBnpm install\fR (in a package directory, no arguments):
+.P
+Install the dependencies to the local \fBnode_modules\fR folder.
+.P
+In global mode (ie, with \fB-g\fR or \fB--global\fR appended to the command), it installs the current package context (ie, the current working directory) as a global package.
+.P
+By default, \fBnpm install\fR will install all modules listed as dependencies in \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR.
+.P
+With the \fB--production\fR flag (or when the \fBNODE_ENV\fR environment variable is set to \fBproduction\fR), npm will not install modules listed in \fBdevDependencies\fR. To install all modules listed in both \fBdependencies\fR and \fBdevDependencies\fR when \fBNODE_ENV\fR environment variable is set to \fBproduction\fR, you can use \fB--production=false\fR.
+.RS 4
+.P
+NOTE: The \fB--production\fR flag has no particular meaning when adding a dependency to a project.
+.RE 0
+
+.IP \(bu 4
+\fBnpm install <folder>\fR:
+.P
+If \fB<folder>\fR sits inside the root of your project, its dependencies will be installed and may be hoisted to the top-level \fBnode_modules\fR as they would for other types of dependencies. If \fB<folder>\fR sits outside the root of your project, \fInpm will not install the package dependencies\fR in the directory \fB<folder>\fR, but it will create a symlink to \fB<folder>\fR.
+.RS 4
+.P
+NOTE: If you want to install the content of a directory like a package from the registry instead of creating a link, you would need to use the \fB--install-links\fR option.
+.RE 0
+
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install ../../other-package --install-links
+npm install ./sub-package
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install <tarball file>\fR:
+.P
+Install a package that is sitting on the filesystem. Note: if you just want to link a dev directory into your npm root, you can do this more easily by using npm help link.
+.P
+Tarball requirements:
+.RS 4
+.IP \(bu 4
+The filename \fImust\fR use \fB.tar\fR, \fB.tar.gz\fR, or \fB.tgz\fR as the extension.
+.IP \(bu 4
+The package contents should reside in a subfolder inside the tarball (usually it is called \fBpackage/\fR). npm strips one directory layer when installing the package (an equivalent of \fBtar x --strip-components=1\fR is run).
+.IP \(bu 4
+The package must contain a \fBpackage.json\fR file with \fBname\fR and \fBversion\fR properties.
+.RE 0
+
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install ./package.tgz
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install <tarball url>\fR:
+.P
+Fetch the tarball url, and then install it. In order to distinguish between this and other options, the argument must start with "http://" or "https://"
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install https://github.com/indexzero/forever/tarball/v0.5.6
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install \[lB]<@scope>/\[rB]<name>\fR:
+.P
+Do a \fB<name>@<tag>\fR install, where \fB<tag>\fR is the "tag" config. (See \fB\[rs]fBconfig\[rs]fR\fR \fI\(la/using-npm/config#tag\(ra\fR. The config's default value is \fBlatest\fR.)
+.P
+In most cases, this will install the version of the modules tagged as \fBlatest\fR on the npm registry.
+.P
+\fBNote:\fR When installing by name without specifying a version or tag, npm prioritizes versions that match the current Node.js version based on the package's \fBengines\fR field. If the \fBlatest\fR tag points to a version incompatible with your current Node.js version, npm will install the newest compatible version instead. To install a specific version regardless of \fBengines\fR compatibility, explicitly specify the version or tag: \fBnpm install <name>@latest\fR.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install sax
+.fi
+.RE
+.P
+\fBnpm install\fR saves any specified packages into \fBdependencies\fR by default. Additionally, you can control where and how they get saved with some additional flags:
+.RS 4
+.IP \(bu 4
+\fB-P, --save-prod\fR: Package will appear in your \fBdependencies\fR. This is the default unless \fB-D\fR or \fB-O\fR are present.
+.IP \(bu 4
+\fB-D, --save-dev\fR: Package will appear in your \fBdevDependencies\fR.
+.IP \(bu 4
+\fB--save-peer\fR: Package will appear in your \fBpeerDependencies\fR.
+.IP \(bu 4
+\fB-O, --save-optional\fR: Package will appear in your \fBoptionalDependencies\fR.
+.IP \(bu 4
+\fB--no-save\fR: Prevents saving to \fBdependencies\fR.
+.RE 0
+
+.P
+When using any of the above options to save dependencies to your package.json, there are two additional, optional flags:
+.RS 4
+.IP \(bu 4
+\fB-E, --save-exact\fR: Saved dependencies will be configured with an exact version rather than using npm's default semver range operator.
+.IP \(bu 4
+\fB-B, --save-bundle\fR: Saved dependencies will also be added to your \fBbundleDependencies\fR list.
+.RE 0
+
+.P
+Further, if you have an \fBnpm-shrinkwrap.json\fR or \fBpackage-lock.json\fR then it will be updated as well.
+.P
+\fB<scope>\fR is optional. The package will be downloaded from the registry associated with the specified scope. If no registry is associated with the given scope the default registry is assumed. See npm help scope.
+.P
+Note: if you do not include the @-symbol on your scope name, npm will interpret this as a GitHub repository instead, see below. Scopes names must also be followed by a slash.
+.P
+Examples:
+.P
+.RS 2
+.nf
+npm install sax
+npm install githubname/reponame
+npm install @myorg/privatepackage
+npm install node-tap --save-dev
+npm install dtrace-provider --save-optional
+npm install readable-stream --save-exact
+npm install ansi-regex --save-bundle
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install <alias>@npm:<name>\fR:
+.P
+Install a package under a custom alias. Allows multiple versions of a same-name package side-by-side, more convenient import names for packages with otherwise long ones, and using git forks replacements or forked npm packages as replacements. Aliasing works only on your project and does not rename packages in transitive dependencies. Aliases should follow the naming conventions stated in \fB\[rs]fBvalidate-npm-package-name\[rs]fR\fR \fI\(lahttps://www.npmjs.com/package/validate-npm-package-name#naming-rules\(ra\fR.
+.P
+Examples:
+.P
+.RS 2
+.nf
+npm install my-react@npm:react
+npm install jquery2@npm:jquery@2
+npm install jquery3@npm:jquery@3
+npm install npa@npm:npm-package-arg
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install \[lB]<@scope>/\[rB]<name>@<tag>\fR:
+.P
+Install the version of the package that is referenced by the specified tag. If the tag does not exist in the registry data for that package, then this will fail.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install sax@latest
+npm install @myorg/mypackage@latest
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install \[lB]<@scope>/\[rB]<name>@<version>\fR:
+.P
+Install the specified version of the package. This will fail if the version has not been published to the registry.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install sax@0.1.1
+npm install @myorg/privatepackage@1.5.0
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install \[lB]<@scope>/\[rB]<name>@<version range>\fR:
+.P
+Install a version of the package matching the specified version range. This will follow the same rules for resolving dependencies described in \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR.
+.P
+Note that most version ranges must be put in quotes so that your shell will treat it as a single argument.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install sax@">=0.1.0 <0.2.0"
+npm install @myorg/privatepackage@"16 - 17"
+.fi
+.RE
+.P
+\fBPrerelease versions:\fR By default, version ranges only match stable versions. To include prerelease versions, they must be explicitly specified in the range. Prerelease versions are tied to a specific version triple (major.minor.patch). For example, \fB^1.2.3-beta.1\fR will only match prereleases for \fB1.2.x\fR, not \fB1.3.x\fR. To match all prereleases for a major version, use a range like \fB^1.0.0-0\fR, which will include all \fB1.x.x\fR prereleases.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install package@^1.2.3-beta.1  # Matches 1.2.3-beta.1, 1.2.3-beta.2, 1.2.4-beta.1, etc.
+npm install package@^1.0.0-0       # Matches all 1.x.x prereleases and stable versions
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install <git remote url>\fR:
+.P
+Installs the package from the hosted git provider, cloning it with \fBgit\fR. For a full git remote url, only that URL will be attempted.
+.P
+.RS 2
+.nf
+<protocol>://\[lB]<user>\[lB]:<password>\[rB]@\[rB]<hostname>\[lB]:<port>\[rB]\[lB]:\[rB]\[lB]/\[rB]<path>\[lB]#<commit-ish> | #semver:<semver>\[rB]
+.fi
+.RE
+.P
+\fB<protocol>\fR is one of \fBgit\fR, \fBgit+ssh\fR, \fBgit+http\fR, \fBgit+https\fR, or \fBgit+file\fR.
+.P
+If \fB#<commit-ish>\fR is provided, it will be used to clone exactly that commit. If the commit-ish has the format \fB#semver:<semver>\fR, \fB<semver>\fR can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency. If neither \fB#<commit-ish>\fR or \fB#semver:<semver>\fR is specified, then the default branch of the repository is used.
+.P
+If the repository makes use of submodules, those submodules will be cloned as well.
+.P
+If the package being installed contains a \fBprepare\fR script, its \fBdependencies\fR and \fBdevDependencies\fR will be installed, and the prepare script will be run, before the package is packaged and installed.
+.P
+The following git environment variables are recognized by npm and will be added to the environment when running git:
+.RS 4
+.IP \(bu 4
+\fBGIT_ASKPASS\fR
+.IP \(bu 4
+\fBGIT_EXEC_PATH\fR
+.IP \(bu 4
+\fBGIT_PROXY_COMMAND\fR
+.IP \(bu 4
+\fBGIT_SSH\fR
+.IP \(bu 4
+\fBGIT_SSH_COMMAND\fR
+.IP \(bu 4
+\fBGIT_SSL_CAINFO\fR
+.IP \(bu 4
+\fBGIT_SSL_NO_VERIFY\fR
+.RE 0
+
+.P
+See the git man page for details.
+.P
+Examples:
+.P
+.RS 2
+.nf
+npm install git+ssh://git@github.com:npm/cli.git#v1.0.27
+npm install git+ssh://git@github.com:npm/cli#pull/273
+npm install git+ssh://git@github.com:npm/cli#semver:^5.0
+npm install git+https://isaacs@github.com/npm/cli.git
+npm install git://github.com/npm/cli.git#v1.0.27
+GIT_SSH_COMMAND='ssh -i ~/.ssh/custom_ident' npm install git+ssh://git@github.com:npm/cli.git
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install <githubname>/<githubrepo>\[lB]#<commit-ish>\[rB]\fR:
+.IP \(bu 4
+\fBnpm install github:<githubname>/<githubrepo>\[lB]#<commit-ish>\[rB]\fR:
+.P
+Install the package at \fBhttps://github.com/githubname/githubrepo\fR by attempting to clone it using \fBgit\fR.
+.P
+If \fB#<commit-ish>\fR is provided, it will be used to clone exactly that commit. If the commit-ish has the format \fB#semver:<semver>\fR, \fB<semver>\fR can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency. If neither \fB#<commit-ish>\fR or \fB#semver:<semver>\fR is specified, then the default branch is used.
+.P
+As with regular git dependencies, \fBdependencies\fR and \fBdevDependencies\fR will be installed if the package has a \fBprepare\fR script before the package is done installing.
+.P
+Examples:
+.P
+.RS 2
+.nf
+npm install mygithubuser/myproject
+npm install github:mygithubuser/myproject
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install gist:\[lB]<githubname>/\[rB]<gistID>\[lB]#<commit-ish>|#semver:<semver>\[rB]\fR:
+.P
+Install the package at \fBhttps://gist.github.com/gistID\fR by attempting to clone it using \fBgit\fR. The GitHub username associated with the gist is optional and will not be saved in \fBpackage.json\fR.
+.P
+As with regular git dependencies, \fBdependencies\fR and \fBdevDependencies\fR will be installed if the package has a \fBprepare\fR script before the package is done installing.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install gist:101a11beef
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install bitbucket:<bitbucketname>/<bitbucketrepo>\[lB]#<commit-ish>\[rB]\fR:
+.P
+Install the package at \fBhttps://bitbucket.org/bitbucketname/bitbucketrepo\fR by attempting to clone it using \fBgit\fR.
+.P
+If \fB#<commit-ish>\fR is provided, it will be used to clone exactly that commit. If the commit-ish has the format \fB#semver:<semver>\fR, \fB<semver>\fR can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency. If neither \fB#<commit-ish>\fR or \fB#semver:<semver>\fR is specified, then \fBmaster\fR is used.
+.P
+As with regular git dependencies, \fBdependencies\fR and \fBdevDependencies\fR will be installed if the package has a \fBprepare\fR script before the package is done installing.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install bitbucket:mybitbucketuser/myproject
+.fi
+.RE
+.IP \(bu 4
+\fBnpm install gitlab:<gitlabname>/<gitlabrepo>\[lB]#<commit-ish>\[rB]\fR:
+.P
+Install the package at \fBhttps://gitlab.com/gitlabname/gitlabrepo\fR by attempting to clone it using \fBgit\fR.
+.P
+If \fB#<commit-ish>\fR is provided, it will be used to clone exactly that commit. If the commit-ish has the format \fB#semver:<semver>\fR, \fB<semver>\fR can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency. If neither \fB#<commit-ish>\fR or \fB#semver:<semver>\fR is specified, then \fBmaster\fR is used.
+.P
+As with regular git dependencies, \fBdependencies\fR and \fBdevDependencies\fR will be installed if the package has a \fBprepare\fR script before the package is done installing.
+.P
+Example:
+.P
+.RS 2
+.nf
+npm install gitlab:mygitlabuser/myproject
+npm install gitlab:myusr/myproj#semver:^5.0
+.fi
+.RE
+.RE 0
+
+.P
+You may combine multiple arguments and even multiple types of arguments. For example:
+.P
+.RS 2
+.nf
+npm install sax@">=0.1.0 <0.2.0" bench supervisor
+.fi
+.RE
+.P
+The \fB--tag\fR argument will apply to all of the specified install targets. If a tag with the given name exists, the tagged version is preferred over newer versions.
+.P
+\fBNote:\fR The \fB--tag\fR option only affects packages specified on the command line. It does not override version ranges specified in \fBpackage.json\fR. For example, if \fBpackage.json\fR specifies \fB"foo": "^1.0.0"\fR and you run \fBnpm install --tag beta\fR, npm will still install a version matching \fB^1.0.0\fR even if the \fBbeta\fR tag points to a different version. To install a tagged version, specify the package explicitly: \fBnpm install foo@beta\fR.
+.P
+The \fB--dry-run\fR argument will report in the usual way what the install would have done without actually installing anything.
+.P
+The \fB--package-lock-only\fR argument will only update the \fBpackage-lock.json\fR, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+The \fB-f\fR or \fB--force\fR argument will force npm to fetch remote resources even if a local copy exists on disk.
+.P
+.RS 2
+.nf
+npm install sax --force
+.fi
+.RE
+.SS "Configuration"
+.P
+See the npm help config help doc. Many of the configuration params have some effect on installation, since that's most of what npm does.
+.P
+These are some of the most common options related to installation.
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBsave-exact\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Dependencies saved to package.json will be configured with an exact version rather than using npm's default semver range operator.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBprefer-dedupe\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prefer to deduplicate packages if possible, rather than choosing a newer version of a dependency.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbefore\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Date
+.RE 0
+
+.P
+If passed to \fBnpm install\fR, will rebuild the npm tree such that only versions that were available \fBon or before\fR the given date are installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
+.P
+This config cannot be used with: \fBmin-release-age\fR
+.SS "\fBmin-release-age\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
+.P
+This config cannot be used with: \fBbefore\fR
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBcpu\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override CPU architecture of native modules to install. Acceptable values are same as \fBcpu\fR field of package.json, which comes from \fBprocess.arch\fR.
+.SS "\fBos\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override OS of native modules to install. Acceptable values are same as \fBos\fR field of package.json, which comes from \fBprocess.platform\fR.
+.SS "\fBlibc\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override libc of native modules to install. Acceptable values are same as \fBlibc\fR field of package.json
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "Algorithm"
+.P
+Given a \fBpackage{dep}\fR structure: \fBA{B,C}, B{C}, C{D}\fR, the npm install algorithm produces:
+.P
+.RS 2
+.nf
+A
++-- B
++-- C
++-- D
+.fi
+.RE
+.P
+That is, the dependency from B to C is satisfied by the fact that A already caused C to be installed at a higher level. D is still installed at the top level because nothing conflicts with it.
+.P
+For \fBA{B,C}, B{C,D@1}, C{D@2}\fR, this algorithm produces:
+.P
+.RS 2
+.nf
+A
++-- B
++-- C
+   `-- D@2
++-- D@1
+.fi
+.RE
+.P
+Because B's D@1 will be installed in the top-level, C now has to install D@2 privately for itself. This algorithm is deterministic, but different trees may be produced if two dependencies are requested for installation in a different order.
+.P
+See npm help folders for a more detailed description of the specific folder structures that npm creates.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help update
+.IP \(bu 4
+npm help audit
+.IP \(bu 4
+npm help fund
+.IP \(bu 4
+npm help link
+.IP \(bu 4
+npm help rebuild
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help dist-tag
+.IP \(bu 4
+npm help uninstall
+.IP \(bu 4
+npm help shrinkwrap
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-link.1 b/node/node_modules/npm/man/man1/npm-link.1
new file mode 100644
index 0000000000000000000000000000000000000000..2d7a1f60309488b540288f80f82e04d4c08b1b83
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-link.1
@@ -0,0 +1,367 @@
+.TH "NPM-LINK" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-link\fR - Symlink a package folder
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm link \[lB]<package-spec>\[rB]
+
+alias: ln
+.fi
+.RE
+.SS "Description"
+.P
+This is handy for installing your own stuff, so that you can work on it and test iteratively without having to continually rebuild.
+.P
+Package linking is a two-step process.
+.P
+First, \fBnpm link\fR in a package folder with no arguments will create a symlink in the global folder \fB{prefix}/lib/node_modules/<package>\fR that links to the package where the \fBnpm link\fR command was executed. It will also link any bins in the package to \fB{prefix}/bin/{name}\fR. Note that \fBnpm link\fR uses the global prefix (see \fBnpm prefix -g\fR for its value).
+.P
+Next, in some other location, \fBnpm link package-name\fR will create a symbolic link from globally-installed \fBpackage-name\fR to \fBnode_modules/\fR of the current folder.
+.P
+Note that \fBpackage-name\fR is taken from \fBpackage.json\fR, \fInot\fR from the directory name.
+.P
+The package name can be optionally prefixed with a scope. See npm help scope. The scope must be preceded by an @-symbol and followed by a slash.
+.P
+When creating tarballs for \fBnpm publish\fR, the linked packages are "snapshotted" to their current state by resolving the symbolic links, if they are included in \fBbundleDependencies\fR.
+.P
+For example:
+.P
+.RS 2
+.nf
+cd ~/projects/node-redis    # go into the package directory
+npm link                    # creates global link
+cd ~/projects/node-bloggy   # go into some other package directory.
+npm link redis              # link-install the package
+.fi
+.RE
+.P
+Now, any changes to \fB~/projects/node-redis\fR will be reflected in \fB~/projects/node-bloggy/node_modules/node-redis/\fR. Note that the link should be to the package name, not the directory name for that package.
+.P
+You may also shortcut the two steps in one. For example, to do the above use-case in a shorter way:
+.P
+.RS 2
+.nf
+cd ~/projects/node-bloggy  # go into the dir of your main project
+npm link ../node-redis     # link the dir of your dependency
+.fi
+.RE
+.P
+The second line is the equivalent of doing:
+.P
+.RS 2
+.nf
+(cd ../node-redis; npm link)
+npm link redis
+.fi
+.RE
+.P
+That is, it first creates a global link, and then links the global installation target into your project's \fBnode_modules\fR folder.
+.P
+Note that in this case, you are referring to the directory name, \fBnode-redis\fR, rather than the package name \fBredis\fR.
+.P
+If your linked package is scoped (see npm help scope) your link command must include that scope, e.g.
+.P
+.RS 2
+.nf
+npm link @myorg/privatepackage
+.fi
+.RE
+.SS "Caveat"
+.P
+Note that package dependencies linked in this way are \fInot\fR saved to \fBpackage.json\fR by default, on the assumption that the intention is to have a link stand in for a regular non-link dependency. Otherwise, for example, if you depend on \fBredis@^3.0.1\fR, and ran \fBnpm link redis\fR, it would replace the \fB^3.0.1\fR dependency with \fBfile:../path/to/node-redis\fR, which you probably don't want! Additionally, other users or developers on your project would run into issues if they do not have their folders set up exactly the same as yours.
+.P
+If you are adding a \fInew\fR dependency as a link, you should add it to the relevant metadata by running \fBnpm install <dep> --package-lock-only\fR.
+.P
+If you \fIwant\fR to save the \fBfile:\fR reference in your \fBpackage.json\fR and \fBpackage-lock.json\fR files, you can use \fBnpm link <dep> --save\fR to do so.
+.SS "Workspace Usage"
+.P
+\fBnpm link <pkg> --workspace <name>\fR will link the relevant package as a dependency of the specified workspace(s). Note that It may actually be linked into the parent project's \fBnode_modules\fR folder, if there are no conflicting dependencies.
+.P
+\fBnpm link --workspace <name>\fR will create a global link to the specified workspace(s).
+.SS "Configuration"
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBsave-exact\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Dependencies saved to package.json will be configured with an exact version rather than using npm's default semver range operator.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help developers
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-ll.1 b/node/node_modules/npm/man/man1/npm-ll.1
new file mode 100644
index 0000000000000000000000000000000000000000..f7a3d958230da474a7ac927be8153ca56b055076
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-ll.1
@@ -0,0 +1,231 @@
+.TH "NPM-LL" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-ll\fR - List installed packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm ll \[lB]\[lB]<@scope>/\[rB]<pkg> ...\[rB]
+
+alias: la
+.fi
+.RE
+.SS "Description"
+.P
+List installed packages
+.SS "Configuration"
+.SS "\fBall\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When running \fBnpm outdated\fR and \fBnpm ls\fR, setting \fB--all\fR will show all outdated or installed packages, rather than only those directly depended upon by the current project.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBdepth\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBInfinity\fR if \fB--all\fR is set; otherwise, \fB0\fR
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+The depth to go when recursing packages for \fBnpm ls\fR.
+.P
+If not set, \fBnpm ls\fR will show only the immediate dependencies of the root project. If \fB--all\fR is set, then npm will show all dependencies by default.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBlink\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Used with \fBnpm ls\fR, limiting output to only those packages that are linked.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBunicode\fR"
+.RS 0
+.IP \(bu 4
+Default: false on windows, true on mac/unix systems with a unicode locale, as defined by the \fBLC_ALL\fR, \fBLC_CTYPE\fR, or \fBLANG\fR environment variables.
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to true, npm uses unicode characters in the tree output. When false, it uses ascii characters instead of unicode glyphs.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "help config"
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-login.1 b/node/node_modules/npm/man/man1/npm-login.1
new file mode 100644
index 0000000000000000000000000000000000000000..9f20ccfd8cc84f8478c73fca78065c0860576eb8
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-login.1
@@ -0,0 +1,97 @@
+.TH "NPM-LOGIN" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-login\fR - Login to a registry user account
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm login
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Verify a user in the specified registry, and save the credentials to the \fB.npmrc\fR file. If no registry is specified, the default registry will be used (see npm help config).
+.P
+When you run \fBnpm login\fR, the CLI automatically generates a legacy token of \fBpublish\fR type. For more information, see \fBAbout legacy tokens\fR \fI\(la/about-access-tokens#about-legacy-tokens\(ra\fR.
+.P
+When using \fBlegacy\fR for your \fBauth-type\fR, the username and password, are read in from prompts.
+.P
+To reset your password, go to \fI\(lahttps://www.npmjs.com/forgot\(ra\fR
+.P
+To change your email address, go to \fI\(lahttps://www.npmjs.com/email-edit\(ra\fR
+.P
+You may use this command multiple times with the same user account to authorize on a new machine. When authenticating on a new machine, the username, password and email address must all match with your existing record.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBscope\fR"
+.RS 0
+.IP \(bu 4
+Default: the scope of the current project, if any, or ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Associate an operation with a scope for a scoped registry.
+.P
+Useful when logging in to or out of a private registry:
+.P
+.RS 2
+.nf
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+.fi
+.RE
+.P
+This will cause \fB@mycorp\fR to be mapped to the registry for future installation of packages specified according to the pattern \fB@mycorp/package\fR.
+.P
+This will also cause \fBnpm init\fR to create a scoped package.
+.P
+.RS 2
+.nf
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+.fi
+.RE
+.SS "\fBauth-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "web"
+.IP \(bu 4
+Type: "legacy" or "web"
+.RE 0
+
+.P
+What authentication strategy to use with \fBlogin\fR. Note that if an \fBotp\fR config is given, this value will always be set to \fBlegacy\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help token
+.IP \(bu 4
+npm help profile
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-logout.1 b/node/node_modules/npm/man/man1/npm-logout.1
new file mode 100644
index 0000000000000000000000000000000000000000..fc04d6ec0a8c69dbc60d474a9345607687c1e673
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-logout.1
@@ -0,0 +1,75 @@
+.TH "NPM-LOGOUT" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-logout\fR - Log out of the registry
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm logout
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+When logged into a registry that supports token-based authentication, tell the server to end this token's session. This will invalidate the token everywhere you're using it, not just for the current environment.
+.P
+When logged into a legacy registry that uses username and password authentication, this will clear the credentials in your user configuration. In this case, it will \fIonly\fR affect the current environment.
+.P
+If \fB--scope\fR is provided, this will find the credentials for the registry connected to that scope, if set.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBscope\fR"
+.RS 0
+.IP \(bu 4
+Default: the scope of the current project, if any, or ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Associate an operation with a scope for a scoped registry.
+.P
+Useful when logging in to or out of a private registry:
+.P
+.RS 2
+.nf
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+.fi
+.RE
+.P
+This will cause \fB@mycorp\fR to be mapped to the registry for future installation of packages specified according to the pattern \fB@mycorp/package\fR.
+.P
+This will also cause \fBnpm init\fR to create a scoped package.
+.P
+.RS 2
+.nf
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+.fi
+.RE
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help adduser
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help whoami
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-ls.1 b/node/node_modules/npm/man/man1/npm-ls.1
new file mode 100644
index 0000000000000000000000000000000000000000..f21f367b1b802f59c361c5ee014efc548174fa86
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-ls.1
@@ -0,0 +1,271 @@
+.TH "NPM-LS" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-ls\fR - List installed packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm ls <package-spec>
+
+alias: list
+.fi
+.RE
+.SS "Description"
+.P
+This command will print to stdout all the versions of packages that are installed, as well as their dependencies when \fB--all\fR is specified, in a tree structure.
+.P
+Note: to get a "bottoms up" view of why a given package is included in the tree at all, use npm help explain.
+.P
+Positional arguments are \fBname@version-range\fR identifiers, which will limit the results to only the paths to the packages named. Note that nested packages will \fIalso\fR show the paths to the specified packages. For example, running \fBnpm ls promzard\fR in npm's source tree will show:
+.P
+.RS 2
+.nf
+npm@11.13.0 /path/to/npm
+└─┬ init-package-json@0.0.4
+  └── promzard@0.1.5
+.fi
+.RE
+.P
+It will print out extraneous, missing, and invalid packages.
+.P
+If a project specifies git urls for dependencies these are shown in parentheses after the \fBname@version\fR to make it easier for users to recognize potential forks of a project.
+.P
+The tree shown is the logical dependency tree, based on package dependencies, not the physical layout of your \fBnode_modules\fR folder.
+.P
+When run as \fBll\fR or \fBla\fR, it shows extended information by default.
+.SS "Configuration"
+.SS "\fBall\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When running \fBnpm outdated\fR and \fBnpm ls\fR, setting \fB--all\fR will show all outdated or installed packages, rather than only those directly depended upon by the current project.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBdepth\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBInfinity\fR if \fB--all\fR is set; otherwise, \fB0\fR
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+The depth to go when recursing packages for \fBnpm ls\fR.
+.P
+If not set, \fBnpm ls\fR will show only the immediate dependencies of the root project. If \fB--all\fR is set, then npm will show all dependencies by default.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBlink\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Used with \fBnpm ls\fR, limiting output to only those packages that are linked.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBunicode\fR"
+.RS 0
+.IP \(bu 4
+Default: false on windows, true on mac/unix systems with a unicode locale, as defined by the \fBLC_ALL\fR, \fBLC_CTYPE\fR, or \fBLANG\fR environment variables.
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to true, npm uses unicode characters in the tree output. When false, it uses ascii characters instead of unicode glyphs.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help explain
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help explain
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help link
+.IP \(bu 4
+npm help prune
+.IP \(bu 4
+npm help outdated
+.IP \(bu 4
+npm help update
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-org.1 b/node/node_modules/npm/man/man1/npm-org.1
new file mode 100644
index 0000000000000000000000000000000000000000..4ef63daa1039d6876bde0155dea7aa969658e31c
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-org.1
@@ -0,0 +1,125 @@
+.TH "NPM-ORG" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-org\fR - Manage orgs
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm org set orgname username \[lB]developer | admin | owner\[rB]
+npm org rm orgname username
+npm org ls orgname \[lB]<username>\[rB]
+
+alias: ogr
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Example"
+.P
+Add a new developer to an org:
+.P
+.RS 2
+.nf
+$ npm org set my-org @mx-smith
+.fi
+.RE
+.P
+Add a new admin to an org (or change a developer to an admin):
+.P
+.RS 2
+.nf
+$ npm org set my-org @mx-santos admin
+.fi
+.RE
+.P
+Remove a user from an org:
+.P
+.RS 2
+.nf
+$ npm org rm my-org mx-santos
+.fi
+.RE
+.P
+List all users in an org:
+.P
+.RS 2
+.nf
+$ npm org ls my-org
+.fi
+.RE
+.P
+List all users in JSON format:
+.P
+.RS 2
+.nf
+$ npm org ls my-org --json
+.fi
+.RE
+.P
+See what role a user has in an org:
+.P
+.RS 2
+.nf
+$ npm org ls my-org @mx-santos
+.fi
+.RE
+.SS "Description"
+.P
+You can use the \fBnpm org\fR commands to manage and view users of an organization. It supports adding and removing users, changing their roles, listing them, and finding specific ones and their roles.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "using orgs"
+.IP \(bu 4
+\fBDocumentation on npm Orgs\fR \fI\(lahttps://docs.npmjs.com/orgs/\(ra\fR
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-outdated.1 b/node/node_modules/npm/man/man1/npm-outdated.1
new file mode 100644
index 0000000000000000000000000000000000000000..2164b1600826e085e1a5da9f4502afaf12cf61f0
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-outdated.1
@@ -0,0 +1,214 @@
+.TH "NPM-OUTDATED" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-outdated\fR - Check for outdated packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm outdated \[lB]<package-spec> ...\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This command will check the registry to see if any (or, specific) installed packages are currently outdated.
+.P
+By default, only the direct dependencies of the root project and direct dependencies of your configured \fIworkspaces\fR are shown. Use \fB--all\fR to find all outdated meta-dependencies as well.
+.P
+In the output:
+.RS 0
+.IP \(bu 4
+\fBwanted\fR is the maximum version of the package that satisfies the semver range specified in \fBpackage.json\fR. If there's no available semver range (i.e. you're running \fBnpm outdated --global\fR, or the package isn't included in \fBpackage.json\fR), then \fBwanted\fR shows the currently-installed version.
+.IP \(bu 4
+\fBlatest\fR is the version of the package tagged as latest in the registry. Running \fBnpm publish\fR with no special configuration will publish the package with a dist-tag of \fBlatest\fR. This may or may not be the maximum version of the package, or the most-recently published version of the package, depending on how the package's developer manages the latest npm help dist-tag.
+.IP \(bu 4
+\fBlocation\fR is where in the physical tree the package is located.
+.IP \(bu 4
+\fBdepended by\fR shows which package depends on the displayed dependency
+.IP \(bu 4
+\fBpackage type\fR (when using \fB--long\fR / \fB-l\fR) tells you whether this package is a \fBdependency\fR or a dev/peer/optional dependency. Packages not included in \fBpackage.json\fR are always marked \fBdependencies\fR.
+.IP \(bu 4
+\fBhomepage\fR (when using \fB--long\fR / \fB-l\fR) is the \fBhomepage\fR value contained in the package's packument
+.IP \(bu 4
+\fBdepended by location\fR (when using \fB--long\fR / \fB-l\fR) shows location of the package that depends on the displayed dependency
+.IP \(bu 4
+Red means there's a newer version matching your semver requirements, so you should update now.
+.IP \(bu 4
+Yellow indicates that there's a newer version \fIabove\fR your semver requirements (usually new major, or new 0.x minor) so proceed with caution.
+.RE 0
+
+.SS "An example"
+.P
+.RS 2
+.nf
+$ npm outdated
+Package      Current   Wanted   Latest  Location                  Depended by
+glob          5.0.15   5.0.15    6.0.1  node_modules/glob         dependent-package-name
+nothingness    0.0.3      git      git  node_modules/nothingness  dependent-package-name
+npm            3.5.1    3.5.2    3.5.1  node_modules/npm          dependent-package-name
+local-dev      0.0.3   linked   linked  local-dev                 dependent-package-name
+once           1.3.2    1.3.3    1.3.3  node_modules/once         dependent-package-name
+.fi
+.RE
+.P
+With these \fBdependencies\fR:
+.P
+.RS 2
+.nf
+{
+  "glob": "^5.0.15",
+  "nothingness": "github:othiym23/nothingness#master",
+  "npm": "^3.5.1",
+  "once": "^1.3.1"
+}
+.fi
+.RE
+.P
+A few things to note:
+.RS 0
+.IP \(bu 4
+\fBglob\fR requires \fB^5\fR, which prevents npm from installing \fBglob@6\fR, which is outside the semver range.
+.IP \(bu 4
+Git dependencies will always be reinstalled, because of how they're specified. The installed committish might satisfy the dependency specifier (if it's something immutable, like a commit SHA), or it might not, so \fBnpm outdated\fR and \fBnpm update\fR have to fetch Git repos to check. This is why currently doing a reinstall of a Git dependency always forces a new clone and install.
+.IP \(bu 4
+\fBnpm@3.5.2\fR is marked as "wanted", but "latest" is \fBnpm@3.5.1\fR because npm uses dist-tags to manage its \fBlatest\fR and \fBnext\fR release channels. \fBnpm update\fR will install the \fInewest\fR version, but \fBnpm install npm\fR (with no semver range) will install whatever's tagged as \fBlatest\fR.
+.IP \(bu 4
+\fBonce\fR is just plain out of date. Reinstalling \fBnode_modules\fR from scratch or running \fBnpm update\fR will bring it up to spec.
+.RE 0
+
+.SS "Configuration"
+.SS "\fBall\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When running \fBnpm outdated\fR and \fBnpm ls\fR, setting \fB--all\fR will show all outdated or installed packages, rather than only those directly depended upon by the current project.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBbefore\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Date
+.RE 0
+
+.P
+If passed to \fBnpm install\fR, will rebuild the npm tree such that only versions that were available \fBon or before\fR the given date are installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
+.P
+This config cannot be used with: \fBmin-release-age\fR
+.SS "\fBmin-release-age\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
+.P
+This config cannot be used with: \fBbefore\fR
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help update
+.IP \(bu 4
+npm help dist-tag
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-owner.1 b/node/node_modules/npm/man/man1/npm-owner.1
new file mode 100644
index 0000000000000000000000000000000000000000..309c91a8da862648b973bf36d0807bebe8c1eb27
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-owner.1
@@ -0,0 +1,110 @@
+.TH "NPM-OWNER" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-owner\fR - Manage package owners
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm owner add <user> <package-spec>
+npm owner rm <user> <package-spec>
+npm owner ls <package-spec>
+
+alias: author
+.fi
+.RE
+.SS "Description"
+.P
+Manage ownership of published packages.
+.RS 0
+.IP \(bu 4
+ls: List all the users who have access to modify a package and push new versions. Handy when you need to know who to bug for help.
+.IP \(bu 4
+add: Add a new user as a maintainer of a package. This user is enabled to modify metadata, publish new versions, and add other owners.
+.IP \(bu 4
+rm: Remove a user from the package owner list. This immediately revokes their privileges.
+.RE 0
+
+.P
+Note that there is only one level of access. Either you can modify a package, or you can't. Future versions may contain more fine-grained access levels, but that is not implemented at this time.
+.P
+If you have two-factor authentication enabled with \fBauth-and-writes\fR (see npm help npm-profile) then you'll need to go through a second factor flow when changing ownership or include an otp on the command line with \fB--otp\fR.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help profile
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help adduser
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-pack.1 b/node/node_modules/npm/man/man1/npm-pack.1
new file mode 100644
index 0000000000000000000000000000000000000000..982a383338fc8540c3987dacaec29194899fb6e9
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-pack.1
@@ -0,0 +1,142 @@
+.TH "NPM-PACK" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-pack\fR - Create a tarball from a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm pack <package-spec>
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBpack-destination\fR"
+.RS 0
+.IP \(bu 4
+Default: "."
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Directory in which \fBnpm pack\fR will save tarballs.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "Description"
+.P
+For anything that's installable (that is, a package folder, tarball, tarball url, git url, name@tag, name@version, name, or scoped name), this command will fetch it to the cache, copy the tarball to the current working directory as \fB<name>-<version>.tgz\fR, and then write the filenames out to stdout.
+.P
+If the same package is specified multiple times, then the file will be overwritten the second time.
+.P
+If no arguments are supplied, then npm packs the current package folder.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+\fBnpm-packlist package\fR \fI\(lahttp://npm.im/npm-packlist\(ra\fR
+.IP \(bu 4
+npm help cache
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-ping.1 b/node/node_modules/npm/man/man1/npm-ping.1
new file mode 100644
index 0000000000000000000000000000000000000000..4ab7346897c4ccdbe9372fdd0d2ede647f7b7b16
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-ping.1
@@ -0,0 +1,52 @@
+.TH "NPM-PING" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-ping\fR - Ping npm registry
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm ping
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Ping the configured or given npm registry and verify authentication. If it works it will output something like:
+.P
+.RS 2
+.nf
+npm notice PING https://registry.npmjs.org/
+npm notice PONG 255ms
+.fi
+.RE
+.P
+otherwise you will get an error:
+.P
+.RS 2
+.nf
+npm notice PING http://foo.com/
+npm ERR! code E404
+npm ERR! 404 Not Found - GET http://www.foo.com/-/ping?write=true
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help doctor
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-pkg.1 b/node/node_modules/npm/man/man1/npm-pkg.1
new file mode 100644
index 0000000000000000000000000000000000000000..6958f8d533eabd2b083e065633494c8c2f4f9c30
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-pkg.1
@@ -0,0 +1,286 @@
+.TH "NPM-PKG" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-pkg\fR - Manages your package.json
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm pkg set <key>=<value> \[lB]<key>=<value> ...\[rB]
+npm pkg get \[lB]<key> \[lB]<key> ...\[rB]\[rB]
+npm pkg delete <key> \[lB]<key> ...\[rB]
+npm pkg set \[lB]<array>\[lB]<index>\[rB].<key>=<value> ...\[rB]
+npm pkg set \[lB]<array>\[lB]\[rB].<key>=<value> ...\[rB]
+npm pkg fix
+.fi
+.RE
+.SS "Description"
+.P
+A command that automates the management of \fBpackage.json\fR files. \fBnpm pkg\fR provide 3 different sub commands that allow you to modify or retrieve values for given object keys in your \fBpackage.json\fR.
+.P
+The syntax to retrieve and set fields is a dot separated representation of the nested object properties to be found within your \fBpackage.json\fR, it's the same notation used in npm help view to retrieve information from the registry manifest, below you can find more examples on how to use it.
+.P
+Returned values are always in \fBjson\fR format.
+.RS 0
+.IP \(bu 4
+\fBnpm pkg get <field>\fR
+.P
+Retrieves a value \fBkey\fR, defined in your \fBpackage.json\fR file.
+.P
+For example, in order to retrieve the name of the current package, you can run:
+.P
+.RS 2
+.nf
+npm pkg get name
+.fi
+.RE
+.P
+It's also possible to retrieve multiple values at once:
+.P
+.RS 2
+.nf
+npm pkg get name version
+.fi
+.RE
+.P
+You can view child fields by separating them with a period. To retrieve the value of a test \fBscript\fR value, you would run the following command:
+.P
+.RS 2
+.nf
+npm pkg get scripts.test
+.fi
+.RE
+.P
+For fields that are arrays, requesting a non-numeric field will return all of the values from the objects in the list. For example, to get all the contributor emails for a package, you would run:
+.P
+.RS 2
+.nf
+npm pkg get contributors.email
+.fi
+.RE
+.P
+You may also use numeric indices in square braces to specifically select an item in an array field. To just get the email address of the first contributor in the list, you can run:
+.P
+.RS 2
+.nf
+npm pkg get contributors\[lB]0\[rB].email
+.fi
+.RE
+.P
+For complex fields you can also name a property in square brackets to specifically select a child field. This is especially helpful with the exports object:
+.P
+.RS 2
+.nf
+npm pkg get "exports\[lB].\[rB].require"
+.fi
+.RE
+.IP \(bu 4
+\fBnpm pkg set <field>=<value>\fR
+.P
+Sets a \fBvalue\fR in your \fBpackage.json\fR based on the \fBfield\fR value. When saving to your \fBpackage.json\fR file the same set of rules used during \fBnpm install\fR and other cli commands that touches the \fBpackage.json\fR file are used, making sure to respect the existing indentation and possibly applying some validation prior to saving values to the file.
+.P
+The same syntax used to retrieve values from your package can also be used to define new properties or overriding existing ones, below are some examples of how the dot separated syntax can be used to edit your \fBpackage.json\fR file.
+.P
+Defining a new bin named \fBmynewcommand\fR in your \fBpackage.json\fR that points to a file \fBcli.js\fR:
+.P
+.RS 2
+.nf
+npm pkg set bin.mynewcommand=cli.js
+.fi
+.RE
+.P
+Setting multiple fields at once is also possible:
+.P
+.RS 2
+.nf
+npm pkg set description='Awesome package' engines.node='>=10'
+.fi
+.RE
+.P
+It's also possible to add to array values, for example to add a new contributor entry:
+.P
+.RS 2
+.nf
+npm pkg set contributors\[lB]0\[rB].name='Foo' contributors\[lB]0\[rB].email='foo@bar.ca'
+.fi
+.RE
+.P
+You may also append items to the end of an array using the special empty bracket notation:
+.P
+.RS 2
+.nf
+npm pkg set contributors\[lB]\[rB].name='Foo' contributors\[lB]\[rB].name='Bar'
+.fi
+.RE
+.P
+It's also possible to parse values as json prior to saving them to your \fBpackage.json\fR file, for example in order to set a \fB"private": true\fR property:
+.P
+.RS 2
+.nf
+npm pkg set private=true --json
+.fi
+.RE
+.P
+It also enables saving values as numbers:
+.P
+.RS 2
+.nf
+npm pkg set tap.timeout=60 --json
+.fi
+.RE
+.IP \(bu 4
+\fBnpm pkg delete <key>\fR
+.P
+Deletes a \fBkey\fR from your \fBpackage.json\fR
+.P
+The same syntax used to set values from your package can also be used to remove existing ones. For example, in order to remove a script named build:
+.P
+.RS 2
+.nf
+npm pkg delete scripts.build
+.fi
+.RE
+.IP \(bu 4
+\fBnpm pkg fix\fR
+.P
+Auto corrects common errors in your \fBpackage.json\fR. npm already does this during \fBpublish\fR, which leads to subtle (mostly harmless) differences between the contents of your \fBpackage.json\fR file and the manifest that npm uses during installation.
+.RE 0
+
+.SS "Workspaces support"
+.P
+You can set/get/delete items across your configured workspaces by using the \fB\[rs]fBworkspace\[rs]fR\fR \fI\(la/using-npm/config#workspace\(ra\fR or \fB\[rs]fBworkspaces\[rs]fR\fR \fI\(la/using-npm/config#workspaces\(ra\fR config options.
+.P
+For example, setting a \fBfunding\fR value across all configured workspaces of a project:
+.P
+.RS 2
+.nf
+npm pkg set funding=https://example.com --ws
+.fi
+.RE
+.P
+When using \fBnpm pkg get\fR to retrieve info from your configured workspaces, the returned result will be in a json format in which top level keys are the names of each workspace, the values of these keys will be the result values returned from each of the configured workspaces, e.g:
+.P
+.RS 2
+.nf
+npm pkg get name version --ws
+{
+  "a": {
+    "name": "a",
+    "version": "1.0.0"
+  },
+  "b": {
+    "name": "b",
+    "version": "1.0.0"
+  }
+}
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBforce\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Removes various protections against unfortunate side effects, common mistakes, unnecessary performance degradation, and malicious input.
+.RS 0
+.IP \(bu 4
+Allow clobbering non-npm files in global installs.
+.IP \(bu 4
+Allow the \fBnpm version\fR command to work on an unclean git repository.
+.IP \(bu 4
+Allow deleting the cache folder with \fBnpm cache clean\fR.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of npm.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of \fBnode\fR, even if \fB--engine-strict\fR is enabled.
+.IP \(bu 4
+Allow \fBnpm audit fix\fR to install modules outside your stated dependency range (including SemVer-major changes).
+.IP \(bu 4
+Allow unpublishing all versions of a published package.
+.IP \(bu 4
+Allow conflicting peerDependencies to be installed in the root project.
+.IP \(bu 4
+Implicitly set \fB--yes\fR during \fBnpm init\fR.
+.IP \(bu 4
+Allow clobbering existing values in \fBnpm pkg\fR
+.IP \(bu 4
+Allow unpublishing of entire packages (not just a single version).
+.RE 0
+
+.P
+If you don't have a clear idea of what you want to do, it is strongly recommended that you do not use this option!
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SH "SEE ALSO"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help init
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-prefix.1 b/node/node_modules/npm/man/man1/npm-prefix.1
new file mode 100644
index 0000000000000000000000000000000000000000..e38b6b5a7a939c88eecf84c3bfec11536b6251d9
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-prefix.1
@@ -0,0 +1,63 @@
+.TH "NPM-PREFIX" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-prefix\fR - Display prefix
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm prefix
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Print the local prefix to standard output. This is the closest parent directory to contain a \fBpackage.json\fR file or \fBnode_modules\fR directory, unless \fB-g\fR is also specified.
+.P
+If \fB-g\fR is specified, this will be the value of the global prefix. See npm help config for more detail.
+.SS "Example"
+.P
+.RS 2
+.nf
+npm prefix
+/usr/local/projects/foo
+.fi
+.RE
+.P
+.RS 2
+.nf
+npm prefix -g
+/usr/local
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help root
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-profile.1 b/node/node_modules/npm/man/man1/npm-profile.1
new file mode 100644
index 0000000000000000000000000000000000000000..64480d5ecf7b68a48872d68fe92605ca008caa7a
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-profile.1
@@ -0,0 +1,126 @@
+.TH "NPM-PROFILE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-profile\fR - Change settings on your registry profile
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm profile enable-2fa \[lB]auth-only|auth-and-writes\[rB]
+npm profile disable-2fa
+npm profile get \[lB]<key>\[rB]
+npm profile set <key> <value>
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Change your profile information on the registry. Note that this command depends on the registry implementation, so third-party registries may not support this interface.
+.RS 0
+.IP \(bu 4
+\fBnpm profile get \[lB]<property>\[rB]\fR: Display all of the properties of your profile, or one or more specific properties. It looks like:
+.RE 0
+
+.P
+.RS 2
+.nf
+name: example
+email: e@example.com (verified)
+two-factor auth: auth-and-writes
+fullname: Example User
+homepage:
+freenode:
+twitter:
+github:
+created: 2015-02-26T01:38:35.892Z
+updated: 2017-10-02T21:29:45.922Z
+.fi
+.RE
+.RS 0
+.IP \(bu 4
+\fBnpm profile set <property> <value>\fR: Set the value of a profile property. You can set the following properties this way: email, fullname, homepage, freenode, twitter, github
+.IP \(bu 4
+\fBnpm profile set password\fR: Change your password. This is interactive, you'll be prompted for your current password and a new password. You'll also be prompted for an OTP if you have two-factor authentication enabled.
+.IP \(bu 4
+\fBnpm profile enable-2fa \[lB]auth-and-writes|auth-only\[rB]\fR: Enables two-factor authentication. Defaults to \fBauth-and-writes\fR mode. Modes are:
+.RS 4
+.IP \(bu 4
+\fBauth-only\fR: Require an OTP when logging in or making changes to your account's authentication. The OTP will be required on both the website and the command line.
+.IP \(bu 4
+\fBauth-and-writes\fR: Requires an OTP at all the times \fBauth-only\fR does, and also requires one when publishing a module, setting the \fBlatest\fR dist-tag, or changing access via \fBnpm access\fR and \fBnpm owner\fR.
+.RE 0
+
+.IP \(bu 4
+\fBnpm profile disable-2fa\fR: Disables two-factor authentication.
+.RE 0
+
+.SS "Details"
+.P
+Some of these commands may not be available on non npmjs.com registries.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help adduser
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help token
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-prune.1 b/node/node_modules/npm/man/man1/npm-prune.1
new file mode 100644
index 0000000000000000000000000000000000000000..9e84cf40d80629caa92b7694ef9d8f60d9f2258d
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-prune.1
@@ -0,0 +1,184 @@
+.TH "NPM-PRUNE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-prune\fR - Remove extraneous packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm prune \[lB]\[lB]<@scope>/\[rB]<pkg>...\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This command removes "extraneous" packages. If a package name is provided, then only packages matching one of the supplied names are removed.
+.P
+Extraneous packages are those present in the \fBnode_modules\fR folder that are not listed as any package's dependency list.
+.P
+If the \fB--omit=dev\fR flag is specified or the \fBNODE_ENV\fR environment variable is set to \fBproduction\fR, this command will remove the packages specified in your \fBdevDependencies\fR.
+.P
+If the \fB--dry-run\fR flag is used then no changes will actually be made.
+.P
+If the \fB--json\fR flag is used, then the changes \fBnpm prune\fR made (or would have made with \fB--dry-run\fR) are printed as a JSON object.
+.P
+In normal operation, extraneous modules are pruned automatically, so you'll only need this command with the \fB--production\fR flag. However, in the real world, operation is not always "normal". When crashes or mistakes happen, this command can help clean up any resulting garbage.
+.SS "Configuration"
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help uninstall
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help ls
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-publish.1 b/node/node_modules/npm/man/man1/npm-publish.1
new file mode 100644
index 0000000000000000000000000000000000000000..127635ee53ed33da4005027ab725a0c0c282223f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-publish.1
@@ -0,0 +1,261 @@
+.TH "NPM-PUBLISH" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-publish\fR - Publish a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm publish <package-spec>
+.fi
+.RE
+.SS "Description"
+.P
+Publishes a package to the registry so that it can be installed by name.
+.SS "Examples"
+.P
+Publish the package in the current directory:
+.P
+.RS 2
+.nf
+npm publish
+.fi
+.RE
+.P
+Publish a specific workspace:
+.P
+.RS 2
+.nf
+npm publish --workspace=<workspace-name>
+.fi
+.RE
+.P
+Publish multiple workspaces:
+.P
+.RS 2
+.nf
+npm publish --workspace=workspace-a --workspace=workspace-b
+.fi
+.RE
+.P
+Publish all workspaces:
+.P
+.RS 2
+.nf
+npm publish --workspaces
+.fi
+.RE
+.P
+By default npm will publish to the public registry. This can be overridden by specifying a different default registry or using a npm help scope in the name, combined with a scope-configured registry (see \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR).
+.P
+A \fBpackage\fR is interpreted the same way as other commands (like \fBnpm install\fR) and can be:
+.RS 0
+.IP \(bu 4
+a) a folder containing a program described by a \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR file
+.IP \(bu 4
+b) a gzipped tarball containing (a)
+.IP \(bu 4
+c) a url that resolves to (b)
+.IP \(bu 4
+d) a \fB<name>@<version>\fR that is published on the registry (see npm help registry) with (c)
+.IP \(bu 4
+e) a \fB<name>@<tag>\fR (see npm help dist-tag) that points to (d)
+.IP \(bu 4
+f) a \fB<name>\fR that has a "latest" tag satisfying (e)
+.IP \(bu 4
+g) a \fB<git remote url>\fR that resolves to (a)
+.RE 0
+
+.P
+If either (a) or (b) is specified as a relative path, it should begin with an explicit \fB./\fR prefix.
+.P
+The publish will fail if the package name and version combination already exists in the specified registry.
+.P
+Once a package is published with a given name and version, that specific name and version combination can never be used again, even if it is removed with npm help unpublish.
+.P
+As of \fBnpm@5\fR, both a sha1sum and an integrity field with a sha512sum of the tarball will be submitted to the registry during publication. Subsequent installs will use the strongest supported algorithm to verify downloads.
+.P
+Similar to \fB--dry-run\fR see npm help pack, which figures out the files to be included and packs them into a tarball to be uploaded to the registry.
+.SS "Files included in package"
+.P
+To see what will be included in your package, run \fBnpm pack --dry-run\fR. All files are included by default, with the following exceptions:
+.RS 0
+.IP \(bu 4
+Certain files that are relevant to package installation and distribution are always included. For example, \fBpackage.json\fR, \fBREADME.md\fR, \fBLICENSE\fR, and so on.
+.IP \(bu 4
+If there is a "files" list in \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR, then only the files specified will be included. (If directories are specified, then they will be walked recursively and their contents included, subject to the same ignore rules.)
+.IP \(bu 4
+If there is a \fB.gitignore\fR or \fB.npmignore\fR file, then ignored files in that and all child directories will be excluded from the package. If \fIboth\fR files exist, then the \fB.gitignore\fR is ignored, and only the \fB.npmignore\fR is used.
+.P
+\fB.npmignore\fR files follow the \fBsame pattern rules\fR \fI\(lahttps://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring\(ra\fR as \fB.gitignore\fR files
+.IP \(bu 4
+If the file matches certain patterns, then it will \fInever\fR be included, unless explicitly added to the \fB"files"\fR list in \fBpackage.json\fR, or un-ignored with a \fB!\fR rule in a \fB.npmignore\fR or \fB.gitignore\fR file.
+.IP \(bu 4
+Symbolic links are never included in npm packages.
+.RE 0
+
+.P
+See npm help developers for full details on what's included in the published package, as well as details on how the package is built.
+.P
+See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more info on what can and can't be ignored.
+.SS "Configuration"
+.SS "\fBtag\fR"
+.RS 0
+.IP \(bu 4
+Default: "latest"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+If you ask npm to install a package and don't tell it a specific version, then it will install the specified tag.
+.P
+It is the tag added to the package@version specified in the \fBnpm dist-tag
+add\fR command, if no explicit tag is given.
+.P
+When used by the \fBnpm diff\fR command, this is the tag used to fetch the tarball that will be compared with the local files by default.
+.P
+If used in the \fBnpm publish\fR command, this is the tag that will be added to the package submitted to the registry.
+.SS "\fBaccess\fR"
+.RS 0
+.IP \(bu 4
+Default: 'public' for new packages, existing packages it will not change the current level
+.IP \(bu 4
+Type: null, "restricted", or "public"
+.RE 0
+
+.P
+If you do not want your scoped package to be publicly viewable (and installable) set \fB--access=restricted\fR.
+.P
+Unscoped packages cannot be set to \fBrestricted\fR.
+.P
+Note: This defaults to not changing the current access level for existing packages. Specifying a value of \fBrestricted\fR or \fBpublic\fR during publish will change the access for an existing package the same way that \fBnpm access set
+status\fR would.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBprovenance\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When publishing from a supported cloud CI/CD system, the package will be publicly linked to where it was built and published from.
+.P
+This config cannot be used with: \fBprovenance-file\fR
+.SS "\fBprovenance-file\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+When publishing, the provenance bundle at the given path will be used.
+.P
+This config cannot be used with: \fBprovenance\fR
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+\fBnpm-packlist package\fR \fI\(lahttp://npm.im/npm-packlist\(ra\fR
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help scope
+.IP \(bu 4
+npm help adduser
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help deprecate
+.IP \(bu 4
+npm help dist-tag
+.IP \(bu 4
+npm help pack
+.IP \(bu 4
+npm help profile
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-query.1 b/node/node_modules/npm/man/man1/npm-query.1
new file mode 100644
index 0000000000000000000000000000000000000000..23e150803bb48c3605e2b1b14e09c13ab9fa6c6d
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-query.1
@@ -0,0 +1,281 @@
+.TH "NPM-QUERY" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-query\fR - Dependency selector query
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm query <selector>
+.fi
+.RE
+.SS "Description"
+.P
+The \fBnpm query\fR command allows for usage of css selectors in order to retrieve an array of dependency objects.
+.SS "Piping npm query to other commands"
+.P
+.RS 2
+.nf
+# find all dependencies with postinstall scripts & uninstall them
+npm query ":attr(scripts, \[lB]postinstall\[rB])" | jq 'map(.name)|join("\[rs]n")' -r | xargs -I {} npm uninstall {}
+
+# find all git dependencies & explain who requires them
+npm query ":type(git)" | jq 'map(.name)' | xargs -I {} npm why {}
+.fi
+.RE
+.SS "Extended Use Cases & Queries"
+.P
+.RS 2
+.nf
+// all deps
+*
+
+// all direct deps
+:root > *
+
+// direct production deps
+:root > .prod
+
+// direct development deps
+:root > .dev
+
+// any peer dep of a direct deps
+:root > * > .peer
+
+// any workspace dep
+.workspace
+
+// all workspaces that depend on another workspace
+.workspace > .workspace
+
+// all workspaces that have peer deps
+.workspace:has(.peer)
+
+// any dep named "lodash"
+// equivalent to \[lB]name="lodash"\[rB]
+#lodash
+
+// any deps named "lodash" & within semver range ^"1.2.3"
+#lodash@^1.2.3
+// equivalent to...
+\[lB]name="lodash"\[rB]:semver(^1.2.3)
+
+// get the hoisted node for a given semver range
+#lodash@^1.2.3:not(:deduped)
+
+// querying deps with a specific version
+#lodash@2.1.5
+// equivalent to...
+\[lB]name="lodash"\[rB]\[lB]version="2.1.5"\[rB]
+
+// has any deps
+:has(*)
+
+// deps with no other deps (ie. "leaf" nodes)
+:empty
+
+// manually querying git dependencies
+\[lB]repository^=github:\[rB],
+\[lB]repository^=git:\[rB],
+\[lB]repository^=https://github.com\[rB],
+\[lB]repository^=http://github.com\[rB],
+\[lB]repository^=https://github.com\[rB],
+\[lB]repository^=+git:...\[rB]
+
+// querying for all git dependencies
+:type(git)
+
+// get production dependencies that aren't also dev deps
+.prod:not(.dev)
+
+// get dependencies with specific licenses
+\[lB]license=MIT\[rB], \[lB]license=ISC\[rB]
+
+// find all packages that have @ruyadorno as a contributor
+:attr(contributors, \[lB]email=ruyadorno@github.com\[rB])
+.fi
+.RE
+.SS "Example Response Output"
+.RS 0
+.IP \(bu 4
+an array of dependency objects is returned which can contain multiple copies of the same package which may or may not have been linked or deduped
+.RE 0
+
+.P
+.RS 2
+.nf
+\[lB]
+  {
+    "name": "",
+    "version": "",
+    "description": "",
+    "homepage": "",
+    "bugs": {},
+    "author": {},
+    "license": {},
+    "funding": {},
+    "files": \[lB]\[rB],
+    "main": "",
+    "browser": "",
+    "bin": {},
+    "man": \[lB]\[rB],
+    "directories": {},
+    "repository": {},
+    "scripts": {},
+    "config": {},
+    "dependencies": {},
+    "devDependencies": {},
+    "optionalDependencies": {},
+    "bundledDependencies": {},
+    "peerDependencies": {},
+    "peerDependenciesMeta": {},
+    "engines": {},
+    "os": \[lB]\[rB],
+    "cpu": \[lB]\[rB],
+    "workspaces": {},
+    "keywords": \[lB]\[rB],
+    ...
+  },
+  ...
+.fi
+.RE
+.SS "Expecting a certain number of results"
+.P
+One common use of \fBnpm query\fR is to make sure there is only one version of a certain dependency in your tree. This is especially common for ecosystems like that rely on \fBtypescript\fR where having state split across two different but identically-named packages causes bugs. You can use the \fB--expect-results\fR or \fB--expect-result-count\fR in your setup to ensure that npm will exit with an exit code if your tree doesn't look like you want it to.
+.P
+.RS 2
+.nf
+$ npm query '#react' --expect-result-count=1
+.fi
+.RE
+.P
+Perhaps you want to quickly check if there are any production dependencies that could be updated:
+.P
+.RS 2
+.nf
+$ npm query ':root>:outdated(in-range).prod' --no-expect-results
+.fi
+.RE
+.SS "Package lock only mode"
+.P
+If package-lock-only is enabled, only the information in the package lock (or shrinkwrap) is loaded. This means that information from the package.json files of your dependencies will not be included in the result set (e.g. description, homepage, engines).
+.SS "Configuration"
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBexpect-results\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Tells npm whether or not to expect results from the command. Can be either true (expect some results) or false (expect no results).
+.P
+This config cannot be used with: \fBexpect-result-count\fR
+.SS "\fBexpect-result-count\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+Tells to expect a specific number of results from the command.
+.P
+This config cannot be used with: \fBexpect-results\fR
+.SH "SEE ALSO"
+.RS 0
+.IP \(bu 4
+npm help "dependency selectors"
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-rebuild.1 b/node/node_modules/npm/man/man1/npm-rebuild.1
new file mode 100644
index 0000000000000000000000000000000000000000..42282008f087e5e7cc5a1fc2771147bc05468276
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-rebuild.1
@@ -0,0 +1,178 @@
+.TH "NPM-REBUILD" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-rebuild\fR - Rebuild a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm rebuild \[lB]<package-spec>\[rB] ...\[rB]
+
+alias: rb
+.fi
+.RE
+.SS "Description"
+.P
+This command does the following:
+.RS 0
+.IP 1. 4
+Execute lifecycle scripts (\fBpreinstall\fR, \fBinstall\fR, \fBpostinstall\fR, \fBprepare\fR)
+.IP 2. 4
+Links bins depending on whether bin links are enabled
+.RE 0
+
+.P
+This command is particularly useful in scenarios including but not limited to:
+.RS 0
+.IP 1. 4
+Installing a new version of \fBnode.js\fR, where you need to recompile all your C++ add-ons with the updated binary.
+.IP 2. 4
+Installing with \fB--ignore-scripts\fR and \fB--no-bin-links\fR, to explicitly choose which packages to build and/or link bins.
+.RE 0
+
+.P
+If one or more package specs are provided, then only packages with a name and version matching one of the specifiers will be rebuilt.
+.P
+Usually, you should not need to run \fBnpm rebuild\fR as it is already done for you as part of npm install (unless you suppressed these steps with \fB--ignore-scripts\fR or \fB--no-bin-links\fR).
+.P
+If there is a \fBbinding.gyp\fR file in the root of your package, then npm will use a default install hook:
+.P
+.RS 2
+.nf
+"scripts": {
+    "install": "node-gyp rebuild"
+}
+.fi
+.RE
+.P
+This default behavior is suppressed if the \fBpackage.json\fR has its own \fBinstall\fR or \fBpreinstall\fR scripts. It is also suppressed if the package specifies \fB"gypfile": false\fR
+.SS "Configuration"
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-repo.1 b/node/node_modules/npm/man/man1/npm-repo.1
new file mode 100644
index 0000000000000000000000000000000000000000..12a1b97ec19f3986e6fa98dcb06fe7361050541f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-repo.1
@@ -0,0 +1,103 @@
+.TH "NPM-REPO" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-repo\fR - Open package repository page in the browser
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm repo \[lB]<pkgname> \[lB]<pkgname> ...\[rB]\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This command tries to guess at the likely location of a package's repository URL, and then tries to open it using the \fB\[rs]fB--browser\[rs]fR config\fR \fI\(la/using-npm/config#browser\(ra\fR param. If no package name is provided, it will search for a \fBpackage.json\fR in the current folder and use the \fBrepository\fR property.
+.SS "Configuration"
+.SS "\fBbrowser\fR"
+.RS 0
+.IP \(bu 4
+Default: macOS: \fB"open"\fR, Windows: \fB"start"\fR, Others: \fB"xdg-open"\fR
+.IP \(bu 4
+Type: null, Boolean, or String
+.RE 0
+
+.P
+The browser that is called by npm commands to open websites.
+.P
+Set to \fBfalse\fR to suppress browser behavior and instead print urls to terminal.
+.P
+Set to \fBtrue\fR to use default system URL opener.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help docs
+.IP \(bu 4
+npm help config
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-restart.1 b/node/node_modules/npm/man/man1/npm-restart.1
new file mode 100644
index 0000000000000000000000000000000000000000..399a97fc82945dc32187bebec6c4a114f5496229
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-restart.1
@@ -0,0 +1,84 @@
+.TH "NPM-RESTART" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-restart\fR - Restart a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm restart \[lB]-- <args>\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This restarts a project. It is equivalent to running \fBnpm run restart\fR.
+.P
+If the current project has a \fB"restart"\fR script specified in \fBpackage.json\fR, then the following scripts will be run:
+.RS 0
+.IP 1. 4
+prerestart
+.IP 2. 4
+restart
+.IP 3. 4
+postrestart
+.RE 0
+
+.P
+If it does \fInot\fR have a \fB"restart"\fR script specified, but it does have \fBstop\fR and/or \fBstart\fR scripts, then the following scripts will be run:
+.RS 0
+.IP 1. 4
+prerestart
+.IP 2. 4
+prestop
+.IP 3. 4
+stop
+.IP 4. 4
+poststop
+.IP 5. 4
+prestart
+.IP 6. 4
+start
+.IP 7. 4
+poststart
+.IP 8. 4
+postrestart
+.RE 0
+
+.SS "Configuration"
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBscript-shell\fR"
+.RS 0
+.IP \(bu 4
+Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+The shell to use for scripts run with the \fBnpm exec\fR, \fBnpm run\fR and \fBnpm
+init <package-spec>\fR commands.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help test
+.IP \(bu 4
+npm help start
+.IP \(bu 4
+npm help stop
+.IP \(bu 4
+npm help restart
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-root.1 b/node/node_modules/npm/man/man1/npm-root.1
new file mode 100644
index 0000000000000000000000000000000000000000..25d821a74b6204f33f6ee5086d4756ebb37f0a9f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-root.1
@@ -0,0 +1,56 @@
+.TH "NPM-ROOT" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-root\fR - Display npm root
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm root
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Print the effective \fBnode_modules\fR folder to standard out.
+.P
+Useful for using npm in shell scripts that do things with the \fBnode_modules\fR folder. For example:
+.P
+.RS 2
+.nf
+#!/bin/bash
+global_node_modules="$(npm root --global)"
+echo "Global packages installed in: ${global_node_modules}"
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help prefix
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-run.1 b/node/node_modules/npm/man/man1/npm-run.1
new file mode 100644
index 0000000000000000000000000000000000000000..c198144f29553371f5c17ed8bd7d4f853605eec6
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-run.1
@@ -0,0 +1,234 @@
+.TH "NPM-RUN" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-run\fR - Run arbitrary package scripts
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm run <command> \[lB]-- <args>\[rB]
+
+aliases: run-script, rum, urn
+.fi
+.RE
+.SS "Description"
+.P
+This runs an arbitrary command from a package's \fB"scripts"\fR object. If no \fB"command"\fR is provided, it will list the available scripts.
+.P
+\fBrun\[lB]-script\[rB]\fR is used by the test, start, restart, and stop commands, but can be called directly, as well. When the scripts in the package are printed out, they're separated into lifecycle (test, start, restart) and directly-run scripts.
+.P
+Any positional arguments are passed to the specified script. Use \fB--\fR to pass \fB-\fR-prefixed flags and options which would otherwise be parsed by npm.
+.P
+For example:
+.P
+.RS 2
+.nf
+npm run test -- --grep="pattern"
+.fi
+.RE
+.P
+The arguments will only be passed to the script specified after \fBnpm run\fR and not to any \fBpre\fR or \fBpost\fR script.
+.P
+The \fBenv\fR script is a special built-in command that can be used to list environment variables that will be available to the script at runtime. If an "env" command is defined in your package, it will take precedence over the built-in.
+.P
+In addition to the shell's pre-existing \fBPATH\fR, \fBnpm run\fR adds \fBnode_modules/.bin\fR to the \fBPATH\fR provided to scripts. Any binaries provided by locally-installed dependencies can be used without the \fBnode_modules/.bin\fR prefix. For example, if there is a \fBdevDependency\fR on \fBtap\fR in your package, you should write:
+.P
+.RS 2
+.nf
+"scripts": {"test": "tap test/*.js"}
+.fi
+.RE
+.P
+instead of
+.P
+.RS 2
+.nf
+"scripts": {"test": "node_modules/.bin/tap test/*.js"}
+.fi
+.RE
+.P
+The actual shell your script is run within is platform dependent. By default, on Unix-like systems it is the \fB/bin/sh\fR command, on Windows it is \fBcmd.exe\fR. The actual shell referred to by \fB/bin/sh\fR also depends on the system. You can customize the shell with the \fB\[rs]fBscript-shell\[rs]fR config\fR \fI\(la/using-npm/config#script-shell\(ra\fR.
+.P
+Scripts are run from the root of the package folder, regardless of what the current working directory is when \fBnpm run\fR is called. If you want your script to use different behavior based on what subdirectory you're in, you can use the \fBINIT_CWD\fR environment variable, which holds the full path you were in when you ran \fBnpm run\fR.
+.P
+\fBnpm run\fR sets the \fBNODE\fR environment variable to the \fBnode\fR executable with which \fBnpm\fR is executed.
+.P
+If you try to run a script without having a \fBnode_modules\fR directory and it fails, you will be given a warning to run \fBnpm install\fR, just in case you've forgotten.
+.SS "Workspaces support"
+.P
+You may use the \fB\[rs]fBworkspace\[rs]fR\fR \fI\(la/using-npm/config#workspace\(ra\fR or \fB\[rs]fBworkspaces\[rs]fR\fR \fI\(la/using-npm/config#workspaces\(ra\fR configs in order to run an arbitrary command from a package's \fB"scripts"\fR object in the context of the specified workspaces. If no \fB"command"\fR is provided, it will list the available scripts for each of these configured workspaces.
+.P
+Given a project with configured workspaces, e.g:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   +-- b
+   |   `-- package.json
+   `-- c
+       `-- package.json
+.fi
+.RE
+.P
+Assuming the workspace configuration is properly set up at the root level \fBpackage.json\fR file. e.g:
+.P
+.RS 2
+.nf
+{
+    "workspaces": \[lB] "./packages/*" \[rB]
+}
+.fi
+.RE
+.P
+And that each of the configured workspaces has a configured \fBtest\fR script, we can run tests in all of them using the \fB\[rs]fBworkspaces\[rs]fR config\fR \fI\(la/using-npm/config#workspaces\(ra\fR:
+.P
+.RS 2
+.nf
+npm test --workspaces
+.fi
+.RE
+.SS "Filtering workspaces"
+.P
+It's also possible to run a script in a single workspace using the \fBworkspace\fR config along with a name or directory path:
+.P
+.RS 2
+.nf
+npm test --workspace=a
+.fi
+.RE
+.P
+The \fBworkspace\fR config can also be specified multiple times in order to run a specific script in the context of multiple workspaces. When defining values for the \fBworkspace\fR config in the command line, it also possible to use \fB-w\fR as a shorthand, e.g:
+.P
+.RS 2
+.nf
+npm test -w a -w b
+.fi
+.RE
+.P
+This last command will run \fBtest\fR in both \fB./packages/a\fR and \fB./packages/b\fR packages.
+.SS "Configuration"
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBif-present\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm will not exit with an error code when \fBrun\fR is invoked for a script that isn't defined in the \fBscripts\fR section of \fBpackage.json\fR. This option can be used when it's desirable to optionally run a script when it's present and fail if the script fails. This is useful, for example, when running scripts that may only apply for some builds in an otherwise generic CI setup.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBscript-shell\fR"
+.RS 0
+.IP \(bu 4
+Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+The shell to use for scripts run with the \fBnpm exec\fR, \fBnpm run\fR and \fBnpm
+init <package-spec>\fR commands.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help test
+.IP \(bu 4
+npm help start
+.IP \(bu 4
+npm help restart
+.IP \(bu 4
+npm help stop
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-sbom.1 b/node/node_modules/npm/man/man1/npm-sbom.1
new file mode 100644
index 0000000000000000000000000000000000000000..135242b2f1ee54379bee8e445c2a6c42f1fc13b8
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-sbom.1
@@ -0,0 +1,314 @@
+.TH "NPM-SBOM" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-sbom\fR - Generate a Software Bill of Materials (SBOM)
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm sbom
+.fi
+.RE
+.SS "Description"
+.P
+The \fBnpm sbom\fR command generates a Software Bill of Materials (SBOM) listing the dependencies for the current project. SBOMs can be generated in either \fBSPDX\fR \fI\(lahttps://spdx.dev/\(ra\fR or \fBCycloneDX\fR \fI\(lahttps://cyclonedx.org/\(ra\fR format.
+.SS "Example CycloneDX SBOM"
+.P
+.RS 2
+.nf
+{
+  "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "serialNumber": "urn:uuid:09f55116-97e1-49cf-b3b8-44d0207e7730",
+  "version": 1,
+  "metadata": {
+    "timestamp": "2023-09-01T00:00:00.001Z",
+    "lifecycles": \[lB]
+      {
+        "phase": "build"
+      }
+    \[rB],
+    "tools": \[lB]
+      {
+        "vendor": "npm",
+        "name": "cli",
+        "version": "10.1.0"
+      }
+    \[rB],
+    "component": {
+      "bom-ref": "simple@1.0.0",
+      "type": "library",
+      "name": "simple",
+      "version": "1.0.0",
+      "scope": "required",
+      "author": "John Doe",
+      "description": "simple react app",
+      "purl": "pkg:npm/simple@1.0.0",
+      "properties": \[lB]
+        {
+          "name": "cdx:npm:package:path",
+          "value": ""
+        }
+      \[rB],
+      "externalReferences": \[lB]\[rB],
+      "licenses": \[lB]
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      \[rB]
+    }
+  },
+  "components": \[lB]
+    {
+      "bom-ref": "lodash@4.17.21",
+      "type": "library",
+      "name": "lodash",
+      "version": "4.17.21",
+      "scope": "required",
+      "author": "John-David Dalton",
+      "description": "Lodash modular utilities.",
+      "purl": "pkg:npm/lodash@4.17.21",
+      "properties": \[lB]
+        {
+          "name": "cdx:npm:package:path",
+          "value": "node_modules/lodash"
+        }
+      \[rB],
+      "externalReferences": \[lB]
+        {
+          "type": "distribution",
+          "url": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
+        },
+        {
+          "type": "vcs",
+          "url": "git+https://github.com/lodash/lodash.git"
+        },
+        {
+          "type": "website",
+          "url": "https://lodash.com/"
+        },
+        {
+          "type": "issue-tracker",
+          "url": "https://github.com/lodash/lodash/issues"
+        }
+      \[rB],
+      "hashes": \[lB]
+        {
+          "alg": "SHA-512",
+          "content": "bf690311ee7b95e713ba568322e3533f2dd1cb880b189e99d4edef13592b81764daec43e2c54c61d5c558dc5cfb35ecb85b65519e74026ff17675b6f8f916f4a"
+        }
+      \[rB],
+      "licenses": \[lB]
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      \[rB]
+    }
+  \[rB],
+  "dependencies": \[lB]
+    {
+      "ref": "simple@1.0.0",
+      "dependsOn": \[lB]
+        "lodash@4.17.21"
+      \[rB]
+    },
+    {
+      "ref": "lodash@4.17.21",
+      "dependsOn": \[lB]\[rB]
+    }
+  \[rB]
+}
+.fi
+.RE
+.SS "Example SPDX SBOM"
+.P
+.RS 2
+.nf
+{
+  "spdxVersion": "SPDX-2.3",
+  "dataLicense": "CC0-1.0",
+  "SPDXID": "SPDXRef-DOCUMENT",
+  "name": "simple@1.0.0",
+  "documentNamespace": "http://spdx.org/spdxdocs/simple-1.0.0-bf81090e-8bbc-459d-bec9-abeb794e096a",
+  "creationInfo": {
+    "created": "2023-09-01T00:00:00.001Z",
+    "creators": \[lB]
+      "Tool: npm/cli-10.1.0"
+    \[rB]
+  },
+  "documentDescribes": \[lB]
+    "SPDXRef-Package-simple-1.0.0"
+  \[rB],
+  "packages": \[lB]
+    {
+      "name": "simple",
+      "SPDXID": "SPDXRef-Package-simple-1.0.0",
+      "versionInfo": "1.0.0",
+      "packageFileName": "",
+      "description": "simple react app",
+      "primaryPackagePurpose": "LIBRARY",
+      "downloadLocation": "NOASSERTION",
+      "filesAnalyzed": false,
+      "homepage": "NOASSERTION",
+      "licenseDeclared": "MIT",
+      "externalRefs": \[lB]
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/simple@1.0.0"
+        }
+      \[rB]
+    },
+    {
+      "name": "lodash",
+      "SPDXID": "SPDXRef-Package-lodash-4.17.21",
+      "versionInfo": "4.17.21",
+      "packageFileName": "node_modules/lodash",
+      "description": "Lodash modular utilities.",
+      "downloadLocation": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "filesAnalyzed": false,
+      "homepage": "https://lodash.com/",
+      "licenseDeclared": "MIT",
+      "externalRefs": \[lB]
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/lodash@4.17.21"
+        }
+      \[rB],
+      "checksums": \[lB]
+        {
+          "algorithm": "SHA512",
+          "checksumValue": "bf690311ee7b95e713ba568322e3533f2dd1cb880b189e99d4edef13592b81764daec43e2c54c61d5c558dc5cfb35ecb85b65519e74026ff17675b6f8f916f4a"
+        }
+      \[rB]
+    }
+  \[rB],
+  "relationships": \[lB]
+    {
+      "spdxElementId": "SPDXRef-DOCUMENT",
+      "relatedSpdxElement": "SPDXRef-Package-simple-1.0.0",
+      "relationshipType": "DESCRIBES"
+    },
+    {
+      "spdxElementId": "SPDXRef-Package-simple-1.0.0",
+      "relatedSpdxElement": "SPDXRef-Package-lodash-4.17.21",
+      "relationshipType": "DEPENDS_ON"
+    }
+  \[rB]
+}
+.fi
+.RE
+.SS "Package lock only mode"
+.P
+If package-lock-only is enabled, only the information in the package lock (or shrinkwrap) is loaded. This means that information from the package.json files of your dependencies will not be included in the result set (e.g. description, homepage, engines).
+.SS "Configuration"
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBsbom-format\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: "cyclonedx" or "spdx"
+.RE 0
+
+.P
+SBOM format to use when generating SBOMs.
+.SS "\fBsbom-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "library"
+.IP \(bu 4
+Type: "library", "application", or "framework"
+.RE 0
+
+.P
+The type of package described by the generated SBOM. For SPDX, this is the value for the \fBprimaryPackagePurpose\fR field. For CycloneDX, this is the value for the \fBtype\fR field.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SH "SEE ALSO"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help "dependency selectors"
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help workspaces
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-search.1 b/node/node_modules/npm/man/man1/npm-search.1
new file mode 100644
index 0000000000000000000000000000000000000000..036b286306347d0431f9643a447133c87aa3d3ff
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-search.1
@@ -0,0 +1,156 @@
+.TH "NPM-SEARCH" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-search\fR - Search for packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm search <search term> \[lB]<search term> ...\[rB]
+
+aliases: find, s, se
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Search the registry for packages matching the search terms. \fBnpm search\fR performs a linear, incremental, lexically-ordered search through package metadata for all files in the registry. If your terminal has color support, it will further highlight the matches in the results. This can be disabled with the config item \fBcolor\fR
+.P
+Additionally, using the \fB--searchopts\fR and \fB--searchexclude\fR options paired with more search terms will include and exclude further patterns. The main difference between \fB--searchopts\fR and the standard search terms is that the former does not highlight results in the output and you can use them more fine-grained filtering. Additionally, you can add both of these to your config to change default search filtering behavior.
+.P
+Search also allows targeting of maintainers in search results, by prefixing their npm username with \fB=\fR.
+.P
+If a term starts with \fB/\fR, then it's interpreted as a regular expression and supports standard JavaScript RegExp syntax. In this case search will ignore a trailing \fB/\fR . (Note you must escape or quote many regular expression characters in most shells.)
+.SS "Configuration"
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBcolor\fR"
+.RS 0
+.IP \(bu 4
+Default: true unless the NO_COLOR environ is set to something other than '0'
+.IP \(bu 4
+Type: "always" or Boolean
+.RE 0
+
+.P
+If false, never shows colors. If \fB"always"\fR then always shows colors. If true, then only prints color codes for tty file descriptors.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBdescription\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show the description in \fBnpm search\fR
+.SS "\fBsearchlimit\fR"
+.RS 0
+.IP \(bu 4
+Default: 20
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+Number of items to limit search results to. Will not apply at all to legacy searches.
+.SS "\fBsearchopts\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Space-separated options that are always passed to search.
+.SS "\fBsearchexclude\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Space-separated options that limit the results from search.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBprefer-online\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, staleness checks for cached data will be forced, making the CLI look for updates immediately even for fresh package data.
+.SS "\fBprefer-offline\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, staleness checks for cached data will be bypassed, but missing data will be requested from the server. To force full offline mode, use \fB--offline\fR.
+.SS "\fBoffline\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Force offline mode: no network requests will be done during install. To allow the CLI to fill in missing cache data, see \fB--prefer-offline\fR.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help view
+.IP \(bu 4
+npm help cache
+.IP \(bu 4
+https://npm.im/npm-registry-fetch
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-set.1 b/node/node_modules/npm/man/man1/npm-set.1
new file mode 100644
index 0000000000000000000000000000000000000000..45d85c3ec0a168448df62c2f00a7f4f6aa1c7d14
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-set.1
@@ -0,0 +1,61 @@
+.TH "NPM-SET" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-set\fR - Set a value in the npm configuration
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm set <key>=<value> \[lB]<key>=<value> ...\[rB] (See `npm config`)
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Set a value in the npm configuration
+.SS "Configuration"
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBlocation\fR"
+.RS 0
+.IP \(bu 4
+Default: "user" unless \fB--global\fR is passed, which will also set this value to "global"
+.IP \(bu 4
+Type: "global", "user", or "project"
+.RE 0
+
+.P
+When passed to \fBnpm config\fR this refers to which config file to use.
+.P
+When set to "global" mode, packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "help config"
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-shrinkwrap.1 b/node/node_modules/npm/man/man1/npm-shrinkwrap.1
new file mode 100644
index 0000000000000000000000000000000000000000..8bda34b4d53f454243b16f60d589d657a8750d17
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-shrinkwrap.1
@@ -0,0 +1,32 @@
+.TH "NPM-SHRINKWRAP" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-shrinkwrap\fR - Lock down dependency versions for publication
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm shrinkwrap
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+This command repurposes \fBpackage-lock.json\fR into a publishable \fBnpm-shrinkwrap.json\fR or simply creates a new one. The file created and updated by this command will then take precedence over any other existing or future \fBpackage-lock.json\fR files. For a detailed explanation of the design and purpose of package locks in npm, see npm help package-lock-json.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+\fBpackage-lock.json\fR \fI\(la/configuring-npm/package-lock-json\(ra\fR
+.IP \(bu 4
+\fBnpm-shrinkwrap.json\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR
+.IP \(bu 4
+npm help ls
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-star.1 b/node/node_modules/npm/man/man1/npm-star.1
new file mode 100644
index 0000000000000000000000000000000000000000..2abd34b19568bcbddcd5620e7bbac26c5fde3a6c
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-star.1
@@ -0,0 +1,76 @@
+.TH "NPM-STAR" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-star\fR - Mark your favorite packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm star \[lB]<package-spec>...\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+"Starring" a package means that you have some interest in it. It's a vaguely positive way to show that you care.
+.P
+It's a boolean thing. Starring repeatedly has no additional effect.
+.SS "More"
+.P
+There's also these extra commands to help you manage your favorite packages:
+.SS "Unstar"
+.P
+You can also "unstar" a package using npm help unstar
+.P
+"Unstarring" is the same thing, but in reverse.
+.SS "Listing stars"
+.P
+You can see all your starred packages using npm help stars
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBunicode\fR"
+.RS 0
+.IP \(bu 4
+Default: false on windows, true on mac/unix systems with a unicode locale, as defined by the \fBLC_ALL\fR, \fBLC_CTYPE\fR, or \fBLANG\fR environment variables.
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to true, npm uses unicode characters in the tree output. When false, it uses ascii characters instead of unicode glyphs.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help unstar
+.IP \(bu 4
+npm help stars
+.IP \(bu 4
+npm help view
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help adduser
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-stars.1 b/node/node_modules/npm/man/man1/npm-stars.1
new file mode 100644
index 0000000000000000000000000000000000000000..f4d9c2ed400b00430e1448ec74693bdb689a144e
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-stars.1
@@ -0,0 +1,41 @@
+.TH "NPM-STARS" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-stars\fR - View packages marked as favorites
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stars \[lB]<user>\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+If you have starred a lot of neat things and want to find them again quickly this command lets you do just that.
+.P
+You may also want to see your friend's favorite packages, in this case you will most certainly enjoy this command.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help star
+.IP \(bu 4
+npm help unstar
+.IP \(bu 4
+npm help view
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help adduser
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-start.1 b/node/node_modules/npm/man/man1/npm-start.1
new file mode 100644
index 0000000000000000000000000000000000000000..e8b58224cb3e95085fc33665829c3a767fd101f7
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-start.1
@@ -0,0 +1,79 @@
+.TH "NPM-START" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-start\fR - Start a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm start \[lB]-- <args>\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This runs a predefined command specified in the \fB"start"\fR property of a package's \fB"scripts"\fR object.
+.P
+If the \fB"scripts"\fR object does not define a \fB"start"\fR property, npm will run \fBnode server.js\fR.
+.P
+Note that this is different from the default node behavior of running the file specified in a package's \fB"main"\fR attribute when evoking with \fBnode .\fR
+.P
+As of \fB\[rs]fBnpm@2.0.0\[rs]fR\fR \fI\(lahttps://blog.npmjs.org/post/98131109725/npm-2-0-0\(ra\fR, you can use custom arguments when executing scripts. Refer to npm help run for more details.
+.SS "Example"
+.P
+.RS 2
+.nf
+{
+  "scripts": {
+    "start": "node foo.js"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+npm start
+
+> npm@x.x.x start
+> node foo.js
+
+(foo.js output would be here)
+
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBscript-shell\fR"
+.RS 0
+.IP \(bu 4
+Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+The shell to use for scripts run with the \fBnpm exec\fR, \fBnpm run\fR and \fBnpm
+init <package-spec>\fR commands.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help test
+.IP \(bu 4
+npm help restart
+.IP \(bu 4
+npm help stop
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-stop.1 b/node/node_modules/npm/man/man1/npm-stop.1
new file mode 100644
index 0000000000000000000000000000000000000000..c386f33fa0f7a4cf8f6e0d5fb4123934e0060d91
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-stop.1
@@ -0,0 +1,75 @@
+.TH "NPM-STOP" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-stop\fR - Stop a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stop \[lB]-- <args>\[rB]
+.fi
+.RE
+.SS "Description"
+.P
+This runs a predefined command specified in the "stop" property of a package's "scripts" object.
+.P
+Unlike with npm help start, there is no default script that will run if the \fB"stop"\fR property is not defined.
+.SS "Example"
+.P
+.RS 2
+.nf
+{
+  "scripts": {
+    "stop": "node bar.js"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+npm stop
+
+> npm@x.x.x stop
+> node bar.js
+
+(bar.js output would be here)
+
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBscript-shell\fR"
+.RS 0
+.IP \(bu 4
+Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+The shell to use for scripts run with the \fBnpm exec\fR, \fBnpm run\fR and \fBnpm
+init <package-spec>\fR commands.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help test
+.IP \(bu 4
+npm help start
+.IP \(bu 4
+npm help restart
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-team.1 b/node/node_modules/npm/man/man1/npm-team.1
new file mode 100644
index 0000000000000000000000000000000000000000..c5cdcfafbf388709570449a9d86a151fd02b4731
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-team.1
@@ -0,0 +1,148 @@
+.TH "NPM-TEAM" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-team\fR - Manage organization teams and team memberships
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm team create <scope:team> \[lB]--otp <otpcode>\[rB]
+npm team destroy <scope:team> \[lB]--otp <otpcode>\[rB]
+npm team add <scope:team> <user> \[lB]--otp <otpcode>\[rB]
+npm team rm <scope:team> <user> \[lB]--otp <otpcode>\[rB]
+npm team ls <scope>|<scope:team>
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Used to manage teams in organizations, and change team memberships. Does not handle permissions for packages.
+.P
+Teams must always be fully qualified with the organization/scope they belong to when operating on them, separated by a colon (\fB:\fR). That is, if you have a \fBnewteam\fR team in an \fBorg\fR organization, you must always refer to that team as \fB@org:newteam\fR in these commands.
+.P
+If you have two-factor authentication enabled in \fBauth-and-writes\fR mode, then you can provide a code from your authenticator with \fB\[lB]--otp <otpcode>\[rB]\fR. If you don't include this then you will be taken through a second factor flow based on your \fBauthtype\fR.
+.RS 0
+.IP \(bu 4
+create / destroy: Create a new team, or destroy an existing one. Note: You cannot remove the \fBdevelopers\fR team, \fBlearn more.\fR \fI\(lahttps://docs.npmjs.com/about-developers-team\(ra\fR
+.P
+Here's how to create a new team \fBnewteam\fR under the \fBorg\fR org:
+.P
+.RS 2
+.nf
+npm team create @org:newteam
+.fi
+.RE
+.P
+You should see a confirming message such as: \fB+@org:newteam\fR once the new team has been created.
+.IP \(bu 4
+add: Add a user to an existing team.
+.P
+Adding a new user \fBusername\fR to a team named \fBnewteam\fR under the \fBorg\fR org:
+.P
+.RS 2
+.nf
+npm team add @org:newteam username
+.fi
+.RE
+.P
+On success, you should see a message: \fBusername added to @org:newteam\fR
+.IP \(bu 4
+rm: Using \fBnpm team rm\fR you can also remove users from a team they belong to.
+.P
+Here's an example removing user \fBusername\fR from \fBnewteam\fR team in \fBorg\fR organization:
+.P
+.RS 2
+.nf
+npm team rm @org:newteam username
+.fi
+.RE
+.P
+Once the user is removed a confirmation message is displayed: \fBusername removed from @org:newteam\fR
+.IP \(bu 4
+ls: If performed on an organization name, will return a list of existing teams under that organization. If performed on a team, it will instead return a list of all users belonging to that particular team.
+.P
+Here's an example of how to list all teams from an org named \fBorg\fR:
+.P
+.RS 2
+.nf
+npm team ls @org
+.fi
+.RE
+.P
+Example listing all members of a team named \fBnewteam\fR:
+.P
+.RS 2
+.nf
+npm team ls @org:newteam
+.fi
+.RE
+.RE 0
+
+.SS "Details"
+.P
+\fBnpm team\fR always operates directly on the current registry, configurable from the command line using \fB--registry=<registry url>\fR.
+.P
+You must be a \fIteam admin\fR to create teams and manage team membership, under the given organization. Listing teams and team memberships may be done by any member of the organization.
+.P
+Organization creation and management of team admins and \fIorganization\fR members is done through the website, not the npm CLI.
+.P
+To use teams to manage permissions on packages belonging to your organization, use the \fBnpm access\fR command to grant or revoke the appropriate permissions.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help access
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help registry
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-test.1 b/node/node_modules/npm/man/man1/npm-test.1
new file mode 100644
index 0000000000000000000000000000000000000000..93a47dde079f8da4a2eb3822456bb2000e0291bc
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-test.1
@@ -0,0 +1,73 @@
+.TH "NPM-TEST" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-test\fR - Test a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm test \[lB]-- <args>\[rB]
+
+aliases: tst, t
+.fi
+.RE
+.SS "Description"
+.P
+This runs a predefined command specified in the \fB"test"\fR property of a package's \fB"scripts"\fR object.
+.SS "Example"
+.P
+.RS 2
+.nf
+{
+  "scripts": {
+    "test": "node test.js"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+npm test
+> npm@x.x.x test
+> node test.js
+
+(test.js output would be here)
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBscript-shell\fR"
+.RS 0
+.IP \(bu 4
+Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+The shell to use for scripts run with the \fBnpm exec\fR, \fBnpm run\fR and \fBnpm
+init <package-spec>\fR commands.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help start
+.IP \(bu 4
+npm help restart
+.IP \(bu 4
+npm help stop
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-token.1 b/node/node_modules/npm/man/man1/npm-token.1
new file mode 100644
index 0000000000000000000000000000000000000000..5dbc958e14077c1d1a9f27809ee67081ab4105a5
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-token.1
@@ -0,0 +1,200 @@
+.TH "NPM-TOKEN" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-token\fR - Manage your authentication tokens
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm token list
+npm token revoke <id|token>
+npm token create
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+This lets you list, create and revoke authentication tokens.
+.SS "Listing tokens"
+.P
+When listing tokens, an abbreviated token will be displayed. For security purposes the full token is not displayed.
+.SS "Generating tokens"
+.P
+When generating tokens, you will be prompted you for your password and, if you have two-factor authentication enabled, an otp.
+.P
+Please refer to the \fBdocs website\fR \fI\(lahttps://docs.npmjs.com/creating-and-viewing-access-tokens\(ra\fR for more information on generating tokens for CI/CD.
+.SS "Revoking tokens"
+.P
+When revoking a token, you can use the full token (e.g. what you get back from \fBnpm token create\fR, or as can be found in an \fB.npmrc\fR file), or a truncated id. If the given truncated id is not distinct enough to differentiate between multiple existing tokens, you will need to use enough of the id to allow npm to distinguish between them. Full token ids can be found on the \fBnpm website\fR \fI\(lahttps://www.npmjs.com\(ra\fR, or in the \fB--parseable\fR or \fB--json\fR output of \fBnpm token list\fR. This command will NOT accept the truncated token found in the normal \fBnpm token list\fR output.
+.P
+A revoked token will immediately be removed from the registry and you will no longer be able to use it.
+.SS "Configuration"
+.SS "\fBname\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this sets the name/description for the token.
+.SS "\fBtoken-description\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Description text for the token when using \fBnpm token create\fR.
+.SS "\fBexpires\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this sets the expiration in days. If not specified, the server will determine the default expiration.
+.SS "\fBpackages\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this limits the token access to specific packages.
+.SS "\fBpackages-all\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, grants the token access to all packages instead of limiting to specific packages.
+.SS "\fBscopes\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this limits the token access to specific scopes. Provide a scope name (with or without @ prefix).
+.SS "\fBorgs\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this limits the token access to specific organizations.
+.SS "\fBpackages-and-scopes-permission\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "read-only", "read-write", or "no-access"
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, sets the permission level for packages and scopes. Options are "read-only", "read-write", or "no-access".
+.SS "\fBorgs-permission\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "read-only", "read-write", or "no-access"
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, sets the permission level for organizations. Options are "read-only", "read-write", or "no-access".
+.SS "\fBcidr\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+This is a list of CIDR address to be used when configuring limited access tokens with the \fBnpm token create\fR command.
+.SS "\fBbypass-2fa\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, setting this to true will allow the token to bypass two-factor authentication. This is useful for automation and CI/CD workflows.
+.SS "\fBpassword\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Password for authentication. Can be provided via command line when creating tokens, though it's generally safer to be prompted for it.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBread-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+This is used to mark a token as unable to publish when configuring limited access tokens with the \fBnpm token create\fR command.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help adduser
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help profile
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-trust.1 b/node/node_modules/npm/man/man1/npm-trust.1
new file mode 100644
index 0000000000000000000000000000000000000000..8a0f518be4f2c947cb4947da2d9e5acbb663b584
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-trust.1
@@ -0,0 +1,130 @@
+.TH "NPM-TRUST" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-trust\fR - Manage trusted publishing relationships between packages and CI/CD providers
+.SS "Synopsis"
+.P
+Note: This command is unaware of workspaces.
+.SS "Prerequisites"
+.P
+Before using npm trust commands, ensure the following requirements are met:
+.RS 0
+.IP \(bu 4
+\fBnpm version\fR: \fBnpm@11.10.0\fR or above is required. Use \fBnpm install -g npm@^11.10.0\fR to update if needed.
+.IP \(bu 4
+\fBWrite permissions on the package\fR: You must have write access to the package you're configuring.
+.IP \(bu 4
+\fB2FA enabled on account\fR: Two-factor authentication must be enabled at the account level. Even if it's not currently enabled, you must enable it to use trust commands.
+.IP \(bu 4
+\fBSupported authentication methods\fR: Granular Access Tokens (GAT) with the bypass 2FA option are not supported. Legacy basic auth (username and password) credentials will not work for trust commands or endpoints.
+.IP \(bu 4
+\fBPackage must exist\fR: The package you're configuring must already exist on the npm registry.
+.RE 0
+
+.SS "Description"
+.P
+Configure trust relationships between npm packages and CI/CD providers using OpenID Connect (OIDC). This is the command-line equivalent of managing trusted publisher configurations on the npm website.
+.P
+For a comprehensive overview of trusted publishing, see the \fBnpm trusted publishers documentation\fR \fI\(lahttps://docs.npmjs.com/trusted-publishers\(ra\fR.
+.P
+The \fB\[lB]package\[rB]\fR argument specifies the package name. If omitted, npm will use the name from the \fBpackage.json\fR in the current directory.
+.P
+Each trust relationship has its own set of configuration options and flags based on the OIDC claims provided by that provider. OIDC claims come from the CI/CD provider and include information such as repository name, workflow file, or environment. Since each provider's claims differ, the available flags and configuration keys are not universal\[em]npm matches the claims supported by each provider's OIDC configuration. For specific details on which claims and flags are supported for a given provider, use \fBnpm trust <provider> --help\fR.
+.P
+The required options depend on the CI/CD provider you're configuring. Detailed information about each option is available in the \fBmanaging trusted publisher configurations\fR \fI\(lahttps://docs.npmjs.com/trusted-publishers#managing-trusted-publisher-configurations\(ra\fR section of the npm documentation. If a provider is repository-based and the option is not provided, npm will use the \fBrepository.url\fR field from your \fBpackage.json\fR, if available.
+.P
+Currently, the registry only supports one configuration per package. If you attempt to create a new trust relationship when one already exists, it will result in an error. To replace an existing configuration:
+.RS 0
+.IP 1. 4
+Use \fBnpm trust list \[lB]package\[rB]\fR to view the ID of the existing trusted publisher
+.IP 2. 4
+Use \fBnpm trust revoke --id <id> \[lB]package\[rB]\fR to remove the existing configuration
+.IP 3. 4
+Then create your new trust relationship
+.RE 0
+
+.SS "Bulk Usage"
+.P
+For maintainers managing a large number of packages, you can configure trusted publishing in bulk using bash scripting. Create a loop that iterates through package names and their corresponding configuration details, executing the \fBnpm trust <provider>\fR command with the \fB--yes\fR flag for each package.
+.P
+The first request will require two-factor authentication. During two-factor authentication, you'll see an option on the npm website to skip two-factor authentication for the next 5 minutes. Enabling this option will allow subsequent \fBnpm trust <provider>\fR commands to proceed without two-factor authentication, streamlining the bulk configuration process.
+.P
+We recommend adding a 2-second sleep between each call to avoid rate limiting. With this approach, you can configure approximately 80 packages within the 5-minute two-factor authentication skip window.
+.SS "Configuration"
+.SS "\fBnpm trust github\fR"
+.P
+Create a trusted relationship between a package and GitHub Actions
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm trust github \[lB]package\[rB] --file \[lB]--repo|--repository\[rB] \[lB]--env|--environment\[rB] \[lB]-y|--yes\[rB]
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--file\fR | null | String (required) | Name of workflow file within a repositories .GitHub folder (must end in yaml, yml) | | \fB--repository\fR, \fB--repo\fR | null | String | Name of the repository in the format owner/repo | | \fB--environment\fR, \fB--env\fR | null | String | CI environment name | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
+.SS "\fBnpm trust gitlab\fR"
+.P
+Create a trusted relationship between a package and GitLab CI/CD
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm trust gitlab \[lB]package\[rB] --file \[lB]--project|--repo|--repository\[rB] \[lB]--env|--environment\[rB] \[lB]-y|--yes\[rB]
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--file\fR | null | String (required) | Name of pipeline file (e.g., .gitlab-ci.yml) | | \fB--project\fR | null | String | Name of the project in the format group/project or group/subgroup/project | | \fB--environment\fR, \fB--env\fR | null | String | CI environment name | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
+.SS "\fBnpm trust circleci\fR"
+.P
+Create a trusted relationship between a package and CircleCI
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm trust circleci \[lB]package\[rB] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> \[lB]--context-id <uuid>...\[rB] \[lB]-y|--yes\[rB]
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--org-id\fR | null | String (required) | CircleCI organization UUID | | \fB--project-id\fR | null | String (required) | CircleCI project UUID | | \fB--pipeline-definition-id\fR | null | String (required) | CircleCI pipeline definition UUID | | \fB--vcs-origin\fR | null | String (required) | CircleCI repository origin in format 'provider/owner/repo' | | \fB--context-id\fR | null | null or String (can be set multiple times) | CircleCI context UUID to match | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
+.SS "\fBnpm trust list\fR"
+.P
+List trusted relationships for a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm trust list \[lB]package\[rB]
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "\fBnpm trust revoke\fR"
+.P
+Revoke a trusted relationship for a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm trust revoke \[lB]package\[rB] --id=<trust-id>
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--id\fR | null | String (required) | ID of the trusted relationship to revoke | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help token
+.IP \(bu 4
+npm help access
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help registry
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-undeprecate.1 b/node/node_modules/npm/man/man1/npm-undeprecate.1
new file mode 100644
index 0000000000000000000000000000000000000000..c6251f4c0aea6e0c6e0992df805ef7af33841be0
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-undeprecate.1
@@ -0,0 +1,57 @@
+.TH "NPM-UNDEPRECATE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-undeprecate\fR - Undeprecate a version of a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm undeprecate <package-spec>
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+This command will update the npm registry entry for a package, removing any deprecation warnings that currently exist.
+.P
+It works in the same way as npm help deprecate, except that this command removes deprecation warnings instead of adding them.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help deprecate
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-uninstall.1 b/node/node_modules/npm/man/man1/npm-uninstall.1
new file mode 100644
index 0000000000000000000000000000000000000000..39fedba70c67964eb3368a0940f01703d8bc59e2
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-uninstall.1
@@ -0,0 +1,159 @@
+.TH "NPM-UNINSTALL" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-uninstall\fR - Remove a package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm uninstall \[lB]<@scope>/\[rB]<pkg>...
+
+aliases: unlink, remove, rm, r, un
+.fi
+.RE
+.SS "Description"
+.P
+This uninstalls a package, completely removing everything npm installed on its behalf.
+.P
+It also removes the package from the \fBdependencies\fR, \fBdevDependencies\fR, \fBoptionalDependencies\fR, and \fBpeerDependencies\fR objects in your \fBpackage.json\fR.
+.P
+Further, if you have an \fBnpm-shrinkwrap.json\fR or \fBpackage-lock.json\fR, npm will update those files as well.
+.P
+\fB--no-save\fR will tell npm not to remove the package from your \fBpackage.json\fR, \fBnpm-shrinkwrap.json\fR, or \fBpackage-lock.json\fR files.
+.P
+\fB--save\fR or \fB-S\fR will tell npm to remove the package from your \fBpackage.json\fR, \fBnpm-shrinkwrap.json\fR, and \fBpackage-lock.json\fR files. This is the default, but you may need to use this if you have for instance \fBsave=false\fR in your \fBnpmrc\fR file
+.P
+In global mode (ie, with \fB-g\fR or \fB--global\fR appended to the command), it uninstalls the current package context as a global package. \fB--no-save\fR is ignored in this case.
+.P
+Scope is optional and follows the usual rules for npm help scope.
+.SS "Examples"
+.P
+.RS 2
+.nf
+npm uninstall sax
+.fi
+.RE
+.P
+\fBsax\fR will no longer be in your \fBpackage.json\fR, \fBnpm-shrinkwrap.json\fR, or \fBpackage-lock.json\fR files.
+.P
+.RS 2
+.nf
+npm uninstall lodash --no-save
+.fi
+.RE
+.P
+\fBlodash\fR will not be removed from your \fBpackage.json\fR, \fBnpm-shrinkwrap.json\fR, or \fBpackage-lock.json\fR files.
+.SS "Configuration"
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help prune
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-unpublish.1 b/node/node_modules/npm/man/man1/npm-unpublish.1
new file mode 100644
index 0000000000000000000000000000000000000000..cf06c776954311496b579885f66001cf3b0912b4
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-unpublish.1
@@ -0,0 +1,137 @@
+.TH "NPM-UNPUBLISH" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-unpublish\fR - Remove a package from the registry
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm unpublish \[lB]<package-spec>\[rB]
+.fi
+.RE
+.P
+To learn more about how the npm registry treats unpublish, see our \fBunpublish policies\fR \fI\(lahttps://docs.npmjs.com/policies/unpublish\(ra\fR.
+.SS "Warning"
+.P
+Consider using the npm help deprecate command instead, if your intent is to encourage users to upgrade, or if you no longer want to maintain a package.
+.SS "Description"
+.P
+This removes a package version from the registry, deleting its entry and removing the tarball.
+.P
+The npm registry will return an error if you are not npm help "logged in".
+.P
+If you do not specify a package name at all, the name and version to be unpublished will be pulled from the project in the current directory.
+.P
+If you specify a package name but do not specify a version or if you remove all of a package's versions then the registry will remove the root package entry entirely.
+.P
+Even if you unpublish a package version, that specific name and version combination can never be reused. In order to publish the package again, you must use a new version number. If you unpublish the entire package, you may not publish any new versions of that package until 24 hours have passed.
+.SS "Configuration"
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBforce\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Removes various protections against unfortunate side effects, common mistakes, unnecessary performance degradation, and malicious input.
+.RS 0
+.IP \(bu 4
+Allow clobbering non-npm files in global installs.
+.IP \(bu 4
+Allow the \fBnpm version\fR command to work on an unclean git repository.
+.IP \(bu 4
+Allow deleting the cache folder with \fBnpm cache clean\fR.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of npm.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of \fBnode\fR, even if \fB--engine-strict\fR is enabled.
+.IP \(bu 4
+Allow \fBnpm audit fix\fR to install modules outside your stated dependency range (including SemVer-major changes).
+.IP \(bu 4
+Allow unpublishing all versions of a published package.
+.IP \(bu 4
+Allow conflicting peerDependencies to be installed in the root project.
+.IP \(bu 4
+Implicitly set \fB--yes\fR during \fBnpm init\fR.
+.IP \(bu 4
+Allow clobbering existing values in \fBnpm pkg\fR
+.IP \(bu 4
+Allow unpublishing of entire packages (not just a single version).
+.RE 0
+
+.P
+If you don't have a clear idea of what you want to do, it is strongly recommended that you do not use this option!
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help deprecate
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help adduser
+.IP \(bu 4
+npm help owner
+.IP \(bu 4
+npm help login
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-unstar.1 b/node/node_modules/npm/man/man1/npm-unstar.1
new file mode 100644
index 0000000000000000000000000000000000000000..54b50bc209d6c50fd6596b3b8a964b7778b3a816
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-unstar.1
@@ -0,0 +1,70 @@
+.TH "NPM-UNSTAR" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-unstar\fR - Remove an item from your favorite packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm unstar \[lB]<package-spec>...\[rB]
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+"Unstarring" a package is the opposite of npm help star, it removes an item from your list of favorite packages.
+.SS "More"
+.P
+There's also these extra commands to help you manage your favorite packages:
+.SS "Star"
+.P
+You can "star" a package using npm help star
+.SS "Listing stars"
+.P
+You can see all your starred packages using npm help stars
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBunicode\fR"
+.RS 0
+.IP \(bu 4
+Default: false on windows, true on mac/unix systems with a unicode locale, as defined by the \fBLC_ALL\fR, \fBLC_CTYPE\fR, or \fBLANG\fR environment variables.
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to true, npm uses unicode characters in the tree output. When false, it uses ascii characters instead of unicode glyphs.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help star
+.IP \(bu 4
+npm help stars
+.IP \(bu 4
+npm help view
+.IP \(bu 4
+npm help whoami
+.IP \(bu 4
+npm help adduser
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-update.1 b/node/node_modules/npm/man/man1/npm-update.1
new file mode 100644
index 0000000000000000000000000000000000000000..2e0aaa78e32c05324f6d8d43c3e880214e0ec70e
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-update.1
@@ -0,0 +1,436 @@
+.TH "NPM-UPDATE" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-update\fR - Update packages
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm update \[lB]<pkg>...\[rB]
+
+aliases: u, up, upgrade, udpate
+.fi
+.RE
+.SS "Description"
+.P
+This command will update all the packages listed to the latest version (specified by the \fB\[rs]fBtag\[rs]fR config\fR \fI\(la/using-npm/config#tag\(ra\fR), respecting the semver constraints of both your package and its dependencies (if they also require the same package).
+.P
+It will also install missing packages.
+.P
+If the \fB-g\fR flag is specified, this command will update globally installed packages.
+.P
+If no package name is specified, all packages in the specified location (global or local) will be updated.
+.P
+Note that by default \fBnpm update\fR will not update the semver values of direct dependencies in your project \fBpackage.json\fR. If you want to also update values in \fBpackage.json\fR you can run: \fBnpm update --save\fR (or add the \fBsave=true\fR option to a npm help "configuration file" to make that the default behavior).
+.SS "Example"
+.P
+For the examples below, assume that the current package is \fBapp\fR and it depends on dependencies, \fBdep1\fR (\fBdep2\fR, .. etc.). The published versions of \fBdep1\fR are:
+.P
+.RS 2
+.nf
+{
+  "dist-tags": { "latest": "1.2.2" },
+  "versions": \[lB]
+    "1.2.2",
+    "1.2.1",
+    "1.2.0",
+    "1.1.2",
+    "1.1.1",
+    "1.0.0",
+    "0.4.1",
+    "0.4.0",
+    "0.2.0"
+  \[rB]
+}
+.fi
+.RE
+.SS "Caret Dependencies"
+.P
+If \fBapp\fR's \fBpackage.json\fR contains:
+.P
+.RS 2
+.nf
+"dependencies": {
+  "dep1": "^1.1.1"
+}
+.fi
+.RE
+.P
+Then \fBnpm update\fR will install \fBdep1@1.2.2\fR, because \fB1.2.2\fR is \fBlatest\fR and \fB1.2.2\fR satisfies \fB^1.1.1\fR.
+.SS "Tilde Dependencies"
+.P
+However, if \fBapp\fR's \fBpackage.json\fR contains:
+.P
+.RS 2
+.nf
+"dependencies": {
+  "dep1": "~1.1.1"
+}
+.fi
+.RE
+.P
+In this case, running \fBnpm update\fR will install \fBdep1@1.1.2\fR. Even though the \fBlatest\fR tag points to \fB1.2.2\fR, this version does not satisfy \fB~1.1.1\fR, which is equivalent to \fB>=1.1.1 <1.2.0\fR. So the highest-sorting version that satisfies \fB~1.1.1\fR is used, which is \fB1.1.2\fR.
+.SS "Caret Dependencies below 1.0.0"
+.P
+Suppose \fBapp\fR has a caret dependency on a version below \fB1.0.0\fR, for example:
+.P
+.RS 2
+.nf
+"dependencies": {
+  "dep1": "^0.2.0"
+}
+.fi
+.RE
+.P
+\fBnpm update\fR will install \fBdep1@0.2.0\fR.
+.P
+If the dependence were on \fB^0.4.0\fR:
+.P
+.RS 2
+.nf
+"dependencies": {
+  "dep1": "^0.4.0"
+}
+.fi
+.RE
+.P
+Then \fBnpm update\fR will install \fBdep1@0.4.1\fR, because that is the highest-sorting version that satisfies \fB^0.4.0\fR (\fB>= 0.4.0 <0.5.0\fR)
+.SS "Subdependencies"
+.P
+Suppose your app now also has a dependency on \fBdep2\fR
+.P
+.RS 2
+.nf
+{
+  "name": "my-app",
+  "dependencies": {
+      "dep1": "^1.0.0",
+      "dep2": "1.0.0"
+  }
+}
+.fi
+.RE
+.P
+and \fBdep2\fR itself depends on this limited range of \fBdep1\fR
+.P
+.RS 2
+.nf
+{
+"name": "dep2",
+  "dependencies": {
+    "dep1": "~1.1.1"
+  }
+}
+.fi
+.RE
+.P
+Then \fBnpm update\fR will install \fBdep1@1.1.2\fR because that is the highest version that \fBdep2\fR allows. npm will prioritize having a single version of \fBdep1\fR in your tree rather than two when that single version can satisfy the semver requirements of multiple dependencies in your tree. In this case if you really did need your package to use a newer version you would need to use \fBnpm install\fR.
+.SS "Updating Globally-Installed Packages"
+.P
+\fBnpm update -g\fR will apply the \fBupdate\fR action to each globally installed package that is \fBoutdated\fR -- that is, has a version that is different from \fBwanted\fR.
+.P
+Note: Globally installed packages are treated as if they are installed with a caret semver range specified. So if you require to update to \fBlatest\fR you may need to run \fBnpm install -g \[lB]<pkg>...\[rB]\fR
+.P
+NOTE: If a package has been upgraded to a version newer than \fBlatest\fR, it will be \fIdowngraded\fR.
+.SS "Configuration"
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBbefore\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Date
+.RE 0
+
+.P
+If passed to \fBnpm install\fR, will rebuild the npm tree such that only versions that were available \fBon or before\fR the given date are installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
+.P
+This config cannot be used with: \fBmin-release-age\fR
+.SS "\fBmin-release-age\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
+.P
+This config cannot be used with: \fBbefore\fR
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help outdated
+.IP \(bu 4
+npm help shrinkwrap
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help ls
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-version.1 b/node/node_modules/npm/man/man1/npm-version.1
new file mode 100644
index 0000000000000000000000000000000000000000..dbfcf6820492ae04a0893f08820a061c12e8e5f3
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-version.1
@@ -0,0 +1,257 @@
+.TH "NPM-VERSION" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-version\fR - Bump a package version
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm version \[lB]<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease | from-git\[rB]
+
+alias: verison
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBallow-same-version\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prevents throwing an error when \fBnpm version\fR is used to set the new version to the same value as the current version.
+.SS "\fBcommit-hooks\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run git commit hooks when using the \fBnpm version\fR command.
+.SS "\fBgit-tag-version\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tag the commit when using the \fBnpm version\fR command. Setting this to false results in no commit being made at all.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBpreid\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The "prerelease identifier" to use as a prefix for the "prerelease" part of a semver. Like the \fBrc\fR in \fB1.2.0-rc.8\fR.
+.SS "\fBsign-git-tag\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, then the \fBnpm version\fR command will tag the version using \fB-s\fR to add a signature.
+.P
+Note that git requires you to have set up GPG keys in your git configs for this to work properly.
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces-update\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the npm cli will run an update after operations that may possibly change the workspaces installed to the \fBnode_modules\fR folder.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "Description"
+.P
+Run this in a package directory to bump the version and write the new data back to \fBpackage.json\fR, \fBpackage-lock.json\fR, and, if present, \fBnpm-shrinkwrap.json\fR.
+.P
+The \fBnewversion\fR argument should be a valid semver string, a valid second argument to \fBsemver.inc\fR \fI\(lahttps://github.com/npm/node-semver#functions\(ra\fR (one of \fBpatch\fR, \fBminor\fR, \fBmajor\fR, \fBprepatch\fR, \fBpreminor\fR, \fBpremajor\fR, \fBprerelease\fR), or \fBfrom-git\fR. In the second case, the existing version will be incremented by 1 in the specified field. \fBfrom-git\fR will try to read the latest git tag, and use that as the new npm version.
+.P
+\fBNote:\fR If the current version is a prerelease version, \fBpatch\fR will simply remove the prerelease suffix without incrementing the patch version number. For example, \fB1.2.0-5\fR becomes \fB1.2.0\fR with \fBnpm version patch\fR, not \fB1.2.1\fR.
+.P
+If run in a git repo, it will also create a version commit and tag. This behavior is controlled by \fBgit-tag-version\fR (see below), and can be disabled on the command line by running \fBnpm --no-git-tag-version version\fR. It will fail if the working directory is not clean, unless the \fB-f\fR or \fB--force\fR flag is set.
+.P
+\fBNote:\fR Git integration requires a reasonably recent version of git (2.0.0 or later is recommended). If you encounter issues with git commands, ensure your git installation is up to date.
+.P
+If supplied with \fB-m\fR or \fB\[rs]fB--message\[rs]fR config\fR \fI\(la/using-npm/config#message\(ra\fR option, npm will use it as a commit message when creating a version commit. If the \fBmessage\fR config contains \fB%s\fR then that will be replaced with the resulting version number. For example:
+.P
+.RS 2
+.nf
+npm version patch -m "Upgrade to %s for reasons"
+.fi
+.RE
+.P
+If the \fB\[rs]fBsign-git-tag\[rs]fR config\fR \fI\(la/using-npm/config#sign-git-tag\(ra\fR is set, then the tag will be signed using the \fB-s\fR flag to git. Note that you must have a default GPG key set up in your git config for this to work properly. For example:
+.P
+.RS 2
+.nf
+$ npm config set sign-git-tag true
+$ npm version patch
+
+You need a passphrase to unlock the secret key for user: "isaacs (http://blog.izs.me/) <i@izs.me>"
+2048-bit RSA key, ID 6C481CF6, created 2010-08-31
+
+Enter passphrase:
+.fi
+.RE
+.P
+If \fBpreversion\fR, \fBversion\fR, or \fBpostversion\fR are in the \fBscripts\fR property of the package.json, they will be executed as part of running \fBnpm version\fR.
+.P
+The exact order of execution is as follows:
+.RS 0
+.IP 1. 4
+Check to make sure the git working directory is clean before we get started. Your scripts may add files to the commit in future steps. This step is skipped if the \fB--force\fR flag is set.
+.IP 2. 4
+Run the \fBpreversion\fR script. These scripts have access to the old \fBversion\fR in package.json. A typical use would be running your full test suite before deploying. Any files you want added to the commit should be explicitly added using \fBgit add\fR.
+.IP 3. 4
+Bump \fBversion\fR in \fBpackage.json\fR as requested (\fBpatch\fR, \fBminor\fR, \fBmajor\fR, etc).
+.IP 4. 4
+Run the \fBversion\fR script. These scripts have access to the new \fBversion\fR in package.json (so they can incorporate it into file headers in generated files for example). Again, scripts should explicitly add generated files to the commit using \fBgit add\fR.
+.IP 5. 4
+Commit and tag.
+.IP 6. 4
+Run the \fBpostversion\fR script. Use it to clean up the file system or automatically push the commit and/or tag.
+.RE 0
+
+.P
+Take the following example:
+.P
+.RS 2
+.nf
+{
+  "scripts": {
+    "preversion": "npm test",
+    "version": "npm run build && git add -A dist",
+    "postversion": "git push && git push --tags && rm -rf build/temp"
+  }
+}
+.fi
+.RE
+.P
+This runs all your tests and proceeds only if they pass. Then runs your \fBbuild\fR script, and adds everything in the \fBdist\fR directory to the commit. After the commit, it pushes the new commit and tag up to the server, and deletes the \fBbuild/temp\fR directory.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help init
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help config
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-view.1 b/node/node_modules/npm/man/man1/npm-view.1
new file mode 100644
index 0000000000000000000000000000000000000000..f5d80fbdab8c9fe4237701f0264242c2cdef7f00
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-view.1
@@ -0,0 +1,284 @@
+.TH "NPM-VIEW" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-view\fR - View registry info
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm view \[lB]<package-spec>\[rB] \[lB]<field>\[lB].subfield\[rB]...\[rB]
+
+aliases: info, show, v
+.fi
+.RE
+.SS "Description"
+.P
+This command shows data about a package and prints it to stdout.
+.P
+As an example, to view information about the \fBconnect\fR package from the registry, you would run:
+.P
+.RS 2
+.nf
+npm view connect
+.fi
+.RE
+.P
+The default version is \fB"latest"\fR if unspecified.
+.P
+Field names can be specified after the package descriptor. For example, to show the dependencies of the \fBronn\fR package at version \fB0.3.5\fR, you could do the following:
+.P
+.RS 2
+.nf
+npm view ronn@0.3.5 dependencies
+.fi
+.RE
+.P
+By default, \fBnpm view\fR shows data about the current project context (by looking for a \fBpackage.json\fR). To show field data for the current project use a file path (i.e. \fB.\fR):
+.P
+.RS 2
+.nf
+npm view . dependencies
+.fi
+.RE
+.P
+You can view child fields by separating them with a period. To view the git repository URL for the latest version of \fBnpm\fR, you would run the following command:
+.P
+.RS 2
+.nf
+npm view npm repository.url
+.fi
+.RE
+.P
+This makes it easy to view information about a dependency with a bit of shell scripting. For example, to view all the data about the version of \fBopts\fR that \fBronn\fR depends on, you could write the following:
+.P
+.RS 2
+.nf
+npm view opts@$(npm view ronn dependencies.opts)
+.fi
+.RE
+.P
+For fields that are arrays, requesting a non-numeric field will return all of the values from the objects in the list. For example, to get all the contributor email addresses for the \fBexpress\fR package, you would run:
+.P
+.RS 2
+.nf
+npm view express contributors.email
+.fi
+.RE
+.P
+You may also use numeric indices in square braces to specifically select an item in an array field. To just get the email address of the first contributor in the list, you can run:
+.P
+.RS 2
+.nf
+npm view express contributors\[lB]0\[rB].email
+.fi
+.RE
+.P
+If the field value you are querying for is a property of an object, you should run:
+.P
+.RS 2
+.nf
+npm view express time'\[lB]4.8.0\[rB]'
+.fi
+.RE
+.P
+Note: When accessing object properties that contain special characters or numeric keys, you need to use quotes around the key name. For example, to get the publish time of a specific version:
+.P
+.RS 2
+.nf
+npm view express "time\[lB]4.17.1\[rB]"
+.fi
+.RE
+.P
+Without quotes, the shell may interpret the square brackets as glob patterns, causing the command to fail. You can also access the time field for a specific version by specifying the version in the package descriptor:
+.P
+.RS 2
+.nf
+npm view express@4.17.1 time
+.fi
+.RE
+.P
+This will return all version-time pairs, but the context will be for that specific version.
+.P
+Multiple fields may be specified, and will be printed one after another. For example, to get all the contributor names and email addresses, you can do this:
+.P
+.RS 2
+.nf
+npm view express contributors.name contributors.email
+.fi
+.RE
+.P
+"Person" fields are shown as a string if they would be shown as an object. So, for example, this will show the list of \fBnpm\fR contributors in the shortened string format. (See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more on this.)
+.P
+.RS 2
+.nf
+npm view npm contributors
+.fi
+.RE
+.P
+If a version range is provided, then data will be printed for every matching version of the package. This will show which version of \fBjsdom\fR was required by each matching version of \fByui3\fR:
+.P
+.RS 2
+.nf
+npm view yui3@'>0.5.4' dependencies.jsdom
+.fi
+.RE
+.P
+To show the \fBconnect\fR package version history, you can do this:
+.P
+.RS 2
+.nf
+npm view connect versions
+.fi
+.RE
+.SS "Field Access Patterns"
+.P
+The \fBnpm view\fR command supports different ways to access nested fields and array elements in package metadata. Understanding these patterns makes it easier to extract specific information.
+.SS "Nested Object Fields"
+.P
+Use dot notation to access nested object fields:
+.P
+.RS 2
+.nf
+# Access nested properties
+npm view npm repository.url
+npm view express bugs.url
+.fi
+.RE
+.SS "Array Element Access"
+.P
+For arrays, use numeric indices in square brackets to access specific elements:
+.P
+.RS 2
+.nf
+# Get the first contributor's email
+npm view express contributors\[lB]0\[rB].email
+
+# Get the second maintainer's name
+npm view express maintainers\[lB]1\[rB].name
+.fi
+.RE
+.SS "Object Property Access"
+.P
+For object properties (like accessing specific versions in the \fBtime\fR field), use bracket notation with the property name in quotes:
+.P
+.RS 2
+.nf
+# Get publish time for a specific version
+npm view express "time\[lB]4.17.1\[rB]"
+
+# Get dist-tags
+npm view express "dist-tags.latest"
+.fi
+.RE
+.SS "Extracting Fields from Arrays"
+.P
+Request a non-numeric field on an array to get all values from objects in the list:
+.P
+.RS 2
+.nf
+# Get all contributor emails
+npm view express contributors.email
+
+# Get all contributor names
+npm view express contributors.name
+.fi
+.RE
+.SS "Configuration"
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "Output"
+.P
+If only a single string field for a single version is output, then it will not be colorized or quoted, to enable piping the output to another command. If the field is an object, it will be output as a JavaScript object literal.
+.P
+If the \fB--json\fR flag is given, the outputted fields will be JSON.
+.P
+If the version range matches multiple versions then each printed value will be prefixed with the version it applies to.
+.P
+If multiple fields are requested, then each of them is prefixed with the field name.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help "package spec"
+.IP \(bu 4
+npm help search
+.IP \(bu 4
+npm help registry
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help docs
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm-whoami.1 b/node/node_modules/npm/man/man1/npm-whoami.1
new file mode 100644
index 0000000000000000000000000000000000000000..163541e53beb295405834b149ffb60eaf180b8c2
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm-whoami.1
@@ -0,0 +1,39 @@
+.TH "NPM-WHOAMI" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-whoami\fR - Display npm username
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm whoami
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Display the npm username of the currently logged-in user.
+.P
+If logged into a registry that provides token-based authentication, then connect to the \fB/-/whoami\fR registry endpoint to find the username associated with the token, and print to standard output.
+.P
+If logged into a registry that uses Basic Auth, then simply print the \fBusername\fR portion of the authentication string.
+.SS "Configuration"
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help adduser
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npm.1 b/node/node_modules/npm/man/man1/npm.1
new file mode 100644
index 0000000000000000000000000000000000000000..24576385fe4a1206c9905d18980e1afd0b3d341f
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npm.1
@@ -0,0 +1,131 @@
+.TH "NPM" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm\fR - javascript package manager
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Version"
+.P
+11.13.0
+.SS "Description"
+.P
+npm is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently.
+.P
+It is extremely configurable to support a variety of use cases. Most commonly, you use it to publish, discover, install, and develop node programs.
+.P
+Run \fBnpm help\fR to get a list of available commands.
+.SS "Important"
+.P
+npm comes preconfigured to use npm's public registry at https://registry.npmjs.org by default. Use of the npm public registry is subject to terms of use available at https://docs.npmjs.com/policies/terms.
+.P
+You can configure npm to use any compatible registry you like, and even run your own registry. Use of someone else's registry is governed by their terms of use.
+.SS "Introduction"
+.P
+You probably got npm because you want to install stuff.
+.P
+The very first thing you will most likely want to run in any node program is \fBnpm install\fR to install its dependencies.
+.P
+You can also run \fBnpm install blerg\fR to install the latest version of "blerg". Check out npm help install for more info. It can do a lot of stuff.
+.P
+Use the \fBnpm search\fR command to show everything that's available in the public registry. Use \fBnpm ls\fR to show everything you've installed.
+.SS "Dependencies"
+.P
+If a package lists a dependency using a git URL, npm will install that dependency using the \fB\[rs]fBgit\[rs]fR\fR \fI\(lahttps://github.com/git-guides/install-git\(ra\fR command and will generate an error if it is not installed.
+.P
+If one of the packages npm tries to install is a native node module and requires compiling of C++ Code, npm will use \fBnode-gyp\fR \fI\(lahttps://github.com/nodejs/node-gyp\(ra\fR for that task. For a Unix system, \fBnode-gyp\fR \fI\(lahttps://github.com/nodejs/node-gyp\(ra\fR needs Python, make and a buildchain like GCC. On Windows, Python and Microsoft Visual Studio C++ are needed. For more information visit \fBthe node-gyp repository\fR \fI\(lahttps://github.com/nodejs/node-gyp\(ra\fR and the \fBnode-gyp Wiki\fR \fI\(lahttps://github.com/nodejs/node-gyp/wiki\(ra\fR.
+.SS "Directories"
+.P
+See npm help folders to learn about where npm puts stuff.
+.P
+In particular, npm has two modes of operation:
+.RS 0
+.IP \(bu 4
+local mode: npm installs packages into the current project directory, which defaults to the current working directory. Packages install to \fB./node_modules\fR, and bins to \fB./node_modules/.bin\fR.
+.IP \(bu 4
+global mode: npm installs packages into the install prefix at \fB$NPM_CONFIG_PREFIX/lib/node_modules\fR and bins to \fB$NPM_CONFIG_PREFIX/bin\fR.
+.RE 0
+
+.P
+Local mode is the default. Use \fB-g\fR or \fB--global\fR on any command to run in global mode instead.
+.SS "Developer Usage"
+.P
+If you're using npm to develop and publish your code, check out the following help topics:
+.RS 0
+.IP \(bu 4
+json: Make a package.json file. See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR.
+.IP \(bu 4
+link: Links your current working code into Node's path, so that you don't have to reinstall every time you make a change. Use npm help link to do this.
+.IP \(bu 4
+install: It's a good idea to install things if you don't need the symbolic link. Especially, installing other peoples code from the registry is done via npm help install
+.IP \(bu 4
+adduser: Create an account or log in. When you do this, npm will store credentials in the user config file.
+.IP \(bu 4
+publish: Use the npm help publish command to upload your code to the registry.
+.RE 0
+
+.SS "Configuration"
+.P
+npm is extremely configurable. It reads its configuration options from 5 places.
+.RS 0
+.IP \(bu 4
+Command line switches: Set a config with \fB--key val\fR. All keys take a value, even if they are booleans (the config parser doesn't know what the options are at the time of parsing). If you do not provide a value (\fB--key\fR) then the option is set to boolean \fBtrue\fR.
+.IP \(bu 4
+Environment Variables: Set any config by prefixing the name in an environment variable with \fBNPM_CONFIG_\fR. For example, \fBexport NPM_CONFIG_KEY=val\fR.
+.IP \(bu 4
+User Configs: The file at \fB$HOME/.npmrc\fR is an ini-formatted list of configs. If present, it is parsed. If the \fBuserconfig\fR option is set in the cli or env, that file will be used instead.
+.IP \(bu 4
+Global Configs: The file found at \fB./etc/npmrc\fR (relative to the global prefix will be parsed if it is found. See npm help prefix for more info on the global prefix. If the \fBglobalconfig\fR option is set in the cli, env, or user config, then that file is parsed instead.
+.IP \(bu 4
+Defaults: npm's default configuration options are defined in \fBlib/utils/config/definitions.js\fR. These must not be changed.
+.RE 0
+
+.P
+See npm help config for much, much, more information.
+.SS "Contributions"
+.P
+Patches welcome!
+.P
+If you would like to help, but don't know what to work on, read the \fBcontributing guidelines\fR \fI\(lahttps://github.com/npm/cli/blob/latest/CONTRIBUTING.md\(ra\fR and check the issues list.
+.SS "Bugs"
+.P
+When you find issues, please report them: \fI\(lahttps://github.com/npm/cli/issues\(ra\fR
+.P
+Please be sure to follow the template and bug reporting guidelines.
+.SS "Feature Requests"
+.P
+Discuss new feature ideas on our discussion forum:
+.RS 0
+.IP \(bu 4
+\fI\(lahttps://github.com/orgs/community/discussions/categories/npm\(ra\fR
+.RE 0
+
+.P
+Or suggest formal RFC proposals:
+.RS 0
+.IP \(bu 4
+\fI\(lahttps://github.com/npm/rfcs\(ra\fR
+.RE 0
+
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help help
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help prefix
+.IP \(bu 4
+npm help publish
+.RE 0
diff --git a/node/node_modules/npm/man/man1/npx.1 b/node/node_modules/npm/man/man1/npx.1
new file mode 100644
index 0000000000000000000000000000000000000000..94e026c480c41e61945af7affe9df93763d8478a
--- /dev/null
+++ b/node/node_modules/npm/man/man1/npx.1
@@ -0,0 +1,158 @@
+.TH "NPX" "1" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpx\fR - Run a command from a local or remote npm package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npx -- <pkg>\[lB]@<version>\[rB] \[lB]args...\[rB]
+npx --package=<pkg>\[lB]@<version>\[rB] -- <cmd> \[lB]args...\[rB]
+npx -c '<cmd> \[lB]args...\[rB]'
+npx --package=foo -c '<cmd> \[lB]args...\[rB]'
+.fi
+.RE
+.SS "Description"
+.P
+This command allows you to run an arbitrary command from an npm package (either one installed locally, or fetched remotely), in a similar context as running it via \fBnpm run\fR.
+.P
+Run this command to execute a package's binary. Any options and arguments after the package name are passed directly to the executed command, not to npx itself. For example, \fBnpx create-react-app my-app --template typescript\fR will pass \fBmy-app\fR and \fB--template typescript\fR to the \fBcreate-react-app\fR command. To see what options a specific package accepts, consult that package's documentation (e.g., at npmjs.com or in its repository).
+.P
+Whatever packages are specified by the \fB--package\fR option will be provided in the \fBPATH\fR of the executed command, along with any locally installed package executables. The \fB--package\fR option may be specified multiple times, to execute the supplied command in an environment where all specified packages are available.
+.P
+If any requested packages are not present in the local project dependencies, then they are installed to a folder in the npm cache, which is added to the \fBPATH\fR environment variable in the executed process. A prompt is printed (which can be suppressed by providing either \fB--yes\fR or \fB--no\fR).
+.P
+Package names provided without a specifier will be matched with whatever version exists in the local project. Package names with a specifier will only be considered a match if they have the exact same name and version as the local dependency.
+.P
+If no \fB-c\fR or \fB--call\fR option is provided, then the positional arguments are used to generate the command string. If no \fB--package\fR options are provided, then npm will attempt to determine the executable name from the package specifier provided as the first positional argument according to the following heuristic:
+.RS 0
+.IP \(bu 4
+If the package has a single entry in its \fBbin\fR field in \fBpackage.json\fR, or if all entries are aliases of the same command, then that command will be used.
+.IP \(bu 4
+If the package has multiple \fBbin\fR entries, and one of them matches the unscoped portion of the \fBname\fR field, then that command will be used.
+.IP \(bu 4
+If this does not result in exactly one option (either because there are no bin entries, or none of them match the \fBname\fR of the package), then \fBnpm exec\fR exits with an error.
+.RE 0
+
+.P
+To run a binary \fIother than\fR the named binary, specify one or more \fB--package\fR options, which will prevent npm from inferring the package from the first command argument.
+.SS "\fBnpx\fR vs \fBnpm exec\fR"
+.P
+When run via the \fBnpx\fR binary, all flags and options \fImust\fR be set prior to any positional arguments. When run via \fBnpm exec\fR, a double-hyphen \fB--\fR flag can be used to suppress npm's parsing of switches and options that should be sent to the executed command.
+.P
+For example:
+.P
+.RS 2
+.nf
+$ npx foo@latest bar --package=@npmcli/foo
+.fi
+.RE
+.P
+In this case, npm will resolve the \fBfoo\fR package name, and run the following command:
+.P
+.RS 2
+.nf
+$ foo bar --package=@npmcli/foo
+.fi
+.RE
+.P
+Since the \fB--package\fR option comes \fIafter\fR the positional arguments, it is treated as an argument to the executed command.
+.P
+In contrast, due to npm's argument parsing logic, running this command is different:
+.P
+.RS 2
+.nf
+$ npm exec foo@latest bar --package=@npmcli/foo
+.fi
+.RE
+.P
+In this case, npm will parse the \fB--package\fR option first, resolving the \fB@npmcli/foo\fR package. Then, it will execute the following command in that context:
+.P
+.RS 2
+.nf
+$ foo@latest bar
+.fi
+.RE
+.P
+The double-hyphen character is recommended to explicitly tell npm to stop parsing command line options and switches. The following command would thus be equivalent to the \fBnpx\fR command above:
+.P
+.RS 2
+.nf
+$ npm exec -- foo@latest bar --package=@npmcli/foo
+.fi
+.RE
+.SS "Examples"
+.P
+Run the version of \fBtap\fR in the local dependencies, with the provided arguments:
+.P
+.RS 2
+.nf
+$ npm exec -- tap --bail test/foo.js
+$ npx tap --bail test/foo.js
+.fi
+.RE
+.P
+Run a command \fIother than\fR the command whose name matches the package name by specifying a \fB--package\fR option:
+.P
+.RS 2
+.nf
+$ npm exec --package=foo -- bar --bar-argument
+# ~ or ~
+$ npx --package=foo bar --bar-argument
+.fi
+.RE
+.P
+Run an arbitrary shell script, in the context of the current project:
+.P
+.RS 2
+.nf
+$ npm x -c 'eslint && say "hooray, lint passed"'
+$ npx -c 'eslint && say "hooray, lint passed"'
+.fi
+.RE
+.SS "Compatibility with Older npx Versions"
+.P
+The \fBnpx\fR binary was rewritten in npm v7.0.0, and the standalone \fBnpx\fR package deprecated at that time. \fBnpx\fR uses the \fBnpm exec\fR command instead of a separate argument parser and install process, with some affordances to maintain backwards compatibility with the arguments it accepted in previous versions.
+.P
+This resulted in some shifts in its functionality:
+.RS 0
+.IP \(bu 4
+Any \fBnpm\fR config value may be provided.
+.IP \(bu 4
+To prevent security and user-experience problems from mistyping package names, \fBnpx\fR prompts before installing anything. Suppress this prompt with the \fB-y\fR or \fB--yes\fR option.
+.IP \(bu 4
+The \fB--no-install\fR option is deprecated, and will be converted to \fB--no\fR.
+.IP \(bu 4
+Shell fallback functionality is removed, as it is not advisable.
+.IP \(bu 4
+The \fB-p\fR argument is a shorthand for \fB--parseable\fR in npm, but shorthand for \fB--package\fR in npx. This is maintained, but only for the \fBnpx\fR executable.
+.IP \(bu 4
+The \fB--ignore-existing\fR option is removed. Locally installed bins are always present in the executed process \fBPATH\fR.
+.IP \(bu 4
+The \fB--npm\fR option is removed. \fBnpx\fR will always use the \fBnpm\fR it ships with.
+.IP \(bu 4
+The \fB--node-arg\fR and \fB-n\fR options have been removed. Use \fB\[rs]fBNODE_OPTIONS\[rs]fR\fR \fI\(lahttps://nodejs.org/api/cli.html#node_optionsoptions\(ra\fR instead: e.g., \fBNODE_OPTIONS="--trace-warnings --trace-exit" npx foo --random=true\fR
+.IP \(bu 4
+The \fB--always-spawn\fR option is redundant, and thus removed.
+.IP \(bu 4
+The \fB--shell\fR option is replaced with \fB--script-shell\fR, but maintained in the \fBnpx\fR executable for backwards compatibility.
+.RE 0
+
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help test
+.IP \(bu 4
+npm help start
+.IP \(bu 4
+npm help restart
+.IP \(bu 4
+npm help stop
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help exec
+.RE 0
diff --git a/node/node_modules/npm/man/man5/folders.5 b/node/node_modules/npm/man/man5/folders.5
new file mode 100644
index 0000000000000000000000000000000000000000..4332feeaeb9acfddbaab7dd5d0fcfa27dde2bfad
--- /dev/null
+++ b/node/node_modules/npm/man/man5/folders.5
@@ -0,0 +1,147 @@
+.TH "FOLDERS" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBFolders\fR - Folder structures used by npm
+.SS "Description"
+.P
+npm puts various things on your computer. That's its job.
+.P
+This document will tell you what it puts where.
+.SS "tl;dr"
+.RS 0
+.IP \(bu 4
+Local install (default): puts stuff in \fB./node_modules\fR of the current package root.
+.IP \(bu 4
+Global install (with \fB-g\fR): puts stuff in /usr/local or wherever node is installed.
+.IP \(bu 4
+Install it \fBlocally\fR if you're going to \fBrequire()\fR it.
+.IP \(bu 4
+Install it \fBglobally\fR if you're going to run it on the command line.
+.IP \(bu 4
+If you need both, then install it in both places, or use \fBnpm link\fR.
+.RE 0
+
+.SS "prefix Configuration"
+.P
+The \fB\[rs]fBprefix\[rs]fR config\fR \fI\(la/using-npm/config#prefix\(ra\fR defaults to the location where node is installed. On most systems, this is \fB/usr/local\fR. On Windows, it's \fB%AppData%\[rs]npm\fR. On Unix systems, it's one level up, since node is typically installed at \fB{prefix}/bin/node\fR rather than \fB{prefix}/node.exe\fR.
+.P
+When the \fBglobal\fR flag is set, npm installs things into this prefix. When it is not set, it uses the root of the current package, or the current working directory if not in a package already.
+.SS "Node Modules"
+.P
+Packages are dropped into the \fBnode_modules\fR folder under the \fBprefix\fR. When installing locally, this means that you can \fBrequire("packagename")\fR to load its main module, or \fBrequire("packagename/lib/path/to/sub/module")\fR to load other modules.
+.P
+Global installs on Unix systems go to \fB{prefix}/lib/node_modules\fR. Global installs on Windows go to \fB{prefix}/node_modules\fR (that is, no \fBlib\fR folder.)
+.P
+Scoped packages are installed the same way, except they are grouped together in a sub-folder of the relevant \fBnode_modules\fR folder with the name of that scope prefix by the @ symbol, e.g. \fBnpm install @myorg/package\fR would place the package in \fB{prefix}/node_modules/@myorg/package\fR. See npm help scope for more details.
+.P
+If you wish to \fBrequire()\fR a package, then install it locally.
+.SS "Executables"
+.P
+When in global mode, executables are linked into \fB{prefix}/bin\fR on Unix, or directly into \fB{prefix}\fR on Windows. Ensure that path is in your terminal's \fBPATH\fR environment to run them.
+.P
+When in local mode, executables are linked into \fB./node_modules/.bin\fR so that they can be made available to scripts run through npm. (For example, so that a test runner will be in the path when you run \fBnpm test\fR.)
+.SS "Man Pages"
+.P
+When in global mode, man pages are linked into \fB{prefix}/share/man\fR.
+.P
+When in local mode, man pages are not installed.
+.P
+Man pages are not installed on Windows systems.
+.SS "Cache"
+.P
+See npm help cache. Cache files are stored in \fB~/.npm\fR on Posix, or \fB%LocalAppData%/npm-cache\fR on Windows.
+.P
+This is controlled by the \fB\[rs]fBcache\[rs]fR config\fR \fI\(la/using-npm/config#cache\(ra\fR param.
+.SS "More Information"
+.P
+When installing locally, npm first tries to find an appropriate \fBprefix\fR folder. This is so that \fBnpm install foo@1.2.3\fR will install to the sensible root of your package, even if you happen to have \fBcd\fRed into some other folder.
+.P
+Starting at the $PWD, npm will walk up the folder tree checking for a folder that contains either a \fBpackage.json\fR file, or a \fBnode_modules\fR folder. If such a thing is found, then that is treated as the effective "current directory" for the purpose of running npm commands. (This behavior is inspired by and similar to git's .git-folder seeking logic when running git commands in a working dir.)
+.P
+If no package root is found, then the current folder is used.
+.P
+When you run \fBnpm install foo@1.2.3\fR, then the package is loaded into the cache, and then unpacked into \fB./node_modules/foo\fR. Then, any of foo's dependencies are similarly unpacked into \fB./node_modules/foo/node_modules/...\fR.
+.P
+Any bin files are symlinked to \fB./node_modules/.bin/\fR, so that they may be found by npm scripts when necessary.
+.SS "Global Installation"
+.P
+If the \fB\[rs]fBglobal\[rs]fR config\fR \fI\(la/using-npm/config#global\(ra\fR is set to true, then npm will install packages "globally".
+.P
+For global installation, packages are installed roughly the same way, but using the folders described above.
+.SS "Cycles, Conflicts, and Folder Parsimony"
+.P
+Cycles are handled using the property of node's module system that it walks up the directories looking for \fBnode_modules\fR folders. So, at every stage, if a package is already installed in an ancestor \fBnode_modules\fR folder, then it is not installed at the current location.
+.P
+Consider the case above, where \fBfoo -> bar -> baz\fR. Imagine if, in addition to that, baz depended on bar, so you'd have: \fBfoo -> bar -> baz -> bar -> baz ...\fR. However, since the folder structure is: \fBfoo/node_modules/bar/node_modules/baz\fR, there's no need to put another copy of bar into \fB.../baz/node_modules\fR, since when baz calls \fBrequire("bar")\fR, it will get the copy that is installed in \fBfoo/node_modules/bar\fR.
+.P
+This shortcut is only used if the exact same version would be installed in multiple nested \fBnode_modules\fR folders. It is still possible to have \fBa/node_modules/b/node_modules/a\fR if the two "a" packages are different versions. However, without repeating the exact same package multiple times, an infinite regress will always be prevented.
+.P
+Another optimization can be made by installing dependencies at the highest level possible, below the localized "target" folder (hoisting). Since version 3, npm hoists dependencies by default.
+.SS "Example"
+.P
+Consider this dependency graph:
+.P
+.RS 2
+.nf
+foo
++-- blerg@1.2.5
++-- bar@1.2.3
+|   +-- blerg@1.x (latest=1.3.7)
+|   +-- baz@2.x
+|   |   `-- quux@3.x
+|   |       `-- bar@1.2.3 (cycle)
+|   `-- asdf@*
+`-- baz@1.2.3
+    `-- quux@3.x
+        `-- bar
+.fi
+.RE
+.P
+In this case, we might expect a folder structure like this (with all dependencies hoisted to the highest level possible):
+.P
+.RS 2
+.nf
+foo
++-- node_modules
+    +-- blerg (1.2.5) <---\[lB]A\[rB]
+    +-- bar (1.2.3) <---\[lB]B\[rB]
+    |   +-- node_modules
+    |       +-- baz (2.0.2) <---\[lB]C\[rB]
+    +-- asdf (2.3.4)
+    +-- baz (1.2.3) <---\[lB]D\[rB]
+    +-- quux (3.2.0) <---\[lB]E\[rB]
+.fi
+.RE
+.P
+Since foo depends directly on \fBbar@1.2.3\fR and \fBbaz@1.2.3\fR, those are installed in foo's \fBnode_modules\fR folder.
+.P
+Even though the latest copy of blerg is 1.3.7, foo has a specific dependency on version 1.2.5. So, that gets installed at \[lB]A\[rB]. Since the parent installation of blerg satisfies bar's dependency on \fBblerg@1.x\fR, it does not install another copy under \[lB]B\[rB].
+.P
+Bar \[lB]B\[rB] also has dependencies on baz and asdf. Because it depends on \fBbaz@2.x\fR, it cannot re-use the \fBbaz@1.2.3\fR installed in the parent \fBnode_modules\fR folder \[lB]D\[rB], and must install its own copy \[lB]C\[rB]. In order to minimize duplication, npm hoists dependencies to the top level by default, so asdf is installed under \[lB]A\[rB].
+.P
+Underneath bar, the \fBbaz -> quux -> bar\fR dependency creates a cycle. However, because bar is already in quux's ancestry \[lB]B\[rB], it does not unpack another copy of bar into that folder. Likewise, quux's \[lB]E\[rB] folder tree is empty, because its dependency on bar is satisfied by the parent folder copy installed at \[lB]B\[rB].
+.P
+For a graphical breakdown of what is installed where, use \fBnpm ls\fR.
+.SS "Publishing"
+.P
+Upon publishing, npm will look in the \fBnode_modules\fR folder. If any of the items there are not in the \fBbundleDependencies\fR array, then they will not be included in the package tarball.
+.P
+This allows a package maintainer to install all of their dependencies (and dev dependencies) locally, but only re-publish those items that cannot be found elsewhere. See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more information.
+.SS "See also"
+.RS 0
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help pack
+.IP \(bu 4
+npm help cache
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help publish
+.RE 0
diff --git a/node/node_modules/npm/man/man5/install.5 b/node/node_modules/npm/man/man5/install.5
new file mode 100644
index 0000000000000000000000000000000000000000..84e3465f3f1fc95253f3e70f1850c691de1d486d
--- /dev/null
+++ b/node/node_modules/npm/man/man5/install.5
@@ -0,0 +1,54 @@
+.TH "INSTALL" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBInstall\fR - Download and install node and npm
+.SS "Description"
+.P
+To publish and install packages to and from the public npm registry, you must install Node.js and the npm command line interface using either a Node version manager or a Node installer. \fBWe strongly recommend using a Node version manager to install Node.js and npm.\fR We do not recommend using a Node installer, since the Node installation process installs npm in a directory with local permissions and can cause permissions errors when you run npm packages globally.
+.SS "Overview"
+.RS 0
+.IP \(bu 4
+\fI(Checking your version of npm and Node.js)\fR
+.IP \(bu 4
+\fI(Using a Node version manager to install Node.js and npm)\fR
+.IP \(bu 4
+\fI(Using a Node installer to install Node.js and npm)\fR
+.RE 0
+
+.SS "Checking your version of npm and Node.js"
+.P
+To see if you already have Node.js and npm installed and check the installed version, run the following commands:
+.P
+.RS 2
+.nf
+node -v
+npm -v
+.fi
+.RE
+.SS "Using a Node version manager to install Node.js and npm"
+.P
+Node version managers allow you to install and switch between multiple versions of Node.js and npm on your system so you can test your applications on multiple versions of npm to ensure they work for users on different versions. You can \fBsearch for them on GitHub\fR \fI\(lahttps://github.com/search?q=node+version+manager+archived%3Afalse&type=repositories&ref=advsearch\(ra\fR.
+.SS "Using a Node installer to install Node.js and npm"
+.P
+If you are unable to use a Node version manager, you can use a Node installer to install both Node.js and npm on your system.
+.RS 0
+.IP \(bu 4
+\fBNode.js installer\fR \fI\(lahttps://nodejs.org/en/download/\(ra\fR
+.IP \(bu 4
+\fBNodeSource installer\fR \fI\(lahttps://github.com/nodesource/distributions\(ra\fR. If you use Linux, we recommend that you use a NodeSource installer.
+.RE 0
+
+.SS "macOS or Windows Node installers"
+.P
+If you're using macOS or Windows, use one of the installers from the \fBNode.js download page\fR \fI\(lahttps://nodejs.org/en/download/\(ra\fR. Be sure to install the version labeled \fBLTS\fR. Other versions have not yet been tested with npm.
+.SS "Linux or other operating systems Node installers"
+.P
+If you're using Linux or another operating system, use one of the following installers:
+.RS 0
+.IP \(bu 4
+\fBNodeSource installer\fR \fI\(lahttps://github.com/nodesource/distributions\(ra\fR (recommended)
+.IP \(bu 4
+One of the installers on the \fBNode.js download page\fR \fI\(lahttps://nodejs.org/en/download/\(ra\fR
+.RE 0
+
+.P
+Or see \fBthis page\fR \fI\(lahttps://nodejs.org/en/download/package-manager/\(ra\fR to install npm for Linux in the way many Linux developers prefer.
diff --git a/node/node_modules/npm/man/man5/npm-global.5 b/node/node_modules/npm/man/man5/npm-global.5
new file mode 100644
index 0000000000000000000000000000000000000000..4332feeaeb9acfddbaab7dd5d0fcfa27dde2bfad
--- /dev/null
+++ b/node/node_modules/npm/man/man5/npm-global.5
@@ -0,0 +1,147 @@
+.TH "FOLDERS" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBFolders\fR - Folder structures used by npm
+.SS "Description"
+.P
+npm puts various things on your computer. That's its job.
+.P
+This document will tell you what it puts where.
+.SS "tl;dr"
+.RS 0
+.IP \(bu 4
+Local install (default): puts stuff in \fB./node_modules\fR of the current package root.
+.IP \(bu 4
+Global install (with \fB-g\fR): puts stuff in /usr/local or wherever node is installed.
+.IP \(bu 4
+Install it \fBlocally\fR if you're going to \fBrequire()\fR it.
+.IP \(bu 4
+Install it \fBglobally\fR if you're going to run it on the command line.
+.IP \(bu 4
+If you need both, then install it in both places, or use \fBnpm link\fR.
+.RE 0
+
+.SS "prefix Configuration"
+.P
+The \fB\[rs]fBprefix\[rs]fR config\fR \fI\(la/using-npm/config#prefix\(ra\fR defaults to the location where node is installed. On most systems, this is \fB/usr/local\fR. On Windows, it's \fB%AppData%\[rs]npm\fR. On Unix systems, it's one level up, since node is typically installed at \fB{prefix}/bin/node\fR rather than \fB{prefix}/node.exe\fR.
+.P
+When the \fBglobal\fR flag is set, npm installs things into this prefix. When it is not set, it uses the root of the current package, or the current working directory if not in a package already.
+.SS "Node Modules"
+.P
+Packages are dropped into the \fBnode_modules\fR folder under the \fBprefix\fR. When installing locally, this means that you can \fBrequire("packagename")\fR to load its main module, or \fBrequire("packagename/lib/path/to/sub/module")\fR to load other modules.
+.P
+Global installs on Unix systems go to \fB{prefix}/lib/node_modules\fR. Global installs on Windows go to \fB{prefix}/node_modules\fR (that is, no \fBlib\fR folder.)
+.P
+Scoped packages are installed the same way, except they are grouped together in a sub-folder of the relevant \fBnode_modules\fR folder with the name of that scope prefix by the @ symbol, e.g. \fBnpm install @myorg/package\fR would place the package in \fB{prefix}/node_modules/@myorg/package\fR. See npm help scope for more details.
+.P
+If you wish to \fBrequire()\fR a package, then install it locally.
+.SS "Executables"
+.P
+When in global mode, executables are linked into \fB{prefix}/bin\fR on Unix, or directly into \fB{prefix}\fR on Windows. Ensure that path is in your terminal's \fBPATH\fR environment to run them.
+.P
+When in local mode, executables are linked into \fB./node_modules/.bin\fR so that they can be made available to scripts run through npm. (For example, so that a test runner will be in the path when you run \fBnpm test\fR.)
+.SS "Man Pages"
+.P
+When in global mode, man pages are linked into \fB{prefix}/share/man\fR.
+.P
+When in local mode, man pages are not installed.
+.P
+Man pages are not installed on Windows systems.
+.SS "Cache"
+.P
+See npm help cache. Cache files are stored in \fB~/.npm\fR on Posix, or \fB%LocalAppData%/npm-cache\fR on Windows.
+.P
+This is controlled by the \fB\[rs]fBcache\[rs]fR config\fR \fI\(la/using-npm/config#cache\(ra\fR param.
+.SS "More Information"
+.P
+When installing locally, npm first tries to find an appropriate \fBprefix\fR folder. This is so that \fBnpm install foo@1.2.3\fR will install to the sensible root of your package, even if you happen to have \fBcd\fRed into some other folder.
+.P
+Starting at the $PWD, npm will walk up the folder tree checking for a folder that contains either a \fBpackage.json\fR file, or a \fBnode_modules\fR folder. If such a thing is found, then that is treated as the effective "current directory" for the purpose of running npm commands. (This behavior is inspired by and similar to git's .git-folder seeking logic when running git commands in a working dir.)
+.P
+If no package root is found, then the current folder is used.
+.P
+When you run \fBnpm install foo@1.2.3\fR, then the package is loaded into the cache, and then unpacked into \fB./node_modules/foo\fR. Then, any of foo's dependencies are similarly unpacked into \fB./node_modules/foo/node_modules/...\fR.
+.P
+Any bin files are symlinked to \fB./node_modules/.bin/\fR, so that they may be found by npm scripts when necessary.
+.SS "Global Installation"
+.P
+If the \fB\[rs]fBglobal\[rs]fR config\fR \fI\(la/using-npm/config#global\(ra\fR is set to true, then npm will install packages "globally".
+.P
+For global installation, packages are installed roughly the same way, but using the folders described above.
+.SS "Cycles, Conflicts, and Folder Parsimony"
+.P
+Cycles are handled using the property of node's module system that it walks up the directories looking for \fBnode_modules\fR folders. So, at every stage, if a package is already installed in an ancestor \fBnode_modules\fR folder, then it is not installed at the current location.
+.P
+Consider the case above, where \fBfoo -> bar -> baz\fR. Imagine if, in addition to that, baz depended on bar, so you'd have: \fBfoo -> bar -> baz -> bar -> baz ...\fR. However, since the folder structure is: \fBfoo/node_modules/bar/node_modules/baz\fR, there's no need to put another copy of bar into \fB.../baz/node_modules\fR, since when baz calls \fBrequire("bar")\fR, it will get the copy that is installed in \fBfoo/node_modules/bar\fR.
+.P
+This shortcut is only used if the exact same version would be installed in multiple nested \fBnode_modules\fR folders. It is still possible to have \fBa/node_modules/b/node_modules/a\fR if the two "a" packages are different versions. However, without repeating the exact same package multiple times, an infinite regress will always be prevented.
+.P
+Another optimization can be made by installing dependencies at the highest level possible, below the localized "target" folder (hoisting). Since version 3, npm hoists dependencies by default.
+.SS "Example"
+.P
+Consider this dependency graph:
+.P
+.RS 2
+.nf
+foo
++-- blerg@1.2.5
++-- bar@1.2.3
+|   +-- blerg@1.x (latest=1.3.7)
+|   +-- baz@2.x
+|   |   `-- quux@3.x
+|   |       `-- bar@1.2.3 (cycle)
+|   `-- asdf@*
+`-- baz@1.2.3
+    `-- quux@3.x
+        `-- bar
+.fi
+.RE
+.P
+In this case, we might expect a folder structure like this (with all dependencies hoisted to the highest level possible):
+.P
+.RS 2
+.nf
+foo
++-- node_modules
+    +-- blerg (1.2.5) <---\[lB]A\[rB]
+    +-- bar (1.2.3) <---\[lB]B\[rB]
+    |   +-- node_modules
+    |       +-- baz (2.0.2) <---\[lB]C\[rB]
+    +-- asdf (2.3.4)
+    +-- baz (1.2.3) <---\[lB]D\[rB]
+    +-- quux (3.2.0) <---\[lB]E\[rB]
+.fi
+.RE
+.P
+Since foo depends directly on \fBbar@1.2.3\fR and \fBbaz@1.2.3\fR, those are installed in foo's \fBnode_modules\fR folder.
+.P
+Even though the latest copy of blerg is 1.3.7, foo has a specific dependency on version 1.2.5. So, that gets installed at \[lB]A\[rB]. Since the parent installation of blerg satisfies bar's dependency on \fBblerg@1.x\fR, it does not install another copy under \[lB]B\[rB].
+.P
+Bar \[lB]B\[rB] also has dependencies on baz and asdf. Because it depends on \fBbaz@2.x\fR, it cannot re-use the \fBbaz@1.2.3\fR installed in the parent \fBnode_modules\fR folder \[lB]D\[rB], and must install its own copy \[lB]C\[rB]. In order to minimize duplication, npm hoists dependencies to the top level by default, so asdf is installed under \[lB]A\[rB].
+.P
+Underneath bar, the \fBbaz -> quux -> bar\fR dependency creates a cycle. However, because bar is already in quux's ancestry \[lB]B\[rB], it does not unpack another copy of bar into that folder. Likewise, quux's \[lB]E\[rB] folder tree is empty, because its dependency on bar is satisfied by the parent folder copy installed at \[lB]B\[rB].
+.P
+For a graphical breakdown of what is installed where, use \fBnpm ls\fR.
+.SS "Publishing"
+.P
+Upon publishing, npm will look in the \fBnode_modules\fR folder. If any of the items there are not in the \fBbundleDependencies\fR array, then they will not be included in the package tarball.
+.P
+This allows a package maintainer to install all of their dependencies (and dev dependencies) locally, but only re-publish those items that cannot be found elsewhere. See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more information.
+.SS "See also"
+.RS 0
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help pack
+.IP \(bu 4
+npm help cache
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help publish
+.RE 0
diff --git a/node/node_modules/npm/man/man5/npm-json.5 b/node/node_modules/npm/man/man5/npm-json.5
new file mode 100644
index 0000000000000000000000000000000000000000..86f1452b5898b22d0b01cf5525e1759593cefe8c
--- /dev/null
+++ b/node/node_modules/npm/man/man5/npm-json.5
@@ -0,0 +1,1255 @@
+.TH "PACKAGE.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBpackage.json\fR - Specifics of npm's package.json handling
+.SS "Description"
+.P
+This document is all you need to know about what's required in your package.json file. It must be actual JSON, not just a JavaScript object literal.
+.P
+A lot of the behavior described in this document is affected by the config settings described in npm help config.
+.SS "name"
+.P
+If you plan to publish your package, the \fImost\fR important things in your package.json are the name and version fields as they will be required. The name and version together form an identifier that is assumed to be completely unique. Changes to the package should come along with changes to the version. If you don't plan to publish your package, the name and version fields are optional.
+.P
+The name is what your thing is called.
+.P
+Some rules:
+.RS 0
+.IP \(bu 4
+The name must be less than or equal to 214 characters. This includes the scope for scoped packages.
+.IP \(bu 4
+The names of scoped packages can begin with a dot or an underscore. This is not permitted without a scope.
+.IP \(bu 4
+New packages must not have uppercase letters in the name.
+.IP \(bu 4
+The name ends up being part of a URL, an argument on the command line, and a folder name. Therefore, the name can't contain any non-URL-safe characters.
+.RE 0
+
+.P
+Some tips:
+.RS 0
+.IP \(bu 4
+Don't use the same name as a core Node module.
+.IP \(bu 4
+Don't put "js" or "node" in the name. It's assumed that it's js, since you're writing a package.json file, and you can specify the engine using the "\fI(engines)\fR" field. (See below.)
+.IP \(bu 4
+The name will probably be passed as an argument to require(), so it should be something short, but also reasonably descriptive.
+.IP \(bu 4
+You may want to check the npm registry to see if there's something by that name already, before you get too attached to it. \fI\(lahttps://www.npmjs.com/\(ra\fR
+.RE 0
+
+.P
+A name can be optionally prefixed by a scope, e.g. \fB@npm/example\fR. See npm help scope for more detail.
+.SS "version"
+.P
+If you plan to publish your package, the \fImost\fR important things in your package.json are the name and version fields as they will be required. The name and version together form an identifier that is assumed to be completely unique. Changes to the package should come along with changes to the version. If you don't plan to publish your package, the name and version fields are optional.
+.P
+Version must be parseable by \fBnode-semver\fR \fI\(lahttps://github.com/npm/node-semver\(ra\fR, which is bundled with npm as a dependency. (\fBnpm install semver\fR to use it yourself.)
+.SS "description"
+.P
+Put a description in it. It's a string. This helps people discover your package, as it's listed in \fBnpm search\fR.
+.SS "keywords"
+.P
+Put keywords in it. It's an array of strings. This helps people discover your package as it's listed in \fBnpm search\fR.
+.P
+Example:
+.P
+.RS 2
+.nf
+"keywords": \[lB]
+  "node",
+  "javascript",
+  "npm"
+\[rB]
+.fi
+.RE
+.SS "homepage"
+.P
+The URL to the project homepage.
+.P
+Example:
+.P
+.RS 2
+.nf
+"homepage": "https://github.com/npm/example#readme"
+.fi
+.RE
+.SS "bugs"
+.P
+The URL to your project's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your package.
+.P
+It should look like this:
+.P
+.RS 2
+.nf
+{
+  "bugs": {
+    "url": "https://github.com/npm/example/issues",
+    "email": "example@npmjs.com"
+  }
+}
+.fi
+.RE
+.P
+You can specify either one or both values. If you want to provide only a URL, you can specify the value for "bugs" as a simple string instead of an object.
+.P
+If a URL is provided, it will be used by the \fBnpm bugs\fR command.
+.SS "license"
+.P
+You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
+.P
+If you're using a common license such as BSD-2-Clause or MIT, add a current SPDX license identifier for the license you're using, like this:
+.P
+.RS 2
+.nf
+{
+  "license" : "BSD-3-Clause"
+}
+.fi
+.RE
+.P
+You can check \fBthe full list of SPDX license IDs\fR \fI\(lahttps://spdx.org/licenses/\(ra\fR. Ideally, you should pick one that is \fBOSI\fR \fI\(lahttps://opensource.org/licenses/\(ra\fR approved.
+.P
+If your package is licensed under multiple common licenses, use an \fBSPDX license expression syntax version 2.0 string\fR \fI\(lahttps://spdx.dev/specifications/\(ra\fR, like this:
+.P
+.RS 2
+.nf
+{
+  "license" : "(ISC OR GPL-3.0)"
+}
+.fi
+.RE
+.P
+If you are using a license that hasn't been assigned an SPDX identifier, or if you are using a custom license, use a string value like this one:
+.P
+.RS 2
+.nf
+{
+  "license" : "SEE LICENSE IN <filename>"
+}
+.fi
+.RE
+.P
+Then include a file named \fB<filename>\fR at the top level of the package.
+.P
+Some old packages used license objects or a "licenses" property containing an array of license objects:
+.P
+.RS 2
+.nf
+// Not valid metadata
+{
+  "license" : {
+    "type" : "ISC",
+    "url" : "https://opensource.org/licenses/ISC"
+  }
+}
+
+// Not valid metadata
+{
+  "licenses" : \[lB]
+    {
+      "type": "MIT",
+      "url": "https://www.opensource.org/licenses/mit-license.php"
+    },
+    {
+      "type": "Apache-2.0",
+      "url": "https://opensource.org/licenses/apache2.0.php"
+    }
+  \[rB]
+}
+.fi
+.RE
+.P
+Those styles are now deprecated. Instead, use SPDX expressions, like this:
+.P
+.RS 2
+.nf
+{
+  "license": "ISC"
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "license": "(MIT OR Apache-2.0)"
+}
+.fi
+.RE
+.P
+Finally, if you do not wish to grant others the right to use a private or unpublished package under any terms:
+.P
+.RS 2
+.nf
+{
+  "license": "UNLICENSED"
+}
+.fi
+.RE
+.P
+Consider also setting \fB"private": true\fR to prevent accidental publication.
+.SS "people fields: author, contributors"
+.P
+The "author" is one person. "contributors" is an array of people. A "person" is an object with a "name" field and optionally "url" and "email", like this:
+.P
+.RS 2
+.nf
+{
+  "name" : "Barney Rubble",
+  "email" : "barney@npmjs.com",
+  "url" : "http://barnyrubble.npmjs.com/"
+}
+.fi
+.RE
+.P
+Or you can shorten that all into a single string, and npm will parse it for you:
+.P
+.RS 2
+.nf
+{
+  "author": "Barney Rubble <barney@npmjs.com> (http://barnyrubble.npmjs.com/)"
+}
+.fi
+.RE
+.P
+Both email and url are optional either way.
+.P
+npm also sets a top-level "maintainers" field with your npm user info.
+.SS "funding"
+.P
+You can specify an object containing a URL that provides up-to-date information about ways to help fund development of your package, a string URL, or an array of objects and string URLs:
+.P
+.RS 2
+.nf
+{
+  "funding": {
+    "type" : "individual",
+    "url" : "http://npmjs.com/donate"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "funding": {
+    "type" : "patreon",
+    "url" : "https://www.patreon.com/user"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "funding": "http://npmjs.com/donate"
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "funding": \[lB]
+    {
+      "type" : "individual",
+      "url" : "http://npmjs.com/donate"
+    },
+    "http://npmjs.com/donate-also",
+    {
+      "type" : "patreon",
+      "url" : "https://www.patreon.com/user"
+    }
+  \[rB]
+}
+.fi
+.RE
+.P
+Users can use the \fBnpm fund\fR subcommand to list the \fBfunding\fR URLs of all dependencies of their project, direct and indirect. A shortcut to visit each funding URL is also available when providing the project name such as: \fBnpm fund <projectname>\fR (when there are multiple URLs, the first one will be visited)
+.SS "files"
+.P
+The optional \fBfiles\fR field is an array of file patterns that describes the entries to be included when your package is installed as a dependency. File patterns follow a similar syntax to \fB.gitignore\fR, but reversed: including a file, directory, or glob pattern (\fB*\fR, \fB**/*\fR, and such) will make it so that file is included in the tarball when it's packed. Omitting the field will make it default to \fB\[lB]"*"\[rB]\fR, which means it will include all files.
+.P
+Some special files and directories are also included or excluded regardless of whether they exist in the \fBfiles\fR array (see below).
+.P
+You can also provide a \fB.npmignore\fR file in the root of your package or in subdirectories, which will keep files from being included. At the root of your package it will not override the "files" field, but in subdirectories it will. The \fB.npmignore\fR file works just like a \fB.gitignore\fR. If there is a \fB.gitignore\fR file, and \fB.npmignore\fR is missing, \fB.gitignore\fR's contents will be used instead.
+.P
+Certain files are always included, regardless of settings:
+.RS 0
+.IP \(bu 4
+\fBpackage.json\fR
+.IP \(bu 4
+\fBREADME\fR
+.IP \(bu 4
+\fBLICENSE\fR / \fBLICENCE\fR
+.IP \(bu 4
+The file in the "main" field
+.IP \(bu 4
+The file(s) in the "bin" field
+.RE 0
+
+.P
+\fBREADME\fR & \fBLICENSE\fR can have any case and extension.
+.P
+Some files are always ignored by default:
+.RS 0
+.IP \(bu 4
+\fB*.orig\fR
+.IP \(bu 4
+\fB.*.swp\fR
+.IP \(bu 4
+\fB.DS_Store\fR
+.IP \(bu 4
+\fB._*\fR
+.IP \(bu 4
+\fB.git\fR
+.IP \(bu 4
+\fB.hg\fR
+.IP \(bu 4
+\fB.lock-wscript\fR
+.IP \(bu 4
+\fB.npmrc\fR
+.IP \(bu 4
+\fB.svn\fR
+.IP \(bu 4
+\fB.wafpickle-N\fR
+.IP \(bu 4
+\fBCVS\fR
+.IP \(bu 4
+\fBconfig.gypi\fR
+.IP \(bu 4
+\fBnode_modules\fR
+.IP \(bu 4
+\fBnpm-debug.log\fR
+.IP \(bu 4
+\fBpackage-lock.json\fR (use \fB\[rs]fBnpm-shrinkwrap.json\[rs]fR\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR if you wish it to be published)
+.IP \(bu 4
+\fBpnpm-lock.yaml\fR
+.IP \(bu 4
+\fByarn.lock\fR
+.IP \(bu 4
+\fBbun.lockb\fR
+.RE 0
+
+.P
+Most of these ignored files can be included specifically if included in the \fBfiles\fR globs. Exceptions to this are:
+.RS 0
+.IP \(bu 4
+\fB.git\fR
+.IP \(bu 4
+\fB.npmrc\fR
+.IP \(bu 4
+\fBnode_modules\fR
+.IP \(bu 4
+\fBpackage-lock.json\fR
+.IP \(bu 4
+\fBpnpm-lock.yaml\fR
+.IP \(bu 4
+\fByarn.lock\fR
+.IP \(bu 4
+\fBbun.lockb\fR
+.RE 0
+
+.P
+These cannot be included.
+.SS "exports"
+.P
+The "exports" provides a modern alternative to "main" allowing multiple entry points to be defined, conditional entry resolution support between environments, and preventing any other entry points besides those defined in "exports". This encapsulation allows module authors to clearly define the public interface for their package. For more details see the \fBnode.js documentation on package entry points\fR \fI\(lahttps://nodejs.org/api/packages.html#package-entry-points\(ra\fR
+.SS "main"
+.P
+The main field is a module ID that is the primary entry point to your program. That is, if your package is named \fBfoo\fR, and a user installs it, and then does \fBrequire("foo")\fR, then your main module's exports object will be returned.
+.P
+This should be a module relative to the root of your package folder.
+.P
+For most modules, it makes the most sense to have a main script and often not much else.
+.P
+If \fBmain\fR is not set, it defaults to \fBindex.js\fR in the package's root folder.
+.SS "type"
+.P
+The \fBtype\fR field defines how Node.js should interpret \fB.js\fR files in your package. This field is not used by npm.
+.P
+See the \fBNode.js documentation on the type field\fR \fI\(lahttps://nodejs.org/api/packages.html#type\(ra\fR for more information.
+.SS "browser"
+.P
+If your module is meant to be used client-side the browser field should be used instead of the main field. This is helpful to hint users that it might rely on primitives that aren't available in Node.js modules. (e.g. \fBwindow\fR)
+.SS "bin"
+.P
+A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)
+.P
+To use this, supply a \fBbin\fR field in your package.json which is a map of command name to local file name. When this package is installed globally, that file will be either linked inside the global bins directory or a cmd (Windows Command File) will be created which executes the specified file in the \fBbin\fR field, so it is available to run by \fBname\fR or \fBname.cmd\fR (on Windows PowerShell). When this package is installed as a dependency in another package, the file will be linked where it will be available to that package either directly by \fBnpm exec\fR or by name in other scripts when invoking them via \fBnpm run\fR.
+.P
+For example, myapp could have this:
+.P
+.RS 2
+.nf
+{
+  "bin": {
+    "myapp": "bin/cli.js"
+  }
+}
+.fi
+.RE
+.P
+So, when you install myapp, in case of unix-like OS it'll create a symlink from the \fBcli.js\fR script to \fB/usr/local/bin/myapp\fR and in case of windows it will create a cmd file usually at \fBC:\[rs]Users\[rs]{Username}\[rs]AppData\[rs]Roaming\[rs]npm\[rs]myapp.cmd\fR which runs the \fBcli.js\fR script.
+.P
+If you have a single executable, and its name should be the name of the package, then you can just supply it as a string. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": "path/to/program"
+}
+.fi
+.RE
+.P
+would be the same as this:
+.P
+.RS 2
+.nf
+{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": {
+    "my-program": "path/to/program"
+  }
+}
+.fi
+.RE
+.P
+Please make sure that your file(s) referenced in \fBbin\fR starts with \fB#!/usr/bin/env node\fR; otherwise, the scripts are started without the node executable!
+.P
+Note that you can also set the executable files using \fI(directories.bin)\fR.
+.P
+See \fBfolders\fR \fI\(la/configuring-npm/folders#executables\(ra\fR for more info on executables.
+.SS "man"
+.P
+Specify either a single file or an array of filenames to put in place for the \fBman\fR program to find.
+.P
+If only a single file is provided, then it's installed such that it is the result from \fBman <pkgname>\fR, regardless of its actual filename. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": "./man/doc.1"
+}
+.fi
+.RE
+.P
+would link the \fB./man/doc.1\fR file in such that it is the target for \fBman foo\fR
+.P
+If the filename doesn't start with the package name, then it's prefixed. So, this:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": \[lB]
+    "./man/foo.1",
+    "./man/bar.1"
+  \[rB]
+}
+.fi
+.RE
+.P
+will create files to do \fBman foo\fR and \fBman foo-bar\fR.
+.P
+Man files must end with a number, and optionally a \fB.gz\fR suffix if they are compressed. The number dictates which man section the file is installed into.
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": \[lB]
+    "./man/foo.1",
+    "./man/foo.2"
+  \[rB]
+}
+.fi
+.RE
+.P
+will create entries for \fBman foo\fR and \fBman 2 foo\fR
+.SS "directories"
+.P
+The CommonJS \fBPackages\fR \fI\(lahttp://wiki.commonjs.org/wiki/Packages/1.0\(ra\fR spec details a few ways that you can indicate the structure of your package using a \fBdirectories\fR object. If you look at \fBnpm's package.json\fR \fI\(lahttps://registry.npmjs.org/npm/latest\(ra\fR, you'll see that it has directories for doc, lib, and man.
+.P
+In the future, this information may be used in other creative ways.
+.SS "directories.bin"
+.P
+If you specify a \fBbin\fR directory in \fBdirectories.bin\fR, all the files in that folder will be added.
+.P
+Because of the way the \fBbin\fR directive works, specifying both a \fBbin\fR path and setting \fBdirectories.bin\fR is an error. If you want to specify individual files, use \fBbin\fR, and for all the files in an existing \fBbin\fR directory, use \fBdirectories.bin\fR.
+.SS "directories.man"
+.P
+A folder that is full of man pages. Sugar to generate a "man" array by walking the folder.
+.SS "repository"
+.P
+Specify the place where your code lives. This is helpful for people who want to contribute. If the git repo is on GitHub, then the \fBnpm repo\fR command will be able to find you.
+.P
+Do it like this:
+.P
+.RS 2
+.nf
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git"
+  }
+}
+.fi
+.RE
+.P
+The URL should be a publicly available (perhaps read-only) URL that can be handed directly to a VCS program without any modification. It should not be a URL to an html project page that you put in your browser. It's for computers.
+.P
+For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for \fBnpm install\fR:
+.P
+.RS 2
+.nf
+{
+  "repository": "npm/example",
+
+  "repository": "github:npm/example",
+
+  "repository": "gist:11081aaa281",
+
+  "repository": "bitbucket:user/repo",
+
+  "repository": "gitlab:user/repo"
+}
+.fi
+.RE
+.P
+\fBNote on normalization:\fR When you publish a package, npm normalizes the \fBrepository\fR field to the full object format with a \fBurl\fR property. If you use a shorthand format (like \fB"npm/example"\fR), you'll see a warning during \fBnpm publish\fR indicating that the field was auto-corrected. While the shorthand format currently works, it's recommended to use the full object format in your \fBpackage.json\fR to avoid warnings and ensure future compatibility:
+.P
+.RS 2
+.nf
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/example.git"
+  }
+}
+.fi
+.RE
+.P
+You can run \fBnpm pkg fix\fR to automatically convert shorthand formats to the normalized object format.
+.P
+If the \fBpackage.json\fR for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives:
+.P
+.RS 2
+.nf
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git",
+    "directory": "workspaces/libnpmpublish"
+  }
+}
+.fi
+.RE
+.SS "scripts"
+.P
+The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package. The key is the lifecycle event, and the value is the command to run at that point.
+.P
+See npm help scripts to find out more about writing package scripts.
+.SS "gypfile"
+.P
+If you have a binding.gyp file in the root of your package and you have not defined your own \fBinstall\fR or \fBpreinstall\fR scripts, npm will default to building your module using node-gyp.
+.P
+To prevent npm from automatically building your module with node-gyp, set \fBgypfile\fR to \fBfalse\fR:
+.P
+.RS 2
+.nf
+{
+  "gypfile": false
+}
+.fi
+.RE
+.P
+This is useful for packages that include native addons but want to handle the build process differently, or packages that have a binding.gyp file but should not be built as a native addon.
+.SS "config"
+.P
+A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades. For instance, if a package had the following:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "config": {
+    "port": "8080"
+  }
+}
+.fi
+.RE
+.P
+It could also have a "start" script that referenced the \fBnpm_package_config_port\fR environment variable.
+.SS "dependencies"
+.P
+Dependencies are specified in a simple object that maps a package name to a version range. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or git URL.
+.P
+\fBPlease do not put test harnesses or transpilers or other "development" time tools in your \fBdependencies\fB object.\fR See \fBdevDependencies\fR, below.
+.P
+See \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR for more details about specifying version ranges.
+.RS 0
+.IP \(bu 4
+\fBversion\fR Must match \fBversion\fR exactly
+.IP \(bu 4
+\fB>version\fR Must be greater than \fBversion\fR
+.IP \(bu 4
+\fB>=version\fR etc
+.IP \(bu 4
+\fB<version\fR
+.IP \(bu 4
+\fB<=version\fR
+.IP \(bu 4
+\fB~version\fR "Approximately equivalent to version" See \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR
+.IP \(bu 4
+\fB^version\fR "Compatible with version" See \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR
+.IP \(bu 4
+\fB1.2.x\fR 1.2.0, 1.2.1, etc., but not 1.3.0
+.IP \(bu 4
+\fBhttp://...\fR See 'URLs as Dependencies' below
+.IP \(bu 4
+\fB*\fR Matches any version
+.IP \(bu 4
+\fB""\fR (just an empty string) Same as \fB*\fR
+.IP \(bu 4
+\fBversion1 - version2\fR Same as \fB>=version1 <=version2\fR.
+.IP \(bu 4
+\fBrange1 || range2\fR Passes if either range1 or range2 are satisfied.
+.IP \(bu 4
+\fBgit...\fR See 'Git URLs as Dependencies' below
+.IP \(bu 4
+\fBuser/repo\fR See 'GitHub URLs' below
+.IP \(bu 4
+\fBtag\fR A specific version tagged and published as \fBtag\fR See npm help dist-tag
+.IP \(bu 4
+\fBpath/path/path\fR See \fI(Local Paths)\fR below
+.IP \(bu 4
+\fBnpm:@scope/pkg@version\fR Custom alias for a package See \fB\[rs]fBpackage-spec\[rs]fR\fR \fI\(la/using-npm/package-spec#aliases\(ra\fR
+.RE 0
+
+.P
+For example, these are all valid:
+.P
+.RS 2
+.nf
+{
+  "dependencies": {
+    "foo": "1.0.0 - 2.9999.9999",
+    "bar": ">=1.0.2 <2.1.2",
+    "baz": ">1.0.2 <=2.3.4",
+    "boo": "2.0.1",
+    "qux": "<1.0.0 || >=2.3.1 <2.4.5 || >=2.5.2 <3.0.0",
+    "asd": "http://npmjs.com/example.tar.gz",
+    "til": "~1.2",
+    "elf": "~1.2.3",
+    "two": "2.x",
+    "thr": "3.3.x",
+    "lat": "latest",
+    "dyl": "file:../dyl",
+    "kpg": "npm:pkg@1.0.0"
+  }
+}
+.fi
+.RE
+.SS "URLs as Dependencies"
+.P
+You may specify a tarball URL in place of a version range.
+.P
+This tarball will be downloaded and installed locally to your package at install time.
+.SS "Git URLs as Dependencies"
+.P
+Git URLs are of the form:
+.P
+.RS 2
+.nf
+<protocol>://\[lB]<user>\[lB]:<password>\[rB]@\[rB]<hostname>\[lB]:<port>\[rB]\[lB]:\[rB]\[lB]/\[rB]<path>\[lB]#<commit-ish> | #semver:<semver>\[rB]
+.fi
+.RE
+.P
+\fB<protocol>\fR is one of \fBgit\fR, \fBgit+ssh\fR, \fBgit+http\fR, \fBgit+https\fR, or \fBgit+file\fR.
+.P
+If \fB#<commit-ish>\fR is provided, it will be used to clone exactly that commit. If the commit-ish has the format \fB#semver:<semver>\fR, \fB<semver>\fR can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency. If neither \fB#<commit-ish>\fR or \fB#semver:<semver>\fR is specified, then the default branch is used.
+.P
+Examples:
+.P
+.RS 2
+.nf
+git+ssh://git@github.com:npm/cli.git#v1.0.27
+git+ssh://git@github.com:npm/cli#semver:^5.0
+git+https://isaacs@github.com/npm/cli.git
+git://github.com/npm/cli.git#v1.0.27
+.fi
+.RE
+.P
+When installing from a \fBgit\fR repository, the presence of certain fields in the \fBpackage.json\fR will cause npm to believe it needs to perform a build. To do so your repository will be cloned into a temporary directory, all of its deps installed, relevant scripts run, and the resulting directory packed and installed.
+.P
+This flow will occur if your git dependency uses \fBworkspaces\fR, or if any of the following scripts are present:
+.RS 0
+.IP \(bu 4
+\fBbuild\fR
+.IP \(bu 4
+\fBprepare\fR
+.IP \(bu 4
+\fBprepack\fR
+.IP \(bu 4
+\fBpreinstall\fR
+.IP \(bu 4
+\fBinstall\fR
+.IP \(bu 4
+\fBpostinstall\fR
+.RE 0
+
+.P
+If your git repository includes pre-built artifacts, you will likely want to make sure that none of the above scripts are defined, or your dependency will be rebuilt for every installation.
+.SS "GitHub URLs"
+.P
+As of version 1.1.65, you can refer to GitHub URLs as just "foo": "user/foo-project". Just as with git URLs, a \fBcommit-ish\fR suffix can be included. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "0.0.0",
+  "dependencies": {
+    "express": "expressjs/express",
+    "mocha": "mochajs/mocha#4727d357ea",
+    "module": "npm/example-github-repo#feature\[rs]/branch"
+  }
+}
+.fi
+.RE
+.SS "Local Paths"
+.P
+As of version 2.0.0 you can provide a path to a local directory that contains a package. Local paths can be saved using \fBnpm install -S\fR or \fBnpm install --save\fR, using any of these forms:
+.P
+.RS 2
+.nf
+../foo/bar
+~/foo/bar
+./foo/bar
+/foo/bar
+.fi
+.RE
+.P
+in which case they will be normalized to a relative path and added to your \fBpackage.json\fR. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "baz",
+  "dependencies": {
+    "bar": "file:../foo/bar"
+  }
+}
+.fi
+.RE
+.P
+This feature is helpful for local offline development and creating tests that require npm installing where you don't want to hit an external server, but should not be used when publishing your package to the public registry.
+.P
+\fInote\fR: Packages linked by local path will not have their own dependencies installed when \fBnpm install\fR is run. You must run \fBnpm install\fR from inside the local path itself.
+.SS "devDependencies"
+.P
+If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.
+.P
+In this case, it's best to map these additional items in a \fBdevDependencies\fR object.
+.P
+These things will be installed when doing \fBnpm link\fR or \fBnpm install\fR from the root of a package, and can be managed like any other npm configuration param. See npm help config for more on the topic.
+.P
+For build steps that are not platform-specific, such as compiling CoffeeScript or other languages to JavaScript, use the \fBprepare\fR script to do this, and make the required package a devDependency.
+.P
+For example:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/ethopia-waza",
+  "description": "a delightfully fruity coffee varietal",
+  "version": "1.2.3",
+  "devDependencies": {
+    "coffee-script": "~1.6.3"
+  },
+  "scripts": {
+    "prepare": "coffee -o lib/ -c src/waza.coffee"
+  },
+  "main": "lib/waza.js"
+}
+.fi
+.RE
+.P
+The \fBprepare\fR script will be run before publishing, so that users can consume the functionality without requiring them to compile it themselves. In dev mode (ie, locally running \fBnpm install\fR), it'll run this script as well, so that you can test it easily.
+.SS "peerDependencies"
+.P
+In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a \fBrequire\fR of this host. This is usually referred to as a \fIplugin\fR. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.
+.P
+For example:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x"
+  }
+}
+.fi
+.RE
+.P
+This ensures your package \fB@npm/tea-latte\fR can be installed \fIalong\fR with the second major version of the host package \fB@npm/tea\fR only. \fBnpm install tea-latte\fR could possibly yield the following dependency graph:
+.P
+.RS 2
+.nf
+├── @npm/tea-latte@1.3.5
+└── @npm/tea@2.2.0
+.fi
+.RE
+.P
+In npm versions 3 through 6, \fBpeerDependencies\fR were not automatically installed, and would raise a warning if an invalid version of the peer dependency was found in the tree. As of npm v7, peerDependencies \fIare\fR installed by default.
+.P
+Trying to install another plugin with a conflicting requirement may cause an error if the tree cannot be resolved correctly. For this reason, make sure your plugin requirement is as broad as possible, and not to lock it down to specific patch versions.
+.P
+Assuming the host complies with \fBsemver\fR \fI\(lahttps://semver.org/\(ra\fR, only changes in the host package's major version will break your plugin. Thus, if you've worked with every 1.x version of the host package, use \fB"^1.0"\fR or \fB"1.x"\fR to express this. If you depend on features introduced in 1.5.2, use \fB"^1.5.2"\fR.
+.SS "peerDependenciesMeta"
+.P
+The \fBpeerDependenciesMeta\fR field serves to provide npm more information on how your peer dependencies are to be used. Specifically, it allows peer dependencies to be marked as optional. Npm will not automatically install optional peer dependencies. This allows you to integrate and interact with a variety of host packages without requiring all of them to be installed.
+.P
+For example:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x",
+    "@npm/soy-milk": "1.2"
+  },
+  "peerDependenciesMeta": {
+    "@npm/soy-milk": {
+      "optional": true
+    }
+  }
+}
+.fi
+.RE
+.SS "bundleDependencies"
+.P
+This defines an array of package names that will be bundled when publishing the package.
+.P
+In cases where you need to preserve npm packages locally or have them available through a single file download, you can bundle the packages in a tarball file by specifying the package names in the \fBbundleDependencies\fR array and executing \fBnpm pack\fR.
+.P
+For example:
+.P
+If we define a package.json like this:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/awesome-web-framework",
+  "version": "1.0.0",
+  "bundleDependencies": \[lB]
+    "@npm/renderized",
+    "@npm/super-streams"
+  \[rB]
+}
+.fi
+.RE
+.P
+we can obtain \fB@npm/awesome-web-framework-1.0.0.tgz\fR file by running \fBnpm pack\fR. This file contains the dependencies \fB@npm/renderized\fR and \fB@npm/super-streams\fR which can be installed in a new project by executing \fBnpm install awesome-web-framework-1.0.0.tgz\fR. Note that the package names do not include any versions, as that information is specified in \fBdependencies\fR.
+.P
+If this is spelled \fB"bundledDependencies"\fR, then that is also honored.
+.P
+Alternatively, \fB"bundleDependencies"\fR can be defined as a boolean value. A value of \fBtrue\fR will bundle all dependencies, a value of \fBfalse\fR will bundle none.
+.SS "optionalDependencies"
+.P
+If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the \fBoptionalDependencies\fR object. This is a map of package name to version or URL, just like the \fBdependencies\fR object. The difference is that build failures do not cause installation to fail. Running \fBnpm install --omit=optional\fR will prevent these dependencies from being installed.
+.P
+It is still your program's responsibility to handle the lack of the dependency. For example, something like this:
+.P
+.RS 2
+.nf
+try {
+  var foo = require('@npm/foo')
+  var fooVersion = require('@npm/foo/package.json').version
+} catch (er) {
+  foo = null
+}
+if ( notGoodFooVersion(fooVersion) ) {
+  foo = null
+}
+
+// .. then later in your program ..
+
+if (foo) {
+  foo.doFooThings()
+}
+.fi
+.RE
+.P
+Entries in \fBoptionalDependencies\fR will override entries of the same name in \fBdependencies\fR, so it's usually best to only put in one place.
+.SS "overrides"
+.P
+If you need to make specific changes to dependencies of your dependencies, for example replacing the version of a dependency with a known security issue, replacing an existing dependency with a fork, or making sure that the same version of a package is used everywhere, then you may add an override.
+.P
+Overrides provide a way to replace a package in your dependency tree with another version, or another package entirely. These changes can be scoped as specific or as vague as desired.
+.P
+Overrides are only considered in the root \fBpackage.json\fR file for a project. Overrides in installed dependencies (including npm help workspaces) are not considered in dependency tree resolution. Published packages may dictate their resolutions by pinning dependencies or using an \fB\[rs]fBnpm-shrinkwrap.json\[rs]fR\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR file.
+.P
+To make sure the package \fB@npm/foo\fR is always installed as version \fB1.0.0\fR no matter what version your dependencies rely on:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/foo": "1.0.0"
+  }
+}
+.fi
+.RE
+.P
+The above is a short hand notation, the full object form can be used to allow overriding a package itself as well as a child of the package. This will cause \fB@npm/foo\fR to always be \fB1.0.0\fR while also making \fB@npm/bar\fR at any depth beyond \fB@npm/foo\fR also \fB1.0.0\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/foo": {
+      ".": "1.0.0",
+      "@npm/bar": "1.0.0"
+    }
+  }
+}
+.fi
+.RE
+.P
+To only override \fB@npm/foo\fR to be \fB1.0.0\fR when it's a child (or grandchild, or great grandchild, etc) of the package \fB@npm/bar\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/bar": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+.fi
+.RE
+.P
+Keys can be nested to any arbitrary length. To override \fB@npm/foo\fR only when it's a child of \fB@npm/bar\fR and only when \fB@npm/bar\fR is a child of \fB@npm/baz\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/baz": {
+      "@npm/bar": {
+        "@npm/foo": "1.0.0"
+      }
+    }
+  }
+}
+.fi
+.RE
+.P
+The key of an override can also include a version, or range of versions. To override \fB@npm/foo\fR to \fB1.0.0\fR, but only when it's a child of \fB@npm/bar@2.0.0\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/bar@2.0.0": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+.fi
+.RE
+.P
+You may not set an override for a package that you directly depend on unless both the dependency and the override itself share the exact same spec. To make this limitation easier to deal with, overrides may also be defined as a reference to a spec for a direct dependency by prefixing the name of the package you wish the version to match with a \fB$\fR.
+.P
+.RS 2
+.nf
+{
+  "dependencies": {
+    "@npm/foo": "^1.0.0"
+  },
+  "overrides": {
+    // BAD, will throw an EOVERRIDE error
+    // "foo": "^2.0.0"
+    // GOOD, specs match so override is allowed
+    // "foo": "^1.0.0"
+    // BEST, the override is defined as a reference to the dependency
+    "@npm/foo": "$foo",
+    // the referenced package does not need to match the overridden one
+    "@npm/bar": "$foo"
+  }
+}
+.fi
+.RE
+.SS "Replacing a dependency with a fork"
+.P
+You can replace a package with a different package or fork using several methods:
+.P
+\fBUsing the \fBnpm:\fB prefix to replace with a different package name:\fR
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "package-name": "npm:@scope/forked-package@1.0.0"
+  }
+}
+.fi
+.RE
+.P
+\fBUsing a GitHub repository (supports branches, tags, or commit hashes):\fR
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "package-name": "github:username/repo#branch-name"
+  }
+}
+.fi
+.RE
+.P
+\fBUsing a local file path:\fR
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "package-name": "file:../local-fork"
+  }
+}
+.fi
+.RE
+.P
+These replacement methods work for both top-level overrides and nested overrides. For example, to replace a transitive dependency with a fork:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "parent-package": {
+      "vulnerable-dep": "github:username/patched-fork#v2.0.1"
+    }
+  }
+}
+.fi
+.RE
+.SS "engines"
+.P
+You can specify the version of node that your stuff works on:
+.P
+.RS 2
+.nf
+{
+  "engines": {
+    "node": ">=0.10.3 <15"
+  }
+}
+.fi
+.RE
+.P
+And, like with dependencies, if you don't specify the version (or if you specify "*" as the version), then any version of node will do.
+.P
+You can also use the "engines" field to specify which versions of npm are capable of properly installing your program. For example:
+.P
+.RS 2
+.nf
+{
+  "engines": {
+    "npm": "~1.0.20"
+  }
+}
+.fi
+.RE
+.P
+Unless the user has set the \fB\[rs]fBengine-strict\[rs]fR config\fR \fI\(la/using-npm/config#engine-strict\(ra\fR flag, this field is advisory only and will only produce warnings when your package is installed as a dependency.
+.SS "os"
+.P
+You can specify which operating systems your module will run on:
+.P
+.RS 2
+.nf
+{
+  "os": \[lB]
+    "darwin",
+    "linux"
+  \[rB]
+}
+.fi
+.RE
+.P
+You can also block instead of allowing operating systems, just prepend the blocked os with a '!':
+.P
+.RS 2
+.nf
+{
+  "os": \[lB]
+    "!win32"
+  \[rB]
+}
+.fi
+.RE
+.P
+The host operating system is determined by \fBprocess.platform\fR
+.P
+It is allowed to both block and allow an item, although there isn't any good reason to do this.
+.SS "cpu"
+.P
+If your code only runs on certain cpu architectures, you can specify which ones.
+.P
+.RS 2
+.nf
+{
+  "cpu": \[lB]
+    "x64",
+    "ia32"
+  \[rB]
+}
+.fi
+.RE
+.P
+Like the \fBos\fR option, you can also block architectures:
+.P
+.RS 2
+.nf
+{
+  "cpu": \[lB]
+    "!arm",
+    "!mips"
+  \[rB]
+}
+.fi
+.RE
+.P
+The host architecture is determined by \fBprocess.arch\fR
+.SS "libc"
+.P
+If your code only runs or builds in certain versions of libc, you can specify which ones. This field only applies if \fBos\fR is \fBlinux\fR.
+.P
+.RS 2
+.nf
+{
+  "os": "linux",
+  "libc": "glibc"
+}
+.fi
+.RE
+.SS "devEngines"
+.P
+The \fBdevEngines\fR field aids engineers working on a codebase to all be using the same tooling.
+.P
+You can specify a \fBdevEngines\fR property in your \fBpackage.json\fR which will run before \fBinstall\fR, \fBci\fR, and \fBrun\fR commands.
+.RS 0
+.P
+Note: \fBengines\fR and \fBdevEngines\fR differ in object shape. They also function very differently. \fBengines\fR is designed to alert the user when a dependency uses a different npm or node version than the project it's being used in, whereas \fBdevEngines\fR is used to alert people interacting with the source code of a project.
+.RE 0
+
+.P
+The supported keys under the \fBdevEngines\fR property are \fBcpu\fR, \fBos\fR, \fBlibc\fR, \fBruntime\fR, and \fBpackageManager\fR. Each property can be an object or an array of objects. Objects must contain \fBname\fR, and optionally can specify \fBversion\fR, and \fBonFail\fR. \fBonFail\fR can be \fBwarn\fR, \fBerror\fR, or \fBignore\fR, and if left undefined is of the same value as \fBerror\fR. \fBnpm\fR will assume that you're running with \fBnode\fR. Here's an example of a project that will fail if the environment is not \fBnode\fR and \fBnpm\fR. If you set \fBruntime.name\fR or \fBpackageManager.name\fR to any other string, it will fail within the npm CLI.
+.P
+.RS 2
+.nf
+{
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "onFail": "error"
+    }
+  }
+}
+.fi
+.RE
+.SS "private"
+.P
+If you set \fB"private": true\fR in your package.json, then npm will refuse to publish it.
+.P
+This is a way to prevent accidental publication of private repositories. If you would like to ensure that a given package is only ever published to a specific registry (for example, an internal registry), then use the \fBpublishConfig\fR dictionary described below to override the \fBregistry\fR config param at publish-time.
+.SS "publishConfig"
+.P
+This is a set of config values that will be used at publish-time. It's especially handy if you want to set the tag, registry or access, so that you can ensure that a given package is not tagged with "latest", published to the global public registry or that a scoped module is private by default.
+.P
+See npm help config to see the list of config options that can be overridden.
+.SS "workspaces"
+.P
+The optional \fBworkspaces\fR field is an array of file patterns that describes locations within the local file system that the install client should look up to find each npm help workspace that needs to be symlinked to the top level \fBnode_modules\fR folder.
+.P
+It can describe either the direct paths of the folders to be used as workspaces or it can define globs that will resolve to these same folders.
+.P
+In the following example, all folders located inside the folder \fB./packages\fR will be treated as workspaces as long as they have valid \fBpackage.json\fR files inside them:
+.P
+.RS 2
+.nf
+{
+  "name": "workspace-example",
+  "workspaces": \[lB]
+    "./packages/*"
+  \[rB]
+}
+.fi
+.RE
+.P
+See npm help workspaces for more examples.
+.SS "DEFAULT VALUES"
+.P
+npm will default some values based on package contents.
+.RS 0
+.IP \(bu 4
+\fB"scripts": {"start": "node server.js"}\fR
+.P
+If there is a \fBserver.js\fR file in the root of your package, then npm will default the \fBstart\fR command to \fBnode server.js\fR.
+.IP \(bu 4
+\fB"scripts":{"install": "node-gyp rebuild"}\fR
+.P
+If there is a \fBbinding.gyp\fR file in the root of your package and you have not defined an \fBinstall\fR or \fBpreinstall\fR script, npm will default the \fBinstall\fR command to compile using node-gyp.
+.IP \(bu 4
+\fB"contributors": \[lB]...\[rB]\fR
+.P
+If there is an \fBAUTHORS\fR file in the root of your package, npm will treat each line as a \fBName <email> (url)\fR format, where email and url are optional. Lines which start with a \fB#\fR or are blank, will be ignored.
+.RE 0
+
+.SS "SEE ALSO"
+.RS 0
+.IP \(bu 4
+\fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR
+.IP \(bu 4
+npm help workspaces
+.IP \(bu 4
+npm help init
+.IP \(bu 4
+npm help version
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help help
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help uninstall
+.RE 0
diff --git a/node/node_modules/npm/man/man5/npm-shrinkwrap-json.5 b/node/node_modules/npm/man/man5/npm-shrinkwrap-json.5
new file mode 100644
index 0000000000000000000000000000000000000000..3c1b15867925692363ff2976dfa6b766a62ca112
--- /dev/null
+++ b/node/node_modules/npm/man/man5/npm-shrinkwrap-json.5
@@ -0,0 +1,23 @@
+.TH "NPM-SHRINKWRAP.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBnpm-shrinkwrap.json\fR - A publishable lockfile
+.SS "Description"
+.P
+\fBnpm-shrinkwrap.json\fR is a file created by npm help shrinkwrap. It is identical to \fBpackage-lock.json\fR, with one major caveat: Unlike \fBpackage-lock.json\fR, \fBnpm-shrinkwrap.json\fR may be included when publishing a package.
+.P
+The recommended use-case for \fBnpm-shrinkwrap.json\fR is applications deployed through the publishing process on the registry: for example, daemons and command-line tools intended as global installs or \fBdevDependencies\fR. It's strongly discouraged for library authors to publish this file, since that would prevent end users from having control over transitive dependency updates.
+.P
+If both \fBpackage-lock.json\fR and \fBnpm-shrinkwrap.json\fR are present in a package root, \fBnpm-shrinkwrap.json\fR will be preferred over the \fBpackage-lock.json\fR file.
+.P
+For full details and description of the \fBnpm-shrinkwrap.json\fR file format, refer to the manual page for \fBpackage-lock.json\fR \fI\(la/configuring-npm/package-lock-json\(ra\fR.
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help shrinkwrap
+.IP \(bu 4
+\fBpackage-lock.json\fR \fI\(la/configuring-npm/package-lock-json\(ra\fR
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man5/npmrc.5 b/node/node_modules/npm/man/man5/npmrc.5
new file mode 100644
index 0000000000000000000000000000000000000000..c2dc25b60b9f648ad44efdb59a34af93c909f84f
--- /dev/null
+++ b/node/node_modules/npm/man/man5/npmrc.5
@@ -0,0 +1,195 @@
+.TH ".NPMRC" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fB.npmrc\fR - The npm config files
+.SS "Description"
+.P
+npm gets its config settings from the command line, environment variables, and \fBnpmrc\fR files.
+.P
+The \fBnpm config\fR command can be used to update and edit the contents of the user and global npmrc files.
+.P
+For a list of available configuration options, see npm help config.
+.SS "Files"
+.P
+The four relevant files are:
+.RS 0
+.IP \(bu 4
+per-project config file (\fB/path/to/my/project/.npmrc\fR)
+.IP \(bu 4
+per-user config file (\fB~/.npmrc\fR)
+.IP \(bu 4
+global config file (\fB$PREFIX/etc/npmrc\fR)
+.IP \(bu 4
+npm builtin config file (\fB/path/to/npm/npmrc\fR)
+.RE 0
+
+.P
+All npm config files are an ini-formatted list of \fBkey = value\fR parameters. Environment variables can be replaced using \fB${VARIABLE_NAME}\fR. By default if the variable is not defined, it is left unreplaced. By adding \fB?\fR after variable name they can be forced to evaluate to an empty string instead. For example:
+.P
+.RS 2
+.nf
+cache = ${HOME}/.npm-packages
+node-options = "${NODE_OPTIONS?} --use-system-ca"
+.fi
+.RE
+.P
+Each of these files is loaded, and config options are resolved in priority order. For example, a setting in the userconfig file would override the setting in the globalconfig file.
+.P
+Array values are specified by adding "\[lB]\[rB]" after the key name. For example:
+.P
+.RS 2
+.nf
+key\[lB]\[rB] = "first value"
+key\[lB]\[rB] = "second value"
+.fi
+.RE
+.SS "Comments"
+.P
+Lines in \fB.npmrc\fR files are interpreted as comments when they begin with a \fB;\fR or \fB#\fR character. \fB.npmrc\fR files are parsed by \fBnpm/ini\fR \fI\(lahttps://github.com/npm/ini\(ra\fR, which specifies this comment syntax.
+.P
+For example:
+.P
+.RS 2
+.nf
+# last modified: 01 Jan 2016
+; Set a new registry for a scoped package
+@myscope:registry=https://mycustomregistry.example.org
+.fi
+.RE
+.SS "Per-project config file"
+.P
+When working locally in a project, a \fB.npmrc\fR file in the root of the project (ie, a sibling of \fBnode_modules\fR and \fBpackage.json\fR) will set config values specific to this project.
+.P
+Note that this only applies to the root of the project that you're running npm in. It has no effect when your module is published. For example, you can't publish a module that forces itself to install globally, or in a different location.
+.P
+Additionally, this file is not read in global mode, such as when running \fBnpm install -g\fR.
+.SS "Per-user config file"
+.P
+\fB$HOME/.npmrc\fR (or the \fBuserconfig\fR param, if set in the environment or on the command line)
+.SS "Global config file"
+.P
+\fB$PREFIX/etc/npmrc\fR (or the \fBglobalconfig\fR param, if set above): This file is an ini-file formatted list of \fBkey = value\fR parameters. Environment variables can be replaced as above.
+.SS "Built-in config file"
+.P
+\fBpath/to/npm/itself/npmrc\fR
+.P
+This is an unchangeable "builtin" configuration file that npm keeps consistent across updates. Set fields in here using the \fB./configure\fR script that comes with npm. This is primarily for distribution maintainers to override default configs in a standard and consistent manner.
+.SS "Auth related configuration"
+.P
+The settings \fB_auth\fR, \fB_authToken\fR, \fBusername\fR, \fB_password\fR, \fBcertfile\fR, and \fBkeyfile\fR must all be scoped to a specific registry. This ensures that \fBnpm\fR will never send credentials to the wrong host.
+.P
+The full list is:
+.RS 0
+.IP \(bu 4
+\fB_auth\fR (base64 authentication string)
+.IP \(bu 4
+\fB_authToken\fR (authentication token)
+.IP \(bu 4
+\fBusername\fR
+.IP \(bu 4
+\fB_password\fR
+.IP \(bu 4
+\fBemail\fR
+.IP \(bu 4
+\fBcafile\fR (path to certificate authority file)
+.IP \(bu 4
+\fBcertfile\fR (path to certificate file)
+.IP \(bu 4
+\fBkeyfile\fR (path to key file)
+.RE 0
+
+.P
+In order to scope these values, they must be prefixed by a URI fragment. If the credential is meant for any request to a registry on a single host, the scope may look like \fB//registry.npmjs.org/:\fR. If it must be scoped to a specific path on the host that path may also be provided, such as \fB//my-custom-registry.org/unique/path:\fR.
+.SS "Unsupported Custom Configuration Keys"
+.P
+Starting in npm v11.2.0, npm warns when unknown configuration keys are defined in \fB.npmrc\fR. In a future major version of npm, these unknown keys may no longer be accepted.
+.P
+Only configuration keys that npm officially supports are recognized. Custom keys intended for third-party tools (for example, \fBelectron-builder\fR) should not be placed in \fB.npmrc\fR.
+.P
+If you need package-level configuration for use in scripts, use the \fBconfig\fR field in your \fBpackage.json\fR instead:
+.P
+.RS 2
+.nf
+{
+  "name": "my-package",
+  "config": {
+    "mirror": "https://example.com/"
+  }
+}
+
+.fi
+.RE
+.P
+Values defined in \fBpackage.json#config\fR are exposed to scripts as environment variables prefixed with \fBnpm_package_config_\fR. For example:
+.P
+.RS 2
+.nf
+npm_package_config_mirror
+.fi
+.RE
+.P
+If you need to pass arguments to a script command, use \fB--\fR to separate npm arguments from script arguments:
+.P
+.RS 2
+.nf
+npm run build -- --customFlag
+.fi
+.RE
+.P
+Using environment variables is also recommended for cross-platform configuration instead of defining unsupported keys in \fB.npmrc\fR.
+.P
+.RS 2
+.nf
+; bad config
+_authToken=MYTOKEN
+
+; good config
+@myorg:registry=https://somewhere-else.com/myorg
+@another:registry=https://somewhere-else.com/another
+//registry.npmjs.org/:_authToken=MYTOKEN
+
+; would apply to both @myorg and @another
+//somewhere-else.com/:_authToken=MYTOKEN
+
+; would apply only to @myorg
+//somewhere-else.com/myorg/:_authToken=MYTOKEN1
+
+; would apply only to @another
+//somewhere-else.com/another/:_authToken=MYTOKEN2
+.fi
+.RE
+.SS "Custom / third-party config keys"
+.P
+npm only recognizes its own npm help "configuration options". If your \fB.npmrc\fR contains keys that are not part of npm's config definitions (for example, \fBelectron_mirror\fR or \fBsass_binary_site\fR), npm will emit a warning:
+.P
+.RS 2
+.nf
+warn Unknown user config "electron_mirror".
+This will stop working in the next major version of npm.
+.fi
+.RE
+.P
+These keys were historically tolerated but are not officially supported. A future major version of npm will treat unknown top-level keys as errors.
+.P
+Some tools (such as \fB@electron/get\fR or \fBnode-sass\fR) read their own configuration from environment variables or from \fB.npmrc\fR by convention. You can set these values as environment variables instead:
+.P
+.RS 2
+.nf
+export ELECTRON_MIRROR="https://mirrorexample.npmjs.org/mirrors/electron/"
+export ELECTRON_CUSTOM_DIR="{{ version }}"
+.fi
+.RE
+.P
+Environment variables are the most portable approach and work regardless of \fB.npmrc\fR format.
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help npm
+.RE 0
diff --git a/node/node_modules/npm/man/man5/package-json.5 b/node/node_modules/npm/man/man5/package-json.5
new file mode 100644
index 0000000000000000000000000000000000000000..86f1452b5898b22d0b01cf5525e1759593cefe8c
--- /dev/null
+++ b/node/node_modules/npm/man/man5/package-json.5
@@ -0,0 +1,1255 @@
+.TH "PACKAGE.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBpackage.json\fR - Specifics of npm's package.json handling
+.SS "Description"
+.P
+This document is all you need to know about what's required in your package.json file. It must be actual JSON, not just a JavaScript object literal.
+.P
+A lot of the behavior described in this document is affected by the config settings described in npm help config.
+.SS "name"
+.P
+If you plan to publish your package, the \fImost\fR important things in your package.json are the name and version fields as they will be required. The name and version together form an identifier that is assumed to be completely unique. Changes to the package should come along with changes to the version. If you don't plan to publish your package, the name and version fields are optional.
+.P
+The name is what your thing is called.
+.P
+Some rules:
+.RS 0
+.IP \(bu 4
+The name must be less than or equal to 214 characters. This includes the scope for scoped packages.
+.IP \(bu 4
+The names of scoped packages can begin with a dot or an underscore. This is not permitted without a scope.
+.IP \(bu 4
+New packages must not have uppercase letters in the name.
+.IP \(bu 4
+The name ends up being part of a URL, an argument on the command line, and a folder name. Therefore, the name can't contain any non-URL-safe characters.
+.RE 0
+
+.P
+Some tips:
+.RS 0
+.IP \(bu 4
+Don't use the same name as a core Node module.
+.IP \(bu 4
+Don't put "js" or "node" in the name. It's assumed that it's js, since you're writing a package.json file, and you can specify the engine using the "\fI(engines)\fR" field. (See below.)
+.IP \(bu 4
+The name will probably be passed as an argument to require(), so it should be something short, but also reasonably descriptive.
+.IP \(bu 4
+You may want to check the npm registry to see if there's something by that name already, before you get too attached to it. \fI\(lahttps://www.npmjs.com/\(ra\fR
+.RE 0
+
+.P
+A name can be optionally prefixed by a scope, e.g. \fB@npm/example\fR. See npm help scope for more detail.
+.SS "version"
+.P
+If you plan to publish your package, the \fImost\fR important things in your package.json are the name and version fields as they will be required. The name and version together form an identifier that is assumed to be completely unique. Changes to the package should come along with changes to the version. If you don't plan to publish your package, the name and version fields are optional.
+.P
+Version must be parseable by \fBnode-semver\fR \fI\(lahttps://github.com/npm/node-semver\(ra\fR, which is bundled with npm as a dependency. (\fBnpm install semver\fR to use it yourself.)
+.SS "description"
+.P
+Put a description in it. It's a string. This helps people discover your package, as it's listed in \fBnpm search\fR.
+.SS "keywords"
+.P
+Put keywords in it. It's an array of strings. This helps people discover your package as it's listed in \fBnpm search\fR.
+.P
+Example:
+.P
+.RS 2
+.nf
+"keywords": \[lB]
+  "node",
+  "javascript",
+  "npm"
+\[rB]
+.fi
+.RE
+.SS "homepage"
+.P
+The URL to the project homepage.
+.P
+Example:
+.P
+.RS 2
+.nf
+"homepage": "https://github.com/npm/example#readme"
+.fi
+.RE
+.SS "bugs"
+.P
+The URL to your project's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your package.
+.P
+It should look like this:
+.P
+.RS 2
+.nf
+{
+  "bugs": {
+    "url": "https://github.com/npm/example/issues",
+    "email": "example@npmjs.com"
+  }
+}
+.fi
+.RE
+.P
+You can specify either one or both values. If you want to provide only a URL, you can specify the value for "bugs" as a simple string instead of an object.
+.P
+If a URL is provided, it will be used by the \fBnpm bugs\fR command.
+.SS "license"
+.P
+You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
+.P
+If you're using a common license such as BSD-2-Clause or MIT, add a current SPDX license identifier for the license you're using, like this:
+.P
+.RS 2
+.nf
+{
+  "license" : "BSD-3-Clause"
+}
+.fi
+.RE
+.P
+You can check \fBthe full list of SPDX license IDs\fR \fI\(lahttps://spdx.org/licenses/\(ra\fR. Ideally, you should pick one that is \fBOSI\fR \fI\(lahttps://opensource.org/licenses/\(ra\fR approved.
+.P
+If your package is licensed under multiple common licenses, use an \fBSPDX license expression syntax version 2.0 string\fR \fI\(lahttps://spdx.dev/specifications/\(ra\fR, like this:
+.P
+.RS 2
+.nf
+{
+  "license" : "(ISC OR GPL-3.0)"
+}
+.fi
+.RE
+.P
+If you are using a license that hasn't been assigned an SPDX identifier, or if you are using a custom license, use a string value like this one:
+.P
+.RS 2
+.nf
+{
+  "license" : "SEE LICENSE IN <filename>"
+}
+.fi
+.RE
+.P
+Then include a file named \fB<filename>\fR at the top level of the package.
+.P
+Some old packages used license objects or a "licenses" property containing an array of license objects:
+.P
+.RS 2
+.nf
+// Not valid metadata
+{
+  "license" : {
+    "type" : "ISC",
+    "url" : "https://opensource.org/licenses/ISC"
+  }
+}
+
+// Not valid metadata
+{
+  "licenses" : \[lB]
+    {
+      "type": "MIT",
+      "url": "https://www.opensource.org/licenses/mit-license.php"
+    },
+    {
+      "type": "Apache-2.0",
+      "url": "https://opensource.org/licenses/apache2.0.php"
+    }
+  \[rB]
+}
+.fi
+.RE
+.P
+Those styles are now deprecated. Instead, use SPDX expressions, like this:
+.P
+.RS 2
+.nf
+{
+  "license": "ISC"
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "license": "(MIT OR Apache-2.0)"
+}
+.fi
+.RE
+.P
+Finally, if you do not wish to grant others the right to use a private or unpublished package under any terms:
+.P
+.RS 2
+.nf
+{
+  "license": "UNLICENSED"
+}
+.fi
+.RE
+.P
+Consider also setting \fB"private": true\fR to prevent accidental publication.
+.SS "people fields: author, contributors"
+.P
+The "author" is one person. "contributors" is an array of people. A "person" is an object with a "name" field and optionally "url" and "email", like this:
+.P
+.RS 2
+.nf
+{
+  "name" : "Barney Rubble",
+  "email" : "barney@npmjs.com",
+  "url" : "http://barnyrubble.npmjs.com/"
+}
+.fi
+.RE
+.P
+Or you can shorten that all into a single string, and npm will parse it for you:
+.P
+.RS 2
+.nf
+{
+  "author": "Barney Rubble <barney@npmjs.com> (http://barnyrubble.npmjs.com/)"
+}
+.fi
+.RE
+.P
+Both email and url are optional either way.
+.P
+npm also sets a top-level "maintainers" field with your npm user info.
+.SS "funding"
+.P
+You can specify an object containing a URL that provides up-to-date information about ways to help fund development of your package, a string URL, or an array of objects and string URLs:
+.P
+.RS 2
+.nf
+{
+  "funding": {
+    "type" : "individual",
+    "url" : "http://npmjs.com/donate"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "funding": {
+    "type" : "patreon",
+    "url" : "https://www.patreon.com/user"
+  }
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "funding": "http://npmjs.com/donate"
+}
+.fi
+.RE
+.P
+.RS 2
+.nf
+{
+  "funding": \[lB]
+    {
+      "type" : "individual",
+      "url" : "http://npmjs.com/donate"
+    },
+    "http://npmjs.com/donate-also",
+    {
+      "type" : "patreon",
+      "url" : "https://www.patreon.com/user"
+    }
+  \[rB]
+}
+.fi
+.RE
+.P
+Users can use the \fBnpm fund\fR subcommand to list the \fBfunding\fR URLs of all dependencies of their project, direct and indirect. A shortcut to visit each funding URL is also available when providing the project name such as: \fBnpm fund <projectname>\fR (when there are multiple URLs, the first one will be visited)
+.SS "files"
+.P
+The optional \fBfiles\fR field is an array of file patterns that describes the entries to be included when your package is installed as a dependency. File patterns follow a similar syntax to \fB.gitignore\fR, but reversed: including a file, directory, or glob pattern (\fB*\fR, \fB**/*\fR, and such) will make it so that file is included in the tarball when it's packed. Omitting the field will make it default to \fB\[lB]"*"\[rB]\fR, which means it will include all files.
+.P
+Some special files and directories are also included or excluded regardless of whether they exist in the \fBfiles\fR array (see below).
+.P
+You can also provide a \fB.npmignore\fR file in the root of your package or in subdirectories, which will keep files from being included. At the root of your package it will not override the "files" field, but in subdirectories it will. The \fB.npmignore\fR file works just like a \fB.gitignore\fR. If there is a \fB.gitignore\fR file, and \fB.npmignore\fR is missing, \fB.gitignore\fR's contents will be used instead.
+.P
+Certain files are always included, regardless of settings:
+.RS 0
+.IP \(bu 4
+\fBpackage.json\fR
+.IP \(bu 4
+\fBREADME\fR
+.IP \(bu 4
+\fBLICENSE\fR / \fBLICENCE\fR
+.IP \(bu 4
+The file in the "main" field
+.IP \(bu 4
+The file(s) in the "bin" field
+.RE 0
+
+.P
+\fBREADME\fR & \fBLICENSE\fR can have any case and extension.
+.P
+Some files are always ignored by default:
+.RS 0
+.IP \(bu 4
+\fB*.orig\fR
+.IP \(bu 4
+\fB.*.swp\fR
+.IP \(bu 4
+\fB.DS_Store\fR
+.IP \(bu 4
+\fB._*\fR
+.IP \(bu 4
+\fB.git\fR
+.IP \(bu 4
+\fB.hg\fR
+.IP \(bu 4
+\fB.lock-wscript\fR
+.IP \(bu 4
+\fB.npmrc\fR
+.IP \(bu 4
+\fB.svn\fR
+.IP \(bu 4
+\fB.wafpickle-N\fR
+.IP \(bu 4
+\fBCVS\fR
+.IP \(bu 4
+\fBconfig.gypi\fR
+.IP \(bu 4
+\fBnode_modules\fR
+.IP \(bu 4
+\fBnpm-debug.log\fR
+.IP \(bu 4
+\fBpackage-lock.json\fR (use \fB\[rs]fBnpm-shrinkwrap.json\[rs]fR\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR if you wish it to be published)
+.IP \(bu 4
+\fBpnpm-lock.yaml\fR
+.IP \(bu 4
+\fByarn.lock\fR
+.IP \(bu 4
+\fBbun.lockb\fR
+.RE 0
+
+.P
+Most of these ignored files can be included specifically if included in the \fBfiles\fR globs. Exceptions to this are:
+.RS 0
+.IP \(bu 4
+\fB.git\fR
+.IP \(bu 4
+\fB.npmrc\fR
+.IP \(bu 4
+\fBnode_modules\fR
+.IP \(bu 4
+\fBpackage-lock.json\fR
+.IP \(bu 4
+\fBpnpm-lock.yaml\fR
+.IP \(bu 4
+\fByarn.lock\fR
+.IP \(bu 4
+\fBbun.lockb\fR
+.RE 0
+
+.P
+These cannot be included.
+.SS "exports"
+.P
+The "exports" provides a modern alternative to "main" allowing multiple entry points to be defined, conditional entry resolution support between environments, and preventing any other entry points besides those defined in "exports". This encapsulation allows module authors to clearly define the public interface for their package. For more details see the \fBnode.js documentation on package entry points\fR \fI\(lahttps://nodejs.org/api/packages.html#package-entry-points\(ra\fR
+.SS "main"
+.P
+The main field is a module ID that is the primary entry point to your program. That is, if your package is named \fBfoo\fR, and a user installs it, and then does \fBrequire("foo")\fR, then your main module's exports object will be returned.
+.P
+This should be a module relative to the root of your package folder.
+.P
+For most modules, it makes the most sense to have a main script and often not much else.
+.P
+If \fBmain\fR is not set, it defaults to \fBindex.js\fR in the package's root folder.
+.SS "type"
+.P
+The \fBtype\fR field defines how Node.js should interpret \fB.js\fR files in your package. This field is not used by npm.
+.P
+See the \fBNode.js documentation on the type field\fR \fI\(lahttps://nodejs.org/api/packages.html#type\(ra\fR for more information.
+.SS "browser"
+.P
+If your module is meant to be used client-side the browser field should be used instead of the main field. This is helpful to hint users that it might rely on primitives that aren't available in Node.js modules. (e.g. \fBwindow\fR)
+.SS "bin"
+.P
+A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)
+.P
+To use this, supply a \fBbin\fR field in your package.json which is a map of command name to local file name. When this package is installed globally, that file will be either linked inside the global bins directory or a cmd (Windows Command File) will be created which executes the specified file in the \fBbin\fR field, so it is available to run by \fBname\fR or \fBname.cmd\fR (on Windows PowerShell). When this package is installed as a dependency in another package, the file will be linked where it will be available to that package either directly by \fBnpm exec\fR or by name in other scripts when invoking them via \fBnpm run\fR.
+.P
+For example, myapp could have this:
+.P
+.RS 2
+.nf
+{
+  "bin": {
+    "myapp": "bin/cli.js"
+  }
+}
+.fi
+.RE
+.P
+So, when you install myapp, in case of unix-like OS it'll create a symlink from the \fBcli.js\fR script to \fB/usr/local/bin/myapp\fR and in case of windows it will create a cmd file usually at \fBC:\[rs]Users\[rs]{Username}\[rs]AppData\[rs]Roaming\[rs]npm\[rs]myapp.cmd\fR which runs the \fBcli.js\fR script.
+.P
+If you have a single executable, and its name should be the name of the package, then you can just supply it as a string. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": "path/to/program"
+}
+.fi
+.RE
+.P
+would be the same as this:
+.P
+.RS 2
+.nf
+{
+  "name": "my-program",
+  "version": "1.2.5",
+  "bin": {
+    "my-program": "path/to/program"
+  }
+}
+.fi
+.RE
+.P
+Please make sure that your file(s) referenced in \fBbin\fR starts with \fB#!/usr/bin/env node\fR; otherwise, the scripts are started without the node executable!
+.P
+Note that you can also set the executable files using \fI(directories.bin)\fR.
+.P
+See \fBfolders\fR \fI\(la/configuring-npm/folders#executables\(ra\fR for more info on executables.
+.SS "man"
+.P
+Specify either a single file or an array of filenames to put in place for the \fBman\fR program to find.
+.P
+If only a single file is provided, then it's installed such that it is the result from \fBman <pkgname>\fR, regardless of its actual filename. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": "./man/doc.1"
+}
+.fi
+.RE
+.P
+would link the \fB./man/doc.1\fR file in such that it is the target for \fBman foo\fR
+.P
+If the filename doesn't start with the package name, then it's prefixed. So, this:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": \[lB]
+    "./man/foo.1",
+    "./man/bar.1"
+  \[rB]
+}
+.fi
+.RE
+.P
+will create files to do \fBman foo\fR and \fBman foo-bar\fR.
+.P
+Man files must end with a number, and optionally a \fB.gz\fR suffix if they are compressed. The number dictates which man section the file is installed into.
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "1.2.3",
+  "description": "A packaged foo fooer for fooing foos",
+  "main": "foo.js",
+  "man": \[lB]
+    "./man/foo.1",
+    "./man/foo.2"
+  \[rB]
+}
+.fi
+.RE
+.P
+will create entries for \fBman foo\fR and \fBman 2 foo\fR
+.SS "directories"
+.P
+The CommonJS \fBPackages\fR \fI\(lahttp://wiki.commonjs.org/wiki/Packages/1.0\(ra\fR spec details a few ways that you can indicate the structure of your package using a \fBdirectories\fR object. If you look at \fBnpm's package.json\fR \fI\(lahttps://registry.npmjs.org/npm/latest\(ra\fR, you'll see that it has directories for doc, lib, and man.
+.P
+In the future, this information may be used in other creative ways.
+.SS "directories.bin"
+.P
+If you specify a \fBbin\fR directory in \fBdirectories.bin\fR, all the files in that folder will be added.
+.P
+Because of the way the \fBbin\fR directive works, specifying both a \fBbin\fR path and setting \fBdirectories.bin\fR is an error. If you want to specify individual files, use \fBbin\fR, and for all the files in an existing \fBbin\fR directory, use \fBdirectories.bin\fR.
+.SS "directories.man"
+.P
+A folder that is full of man pages. Sugar to generate a "man" array by walking the folder.
+.SS "repository"
+.P
+Specify the place where your code lives. This is helpful for people who want to contribute. If the git repo is on GitHub, then the \fBnpm repo\fR command will be able to find you.
+.P
+Do it like this:
+.P
+.RS 2
+.nf
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git"
+  }
+}
+.fi
+.RE
+.P
+The URL should be a publicly available (perhaps read-only) URL that can be handed directly to a VCS program without any modification. It should not be a URL to an html project page that you put in your browser. It's for computers.
+.P
+For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for \fBnpm install\fR:
+.P
+.RS 2
+.nf
+{
+  "repository": "npm/example",
+
+  "repository": "github:npm/example",
+
+  "repository": "gist:11081aaa281",
+
+  "repository": "bitbucket:user/repo",
+
+  "repository": "gitlab:user/repo"
+}
+.fi
+.RE
+.P
+\fBNote on normalization:\fR When you publish a package, npm normalizes the \fBrepository\fR field to the full object format with a \fBurl\fR property. If you use a shorthand format (like \fB"npm/example"\fR), you'll see a warning during \fBnpm publish\fR indicating that the field was auto-corrected. While the shorthand format currently works, it's recommended to use the full object format in your \fBpackage.json\fR to avoid warnings and ensure future compatibility:
+.P
+.RS 2
+.nf
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/example.git"
+  }
+}
+.fi
+.RE
+.P
+You can run \fBnpm pkg fix\fR to automatically convert shorthand formats to the normalized object format.
+.P
+If the \fBpackage.json\fR for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives:
+.P
+.RS 2
+.nf
+{
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/cli.git",
+    "directory": "workspaces/libnpmpublish"
+  }
+}
+.fi
+.RE
+.SS "scripts"
+.P
+The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package. The key is the lifecycle event, and the value is the command to run at that point.
+.P
+See npm help scripts to find out more about writing package scripts.
+.SS "gypfile"
+.P
+If you have a binding.gyp file in the root of your package and you have not defined your own \fBinstall\fR or \fBpreinstall\fR scripts, npm will default to building your module using node-gyp.
+.P
+To prevent npm from automatically building your module with node-gyp, set \fBgypfile\fR to \fBfalse\fR:
+.P
+.RS 2
+.nf
+{
+  "gypfile": false
+}
+.fi
+.RE
+.P
+This is useful for packages that include native addons but want to handle the build process differently, or packages that have a binding.gyp file but should not be built as a native addon.
+.SS "config"
+.P
+A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades. For instance, if a package had the following:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "config": {
+    "port": "8080"
+  }
+}
+.fi
+.RE
+.P
+It could also have a "start" script that referenced the \fBnpm_package_config_port\fR environment variable.
+.SS "dependencies"
+.P
+Dependencies are specified in a simple object that maps a package name to a version range. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or git URL.
+.P
+\fBPlease do not put test harnesses or transpilers or other "development" time tools in your \fBdependencies\fB object.\fR See \fBdevDependencies\fR, below.
+.P
+See \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR for more details about specifying version ranges.
+.RS 0
+.IP \(bu 4
+\fBversion\fR Must match \fBversion\fR exactly
+.IP \(bu 4
+\fB>version\fR Must be greater than \fBversion\fR
+.IP \(bu 4
+\fB>=version\fR etc
+.IP \(bu 4
+\fB<version\fR
+.IP \(bu 4
+\fB<=version\fR
+.IP \(bu 4
+\fB~version\fR "Approximately equivalent to version" See \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR
+.IP \(bu 4
+\fB^version\fR "Compatible with version" See \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR
+.IP \(bu 4
+\fB1.2.x\fR 1.2.0, 1.2.1, etc., but not 1.3.0
+.IP \(bu 4
+\fBhttp://...\fR See 'URLs as Dependencies' below
+.IP \(bu 4
+\fB*\fR Matches any version
+.IP \(bu 4
+\fB""\fR (just an empty string) Same as \fB*\fR
+.IP \(bu 4
+\fBversion1 - version2\fR Same as \fB>=version1 <=version2\fR.
+.IP \(bu 4
+\fBrange1 || range2\fR Passes if either range1 or range2 are satisfied.
+.IP \(bu 4
+\fBgit...\fR See 'Git URLs as Dependencies' below
+.IP \(bu 4
+\fBuser/repo\fR See 'GitHub URLs' below
+.IP \(bu 4
+\fBtag\fR A specific version tagged and published as \fBtag\fR See npm help dist-tag
+.IP \(bu 4
+\fBpath/path/path\fR See \fI(Local Paths)\fR below
+.IP \(bu 4
+\fBnpm:@scope/pkg@version\fR Custom alias for a package See \fB\[rs]fBpackage-spec\[rs]fR\fR \fI\(la/using-npm/package-spec#aliases\(ra\fR
+.RE 0
+
+.P
+For example, these are all valid:
+.P
+.RS 2
+.nf
+{
+  "dependencies": {
+    "foo": "1.0.0 - 2.9999.9999",
+    "bar": ">=1.0.2 <2.1.2",
+    "baz": ">1.0.2 <=2.3.4",
+    "boo": "2.0.1",
+    "qux": "<1.0.0 || >=2.3.1 <2.4.5 || >=2.5.2 <3.0.0",
+    "asd": "http://npmjs.com/example.tar.gz",
+    "til": "~1.2",
+    "elf": "~1.2.3",
+    "two": "2.x",
+    "thr": "3.3.x",
+    "lat": "latest",
+    "dyl": "file:../dyl",
+    "kpg": "npm:pkg@1.0.0"
+  }
+}
+.fi
+.RE
+.SS "URLs as Dependencies"
+.P
+You may specify a tarball URL in place of a version range.
+.P
+This tarball will be downloaded and installed locally to your package at install time.
+.SS "Git URLs as Dependencies"
+.P
+Git URLs are of the form:
+.P
+.RS 2
+.nf
+<protocol>://\[lB]<user>\[lB]:<password>\[rB]@\[rB]<hostname>\[lB]:<port>\[rB]\[lB]:\[rB]\[lB]/\[rB]<path>\[lB]#<commit-ish> | #semver:<semver>\[rB]
+.fi
+.RE
+.P
+\fB<protocol>\fR is one of \fBgit\fR, \fBgit+ssh\fR, \fBgit+http\fR, \fBgit+https\fR, or \fBgit+file\fR.
+.P
+If \fB#<commit-ish>\fR is provided, it will be used to clone exactly that commit. If the commit-ish has the format \fB#semver:<semver>\fR, \fB<semver>\fR can be any valid semver range or exact version, and npm will look for any tags or refs matching that range in the remote repository, much as it would for a registry dependency. If neither \fB#<commit-ish>\fR or \fB#semver:<semver>\fR is specified, then the default branch is used.
+.P
+Examples:
+.P
+.RS 2
+.nf
+git+ssh://git@github.com:npm/cli.git#v1.0.27
+git+ssh://git@github.com:npm/cli#semver:^5.0
+git+https://isaacs@github.com/npm/cli.git
+git://github.com/npm/cli.git#v1.0.27
+.fi
+.RE
+.P
+When installing from a \fBgit\fR repository, the presence of certain fields in the \fBpackage.json\fR will cause npm to believe it needs to perform a build. To do so your repository will be cloned into a temporary directory, all of its deps installed, relevant scripts run, and the resulting directory packed and installed.
+.P
+This flow will occur if your git dependency uses \fBworkspaces\fR, or if any of the following scripts are present:
+.RS 0
+.IP \(bu 4
+\fBbuild\fR
+.IP \(bu 4
+\fBprepare\fR
+.IP \(bu 4
+\fBprepack\fR
+.IP \(bu 4
+\fBpreinstall\fR
+.IP \(bu 4
+\fBinstall\fR
+.IP \(bu 4
+\fBpostinstall\fR
+.RE 0
+
+.P
+If your git repository includes pre-built artifacts, you will likely want to make sure that none of the above scripts are defined, or your dependency will be rebuilt for every installation.
+.SS "GitHub URLs"
+.P
+As of version 1.1.65, you can refer to GitHub URLs as just "foo": "user/foo-project". Just as with git URLs, a \fBcommit-ish\fR suffix can be included. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "foo",
+  "version": "0.0.0",
+  "dependencies": {
+    "express": "expressjs/express",
+    "mocha": "mochajs/mocha#4727d357ea",
+    "module": "npm/example-github-repo#feature\[rs]/branch"
+  }
+}
+.fi
+.RE
+.SS "Local Paths"
+.P
+As of version 2.0.0 you can provide a path to a local directory that contains a package. Local paths can be saved using \fBnpm install -S\fR or \fBnpm install --save\fR, using any of these forms:
+.P
+.RS 2
+.nf
+../foo/bar
+~/foo/bar
+./foo/bar
+/foo/bar
+.fi
+.RE
+.P
+in which case they will be normalized to a relative path and added to your \fBpackage.json\fR. For example:
+.P
+.RS 2
+.nf
+{
+  "name": "baz",
+  "dependencies": {
+    "bar": "file:../foo/bar"
+  }
+}
+.fi
+.RE
+.P
+This feature is helpful for local offline development and creating tests that require npm installing where you don't want to hit an external server, but should not be used when publishing your package to the public registry.
+.P
+\fInote\fR: Packages linked by local path will not have their own dependencies installed when \fBnpm install\fR is run. You must run \fBnpm install\fR from inside the local path itself.
+.SS "devDependencies"
+.P
+If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.
+.P
+In this case, it's best to map these additional items in a \fBdevDependencies\fR object.
+.P
+These things will be installed when doing \fBnpm link\fR or \fBnpm install\fR from the root of a package, and can be managed like any other npm configuration param. See npm help config for more on the topic.
+.P
+For build steps that are not platform-specific, such as compiling CoffeeScript or other languages to JavaScript, use the \fBprepare\fR script to do this, and make the required package a devDependency.
+.P
+For example:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/ethopia-waza",
+  "description": "a delightfully fruity coffee varietal",
+  "version": "1.2.3",
+  "devDependencies": {
+    "coffee-script": "~1.6.3"
+  },
+  "scripts": {
+    "prepare": "coffee -o lib/ -c src/waza.coffee"
+  },
+  "main": "lib/waza.js"
+}
+.fi
+.RE
+.P
+The \fBprepare\fR script will be run before publishing, so that users can consume the functionality without requiring them to compile it themselves. In dev mode (ie, locally running \fBnpm install\fR), it'll run this script as well, so that you can test it easily.
+.SS "peerDependencies"
+.P
+In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a \fBrequire\fR of this host. This is usually referred to as a \fIplugin\fR. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.
+.P
+For example:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x"
+  }
+}
+.fi
+.RE
+.P
+This ensures your package \fB@npm/tea-latte\fR can be installed \fIalong\fR with the second major version of the host package \fB@npm/tea\fR only. \fBnpm install tea-latte\fR could possibly yield the following dependency graph:
+.P
+.RS 2
+.nf
+├── @npm/tea-latte@1.3.5
+└── @npm/tea@2.2.0
+.fi
+.RE
+.P
+In npm versions 3 through 6, \fBpeerDependencies\fR were not automatically installed, and would raise a warning if an invalid version of the peer dependency was found in the tree. As of npm v7, peerDependencies \fIare\fR installed by default.
+.P
+Trying to install another plugin with a conflicting requirement may cause an error if the tree cannot be resolved correctly. For this reason, make sure your plugin requirement is as broad as possible, and not to lock it down to specific patch versions.
+.P
+Assuming the host complies with \fBsemver\fR \fI\(lahttps://semver.org/\(ra\fR, only changes in the host package's major version will break your plugin. Thus, if you've worked with every 1.x version of the host package, use \fB"^1.0"\fR or \fB"1.x"\fR to express this. If you depend on features introduced in 1.5.2, use \fB"^1.5.2"\fR.
+.SS "peerDependenciesMeta"
+.P
+The \fBpeerDependenciesMeta\fR field serves to provide npm more information on how your peer dependencies are to be used. Specifically, it allows peer dependencies to be marked as optional. Npm will not automatically install optional peer dependencies. This allows you to integrate and interact with a variety of host packages without requiring all of them to be installed.
+.P
+For example:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/tea-latte",
+  "version": "1.3.5",
+  "peerDependencies": {
+    "@npm/tea": "2.x",
+    "@npm/soy-milk": "1.2"
+  },
+  "peerDependenciesMeta": {
+    "@npm/soy-milk": {
+      "optional": true
+    }
+  }
+}
+.fi
+.RE
+.SS "bundleDependencies"
+.P
+This defines an array of package names that will be bundled when publishing the package.
+.P
+In cases where you need to preserve npm packages locally or have them available through a single file download, you can bundle the packages in a tarball file by specifying the package names in the \fBbundleDependencies\fR array and executing \fBnpm pack\fR.
+.P
+For example:
+.P
+If we define a package.json like this:
+.P
+.RS 2
+.nf
+{
+  "name": "@npm/awesome-web-framework",
+  "version": "1.0.0",
+  "bundleDependencies": \[lB]
+    "@npm/renderized",
+    "@npm/super-streams"
+  \[rB]
+}
+.fi
+.RE
+.P
+we can obtain \fB@npm/awesome-web-framework-1.0.0.tgz\fR file by running \fBnpm pack\fR. This file contains the dependencies \fB@npm/renderized\fR and \fB@npm/super-streams\fR which can be installed in a new project by executing \fBnpm install awesome-web-framework-1.0.0.tgz\fR. Note that the package names do not include any versions, as that information is specified in \fBdependencies\fR.
+.P
+If this is spelled \fB"bundledDependencies"\fR, then that is also honored.
+.P
+Alternatively, \fB"bundleDependencies"\fR can be defined as a boolean value. A value of \fBtrue\fR will bundle all dependencies, a value of \fBfalse\fR will bundle none.
+.SS "optionalDependencies"
+.P
+If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the \fBoptionalDependencies\fR object. This is a map of package name to version or URL, just like the \fBdependencies\fR object. The difference is that build failures do not cause installation to fail. Running \fBnpm install --omit=optional\fR will prevent these dependencies from being installed.
+.P
+It is still your program's responsibility to handle the lack of the dependency. For example, something like this:
+.P
+.RS 2
+.nf
+try {
+  var foo = require('@npm/foo')
+  var fooVersion = require('@npm/foo/package.json').version
+} catch (er) {
+  foo = null
+}
+if ( notGoodFooVersion(fooVersion) ) {
+  foo = null
+}
+
+// .. then later in your program ..
+
+if (foo) {
+  foo.doFooThings()
+}
+.fi
+.RE
+.P
+Entries in \fBoptionalDependencies\fR will override entries of the same name in \fBdependencies\fR, so it's usually best to only put in one place.
+.SS "overrides"
+.P
+If you need to make specific changes to dependencies of your dependencies, for example replacing the version of a dependency with a known security issue, replacing an existing dependency with a fork, or making sure that the same version of a package is used everywhere, then you may add an override.
+.P
+Overrides provide a way to replace a package in your dependency tree with another version, or another package entirely. These changes can be scoped as specific or as vague as desired.
+.P
+Overrides are only considered in the root \fBpackage.json\fR file for a project. Overrides in installed dependencies (including npm help workspaces) are not considered in dependency tree resolution. Published packages may dictate their resolutions by pinning dependencies or using an \fB\[rs]fBnpm-shrinkwrap.json\[rs]fR\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR file.
+.P
+To make sure the package \fB@npm/foo\fR is always installed as version \fB1.0.0\fR no matter what version your dependencies rely on:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/foo": "1.0.0"
+  }
+}
+.fi
+.RE
+.P
+The above is a short hand notation, the full object form can be used to allow overriding a package itself as well as a child of the package. This will cause \fB@npm/foo\fR to always be \fB1.0.0\fR while also making \fB@npm/bar\fR at any depth beyond \fB@npm/foo\fR also \fB1.0.0\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/foo": {
+      ".": "1.0.0",
+      "@npm/bar": "1.0.0"
+    }
+  }
+}
+.fi
+.RE
+.P
+To only override \fB@npm/foo\fR to be \fB1.0.0\fR when it's a child (or grandchild, or great grandchild, etc) of the package \fB@npm/bar\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/bar": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+.fi
+.RE
+.P
+Keys can be nested to any arbitrary length. To override \fB@npm/foo\fR only when it's a child of \fB@npm/bar\fR and only when \fB@npm/bar\fR is a child of \fB@npm/baz\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/baz": {
+      "@npm/bar": {
+        "@npm/foo": "1.0.0"
+      }
+    }
+  }
+}
+.fi
+.RE
+.P
+The key of an override can also include a version, or range of versions. To override \fB@npm/foo\fR to \fB1.0.0\fR, but only when it's a child of \fB@npm/bar@2.0.0\fR:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "@npm/bar@2.0.0": {
+      "@npm/foo": "1.0.0"
+    }
+  }
+}
+.fi
+.RE
+.P
+You may not set an override for a package that you directly depend on unless both the dependency and the override itself share the exact same spec. To make this limitation easier to deal with, overrides may also be defined as a reference to a spec for a direct dependency by prefixing the name of the package you wish the version to match with a \fB$\fR.
+.P
+.RS 2
+.nf
+{
+  "dependencies": {
+    "@npm/foo": "^1.0.0"
+  },
+  "overrides": {
+    // BAD, will throw an EOVERRIDE error
+    // "foo": "^2.0.0"
+    // GOOD, specs match so override is allowed
+    // "foo": "^1.0.0"
+    // BEST, the override is defined as a reference to the dependency
+    "@npm/foo": "$foo",
+    // the referenced package does not need to match the overridden one
+    "@npm/bar": "$foo"
+  }
+}
+.fi
+.RE
+.SS "Replacing a dependency with a fork"
+.P
+You can replace a package with a different package or fork using several methods:
+.P
+\fBUsing the \fBnpm:\fB prefix to replace with a different package name:\fR
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "package-name": "npm:@scope/forked-package@1.0.0"
+  }
+}
+.fi
+.RE
+.P
+\fBUsing a GitHub repository (supports branches, tags, or commit hashes):\fR
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "package-name": "github:username/repo#branch-name"
+  }
+}
+.fi
+.RE
+.P
+\fBUsing a local file path:\fR
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "package-name": "file:../local-fork"
+  }
+}
+.fi
+.RE
+.P
+These replacement methods work for both top-level overrides and nested overrides. For example, to replace a transitive dependency with a fork:
+.P
+.RS 2
+.nf
+{
+  "overrides": {
+    "parent-package": {
+      "vulnerable-dep": "github:username/patched-fork#v2.0.1"
+    }
+  }
+}
+.fi
+.RE
+.SS "engines"
+.P
+You can specify the version of node that your stuff works on:
+.P
+.RS 2
+.nf
+{
+  "engines": {
+    "node": ">=0.10.3 <15"
+  }
+}
+.fi
+.RE
+.P
+And, like with dependencies, if you don't specify the version (or if you specify "*" as the version), then any version of node will do.
+.P
+You can also use the "engines" field to specify which versions of npm are capable of properly installing your program. For example:
+.P
+.RS 2
+.nf
+{
+  "engines": {
+    "npm": "~1.0.20"
+  }
+}
+.fi
+.RE
+.P
+Unless the user has set the \fB\[rs]fBengine-strict\[rs]fR config\fR \fI\(la/using-npm/config#engine-strict\(ra\fR flag, this field is advisory only and will only produce warnings when your package is installed as a dependency.
+.SS "os"
+.P
+You can specify which operating systems your module will run on:
+.P
+.RS 2
+.nf
+{
+  "os": \[lB]
+    "darwin",
+    "linux"
+  \[rB]
+}
+.fi
+.RE
+.P
+You can also block instead of allowing operating systems, just prepend the blocked os with a '!':
+.P
+.RS 2
+.nf
+{
+  "os": \[lB]
+    "!win32"
+  \[rB]
+}
+.fi
+.RE
+.P
+The host operating system is determined by \fBprocess.platform\fR
+.P
+It is allowed to both block and allow an item, although there isn't any good reason to do this.
+.SS "cpu"
+.P
+If your code only runs on certain cpu architectures, you can specify which ones.
+.P
+.RS 2
+.nf
+{
+  "cpu": \[lB]
+    "x64",
+    "ia32"
+  \[rB]
+}
+.fi
+.RE
+.P
+Like the \fBos\fR option, you can also block architectures:
+.P
+.RS 2
+.nf
+{
+  "cpu": \[lB]
+    "!arm",
+    "!mips"
+  \[rB]
+}
+.fi
+.RE
+.P
+The host architecture is determined by \fBprocess.arch\fR
+.SS "libc"
+.P
+If your code only runs or builds in certain versions of libc, you can specify which ones. This field only applies if \fBos\fR is \fBlinux\fR.
+.P
+.RS 2
+.nf
+{
+  "os": "linux",
+  "libc": "glibc"
+}
+.fi
+.RE
+.SS "devEngines"
+.P
+The \fBdevEngines\fR field aids engineers working on a codebase to all be using the same tooling.
+.P
+You can specify a \fBdevEngines\fR property in your \fBpackage.json\fR which will run before \fBinstall\fR, \fBci\fR, and \fBrun\fR commands.
+.RS 0
+.P
+Note: \fBengines\fR and \fBdevEngines\fR differ in object shape. They also function very differently. \fBengines\fR is designed to alert the user when a dependency uses a different npm or node version than the project it's being used in, whereas \fBdevEngines\fR is used to alert people interacting with the source code of a project.
+.RE 0
+
+.P
+The supported keys under the \fBdevEngines\fR property are \fBcpu\fR, \fBos\fR, \fBlibc\fR, \fBruntime\fR, and \fBpackageManager\fR. Each property can be an object or an array of objects. Objects must contain \fBname\fR, and optionally can specify \fBversion\fR, and \fBonFail\fR. \fBonFail\fR can be \fBwarn\fR, \fBerror\fR, or \fBignore\fR, and if left undefined is of the same value as \fBerror\fR. \fBnpm\fR will assume that you're running with \fBnode\fR. Here's an example of a project that will fail if the environment is not \fBnode\fR and \fBnpm\fR. If you set \fBruntime.name\fR or \fBpackageManager.name\fR to any other string, it will fail within the npm CLI.
+.P
+.RS 2
+.nf
+{
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "onFail": "error"
+    }
+  }
+}
+.fi
+.RE
+.SS "private"
+.P
+If you set \fB"private": true\fR in your package.json, then npm will refuse to publish it.
+.P
+This is a way to prevent accidental publication of private repositories. If you would like to ensure that a given package is only ever published to a specific registry (for example, an internal registry), then use the \fBpublishConfig\fR dictionary described below to override the \fBregistry\fR config param at publish-time.
+.SS "publishConfig"
+.P
+This is a set of config values that will be used at publish-time. It's especially handy if you want to set the tag, registry or access, so that you can ensure that a given package is not tagged with "latest", published to the global public registry or that a scoped module is private by default.
+.P
+See npm help config to see the list of config options that can be overridden.
+.SS "workspaces"
+.P
+The optional \fBworkspaces\fR field is an array of file patterns that describes locations within the local file system that the install client should look up to find each npm help workspace that needs to be symlinked to the top level \fBnode_modules\fR folder.
+.P
+It can describe either the direct paths of the folders to be used as workspaces or it can define globs that will resolve to these same folders.
+.P
+In the following example, all folders located inside the folder \fB./packages\fR will be treated as workspaces as long as they have valid \fBpackage.json\fR files inside them:
+.P
+.RS 2
+.nf
+{
+  "name": "workspace-example",
+  "workspaces": \[lB]
+    "./packages/*"
+  \[rB]
+}
+.fi
+.RE
+.P
+See npm help workspaces for more examples.
+.SS "DEFAULT VALUES"
+.P
+npm will default some values based on package contents.
+.RS 0
+.IP \(bu 4
+\fB"scripts": {"start": "node server.js"}\fR
+.P
+If there is a \fBserver.js\fR file in the root of your package, then npm will default the \fBstart\fR command to \fBnode server.js\fR.
+.IP \(bu 4
+\fB"scripts":{"install": "node-gyp rebuild"}\fR
+.P
+If there is a \fBbinding.gyp\fR file in the root of your package and you have not defined an \fBinstall\fR or \fBpreinstall\fR script, npm will default the \fBinstall\fR command to compile using node-gyp.
+.IP \(bu 4
+\fB"contributors": \[lB]...\[rB]\fR
+.P
+If there is an \fBAUTHORS\fR file in the root of your package, npm will treat each line as a \fBName <email> (url)\fR format, where email and url are optional. Lines which start with a \fB#\fR or are blank, will be ignored.
+.RE 0
+
+.SS "SEE ALSO"
+.RS 0
+.IP \(bu 4
+\fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#versions\(ra\fR
+.IP \(bu 4
+npm help workspaces
+.IP \(bu 4
+npm help init
+.IP \(bu 4
+npm help version
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help help
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help uninstall
+.RE 0
diff --git a/node/node_modules/npm/man/man5/package-lock-json.5 b/node/node_modules/npm/man/man5/package-lock-json.5
new file mode 100644
index 0000000000000000000000000000000000000000..290298614f2dbde26ee30acec88eef020c9a73e4
--- /dev/null
+++ b/node/node_modules/npm/man/man5/package-lock-json.5
@@ -0,0 +1,166 @@
+.TH "PACKAGE-LOCK.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBpackage-lock.json\fR - A manifestation of the manifest
+.SS "Description"
+.P
+\fBpackage-lock.json\fR is automatically generated for any operations where npm modifies either the \fBnode_modules\fR tree, or \fBpackage.json\fR. It describes the exact tree that was generated, such that subsequent installs are able to generate identical trees, regardless of intermediate dependency updates.
+.P
+This file is intended to be committed into source repositories, and serves various purposes:
+.RS 0
+.IP \(bu 4
+Describe a single representation of a dependency tree such that teammates, deployments, and continuous integration are guaranteed to install exactly the same dependencies.
+.IP \(bu 4
+Provide a facility for users to "time-travel" to previous states of \fBnode_modules\fR without having to commit the directory itself.
+.IP \(bu 4
+Facilitate greater visibility of tree changes through readable source control diffs.
+.IP \(bu 4
+Optimize the installation process by allowing npm to skip repeated metadata resolutions for previously-installed packages.
+.IP \(bu 4
+As of npm v7, lockfiles include enough information to gain a complete picture of the package tree, reducing the need to read \fBpackage.json\fR files, and allowing for significant performance improvements.
+.RE 0
+
+.P
+When \fBnpm\fR creates or updates \fBpackage-lock.json\fR, it will infer line endings and indentation from \fBpackage.json\fR so that the formatting of both files matches.
+.SS "\fBpackage-lock.json\fR vs \fBnpm-shrinkwrap.json\fR"
+.P
+Both of these files have the same format, and perform similar functions in the root of a project.
+.P
+The difference is that \fBpackage-lock.json\fR cannot be published, and it will be ignored if found in any place other than the root project.
+.P
+In contrast, \fBnpm-shrinkwrap.json\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR allows publication, and defines the dependency tree from the point encountered. This is not recommended unless deploying a CLI tool or otherwise using the publication process for producing production packages.
+.P
+If both \fBpackage-lock.json\fR and \fBnpm-shrinkwrap.json\fR are present in the root of a project, \fBnpm-shrinkwrap.json\fR will take precedence and \fBpackage-lock.json\fR will be ignored.
+.SS "Hidden Lockfiles"
+.P
+In order to avoid processing the \fBnode_modules\fR folder repeatedly, npm as of v7 uses a "hidden" lockfile present in \fBnode_modules/.package-lock.json\fR. This contains information about the tree, and is used in lieu of reading the entire \fBnode_modules\fR hierarchy provided that the following conditions are met:
+.RS 0
+.IP \(bu 4
+All package folders it references exist in the \fBnode_modules\fR hierarchy.
+.IP \(bu 4
+No package folders exist in the \fBnode_modules\fR hierarchy that are not listed in the lockfile.
+.IP \(bu 4
+The modified time of the file is at least as recent as all of the package folders it references.
+.RE 0
+
+.P
+That is, the hidden lockfile will only be relevant if it was created as part of the most recent update to the package tree. If another CLI mutates the tree in any way, this will be detected, and the hidden lockfile will be ignored.
+.P
+Note that it \fIis\fR possible to manually change the \fIcontents\fR of a package in such a way that the modified time of the package folder is unaffected. For example, if you add a file to \fBnode_modules/foo/lib/bar.js\fR, then the modified time on \fBnode_modules/foo\fR will not reflect this change. If you are manually editing files in \fBnode_modules\fR, it is generally best to delete the file at \fBnode_modules/.package-lock.json\fR.
+.P
+As the hidden lockfile is ignored by older npm versions, it does not contain the backwards compatibility affordances present in "normal" lockfiles. That is, it is \fBlockfileVersion: 3\fR, rather than \fBlockfileVersion: 2\fR.
+.SS "Handling Old Lockfiles"
+.P
+When npm detects a lockfile from npm v6 or before during the package installation process, it is automatically updated to fetch missing information from either the \fBnode_modules\fR tree or (in the case of empty \fBnode_modules\fR trees or very old lockfile formats) the npm registry.
+.SS "File Format"
+.SS "\fBname\fR"
+.P
+The name of the package this is a package-lock for. This will match what's in \fBpackage.json\fR.
+.SS "\fBversion\fR"
+.P
+The version of the package this is a package-lock for. This will match what's in \fBpackage.json\fR.
+.SS "\fBlockfileVersion\fR"
+.P
+An integer version, starting at \fB1\fR with the version number of this document whose semantics were used when generating this \fBpackage-lock.json\fR.
+.P
+Note that the file format changed significantly in npm v7 to track information that would have otherwise required looking in \fBnode_modules\fR or the npm registry. Lockfiles generated by npm v7 will contain \fBlockfileVersion: 2\fR.
+.RS 0
+.IP \(bu 4
+No version provided: an "ancient" shrinkwrap file from a version of npm prior to npm v5.
+.IP \(bu 4
+\fB1\fR: The lockfile version used by npm v5 and v6.
+.IP \(bu 4
+\fB2\fR: The lockfile version used by npm v7 and v8. Backwards compatible to v1 lockfiles.
+.IP \(bu 4
+\fB3\fR: The lockfile version used by npm v9 and above. Backwards compatible to npm v7.
+.RE 0
+
+.P
+npm will always attempt to get whatever data it can out of a lockfile, even if it is not a version that it was designed to support.
+.SS "\fBpackages\fR"
+.P
+This is an object that maps package locations to an object containing the information about that package.
+.P
+The root project is typically listed with a key of \fB""\fR, and all other packages are listed with their relative paths from the root project folder.
+.P
+Package descriptors have the following fields:
+.RS 0
+.IP \(bu 4
+version: The version found in \fBpackage.json\fR
+.IP \(bu 4
+resolved: The place where the package was actually resolved from. In the case of packages fetched from the registry, this will be a url to a tarball. In the case of git dependencies, this will be the full git url with commit sha. In the case of link dependencies, this will be the location of the link target. \fBregistry.npmjs.org\fR is a magic value meaning "the currently configured registry".
+.IP \(bu 4
+integrity: A \fBsha512\fR or \fBsha1\fR \fBStandard Subresource Integrity\fR \fI\(lahttps://w3c.github.io/webappsec/specs/subresourceintegrity/\(ra\fR string for the artifact that was unpacked in this location.
+.IP \(bu 4
+link: A flag to indicate that this is a symbolic link. If this is present, no other fields are specified, since the link target will also be included in the lockfile.
+.IP \(bu 4
+dev, optional, devOptional: If the package is strictly part of the \fBdevDependencies\fR tree, then \fBdev\fR will be true. If it is strictly part of the \fBoptionalDependencies\fR tree, then \fBoptional\fR will be set. If it is both a \fBdev\fR dependency \fIand\fR an \fBoptional\fR dependency of a non-dev dependency, then \fBdevOptional\fR will be set. (An \fBoptional\fR dependency of a \fBdev\fR dependency will have both \fBdev\fR and \fBoptional\fR set.)
+.IP \(bu 4
+inBundle: A flag to indicate that the package is a bundled dependency.
+.IP \(bu 4
+hasInstallScript: A flag to indicate that the package has a \fBpreinstall\fR, \fBinstall\fR, or \fBpostinstall\fR script.
+.IP \(bu 4
+hasShrinkwrap: A flag to indicate that the package has an \fBnpm-shrinkwrap.json\fR file.
+.IP \(bu 4
+bin, license, engines, dependencies, optionalDependencies: fields from \fBpackage.json\fR
+.IP \(bu 4
+os: An array of operating systems this package is compatible with, as specified in \fBpackage.json\fR. This field is included when the package specifies OS restrictions.
+.IP \(bu 4
+cpu: An array of CPU architectures this package is compatible with, as specified in \fBpackage.json\fR. This field is included when the package specifies CPU restrictions.
+.IP \(bu 4
+funding: Funding information for the package, as specified in \fBpackage.json\fR. This field contains details about how to support the package maintainers.
+.RE 0
+
+.SS "dependencies"
+.P
+Legacy data for supporting versions of npm that use \fBlockfileVersion: 1\fR. This is a mapping of package names to dependency objects. Because the object structure is strictly hierarchical, symbolic link dependencies are somewhat challenging to represent in some cases.
+.P
+npm v7 ignores this section entirely if a \fBpackages\fR section is present, but does keep it up to date in order to support switching between npm v6 and npm v7.
+.P
+Dependency objects have the following fields:
+.RS 0
+.IP \(bu 4
+version: a specifier that varies depending on the nature of the package, and is usable in fetching a new copy of it. Note that for peer dependencies that are not installed, or optional dependencies that are not installed, this field may be omitted.
+.RS 4
+.IP \(bu 4
+bundled dependencies: Regardless of source, this is a version number that is purely for informational purposes.
+.IP \(bu 4
+registry sources: This is a version number. (eg, \fB1.2.3\fR)
+.IP \(bu 4
+git sources: This is a git specifier with resolved committish. (eg, \fBgit+https://example.com/foo/bar#115311855adb0789a0466714ed48a1499ffea97e\fR)
+.IP \(bu 4
+http tarball sources: This is the URL of the tarball. (eg, \fBhttps://example.com/example-1.3.0.tgz\fR)
+.IP \(bu 4
+local tarball sources: This is the file URL of the tarball. (eg \fBfile:///opt/storage/example-1.3.0.tgz\fR)
+.IP \(bu 4
+local link sources: This is the file URL of the link. (eg \fBfile:libs/our-module\fR)
+.RE 0
+
+.P
+\fBNote:\fR The \fBversion\fR field may be omitted for certain types of dependencies, such as optional peer dependencies that are not installed. In these cases, only metadata fields like \fBdev\fR, \fBoptional\fR, and \fBpeer\fR will be present.
+.IP \(bu 4
+integrity: A \fBsha512\fR or \fBsha1\fR \fBStandard Subresource Integrity\fR \fI\(lahttps://w3c.github.io/webappsec/specs/subresourceintegrity/\(ra\fR string for the artifact that was unpacked in this location. For git dependencies, this is the commit sha.
+.IP \(bu 4
+resolved: For registry sources this is path of the tarball relative to the registry URL. If the tarball URL isn't on the same server as the registry URL then this is a complete URL. \fBregistry.npmjs.org\fR is a magic value meaning "the currently configured registry".
+.IP \(bu 4
+bundled: If true, this is the bundled dependency and will be installed by the parent module. When installing, this module will be extracted from the parent module during the extract phase, not installed as a separate dependency.
+.IP \(bu 4
+dev: If true then this dependency is either a development dependency ONLY of the top level module or a transitive dependency of one. This is false for dependencies that are both a development dependency of the top level and a transitive dependency of a non-development dependency of the top level.
+.IP \(bu 4
+optional: If true then this dependency is either an optional dependency ONLY of the top level module or a transitive dependency of one. This is false for dependencies that are both an optional dependency of the top level and a transitive dependency of a non-optional dependency of the top level.
+.IP \(bu 4
+requires: This is a mapping of module name to version. This is a list of everything this module requires, regardless of where it will be installed. The version should match via normal matching rules a dependency either in our \fBdependencies\fR or in a level higher than us.
+.IP \(bu 4
+dependencies: The dependencies of this dependency, exactly as at the top level.
+.RE 0
+
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help shrinkwrap
+.IP \(bu 4
+\fBnpm-shrinkwrap.json\fR \fI\(la/configuring-npm/npm-shrinkwrap-json\(ra\fR
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man7/config.7 b/node/node_modules/npm/man/man7/config.7
new file mode 100644
index 0000000000000000000000000000000000000000..480ac85dac760273b14f2e521e4a65bd37dd6b89
--- /dev/null
+++ b/node/node_modules/npm/man/man7/config.7
@@ -0,0 +1,2246 @@
+.TH "CONFIG" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBConfig\fR - About npm configuration
+.SS "Description"
+.P
+This article details npm configuration in general. To learn about the \fBconfig\fR command, see npm help config.
+.P
+npm gets its configuration values from the following sources, sorted by priority:
+.SS "Command Line Flags"
+.P
+Putting \fB--foo bar\fR on the command line sets the \fBfoo\fR configuration parameter to \fB"bar"\fR. A \fB--\fR argument tells the cli parser to stop reading flags. Using \fB--flag\fR without specifying any value will set the value to \fBtrue\fR.
+.P
+Example: \fB--flag1 --flag2\fR will set both configuration parameters to \fBtrue\fR, while \fB--flag1 --flag2 bar\fR will set \fBflag1\fR to \fBtrue\fR, and \fBflag2\fR to \fBbar\fR. Finally, \fB--flag1 --flag2 -- bar\fR will set both configuration parameters to \fBtrue\fR, and the \fBbar\fR is taken as a command argument.
+.P
+\fBCommon examples:\fR
+.RS 0
+.IP \(bu 4
+\fBnpm install --prefix /path/to/dir\fR - Runs npm commands in a different directory without changing the current working directory
+.IP \(bu 4
+\fBnpm install --global\fR - Installs packages globally (shorthand: \fB-g\fR)
+.IP \(bu 4
+\fBnpm install --save-dev\fR - Saves to devDependencies (shorthand: \fB-D\fR)
+.RE 0
+
+.P
+Any configuration option documented in the \fI(Config Settings)\fR section below can be set via command line flags using \fB--option-name value\fR syntax.
+.SS "Environment Variables"
+.P
+Any environment variables that start with \fBnpm_config_\fR will be interpreted as a configuration parameter. For example, putting \fBnpm_config_foo=bar\fR in your environment will set the \fBfoo\fR configuration parameter to \fBbar\fR. Any environment configurations that are not given a value will be given the value of \fBtrue\fR. Config values are case-insensitive, so \fBNPM_CONFIG_FOO=bar\fR will work the same. However, please note that inside npm help scripts npm will set its own environment variables and Node will prefer those lowercase versions over any uppercase ones that you might set. For details see \fBthis issue\fR \fI\(lahttps://github.com/npm/npm/issues/14528\(ra\fR.
+.P
+Notice that you need to use underscores instead of dashes, so \fB--allow-same-version\fR would become \fBnpm_config_allow_same_version=true\fR.
+.P
+\fBImportant:\fR When defining custom configuration keys in \fB.npmrc\fR files, use hyphens instead of underscores (e.g., \fBcustom-key=value\fR). This ensures they can be overridden by environment variables, since npm automatically converts underscores to hyphens when reading environment variables. Keys with underscores in \fB.npmrc\fR files cannot be overridden via environment variables.
+.SS "npmrc Files"
+.P
+The four relevant files are:
+.RS 0
+.IP \(bu 4
+per-project configuration file (\fB/path/to/my/project/.npmrc\fR)
+.IP \(bu 4
+per-user configuration file (defaults to \fB$HOME/.npmrc\fR; configurable via CLI option \fB--userconfig\fR or environment variable \fB$NPM_CONFIG_USERCONFIG\fR)
+.IP \(bu 4
+global configuration file (defaults to \fB$PREFIX/etc/npmrc\fR; configurable via CLI option \fB--globalconfig\fR or environment variable \fB$NPM_CONFIG_GLOBALCONFIG\fR)
+.IP \(bu 4
+npm's built-in configuration file (\fB/path/to/npm/npmrc\fR)
+.RE 0
+
+.P
+See npm help npmrc for more details.
+.SS "Default Configs"
+.P
+Run \fBnpm config ls -l\fR to see a set of configuration parameters that are internal to npm, and are defaults if nothing else is specified.
+.SS "Shorthands and Other CLI Niceties"
+.P
+The following shorthands are parsed on the command-line:
+.RS 0
+.IP \(bu 4
+\fB-a\fR: \fB--all\fR
+.IP \(bu 4
+\fB--enjoy-by\fR: \fB--before\fR
+.IP \(bu 4
+\fB-c\fR: \fB--call\fR
+.IP \(bu 4
+\fB--desc\fR: \fB--description\fR
+.IP \(bu 4
+\fB-f\fR: \fB--force\fR
+.IP \(bu 4
+\fB-g\fR: \fB--global\fR
+.IP \(bu 4
+\fB--iwr\fR: \fB--include-workspace-root\fR
+.IP \(bu 4
+\fB-L\fR: \fB--location\fR
+.IP \(bu 4
+\fB-d\fR: \fB--loglevel info\fR
+.IP \(bu 4
+\fB-s\fR: \fB--loglevel silent\fR
+.IP \(bu 4
+\fB--silent\fR: \fB--loglevel silent\fR
+.IP \(bu 4
+\fB--ddd\fR: \fB--loglevel silly\fR
+.IP \(bu 4
+\fB--dd\fR: \fB--loglevel verbose\fR
+.IP \(bu 4
+\fB--verbose\fR: \fB--loglevel verbose\fR
+.IP \(bu 4
+\fB-q\fR: \fB--loglevel warn\fR
+.IP \(bu 4
+\fB--quiet\fR: \fB--loglevel warn\fR
+.IP \(bu 4
+\fB-l\fR: \fB--long\fR
+.IP \(bu 4
+\fB-m\fR: \fB--message\fR
+.IP \(bu 4
+\fB--local\fR: \fB--no-global\fR
+.IP \(bu 4
+\fB-n\fR: \fB--no-yes\fR
+.IP \(bu 4
+\fB--no\fR: \fB--no-yes\fR
+.IP \(bu 4
+\fB-p\fR: \fB--parseable\fR
+.IP \(bu 4
+\fB--porcelain\fR: \fB--parseable\fR
+.IP \(bu 4
+\fB-C\fR: \fB--prefix\fR
+.IP \(bu 4
+\fB--readonly\fR: \fB--read-only\fR
+.IP \(bu 4
+\fB--reg\fR: \fB--registry\fR
+.IP \(bu 4
+\fB-S\fR: \fB--save\fR
+.IP \(bu 4
+\fB-B\fR: \fB--save-bundle\fR
+.IP \(bu 4
+\fB-D\fR: \fB--save-dev\fR
+.IP \(bu 4
+\fB-E\fR: \fB--save-exact\fR
+.IP \(bu 4
+\fB-O\fR: \fB--save-optional\fR
+.IP \(bu 4
+\fB-P\fR: \fB--save-prod\fR
+.IP \(bu 4
+\fB-?\fR: \fB--usage\fR
+.IP \(bu 4
+\fB-h\fR: \fB--usage\fR
+.IP \(bu 4
+\fB-H\fR: \fB--usage\fR
+.IP \(bu 4
+\fB--help\fR: \fB--usage\fR
+.IP \(bu 4
+\fB-v\fR: \fB--version\fR
+.IP \(bu 4
+\fB-w\fR: \fB--workspace\fR
+.IP \(bu 4
+\fB--ws\fR: \fB--workspaces\fR
+.IP \(bu 4
+\fB-y\fR: \fB--yes\fR
+.RE 0
+
+.P
+If the specified configuration param resolves unambiguously to a known configuration parameter, then it is expanded to that configuration parameter. For example:
+.P
+.RS 2
+.nf
+npm ls --par
+# same as:
+npm ls --parseable
+.fi
+.RE
+.P
+If multiple single-character shorthands are strung together, and the resulting combination is unambiguously not some other configuration param, then it is expanded to its various component pieces. For example:
+.P
+.RS 2
+.nf
+npm ls -gpld
+# same as:
+npm ls --global --parseable --long --loglevel info
+.fi
+.RE
+.SS "Config Settings"
+.SS "\fB_auth\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+A basic-auth string to use when authenticating against the npm registry. This will ONLY be used to authenticate against the npm registry. For other registries you will need to scope it like "//other-registry.tld/:_auth"
+.P
+Warning: This should generally not be set via a command-line option. It is safer to use a registry-provided authentication bearer token stored in the ~/.npmrc file by running \fBnpm login\fR.
+.SS "\fBaccess\fR"
+.RS 0
+.IP \(bu 4
+Default: 'public' for new packages, existing packages it will not change the current level
+.IP \(bu 4
+Type: null, "restricted", or "public"
+.RE 0
+
+.P
+If you do not want your scoped package to be publicly viewable (and installable) set \fB--access=restricted\fR.
+.P
+Unscoped packages cannot be set to \fBrestricted\fR.
+.P
+Note: This defaults to not changing the current access level for existing packages. Specifying a value of \fBrestricted\fR or \fBpublic\fR during publish will change the access for an existing package the same way that \fBnpm access set
+status\fR would.
+.SS "\fBall\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When running \fBnpm outdated\fR and \fBnpm ls\fR, setting \fB--all\fR will show all outdated or installed packages, rather than only those directly depended upon by the current project.
+.SS "\fBallow-git\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-same-version\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prevents throwing an error when \fBnpm version\fR is used to set the new version to the same value as the current version.
+.SS "\fBaudit\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" submit audit reports alongside the current npm command to the default registry and all registries configured for scopes. See the documentation for npm help audit for details on what is submitted.
+.SS "\fBaudit-level\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "info", "low", "moderate", "high", "critical", or "none"
+.RE 0
+
+.P
+The minimum level of vulnerability for \fBnpm audit\fR to exit with a non-zero exit code.
+.SS "\fBauth-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "web"
+.IP \(bu 4
+Type: "legacy" or "web"
+.RE 0
+
+.P
+What authentication strategy to use with \fBlogin\fR. Note that if an \fBotp\fR config is given, this value will always be set to \fBlegacy\fR.
+.SS "\fBbefore\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Date
+.RE 0
+
+.P
+If passed to \fBnpm install\fR, will rebuild the npm tree such that only versions that were available \fBon or before\fR the given date are installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
+.P
+This config cannot be used with: \fBmin-release-age\fR
+.SS "\fBbin-links\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tells npm to create symlinks (or \fB.cmd\fR shims on Windows) for package executables.
+.P
+Set to false to have it not do this. This can be used to work around the fact that some file systems don't support symlinks, even on ostensibly Unix systems.
+.SS "\fBbrowser\fR"
+.RS 0
+.IP \(bu 4
+Default: macOS: \fB"open"\fR, Windows: \fB"start"\fR, Others: \fB"xdg-open"\fR
+.IP \(bu 4
+Type: null, Boolean, or String
+.RE 0
+
+.P
+The browser that is called by npm commands to open websites.
+.P
+Set to \fBfalse\fR to suppress browser behavior and instead print urls to terminal.
+.P
+Set to \fBtrue\fR to use default system URL opener.
+.SS "\fBbypass-2fa\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, setting this to true will allow the token to bypass two-factor authentication. This is useful for automation and CI/CD workflows.
+.SS "\fBca\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+The Certificate Authority signing certificate that is trusted for SSL connections to the registry. Values should be in PEM format (Windows calls it "Base-64 encoded X.509 (.CER)") with newlines replaced by the string "\[rs]n". For example:
+.P
+.RS 2
+.nf
+ca="-----BEGIN CERTIFICATE-----\[rs]nXXXX\[rs]nXXXX\[rs]n-----END CERTIFICATE-----"
+.fi
+.RE
+.P
+Set to \fBnull\fR to only allow "known" registrars, or to a specific CA cert to trust only that specific signing authority.
+.P
+Multiple CAs can be trusted by specifying an array of certificates:
+.P
+.RS 2
+.nf
+ca\[lB]\[rB]="..."
+ca\[lB]\[rB]="..."
+.fi
+.RE
+.P
+See also the \fBstrict-ssl\fR config.
+.SS "\fBcache\fR"
+.RS 0
+.IP \(bu 4
+Default: Windows: \fB%LocalAppData%\[rs]npm-cache\fR, Posix: \fB~/.npm\fR
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+The location of npm's cache directory.
+.SS "\fBcafile\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+A path to a file containing one or multiple Certificate Authority signing certificates. Similar to the \fBca\fR setting, but allows for multiple CA's, as well as for the CA information to be stored in a file on disk.
+.SS "\fBcall\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Optional companion option for \fBnpm exec\fR, \fBnpx\fR that allows for specifying a custom command to be run along with the installed packages.
+.P
+.RS 2
+.nf
+npm exec --package yo --package generator-node --call "yo node"
+.fi
+.RE
+.SS "\fBcidr\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+This is a list of CIDR address to be used when configuring limited access tokens with the \fBnpm token create\fR command.
+.SS "\fBcolor\fR"
+.RS 0
+.IP \(bu 4
+Default: true unless the NO_COLOR environ is set to something other than '0'
+.IP \(bu 4
+Type: "always" or Boolean
+.RE 0
+
+.P
+If false, never shows colors. If \fB"always"\fR then always shows colors. If true, then only prints color codes for tty file descriptors.
+.SS "\fBcommit-hooks\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run git commit hooks when using the \fBnpm version\fR command.
+.SS "\fBcpu\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override CPU architecture of native modules to install. Acceptable values are same as \fBcpu\fR field of package.json, which comes from \fBprocess.arch\fR.
+.SS "\fBdepth\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBInfinity\fR if \fB--all\fR is set; otherwise, \fB0\fR
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+The depth to go when recursing packages for \fBnpm ls\fR.
+.P
+If not set, \fBnpm ls\fR will show only the immediate dependencies of the root project. If \fB--all\fR is set, then npm will show all dependencies by default.
+.SS "\fBdescription\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show the description in \fBnpm search\fR
+.SS "\fBdiff\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Define arguments to compare in \fBnpm diff\fR.
+.SS "\fBdiff-dst-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: "b/"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Destination prefix to be used in \fBnpm diff\fR output.
+.SS "\fBdiff-ignore-all-space\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Ignore whitespace when comparing lines in \fBnpm diff\fR.
+.SS "\fBdiff-name-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prints only filenames when using \fBnpm diff\fR.
+.SS "\fBdiff-no-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Do not show any source or destination prefix in \fBnpm diff\fR output.
+.P
+Note: this causes \fBnpm diff\fR to ignore the \fB--diff-src-prefix\fR and \fB--diff-dst-prefix\fR configs.
+.SS "\fBdiff-src-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: "a/"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Source prefix to be used in \fBnpm diff\fR output.
+.SS "\fBdiff-text\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Treat all files as text in \fBnpm diff\fR.
+.SS "\fBdiff-unified\fR"
+.RS 0
+.IP \(bu 4
+Default: 3
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The number of lines of context to print in \fBnpm diff\fR.
+.SS "\fBdry-run\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR.
+.P
+Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc.
+.SS "\fBeditor\fR"
+.RS 0
+.IP \(bu 4
+Default: The EDITOR or VISUAL environment variables, or '%SYSTEMROOT%\[rs]notepad.exe' on Windows, or 'vi' on Unix systems
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The command to run for \fBnpm edit\fR and \fBnpm config edit\fR.
+.SS "\fBengine-strict\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, then npm will stubbornly refuse to install (or even consider installing) any package that claims to not be compatible with the current Node.js version.
+.P
+This can be overridden by setting the \fB--force\fR flag.
+.SS "\fBexpect-result-count\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+Tells to expect a specific number of results from the command.
+.P
+This config cannot be used with: \fBexpect-results\fR
+.SS "\fBexpect-results\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Tells npm whether or not to expect results from the command. Can be either true (expect some results) or false (expect no results).
+.P
+This config cannot be used with: \fBexpect-result-count\fR
+.SS "\fBexpires\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this sets the expiration in days. If not specified, the server will determine the default expiration.
+.SS "\fBfetch-retries\fR"
+.RS 0
+.IP \(bu 4
+Default: 2
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The "retries" config for the \fBretry\fR module to use when fetching packages from the registry.
+.P
+npm will retry idempotent read requests to the registry in the case of network failures or 5xx HTTP errors.
+.SS "\fBfetch-retry-factor\fR"
+.RS 0
+.IP \(bu 4
+Default: 10
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The "factor" config for the \fBretry\fR module to use when fetching packages.
+.SS "\fBfetch-retry-maxtimeout\fR"
+.RS 0
+.IP \(bu 4
+Default: 60000 (1 minute)
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The "maxTimeout" config for the \fBretry\fR module to use when fetching packages.
+.SS "\fBfetch-retry-mintimeout\fR"
+.RS 0
+.IP \(bu 4
+Default: 10000 (10 seconds)
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The "minTimeout" config for the \fBretry\fR module to use when fetching packages.
+.SS "\fBfetch-timeout\fR"
+.RS 0
+.IP \(bu 4
+Default: 300000 (5 minutes)
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The maximum amount of time to wait for HTTP requests to complete.
+.SS "\fBforce\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Removes various protections against unfortunate side effects, common mistakes, unnecessary performance degradation, and malicious input.
+.RS 0
+.IP \(bu 4
+Allow clobbering non-npm files in global installs.
+.IP \(bu 4
+Allow the \fBnpm version\fR command to work on an unclean git repository.
+.IP \(bu 4
+Allow deleting the cache folder with \fBnpm cache clean\fR.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of npm.
+.IP \(bu 4
+Allow installing packages that have an \fBengines\fR declaration requiring a different version of \fBnode\fR, even if \fB--engine-strict\fR is enabled.
+.IP \(bu 4
+Allow \fBnpm audit fix\fR to install modules outside your stated dependency range (including SemVer-major changes).
+.IP \(bu 4
+Allow unpublishing all versions of a published package.
+.IP \(bu 4
+Allow conflicting peerDependencies to be installed in the root project.
+.IP \(bu 4
+Implicitly set \fB--yes\fR during \fBnpm init\fR.
+.IP \(bu 4
+Allow clobbering existing values in \fBnpm pkg\fR
+.IP \(bu 4
+Allow unpublishing of entire packages (not just a single version).
+.RE 0
+
+.P
+If you don't have a clear idea of what you want to do, it is strongly recommended that you do not use this option!
+.SS "\fBforeground-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBfalse\fR unless when using \fBnpm pack\fR or \fBnpm publish\fR where it defaults to \fBtrue\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Run all build scripts (ie, \fBpreinstall\fR, \fBinstall\fR, and \fBpostinstall\fR) scripts for installed packages in the foreground process, sharing standard input, output, and error with the main npm process.
+.P
+Note that this will generally make installs run slower, and be much noisier, but can be useful for debugging.
+.SS "\fBformat-package-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Format \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR as a human readable file.
+.SS "\fBfund\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When "true" displays the message at the end of each \fBnpm install\fR acknowledging the number of dependencies looking for funding. See npm help fund for details.
+.SS "\fBgit\fR"
+.RS 0
+.IP \(bu 4
+Default: "git"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The command to use for git commands. If git is installed on the computer, but is not in the \fBPATH\fR, then set this to the full path to the git binary.
+.SS "\fBgit-tag-version\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Tag the commit when using the \fBnpm version\fR command. Setting this to false results in no commit being made at all.
+.SS "\fBglobal\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Operates in "global" mode, so that packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBglobalconfig\fR"
+.RS 0
+.IP \(bu 4
+Default: The global --prefix setting plus 'etc/npmrc'. For example, '/usr/local/etc/npmrc'
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+The config file to read for global config options.
+.SS "\fBheading\fR"
+.RS 0
+.IP \(bu 4
+Default: "npm"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The string that starts all the debugging log output.
+.SS "\fBhttps-proxy\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or URL
+.RE 0
+
+.P
+A proxy to use for outgoing https requests. If the \fBHTTPS_PROXY\fR or \fBhttps_proxy\fR or \fBHTTP_PROXY\fR or \fBhttp_proxy\fR environment variables are set, proxy settings will be honored by the underlying \fBmake-fetch-happen\fR library.
+.SS "\fBif-present\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm will not exit with an error code when \fBrun\fR is invoked for a script that isn't defined in the \fBscripts\fR section of \fBpackage.json\fR. This option can be used when it's desirable to optionally run a script when it's present and fail if the script fails. This is useful, for example, when running scripts that may only apply for some builds in an otherwise generic CI setup.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBignore-scripts\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, npm does not run scripts specified in package.json files.
+.P
+Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBinclude\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: "prod", "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Option that allows for defining which types of dependencies to install.
+.P
+This is the inverse of \fB--omit=<type>\fR.
+.P
+Dependency types specified in \fB--include\fR will not be omitted, regardless of the order in which omit/include are specified on the command-line.
+.SS "\fBinclude-attestations\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When used with \fBnpm audit signatures --json\fR, includes the full sigstore attestation bundles in the JSON output for each verified package. The bundles contain DSSE envelopes, verification material, and transparency log entries.
+.SS "\fBinclude-staged\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Allow installing "staged" published packages, as defined by \fBnpm RFC PR #92\fR \fI\(lahttps://github.com/npm/rfcs/pull/92\(ra\fR.
+.P
+This is experimental, and not implemented by the npm public registry.
+.SS "\fBinclude-workspace-root\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Include the workspace root when workspaces are enabled for a command.
+.P
+When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBinit-author-email\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package author's email.
+.SS "\fBinit-author-name\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package author's name.
+.SS "\fBinit-author-url\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: "" or URL
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package author's homepage.
+.SS "\fBinit-license\fR"
+.RS 0
+.IP \(bu 4
+Default: "ISC"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package license.
+.SS "\fBinit-module\fR"
+.RS 0
+.IP \(bu 4
+Default: "~/.npm-init.js"
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+A module that will be loaded by the \fBnpm init\fR command. See the documentation for the \fBinit-package-json\fR \fI\(lahttps://github.com/npm/init-package-json\(ra\fR module for more information, or npm help init.
+.SS "\fBinit-private\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+The value \fBnpm init\fR should use by default for the package's private flag.
+.SS "\fBinit-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "commonjs"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The value that \fBnpm init\fR should use by default for the package.json type field.
+.SS "\fBinit-version\fR"
+.RS 0
+.IP \(bu 4
+Default: "1.0.0"
+.IP \(bu 4
+Type: SemVer string
+.RE 0
+
+.P
+The value that \fBnpm init\fR should use by default for the package version number, if not already set in package.json.
+.SS "\fBinstall-links\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set file: protocol dependencies will be packed and installed as regular dependencies instead of creating a symlink. This option has no effect on workspaces.
+.SS "\fBinstall-strategy\fR"
+.RS 0
+.IP \(bu 4
+Default: "hoisted"
+.IP \(bu 4
+Type: "hoisted", "nested", "shallow", or "linked"
+.RE 0
+
+.P
+Sets the strategy for installing packages in node_modules. hoisted (default): Install non-duplicated in top-level, and duplicated as necessary within directory structure. nested: (formerly --legacy-bundling) install in place, no hoisting. shallow (formerly --global-style) only install direct deps at top-level. linked: (experimental) install in node_modules/.store, link in place, unhoisted.
+.SS "\fBjson\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to output JSON data, rather than the normal output.
+.RS 0
+.IP \(bu 4
+In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR.
+.RE 0
+
+.P
+Not supported by all npm commands.
+.SS "\fBlegacy-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Causes npm to completely ignore \fBpeerDependencies\fR when building a package tree, as in npm versions 3 through 6.
+.P
+If a package cannot be installed because of overly strict \fBpeerDependencies\fR that collide, it provides a way to move forward resolving the situation.
+.P
+This differs from \fB--omit=peer\fR, in that \fB--omit=peer\fR will avoid unpacking \fBpeerDependencies\fR on disk, but will still design a tree such that \fBpeerDependencies\fR \fIcould\fR be unpacked in a correct place.
+.P
+Use of \fBlegacy-peer-deps\fR is not recommended, as it will not enforce the \fBpeerDependencies\fR contract that meta-dependencies may rely on.
+.SS "\fBlibc\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override libc of native modules to install. Acceptable values are same as \fBlibc\fR field of package.json
+.SS "\fBlink\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Used with \fBnpm ls\fR, limiting output to only those packages that are linked.
+.SS "\fBlocal-address\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: IP Address
+.RE 0
+
+.P
+The IP address of the local interface to use when making connections to the npm registry. Must be IPv4 in versions of Node prior to 0.12.
+.SS "\fBlocation\fR"
+.RS 0
+.IP \(bu 4
+Default: "user" unless \fB--global\fR is passed, which will also set this value to "global"
+.IP \(bu 4
+Type: "global", "user", or "project"
+.RE 0
+
+.P
+When passed to \fBnpm config\fR this refers to which config file to use.
+.P
+When set to "global" mode, packages are installed into the \fBprefix\fR folder instead of the current working directory. See npm help folders for more on the differences in behavior.
+.RS 0
+.IP \(bu 4
+packages are installed into the \fB{prefix}/lib/node_modules\fR folder, instead of the current working directory.
+.IP \(bu 4
+bin files are linked to \fB{prefix}/bin\fR
+.IP \(bu 4
+man pages are linked to \fB{prefix}/share/man\fR
+.RE 0
+
+.SS "\fBlockfile-version\fR"
+.RS 0
+.IP \(bu 4
+Default: Version 3 if no lockfile, auto-converting v1 lockfiles to v3; otherwise, maintain current lockfile version.
+.IP \(bu 4
+Type: null, 1, 2, 3, "1", "2", or "3"
+.RE 0
+
+.P
+Set the lockfile format version to be used in package-lock.json and npm-shrinkwrap-json files. Possible options are:
+.P
+1: The lockfile version used by npm versions 5 and 6. Lacks some data that is used during the install, resulting in slower and possibly less deterministic installs. Prevents lockfile churn when interoperating with older npm versions.
+.P
+2: The default lockfile version used by npm version 7 and 8. Includes both the version 1 lockfile data and version 3 lockfile data, for maximum determinism and interoperability, at the expense of more bytes on disk.
+.P
+3: Only the new lockfile information introduced in npm version 7. Smaller on disk than lockfile version 2, but not interoperable with older npm versions. Ideal if all users are on npm version 7 and higher.
+.SS "\fBloglevel\fR"
+.RS 0
+.IP \(bu 4
+Default: "notice"
+.IP \(bu 4
+Type: "silent", "error", "warn", "notice", "http", "info", "verbose", or "silly"
+.RE 0
+
+.P
+What level of logs to report. All logs are written to a debug log, with the path to that file printed if the execution of a command fails.
+.P
+Any logs of a higher level than the setting are shown. The default is "notice".
+.P
+See also the \fBforeground-scripts\fR config.
+.SS "\fBlogs-dir\fR"
+.RS 0
+.IP \(bu 4
+Default: A directory named \fB_logs\fR inside the cache
+.IP \(bu 4
+Type: null or Path
+.RE 0
+
+.P
+The location of npm's log directory. See npm help logging for more information.
+.SS "\fBlogs-max\fR"
+.RS 0
+.IP \(bu 4
+Default: 10
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The maximum number of log files to store.
+.P
+If set to 0, no log files will be written for the current run.
+.SS "\fBlong\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show extended information in \fBls\fR, \fBsearch\fR, and \fBhelp-search\fR.
+.SS "\fBmaxsockets\fR"
+.RS 0
+.IP \(bu 4
+Default: 15
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The maximum number of connections to use per origin (protocol/host/port combination).
+.SS "\fBmessage\fR"
+.RS 0
+.IP \(bu 4
+Default: "%s"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Commit message which is used by \fBnpm version\fR when creating version commit.
+.P
+Any "%s" in the message will be replaced with the version number.
+.SS "\fBmin-release-age\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
+.P
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
+.P
+This config cannot be used with: \fBbefore\fR
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBname\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this sets the name/description for the token.
+.SS "\fBnode-gyp\fR"
+.RS 0
+.IP \(bu 4
+Default: The path to the node-gyp bin that ships with npm
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+This is the location of the "node-gyp" bin. By default it uses one that ships with npm itself.
+.P
+You can use this config to specify your own "node-gyp" to run when it is required to build a package.
+.SS "\fBnode-options\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Options to pass through to Node.js via the \fBNODE_OPTIONS\fR environment variable. This does not impact how npm itself is executed but it does impact how lifecycle scripts are called.
+.SS "\fBnoproxy\fR"
+.RS 0
+.IP \(bu 4
+Default: The value of the NO_PROXY environment variable
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Domain extensions that should bypass any proxies.
+.P
+Also accepts a comma-delimited string.
+.SS "\fBoffline\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Force offline mode: no network requests will be done during install. To allow the CLI to fill in missing cache data, see \fB--prefer-offline\fR.
+.SS "\fBomit\fR"
+.RS 0
+.IP \(bu 4
+Default: 'dev' if the \fBNODE_ENV\fR environment variable is set to 'production'; otherwise, empty.
+.IP \(bu 4
+Type: "dev", "optional", or "peer" (can be set multiple times)
+.RE 0
+
+.P
+Dependency types to omit from the installation tree on disk.
+.P
+Note that these dependencies \fIare\fR still resolved and added to the \fBpackage-lock.json\fR or \fBnpm-shrinkwrap.json\fR file. They are just not physically installed on disk.
+.P
+If a package type appears in both the \fB--include\fR and \fB--omit\fR lists, then it will be included.
+.P
+If the resulting omit list includes \fB'dev'\fR, then the \fBNODE_ENV\fR environment variable will be set to \fB'production'\fR for all lifecycle scripts.
+.SS "\fBomit-lockfile-registry-resolved\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+This option causes npm to create lock files without a \fBresolved\fR key for registry dependencies. Subsequent installs will need to resolve tarball endpoints with the configured registry, likely resulting in a longer install time.
+.SS "\fBorgs\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this limits the token access to specific organizations.
+.SS "\fBorgs-permission\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "read-only", "read-write", or "no-access"
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, sets the permission level for organizations. Options are "read-only", "read-write", or "no-access".
+.SS "\fBos\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Override OS of native modules to install. Acceptable values are same as \fBos\fR field of package.json, which comes from \fBprocess.platform\fR.
+.SS "\fBotp\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR.
+.P
+If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one.
+.SS "\fBpack-destination\fR"
+.RS 0
+.IP \(bu 4
+Default: "."
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Directory in which \fBnpm pack\fR will save tarballs.
+.SS "\fBpackage\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+The package or packages to install for npm help exec
+.SS "\fBpackage-lock\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to false, then ignore \fBpackage-lock.json\fR files when installing. This will also prevent \fIwriting\fR \fBpackage-lock.json\fR if \fBsave\fR is true.
+.SS "\fBpackage-lock-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the current operation will only use the \fBpackage-lock.json\fR, ignoring \fBnode_modules\fR.
+.P
+For \fBupdate\fR this means only the \fBpackage-lock.json\fR will be updated, instead of checking \fBnode_modules\fR and downloading dependencies.
+.P
+For \fBlist\fR this means the output will be based on the tree described by the \fBpackage-lock.json\fR, rather than the contents of \fBnode_modules\fR.
+.SS "\fBpackages\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this limits the token access to specific packages.
+.SS "\fBpackages-all\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, grants the token access to all packages instead of limiting to specific packages.
+.SS "\fBpackages-and-scopes-permission\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "read-only", "read-write", or "no-access"
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, sets the permission level for packages and scopes. Options are "read-only", "read-write", or "no-access".
+.SS "\fBparseable\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Output parseable results from commands that write to standard output. For \fBnpm search\fR, this will be tab-separated table format.
+.SS "\fBpassword\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Password for authentication. Can be provided via command line when creating tokens, though it's generally safer to be prompted for it.
+.SS "\fBprefer-dedupe\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Prefer to deduplicate packages if possible, rather than choosing a newer version of a dependency.
+.SS "\fBprefer-offline\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, staleness checks for cached data will be bypassed, but missing data will be requested from the server. To force full offline mode, use \fB--offline\fR.
+.SS "\fBprefer-online\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, staleness checks for cached data will be forced, making the CLI look for updates immediately even for fresh package data.
+.SS "\fBprefix\fR"
+.RS 0
+.IP \(bu 4
+Default: In global mode, the folder where the node executable is installed. Otherwise, the nearest parent folder containing either a package.json file or a node_modules folder.
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+The location to install global items. If set on the command line, then it forces non-global commands to run in the specified folder.
+.SS "\fBpreid\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The "prerelease identifier" to use as a prefix for the "prerelease" part of a semver. Like the \fBrc\fR in \fB1.2.0-rc.8\fR.
+.SS "\fBprogress\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR when not in CI and both stderr and stdout are TTYs and not in a dumb terminal
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to \fBtrue\fR, npm will display a progress bar during time intensive operations, if \fBprocess.stderr\fR and \fBprocess.stdout\fR are a TTY.
+.P
+Set to \fBfalse\fR to suppress the progress bar.
+.SS "\fBprovenance\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When publishing from a supported cloud CI/CD system, the package will be publicly linked to where it was built and published from.
+.P
+This config cannot be used with: \fBprovenance-file\fR
+.SS "\fBprovenance-file\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+When publishing, the provenance bundle at the given path will be used.
+.P
+This config cannot be used with: \fBprovenance\fR
+.SS "\fBproxy\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, false, or URL
+.RE 0
+
+.P
+A proxy to use for outgoing http requests. If the \fBHTTP_PROXY\fR or \fBhttp_proxy\fR environment variables are set, proxy settings will be honored by the underlying \fBrequest\fR library.
+.SS "\fBread-only\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+This is used to mark a token as unable to publish when configuring limited access tokens with the \fBnpm token create\fR command.
+.SS "\fBrebuild-bundle\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Rebuild bundled dependencies after installation.
+.SS "\fBregistry\fR"
+.RS 0
+.IP \(bu 4
+Default: "https://registry.npmjs.org/"
+.IP \(bu 4
+Type: URL
+.RE 0
+
+.P
+The base URL of the npm registry.
+.SS "\fBreplace-registry-host\fR"
+.RS 0
+.IP \(bu 4
+Default: "npmjs"
+.IP \(bu 4
+Type: "npmjs", "never", "always", or String
+.RE 0
+
+.P
+Defines behavior for replacing the registry host in a lockfile with the configured registry.
+.P
+The default behavior is to replace package dist URLs from the default registry (https://registry.npmjs.org) to the configured registry. If set to "never", then use the registry value. If set to "always", then replace the registry host with the configured host every time.
+.P
+You may also specify a bare hostname (e.g., "registry.npmjs.org").
+.SS "\fBsave\fR"
+.RS 0
+.IP \(bu 4
+Default: \fBtrue\fR unless when using \fBnpm update\fR where it defaults to \fBfalse\fR
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a \fBpackage.json\fR file as dependencies.
+.P
+When used with the \fBnpm rm\fR command, removes the dependency from \fBpackage.json\fR.
+.P
+Will also prevent writing to \fBpackage-lock.json\fR if set to \fBfalse\fR.
+.SS "\fBsave-bundle\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If a package would be saved at install time by the use of \fB--save\fR, \fB--save-dev\fR, or \fB--save-optional\fR, then also put it in the \fBbundleDependencies\fR list.
+.P
+Ignored if \fB--save-peer\fR is set, since peerDependencies cannot be bundled.
+.SS "\fBsave-dev\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a package.json file as \fBdevDependencies\fR.
+.P
+This config cannot be used with: \fBsave-optional\fR, \fBsave-peer\fR, \fBsave-prod\fR
+.SS "\fBsave-exact\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Dependencies saved to package.json will be configured with an exact version rather than using npm's default semver range operator.
+.SS "\fBsave-optional\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a package.json file as \fBoptionalDependencies\fR.
+.P
+This config cannot be used with: \fBsave-dev\fR, \fBsave-peer\fR, \fBsave-prod\fR
+.SS "\fBsave-peer\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages to a package.json file as \fBpeerDependencies\fR
+.P
+This config cannot be used with: \fBsave-dev\fR, \fBsave-optional\fR, \fBsave-prod\fR
+.SS "\fBsave-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: "^"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Configure how versions of packages installed to a package.json file via \fB--save\fR or \fB--save-dev\fR get prefixed.
+.P
+For example if a package has version \fB1.2.3\fR, by default its version is set to \fB^1.2.3\fR which allows minor upgrades for that package, but after \fBnpm
+config set save-prefix='~'\fR it would be set to \fB~1.2.3\fR which only allows patch upgrades.
+.SS "\fBsave-prod\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Save installed packages into \fBdependencies\fR specifically. This is useful if a package already exists in \fBdevDependencies\fR or \fBoptionalDependencies\fR, but you want to move it to be a non-optional production dependency.
+.P
+This is the default behavior if \fB--save\fR is true, and neither \fB--save-dev\fR or \fB--save-optional\fR are true.
+.P
+This config cannot be used with: \fBsave-dev\fR, \fBsave-optional\fR, \fBsave-peer\fR
+.SS "\fBsbom-format\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: "cyclonedx" or "spdx"
+.RE 0
+
+.P
+SBOM format to use when generating SBOMs.
+.SS "\fBsbom-type\fR"
+.RS 0
+.IP \(bu 4
+Default: "library"
+.IP \(bu 4
+Type: "library", "application", or "framework"
+.RE 0
+
+.P
+The type of package described by the generated SBOM. For SPDX, this is the value for the \fBprimaryPackagePurpose\fR field. For CycloneDX, this is the value for the \fBtype\fR field.
+.SS "\fBscope\fR"
+.RS 0
+.IP \(bu 4
+Default: the scope of the current project, if any, or ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Associate an operation with a scope for a scoped registry.
+.P
+Useful when logging in to or out of a private registry:
+.P
+.RS 2
+.nf
+# log in, linking the scope to the custom registry
+npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+# log out, removing the link and the auth token
+npm logout --scope=@mycorp
+.fi
+.RE
+.P
+This will cause \fB@mycorp\fR to be mapped to the registry for future installation of packages specified according to the pattern \fB@mycorp/package\fR.
+.P
+This will also cause \fBnpm init\fR to create a scoped package.
+.P
+.RS 2
+.nf
+# accept all defaults, and create a package named "@foo/whatever",
+# instead of just named "whatever"
+npm init --scope=@foo --yes
+.fi
+.RE
+.SS "\fBscopes\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String (can be set multiple times)
+.RE 0
+
+.P
+When creating a Granular Access Token with \fBnpm token create\fR, this limits the token access to specific scopes. Provide a scope name (with or without @ prefix).
+.SS "\fBscript-shell\fR"
+.RS 0
+.IP \(bu 4
+Default: '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+The shell to use for scripts run with the \fBnpm exec\fR, \fBnpm run\fR and \fBnpm
+init <package-spec>\fR commands.
+.SS "\fBsearchexclude\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Space-separated options that limit the results from search.
+.SS "\fBsearchlimit\fR"
+.RS 0
+.IP \(bu 4
+Default: 20
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+Number of items to limit search results to. Will not apply at all to legacy searches.
+.SS "\fBsearchopts\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Space-separated options that are always passed to search.
+.SS "\fBsearchstaleness\fR"
+.RS 0
+.IP \(bu 4
+Default: 900
+.IP \(bu 4
+Type: Number
+.RE 0
+
+.P
+The age of the cache, in seconds, before another registry request is made if using legacy search endpoint.
+.SS "\fBshell\fR"
+.RS 0
+.IP \(bu 4
+Default: SHELL environment variable, or "bash" on Posix, or "cmd.exe" on Windows
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The shell to run for the \fBnpm explore\fR command.
+.SS "\fBsign-git-commit\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, then the \fBnpm version\fR command will commit the new package version using \fB-S\fR to add a signature.
+.P
+Note that git requires you to have set up GPG keys in your git configs for this to work properly.
+.SS "\fBsign-git-tag\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, then the \fBnpm version\fR command will tag the version using \fB-s\fR to add a signature.
+.P
+Note that git requires you to have set up GPG keys in your git configs for this to work properly.
+.SS "\fBstrict-peer-deps\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to \fBtrue\fR, and \fB--legacy-peer-deps\fR is not set, then \fIany\fR conflicting \fBpeerDependencies\fR will be treated as an install failure, even if npm could reasonably guess the appropriate resolution based on non-peer dependency relationships.
+.P
+By default, conflicting \fBpeerDependencies\fR deep in the dependency graph will be resolved using the nearest non-peer dependency specification, even if doing so will result in some packages receiving a peer dependency outside the range set in their package's \fBpeerDependencies\fR object.
+.P
+When such an override is performed, a warning is printed, explaining the conflict and the packages involved. If \fB--strict-peer-deps\fR is set, then this warning is treated as a failure.
+.SS "\fBstrict-ssl\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Whether or not to do SSL key validation when making requests to the registry via https.
+.P
+See also the \fBca\fR config.
+.SS "\fBtag\fR"
+.RS 0
+.IP \(bu 4
+Default: "latest"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+If you ask npm to install a package and don't tell it a specific version, then it will install the specified tag.
+.P
+It is the tag added to the package@version specified in the \fBnpm dist-tag
+add\fR command, if no explicit tag is given.
+.P
+When used by the \fBnpm diff\fR command, this is the tag used to fetch the tarball that will be compared with the local files by default.
+.P
+If used in the \fBnpm publish\fR command, this is the tag that will be added to the package submitted to the registry.
+.SS "\fBtag-version-prefix\fR"
+.RS 0
+.IP \(bu 4
+Default: "v"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+If set, alters the prefix used when tagging a new version when performing a version increment using \fBnpm version\fR. To remove the prefix altogether, set it to the empty string: \fB""\fR.
+.P
+Because other tools may rely on the convention that npm version tags look like \fBv1.0.0\fR, \fIonly use this property if it is absolutely necessary\fR. In particular, use care when overriding this setting for public packages.
+.SS "\fBtiming\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, writes timing information to a process specific json file in the cache or \fBlogs-dir\fR. The file name ends with \fB-timing.json\fR.
+.P
+You can quickly view it with this \fBjson\fR \fI\(lahttps://npm.im/json\(ra\fR command line: \fBcat ~/.npm/_logs/*-timing.json | npm exec -- json -g\fR.
+.P
+Timing information will also be reported in the terminal. To suppress this while still writing the timing file, use \fB--silent\fR.
+.SS "\fBtoken-description\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.RE 0
+
+.P
+Description text for the token when using \fBnpm token create\fR.
+.SS "\fBumask\fR"
+.RS 0
+.IP \(bu 4
+Default: 0
+.IP \(bu 4
+Type: Octal numeric string in range 0000..0777 (0..511)
+.RE 0
+
+.P
+The "umask" value to use when setting the file creation mode on files and folders.
+.P
+Folders and executables are given a mode which is \fB0o777\fR masked against this value. Other files are given a mode which is \fB0o666\fR masked against this value.
+.P
+Note that the underlying system will \fIalso\fR apply its own umask value to files and folders that are created, and npm does not circumvent this, but rather adds the \fB--umask\fR config to it.
+.P
+Thus, the effective default umask value on most POSIX systems is 0o22, meaning that folders and executables are created with a mode of 0o755 and other files are created with a mode of 0o644.
+.SS "\fBunicode\fR"
+.RS 0
+.IP \(bu 4
+Default: false on windows, true on mac/unix systems with a unicode locale, as defined by the \fBLC_ALL\fR, \fBLC_CTYPE\fR, or \fBLANG\fR environment variables.
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+When set to true, npm uses unicode characters in the tree output. When false, it uses ascii characters instead of unicode glyphs.
+.SS "\fBupdate-notifier\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Set to false to suppress the update notification when using an older version of npm than the latest.
+.SS "\fBusage\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+Show short usage output about the command specified.
+.SS "\fBuser-agent\fR"
+.RS 0
+.IP \(bu 4
+Default: "npm/{npm-version} node/{node-version} {platform} {arch} workspaces/{workspaces} {ci}"
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+Sets the User-Agent request header. The following fields are replaced with their actual counterparts:
+.RS 0
+.IP \(bu 4
+\fB{npm-version}\fR - The npm version in use
+.IP \(bu 4
+\fB{node-version}\fR - The Node.js version in use
+.IP \(bu 4
+\fB{platform}\fR - The value of \fBprocess.platform\fR
+.IP \(bu 4
+\fB{arch}\fR - The value of \fBprocess.arch\fR
+.IP \(bu 4
+\fB{workspaces}\fR - Set to \fBtrue\fR if the \fBworkspaces\fR or \fBworkspace\fR options are set.
+.IP \(bu 4
+\fB{ci}\fR - The value of the \fBci-name\fR config, if set, prefixed with \fBci/\fR, or an empty string if \fBci-name\fR is empty.
+.RE 0
+
+.SS "\fBuserconfig\fR"
+.RS 0
+.IP \(bu 4
+Default: "~/.npmrc"
+.IP \(bu 4
+Type: Path
+.RE 0
+
+.P
+The location of user-level configuration settings.
+.P
+This may be overridden by the \fBnpm_config_userconfig\fR environment variable or the \fB--userconfig\fR command line option, but may \fInot\fR be overridden by settings in the \fBglobalconfig\fR file.
+.SS "\fBversion\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, output the npm version and exit successfully.
+.P
+Only relevant when specified explicitly on the command line.
+.SS "\fBversions\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If true, output the npm version as well as node's \fBprocess.versions\fR map and the version in the current working directory's \fBpackage.json\fR file if one exists, and exit successfully.
+.P
+Only relevant when specified explicitly on the command line.
+.SS "\fBviewer\fR"
+.RS 0
+.IP \(bu 4
+Default: "man" on Posix, "browser" on Windows
+.IP \(bu 4
+Type: String
+.RE 0
+
+.P
+The program to use to view help content.
+.P
+Set to \fB"browser"\fR to view html help content in the default web browser.
+.SS "\fBwhich\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Number
+.RE 0
+
+.P
+If there are multiple funding sources, which 1-indexed source URL to open.
+.SS "\fBworkspace\fR"
+.RS 0
+.IP \(bu 4
+Default:
+.IP \(bu 4
+Type: String (can be set multiple times)
+.RE 0
+
+.P
+Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option.
+.P
+Valid values for the \fBworkspace\fR config are either:
+.RS 0
+.IP \(bu 4
+Workspace names
+.IP \(bu 4
+Path to a workspace directory
+.IP \(bu 4
+Path to a parent workspace directory (will result in selecting all workspaces within that folder)
+.RE 0
+
+.P
+When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project.
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Set to true to run the command in the context of \fBall\fR configured workspaces.
+.P
+Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly:
+.RS 0
+.IP \(bu 4
+Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config.
+.RE 0
+
+.P
+This value is not exported to the environment for child processes.
+.SS "\fBworkspaces-update\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.RE 0
+
+.P
+If set to true, the npm cli will run an update after operations that may possibly change the workspaces installed to the \fBnode_modules\fR folder.
+.SS "\fByes\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.RE 0
+
+.P
+Automatically answer "yes" to any prompts that npm might print on the command line.
+.SS "\fBalso\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "dev", or "development"
+.IP \(bu 4
+DEPRECATED: Please use --include=dev instead.
+.RE 0
+
+.P
+When set to \fBdev\fR or \fBdevelopment\fR, this is an alias for \fB--include=dev\fR.
+.SS "\fBcache-max\fR"
+.RS 0
+.IP \(bu 4
+Default: Infinity
+.IP \(bu 4
+Type: Number
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--prefer-online\fR
+.RE 0
+
+.P
+\fB--cache-max=0\fR is an alias for \fB--prefer-online\fR
+.SS "\fBcache-min\fR"
+.RS 0
+.IP \(bu 4
+Default: 0
+.IP \(bu 4
+Type: Number
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--prefer-offline\fR.
+.RE 0
+
+.P
+\fB--cache-min=9999 (or bigger)\fR is an alias for \fB--prefer-offline\fR.
+.SS "\fBcert\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.IP \(bu 4
+DEPRECATED: \fBkey\fR and \fBcert\fR are no longer used for most registry operations. Use registry scoped \fBkeyfile\fR and \fBcertfile\fR instead. Example: //other-registry.tld/:keyfile=/path/to/key.pem //other-registry.tld/:certfile=/path/to/cert.crt
+.RE 0
+
+.P
+A client certificate to pass when accessing the registry. Values should be in PEM format (Windows calls it "Base-64 encoded X.509 (.CER)") with newlines replaced by the string "\[rs]n". For example:
+.P
+.RS 2
+.nf
+cert="-----BEGIN CERTIFICATE-----\[rs]nXXXX\[rs]nXXXX\[rs]n-----END CERTIFICATE-----"
+.fi
+.RE
+.P
+It is \fInot\fR the path to a certificate file, though you can set a registry-scoped "certfile" path like "//other-registry.tld/:certfile=/path/to/cert.pem".
+.SS "\fBdev\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: Please use --include=dev instead.
+.RE 0
+
+.P
+Alias for \fB--include=dev\fR.
+.SS "\fBglobal-style\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=shallow\fR
+.RE 0
+
+.P
+Only install direct dependencies in the top level \fBnode_modules\fR, but hoist on deeper dependencies. Sets \fB--install-strategy=shallow\fR.
+.SS "\fBinit.author.email\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.IP \(bu 4
+DEPRECATED: Use \fB--init-author-email\fR instead.
+.RE 0
+
+.P
+Alias for \fB--init-author-email\fR
+.SS "\fBinit.author.name\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: String
+.IP \(bu 4
+DEPRECATED: Use \fB--init-author-name\fR instead.
+.RE 0
+
+.P
+Alias for \fB--init-author-name\fR
+.SS "\fBinit.author.url\fR"
+.RS 0
+.IP \(bu 4
+Default: ""
+.IP \(bu 4
+Type: "" or URL
+.IP \(bu 4
+DEPRECATED: Use \fB--init-author-url\fR instead.
+.RE 0
+
+.P
+Alias for \fB--init-author-url\fR
+.SS "\fBinit.license\fR"
+.RS 0
+.IP \(bu 4
+Default: "ISC"
+.IP \(bu 4
+Type: String
+.IP \(bu 4
+DEPRECATED: Use \fB--init-license\fR instead.
+.RE 0
+
+.P
+Alias for \fB--init-license\fR
+.SS "\fBinit.module\fR"
+.RS 0
+.IP \(bu 4
+Default: "~/.npm-init.js"
+.IP \(bu 4
+Type: Path
+.IP \(bu 4
+DEPRECATED: Use \fB--init-module\fR instead.
+.RE 0
+
+.P
+Alias for \fB--init-module\fR
+.SS "\fBinit.version\fR"
+.RS 0
+.IP \(bu 4
+Default: "1.0.0"
+.IP \(bu 4
+Type: SemVer string
+.IP \(bu 4
+DEPRECATED: Use \fB--init-version\fR instead.
+.RE 0
+
+.P
+Alias for \fB--init-version\fR
+.SS "\fBkey\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or String
+.IP \(bu 4
+DEPRECATED: \fBkey\fR and \fBcert\fR are no longer used for most registry operations. Use registry scoped \fBkeyfile\fR and \fBcertfile\fR instead. Example: //other-registry.tld/:keyfile=/path/to/key.pem //other-registry.tld/:certfile=/path/to/cert.crt
+.RE 0
+
+.P
+A client key to pass when accessing the registry. Values should be in PEM format with newlines replaced by the string "\[rs]n". For example:
+.P
+.RS 2
+.nf
+key="-----BEGIN PRIVATE KEY-----\[rs]nXXXX\[rs]nXXXX\[rs]n-----END PRIVATE KEY-----"
+.fi
+.RE
+.P
+It is \fInot\fR the path to a key file, though you can set a registry-scoped "keyfile" path like "//other-registry.tld/:keyfile=/path/to/key.pem".
+.SS "\fBlegacy-bundling\fR"
+.RS 0
+.IP \(bu 4
+Default: false
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: This option has been deprecated in favor of \fB--install-strategy=nested\fR
+.RE 0
+
+.P
+Instead of hoisting package installs in \fBnode_modules\fR, install packages in the same manner that they are depended on. This may cause very deep directory structures and duplicate package installs as there is no de-duplicating. Sets \fB--install-strategy=nested\fR.
+.SS "\fBonly\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null, "prod", or "production"
+.IP \(bu 4
+DEPRECATED: Use \fB--omit=dev\fR to omit dev dependencies from the install.
+.RE 0
+
+.P
+When set to \fBprod\fR or \fBproduction\fR, this is an alias for \fB--omit=dev\fR.
+.SS "\fBoptional\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.IP \(bu 4
+DEPRECATED: Use \fB--omit=optional\fR to exclude optional dependencies, or \fB--include=optional\fR to include them.
+.RE 0
+
+.P
+Default value does install optional deps unless otherwise omitted.
+.P
+Alias for --include=optional or --omit=optional
+.SS "\fBproduction\fR"
+.RS 0
+.IP \(bu 4
+Default: null
+.IP \(bu 4
+Type: null or Boolean
+.IP \(bu 4
+DEPRECATED: Use \fB--omit=dev\fR instead.
+.RE 0
+
+.P
+Alias for \fB--omit=dev\fR
+.SS "\fBshrinkwrap\fR"
+.RS 0
+.IP \(bu 4
+Default: true
+.IP \(bu 4
+Type: Boolean
+.IP \(bu 4
+DEPRECATED: Use the --package-lock setting instead.
+.RE 0
+
+.P
+Alias for --package-lock
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help folders
+.IP \(bu 4
+npm help npm
+.RE 0
diff --git a/node/node_modules/npm/man/man7/dependency-selectors.7 b/node/node_modules/npm/man/man7/dependency-selectors.7
new file mode 100644
index 0000000000000000000000000000000000000000..e9990de4c0078cd408561e5c09411d5ade37980c
--- /dev/null
+++ b/node/node_modules/npm/man/man7/dependency-selectors.7
@@ -0,0 +1,331 @@
+.TH "SELECTORS" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBSelectors\fR - Dependency Selector Syntax & Querying
+.SS "Description"
+.P
+The npm help query command exposes a new dependency selector syntax (informed by & respecting many aspects of the \fBCSS Selectors 4 Spec\fR \fI\(lahttps://dev.w3.org/csswg/selectors4/#relational\(ra\fR) which:
+.RS 0
+.IP \(bu 4
+Standardizes the shape of, & querying of, dependency graphs with a robust object model, metadata & selector syntax
+.IP \(bu 4
+Leverages existing, known language syntax & operators from CSS to make disparate package information broadly accessible
+.IP \(bu 4
+Unlocks the ability to answer complex, multi-faceted questions about dependencies, their relationships & associative metadata
+.IP \(bu 4
+Consolidates redundant logic of similar query commands in \fBnpm\fR (ex. \fBnpm fund\fR, \fBnpm ls\fR, \fBnpm outdated\fR, \fBnpm audit\fR ...)
+.RE 0
+
+.SS "Dependency Selector Syntax"
+.SS "Overview:"
+.RS 0
+.IP \(bu 4
+there is no "type" or "tag" selectors (ex. \fBdiv, h1, a\fR) as a dependency/target is the only type of \fBNode\fR that can be queried
+.IP \(bu 4
+the term "dependencies" is in reference to any \fBNode\fR found in a \fBtree\fR returned by \fBArborist\fR
+.RE 0
+
+.SS "Combinators"
+.RS 0
+.IP \(bu 4
+\fB>\fR direct descendant/child
+.IP \(bu 4
+\fB \fR any descendant/child
+.IP \(bu 4
+\fB~\fR sibling
+.RE 0
+
+.SS "Selectors"
+.RS 0
+.IP \(bu 4
+\fB*\fR universal selector
+.IP \(bu 4
+\fB#<name>\fR dependency selector (equivalent to \fB\[lB]name="..."\[rB]\fR)
+.IP \(bu 4
+\fB#<name>@<version>\fR (equivalent to \fB\[lB]name=<name>\[rB]:semver(<version>)\fR)
+.IP \(bu 4
+\fB,\fR selector list delimiter
+.IP \(bu 4
+\fB.\fR dependency type selector
+.IP \(bu 4
+\fB:\fR pseudo selector
+.RE 0
+
+.SS "Dependency Type Selectors"
+.RS 0
+.IP \(bu 4
+\fB.prod\fR dependency found in the \fBdependencies\fR section of \fBpackage.json\fR, or is a child of said dependency
+.IP \(bu 4
+\fB.dev\fR dependency found in the \fBdevDependencies\fR section of \fBpackage.json\fR, or is a child of said dependency
+.IP \(bu 4
+\fB.optional\fR dependency found in the \fBoptionalDependencies\fR section of \fBpackage.json\fR, or has \fB"optional": true\fR set in its entry in the \fBpeerDependenciesMeta\fR section of \fBpackage.json\fR, or a child of said dependency
+.IP \(bu 4
+\fB.peer\fR dependency found in the \fBpeerDependencies\fR section of \fBpackage.json\fR
+.IP \(bu 4
+\fB.workspace\fR dependency found in the \fB\[rs]fBworkspaces\[rs]fR\fR \fI\(lahttps://docs.npmjs.com/cli/v8/using-npm/workspaces\(ra\fR section of \fBpackage.json\fR
+.IP \(bu 4
+\fB.bundled\fR dependency found in the \fBbundleDependencies\fR section of \fBpackage.json\fR, or is a child of said dependency
+.RE 0
+
+.SS "Pseudo Selectors"
+.RS 0
+.IP \(bu 4
+\fB\[rs]fB:not(<selector>)\[rs]fR\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/:not\(ra\fR
+.IP \(bu 4
+\fB\[rs]fB:has(<selector>)\[rs]fR\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/:has\(ra\fR
+.IP \(bu 4
+\fB\[rs]fB:is(<selector list>)\[rs]fR\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/:is\(ra\fR
+.IP \(bu 4
+\fB\[rs]fB:root\[rs]fR\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/:root\(ra\fR matches the root node/dependency
+.IP \(bu 4
+\fB\[rs]fB:scope\[rs]fR\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/:scope\(ra\fR matches node/dependency it was queried against
+.IP \(bu 4
+\fB\[rs]fB:empty\[rs]fR\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/:empty\(ra\fR when a dependency has no dependencies
+.IP \(bu 4
+\fB\[rs]fB:private\[rs]fR\fR \fI\(lahttps://docs.npmjs.com/cli/v8/configuring-npm/package-json#private\(ra\fR when a dependency is private
+.IP \(bu 4
+\fB:link\fR when a dependency is linked (for instance, workspaces or packages manually \fB\[rs]fBlinked\[rs]fR\fR \fI\(lahttps://docs.npmjs.com/cli/v8/commands/npm-link\(ra\fR
+.IP \(bu 4
+\fB:deduped\fR when a dependency has been deduped (note that this does \fInot\fR always mean the dependency has been hoisted to the root of node_modules)
+.IP \(bu 4
+\fB:overridden\fR when a dependency has been overridden
+.IP \(bu 4
+\fB:extraneous\fR when a dependency exists but is not defined as a dependency of any node
+.IP \(bu 4
+\fB:invalid\fR when a dependency version is out of its ancestors specified range
+.IP \(bu 4
+\fB:missing\fR when a dependency is not found on disk
+.IP \(bu 4
+\fB:semver(<spec>, \[lB]selector\[rB], \[lB]function\[rB])\fR match a valid \fB\[rs]fBnode-semver\[rs]fR\fR \fI\(lahttps://github.com/npm/node-semver\(ra\fR version or range to a selector
+.IP \(bu 4
+\fB:path(<path>)\fR \fBglob\fR \fI\(lahttps://www.npmjs.com/package/glob\(ra\fR matching based on dependencies path relative to the project
+.IP \(bu 4
+\fB:type(<type>)\fR \fBbased on currently recognized types\fR \fI\(lahttps://github.com/npm/npm-package-arg#result-object\(ra\fR. You can also use the aggregate type of \fBregistry\fR for any registry dependency (e.g. tag, version, range, alias)
+.IP \(bu 4
+\fB:outdated(<type>)\fR when a dependency is outdated
+.IP \(bu 4
+\fB:vuln(<selector>)\fR when a dependency has a known vulnerability
+.RE 0
+
+.SS "\fB:semver(<spec>, \[lB]selector\[rB], \[lB]function\[rB])\fR"
+.P
+The \fB:semver()\fR pseudo selector allows comparing fields from each node's \fBpackage.json\fR using \fBsemver\fR \fI\(lahttps://github.com/npm/node-semver#readme\(ra\fR methods. It accepts up to 3 parameters, all but the first of which are optional.
+.RS 0
+.IP \(bu 4
+\fBspec\fR a semver version or range
+.IP \(bu 4
+\fBselector\fR an attribute selector for each node (default \fB\[lB]version\[rB]\fR)
+.IP \(bu 4
+\fBfunction\fR a semver method to apply, one of: \fBsatisfies\fR, \fBintersects\fR, \fBsubset\fR, \fBgt\fR, \fBgte\fR, \fBgtr\fR, \fBlt\fR, \fBlte\fR, \fBltr\fR, \fBeq\fR, \fBneq\fR or the special function \fBinfer\fR (default \fBinfer\fR)
+.RE 0
+
+.P
+When the special \fBinfer\fR function is used the \fBspec\fR and the actual value from the node are compared. If both are versions, according to \fBsemver.valid()\fR, \fBeq\fR is used. If both values are ranges, according to \fB!semver.valid()\fR, \fBintersects\fR is used. If the values are mixed types \fBsatisfies\fR is used.
+.P
+Some examples:
+.RS 0
+.IP \(bu 4
+\fB:semver(^1.0.0)\fR returns every node that has a \fBversion\fR satisfied by the provided range \fB^1.0.0\fR
+.IP \(bu 4
+\fB:semver(16.0.0, :attr(engines, \[lB]node\[rB]))\fR returns every node which has an \fBengines.node\fR property satisfying the version \fB16.0.0\fR
+.IP \(bu 4
+\fB:semver(1.0.0, \[lB]version\[rB], lt)\fR every node with a \fBversion\fR less than \fB1.0.0\fR
+.RE 0
+
+.SS "\fB:outdated(<type>)\fR"
+.P
+The \fB:outdated\fR pseudo selector retrieves data from the registry and returns information about which of your dependencies are outdated. The type parameter may be one of the following:
+.RS 0
+.IP \(bu 4
+\fBany\fR (default) a version exists that is greater than the current one
+.IP \(bu 4
+\fBin-range\fR a version exists that is greater than the current one, and satisfies at least one if its parent's dependencies
+.IP \(bu 4
+\fBout-of-range\fR a version exists that is greater than the current one, does not satisfy at least one of its parent's dependencies
+.IP \(bu 4
+\fBmajor\fR a version exists that is a semver major greater than the current one
+.IP \(bu 4
+\fBminor\fR a version exists that is a semver minor greater than the current one
+.IP \(bu 4
+\fBpatch\fR a version exists that is a semver patch greater than the current one
+.RE 0
+
+.P
+In addition to the filtering performed by the pseudo selector, some extra data is added to the resulting objects. The following data can be found under the \fBqueryContext\fR property of each node.
+.RS 0
+.IP \(bu 4
+\fBversions\fR an array of every available version of the given node
+.IP \(bu 4
+\fBoutdated.inRange\fR an array of objects, each with a \fBfrom\fR and \fBversions\fR, where \fBfrom\fR is the on-disk location of the node that depends on the current node and \fBversions\fR is an array of all available versions that satisfies that dependency. This is only populated if \fB:outdated(in-range)\fR is used.
+.IP \(bu 4
+\fBoutdated.outOfRange\fR an array of objects, identical in shape to \fBinRange\fR, but where the \fBversions\fR array is every available version that does not satisfy the dependency. This is only populated if \fB:outdated(out-of-range)\fR is used.
+.RE 0
+
+.P
+Some examples:
+.RS 0
+.IP \(bu 4
+\fB:root > :outdated(major)\fR returns every direct dependency that has a new semver major release
+.IP \(bu 4
+\fB.prod:outdated(in-range)\fR returns production dependencies that have a new release that satisfies at least one of its parent's dependencies
+.RE 0
+
+.SS "\fB:vuln\fR"
+.P
+The \fB:vuln\fR pseudo selector retrieves data from the registry and returns information about which if your dependencies has a known vulnerability. Only dependencies whose current version matches a vulnerability will be returned. For example if you have \fBsemver@7.6.0\fR in your tree, a vulnerability for \fBsemver\fR which affects versions \fB<=6.3.1\fR will not match.
+.P
+You can also filter results by certain attributes in advisories. Currently that includes \fBseverity\fR and \fBcwe\fR. Note that severity filtering is done per severity, it does not include severities "higher" or "lower" than the one specified.
+.P
+In addition to the filtering performed by the pseudo selector, info about each relevant advisory will be added to the \fBqueryContext\fR attribute of each node under the \fBadvisories\fR attribute.
+.P
+Some examples:
+.RS 0
+.IP \(bu 4
+\fB:root > .prod:vuln\fR returns direct production dependencies with any known vulnerability
+.IP \(bu 4
+\fB:vuln(\[lB]severity=high\[rB])\fR returns only dependencies with a vulnerability with a \fBhigh\fR severity.
+.IP \(bu 4
+\fB:vuln(\[lB]severity=high\[rB],\[lB]severity=moderate\[rB])\fR returns only dependencies with a vulnerability with a \fBhigh\fR or \fBmoderate\fR severity.
+.IP \(bu 4
+\fB:vuln(\[lB]cwe=1333\[rB])\fR returns only dependencies with a vulnerability that includes CWE-1333 (ReDoS)
+.RE 0
+
+.SS "\fBAttribute Selectors\fR \fI\(lahttps://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors\(ra\fR"
+.P
+The attribute selector evaluates the key/value pairs in \fBpackage.json\fR if they are \fBString\fRs.
+.RS 0
+.IP \(bu 4
+\fB\[lB]\[rB]\fR attribute selector (ie. existence of attribute)
+.IP \(bu 4
+\fB\[lB]attribute=value\[rB]\fR attribute value is equivalent...
+.IP \(bu 4
+\fB\[lB]attribute~=value\[rB]\fR attribute value contains word...
+.IP \(bu 4
+\fB\[lB]attribute*=value\[rB]\fR attribute value contains string...
+.IP \(bu 4
+\fB\[lB]attribute|=value\[rB]\fR attribute value is equal to or starts with...
+.IP \(bu 4
+\fB\[lB]attribute^=value\[rB]\fR attribute value starts with...
+.IP \(bu 4
+\fB\[lB]attribute$=value\[rB]\fR attribute value ends with...
+.RE 0
+
+.SS "\fBArray\fR & \fBObject\fR Attribute Selectors"
+.P
+The generic \fB:attr()\fR pseudo selector standardizes a pattern which can be used for attribute selection of \fBObject\fRs, \fBArray\fRs or \fBArrays\fR of \fBObject\fRs accessible via \fBArborist\fR's \fBNode.package\fR metadata. This allows for iterative attribute selection beyond top-level \fBString\fR evaluation. The last argument passed to \fB:attr()\fR must be an \fBattribute\fR selector or a nested \fB:attr()\fR. See examples below:
+.SS "\fBObjects\fR"
+.P
+.RS 2
+.nf
+/* return dependencies that have a `scripts.test` containing `"tap"` */
+*:attr(scripts, \[lB]test~=tap\[rB])
+.fi
+.RE
+.SS "Nested \fBObjects\fR"
+.P
+Nested objects are expressed as sequential arguments to \fB:attr()\fR.
+.P
+.RS 2
+.nf
+/* return dependencies that have a \[lB]testling config\[rB](https://ci.testling.com/guide/advanced_configuration) for opera browsers */
+*:attr(testling, browsers, \[lB]~=opera\[rB])
+.fi
+.RE
+.SS "\fBArrays\fR"
+.P
+\fBArray\fRs specifically uses a special/reserved \fB.\fR character in place of a typical attribute name. \fBArrays\fR also support exact \fBvalue\fR matching when a \fBString\fR is passed to the selector.
+.SS "Example of an \fBArray\fR Attribute Selection:"
+.P
+.RS 2
+.nf
+/* removes the distinction between properties & arrays */
+/* ie. we'd have to check the property & iterate to match selection */
+*:attr(\[lB]keywords^=react\[rB])
+*:attr(contributors, :attr(\[lB]name~=Jordan\[rB]))
+.fi
+.RE
+.SS "Example of an \fBArray\fR matching directly to a value:"
+.P
+.RS 2
+.nf
+/* return dependencies that have the exact keyword "react" */
+/* this is equivalent to `*:keywords(\[lB]value="react"\[rB])` */
+*:attr(\[lB]keywords=react\[rB])
+.fi
+.RE
+.SS "Example of an \fBArray\fR of \fBObject\fRs:"
+.P
+.RS 2
+.nf
+/* returns */
+*:attr(contributors, \[lB]email=ruyadorno@github.com\[rB])
+.fi
+.RE
+.SS "Groups"
+.P
+Dependency groups are defined by the package relationships to their ancestors (ie. the dependency types that are defined in \fBpackage.json\fR). This approach is user-centric as the ecosystem has been taught to think about dependencies in these groups first-and-foremost. Dependencies are allowed to be included in multiple groups (ex. a \fBprod\fR dependency may also be a \fBdev\fR dependency (in that it's also required by another \fBdev\fR dependency) & may also be \fBbundled\fR - a selector for that type of dependency would look like: \fB*.prod.dev.bundled\fR).
+.RS 0
+.IP \(bu 4
+\fB.prod\fR
+.IP \(bu 4
+\fB.dev\fR
+.IP \(bu 4
+\fB.optional\fR
+.IP \(bu 4
+\fB.peer\fR
+.IP \(bu 4
+\fB.bundled\fR
+.IP \(bu 4
+\fB.workspace\fR
+.RE 0
+
+.P
+Please note that currently \fBworkspace\fR deps are always \fBprod\fR dependencies. Additionally the \fB.root\fR dependency is also considered a \fBprod\fR dependency.
+.SS "Programmatic Usage"
+.RS 0
+.IP \(bu 4
+\fBArborist\fR's \fBNode\fR Class has a \fB.querySelectorAll()\fR method
+.RS 4
+.IP \(bu 4
+this method will return a filtered, flattened dependency Arborist \fBNode\fR list based on a valid query selector
+.RE 0
+
+.RE 0
+
+.P
+.RS 2
+.nf
+const Arborist = require('@npmcli/arborist')
+const arb = new Arborist({})
+.fi
+.RE
+.P
+.RS 2
+.nf
+// root-level
+arb.loadActual().then(async (tree) => {
+  // query all production dependencies
+  const results = await tree.querySelectorAll('.prod')
+  console.log(results)
+})
+.fi
+.RE
+.P
+.RS 2
+.nf
+// iterative
+arb.loadActual().then(async (tree) => {
+  // query for the deduped version of react
+  const results = await tree.querySelectorAll('#react:not(:deduped)')
+  // query the deduped react for git deps
+  const deps = await results\[lB]0\[rB].querySelectorAll(':type(git)')
+  console.log(deps)
+})
+.fi
+.RE
+.SH "SEE ALSO"
+.RS 0
+.IP \(bu 4
+npm help query
+.IP \(bu 4
+\fB@npmcli/arborist\fR \fI\(lahttps://npm.im/@npmcli/arborist\(ra\fR
+.RE 0
diff --git a/node/node_modules/npm/man/man7/developers.7 b/node/node_modules/npm/man/man7/developers.7
new file mode 100644
index 0000000000000000000000000000000000000000..ea1507dbed86cc7a4a07f63f9410df967f9fe7cc
--- /dev/null
+++ b/node/node_modules/npm/man/man7/developers.7
@@ -0,0 +1,234 @@
+.TH "DEVELOPERS" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBDevelopers\fR - Developer guide
+.SS "Description"
+.P
+So, you've decided to use npm to develop (and maybe publish/deploy) your project.
+.P
+Fantastic!
+.P
+There are a few things that you need to do above the simple steps that your users will do to install your program.
+.SS "About These Documents"
+.P
+These are man pages. If you install npm, you should be able to then do \fBman npm-thing\fR to get the documentation on a particular topic, or \fBnpm help thing\fR to see the same information.
+.SS "What is a Package"
+.P
+A package is:
+.RS 0
+.IP \(bu 4
+a) a folder containing a program described by a package.json file
+.IP \(bu 4
+b) a gzipped tarball containing (a)
+.IP \(bu 4
+c) a url that resolves to (b)
+.IP \(bu 4
+d) a \fB<name>@<version>\fR that is published on the registry with (c)
+.IP \(bu 4
+e) a \fB<name>@<tag>\fR that points to (d)
+.IP \(bu 4
+f) a \fB<name>\fR that has a "latest" tag satisfying (e)
+.IP \(bu 4
+g) a \fBgit\fR url that, when cloned, results in (a).
+.RE 0
+
+.P
+Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).
+.P
+Git urls can be of the form:
+.P
+.RS 2
+.nf
+git://github.com/user/project.git#commit-ish
+git+ssh://user@hostname:project.git#commit-ish
+git+http://user@hostname/project/blah.git#commit-ish
+git+https://user@hostname/project/blah.git#commit-ish
+.fi
+.RE
+.P
+The \fBcommit-ish\fR can be any tag, sha, or branch which can be supplied as an argument to \fBgit checkout\fR. The default is whatever the repository uses as its default branch.
+.SS "The package.json File"
+.P
+You need to have a \fBpackage.json\fR file in the root of your project to do much of anything with npm. That is basically the whole interface.
+.P
+See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for details about what goes in that file. At the very least, you need:
+.RS 0
+.IP \(bu 4
+name: This should be a string that identifies your project. Please do not use the name to specify that it runs on node, or is in JavaScript. You can use the "engines" field to explicitly state the versions of node (or whatever else) that your program requires, and it's pretty well assumed that it's JavaScript.
+.P
+It does not necessarily need to match your github repository name.
+.P
+So, \fBnode-foo\fR and \fBbar-js\fR are bad names. \fBfoo\fR or \fBbar\fR are better.
+.IP \(bu 4
+version: A semver-compatible version.
+.IP \(bu 4
+engines: Specify the versions of node (or whatever else) that your program runs on. The node API changes a lot, and there may be bugs or new functionality that you depend on. Be explicit.
+.IP \(bu 4
+author: Take some credit.
+.IP \(bu 4
+scripts: If you have a special compilation or installation script, then you should put it in the \fBscripts\fR object. You should definitely have at least a basic smoke-test command as the "scripts.test" field. See npm help scripts.
+.IP \(bu 4
+main: If you have a single module that serves as the entry point to your program (like what the "foo" package gives you at require("foo")), then you need to specify that in the "main" field.
+.IP \(bu 4
+directories: This is an object mapping names to folders. The best ones to include are "lib" and "doc", but if you use "man" to specify a folder full of man pages, they'll get installed just like these ones.
+.RE 0
+
+.P
+You can use \fBnpm init\fR in the root of your package in order to get you started with a pretty basic package.json file. See npm help init for more info.
+.SS "Keeping files \fIout\fR of your Package"
+.P
+Use a \fB.npmignore\fR file to keep stuff out of your package. If there's no \fB.npmignore\fR file, but there \fIis\fR a \fB.gitignore\fR file, then npm will ignore the stuff matched by the \fB.gitignore\fR file. If you \fIwant\fR to include something that is excluded by your \fB.gitignore\fR file, you can create an empty \fB.npmignore\fR file to override it. Like \fBgit\fR, \fBnpm\fR looks for \fB.npmignore\fR and \fB.gitignore\fR files in all subdirectories of your package, not only the root directory.
+.P
+\fB.npmignore\fR files follow the \fBsame pattern rules\fR \fI\(lahttps://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#_ignoring\(ra\fR as \fB.gitignore\fR files:
+.RS 0
+.IP \(bu 4
+Blank lines or lines starting with \fB#\fR are ignored.
+.IP \(bu 4
+Standard glob patterns work.
+.IP \(bu 4
+You can end patterns with a forward slash \fB/\fR to specify a directory.
+.IP \(bu 4
+You can negate a pattern by starting it with an exclamation point \fB!\fR.
+.RE 0
+
+.P
+By default, some paths and files are ignored, so there's no need to add them to \fB.npmignore\fR explicitly. Some examples are:
+.RS 0
+.IP \(bu 4
+\fB.*.swp\fR
+.IP \(bu 4
+\fB._*\fR
+.IP \(bu 4
+\fB.DS_Store\fR
+.IP \(bu 4
+\fB.git\fR
+.IP \(bu 4
+\fB.gitignore\fR
+.IP \(bu 4
+\fB.hg\fR
+.IP \(bu 4
+\fB.npmignore\fR
+.IP \(bu 4
+\fB.npmrc\fR
+.IP \(bu 4
+\fB.lock-wscript\fR
+.IP \(bu 4
+\fB.svn\fR
+.IP \(bu 4
+\fB.wafpickle-*\fR
+.IP \(bu 4
+\fBconfig.gypi\fR
+.IP \(bu 4
+\fBCVS\fR
+.IP \(bu 4
+\fBnpm-debug.log\fR
+.RE 0
+
+.P
+Additionally, everything in \fBnode_modules\fR is ignored, except for bundled dependencies. npm automatically handles this for you, so don't bother adding \fBnode_modules\fR to \fB.npmignore\fR.
+.P
+The following paths and files are never ignored, so adding them to \fB.npmignore\fR is pointless:
+.RS 0
+.IP \(bu 4
+\fBpackage.json\fR
+.IP \(bu 4
+\fBREADME\fR (and its variants)
+.IP \(bu 4
+\fBLICENSE\fR / \fBLICENCE\fR
+.RE 0
+
+.P
+If, given the structure of your project, you find \fB.npmignore\fR to be a maintenance headache, you might instead try populating the \fBfiles\fR property of \fBpackage.json\fR, which is an array of file or directory names that should be included in your package. Sometimes manually picking which items to allow is easier to manage than building a block list.
+.P
+See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more info on what can and can't be ignored.
+.SS "Testing whether your \fB.npmignore\fR or \fBfiles\fR config works"
+.P
+If you want to double check that your package will include only the files you intend it to when published, you can run the \fBnpm pack\fR command locally which will generate a tarball in the working directory, the same way it does for publishing.
+.SS "Link Packages"
+.P
+\fBnpm link\fR is designed to install a development package and see the changes in real time without having to keep re-installing it. (You do need to either re-link or \fBnpm rebuild -g\fR to update compiled packages, of course.)
+.P
+More info at npm help link.
+.SS "Before Publishing: Make Sure Your Package Installs and Works"
+.P
+\fBThis is important.\fR
+.P
+If you cannot install it locally, you'll have problems trying to publish it. Or, worse yet, you'll be able to publish it, but you'll be publishing a broken or pointless package. So don't do that.
+.P
+In the root of your package, do this:
+.P
+.RS 2
+.nf
+npm install . -g
+.fi
+.RE
+.P
+That'll show you that it's working. If you'd rather just create a symlink package that points to your working directory, then do this:
+.P
+.RS 2
+.nf
+npm link
+.fi
+.RE
+.P
+Use \fBnpm ls -g\fR to see if it's there.
+.P
+To test a local install, go into some other folder, and then do:
+.P
+.RS 2
+.nf
+cd ../some-other-folder
+npm install ../my-package
+.fi
+.RE
+.P
+to install it locally into the node_modules folder in that other place.
+.P
+Then go into the node-repl, and try using require("my-thing") to bring in your module's main module.
+.SS "Create a User Account"
+.P
+Create a user with the adduser command. It works like this:
+.P
+.RS 2
+.nf
+npm adduser
+.fi
+.RE
+.P
+and then follow the prompts.
+.P
+This is documented better in npm help adduser.
+.SS "Publish your Package"
+.P
+This part's easy. In the root of your folder, do this:
+.P
+.RS 2
+.nf
+npm publish
+.fi
+.RE
+.P
+You can give publish a url to a tarball, or a filename of a tarball, or a path to a folder.
+.P
+Note that pretty much \fBeverything in that folder will be exposed\fR by default. So, if you have secret stuff in there, use a \fB.npmignore\fR file to list out the globs to ignore, or publish from a fresh checkout.
+.SS "Brag about it"
+.P
+Send emails, write blogs, blab in IRC.
+.P
+Tell the world how easy it is to install your program!
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help npm
+.IP \(bu 4
+npm help init
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help scripts
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help adduser
+.IP \(bu 4
+npm help registry
+.RE 0
diff --git a/node/node_modules/npm/man/man7/logging.7 b/node/node_modules/npm/man/man7/logging.7
new file mode 100644
index 0000000000000000000000000000000000000000..0acdc4063e1e337491fe23c64d3e7b2f3103f38e
--- /dev/null
+++ b/node/node_modules/npm/man/man7/logging.7
@@ -0,0 +1,108 @@
+.TH "LOGGING" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBLogging\fR - Why, What & How we Log
+.SS "Description"
+.P
+The \fBnpm\fR CLI has various mechanisms for showing different levels of information back to end-users for certain commands, configurations & environments.
+.SS "Setting Log File Location"
+.P
+All logs are written to a debug log, with the path to that file printed if the execution of a command fails.
+.P
+The default location of the logs directory is a directory named \fB_logs\fR inside the npm cache. This can be changed with the \fBlogs-dir\fR config option.
+.P
+For example, if you wanted to write all your logs to the current working directory, you could run: \fBnpm install --logs-dir=.\fR. This is especially helpful in debugging a specific \fBnpm\fR issue as you can run a command multiple times with different config values and then diff all the log files.
+.P
+Log files will be removed from the \fBlogs-dir\fR when the number of log files exceeds \fBlogs-max\fR, with the oldest logs being deleted first.
+.P
+To turn off logs completely set \fB--logs-max=0\fR.
+.SS "Setting Log Levels"
+.SS "\fBloglevel\fR"
+.P
+\fBloglevel\fR is a global argument/config that can be set to determine the type of information to be displayed.
+.P
+The default value of \fBloglevel\fR is \fB"notice"\fR but there are several levels/types of logs available, including:
+.RS 0
+.IP \(bu 4
+\fB"silent"\fR
+.IP \(bu 4
+\fB"error"\fR
+.IP \(bu 4
+\fB"warn"\fR
+.IP \(bu 4
+\fB"notice"\fR
+.IP \(bu 4
+\fB"http"\fR
+.IP \(bu 4
+\fB"info"\fR
+.IP \(bu 4
+\fB"verbose"\fR
+.IP \(bu 4
+\fB"silly"\fR
+.RE 0
+
+.P
+All logs pertaining to a level preceding the current setting will be shown.
+.SS "Aliases"
+.P
+The log levels listed above have various corresponding aliases, including:
+.RS 0
+.IP \(bu 4
+\fB-d\fR: \fB--loglevel info\fR
+.IP \(bu 4
+\fB--dd\fR: \fB--loglevel verbose\fR
+.IP \(bu 4
+\fB--verbose\fR: \fB--loglevel verbose\fR
+.IP \(bu 4
+\fB--ddd\fR: \fB--loglevel silly\fR
+.IP \(bu 4
+\fB-q\fR: \fB--loglevel warn\fR
+.IP \(bu 4
+\fB--quiet\fR: \fB--loglevel warn\fR
+.IP \(bu 4
+\fB-s\fR: \fB--loglevel silent\fR
+.IP \(bu 4
+\fB--silent\fR: \fB--loglevel silent\fR
+.RE 0
+
+.SS "\fBforeground-scripts\fR"
+.P
+The \fBnpm\fR CLI began hiding the output of lifecycle scripts for \fBnpm install\fR as of \fBv7\fR. Notably, this means you will not see logs/output from packages that may be using "install scripts" to display information back to you or from your own project's scripts defined in \fBpackage.json\fR. If you'd like to change this behavior & log this output you can set \fBforeground-scripts\fR to \fBtrue\fR.
+.SS "Timing Information"
+.P
+The \fB\[rs]fB--timing\[rs]fR config\fR \fI\(la/using-npm/config#timing\(ra\fR can be set which does a few things:
+.RS 0
+.IP 1. 4
+Always shows the full path to the debug log regardless of command exit status
+.IP 2. 4
+Write timing information to a process specific timing file in the cache or \fBlogs-dir\fR
+.IP 3. 4
+Output timing information to the terminal
+.RE 0
+
+.P
+This file contains a \fBtimers\fR object where the keys are an identifier for the portion of the process being timed and the value is the number of milliseconds it took to complete.
+.P
+Sometimes it is helpful to get timing information without outputting anything to the terminal. For example, the performance might be affected by writing to the terminal. In this case you can use \fB--timing --silent\fR which will still write the timing file, but not output anything to the terminal while running.
+.SS "Registry Response Headers"
+.SS "\fBnpm-notice\fR"
+.P
+The \fBnpm\fR CLI reads from & logs any \fBnpm-notice\fR headers that are returned from the configured registry. This mechanism can be used by third-party registries to provide useful information when network-dependent requests occur.
+.P
+This header is not cached, and will not be logged if the request is served from the cache.
+.SS "Logs and Sensitive Information"
+.P
+The \fBnpm\fR CLI makes a best effort to redact the following from terminal output and log files:
+.RS 0
+.IP \(bu 4
+Passwords inside basic auth URLs
+.IP \(bu 4
+npm tokens
+.RE 0
+
+.P
+However, this behavior should not be relied on to keep all possible sensitive information redacted. If you are concerned about secrets in your log file or terminal output, you can use \fB--loglevel=silent\fR and \fB--logs-max=0\fR to ensure no logs are written to your terminal or filesystem.
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help config
+.RE 0
diff --git a/node/node_modules/npm/man/man7/orgs.7 b/node/node_modules/npm/man/man7/orgs.7
new file mode 100644
index 0000000000000000000000000000000000000000..3a33aa82e551c089cf9f09e1d2676e0d5271efa1
--- /dev/null
+++ b/node/node_modules/npm/man/man7/orgs.7
@@ -0,0 +1,145 @@
+.TH "ORGANIZATIONS" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBOrganizations\fR - Working with teams & organizations
+.SS "Description"
+.P
+There are three levels of org users:
+.RS 0
+.IP 1. 4
+Super admin, controls billing & adding people to the org.
+.IP 2. 4
+Team admin, manages team membership & package access.
+.IP 3. 4
+Developer, works on packages they are given access to.
+.RE 0
+
+.P
+The super admin is the only person who can add users to the org because it impacts the monthly bill. The super admin will use the website to manage membership. Every org has a \fBdevelopers\fR team that all users are automatically added to.
+.P
+The team admin is the person who manages team creation, team membership, and package access for teams. The team admin grants package access to teams, not individuals.
+.P
+The developer will be able to access packages based on the teams they are on. Access is either read-write or read-only.
+.P
+There are two main commands:
+.RS 0
+.IP 1. 4
+\fBnpm team\fR see npm help team for more details
+.IP 2. 4
+\fBnpm access\fR see npm help access for more details
+.RE 0
+
+.SS "Team Admins create teams"
+.RS 0
+.IP \(bu 4
+Check who you\[cq]ve added to your org:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm team ls <org>:developers
+.fi
+.RE
+.RS 0
+.IP \(bu 4
+Each org is automatically given a \fBdevelopers\fR team, so you can see the whole list of team members in your org. This team automatically gets read-write access to all packages, but you can change that with the \fBaccess\fR command.
+.IP \(bu 4
+Create a new team:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm team create <org:team>
+.fi
+.RE
+.RS 0
+.IP \(bu 4
+Add members to that team:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm team add <org:team> <user>
+.fi
+.RE
+.SS "Publish a package and adjust package access"
+.RS 0
+.IP \(bu 4
+In package directory, run
+.RE 0
+
+.P
+.RS 2
+.nf
+npm init --scope=<org>
+.fi
+.RE
+.P
+to scope it for your org & publish as usual
+.RS 0
+.IP \(bu 4
+Grant access:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm access grant <read-only|read-write> <org:team> \[lB]<package>\[rB]
+.fi
+.RE
+.RS 0
+.IP \(bu 4
+Revoke access:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm access revoke <org:team> \[lB]<package>\[rB]
+.fi
+.RE
+.SS "Monitor your package access"
+.RS 0
+.IP \(bu 4
+See what org packages a team member can access:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm access list packages <org> <user>
+.fi
+.RE
+.RS 0
+.IP \(bu 4
+See packages available to a specific team:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm access list packages <org:team>
+.fi
+.RE
+.RS 0
+.IP \(bu 4
+Check which teams are collaborating on a package:
+.RE 0
+
+.P
+.RS 2
+.nf
+npm access list collaborators <pkg>
+.fi
+.RE
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help team
+.IP \(bu 4
+npm help access
+.IP \(bu 4
+npm help scope
+.RE 0
diff --git a/node/node_modules/npm/man/man7/package-spec.7 b/node/node_modules/npm/man/man7/package-spec.7
new file mode 100644
index 0000000000000000000000000000000000000000..7cbe764d0d25853d7dfb0d6989798b5c70e6a506
--- /dev/null
+++ b/node/node_modules/npm/man/man7/package-spec.7
@@ -0,0 +1,126 @@
+.TH "SPEC" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBspec\fR - Package name specifier
+.SS "Description"
+.P
+Commands like \fBnpm install\fR and the dependency sections in the \fBpackage.json\fR use a package name specifier. This can be many different things that all refer to a "package". Examples include a package name, git url, tarball, or local directory. These will generally be referred to as \fB<package-spec>\fR in the help output for the npm commands that use this package name specifier.
+.SS "Package name"
+.RS 0
+.IP \(bu 4
+\fB\[lB]<@scope>/\[rB]<pkg>\fR
+.IP \(bu 4
+\fB\[lB]<@scope>/\[rB]<pkg>@<tag>\fR
+.IP \(bu 4
+\fB\[lB]<@scope>/\[rB]<pkg>@<version>\fR
+.IP \(bu 4
+\fB\[lB]<@scope>/\[rB]<pkg>@<version range>\fR
+.RE 0
+
+.P
+Refers to a package by name, with or without a scope, and optionally tag, version, or version range. This is typically used in combination with the \fBregistry\fR \fI\(la/using-npm/config#registry\(ra\fR config to refer to a package in a registry.
+.P
+Examples:
+.RS 0
+.IP \(bu 4
+\fBnpm\fR
+.IP \(bu 4
+\fB@npmcli/arborist\fR
+.IP \(bu 4
+\fB@npmcli/arborist@latest\fR
+.IP \(bu 4
+\fBnpm@6.13.1\fR
+.IP \(bu 4
+\fBnpm@^4.0.0\fR
+.RE 0
+
+.SS "Aliases"
+.RS 0
+.IP \(bu 4
+\fB<alias>@npm:<name>\fR
+.RE 0
+
+.P
+Primarily used by commands like \fBnpm install\fR and in the dependency sections in the \fBpackage.json\fR, this refers to a package by an alias. The \fB<alias>\fR is the name of the package as it is reified in the \fBnode_modules\fR folder, and the \fB<name>\fR refers to a package name as found in the configured registry.
+.P
+See \fBPackage name\fR above for more info on referring to a package by name, and \fBregistry\fR \fI\(la/using-npm/config#registry\(ra\fR for configuring which registry is used when referring to a package by name.
+.P
+Examples:
+.RS 0
+.IP \(bu 4
+\fBsemver@npm:@npmcli/semver-with-patch\fR
+.IP \(bu 4
+\fBsemver@npm:semver@7.2.2\fR
+.IP \(bu 4
+\fBsemver@npm:semver@legacy\fR
+.RE 0
+
+.SS "Folders"
+.RS 0
+.IP \(bu 4
+\fB<folder>\fR
+.RE 0
+
+.P
+This refers to a package on the local filesystem. Specifically this is a folder with a \fBpackage.json\fR file in it. This \fIshould\fR always be prefixed with a \fB/\fR or \fB./\fR (or your OS equivalent) to reduce confusion. npm currently will parse a string with more than one \fB/\fR in it as a folder, but this is legacy behavior that may be removed in a future version.
+.P
+Examples:
+.RS 0
+.IP \(bu 4
+\fB./my-package\fR
+.IP \(bu 4
+\fB/opt/npm/my-package\fR
+.RE 0
+
+.SS "Tarballs"
+.RS 0
+.IP \(bu 4
+\fB<tarball file>\fR
+.IP \(bu 4
+\fB<tarball url>\fR
+.RE 0
+
+.P
+Examples:
+.RS 0
+.IP \(bu 4
+\fB./my-package.tgz\fR
+.IP \(bu 4
+\fBhttps://registry.npmjs.org/semver/-/semver-1.0.0.tgz\fR
+.RE 0
+
+.P
+Refers to a package in a tarball format, either on the local filesystem or remotely via url. This is the format that packages exist in when uploaded to a registry.
+.SS "git urls"
+.RS 0
+.IP \(bu 4
+\fB<git:// url>\fR
+.IP \(bu 4
+\fB<github username>/<github project>\fR
+.RE 0
+
+.P
+Refers to a package in a git repo. This can be a full git url, git shorthand, or a username/package on GitHub. You can specify a git tag, branch, or other git ref by appending \fB#ref\fR.
+.P
+Examples:
+.RS 0
+.IP \(bu 4
+\fBhttps://github.com/npm/cli.git\fR
+.IP \(bu 4
+\fBgit@github.com:npm/cli.git\fR
+.IP \(bu 4
+\fBgit+ssh://git@github.com/npm/cli#v6.0.0\fR
+.IP \(bu 4
+\fBgithub:npm/cli#HEAD\fR
+.IP \(bu 4
+\fBnpm/cli#c12ea07\fR
+.RE 0
+
+.SS "See also"
+.RS 0
+.IP \(bu 4
+\fBnpm-package-arg\fR \fI\(lahttps://npm.im/npm-package-arg\(ra\fR
+.IP \(bu 4
+npm help scope
+.IP \(bu 4
+npm help config
+.RE 0
diff --git a/node/node_modules/npm/man/man7/registry.7 b/node/node_modules/npm/man/man7/registry.7
new file mode 100644
index 0000000000000000000000000000000000000000..133574a9bc60864fcead6adf4e6d29c1d44b9301
--- /dev/null
+++ b/node/node_modules/npm/man/man7/registry.7
@@ -0,0 +1,49 @@
+.TH "REGISTRY" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBRegistry\fR - The JavaScript Package Registry
+.SS "Description"
+.P
+To resolve packages by name and version, npm talks to a registry website that implements the CommonJS Package Registry specification for reading package info.
+.P
+npm is configured to use the \fBnpm public registry\fR at \fI\(lahttps://registry.npmjs.org\(ra\fR by default. Use of the npm public registry is subject to terms of use available at \fI\(lahttps://docs.npmjs.com/policies/terms\(ra\fR.
+.P
+You can configure npm to use any compatible registry you like, and even run your own registry. Use of someone else's registry may be governed by their terms of use.
+.P
+npm's package registry implementation supports several write APIs as well, to allow for publishing packages and managing user account information.
+.P
+The registry URL used is determined by the scope of the package (see npm help scope. If no scope is specified, the default registry is used, which is supplied by the \fB\[rs]fBregistry\[rs]fR config\fR \fI\(la/using-npm/config#registry\(ra\fR parameter. See npm help config, npm help npmrc, and npm help config for more on managing npm's configuration. Authentication configuration such as auth tokens and certificates are configured specifically scoped to an individual registry. See \fBAuth Related Configuration\fR \fI\(la/configuring-npm/npmrc#auth-related-configuration\(ra\fR
+.P
+When the default registry is used in a package-lock or shrinkwrap it has the special meaning of "the currently configured registry". If you create a lock file while using the default registry you can switch to another registry and npm will install packages from the new registry, but if you create a lock file while using a custom registry packages will be installed from that registry even after you change to another registry.
+.SS "Does npm send any information about me back to the registry?"
+.P
+Yes.
+.P
+When making requests of the registry npm adds two headers with information about your environment:
+.RS 0
+.IP \(bu 4
+\fBNpm-Scope\fR \[en] If your project is scoped, this header will contain its scope. In the future npm hopes to build registry features that use this information to allow you to customize your experience for your organization.
+.IP \(bu 4
+\fBNpm-In-CI\fR \[en] Set to "true" if npm believes this install is running in a continuous integration environment, "false" otherwise. This is detected by looking for the following environment variables: \fBCI\fR, \fBTDDIUM\fR, \fBJENKINS_URL\fR, \fBbamboo.buildKey\fR. If you'd like to learn more you may find the \fBoriginal PR\fR \fI\(lahttps://github.com/npm/npm-registry-client/pull/129\(ra\fR interesting. This is used to gather better metrics on how npm is used by humans, versus build farms.
+.RE 0
+
+.P
+The npm registry does not try to correlate the information in these headers with any authenticated accounts that may be used in the same requests.
+.SS "How can I prevent my package from being published in the official registry?"
+.P
+Set \fB"private": true\fR in your \fBpackage.json\fR to prevent it from being published at all, or \fB"publishConfig":{"registry":"http://my-internal-registry.local"}\fR to force it to be published only to your internal/private registry.
+.P
+See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more info on what goes in the package.json file.
+.SS "Where can I find my (and others') published packages?"
+.P
+\fI\(lahttps://www.npmjs.com/\(ra\fR
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help config
+.IP \(bu 4
+npm help npmrc
+.IP \(bu 4
+npm help developers
+.RE 0
diff --git a/node/node_modules/npm/man/man7/removal.7 b/node/node_modules/npm/man/man7/removal.7
new file mode 100644
index 0000000000000000000000000000000000000000..88baa205a0e1bf50a027ed12f92c2960974cb111
--- /dev/null
+++ b/node/node_modules/npm/man/man7/removal.7
@@ -0,0 +1,54 @@
+.TH "REMOVAL" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBRemoval\fR - Cleaning the slate
+.SS "Synopsis"
+.P
+So sad to see you go.
+.P
+.RS 2
+.nf
+sudo npm uninstall npm -g
+.fi
+.RE
+.P
+Or, if that fails, please proceed to more severe uninstalling methods.
+.SS "More Severe Uninstalling"
+.P
+Usually, the above instructions are sufficient. That will remove npm, but leave behind anything you've installed.
+.P
+If that doesn't work, or if you require more drastic measures, continue reading.
+.P
+Note that this is only necessary for globally-installed packages. Local installs are completely contained within a project's \fBnode_modules\fR folder. Delete that folder, and everything is gone unless a package's install script is particularly ill-behaved.
+.P
+This assumes that you installed node and npm in the default place. If you configured node with a different \fB--prefix\fR, or installed npm with a different prefix setting, then adjust the paths accordingly, replacing \fB/usr/local\fR with your install prefix.
+.P
+To remove everything npm-related manually:
+.P
+.RS 2
+.nf
+rm -rf /usr/local/{lib/node{,/.npm,_modules},bin,share/man}/npm*
+.fi
+.RE
+.P
+If you installed things \fIwith\fR npm, then your best bet is to uninstall them with npm first, and then install them again once you have a proper install. This can help find any symlinks that are lying around:
+.P
+.RS 2
+.nf
+ls -laF /usr/local/{lib/node{,/.npm},bin,share/man} | grep npm
+.fi
+.RE
+.P
+Prior to version 0.3, npm used shim files for executables and node modules. To track those down, you can do the following:
+.P
+.RS 2
+.nf
+find /usr/local/{lib/node,bin} -exec grep -l npm \[rs]{\[rs]} \[rs]; ;
+.fi
+.RE
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help uninstall
+.IP \(bu 4
+npm help prune
+.RE 0
diff --git a/node/node_modules/npm/man/man7/scope.7 b/node/node_modules/npm/man/man7/scope.7
new file mode 100644
index 0000000000000000000000000000000000000000..a1f34a2ab7815f48c35e8c7d633392d8d6edfcf6
--- /dev/null
+++ b/node/node_modules/npm/man/man7/scope.7
@@ -0,0 +1,113 @@
+.TH "SCOPE" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBScope\fR - Scoped packages
+.SS "Description"
+.P
+All npm packages have a name. Some package names also have a scope. A scope follows the usual rules for package names (URL-safe characters, no leading dots or underscores). When used in package names, scopes are preceded by an \fB@\fR symbol and followed by a slash, e.g.
+.P
+.RS 2
+.nf
+@somescope/somepackagename
+.fi
+.RE
+.P
+Scopes are a way of grouping related packages together, and also affect a few things about the way npm treats the package.
+.P
+Each npm user/organization has their own scope, and only you can add packages in your scope. This means you don't have to worry about someone taking your package name ahead of you. Thus it is also a good way to signal official packages for organizations.
+.P
+Scoped packages can be published and installed as of \fBnpm@2\fR and are supported by the primary npm registry. Unscoped packages can depend on scoped packages and vice versa. The npm client is backwards-compatible with unscoped registries, so it can be used to work with scoped and unscoped registries at the same time.
+.SS "Installing scoped packages"
+.P
+Scoped packages are installed to a sub-folder of the regular installation folder, e.g. if your other packages are installed in \fBnode_modules/packagename\fR, scoped modules will be installed in \fBnode_modules/@myorg/packagename\fR. The scope folder (\fB@myorg\fR) is simply the name of the scope preceded by an \fB@\fR symbol, and can contain any number of scoped packages.
+.P
+A scoped package is installed by referencing it by name, preceded by an \fB@\fR symbol, in \fBnpm install\fR:
+.P
+.RS 2
+.nf
+npm install @myorg/mypackage
+.fi
+.RE
+.P
+Or in \fBpackage.json\fR:
+.P
+.RS 2
+.nf
+"dependencies": {
+  "@myorg/mypackage": "^1.3.0"
+}
+.fi
+.RE
+.P
+Note that if the \fB@\fR symbol is omitted, in either case, npm will instead attempt to install from GitHub; see npm help install.
+.SS "Requiring scoped packages"
+.P
+Because scoped packages are installed into a scope folder, you have to include the name of the scope when requiring them in your code, e.g.
+.P
+.RS 2
+.nf
+require('@myorg/mypackage')
+.fi
+.RE
+.P
+There is nothing special about the way Node treats scope folders. This simply requires the \fBmypackage\fR module in the folder named \fB@myorg\fR.
+.SS "Publishing scoped packages"
+.P
+Scoped packages can be published from the CLI as of \fBnpm@2\fR and can be published to any registry that supports them, including the primary npm registry.
+.P
+(As of 2015-04-19, and with npm 2.0 or better, the primary npm registry \fBdoes\fR support scoped packages.)
+.P
+If you wish, you may associate a scope with a registry; see below.
+.SS "Publishing public scoped packages to the primary npm registry"
+.P
+Publishing to a scope, you have two options:
+.RS 0
+.IP \(bu 4
+Publishing to your user scope (example: \fB@username/module\fR)
+.IP \(bu 4
+Publishing to an organization scope (example: \fB@org/module\fR)
+.RE 0
+
+.P
+If publishing a public module to an organization scope, you must first either create an organization with the name of the scope that you'd like to publish to or be added to an existing organization with the appropriate permissions. For example, if you'd like to publish to \fB@org\fR, you would need to create the \fBorg\fR organization on npmjs.com prior to trying to publish.
+.P
+Scoped packages are not public by default. You will need to specify \fB--access public\fR with the initial \fBnpm publish\fR command. This will publish the package and set access to \fBpublic\fR as if you had run \fBnpm access public\fR after publishing. You do not need to do this when publishing new versions of an existing scoped package.
+.SS "Publishing private scoped packages to the npm registry"
+.P
+To publish a private scoped package to the npm registry, you must have an \fBnpm Private Modules\fR \fI\(lahttps://docs.npmjs.com/private-modules/intro\(ra\fR account.
+.P
+You can then publish the module with \fBnpm publish\fR or \fBnpm publish
+--access restricted\fR, and it will be present in the npm registry, with restricted access. You can then change the access permissions, if desired, with \fBnpm access\fR or on the npmjs.com website.
+.SS "Associating a scope with a registry"
+.P
+Scopes can be associated with a separate registry. This allows you to seamlessly use a mix of packages from the primary npm registry and one or more private registries, such as \fBGitHub Packages\fR \fI\(lahttps://github.com/features/packages\(ra\fR or the open source \fBVerdaccio\fR \fI\(lahttps://verdaccio.org\(ra\fR project.
+.P
+You can associate a scope with a registry at login, e.g.
+.P
+.RS 2
+.nf
+npm login --registry=http://reg.example.com --scope=@myco
+.fi
+.RE
+.P
+Scopes have a many-to-one relationship with registries: one registry can host multiple scopes, but a scope only ever points to one registry.
+.P
+You can also associate a scope with a registry using \fBnpm config\fR:
+.P
+.RS 2
+.nf
+npm config set @myco:registry=http://reg.example.com
+.fi
+.RE
+.P
+Once a scope is associated with a registry, any \fBnpm install\fR for a package with that scope will request packages from that registry instead. Any \fBnpm publish\fR for a package name that contains the scope will be published to that registry instead.
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help access
+.IP \(bu 4
+npm help registry
+.RE 0
diff --git a/node/node_modules/npm/man/man7/scripts.7 b/node/node_modules/npm/man/man7/scripts.7
new file mode 100644
index 0000000000000000000000000000000000000000..54fb21ab0aeb7aa6ad33017de9d80b9fecf5a8c1
--- /dev/null
+++ b/node/node_modules/npm/man/man7/scripts.7
@@ -0,0 +1,457 @@
+.TH "SCRIPTS" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBScripts\fR - How npm handles the "scripts" field
+.SS "Description"
+.P
+The \fB"scripts"\fR property of your \fBpackage.json\fR file supports a number of built-in scripts and their preset life cycle events as well as arbitrary scripts. These all can be executed by running \fBnpm run <stage>\fR. \fIPre\fR and \fIpost\fR commands with matching names will be run for those as well (e.g. \fBpremyscript\fR, \fBmyscript\fR, \fBpostmyscript\fR). Scripts from dependencies can be run with \fBnpm explore <pkg> -- npm run <stage>\fR.
+.SS "Pre & Post Scripts"
+.P
+To create "pre" or "post" scripts for any scripts defined in the \fB"scripts"\fR section of the \fBpackage.json\fR, simply create another script \fIwith a matching name\fR and add "pre" or "post" to the beginning of them.
+.P
+.RS 2
+.nf
+{
+  "scripts": {
+    "precompress": "{{ executes BEFORE the `compress` script }}",
+    "compress": "{{ run command to compress files }}",
+    "postcompress": "{{ executes AFTER `compress` script }}"
+  }
+}
+.fi
+.RE
+.P
+In this example \fBnpm run compress\fR would execute these scripts as described.
+.SS "Life Cycle Scripts"
+.P
+There are some special life cycle scripts that happen only in certain situations. These scripts happen in addition to the \fBpre<event>\fR, \fBpost<event>\fR, and \fB<event>\fR scripts.
+.RS 0
+.IP \(bu 4
+\fBprepare\fR, \fBprepublish\fR, \fBprepublishOnly\fR, \fBprepack\fR, \fBpostpack\fR, \fBdependencies\fR
+.RE 0
+
+.P
+\fBprepare\fR (since \fBnpm@4.0.0\fR)
+.RS 0
+.IP \(bu 4
+Runs BEFORE the package is packed, i.e. during \fBnpm publish\fR and \fBnpm pack\fR
+.IP \(bu 4
+Runs on local \fBnpm install\fR without package arguments (runs with flags like \fB--production\fR or \fB--omit=dev\fR, but does not run when installing specific packages like \fBnpm install express\fR)
+.IP \(bu 4
+Runs AFTER \fBprepublishOnly\fR and \fBprepack\fR, but BEFORE \fBpostpack\fR
+.IP \(bu 4
+Runs for a package if it's being installed as a link through \fBnpm install <folder>\fR
+.IP \(bu 4
+NOTE: If a package being installed through git contains a \fBprepare\fR script, its \fBdependencies\fR and \fBdevDependencies\fR will be installed, and the prepare script will be run, before the package is packaged and installed.
+.IP \(bu 4
+As of \fBnpm@7\fR these scripts run in the background. To see the output, run with: \fB--foreground-scripts\fR.
+.IP \(bu 4
+\fBIn workspaces, prepare scripts run concurrently\fR across all packages. If you have interdependent packages where one must build before another, consider using \fB--foreground-scripts\fR (which can be set in \fB.npmrc\fR with \fBforeground-scripts=true\fR) to run scripts sequentially, or structure your build differently.
+.RE 0
+
+.P
+\fBprepublish\fR (DEPRECATED)
+.RS 0
+.IP \(bu 4
+Does not run during \fBnpm publish\fR, but does run during \fBnpm ci\fR and \fBnpm install\fR. See below for more info.
+.RE 0
+
+.P
+\fBprepublishOnly\fR
+.RS 0
+.IP \(bu 4
+Runs BEFORE the package is prepared and packed, ONLY on \fBnpm publish\fR.
+.RE 0
+
+.P
+\fBprepack\fR
+.RS 0
+.IP \(bu 4
+Runs BEFORE a tarball is packed (on "\fBnpm pack\fR", "\fBnpm publish\fR", and when installing a git dependency).
+.IP \(bu 4
+NOTE: "\fBnpm run pack\fR" is NOT the same as "\fBnpm pack\fR". "\fBnpm run pack\fR" is an arbitrary user defined script name, whereas, "\fBnpm pack\fR" is a CLI defined command.
+.RE 0
+
+.P
+\fBpostpack\fR
+.RS 0
+.IP \(bu 4
+Runs AFTER the tarball has been generated but before it is moved to its final destination (if at all, publish does not save the tarball locally)
+.RE 0
+
+.P
+\fBdependencies\fR
+.RS 0
+.IP \(bu 4
+Runs AFTER any operations that modify the \fBnode_modules\fR directory IF changes occurred.
+.IP \(bu 4
+Does NOT run in global mode
+.RE 0
+
+.SS "Prepare and Prepublish"
+.P
+\fBDeprecation Note: prepublish\fR
+.P
+Since \fBnpm@1.1.71\fR, the npm CLI has run the \fBprepublish\fR script for both \fBnpm publish\fR and \fBnpm install\fR, because it's a convenient way to prepare a package for use (some common use cases are described in the section below). It has also turned out to be, in practice, \fBvery confusing\fR \fI\(lahttps://github.com/npm/npm/issues/10074\(ra\fR. As of \fBnpm@4.0.0\fR, a new event has been introduced, \fBprepare\fR, that preserves this existing behavior. A \fInew\fR event, \fBprepublishOnly\fR has been added as a transitional strategy to allow users to avoid the confusing behavior of existing npm versions and only run on \fBnpm publish\fR (for instance, running the tests one last time to ensure they're in good shape).
+.P
+See \fI\(lahttps://github.com/npm/npm/issues/10074\(ra\fR for a much lengthier justification, with further reading, for this change.
+.P
+\fBUse Cases\fR
+.P
+Use a \fBprepare\fR script to perform build tasks that are platform-independent and need to run before your package is used. This includes tasks such as:
+.RS 0
+.IP \(bu 4
+Compiling TypeScript or other source code into JavaScript.
+.IP \(bu 4
+Creating minified versions of JavaScript source code.
+.IP \(bu 4
+Fetching remote resources that your package will use.
+.RE 0
+
+.P
+Running these build tasks in the \fBprepare\fR script ensures they happen once, in a single place, reducing complexity and variability. Additionally, this means that:
+.RS 0
+.IP \(bu 4
+You can depend on build tools as \fBdevDependencies\fR, and thus your users don't need to have them installed.
+.IP \(bu 4
+You don't need to include minifiers in your package, reducing the size for your users.
+.IP \(bu 4
+You don't need to rely on your users having \fBcurl\fR or \fBwget\fR or other system tools on the target machines.
+.RE 0
+
+.SS "Dependencies"
+.P
+The \fBdependencies\fR script is run any time an \fBnpm\fR command causes changes to the \fBnode_modules\fR directory. It is run AFTER the changes have been applied and the \fBpackage.json\fR and \fBpackage-lock.json\fR files have been updated.
+.SS "Life Cycle Operation Order"
+.SS "npm help \"cache add\""
+.RS 0
+.IP \(bu 4
+\fBprepare\fR
+.RE 0
+
+.SS "npm help ci"
+.RS 0
+.IP \(bu 4
+\fBpreinstall\fR
+.IP \(bu 4
+\fBinstall\fR
+.IP \(bu 4
+\fBpostinstall\fR
+.IP \(bu 4
+\fBprepublish\fR
+.IP \(bu 4
+\fBpreprepare\fR
+.IP \(bu 4
+\fBprepare\fR
+.IP \(bu 4
+\fBpostprepare\fR
+.RE 0
+
+.P
+These all run after the actual installation of modules into \fBnode_modules\fR, in order, with no internal actions happening in between
+.SS "npm help diff"
+.RS 0
+.IP \(bu 4
+\fBprepare\fR
+.RE 0
+
+.SS "npm help install"
+.P
+These also run when you run \fBnpm install -g <pkg-name>\fR
+.RS 0
+.IP \(bu 4
+\fBpreinstall\fR
+.IP \(bu 4
+\fBinstall\fR
+.IP \(bu 4
+\fBpostinstall\fR
+.IP \(bu 4
+\fBprepublish\fR
+.IP \(bu 4
+\fBpreprepare\fR
+.IP \(bu 4
+\fBprepare\fR
+.IP \(bu 4
+\fBpostprepare\fR
+.RE 0
+
+.P
+If there is a \fBbinding.gyp\fR file in the root of your package and you haven't defined your own \fBinstall\fR or \fBpreinstall\fR scripts, npm will default the \fBinstall\fR command to compile using node-gyp via \fBnode-gyp rebuild\fR
+.P
+These are run from the scripts of \fB<pkg-name>\fR
+.SS "npm help pack"
+.RS 0
+.IP \(bu 4
+\fBprepack\fR
+.IP \(bu 4
+\fBprepare\fR
+.IP \(bu 4
+\fBpostpack\fR
+.RE 0
+
+.SS "npm help publish"
+.RS 0
+.IP \(bu 4
+\fBprepublishOnly\fR
+.IP \(bu 4
+\fBprepack\fR
+.IP \(bu 4
+\fBprepare\fR
+.IP \(bu 4
+\fBpostpack\fR
+.IP \(bu 4
+\fBpublish\fR
+.IP \(bu 4
+\fBpostpublish\fR
+.RE 0
+
+.SS "npm help rebuild"
+.RS 0
+.IP \(bu 4
+\fBpreinstall\fR
+.IP \(bu 4
+\fBinstall\fR
+.IP \(bu 4
+\fBpostinstall\fR
+.IP \(bu 4
+\fBprepare\fR
+.RE 0
+
+.P
+\fBprepare\fR is only run if the current directory is a symlink (e.g. with linked packages)
+.SS "npm help restart"
+.P
+If there is a \fBrestart\fR script defined, these events are run; otherwise, \fBstop\fR and \fBstart\fR are both run if present, including their \fBpre\fR and \fBpost\fR iterations)
+.RS 0
+.IP \(bu 4
+\fBprerestart\fR
+.IP \(bu 4
+\fBrestart\fR
+.IP \(bu 4
+\fBpostrestart\fR
+.RE 0
+
+.SS "\fB\[rs]fBnpm run <user defined>\[rs]fR\fR \fI\(la/commands/npm-run\(ra\fR"
+.RS 0
+.IP \(bu 4
+\fBpre<user-defined>\fR
+.IP \(bu 4
+\fB<user-defined>\fR
+.IP \(bu 4
+\fBpost<user-defined>\fR
+.RE 0
+
+.SS "npm help start"
+.RS 0
+.IP \(bu 4
+\fBprestart\fR
+.IP \(bu 4
+\fBstart\fR
+.IP \(bu 4
+\fBpoststart\fR
+.RE 0
+
+.P
+If there is a \fBserver.js\fR file in the root of your package, then npm will default the \fBstart\fR command to \fBnode server.js\fR. \fBprestart\fR and \fBpoststart\fR will still run in this case.
+.SS "npm help stop"
+.RS 0
+.IP \(bu 4
+\fBprestop\fR
+.IP \(bu 4
+\fBstop\fR
+.IP \(bu 4
+\fBpoststop\fR
+.RE 0
+
+.SS "npm help test"
+.RS 0
+.IP \(bu 4
+\fBpretest\fR
+.IP \(bu 4
+\fBtest\fR
+.IP \(bu 4
+\fBposttest\fR
+.RE 0
+
+.SS "npm help version"
+.RS 0
+.IP \(bu 4
+\fBpreversion\fR
+.IP \(bu 4
+\fBversion\fR
+.IP \(bu 4
+\fBpostversion\fR
+.RE 0
+
+.SS "A Note on a lack of npm help uninstall scripts"
+.P
+While npm v6 had \fBuninstall\fR lifecycle scripts, npm v7 does not. Removal of a package can happen for a wide variety of reasons, and there's no clear way to currently give the script enough context to be useful.
+.P
+Reasons for a package removal include:
+.RS 0
+.IP \(bu 4
+a user directly uninstalled this package
+.IP \(bu 4
+a user uninstalled a dependent package and so this dependency is being uninstalled
+.IP \(bu 4
+a user uninstalled a dependent package but another package also depends on this version
+.IP \(bu 4
+this version has been merged as a duplicate with another version
+.IP \(bu 4
+etc.
+.RE 0
+
+.P
+Due to the lack of necessary context, \fBuninstall\fR lifecycle scripts are not implemented and will not function.
+.SS "Working Directory for Scripts"
+.P
+Scripts are always run from the root of the package folder, regardless of what the current working directory is when \fBnpm\fR is invoked. This means your scripts can reliably assume they are running in the package root.
+.P
+If you want your script to behave differently based on the directory you were in when you ran \fBnpm\fR, you can use the \fBINIT_CWD\fR environment variable, which holds the full path you were in when you ran \fBnpm run\fR.
+.SS "Historical Behavior in Older npm Versions"
+.P
+For npm v6 and earlier, scripts were generally run from the root of the package, but there were rare cases and bugs in older versions where this was not guaranteed. If your package must support very old npm versions, you may wish to add a safeguard in your scripts (for example, by checking process.cwd()).
+.P
+For more details, see:
+.RS 0
+.IP \(bu 4
+\fBnpm v7 release notes\fR \fI\(lahttps://github.com/npm/cli/releases/tag/v7.0.0\(ra\fR
+.IP \(bu 4
+\fBDiscussion about script working directory reliability in npm v6 and earlier\fR \fI\(lahttps://github.com/npm/npm/issues/12356\(ra\fR
+.RE 0
+
+.SS "Environment"
+.P
+Package scripts run in an environment where many pieces of information are made available regarding the setup of npm and the current state of the process.
+.SS "path"
+.P
+If you depend on modules that define executable scripts, like test suites, then those executables will be added to the \fBPATH\fR for executing the scripts. So, if your package.json has this:
+.P
+.RS 2
+.nf
+{
+  "name" : "foo",
+  "dependencies" : {
+    "bar" : "0.1.x"
+  },
+  "scripts": {
+    "start" : "bar ./test"
+  }
+}
+.fi
+.RE
+.P
+then you could run \fBnpm start\fR to execute the \fBbar\fR script, which is exported into the \fBnode_modules/.bin\fR directory on \fBnpm install\fR.
+.SS "package.json vars"
+.P
+npm sets the following environment variables from the package.json:
+.RS 0
+.IP \(bu 4
+\fBnpm_package_name\fR - The package name
+.IP \(bu 4
+\fBnpm_package_version\fR - The package version
+.IP \(bu 4
+\fBnpm_package_bin_*\fR - Each executable defined in the bin field
+.IP \(bu 4
+\fBnpm_package_engines_*\fR - Each engine defined in the engines field
+.IP \(bu 4
+\fBnpm_package_config_*\fR - Each config value defined in the config field
+.IP \(bu 4
+\fBnpm_package_json\fR - The full path to the package.json file
+.RE 0
+
+.P
+Additionally, for install scripts (\fBpreinstall\fR, \fBinstall\fR, \fBpostinstall\fR), npm sets these environment variables:
+.RS 0
+.IP \(bu 4
+\fBnpm_package_resolved\fR - The resolved URL for the package
+.IP \(bu 4
+\fBnpm_package_integrity\fR - The integrity hash for the package
+.IP \(bu 4
+\fBnpm_package_optional\fR - Set to \fB"true"\fR if the package is optional
+.IP \(bu 4
+\fBnpm_package_dev\fR - Set to \fB"true"\fR if the package is a dev dependency
+.IP \(bu 4
+\fBnpm_package_peer\fR - Set to \fB"true"\fR if the package is a peer dependency
+.IP \(bu 4
+\fBnpm_package_dev_optional\fR - Set to \fB"true"\fR if the package is both dev and optional
+.RE 0
+
+.P
+For example, if you had \fB{"name":"foo", "version":"1.2.5"}\fR in your package.json file, then your package scripts would have the \fBnpm_package_name\fR environment variable set to "foo", and the \fBnpm_package_version\fR set to "1.2.5". You can access these variables in your code with \fBprocess.env.npm_package_name\fR and \fBprocess.env.npm_package_version\fR.
+.P
+\fBNote:\fR In npm 7 and later, most package.json fields are no longer provided as environment variables. Scripts that need access to other package.json fields should read the package.json file directly. The \fBnpm_package_json\fR environment variable provides the path to the file for this purpose.
+.P
+See \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR for more on package configs.
+.SS "current lifecycle event"
+.P
+Lastly, the \fBnpm_lifecycle_event\fR environment variable is set to whichever stage of the cycle is being executed. So, you could have a single script used for different parts of the process which switches based on what's currently happening.
+.P
+Objects are flattened following this format, so if you had \fB{"scripts":{"install":"foo.js"}}\fR in your package.json, then you'd see this in the script:
+.P
+.RS 2
+.nf
+process.env.npm_package_scripts_install === "foo.js"
+.fi
+.RE
+.SS "Examples"
+.P
+For example, if your package.json contains this:
+.P
+.RS 2
+.nf
+{
+  "scripts" : {
+    "prepare" : "scripts/build.js",
+    "test" : "scripts/test.js"
+  }
+}
+.fi
+.RE
+.P
+then \fBscripts/build.js\fR will be called for the prepare stage of the lifecycle, and you can check the \fBnpm_lifecycle_event\fR environment variable if your script needs to behave differently in different contexts.
+.P
+If you want to run build commands, you can do so. This works just fine:
+.P
+.RS 2
+.nf
+{
+  "scripts" : {
+    "prepare" : "npm run build",
+    "build" : "tsc",
+    "test" : "jest"
+  }
+}
+.fi
+.RE
+.SS "Exiting"
+.P
+Scripts are run by passing the line as a script argument to \fB/bin/sh\fR on POSIX systems or \fBcmd.exe\fR on Windows. You can control which shell is used by setting the \fB\[rs]fBscript-shell\[rs]fR\fR \fI\(la/using-npm/config#script-shell\(ra\fR configuration option.
+.P
+If the script exits with a code other than 0, then this will abort the process.
+.P
+Note that these script files don't have to be Node.js or even JavaScript programs. They just have to be some kind of executable file.
+.SS "Best Practices"
+.RS 0
+.IP \(bu 4
+Don't exit with a non-zero error code unless you \fIreally\fR mean it. If the failure is minor or only will prevent some optional features, then it's better to just print a warning and exit successfully.
+.IP \(bu 4
+Try not to use scripts to do what npm can do for you. Read through \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json\(ra\fR to see all the things that you can specify and enable by simply describing your package appropriately. In general, this will lead to a more robust and consistent state.
+.IP \(bu 4
+Inspect the env to determine where to put things. For instance, if the \fBNPM_CONFIG_BINROOT\fR environment variable is set to \fB/home/user/bin\fR, then don't try to install executables into \fB/usr/local/bin\fR. The user probably set it up that way for a reason.
+.IP \(bu 4
+Don't prefix your script commands with "sudo". If root permissions are required for some reason, then it'll fail with that error, and the user will sudo the npm command in question.
+.IP \(bu 4
+Don't use \fBinstall\fR. Use a \fB.gyp\fR file for compilation, and \fBprepare\fR for anything else. You should almost never have to explicitly set a preinstall or install script. If you are doing this, please consider if there is another option. The only valid use of \fBinstall\fR or \fBpreinstall\fR scripts is for compilation which must be done on the target architecture.
+.RE 0
+
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+\fBpackage.json\fR \fI\(la/configuring-npm/package-json\(ra\fR
+.IP \(bu 4
+npm help developers
+.IP \(bu 4
+npm help install
+.RE 0
diff --git a/node/node_modules/npm/man/man7/workspaces.7 b/node/node_modules/npm/man/man7/workspaces.7
new file mode 100644
index 0000000000000000000000000000000000000000..77a93a08f8d8ef41b3e9b4ef320118da7fdea51d
--- /dev/null
+++ b/node/node_modules/npm/man/man7/workspaces.7
@@ -0,0 +1,236 @@
+.TH "WORKSPACES" "7" "April 2026" "NPM@11.13.0" ""
+.SH "NAME"
+\fBWorkspaces\fR - Working with workspaces
+.SS "Description"
+.P
+\fBWorkspaces\fR is a generic term that refers to the set of features in the npm cli that provides support for managing multiple packages from your local file system from within a singular top-level, root package.
+.P
+This set of features makes up for a much more streamlined workflow handling linked packages from the local file system. It automates the linking process as part of \fBnpm install\fR and removes the need to manually use \fBnpm link\fR in order to add references to packages that should be symlinked into the current \fBnode_modules\fR folder.
+.P
+We also refer to these packages being auto-symlinked during \fBnpm install\fR as a single \fBworkspace\fR, meaning it's a nested package within the current local file system that is explicitly defined in the \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json#workspaces\(ra\fR \fBworkspaces\fR configuration.
+.SS "Defining workspaces"
+.P
+Workspaces are usually defined via the \fBworkspaces\fR property of the \fB\[rs]fBpackage.json\[rs]fR\fR \fI\(la/configuring-npm/package-json#workspaces\(ra\fR file, e.g:
+.P
+.RS 2
+.nf
+{
+  "name": "my-workspaces-powered-project",
+  "workspaces": \[lB]
+    "packages/a"
+  \[rB]
+}
+.fi
+.RE
+.P
+Given the above \fBpackage.json\fR example living at a current working directory \fB.\fR that contains a folder named \fBpackages/a\fR that itself contains a \fBpackage.json\fR inside it, defining a Node.js package, e.g:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+.fi
+.RE
+.P
+The expected result once running \fBnpm install\fR in this current working directory \fB.\fR is that the folder \fBpackages/a\fR will get symlinked to the \fBnode_modules\fR folder of the current working dir.
+.P
+Below is a post \fBnpm install\fR example, given that same previous example structure of files and folders:
+.P
+.RS 2
+.nf
+.
++-- node_modules
+|  `-- a -> ../packages/a
++-- package-lock.json
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+.fi
+.RE
+.SS "Getting started with workspaces"
+.P
+You may automate the required steps to define a new workspace using npm help init. For example in a project that already has a \fBpackage.json\fR defined you can run:
+.P
+.RS 2
+.nf
+npm init -w ./packages/a
+.fi
+.RE
+.P
+This command will create the missing folders and a new \fBpackage.json\fR file (if needed) while also making sure to properly configure the \fB"workspaces"\fR property of your root project \fBpackage.json\fR.
+.SS "Adding dependencies to a workspace"
+.P
+It's possible to directly add/remove/update dependencies of your workspaces using the \fB\[rs]fBworkspace\[rs]fR config\fR \fI\(la/using-npm/config#workspace\(ra\fR.
+.P
+For example, assuming the following structure:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- b
+       `-- package.json
+.fi
+.RE
+.P
+If you want to add a dependency named \fBabbrev\fR from the registry as a dependency of your workspace \fBa\fR, you may use the workspace config to tell the npm installer that package should be added as a dependency of the provided workspace:
+.P
+.RS 2
+.nf
+npm install abbrev -w a
+.fi
+.RE
+.P
+\fBAdding a workspace as a dependency of another workspace:\fR
+.P
+The same approach works when adding one workspace as a dependency of another. If you want to add workspace \fBb\fR as a dependency of workspace \fBa\fR, run:
+.P
+.RS 2
+.nf
+npm install b -w a
+.fi
+.RE
+.P
+npm will detect that \fBb\fR is a workspace and automatically symlink it rather than fetching it from the registry. The resulting entry in workspace \fBa\fR's \fBpackage.json\fR will use a standard version range:
+.P
+.RS 2
+.nf
+{
+  "dependencies": {
+    "b": "^1.0.0"
+  }
+}
+.fi
+.RE
+.P
+Note: other installing commands such as \fBuninstall\fR, \fBci\fR, etc will also respect the provided \fBworkspace\fR configuration.
+.SS "Using workspaces"
+.P
+Given the \fBspecifics of how Node.js handles module resolution\fR \fI\(lahttps://nodejs.org/dist/latest-v14.x/docs/api/modules.html#modules_all_together\(ra\fR it's possible to consume any defined workspace by its declared \fBpackage.json\fR \fBname\fR. Continuing from the example defined above, let's also create a Node.js script that will require the workspace \fBa\fR example module, e.g:
+.P
+.RS 2
+.nf
+// ./packages/a/index.js
+module.exports = 'a'
+
+// ./lib/index.js
+const moduleA = require('a')
+console.log(moduleA) // -> a
+.fi
+.RE
+.P
+When running it with:
+.P
+\fBnode lib/index.js\fR
+.P
+This demonstrates how the nature of \fBnode_modules\fR resolution allows for \fBworkspaces\fR to enable a portable workflow for requiring each \fBworkspace\fR in such a way that is also easy to npm help publish these nested workspaces to be consumed elsewhere.
+.SS "Running commands in the context of workspaces"
+.P
+You can use the \fBworkspace\fR configuration option to run commands in the context of a configured workspace. Additionally, if your current directory is in a workspace, the \fBworkspace\fR configuration is implicitly set, and \fBprefix\fR is set to the root workspace.
+.P
+Following is a quick example on how to use the \fBnpm run\fR command in the context of nested workspaces. For a project containing multiple workspaces, e.g:
+.P
+.RS 2
+.nf
+.
++-- package.json
+`-- packages
+   +-- a
+   |   `-- package.json
+   `-- b
+       `-- package.json
+.fi
+.RE
+.P
+By running a command using the \fBworkspace\fR option, it's possible to run the given command in the context of that specific workspace. e.g:
+.P
+.RS 2
+.nf
+npm run test --workspace=a
+.fi
+.RE
+.P
+You could also run the command within the workspace.
+.P
+.RS 2
+.nf
+cd packages/a && npm run test
+.fi
+.RE
+.P
+Either will run the \fBtest\fR script defined within the \fB./packages/a/package.json\fR file.
+.P
+Please note that you can also specify this argument multiple times in the command-line in order to target multiple workspaces, e.g:
+.P
+.RS 2
+.nf
+npm run test --workspace=a --workspace=b
+.fi
+.RE
+.P
+Or run the command for each workspace within the 'packages' folder:
+.P
+.RS 2
+.nf
+npm run test --workspace=packages
+.fi
+.RE
+.P
+It's also possible to use the \fBworkspaces\fR (plural) configuration option to enable the same behavior but running that command in the context of \fBall\fR configured workspaces. e.g:
+.P
+.RS 2
+.nf
+npm run test --workspaces
+.fi
+.RE
+.P
+Will run the \fBtest\fR script in both \fB./packages/a\fR and \fB./packages/b\fR.
+.P
+Commands will be run in each workspace in the order they appear in your \fBpackage.json\fR
+.P
+.RS 2
+.nf
+{
+  "workspaces": \[lB] "packages/a", "packages/b" \[rB]
+}
+.fi
+.RE
+.P
+Order of run is different with:
+.P
+.RS 2
+.nf
+{
+  "workspaces": \[lB] "packages/b", "packages/a" \[rB]
+}
+.fi
+.RE
+.SS "Ignoring missing scripts"
+.P
+It is not required for all of the workspaces to implement scripts run with the \fBnpm run\fR command.
+.P
+By running the command with the \fB--if-present\fR flag, npm will ignore workspaces missing target script.
+.P
+.RS 2
+.nf
+npm run test --workspaces --if-present
+.fi
+.RE
+.SS "See also"
+.RS 0
+.IP \(bu 4
+npm help install
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help run
+.IP \(bu 4
+npm help config
+.RE 0
diff --git a/node/node_modules/npm/node_modules/@gar/promise-retry/LICENSE b/node/node_modules/npm/node_modules/@gar/promise-retry/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..b9e98d82a1cd8a300d43caf9ff4303db16226348
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@gar/promise-retry/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tim Koschützki (tim@debuggable.com), Felix Geisendörfer (felix@debuggable.com)
+Copyright (c) 2014 IndigoUnited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node/node_modules/npm/node_modules/@gar/promise-retry/lib/index.js b/node/node_modules/npm/node_modules/@gar/promise-retry/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..2de4ff81ce2f2c70181fc7d4da28e946ffb3f3e6
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@gar/promise-retry/lib/index.js
@@ -0,0 +1,62 @@
+const { RetryOperation } = require('./retry')
+
+const createTimeout = (attempt, opts) => Math.min(Math.round((1 + (opts.randomize ? Math.random() : 0)) * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt)), opts.maxTimeout)
+const isRetryError = err => err?.code === 'EPROMISERETRY' && Object.hasOwn(err, 'retried')
+
+const promiseRetry = async (fn, options = {}) => {
+  let timeouts = []
+  if (options instanceof Array) {
+    timeouts = [...options]
+  } else {
+    if (options.retries === Infinity) {
+      options.forever = true
+      delete options.retries
+    }
+    const opts = {
+      retries: 10,
+      factor: 2,
+      minTimeout: 1 * 1000,
+      maxTimeout: Infinity,
+      randomize: false,
+      ...options
+    }
+    if (opts.minTimeout > opts.maxTimeout) {
+      throw new Error('minTimeout is greater than maxTimeout')
+    }
+    if (opts.retries) {
+      for (let i = 0; i < opts.retries; i++) {
+        timeouts.push(createTimeout(i, opts))
+      }
+      // sort the array numerically ascending (since the timeouts may be out of order at factor < 1)
+      timeouts.sort((a, b) => a - b)
+    } else if (options.forever) {
+      timeouts.push(createTimeout(0, opts))
+    }
+  }
+
+  const operation = new RetryOperation(timeouts, {
+    forever: options.forever,
+    unref: options.unref,
+    maxRetryTime: options.maxRetryTime
+  })
+
+  return new Promise(function (resolve, reject) {
+    operation.attempt(async number => {
+      try {
+        const result = await fn(err => {
+          throw Object.assign(new Error('Retrying'), { code: 'EPROMISERETRY', retried: err })
+        }, number, operation)
+        return resolve(result)
+      } catch (err) {
+        if (!isRetryError(err)) {
+          return reject(err)
+        }
+        if (!operation.retry(err.retried || new Error())) {
+          return reject(err.retried)
+        }
+      }
+    })
+  })
+}
+
+module.exports = { promiseRetry }
diff --git a/node/node_modules/npm/node_modules/@gar/promise-retry/lib/retry.js b/node/node_modules/npm/node_modules/@gar/promise-retry/lib/retry.js
new file mode 100644
index 0000000000000000000000000000000000000000..646b4fc805691bb3bb5c75145582420e55ea5e5e
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@gar/promise-retry/lib/retry.js
@@ -0,0 +1,109 @@
+class RetryOperation {
+  #attempts = 1
+  #cachedTimeouts = null
+  #errors = []
+  #fn = null
+  #maxRetryTime
+  #operationStart = null
+  #originalTimeouts
+  #timeouts
+  #timer = null
+  #unref
+
+  constructor (timeouts, options = {}) {
+    this.#originalTimeouts = [...timeouts]
+    this.#timeouts = [...timeouts]
+    this.#unref = options.unref
+    this.#maxRetryTime = options.maxRetryTime || Infinity
+    if (options.forever) {
+      this.#cachedTimeouts = [...this.#timeouts]
+    }
+  }
+
+  get timeouts () {
+    return [...this.#timeouts]
+  }
+
+  get errors () {
+    return [...this.#errors]
+  }
+
+  get attempts () {
+    return this.#attempts
+  }
+
+  get mainError () {
+    let mainError = null
+    if (this.#errors.length) {
+      let mainErrorCount = 0
+      const counts = {}
+      for (let i = 0; i < this.#errors.length; i++) {
+        const error = this.#errors[i]
+        const { message } = error
+        if (!counts[message]) {
+          counts[message] = 0
+        }
+        counts[message]++
+
+        if (counts[message] >= mainErrorCount) {
+          mainError = error
+          mainErrorCount = counts[message]
+        }
+      }
+    }
+    return mainError
+  }
+
+  reset () {
+    this.#attempts = 1
+    this.#timeouts = [...this.#originalTimeouts]
+  }
+
+  stop () {
+    if (this.#timer) {
+      clearTimeout(this.#timer)
+    }
+
+    this.#timeouts = []
+    this.#cachedTimeouts = null
+  }
+
+  retry (err) {
+    this.#errors.push(err)
+    if (new Date().getTime() - this.#operationStart >= this.#maxRetryTime) {
+      // XXX This puts the timeout error first, meaning it will never show as mainError, there may be no way to ever see this
+      this.#errors.unshift(new Error('RetryOperation timeout occurred'))
+      return false
+    }
+
+    let timeout = this.#timeouts.shift()
+    if (timeout === undefined) {
+      // We're out of timeouts, clear the last error and repeat the final timeout
+      if (this.#cachedTimeouts) {
+        this.#errors.pop()
+        timeout = this.#cachedTimeouts.at(-1)
+      } else {
+        return false
+      }
+    }
+
+    // TODO what if there already is a timer?
+    this.#timer = setTimeout(() => {
+      this.#attempts++
+      this.#fn(this.#attempts)
+    }, timeout)
+
+    if (this.#unref) {
+      this.#timer.unref()
+    }
+
+    return true
+  }
+
+  attempt (fn) {
+    this.#fn = fn
+    this.#operationStart = new Date().getTime()
+    this.#fn(this.#attempts)
+  }
+}
+module.exports = { RetryOperation }
diff --git a/node/node_modules/npm/node_modules/@gar/promise-retry/package.json b/node/node_modules/npm/node_modules/@gar/promise-retry/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..362908c5305f5bacf907773b064c2e8192f464a2
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@gar/promise-retry/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "@gar/promise-retry",
+  "version": "1.0.3",
+  "description": "Retries a function that returns a promise, leveraging the power of the retry module.",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "type": "commonjs",
+  "exports": {
+    ".": [
+      {
+        "default": "./lib/index.js",
+        "types": "./lib/index.d.ts"
+      },
+      "./lib/index.js"
+    ]
+  },
+  "scripts": {
+    "lint": "npx standard",
+    "lint:fix": "npx standard --fix",
+    "test": "node --test --experimental-test-coverage --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=100",
+    "typelint": "npx -p typescript tsc ./lib/index.d.ts",
+    "posttest": "npm run lint",
+    "postlint": "npm run typelint"
+  },
+  "bugs": {
+    "url": "https://github.com/wraithgar/node-promise-retry/issues/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/wraithgar/node-promise-retry.git"
+  },
+  "keywords": [
+    "retry",
+    "promise",
+    "backoff",
+    "repeat",
+    "replay"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0"
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@isaacs/fs-minipass/LICENSE b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..32eb517086ebb24cfe3dd076033211d444186dc9
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/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/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/commonjs/index.js b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/commonjs/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef71e40140c578ce2628d0318bcdaf292cfcbb14
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/commonjs/index.js
@@ -0,0 +1,430 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteStreamSync = exports.WriteStream = exports.ReadStreamSync = exports.ReadStream = void 0;
+const events_1 = __importDefault(require("events"));
+const fs_1 = __importDefault(require("fs"));
+const minipass_1 = require("minipass");
+const writev = fs_1.default.writev;
+const _autoClose = Symbol('_autoClose');
+const _close = Symbol('_close');
+const _ended = Symbol('_ended');
+const _fd = Symbol('_fd');
+const _finished = Symbol('_finished');
+const _flags = Symbol('_flags');
+const _flush = Symbol('_flush');
+const _handleChunk = Symbol('_handleChunk');
+const _makeBuf = Symbol('_makeBuf');
+const _mode = Symbol('_mode');
+const _needDrain = Symbol('_needDrain');
+const _onerror = Symbol('_onerror');
+const _onopen = Symbol('_onopen');
+const _onread = Symbol('_onread');
+const _onwrite = Symbol('_onwrite');
+const _open = Symbol('_open');
+const _path = Symbol('_path');
+const _pos = Symbol('_pos');
+const _queue = Symbol('_queue');
+const _read = Symbol('_read');
+const _readSize = Symbol('_readSize');
+const _reading = Symbol('_reading');
+const _remain = Symbol('_remain');
+const _size = Symbol('_size');
+const _write = Symbol('_write');
+const _writing = Symbol('_writing');
+const _defaultFlag = Symbol('_defaultFlag');
+const _errored = Symbol('_errored');
+class ReadStream extends minipass_1.Minipass {
+    [_errored] = false;
+    [_fd];
+    [_path];
+    [_readSize];
+    [_reading] = false;
+    [_size];
+    [_remain];
+    [_autoClose];
+    constructor(path, opt) {
+        opt = opt || {};
+        super(opt);
+        this.readable = true;
+        this.writable = false;
+        if (typeof path !== 'string') {
+            throw new TypeError('path must be a string');
+        }
+        this[_errored] = false;
+        this[_fd] = typeof opt.fd === 'number' ? opt.fd : undefined;
+        this[_path] = path;
+        this[_readSize] = opt.readSize || 16 * 1024 * 1024;
+        this[_reading] = false;
+        this[_size] = typeof opt.size === 'number' ? opt.size : Infinity;
+        this[_remain] = this[_size];
+        this[_autoClose] =
+            typeof opt.autoClose === 'boolean' ? opt.autoClose : true;
+        if (typeof this[_fd] === 'number') {
+            this[_read]();
+        }
+        else {
+            this[_open]();
+        }
+    }
+    get fd() {
+        return this[_fd];
+    }
+    get path() {
+        return this[_path];
+    }
+    //@ts-ignore
+    write() {
+        throw new TypeError('this is a readable stream');
+    }
+    //@ts-ignore
+    end() {
+        throw new TypeError('this is a readable stream');
+    }
+    [_open]() {
+        fs_1.default.open(this[_path], 'r', (er, fd) => this[_onopen](er, fd));
+    }
+    [_onopen](er, fd) {
+        if (er) {
+            this[_onerror](er);
+        }
+        else {
+            this[_fd] = fd;
+            this.emit('open', fd);
+            this[_read]();
+        }
+    }
+    [_makeBuf]() {
+        return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]));
+    }
+    [_read]() {
+        if (!this[_reading]) {
+            this[_reading] = true;
+            const buf = this[_makeBuf]();
+            /* c8 ignore start */
+            if (buf.length === 0) {
+                return process.nextTick(() => this[_onread](null, 0, buf));
+            }
+            /* c8 ignore stop */
+            fs_1.default.read(this[_fd], buf, 0, buf.length, null, (er, br, b) => this[_onread](er, br, b));
+        }
+    }
+    [_onread](er, br, buf) {
+        this[_reading] = false;
+        if (er) {
+            this[_onerror](er);
+        }
+        else if (this[_handleChunk](br, buf)) {
+            this[_read]();
+        }
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs_1.default.close(fd, er => er ? this.emit('error', er) : this.emit('close'));
+        }
+    }
+    [_onerror](er) {
+        this[_reading] = true;
+        this[_close]();
+        this.emit('error', er);
+    }
+    [_handleChunk](br, buf) {
+        let ret = false;
+        // no effect if infinite
+        this[_remain] -= br;
+        if (br > 0) {
+            ret = super.write(br < buf.length ? buf.subarray(0, br) : buf);
+        }
+        if (br === 0 || this[_remain] <= 0) {
+            ret = false;
+            this[_close]();
+            super.end();
+        }
+        return ret;
+    }
+    emit(ev, ...args) {
+        switch (ev) {
+            case 'prefinish':
+            case 'finish':
+                return false;
+            case 'drain':
+                if (typeof this[_fd] === 'number') {
+                    this[_read]();
+                }
+                return false;
+            case 'error':
+                if (this[_errored]) {
+                    return false;
+                }
+                this[_errored] = true;
+                return super.emit(ev, ...args);
+            default:
+                return super.emit(ev, ...args);
+        }
+    }
+}
+exports.ReadStream = ReadStream;
+class ReadStreamSync extends ReadStream {
+    [_open]() {
+        let threw = true;
+        try {
+            this[_onopen](null, fs_1.default.openSync(this[_path], 'r'));
+            threw = false;
+        }
+        finally {
+            if (threw) {
+                this[_close]();
+            }
+        }
+    }
+    [_read]() {
+        let threw = true;
+        try {
+            if (!this[_reading]) {
+                this[_reading] = true;
+                do {
+                    const buf = this[_makeBuf]();
+                    /* c8 ignore start */
+                    const br = buf.length === 0
+                        ? 0
+                        : fs_1.default.readSync(this[_fd], buf, 0, buf.length, null);
+                    /* c8 ignore stop */
+                    if (!this[_handleChunk](br, buf)) {
+                        break;
+                    }
+                } while (true);
+                this[_reading] = false;
+            }
+            threw = false;
+        }
+        finally {
+            if (threw) {
+                this[_close]();
+            }
+        }
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs_1.default.closeSync(fd);
+            this.emit('close');
+        }
+    }
+}
+exports.ReadStreamSync = ReadStreamSync;
+class WriteStream extends events_1.default {
+    readable = false;
+    writable = true;
+    [_errored] = false;
+    [_writing] = false;
+    [_ended] = false;
+    [_queue] = [];
+    [_needDrain] = false;
+    [_path];
+    [_mode];
+    [_autoClose];
+    [_fd];
+    [_defaultFlag];
+    [_flags];
+    [_finished] = false;
+    [_pos];
+    constructor(path, opt) {
+        opt = opt || {};
+        super(opt);
+        this[_path] = path;
+        this[_fd] = typeof opt.fd === 'number' ? opt.fd : undefined;
+        this[_mode] = opt.mode === undefined ? 0o666 : opt.mode;
+        this[_pos] = typeof opt.start === 'number' ? opt.start : undefined;
+        this[_autoClose] =
+            typeof opt.autoClose === 'boolean' ? opt.autoClose : true;
+        // truncating makes no sense when writing into the middle
+        const defaultFlag = this[_pos] !== undefined ? 'r+' : 'w';
+        this[_defaultFlag] = opt.flags === undefined;
+        this[_flags] = opt.flags === undefined ? defaultFlag : opt.flags;
+        if (this[_fd] === undefined) {
+            this[_open]();
+        }
+    }
+    emit(ev, ...args) {
+        if (ev === 'error') {
+            if (this[_errored]) {
+                return false;
+            }
+            this[_errored] = true;
+        }
+        return super.emit(ev, ...args);
+    }
+    get fd() {
+        return this[_fd];
+    }
+    get path() {
+        return this[_path];
+    }
+    [_onerror](er) {
+        this[_close]();
+        this[_writing] = true;
+        this.emit('error', er);
+    }
+    [_open]() {
+        fs_1.default.open(this[_path], this[_flags], this[_mode], (er, fd) => this[_onopen](er, fd));
+    }
+    [_onopen](er, fd) {
+        if (this[_defaultFlag] &&
+            this[_flags] === 'r+' &&
+            er &&
+            er.code === 'ENOENT') {
+            this[_flags] = 'w';
+            this[_open]();
+        }
+        else if (er) {
+            this[_onerror](er);
+        }
+        else {
+            this[_fd] = fd;
+            this.emit('open', fd);
+            if (!this[_writing]) {
+                this[_flush]();
+            }
+        }
+    }
+    end(buf, enc) {
+        if (buf) {
+            //@ts-ignore
+            this.write(buf, enc);
+        }
+        this[_ended] = true;
+        // synthetic after-write logic, where drain/finish live
+        if (!this[_writing] &&
+            !this[_queue].length &&
+            typeof this[_fd] === 'number') {
+            this[_onwrite](null, 0);
+        }
+        return this;
+    }
+    write(buf, enc) {
+        if (typeof buf === 'string') {
+            buf = Buffer.from(buf, enc);
+        }
+        if (this[_ended]) {
+            this.emit('error', new Error('write() after end()'));
+            return false;
+        }
+        if (this[_fd] === undefined || this[_writing] || this[_queue].length) {
+            this[_queue].push(buf);
+            this[_needDrain] = true;
+            return false;
+        }
+        this[_writing] = true;
+        this[_write](buf);
+        return true;
+    }
+    [_write](buf) {
+        fs_1.default.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw));
+    }
+    [_onwrite](er, bw) {
+        if (er) {
+            this[_onerror](er);
+        }
+        else {
+            if (this[_pos] !== undefined && typeof bw === 'number') {
+                this[_pos] += bw;
+            }
+            if (this[_queue].length) {
+                this[_flush]();
+            }
+            else {
+                this[_writing] = false;
+                if (this[_ended] && !this[_finished]) {
+                    this[_finished] = true;
+                    this[_close]();
+                    this.emit('finish');
+                }
+                else if (this[_needDrain]) {
+                    this[_needDrain] = false;
+                    this.emit('drain');
+                }
+            }
+        }
+    }
+    [_flush]() {
+        if (this[_queue].length === 0) {
+            if (this[_ended]) {
+                this[_onwrite](null, 0);
+            }
+        }
+        else if (this[_queue].length === 1) {
+            this[_write](this[_queue].pop());
+        }
+        else {
+            const iovec = this[_queue];
+            this[_queue] = [];
+            writev(this[_fd], iovec, this[_pos], (er, bw) => this[_onwrite](er, bw));
+        }
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs_1.default.close(fd, er => er ? this.emit('error', er) : this.emit('close'));
+        }
+    }
+}
+exports.WriteStream = WriteStream;
+class WriteStreamSync extends WriteStream {
+    [_open]() {
+        let fd;
+        // only wrap in a try{} block if we know we'll retry, to avoid
+        // the rethrow obscuring the error's source frame in most cases.
+        if (this[_defaultFlag] && this[_flags] === 'r+') {
+            try {
+                fd = fs_1.default.openSync(this[_path], this[_flags], this[_mode]);
+            }
+            catch (er) {
+                if (er?.code === 'ENOENT') {
+                    this[_flags] = 'w';
+                    return this[_open]();
+                }
+                else {
+                    throw er;
+                }
+            }
+        }
+        else {
+            fd = fs_1.default.openSync(this[_path], this[_flags], this[_mode]);
+        }
+        this[_onopen](null, fd);
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs_1.default.closeSync(fd);
+            this.emit('close');
+        }
+    }
+    [_write](buf) {
+        // throw the original, but try to close if it fails
+        let threw = true;
+        try {
+            this[_onwrite](null, fs_1.default.writeSync(this[_fd], buf, 0, buf.length, this[_pos]));
+            threw = false;
+        }
+        finally {
+            if (threw) {
+                try {
+                    this[_close]();
+                }
+                catch {
+                    // ok error
+                }
+            }
+        }
+    }
+}
+exports.WriteStreamSync = WriteStreamSync;
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/commonjs/package.json b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/commonjs/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..140154e8de6e45b8f73020ef9c28c8ce2321bda2
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/commonjs/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}
diff --git a/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/esm/index.js b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/esm/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e147224443dc0259ba1e21bd3c066ab1809c7122
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/esm/index.js
@@ -0,0 +1,420 @@
+import EE from 'events';
+import fs from 'fs';
+import { Minipass } from 'minipass';
+const writev = fs.writev;
+const _autoClose = Symbol('_autoClose');
+const _close = Symbol('_close');
+const _ended = Symbol('_ended');
+const _fd = Symbol('_fd');
+const _finished = Symbol('_finished');
+const _flags = Symbol('_flags');
+const _flush = Symbol('_flush');
+const _handleChunk = Symbol('_handleChunk');
+const _makeBuf = Symbol('_makeBuf');
+const _mode = Symbol('_mode');
+const _needDrain = Symbol('_needDrain');
+const _onerror = Symbol('_onerror');
+const _onopen = Symbol('_onopen');
+const _onread = Symbol('_onread');
+const _onwrite = Symbol('_onwrite');
+const _open = Symbol('_open');
+const _path = Symbol('_path');
+const _pos = Symbol('_pos');
+const _queue = Symbol('_queue');
+const _read = Symbol('_read');
+const _readSize = Symbol('_readSize');
+const _reading = Symbol('_reading');
+const _remain = Symbol('_remain');
+const _size = Symbol('_size');
+const _write = Symbol('_write');
+const _writing = Symbol('_writing');
+const _defaultFlag = Symbol('_defaultFlag');
+const _errored = Symbol('_errored');
+export class ReadStream extends Minipass {
+    [_errored] = false;
+    [_fd];
+    [_path];
+    [_readSize];
+    [_reading] = false;
+    [_size];
+    [_remain];
+    [_autoClose];
+    constructor(path, opt) {
+        opt = opt || {};
+        super(opt);
+        this.readable = true;
+        this.writable = false;
+        if (typeof path !== 'string') {
+            throw new TypeError('path must be a string');
+        }
+        this[_errored] = false;
+        this[_fd] = typeof opt.fd === 'number' ? opt.fd : undefined;
+        this[_path] = path;
+        this[_readSize] = opt.readSize || 16 * 1024 * 1024;
+        this[_reading] = false;
+        this[_size] = typeof opt.size === 'number' ? opt.size : Infinity;
+        this[_remain] = this[_size];
+        this[_autoClose] =
+            typeof opt.autoClose === 'boolean' ? opt.autoClose : true;
+        if (typeof this[_fd] === 'number') {
+            this[_read]();
+        }
+        else {
+            this[_open]();
+        }
+    }
+    get fd() {
+        return this[_fd];
+    }
+    get path() {
+        return this[_path];
+    }
+    //@ts-ignore
+    write() {
+        throw new TypeError('this is a readable stream');
+    }
+    //@ts-ignore
+    end() {
+        throw new TypeError('this is a readable stream');
+    }
+    [_open]() {
+        fs.open(this[_path], 'r', (er, fd) => this[_onopen](er, fd));
+    }
+    [_onopen](er, fd) {
+        if (er) {
+            this[_onerror](er);
+        }
+        else {
+            this[_fd] = fd;
+            this.emit('open', fd);
+            this[_read]();
+        }
+    }
+    [_makeBuf]() {
+        return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]));
+    }
+    [_read]() {
+        if (!this[_reading]) {
+            this[_reading] = true;
+            const buf = this[_makeBuf]();
+            /* c8 ignore start */
+            if (buf.length === 0) {
+                return process.nextTick(() => this[_onread](null, 0, buf));
+            }
+            /* c8 ignore stop */
+            fs.read(this[_fd], buf, 0, buf.length, null, (er, br, b) => this[_onread](er, br, b));
+        }
+    }
+    [_onread](er, br, buf) {
+        this[_reading] = false;
+        if (er) {
+            this[_onerror](er);
+        }
+        else if (this[_handleChunk](br, buf)) {
+            this[_read]();
+        }
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs.close(fd, er => er ? this.emit('error', er) : this.emit('close'));
+        }
+    }
+    [_onerror](er) {
+        this[_reading] = true;
+        this[_close]();
+        this.emit('error', er);
+    }
+    [_handleChunk](br, buf) {
+        let ret = false;
+        // no effect if infinite
+        this[_remain] -= br;
+        if (br > 0) {
+            ret = super.write(br < buf.length ? buf.subarray(0, br) : buf);
+        }
+        if (br === 0 || this[_remain] <= 0) {
+            ret = false;
+            this[_close]();
+            super.end();
+        }
+        return ret;
+    }
+    emit(ev, ...args) {
+        switch (ev) {
+            case 'prefinish':
+            case 'finish':
+                return false;
+            case 'drain':
+                if (typeof this[_fd] === 'number') {
+                    this[_read]();
+                }
+                return false;
+            case 'error':
+                if (this[_errored]) {
+                    return false;
+                }
+                this[_errored] = true;
+                return super.emit(ev, ...args);
+            default:
+                return super.emit(ev, ...args);
+        }
+    }
+}
+export class ReadStreamSync extends ReadStream {
+    [_open]() {
+        let threw = true;
+        try {
+            this[_onopen](null, fs.openSync(this[_path], 'r'));
+            threw = false;
+        }
+        finally {
+            if (threw) {
+                this[_close]();
+            }
+        }
+    }
+    [_read]() {
+        let threw = true;
+        try {
+            if (!this[_reading]) {
+                this[_reading] = true;
+                do {
+                    const buf = this[_makeBuf]();
+                    /* c8 ignore start */
+                    const br = buf.length === 0
+                        ? 0
+                        : fs.readSync(this[_fd], buf, 0, buf.length, null);
+                    /* c8 ignore stop */
+                    if (!this[_handleChunk](br, buf)) {
+                        break;
+                    }
+                } while (true);
+                this[_reading] = false;
+            }
+            threw = false;
+        }
+        finally {
+            if (threw) {
+                this[_close]();
+            }
+        }
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs.closeSync(fd);
+            this.emit('close');
+        }
+    }
+}
+export class WriteStream extends EE {
+    readable = false;
+    writable = true;
+    [_errored] = false;
+    [_writing] = false;
+    [_ended] = false;
+    [_queue] = [];
+    [_needDrain] = false;
+    [_path];
+    [_mode];
+    [_autoClose];
+    [_fd];
+    [_defaultFlag];
+    [_flags];
+    [_finished] = false;
+    [_pos];
+    constructor(path, opt) {
+        opt = opt || {};
+        super(opt);
+        this[_path] = path;
+        this[_fd] = typeof opt.fd === 'number' ? opt.fd : undefined;
+        this[_mode] = opt.mode === undefined ? 0o666 : opt.mode;
+        this[_pos] = typeof opt.start === 'number' ? opt.start : undefined;
+        this[_autoClose] =
+            typeof opt.autoClose === 'boolean' ? opt.autoClose : true;
+        // truncating makes no sense when writing into the middle
+        const defaultFlag = this[_pos] !== undefined ? 'r+' : 'w';
+        this[_defaultFlag] = opt.flags === undefined;
+        this[_flags] = opt.flags === undefined ? defaultFlag : opt.flags;
+        if (this[_fd] === undefined) {
+            this[_open]();
+        }
+    }
+    emit(ev, ...args) {
+        if (ev === 'error') {
+            if (this[_errored]) {
+                return false;
+            }
+            this[_errored] = true;
+        }
+        return super.emit(ev, ...args);
+    }
+    get fd() {
+        return this[_fd];
+    }
+    get path() {
+        return this[_path];
+    }
+    [_onerror](er) {
+        this[_close]();
+        this[_writing] = true;
+        this.emit('error', er);
+    }
+    [_open]() {
+        fs.open(this[_path], this[_flags], this[_mode], (er, fd) => this[_onopen](er, fd));
+    }
+    [_onopen](er, fd) {
+        if (this[_defaultFlag] &&
+            this[_flags] === 'r+' &&
+            er &&
+            er.code === 'ENOENT') {
+            this[_flags] = 'w';
+            this[_open]();
+        }
+        else if (er) {
+            this[_onerror](er);
+        }
+        else {
+            this[_fd] = fd;
+            this.emit('open', fd);
+            if (!this[_writing]) {
+                this[_flush]();
+            }
+        }
+    }
+    end(buf, enc) {
+        if (buf) {
+            //@ts-ignore
+            this.write(buf, enc);
+        }
+        this[_ended] = true;
+        // synthetic after-write logic, where drain/finish live
+        if (!this[_writing] &&
+            !this[_queue].length &&
+            typeof this[_fd] === 'number') {
+            this[_onwrite](null, 0);
+        }
+        return this;
+    }
+    write(buf, enc) {
+        if (typeof buf === 'string') {
+            buf = Buffer.from(buf, enc);
+        }
+        if (this[_ended]) {
+            this.emit('error', new Error('write() after end()'));
+            return false;
+        }
+        if (this[_fd] === undefined || this[_writing] || this[_queue].length) {
+            this[_queue].push(buf);
+            this[_needDrain] = true;
+            return false;
+        }
+        this[_writing] = true;
+        this[_write](buf);
+        return true;
+    }
+    [_write](buf) {
+        fs.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw));
+    }
+    [_onwrite](er, bw) {
+        if (er) {
+            this[_onerror](er);
+        }
+        else {
+            if (this[_pos] !== undefined && typeof bw === 'number') {
+                this[_pos] += bw;
+            }
+            if (this[_queue].length) {
+                this[_flush]();
+            }
+            else {
+                this[_writing] = false;
+                if (this[_ended] && !this[_finished]) {
+                    this[_finished] = true;
+                    this[_close]();
+                    this.emit('finish');
+                }
+                else if (this[_needDrain]) {
+                    this[_needDrain] = false;
+                    this.emit('drain');
+                }
+            }
+        }
+    }
+    [_flush]() {
+        if (this[_queue].length === 0) {
+            if (this[_ended]) {
+                this[_onwrite](null, 0);
+            }
+        }
+        else if (this[_queue].length === 1) {
+            this[_write](this[_queue].pop());
+        }
+        else {
+            const iovec = this[_queue];
+            this[_queue] = [];
+            writev(this[_fd], iovec, this[_pos], (er, bw) => this[_onwrite](er, bw));
+        }
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs.close(fd, er => er ? this.emit('error', er) : this.emit('close'));
+        }
+    }
+}
+export class WriteStreamSync extends WriteStream {
+    [_open]() {
+        let fd;
+        // only wrap in a try{} block if we know we'll retry, to avoid
+        // the rethrow obscuring the error's source frame in most cases.
+        if (this[_defaultFlag] && this[_flags] === 'r+') {
+            try {
+                fd = fs.openSync(this[_path], this[_flags], this[_mode]);
+            }
+            catch (er) {
+                if (er?.code === 'ENOENT') {
+                    this[_flags] = 'w';
+                    return this[_open]();
+                }
+                else {
+                    throw er;
+                }
+            }
+        }
+        else {
+            fd = fs.openSync(this[_path], this[_flags], this[_mode]);
+        }
+        this[_onopen](null, fd);
+    }
+    [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === 'number') {
+            const fd = this[_fd];
+            this[_fd] = undefined;
+            fs.closeSync(fd);
+            this.emit('close');
+        }
+    }
+    [_write](buf) {
+        // throw the original, but try to close if it fails
+        let threw = true;
+        try {
+            this[_onwrite](null, fs.writeSync(this[_fd], buf, 0, buf.length, this[_pos]));
+            threw = false;
+        }
+        finally {
+            if (threw) {
+                try {
+                    this[_close]();
+                }
+                catch {
+                    // ok error
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/esm/package.json b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/esm/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..916833506f3f5b4f805b8ff70692019bf0910884
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/dist/esm/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
diff --git a/node/node_modules/npm/node_modules/@isaacs/fs-minipass/package.json b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..21f281d630ab2e7d1f231cca2fe9e57a574ccf6e
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/fs-minipass/package.json
@@ -0,0 +1,72 @@
+{
+  "name": "@isaacs/fs-minipass",
+  "version": "4.0.1",
+  "main": "./dist/commonjs/index.js",
+  "scripts": {
+    "prepare": "tshy",
+    "pretest": "npm run prepare",
+    "test": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "format": "prettier --write . --loglevel warn",
+    "typedoc": "typedoc --tsconfig .tshy/esm.json ./src/*.ts"
+  },
+  "keywords": [],
+  "author": "Isaac Z. Schlueter",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/fs-minipass.git"
+  },
+  "description": "fs read and write streams based on minipass",
+  "dependencies": {
+    "minipass": "^7.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "mutate-fs": "^2.1.1",
+    "prettier": "^3.2.5",
+    "tap": "^18.7.1",
+    "tshy": "^1.12.0",
+    "typedoc": "^0.25.12"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "tshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "types": "./dist/commonjs/index.d.ts",
+  "type": "module",
+  "prettier": {
+    "semi": false,
+    "printWidth": 75,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/LICENSE b/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..235bdd54ec77f257af3e9f5bfece770fa2d6d6a8
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+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/node_modules/npm/node_modules/@isaacs/string-locale-compare/index.js b/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d44cf285c282b12c35baa6f79df73f342430d6d
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/index.js
@@ -0,0 +1,42 @@
+const hasIntl = typeof Intl === 'object' && !!Intl
+const Collator = hasIntl && Intl.Collator
+const cache = new Map()
+
+const collatorCompare = (locale, opts) => {
+  const collator = new Collator(locale, opts)
+  return (a, b) => collator.compare(a, b)
+}
+
+const localeCompare = (locale, opts) => (a, b) => a.localeCompare(b, locale, opts)
+
+const knownOptions = [
+  'sensitivity',
+  'numeric',
+  'ignorePunctuation',
+  'caseFirst',
+]
+
+const { hasOwnProperty } = Object.prototype
+
+module.exports = (locale, options = {}) => {
+  if (!locale || typeof locale !== 'string')
+    throw new TypeError('locale required')
+
+  const opts = knownOptions.reduce((opts, k) => {
+    if (hasOwnProperty.call(options, k)) {
+      opts[k] = options[k]
+    }
+    return opts
+  }, {})
+  const key = `${locale}\n${JSON.stringify(opts)}`
+
+  if (cache.has(key))
+    return cache.get(key)
+
+  const compare = hasIntl
+    ? collatorCompare(locale, opts)
+    : localeCompare(locale, opts)
+  cache.set(key, compare)
+
+  return compare
+}
diff --git a/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/package.json b/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..6cb43b092e29eb6e951da74eeafdeb9a010a76c8
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@isaacs/string-locale-compare/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@isaacs/string-locale-compare",
+  "version": "1.1.0",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "description": "Compare strings with Intl.Collator if available, falling back to String.localeCompare otherwise",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/isaacs/string-locale-compare"
+  },
+  "author": "Isaac Z. Schlueter <i@izs.me> (https://izs.me)",
+  "license": "ISC",
+  "scripts": {
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags"
+  },
+  "tap": {
+    "check-coverage": true
+  },
+  "devDependencies": {
+    "tap": "^15.0.9"
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/agent/lib/agents.js b/node/node_modules/npm/node_modules/@npmcli/agent/lib/agents.js
new file mode 100644
index 0000000000000000000000000000000000000000..a0e8b9f5b80de6e10bd852c306839176304b4aa4
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/agent/lib/agents.js
@@ -0,0 +1,206 @@
+'use strict'
+
+const net = require('net')
+const tls = require('tls')
+const { once } = require('events')
+const timers = require('timers/promises')
+const { normalizeOptions, cacheOptions } = require('./options')
+const { getProxy, getProxyAgent, proxyCache } = require('./proxy.js')
+const Errors = require('./errors.js')
+const { Agent: AgentBase } = require('agent-base')
+
+module.exports = class Agent extends AgentBase {
+  #options
+  #timeouts
+  #proxy
+  #noProxy
+  #ProxyAgent
+
+  constructor (options = {}) {
+    const { timeouts, proxy, noProxy, ...normalizedOptions } = normalizeOptions(options)
+
+    super(normalizedOptions)
+
+    this.#options = normalizedOptions
+    this.#timeouts = timeouts
+
+    if (proxy) {
+      this.#proxy = new URL(proxy)
+      this.#noProxy = noProxy
+      this.#ProxyAgent = getProxyAgent(proxy)
+    }
+  }
+
+  get proxy () {
+    return this.#proxy ? { url: this.#proxy } : {}
+  }
+
+  #getProxy (options) {
+    if (!this.#proxy) {
+      return
+    }
+
+    const proxy = getProxy(`${options.protocol}//${options.host}:${options.port}`, {
+      proxy: this.#proxy,
+      noProxy: this.#noProxy,
+    })
+
+    if (!proxy) {
+      return
+    }
+
+    const cacheKey = cacheOptions({
+      ...options,
+      ...this.#options,
+      timeouts: this.#timeouts,
+      proxy,
+    })
+
+    if (proxyCache.has(cacheKey)) {
+      return proxyCache.get(cacheKey)
+    }
+
+    let ProxyAgent = this.#ProxyAgent
+    if (Array.isArray(ProxyAgent)) {
+      ProxyAgent = this.isSecureEndpoint(options) ? ProxyAgent[1] : ProxyAgent[0]
+    }
+
+    const proxyAgent = new ProxyAgent(proxy, {
+      ...this.#options,
+      socketOptions: { family: this.#options.family },
+    })
+    proxyCache.set(cacheKey, proxyAgent)
+
+    return proxyAgent
+  }
+
+  // takes an array of promises and races them against the connection timeout
+  // which will throw the necessary error if it is hit. This will return the
+  // result of the promise race.
+  async #timeoutConnection ({ promises, options, timeout }, ac = new AbortController()) {
+    if (timeout) {
+      const connectionTimeout = timers.setTimeout(timeout, null, { signal: ac.signal })
+        .then(() => {
+          throw new Errors.ConnectionTimeoutError(`${options.host}:${options.port}`)
+        }).catch((err) => {
+          if (err.name === 'AbortError') {
+            return
+          }
+          throw err
+        })
+      promises.push(connectionTimeout)
+    }
+
+    let result
+    try {
+      result = await Promise.race(promises)
+      ac.abort()
+    } catch (err) {
+      ac.abort()
+      throw err
+    }
+    return result
+  }
+
+  async connect (request, options) {
+    // if the connection does not have its own lookup function
+    // set, then use the one from our options
+    options.lookup ??= this.#options.lookup
+
+    let socket
+    let timeout = this.#timeouts.connection
+    const isSecureEndpoint = this.isSecureEndpoint(options)
+
+    const proxy = this.#getProxy(options)
+    if (proxy) {
+      // some of the proxies will wait for the socket to fully connect before
+      // returning so we have to await this while also racing it against the
+      // connection timeout.
+      const start = Date.now()
+      socket = await this.#timeoutConnection({
+        options,
+        timeout,
+        promises: [proxy.connect(request, options)],
+      })
+      // see how much time proxy.connect took and subtract it from
+      // the timeout
+      if (timeout) {
+        timeout = timeout - (Date.now() - start)
+      }
+    } else {
+      socket = (isSecureEndpoint ? tls : net).connect(options)
+    }
+
+    socket.setKeepAlive(this.keepAlive, this.keepAliveMsecs)
+    socket.setNoDelay(this.keepAlive)
+
+    const abortController = new AbortController()
+    const { signal } = abortController
+
+    const connectPromise = socket[isSecureEndpoint ? 'secureConnecting' : 'connecting']
+      ? once(socket, isSecureEndpoint ? 'secureConnect' : 'connect', { signal })
+      : Promise.resolve()
+
+    await this.#timeoutConnection({
+      options,
+      timeout,
+      promises: [
+        connectPromise,
+        once(socket, 'error', { signal }).then((err) => {
+          throw err[0]
+        }),
+      ],
+    }, abortController)
+
+    if (this.#timeouts.idle) {
+      socket.setTimeout(this.#timeouts.idle, () => {
+        socket.destroy(new Errors.IdleTimeoutError(`${options.host}:${options.port}`))
+      })
+    }
+
+    return socket
+  }
+
+  addRequest (request, options) {
+    const proxy = this.#getProxy(options)
+    // it would be better to call proxy.addRequest here but this causes the
+    // http-proxy-agent to call its super.addRequest which causes the request
+    // to be added to the agent twice. since we only support 3 agents
+    // currently (see the required agents in proxy.js) we have manually
+    // checked that the only public methods we need to call are called in the
+    // next block. this could change in the future and presumably we would get
+    // failing tests until we have properly called the necessary methods on
+    // each of our proxy agents
+    if (proxy?.setRequestProps) {
+      proxy.setRequestProps(request, options)
+    }
+
+    request.setHeader('connection', this.keepAlive ? 'keep-alive' : 'close')
+
+    if (this.#timeouts.response) {
+      let responseTimeout
+      request.once('finish', () => {
+        setTimeout(() => {
+          request.destroy(new Errors.ResponseTimeoutError(request, this.#proxy))
+        }, this.#timeouts.response)
+      })
+      request.once('response', () => {
+        clearTimeout(responseTimeout)
+      })
+    }
+
+    if (this.#timeouts.transfer) {
+      let transferTimeout
+      request.once('response', (res) => {
+        setTimeout(() => {
+          res.destroy(new Errors.TransferTimeoutError(request, this.#proxy))
+        }, this.#timeouts.transfer)
+        res.once('close', () => {
+          clearTimeout(transferTimeout)
+        })
+      })
+    }
+
+    return super.addRequest(request, options)
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/agent/lib/dns.js b/node/node_modules/npm/node_modules/@npmcli/agent/lib/dns.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9ce25afd8125500815d954e2d14cb829d10452e
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/agent/lib/dns.js
@@ -0,0 +1,53 @@
+'use strict'
+
+const { LRUCache } = require('lru-cache')
+const dns = require('dns')
+
+// this is a factory so that each request can have its own opts (i.e. ttl)
+// while still sharing the cache across all requests
+const cache = new LRUCache({ max: 50 })
+
+const getOptions = ({
+  family = 0,
+  hints = dns.ADDRCONFIG,
+  all = false,
+  verbatim = undefined,
+  ttl = 5 * 60 * 1000,
+  lookup = dns.lookup,
+}) => ({
+  // hints and lookup are returned since both are top level properties to (net|tls).connect
+  hints,
+  lookup: (hostname, ...args) => {
+    const callback = args.pop() // callback is always last arg
+    const lookupOptions = args[0] ?? {}
+
+    const options = {
+      family,
+      hints,
+      all,
+      verbatim,
+      ...(typeof lookupOptions === 'number' ? { family: lookupOptions } : lookupOptions),
+    }
+
+    const key = JSON.stringify({ hostname, ...options })
+
+    if (cache.has(key)) {
+      const cached = cache.get(key)
+      return process.nextTick(callback, null, ...cached)
+    }
+
+    lookup(hostname, options, (err, ...result) => {
+      if (err) {
+        return callback(err)
+      }
+
+      cache.set(key, result, { ttl })
+      return callback(null, ...result)
+    })
+  },
+})
+
+module.exports = {
+  cache,
+  getOptions,
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/agent/lib/errors.js b/node/node_modules/npm/node_modules/@npmcli/agent/lib/errors.js
new file mode 100644
index 0000000000000000000000000000000000000000..060a20665aca72479e5b7bd80c35552787288020
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/agent/lib/errors.js
@@ -0,0 +1,61 @@
+'use strict'
+
+class InvalidProxyProtocolError extends Error {
+  constructor (url) {
+    super(`Invalid protocol \`${url.protocol}\` connecting to proxy \`${url.host}\``)
+    this.code = 'EINVALIDPROXY'
+    this.proxy = url
+  }
+}
+
+class ConnectionTimeoutError extends Error {
+  constructor (host) {
+    super(`Timeout connecting to host \`${host}\``)
+    this.code = 'ECONNECTIONTIMEOUT'
+    this.host = host
+  }
+}
+
+class IdleTimeoutError extends Error {
+  constructor (host) {
+    super(`Idle timeout reached for host \`${host}\``)
+    this.code = 'EIDLETIMEOUT'
+    this.host = host
+  }
+}
+
+class ResponseTimeoutError extends Error {
+  constructor (request, proxy) {
+    let msg = 'Response timeout '
+    if (proxy) {
+      msg += `from proxy \`${proxy.host}\` `
+    }
+    msg += `connecting to host \`${request.host}\``
+    super(msg)
+    this.code = 'ERESPONSETIMEOUT'
+    this.proxy = proxy
+    this.request = request
+  }
+}
+
+class TransferTimeoutError extends Error {
+  constructor (request, proxy) {
+    let msg = 'Transfer timeout '
+    if (proxy) {
+      msg += `from proxy \`${proxy.host}\` `
+    }
+    msg += `for \`${request.host}\``
+    super(msg)
+    this.code = 'ETRANSFERTIMEOUT'
+    this.proxy = proxy
+    this.request = request
+  }
+}
+
+module.exports = {
+  InvalidProxyProtocolError,
+  ConnectionTimeoutError,
+  IdleTimeoutError,
+  ResponseTimeoutError,
+  TransferTimeoutError,
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/agent/lib/index.js b/node/node_modules/npm/node_modules/@npmcli/agent/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..64cbbb1efbb5bac751ac8acca26897cea2844913
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/agent/lib/index.js
@@ -0,0 +1,56 @@
+'use strict'
+
+const { LRUCache } = require('lru-cache')
+const { normalizeOptions, cacheOptions } = require('./options')
+const { getProxy, proxyCache } = require('./proxy.js')
+const dns = require('./dns.js')
+const Agent = require('./agents.js')
+
+const agentCache = new LRUCache({ max: 20 })
+
+const getAgent = (url, { agent, proxy, noProxy, ...options } = {}) => {
+  // false has meaning so this can't be a simple truthiness check
+  if (agent != null) {
+    return agent
+  }
+
+  url = new URL(url)
+
+  const proxyForUrl = getProxy(url, { proxy, noProxy })
+  const normalizedOptions = {
+    ...normalizeOptions(options),
+    proxy: proxyForUrl,
+  }
+
+  const cacheKey = cacheOptions({
+    ...normalizedOptions,
+    secureEndpoint: url.protocol === 'https:',
+  })
+
+  if (agentCache.has(cacheKey)) {
+    return agentCache.get(cacheKey)
+  }
+
+  const newAgent = new Agent(normalizedOptions)
+  agentCache.set(cacheKey, newAgent)
+
+  return newAgent
+}
+
+module.exports = {
+  getAgent,
+  Agent,
+  // these are exported for backwards compatability
+  HttpAgent: Agent,
+  HttpsAgent: Agent,
+  cache: {
+    proxy: proxyCache,
+    agent: agentCache,
+    dns: dns.cache,
+    clear: () => {
+      proxyCache.clear()
+      agentCache.clear()
+      dns.cache.clear()
+    },
+  },
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/agent/lib/options.js b/node/node_modules/npm/node_modules/@npmcli/agent/lib/options.js
new file mode 100644
index 0000000000000000000000000000000000000000..a4f09638180883185d5ade990dca85600ff161b1
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/agent/lib/options.js
@@ -0,0 +1,86 @@
+'use strict'
+
+const dns = require('./dns')
+
+const normalizeOptions = (opts) => {
+  const family = parseInt(opts.family ?? '0', 10)
+  const keepAlive = opts.keepAlive ?? true
+
+  const normalized = {
+    // nodejs http agent options. these are all the defaults
+    // but kept here to increase the likelihood of cache hits
+    // https://nodejs.org/api/http.html#new-agentoptions
+    keepAliveMsecs: keepAlive ? 1000 : undefined,
+    maxSockets: opts.maxSockets ?? 15,
+    maxTotalSockets: Infinity,
+    maxFreeSockets: keepAlive ? 256 : undefined,
+    scheduling: 'fifo',
+    // then spread the rest of the options
+    ...opts,
+    // we already set these to their defaults that we want
+    family,
+    keepAlive,
+    // our custom timeout options
+    timeouts: {
+      // the standard timeout option is mapped to our idle timeout
+      // and then deleted below
+      idle: opts.timeout ?? 0,
+      connection: 0,
+      response: 0,
+      transfer: 0,
+      ...opts.timeouts,
+    },
+    // get the dns options that go at the top level of socket connection
+    ...dns.getOptions({ family, ...opts.dns }),
+  }
+
+  // remove timeout since we already used it to set our own idle timeout
+  delete normalized.timeout
+
+  return normalized
+}
+
+const createKey = (obj) => {
+  let key = ''
+  const sorted = Object.entries(obj).sort((a, b) => a[0] - b[0])
+  for (let [k, v] of sorted) {
+    if (v == null) {
+      v = 'null'
+    } else if (v instanceof URL) {
+      v = v.toString()
+    } else if (typeof v === 'object') {
+      v = createKey(v)
+    }
+    key += `${k}:${v}:`
+  }
+  return key
+}
+
+const cacheOptions = ({ secureEndpoint, ...options }) => createKey({
+  secureEndpoint: !!secureEndpoint,
+  // socket connect options
+  family: options.family,
+  hints: options.hints,
+  localAddress: options.localAddress,
+  // tls specific connect options
+  strictSsl: secureEndpoint ? !!options.rejectUnauthorized : false,
+  ca: secureEndpoint ? options.ca : null,
+  cert: secureEndpoint ? options.cert : null,
+  key: secureEndpoint ? options.key : null,
+  // http agent options
+  keepAlive: options.keepAlive,
+  keepAliveMsecs: options.keepAliveMsecs,
+  maxSockets: options.maxSockets,
+  maxTotalSockets: options.maxTotalSockets,
+  maxFreeSockets: options.maxFreeSockets,
+  scheduling: options.scheduling,
+  // timeout options
+  timeouts: options.timeouts,
+  // proxy
+  proxy: options.proxy,
+})
+
+module.exports = {
+  normalizeOptions,
+  cacheOptions,
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/agent/lib/proxy.js b/node/node_modules/npm/node_modules/@npmcli/agent/lib/proxy.js
new file mode 100644
index 0000000000000000000000000000000000000000..7505e6547a3e2e06a9a7f925bc4fceda932e3829
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/agent/lib/proxy.js
@@ -0,0 +1,88 @@
+'use strict'
+
+const { HttpProxyAgent } = require('http-proxy-agent')
+const { HttpsProxyAgent } = require('https-proxy-agent')
+const { SocksProxyAgent } = require('socks-proxy-agent')
+const { LRUCache } = require('lru-cache')
+const { InvalidProxyProtocolError } = require('./errors.js')
+
+const PROXY_CACHE = new LRUCache({ max: 20 })
+
+const SOCKS_PROTOCOLS = new Set(SocksProxyAgent.protocols)
+
+const PROXY_ENV_KEYS = new Set(['https_proxy', 'http_proxy', 'proxy', 'no_proxy'])
+
+const PROXY_ENV = Object.entries(process.env).reduce((acc, [key, value]) => {
+  key = key.toLowerCase()
+  if (PROXY_ENV_KEYS.has(key)) {
+    acc[key] = value
+  }
+  return acc
+}, {})
+
+const getProxyAgent = (url) => {
+  url = new URL(url)
+
+  const protocol = url.protocol.slice(0, -1)
+  if (SOCKS_PROTOCOLS.has(protocol)) {
+    return SocksProxyAgent
+  }
+  if (protocol === 'https' || protocol === 'http') {
+    return [HttpProxyAgent, HttpsProxyAgent]
+  }
+
+  throw new InvalidProxyProtocolError(url)
+}
+
+const isNoProxy = (url, noProxy) => {
+  if (typeof noProxy === 'string') {
+    noProxy = noProxy.split(',').map((p) => p.trim()).filter(Boolean)
+  }
+
+  if (!noProxy || !noProxy.length) {
+    return false
+  }
+
+  const hostSegments = url.hostname.split('.').reverse()
+
+  return noProxy.some((no) => {
+    const noSegments = no.split('.').filter(Boolean).reverse()
+    if (!noSegments.length) {
+      return false
+    }
+
+    for (let i = 0; i < noSegments.length; i++) {
+      if (hostSegments[i] !== noSegments[i]) {
+        return false
+      }
+    }
+
+    return true
+  })
+}
+
+const getProxy = (url, { proxy, noProxy }) => {
+  url = new URL(url)
+
+  if (!proxy) {
+    proxy = url.protocol === 'https:'
+      ? PROXY_ENV.https_proxy
+      : PROXY_ENV.https_proxy || PROXY_ENV.http_proxy || PROXY_ENV.proxy
+  }
+
+  if (!noProxy) {
+    noProxy = PROXY_ENV.no_proxy
+  }
+
+  if (!proxy || isNoProxy(url, noProxy)) {
+    return null
+  }
+
+  return new URL(proxy)
+}
+
+module.exports = {
+  getProxyAgent,
+  getProxy,
+  proxyCache: PROXY_CACHE,
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/actual.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/actual.js
new file mode 100644
index 0000000000000000000000000000000000000000..56b70f1117d7fcec64995ade12188a75e0d0fc78
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/actual.js
@@ -0,0 +1,19 @@
+const Arborist = require('../')
+
+const printTree = require('./lib/print-tree.js')
+
+module.exports = (options, time) => new Arborist(options)
+  .loadActual(options)
+  .then(time)
+  .then(async ({ timing, result: tree }) => {
+    printTree(tree)
+    if (options.save) {
+      await tree.meta.save()
+    }
+    if (options.saveHidden) {
+      tree.meta.hiddenLockfile = true
+      tree.meta.filename = options.path + '/node_modules/.package-lock.json'
+      await tree.meta.save()
+    }
+    return `read ${tree.inventory.size} deps in ${timing.ms}`
+  })
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/audit.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/audit.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a039ce6fd0044f9205043026861123f60995200
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/audit.js
@@ -0,0 +1,51 @@
+const Arborist = require('../')
+
+const printTree = require('./lib/print-tree.js')
+const log = require('./lib/logging.js')
+
+const Vuln = require('../lib/vuln.js')
+const printReport = report => {
+  for (const vuln of report.values()) {
+    log.info(printVuln(vuln))
+  }
+  if (report.topVulns.size) {
+    log.info('\n# top-level vulnerabilities')
+    for (const vuln of report.topVulns.values()) {
+      log.info(printVuln(vuln))
+    }
+  }
+}
+
+const printVuln = vuln => {
+  return {
+    __proto__: { constructor: Vuln },
+    name: vuln.name,
+    issues: [...vuln.advisories].map(a => printAdvisory(a)),
+    range: vuln.simpleRange,
+    nodes: [...vuln.nodes].map(node => `${node.name} ${node.location || '#ROOT'}`),
+    ...(vuln.topNodes.size === 0 ? {} : {
+      topNodes: [...vuln.topNodes].map(node => `${node.location || '#ROOT'}`),
+    }),
+  }
+}
+
+const printAdvisory = a => `${a.title}${a.url ? ' ' + a.url : ''}`
+
+module.exports = (options, time) => {
+  const arb = new Arborist(options)
+  return arb
+    .audit(options)
+    .then(time)
+    .then(async ({ timing, result: tree }) => {
+      if (options.fix) {
+        printTree(tree)
+      }
+      printReport(arb.auditReport)
+      if (tree.meta && options.save) {
+        await tree.meta.save()
+      }
+      return options.fix
+        ? `resolved ${tree.inventory.size} deps in ${timing.seconds}`
+        : `done in ${timing.seconds}`
+    })
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/funding.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/funding.js
new file mode 100644
index 0000000000000000000000000000000000000000..0a7b4ac06ace953734b53d55bfb9fa57f86a698b
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/funding.js
@@ -0,0 +1,38 @@
+const Arborist = require('../')
+
+const log = require('./lib/logging.js')
+
+module.exports = (options, time) => {
+  const query = options._.shift()
+  const a = new Arborist(options)
+  return a
+    .loadVirtual()
+    .then(tree => {
+      // only load the actual tree if the virtual one doesn't have modern metadata
+      if (!tree.meta || !(tree.meta.originalLockfileVersion >= 2)) {
+        log.error('old metadata, load actual')
+        throw 'load actual'
+      } else {
+        log.error('meta ok, return virtual tree')
+        return tree
+      }
+    })
+    .catch(() => a.loadActual())
+    .then(time)
+    .then(({ timing, result: tree }) => {
+      if (!query) {
+        for (const node of tree.inventory.values()) {
+          if (node.package.funding) {
+            log.info(node.name, node.location, node.package.funding)
+          }
+        }
+      } else {
+        for (const node of tree.inventory.query('name', query)) {
+          if (node.package.funding) {
+            log.info(node.name, node.location, node.package.funding)
+          }
+        }
+      }
+      return `read ${tree.inventory.size} deps in ${timing.ms}`
+    })
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/ideal.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/ideal.js
new file mode 100644
index 0000000000000000000000000000000000000000..011327c8272a26796318523b9bd0da1cbaf7e43a
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/ideal.js
@@ -0,0 +1,14 @@
+const Arborist = require('../')
+
+const printTree = require('./lib/print-tree.js')
+
+module.exports = (options, time) => new Arborist(options)
+  .buildIdealTree(options)
+  .then(time)
+  .then(async ({ timing, result: tree }) => {
+    printTree(tree)
+    if (tree.meta && options.save) {
+      await tree.meta.save()
+    }
+    return `resolved ${tree.inventory.size} deps in ${timing.seconds}`
+  })
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/index.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..0854996f9863b9d5f7b48e15e9ddc82286b7a3c0
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/index.js
@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { time } = require('proc-log')
+
+const { bin, arb: options } = require('./lib/options')
+const version = require('../package.json').version
+
+const usage = (message = '') => `Arborist - the npm tree doctor
+
+Version: ${version}
+${message && '\n' + message + '\n'}
+# USAGE
+  arborist <cmd> [path] [options...]
+
+# COMMANDS
+
+  * reify: reify ideal tree to node_modules (install, update, rm, ...)
+  * prune: prune the ideal tree and reify (like npm prune)
+  * ideal: generate and print the ideal tree
+  * actual: read and print the actual tree in node_modules
+  * virtual: read and print the virtual tree in the local shrinkwrap file
+  * shrinkwrap: load a local shrinkwrap and print its data
+  * audit: perform a security audit on project dependencies
+  * funding: query funding information in the local package tree.  A second
+    positional argument after the path name can limit to a package name.
+  * license: query license information in the local package tree.  A second
+    positional argument after the path name can limit to a license type.
+  * help: print this text
+  * version: print the version
+
+# OPTIONS
+
+  Most npm options are supported, but in camelCase rather than css-case.  For
+  example, instead of '--dry-run', use '--dryRun'.
+
+  Additionally:
+
+  * --loglevel=warn|--quiet will suppress the printing of package trees
+  * --logfile <file|bool> will output logs to a file
+  * --timing will show timing information
+  * Instead of 'npm install <pkg>', use 'arborist reify --add=<pkg>'.
+    The '--add=<pkg>' option can be specified multiple times.
+  * Instead of 'npm rm <pkg>', use 'arborist reify --rm=<pkg>'.
+    The '--rm=<pkg>' option can be specified multiple times.
+  * Instead of 'npm update', use 'arborist reify --update-all'.
+  * 'npm audit fix' is 'arborist audit --fix'
+`
+
+const commands = {
+  version: () => console.log(version),
+  help: () => console.log(usage()),
+  exit: () => {
+    process.exitCode = 1
+    console.error(
+      usage(`Error: command '${bin.command}' does not exist.`)
+    )
+  },
+}
+
+const commandFiles = fs.readdirSync(__dirname).filter((f) => path.extname(f) === '.js' && f !== __filename)
+
+for (const file of commandFiles) {
+  const command = require(`./${file}`)
+  const name = path.basename(file, '.js')
+  const totalTime = `bin:${name}:init`
+  const scriptTime = `bin:${name}:script`
+
+  commands[name] = () => {
+    const timers = require('./lib/timers')
+    const log = require('./lib/logging')
+
+    log.info(name, options)
+
+    const timeEnd = time.start(totalTime)
+    const scriptEnd = time.start(scriptTime)
+
+    return command(options, (result) => {
+      scriptEnd()
+      return {
+        result,
+        timing: {
+          seconds: `${timers.get(scriptTime) / 1e9}s`,
+          ms: `${timers.get(scriptTime) / 1e6}ms`,
+        },
+      }
+    })
+      .then((result) => {
+        log.info(result)
+        return result
+      })
+      .catch((err) => {
+        process.exitCode = 1
+        log.error(err)
+        return err
+      })
+      .then((r) => {
+        timeEnd()
+        if (bin.loglevel !== 'silent') {
+          console[process.exitCode ? 'error' : 'log'](r)
+        }
+        return r
+      })
+  }
+}
+
+if (commands[bin.command]) {
+  commands[bin.command]()
+} else {
+  commands.exit()
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/logging.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/logging.js
new file mode 100644
index 0000000000000000000000000000000000000000..e437f29425789a68151afa8ddb7ec8b8b646d659
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/logging.js
@@ -0,0 +1,77 @@
+const { log } = require('proc-log')
+const fs = require('node:fs')
+const { dirname } = require('node:path')
+const os = require('node:os')
+const { inspect, format } = require('node:util')
+
+const { bin: options } = require('./options.js')
+
+// add a meta method to proc-log for passing optional
+// metadata through to log handlers
+const META = Symbol('meta')
+const parseArgs = (...args) => {
+  const { [META]: isMeta } = args[args.length - 1] || {}
+  return isMeta
+    ? [args[args.length - 1], ...args.slice(0, args.length - 1)]
+    : [{}, ...args]
+}
+log.meta = (meta = {}) => ({ [META]: true, ...meta })
+
+const levels = new Map([
+  'silly',
+  'verbose',
+  'info',
+  'http',
+  'notice',
+  'warn',
+  'error',
+  'silent',
+].map((level, index) => [level, index]))
+
+const addLogListener = (write, { eol = os.EOL, loglevel = 'silly', colors = false } = {}) => {
+  const levelIndex = levels.get(loglevel)
+
+  const magenta = m => colors ? `\x1B[35m${m}\x1B[39m` : m
+  const dim = m => colors ? `\x1B[2m${m}\x1B[22m` : m
+  const red = m => colors ? `\x1B[31m${m}\x1B[39m` : m
+
+  const formatter = (level, ...args) => {
+    const depth = level === 'error' && args[0] && args[0].code === 'ERESOLVE' ? Infinity : 10
+
+    if (level === 'info' && args[0] === 'timeEnd') {
+      args[1] = dim(args[1])
+    } else if (level === 'error' && args[0] === 'timeError') {
+      args[1] = red(args[1])
+    }
+
+    const messages = args.map(a => typeof a === 'string' ? a : inspect(a, { depth, colors }))
+    const pref = `${process.pid} ${magenta(level)} `
+
+    return pref + format(...messages).trim().split('\n').join(`${eol}${pref}`) + eol
+  }
+
+  process.on('log', (...args) => {
+    const [meta, level, ...logArgs] = parseArgs(...args)
+
+    if (levelIndex <= levels.get(level) || meta.force) {
+      write(formatter(level, ...logArgs))
+    }
+  })
+}
+
+if (options.loglevel !== 'silent') {
+  addLogListener((v) => process.stderr.write(v), {
+    eol: '\n',
+    colors: options.colors,
+    loglevel: options.loglevel,
+  })
+}
+
+if (options.logfile) {
+  log.silly('logfile', options.logfile)
+  fs.mkdirSync(dirname(options.logfile), { recursive: true })
+  const fd = fs.openSync(options.logfile, 'a')
+  addLogListener((str) => fs.writeSync(fd, str))
+}
+
+module.exports = log
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/options.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/options.js
new file mode 100644
index 0000000000000000000000000000000000000000..23ce7fd3c54c4779e848c1a7cfcb759ea54a65be
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/options.js
@@ -0,0 +1,123 @@
+const nopt = require('nopt')
+const path = require('node:path')
+
+const has = (o, k) => Object.prototype.hasOwnProperty.call(o, k)
+
+const cleanPath = (val) => {
+  const k = Symbol('key')
+  const data = {}
+  nopt.typeDefs.path.validate(data, k, val)
+  return data[k]
+}
+
+const parse = (...noptArgs) => {
+  const binOnlyOpts = {
+    command: String,
+    loglevel: String,
+    colors: Boolean,
+    timing: ['always', Boolean],
+    logfile: String,
+  }
+
+  const arbOpts = {
+    add: Array,
+    rm: Array,
+    omit: Array,
+    update: Array,
+    workspaces: Array,
+    global: Boolean,
+    force: Boolean,
+    'global-style': Boolean,
+    'prefer-dedupe': Boolean,
+    'legacy-peer-deps': Boolean,
+    'update-all': Boolean,
+    before: Date,
+    path: path,
+    cache: path,
+    ...binOnlyOpts,
+  }
+
+  const short = {
+    quiet: ['--loglevel', 'warn'],
+    logs: ['--logfile', 'true'],
+    w: '--workspaces',
+    g: '--global',
+    f: '--force',
+  }
+
+  const defaults = {
+    // key order is important for command and path
+    // since they shift positional args
+    // command is 1st, path is 2nd
+    command: (o) => o.argv.remain.shift(),
+    path: (o) => cleanPath(o.argv.remain.shift() || '.'),
+    colors: has(process.env, 'NO_COLOR') ? false : !!process.stderr.isTTY,
+    loglevel: 'silly',
+    timing: (o) => o.loglevel === 'silly',
+    cache: `${process.env.HOME}/.npm/_cacache`,
+  }
+
+  const derived = [
+    // making update either `all` or an array of names but not both
+    ({ updateAll: all, update: names, ...o }) => {
+      if (all || names) {
+        o.update = all != null ? { all } : { names }
+      }
+      return o
+    },
+    ({ logfile, ...o }) => {
+      // logfile is parsed as a string so if its true or set but empty
+      // then set the default logfile
+      if (logfile === 'true' || logfile === '') {
+        logfile = `arb-log-${new Date().toISOString().replace(/[.:]/g, '_')}.log`
+      }
+      // then parse it the same as nopt parses other paths
+      if (logfile) {
+        o.logfile = cleanPath(logfile)
+      }
+      return o
+    },
+  ]
+
+  const transforms = [
+    // Camelcase all top level keys
+    (o) => {
+      const entries = Object.entries(o).map(([k, v]) => [
+        k.replace(/-./g, s => s[1].toUpperCase()),
+        v,
+      ])
+      return Object.fromEntries(entries)
+    },
+    // Set defaults on unset keys
+    (o) => {
+      for (const [k, v] of Object.entries(defaults)) {
+        if (!has(o, k)) {
+          o[k] = typeof v === 'function' ? v(o) : v
+        }
+      }
+      return o
+    },
+    // Set/unset derived values
+    ...derived.map((derive) => (o) => derive(o) || o),
+    // Separate bin and arborist options
+    ({ argv: { remain: _ }, ...o }) => {
+      const bin = { _ }
+      for (const k of Object.keys(binOnlyOpts)) {
+        if (has(o, k)) {
+          bin[k] = o[k]
+          delete o[k]
+        }
+      }
+      return { bin, arb: o }
+    },
+  ]
+
+  let options = nopt(arbOpts, short, ...noptArgs)
+  for (const t of transforms) {
+    options = t(options)
+  }
+
+  return options
+}
+
+module.exports = parse()
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/print-tree.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/print-tree.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc2e66f36d053a9e49fa0befa3ba538fe79b075c
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/print-tree.js
@@ -0,0 +1,4 @@
+const { inspect } = require('node:util')
+const log = require('./logging.js')
+
+module.exports = tree => log.info(inspect(tree.toJSON(), { depth: Infinity }))
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/timers.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/timers.js
new file mode 100644
index 0000000000000000000000000000000000000000..39838e235950bb06fc03741014909cf3639ede1f
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/lib/timers.js
@@ -0,0 +1,33 @@
+const { bin: options } = require('./options.js')
+const log = require('./logging.js')
+
+const timers = new Map()
+const finished = new Map()
+
+process.on('time', (level, name) => {
+  if (level === 'start') {
+    if (timers.has(name)) {
+      throw new Error('conflicting timer! ' + name)
+    }
+    timers.set(name, process.hrtime.bigint())
+  } else if (level === 'end') {
+    if (!timers.has(name)) {
+      throw new Error('timer not started! ' + name)
+    }
+    const elapsed = Number(process.hrtime.bigint() - timers.get(name))
+    timers.delete(name)
+    finished.set(name, elapsed)
+    if (options.timing) {
+      log.info('timeEnd', `${name} ${elapsed / 1e9}s`, log.meta({ force: options.timing === 'always' }))
+    }
+  }
+})
+
+process.on('exit', () => {
+  for (const name of timers.keys()) {
+    log.error('timeError', 'Dangling timer:', name)
+    process.exitCode = 1
+  }
+})
+
+module.exports = finished
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/license.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/license.js
new file mode 100644
index 0000000000000000000000000000000000000000..e03ffc8398db63dd3ee80f64e4471d60f24b6097
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/license.js
@@ -0,0 +1,48 @@
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const Arborist = require('../')
+const log = require('./lib/logging.js')
+
+module.exports = (options, time) => {
+  const query = options._.shift()
+  const a = new Arborist(options)
+  return a
+    .loadVirtual()
+    .then(tree => {
+      // only load the actual tree if the virtual one doesn't have modern metadata
+      if (!tree.meta || !(tree.meta.originalLockfileVersion >= 2)) {
+        throw 'load actual'
+      } else {
+        return tree
+      }
+    }).catch((er) => {
+      log.error('loading actual tree', er)
+      return a.loadActual()
+    })
+    .then(time)
+    .then(({ result: tree }) => {
+      const output = []
+      if (!query) {
+        const set = []
+        for (const license of tree.inventory.query('license')) {
+          set.push([tree.inventory.query('license', license).size, license])
+        }
+
+        for (const [count, license] of set.sort((a, b) =>
+          a[1] && b[1] ? b[0] - a[0] || localeCompare(a[1], b[1])
+          : a[1] ? -1
+          : b[1] ? 1
+          : 0)) {
+          output.push(`${count} ${license}`)
+          log.info(count, license)
+        }
+      } else {
+        for (const node of tree.inventory.query('license', query === 'undefined' ? undefined : query)) {
+          const msg = `${node.name} ${node.location} ${node.package.description || ''}`
+          output.push(msg)
+          log.info(msg)
+        }
+      }
+
+      return output.join('\n')
+    })
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/prune.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/prune.js
new file mode 100644
index 0000000000000000000000000000000000000000..2bc007c29c600d47b1a8697751d720e6ef57a17f
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/prune.js
@@ -0,0 +1,48 @@
+const Arborist = require('../')
+
+const printTree = require('./lib/print-tree.js')
+const log = require('./lib/logging.js')
+
+const printDiff = diff => {
+  const { depth } = require('treeverse')
+  depth({
+    tree: diff,
+    visit: d => {
+      if (d.location === '') {
+        return
+      }
+      switch (d.action) {
+        case 'REMOVE':
+          log.info('REMOVE', d.actual.location)
+          break
+        case 'ADD':
+          log.info('ADD', d.ideal.location, d.ideal.resolved)
+          break
+        case 'CHANGE':
+          log.info('CHANGE', d.actual.location, {
+            from: d.actual.resolved,
+            to: d.ideal.resolved,
+          })
+          break
+      }
+    },
+    getChildren: d => d.children,
+  })
+}
+
+module.exports = (options, time) => {
+  const arb = new Arborist(options)
+  return arb
+    .prune(options)
+    .then(time)
+    .then(async ({ timing, result: tree }) => {
+      printTree(tree)
+      if (options.dryRun) {
+        printDiff(arb.diff)
+      }
+      if (tree.meta && options.save) {
+        await tree.meta.save()
+      }
+      return `resolved ${tree.inventory.size} deps in ${timing.seconds}`
+    })
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/reify.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/reify.js
new file mode 100644
index 0000000000000000000000000000000000000000..eac986d06885e95b67aa4394e526b1522679e6dc
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/reify.js
@@ -0,0 +1,48 @@
+const Arborist = require('../')
+
+const printTree = require('./lib/print-tree.js')
+const log = require('./lib/logging.js')
+
+const printDiff = diff => {
+  const { depth } = require('treeverse')
+  depth({
+    tree: diff,
+    visit: d => {
+      if (d.location === '') {
+        return
+      }
+      switch (d.action) {
+        case 'REMOVE':
+          log.info('REMOVE', d.actual.location)
+          break
+        case 'ADD':
+          log.info('ADD', d.ideal.location, d.ideal.resolved)
+          break
+        case 'CHANGE':
+          log.info('CHANGE', d.actual.location, {
+            from: d.actual.resolved,
+            to: d.ideal.resolved,
+          })
+          break
+      }
+    },
+    getChildren: d => d.children,
+  })
+}
+
+module.exports = (options, time) => {
+  const arb = new Arborist(options)
+  return arb
+    .reify(options)
+    .then(time)
+    .then(async ({ timing, result: tree }) => {
+      printTree(tree)
+      if (options.dryRun) {
+        printDiff(arb.diff)
+      }
+      if (tree.meta && options.save) {
+        await tree.meta.save()
+      }
+      return `resolved ${tree.inventory.size} deps in ${timing.seconds}`
+    })
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/shrinkwrap.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/shrinkwrap.js
new file mode 100644
index 0000000000000000000000000000000000000000..023fca47a3c89136ef403ecaa312405b8ebfa918
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/shrinkwrap.js
@@ -0,0 +1,7 @@
+const Shrinkwrap = require('../lib/shrinkwrap.js')
+
+module.exports = (options, time) => Shrinkwrap
+  .load(options)
+  .then((s) => s.commit())
+  .then(time)
+  .then(({ result: s }) => JSON.stringify(s, 0, 2))
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/bin/virtual.js b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/virtual.js
new file mode 100644
index 0000000000000000000000000000000000000000..72116960c717fd936681ff1e19426be1de84cb24
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/bin/virtual.js
@@ -0,0 +1,14 @@
+const Arborist = require('../')
+
+const printTree = require('./lib/print-tree.js')
+
+module.exports = (options, time) => new Arborist(options)
+  .loadVirtual()
+  .then(time)
+  .then(async ({ timing, result: tree }) => {
+    printTree(tree)
+    if (options.save) {
+      await tree.meta.save()
+    }
+    return `read ${tree.inventory.size} deps in ${timing.ms}`
+  })
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/add-rm-pkg-deps.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/add-rm-pkg-deps.js
new file mode 100644
index 0000000000000000000000000000000000000000..58094d3285dcfe77958e3220af2fe4a64e89aa2e
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/add-rm-pkg-deps.js
@@ -0,0 +1,143 @@
+// add and remove dependency specs to/from pkg manifest
+
+const { log } = require('proc-log')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+
+const add = ({ pkg, add, saveBundle, saveType }) => {
+  for (const { name, rawSpec } of add) {
+    let addSaveType = saveType
+    // if the user does not give us a type, we infer which type(s)
+    // to keep based on the same order of priority we do when
+    // building the tree as defined in the _loadDeps method of
+    // the node class.
+    if (!addSaveType) {
+      addSaveType = inferSaveType(pkg, name)
+    }
+
+    if (addSaveType === 'prod') {
+      // a production dependency can only exist as production (rpj ensures it
+      // doesn't coexist w/ optional)
+      deleteSubKey(pkg, 'devDependencies', name, 'dependencies')
+      deleteSubKey(pkg, 'peerDependencies', name, 'dependencies')
+    } else if (addSaveType === 'dev') {
+      // a dev dependency may co-exist as peer, or optional, but not production
+      deleteSubKey(pkg, 'dependencies', name, 'devDependencies')
+    } else if (addSaveType === 'optional') {
+      // an optional dependency may co-exist as dev (rpj ensures it doesn't
+      // coexist w/ prod)
+      deleteSubKey(pkg, 'peerDependencies', name, 'optionalDependencies')
+    } else { // peer or peerOptional is all that's left
+      // a peer dependency may coexist as dev
+      deleteSubKey(pkg, 'dependencies', name, 'peerDependencies')
+      deleteSubKey(pkg, 'optionalDependencies', name, 'peerDependencies')
+    }
+
+    const depType = saveTypeMap.get(addSaveType)
+
+    pkg[depType] = pkg[depType] || {}
+    if (rawSpec !== '*' || pkg[depType][name] === undefined) {
+      pkg[depType][name] = rawSpec
+    }
+    if (addSaveType === 'optional') {
+      // Affordance for previous npm versions that require this behaviour
+      pkg.dependencies = pkg.dependencies || {}
+      pkg.dependencies[name] = pkg.optionalDependencies[name]
+    }
+
+    if (addSaveType === 'peer' || addSaveType === 'peerOptional') {
+      const pdm = pkg.peerDependenciesMeta || {}
+      if (addSaveType === 'peer' && pdm[name] && pdm[name].optional) {
+        pdm[name].optional = false
+      } else if (addSaveType === 'peerOptional') {
+        pdm[name] = pdm[name] || {}
+        pdm[name].optional = true
+        pkg.peerDependenciesMeta = pdm
+      }
+      // peerDeps are often also a devDep, so that they can be tested when
+      // using package managers that don't auto-install peer deps
+      if (pkg.devDependencies && pkg.devDependencies[name] !== undefined) {
+        pkg.devDependencies[name] = pkg.peerDependencies[name]
+      }
+    }
+
+    if (saveBundle && addSaveType !== 'peer' && addSaveType !== 'peerOptional') {
+      // keep it sorted, keep it unique
+      const bd = new Set(pkg.bundleDependencies || [])
+      bd.add(name)
+      pkg.bundleDependencies = [...bd].sort(localeCompare)
+    }
+  }
+
+  return pkg
+}
+
+// Canonical source of both the map between saveType and where it correlates to
+// in the package, and the names of all our dependencies attributes
+const saveTypeMap = new Map([
+  ['dev', 'devDependencies'],
+  ['optional', 'optionalDependencies'],
+  ['prod', 'dependencies'],
+  ['peerOptional', 'peerDependencies'],
+  ['peer', 'peerDependencies'],
+])
+
+// Finds where the package is already in the spec and infers saveType from that
+const inferSaveType = (pkg, name) => {
+  for (const saveType of saveTypeMap.keys()) {
+    if (hasSubKey(pkg, saveTypeMap.get(saveType), name)) {
+      if (
+        saveType === 'peerOptional' &&
+        (!hasSubKey(pkg, 'peerDependenciesMeta', name) ||
+        !pkg.peerDependenciesMeta[name].optional)
+      ) {
+        return 'peer'
+      }
+      return saveType
+    }
+  }
+  return 'prod'
+}
+
+const hasSubKey = (pkg, depType, name) => {
+  return pkg[depType] && Object.prototype.hasOwnProperty.call(pkg[depType], name)
+}
+
+// Removes a subkey and warns about it if it's being replaced
+const deleteSubKey = (pkg, depType, name, replacedBy) => {
+  if (hasSubKey(pkg, depType, name)) {
+    if (replacedBy) {
+      log.warn('idealTree', `Removing ${depType}.${name} in favor of ${replacedBy}.${name}`)
+    }
+    delete pkg[depType][name]
+
+    // clean up peerDepsMeta if we are removing something from peerDependencies
+    if (depType === 'peerDependencies' && pkg.peerDependenciesMeta) {
+      delete pkg.peerDependenciesMeta[name]
+      if (!Object.keys(pkg.peerDependenciesMeta).length) {
+        delete pkg.peerDependenciesMeta
+      }
+    }
+
+    if (!Object.keys(pkg[depType]).length) {
+      delete pkg[depType]
+    }
+  }
+}
+
+const rm = (pkg, rm) => {
+  for (const depType of new Set(saveTypeMap.values())) {
+    for (const name of rm) {
+      deleteSubKey(pkg, depType, name)
+    }
+  }
+  if (pkg.bundleDependencies) {
+    pkg.bundleDependencies = pkg.bundleDependencies
+      .filter(name => !rm.includes(name))
+    if (!pkg.bundleDependencies.length) {
+      delete pkg.bundleDependencies
+    }
+  }
+  return pkg
+}
+
+module.exports = { add, rm, saveTypeMap, hasSubKey }
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d28da5388134dad936096a0ab7bb789f8c01647
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js
@@ -0,0 +1,1582 @@
+// mixin implementing the buildIdealTree method
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const PackageJson = require('@npmcli/package-json')
+const npa = require('npm-package-arg')
+const pacote = require('pacote')
+const cacache = require('cacache')
+const { callLimit: promiseCallLimit } = require('promise-call-limit')
+const realpath = require('../../lib/realpath.js')
+const { resolve, dirname, sep } = require('node:path')
+const treeCheck = require('../tree-check.js')
+const { readdirScoped } = require('@npmcli/fs')
+const { lstat, readlink } = require('node:fs/promises')
+const { depth } = require('treeverse')
+const { log, time } = require('proc-log')
+const { redact } = require('@npmcli/redact')
+const semver = require('semver')
+
+const {
+  OK,
+  REPLACE,
+  CONFLICT,
+} = require('../can-place-dep.js')
+const PlaceDep = require('../place-dep.js')
+
+const debug = require('../debug.js')
+const fromPath = require('../from-path.js')
+const calcDepFlags = require('../calc-dep-flags.js')
+const Shrinkwrap = require('../shrinkwrap.js')
+const { defaultLockfileVersion } = Shrinkwrap
+const Node = require('../node.js')
+const Link = require('../link.js')
+const addRmPkgDeps = require('../add-rm-pkg-deps.js')
+const optionalSet = require('../optional-set.js')
+const { checkEngine, checkPlatform } = require('npm-install-checks')
+const relpath = require('../relpath.js')
+const resetDepFlags = require('../reset-dep-flags.js')
+
+// note: some of these symbols are shared so we can hit
+// them with unit tests and reuse them across mixins
+const _updateAll = Symbol.for('updateAll')
+const _flagsSuspect = Symbol.for('flagsSuspect')
+const _setWorkspaces = Symbol.for('setWorkspaces')
+const _updateNames = Symbol.for('updateNames')
+const _resolvedAdd = Symbol.for('resolvedAdd')
+const _rpcache = Symbol.for('realpathCache')
+const _stcache = Symbol.for('statCache')
+
+// used by Reify mixin
+const _addNodeToTrashList = Symbol.for('addNodeToTrashList')
+
+// Push items in, pop them sorted by depth and then path
+// Sorts physically shallower deps up to the front of the queue, because
+// they'll affect things deeper in, then alphabetical for consistency between
+// installs
+class DepsQueue {
+  #deps = []
+  #sorted = true
+
+  get length () {
+    return this.#deps.length
+  }
+
+  push (item) {
+    if (!this.#deps.includes(item)) {
+      this.#sorted = false
+      this.#deps.push(item)
+    }
+  }
+
+  pop () {
+    if (!this.#sorted) {
+      this.#deps.sort((a, b) => (a.depth - b.depth) || localeCompare(a.path, b.path))
+      this.#sorted = true
+    }
+    return this.#deps.shift()
+  }
+}
+
+module.exports = cls => class IdealTreeBuilder extends cls {
+  #complete
+  #currentDep = null
+  #depsQueue = new DepsQueue()
+  #depsSeen = new Set()
+  #explicitRequests = new Set()
+  #follow
+  #installStrategy
+  #linkNodes = new Set()
+  #loadFailures = new Set()
+  #manifests = new Map()
+  #mutateTree = false
+  // a map of each module in a peer set to the thing that depended on
+  // that set of peers in the first place.  Use a WeakMap so that we
+  // don't hold onto references for nodes that are garbage collected.
+  #peerSetSource = new WeakMap()
+  #preferDedupe = false
+  #prune
+  #strictPeerDeps
+  #virtualRoots = new Map()
+
+  constructor (options) {
+    super(options)
+
+    const {
+      follow = false,
+      installStrategy = 'hoisted',
+      strictPeerDeps = false,
+      global,
+    } = options
+
+    this.#strictPeerDeps = !!strictPeerDeps
+
+    this.#installStrategy = global ? 'shallow' : installStrategy
+    this.#follow = !!follow
+
+    this[_updateAll] = false
+    this[_updateNames] = []
+    this[_resolvedAdd] = []
+
+    // caches for cached realpath calls
+    const cwd = process.cwd()
+    // assume that the cwd is real enough for our purposes
+    this[_rpcache] = new Map([[cwd, cwd]])
+    this[_stcache] = new Map()
+    this[_flagsSuspect] = false
+  }
+
+  get explicitRequests () {
+    return new Set(this.#explicitRequests)
+  }
+
+  // public method
+  async buildIdealTree (options = {}) {
+    if (this.idealTree) {
+      return this.idealTree
+    }
+
+    // allow the user to set reify options on the ctor as well.
+    // XXX: deprecate separate reify() options object.
+    options = { ...this.options, ...options }
+
+    // an empty array or any falsey value is the same as null
+    if (!options.add || options.add.length === 0) {
+      options.add = null
+    }
+    if (!options.rm || options.rm.length === 0) {
+      options.rm = null
+    }
+
+    const timeEnd = time.start('idealTree')
+
+    if (!options.add && !options.rm && !options.update && this.options.global) {
+      throw new Error('global requires add, rm, or update option')
+    }
+
+    // first get the virtual tree, if possible.  If there's a lockfile, then
+    // that defines the ideal tree, unless the root package.json is not
+    // satisfied by what the ideal tree provides.
+    // from there, we start adding nodes to it to satisfy the deps requested
+    // by the package.json in the root.
+
+    this.#parseSettings(options)
+
+    // start tracker block
+    this.addTracker('idealTree')
+
+    try {
+      await this.#initTree()
+      await this.#inflateAncientLockfile()
+      await this.#applyUserRequests(options)
+      await this.#buildDeps()
+      await this.#fixDepFlags()
+      await this.#pruneFailedOptional()
+      await this.#checkEngineAndPlatform()
+    } finally {
+      timeEnd()
+      this.finishTracker('idealTree')
+    }
+
+    return treeCheck(this.idealTree)
+  }
+
+  async #checkEngineAndPlatform () {
+    const { engineStrict, npmVersion, nodeVersion, omit = [], cpu, os, libc } = this.options
+    const omitSet = new Set(omit)
+
+    for (const node of this.idealTree.inventory.values()) {
+      if (!node.optional && !node.shouldOmit(omitSet)) {
+        try {
+          // if devEngines is present in the root node we ignore the engines check
+          if (!(node.isRoot && node.package.devEngines)) {
+            checkEngine(node.package, npmVersion, nodeVersion, this.options.force)
+          }
+        } catch (err) {
+          if (engineStrict) {
+            throw err
+          }
+          log.warn(err.code, err.message, {
+            package: err.pkgid,
+            required: err.required,
+            current: err.current,
+          })
+        }
+        checkPlatform(node.package, this.options.force)
+      }
+      if (node.optional && !node.inert) {
+        // Mark any optional packages we can't install as inert.
+        // We ignore the --force and --engine-strict flags.
+        try {
+          checkEngine(node.package, npmVersion, nodeVersion, false)
+          checkPlatform(node.package, false, { cpu, os, libc })
+        } catch (error) {
+          const set = optionalSet(node)
+          for (const node of set) {
+            node.inert = true
+          }
+        }
+      }
+    }
+  }
+
+  #parseSettings (options) {
+    const update = options.update === true ? { all: true }
+      : Array.isArray(options.update) ? { names: options.update }
+      : options.update || {}
+
+    if (update.all || !Array.isArray(update.names)) {
+      update.names = []
+    }
+
+    this.#complete = !!options.complete
+    this.#preferDedupe = !!options.preferDedupe
+
+    // validates list of update names, they must
+    // be dep names only, no semver ranges are supported
+    for (const name of update.names) {
+      const spec = npa(name)
+      const validationError =
+        new TypeError(`Update arguments must only contain package names, eg:
+    npm update ${spec.name}`)
+      validationError.code = 'EUPDATEARGS'
+
+      // If they gave us anything other than a bare package name
+      if (spec.raw !== spec.name) {
+        throw validationError
+      }
+    }
+    this[_updateNames] = update.names
+
+    this[_updateAll] = update.all
+    // we prune by default unless explicitly set to boolean false
+    this.#prune = options.prune !== false
+
+    // set if we add anything, but also set here if we know we'll make
+    // changes and thus have to maybe prune later.
+    this.#mutateTree = !!(
+      options.add ||
+      options.rm ||
+      update.all ||
+      update.names.length
+    )
+  }
+
+  // load the initial tree, either the virtualTree from a shrinkwrap,
+  // or just the root node from a package.json
+  async #initTree () {
+    const timeEnd = time.start('idealTree:init')
+    let root
+    if (this.options.global) {
+      root = await this.#globalRootNode()
+    } else {
+      try {
+        const { content: pkg } = await PackageJson.normalize(this.path)
+        root = await this.#rootNodeFromPackage(pkg)
+      } catch (err) {
+        if (err.code === 'EJSONPARSE') {
+          throw err
+        }
+        root = await this.#rootNodeFromPackage({})
+      }
+    }
+    return this[_setWorkspaces](root)
+      // ok to not have a virtual tree.  probably initial install.
+      // When updating all, we load the shrinkwrap, but don't bother
+      // to build out the full virtual tree from it, since we'll be
+      // reconstructing it anyway.
+      .then(root => {
+        if (this.options.global) {
+          return root
+        } else if (!this.options.usePackageLock || this[_updateAll]) {
+          return Shrinkwrap.reset({
+            path: this.path,
+            lockfileVersion: this.options.lockfileVersion,
+            resolveOptions: this.options,
+          }).then(meta => Object.assign(root, { meta }))
+        } else {
+          return this.loadVirtual({ root })
+            .then(tree => {
+              this.#applyRootOverridesToWorkspaces(tree)
+              return tree
+            })
+        }
+      })
+
+      // if we don't have a lockfile to go from, then start with the
+      // actual tree, so we only make the minimum required changes.
+      // don't do this for global installs or updates, because in those
+      // cases we don't use a lockfile anyway.
+      // Load on a new Arborist object, so the Nodes aren't the same,
+      // or else it'll get super confusing when we change them!
+      .then(async root => {
+        if ((!this[_updateAll] && !this.options.global && !root.meta.loadedFromDisk) || (this.options.global && this[_updateNames].length)) {
+          await new this.constructor(this.options).loadActual({ root })
+          const tree = root.target
+          // even though we didn't load it from a package-lock.json FILE,
+          // we still loaded it "from disk", meaning we have to reset
+          // dep flags before assuming that any mutations were reflected.
+          if (tree.children.size) {
+            root.meta.loadedFromDisk = true
+            // set these so that we don't try to ancient lockfile reload it
+            root.meta.originalLockfileVersion = root.meta.lockfileVersion = this.options.lockfileVersion || defaultLockfileVersion
+          }
+        }
+        root.meta.inferFormattingOptions(root.package)
+        return root
+      })
+
+      .then(tree => {
+        // search the virtual tree for missing/invalid edges, if any are found add their source to
+        // the depsQueue so that we'll fix it later
+        depth({
+          tree,
+          getChildren: (node) => {
+            const children = []
+            for (const edge of node.edgesOut.values()) {
+              children.push(edge.to)
+            }
+            return children
+          },
+          filter: node => node,
+          visit: node => {
+            for (const edge of node.edgesOut.values()) {
+              const skipPeerOptional = edge.type === 'peerOptional' && this.options.save === false
+              if (!skipPeerOptional && (!edge.to || !edge.valid)) {
+                this.#depsQueue.push(node)
+                break // no need to continue the loop after the first hit
+              }
+            }
+          },
+        })
+        // null the virtual tree, because we're about to hack away at it
+        // if you want another one, load another copy.
+        this.idealTree = tree
+        this.virtualTree = null
+        timeEnd()
+        return tree
+      })
+  }
+
+  async #globalRootNode () {
+    const root = await this.#rootNodeFromPackage({ dependencies: {} })
+    // this is a gross kludge to handle the fact that we don't save
+    // metadata on the root node in global installs, because the "root"
+    // node is something like /usr/local/lib.
+    const meta = new Shrinkwrap({
+      path: this.path,
+      lockfileVersion: this.options.lockfileVersion,
+      resolveOptions: this.options,
+    })
+    meta.reset()
+    root.meta = meta
+    return root
+  }
+
+  async #rootNodeFromPackage (pkg) {
+    // if the path doesn't exist, then we explode at this point. Note that
+    // this is not a problem for reify(), since it creates the root path
+    // before ever loading trees.
+    // TODO: make buildIdealTree() and loadActual handle a missing root path,
+    // or a symlink to a missing target, and let reify() create it as needed.
+    const real = await realpath(this.path, this[_rpcache], this[_stcache])
+    const Cls = real === this.path ? Node : Link
+    const root = new Cls({
+      path: this.path,
+      realpath: real,
+      pkg,
+      extraneous: false,
+      dev: false,
+      devOptional: false,
+      peer: false,
+      optional: false,
+      global: this.options.global,
+      installLinks: this.installLinks,
+      legacyPeerDeps: this.legacyPeerDeps,
+      loadOverrides: true,
+    })
+    if (root.isLink) {
+      root.target = new Node({
+        path: real,
+        realpath: real,
+        pkg,
+        extraneous: false,
+        dev: false,
+        devOptional: false,
+        peer: false,
+        optional: false,
+        global: this.options.global,
+        installLinks: this.installLinks,
+        legacyPeerDeps: this.legacyPeerDeps,
+        root,
+      })
+    }
+    return root
+  }
+
+  // process the add/rm requests by modifying the root node, and the
+  // update.names request by queueing nodes dependent on those named.
+  async #applyUserRequests (options) {
+    const timeEnd = time.start('idealTree:userRequests')
+    const tree = this.idealTree.target
+
+    if (!this.options.workspaces.length) {
+      await this.#applyUserRequestsToNode(tree, options)
+    } else {
+      const nodes = this.workspaceNodes(tree, this.options.workspaces)
+      if (this.options.includeWorkspaceRoot) {
+        nodes.push(tree)
+      }
+      const appliedRequests = nodes.map(
+        node => this.#applyUserRequestsToNode(node, options)
+      )
+      await Promise.all(appliedRequests)
+    }
+
+    timeEnd()
+  }
+
+  async #applyUserRequestsToNode (tree, options) {
+    // If we have a list of package names to update, and we know it's
+    // going to update them wherever they are, add any paths into those
+    // named nodes to the buildIdealTree queue.
+    if (!this.options.global && this[_updateNames].length) {
+      this.#queueNamedUpdates()
+    }
+
+    // global updates only update the globalTop nodes, but we need to know
+    // that they're there, and not reinstall the world unnecessarily.
+    const globalExplicitUpdateNames = []
+    if (this.options.global && (this[_updateAll] || this[_updateNames].length)) {
+      const nm = resolve(this.path, 'node_modules')
+      const paths = await readdirScoped(nm).catch(() => [])
+      for (const p of paths) {
+        const name = p.replace(/\\/g, '/')
+        const updateName = this[_updateNames].includes(name)
+        if (this[_updateAll] || updateName) {
+          if (updateName) {
+            globalExplicitUpdateNames.push(name)
+          }
+          const dir = resolve(nm, name)
+          const st = await lstat(dir)
+            .catch(/* istanbul ignore next */ () => null)
+          if (st && st.isSymbolicLink()) {
+            const target = await readlink(dir)
+            const real = resolve(dirname(dir), target)
+            tree.package.dependencies[name] = `file:${real}`
+          } else {
+            tree.package.dependencies[name] = '*'
+          }
+        }
+      }
+    }
+
+    if (this.auditReport && this.auditReport.size > 0) {
+      await this.#queueVulnDependents(options)
+    }
+
+    const { add, rm } = options
+
+    if (rm && rm.length) {
+      addRmPkgDeps.rm(tree.package, rm)
+      for (const name of rm) {
+        this.#explicitRequests.add({ from: tree, name, action: 'DELETE' })
+      }
+    }
+
+    if (add && add.length) {
+      await this.#add(tree, options)
+    }
+
+    // triggers a refresh of all edgesOut.  this has to be done BEFORE
+    // adding the edges to explicitRequests, because the package setter
+    // resets all edgesOut.
+    if (add && add.length || rm && rm.length || this.options.global) {
+      tree.package = tree.package
+    }
+
+    for (const spec of this[_resolvedAdd]) {
+      if (spec.tree === tree) {
+        this.#explicitRequests.add(tree.edgesOut.get(spec.name))
+      }
+    }
+    for (const name of globalExplicitUpdateNames) {
+      this.#explicitRequests.add(tree.edgesOut.get(name))
+    }
+
+    this.#depsQueue.push(tree)
+  }
+
+  // This returns a promise because we might not have the name yet, and need to call pacote.manifest to find the name.
+  async #add (tree, { add, saveType = null, saveBundle = false }) {
+    // If we have a link it will need to be added relative to the target's path
+    const path = tree.target.path
+
+    // Get the name for each of the specs in the list.
+    // e.g. doing `foo@bar` we just return foo but if it's a url or git, we don't know the name until we fetch it and look in its manifest.
+    await Promise.all(add.map(async rawSpec => {
+      // We do NOT provide the path to npa here, because user-additions need to be resolved relative to the tree being added to.
+      let spec = npa(rawSpec)
+
+      // if it's just @'' then we reload whatever's there, or get latest.
+      // if it's an explicit tag, we need to install that specific tag version.
+      const isTag = spec.rawSpec && spec.type === 'tag'
+
+      // look up the names of file/directory/git specs
+      if (!spec.name || isTag) {
+        const _isRoot = tree.isProjectRoot || tree.isWorkspace
+        const mani = await pacote.manifest(spec, { ...this.options, _isRoot })
+        if (isTag) {
+          // translate tag to a version
+          spec = npa(`${mani.name}@${mani.version}`)
+        }
+        spec.name = mani.name
+      }
+
+      const { name } = spec
+      if (spec.type === 'file') {
+        spec = npa(`file:${relpath(path, spec.fetchSpec)}`, path)
+        spec.name = name
+      } else if (spec.type === 'directory') {
+        try {
+          const real = await realpath(spec.fetchSpec, this[_rpcache], this[_stcache])
+          spec = npa(`file:${relpath(path, real)}`, path)
+          spec.name = name
+        } catch {
+          // TODO: create synthetic test case to simulate realpath failure
+        }
+      }
+      spec.tree = tree
+      this[_resolvedAdd].push(spec)
+    }))
+
+    // now this._resolvedAdd is a list of spec objects with names.
+    // find a home for each of them!
+    addRmPkgDeps.add({
+      pkg: tree.package,
+      add: this[_resolvedAdd],
+      saveBundle,
+      saveType,
+    })
+  }
+
+  // TODO: provide a way to fix bundled deps by exposing metadata about
+  // what's in the bundle at each published manifest.  Without that, we
+  // can't possibly fix bundled deps without breaking a ton of other stuff,
+  // and leaving the user subject to getting it overwritten later anyway.
+  async #queueVulnDependents (options) {
+    for (const vuln of this.auditReport.values()) {
+      for (const node of vuln.nodes) {
+        const bundler = node.getBundler()
+
+        // XXX this belongs in the audit report itself, not here.
+        // We shouldn't even get these things here, and they shouldn't
+        // be printed by npm-audit-report as if they can be fixed, because
+        // they can't.
+        if (bundler) {
+          log.warn(`audit fix ${node.name}@${node.version}`,
+            `${node.location}\nis a bundled dependency of\n${
+            bundler.name}@${bundler.version} at ${bundler.location}\n` +
+            'It cannot be fixed automatically.\n' +
+            `Check for updates to the ${bundler.name} package.`)
+          continue
+        }
+
+        for (const edge of node.edgesIn) {
+          this.addTracker('idealTree', edge.from.name, edge.from.location)
+          this.#depsQueue.push(edge.from)
+        }
+      }
+    }
+
+    // note any that can't be fixed at the root level without --force
+    // if there's a fix, we use that.  otherwise, the user has to remove it,
+    // find a different thing, fix the upstream, etc.
+    //
+    // XXX: how to handle top nodes that aren't the root?  Maybe the report
+    // just tells the user to cd into that directory and fix it?
+    if (this.options.force && this.auditReport && this.auditReport.topVulns.size) {
+      options.add = options.add || []
+      options.rm = options.rm || []
+      const nodesTouched = new Set()
+      for (const [name, topVuln] of this.auditReport.topVulns.entries()) {
+        const {
+          simpleRange,
+          topNodes,
+          fixAvailable,
+        } = topVuln
+        for (const node of topNodes) {
+          if (!node.isProjectRoot && !node.isWorkspace) {
+            // not something we're going to fix, sorry.  have to cd into
+            // that directory and fix it yourself.
+            log.warn('audit', 'Manual fix required in linked project ' +
+              `at ./${node.location} for ${name}@${simpleRange}.\n` +
+              `'cd ./${node.location}' and run 'npm audit' for details.`)
+            continue
+          }
+
+          if (!fixAvailable) {
+            log.warn('audit', `No fix available for ${name}@${simpleRange}`)
+            continue
+          }
+
+          // name may be different if parent fixes the dep
+          // see Vuln fixAvailable setter
+          const { isSemVerMajor, version, name: fixName } = fixAvailable
+          const breakingMessage = isSemVerMajor
+            ? 'a SemVer major change'
+            : 'outside your stated dependency range'
+          log.warn('audit', `Updating ${fixName} to ${version}, ` +
+            `which is ${breakingMessage}.`)
+
+          await this.#add(node, { add: [`${fixName}@${version}`] })
+          nodesTouched.add(node)
+        }
+      }
+      for (const node of nodesTouched) {
+        node.package = node.package
+      }
+    }
+  }
+
+  #avoidRange (name) {
+    if (!this.auditReport) {
+      return null
+    }
+    const vuln = this.auditReport.get(name)
+    if (!vuln) {
+      return null
+    }
+    return vuln.range
+  }
+
+  #queueNamedUpdates () {
+    // ignore top nodes, since they are not loaded the same way, and
+    // probably have their own project associated with them.
+
+    // for every node with one of the names on the list, we add its
+    // dependents to the queue to be evaluated.  in buildDepStep,
+    // anything on the update names list will get refreshed, even if
+    // it isn't a problem.
+
+    // XXX this could be faster by doing a series of inventory.query('name')
+    // calls rather than walking over everything in the tree.
+    for (const node of this.idealTree.inventory.values()) {
+      // XXX add any invalid edgesOut to the queue
+      if (this[_updateNames].includes(node.name) &&
+        !node.isTop && !node.inDepBundle && !node.inShrinkwrap) {
+        for (const edge of node.edgesIn) {
+          this.addTracker('idealTree', edge.from.name, edge.from.location)
+          this.#depsQueue.push(edge.from)
+        }
+      }
+    }
+  }
+
+  async #inflateAncientLockfile () {
+    const { meta, inventory } = this.idealTree
+    const ancient = meta.ancientLockfile
+    const old = meta.loadedFromDisk && !(meta.originalLockfileVersion >= 2)
+
+    if (inventory.size === 0 || !ancient && !old) {
+      return
+    }
+
+    // if the lockfile is from node v5 or earlier, then we'll have to reload
+    // all the manifests of everything we encounter.  this is costly, but at
+    // least it's just a one-time hit.
+    const timeEnd = time.start('idealTree:inflate')
+
+    // don't warn if we're not gonna actually write it back anyway.
+    const heading = ancient ? 'ancient lockfile' : 'old lockfile'
+    if (ancient || !this.options.lockfileVersion ||
+        this.options.lockfileVersion >= defaultLockfileVersion) {
+      log.warn(heading,
+        `
+The ${meta.type} file was created with an old version of npm,
+so supplemental metadata must be fetched from the registry.
+
+This is a one-time fix-up, please be patient...
+`)
+    }
+
+    this.addTracker('idealTree:inflate')
+    const queue = []
+    for (const node of inventory.values()) {
+      if (node.isProjectRoot) {
+        continue
+      }
+
+      // if the node's location isn't within node_modules then this is actually
+      // a link target, so skip it. the link node itself will be queued later.
+      if (!node.location.startsWith('node_modules')) {
+        continue
+      }
+
+      queue.push(async () => {
+        log.silly('inflate', node.location)
+        const { resolved, version, path, name, location, integrity } = node
+        // don't try to hit the registry for linked deps
+        const useResolved = resolved && (
+          !version || resolved.startsWith('file:')
+        )
+        const id = useResolved ? resolved : version
+        const spec = npa.resolve(name, id, dirname(path))
+        const t = `idealTree:inflate:${location}`
+        this.addTracker(t)
+        try {
+          const mani = await pacote.manifest(spec, {
+            ...this.options,
+            resolved: resolved,
+            integrity: integrity,
+            fullMetadata: false,
+          })
+          node.package = { ...mani, _id: `${mani.name}@${mani.version}` }
+        } catch (er) {
+          const warning = `Could not fetch metadata for ${name}@${id}`
+          log.warn(heading, warning, er)
+        }
+        this.finishTracker(t)
+      })
+    }
+    await promiseCallLimit(queue)
+
+    // have to re-calc dep flags, because the nodes don't have edges
+    // until their packages get assigned, so everything looks extraneous
+    resetDepFlags(this.idealTree)
+    calcDepFlags(this.idealTree)
+
+    // yes, yes, this isn't the "original" version, but now that it's been
+    // upgraded, we need to make sure we don't do the work to upgrade it
+    // again, since it's now as new as can be.
+    if (!this.options.lockfileVersion && !meta.hiddenLockfile) {
+      meta.originalLockfileVersion = defaultLockfileVersion
+    }
+    this.finishTracker('idealTree:inflate')
+    timeEnd()
+  }
+
+  // at this point we have a virtual tree with the actual root node's
+  // package deps, which may be partly or entirely incomplete, invalid
+  // or extraneous.
+  #buildDeps () {
+    const timeEnd = time.start('idealTree:buildDeps')
+    const tree = this.idealTree.target
+    tree.assertRootOverrides()
+    this.#depsQueue.push(tree)
+    // XXX also push anything that depends on a node with a name
+    // in the override list
+    log.silly('idealTree', 'buildDeps')
+    this.addTracker('idealTree', tree.name, '')
+    return this.#buildDepStep().then(timeEnd)
+  }
+
+  async #buildDepStep () {
+    // removes tracker of previous dependency in the queue
+    if (this.#currentDep) {
+      const { location, name } = this.#currentDep
+      time.end(`idealTree:${location || '#root'}`)
+      this.finishTracker('idealTree', name, location)
+      this.#currentDep = null
+    }
+
+    if (!this.#depsQueue.length) {
+      return this.#resolveLinks()
+    }
+
+    const node = this.#depsQueue.pop()
+    const bd = node.package.bundleDependencies
+    const hasBundle = bd && Array.isArray(bd) && bd.length
+    const { hasShrinkwrap } = node
+
+    // if the node was already visited, or has since been removed from the
+    // tree, skip over it and process the rest of the queue.  If a node has
+    // a shrinkwrap, also skip it, because it's going to get its deps
+    // satisfied by whatever's in that file anyway.
+    if (this.#depsSeen.has(node) ||
+        node.root !== this.idealTree ||
+        hasShrinkwrap && !this.#complete) {
+      return this.#buildDepStep()
+    }
+
+    this.#depsSeen.add(node)
+    this.#currentDep = node
+    time.start(`idealTree:${node.location || '#root'}`)
+
+    // if we're loading a _complete_ ideal tree, for a --package-lock-only
+    // installation for example, we have to crack open the tarball and
+    // look inside if it has bundle deps or shrinkwraps.  note that this is
+    // not necessary during a reification, because we just update the
+    // ideal tree by reading bundles/shrinkwraps in place.
+    // Don't bother if the node is from the actual tree and hasn't
+    // been resolved, because we can't fetch it anyway, could be anything!
+    const crackOpen = this.#complete &&
+      node !== this.idealTree &&
+      node.resolved &&
+      (hasBundle || hasShrinkwrap) &&
+      !node.inert
+    if (crackOpen) {
+      const Arborist = this.constructor
+      const opt = { ...this.options }
+      await cacache.tmp.withTmp(this.cache, opt, async path => {
+        await pacote.extract(node.resolved, path, {
+          ...opt,
+          Arborist,
+          resolved: node.resolved,
+          integrity: node.integrity,
+        })
+
+        if (hasShrinkwrap) {
+          await new Arborist({ ...this.options, path })
+            .loadVirtual({ root: node })
+        }
+
+        if (hasBundle) {
+          await new Arborist({ ...this.options, path })
+            .loadActual({ root: node, ignoreMissing: true })
+        }
+      })
+    }
+
+    // if any deps are missing or invalid, then we fetch the manifest for
+    // the thing we want, and build a new dep node from that.
+    // Then, find the ideal placement for that node.  The ideal placement
+    // searches from the node's deps (or parent deps in the case of non-root
+    // peer deps), and walks up the tree until it finds the highest spot
+    // where it doesn't cause any conflicts.
+    //
+    // A conflict can be:
+    // - A node by that name already exists at that location.
+    // - The parent has a peer dep on that name
+    // - One of the node's peer deps conflicts at that location, unless the
+    //   peer dep is met by a node at that location, which is fine.
+    //
+    // If we create a new node, then build its ideal deps as well.
+    //
+    // Note: this is the same "maximally naive" deduping tree-building
+    // algorithm that npm has used since v3.  In a case like this:
+    //
+    // root -> (a@1, b@1||2)
+    // a -> (b@1)
+    //
+    // You'll end up with a tree like this:
+    //
+    // root
+    // +-- a@1
+    // |   +-- b@1
+    // +-- b@2
+    //
+    // rather than this, more deduped, but just as correct tree:
+    //
+    // root
+    // +-- a@1
+    // +-- b@1
+    //
+    // Another way to look at it is that this algorithm favors getting higher
+    // version deps at higher levels in the tree, even if that reduces
+    // potential deduplication.
+    //
+    // Set `preferDedupe: true` in the options to replace the shallower
+    // dep if allowed.
+
+    const tasks = []
+    const peerSource = this.#peerSetSource.get(node) || node
+    for (const edge of this.#problemEdges(node)) {
+      if (edge.peerConflicted) {
+        continue
+      }
+
+      // peerSetSource is only relevant when we have a peerEntryEdge
+      // otherwise we're setting regular non-peer deps as if they have
+      // a virtual root of whatever brought in THIS node.
+      // so we VR the node itself if the edge is not a peer
+      const source = edge.peer ? peerSource : node
+
+      const virtualRoot = this.#virtualRoot(source, true)
+      // reuse virtual root if we already have one, but don't
+      // try to do the override ahead of time, since we MAY be able
+      // to create a more correct tree than the virtual root could.
+      const vrEdge = virtualRoot && virtualRoot.edgesOut.get(edge.name)
+      const vrDep = vrEdge && vrEdge.valid && vrEdge.to
+      // only re-use the virtualRoot if it's a peer edge we're placing.
+      // otherwise, we end up in situations where we override peer deps that
+      // we could have otherwise found homes for.  Eg:
+      // xy -> (x, y)
+      // x -> PEER(z@1)
+      // y -> PEER(z@2)
+      // If xy is a dependency, we can resolve this like:
+      // project
+      // +-- xy
+      // |   +-- y
+      // |   +-- z@2
+      // +-- x
+      // +-- z@1
+      // But if x and y are loaded in the same virtual root, then they will
+      // be forced to agree on a version of z.
+      const required = new Set([edge.from])
+      const parent = edge.peer ? virtualRoot : null
+      const dep = vrDep && vrDep.satisfies(edge) ? vrDep
+        : await this.#nodeFromEdge(edge, parent, null, required)
+
+      /* istanbul ignore next */
+      debug(() => {
+        if (!dep) {
+          throw new Error('no dep??')
+        }
+      })
+
+      tasks.push({ edge, dep })
+    }
+
+    const placeDeps = tasks.sort((a, b) => localeCompare(a.edge.name, b.edge.name))
+
+    const promises = []
+    for (const { edge, dep } of placeDeps) {
+      const pd = new PlaceDep({
+        edge,
+        dep,
+
+        auditReport: this.auditReport,
+        explicitRequest: this.#explicitRequests.has(edge),
+        force: this.options.force,
+        installLinks: this.installLinks,
+        installStrategy: this.#installStrategy,
+        legacyPeerDeps: this.legacyPeerDeps,
+        preferDedupe: this.#preferDedupe,
+        strictPeerDeps: this.#strictPeerDeps,
+        updateNames: this[_updateNames],
+      })
+      // placing a dep is actually a tree of placing the dep itself
+      // and all of its peer group that aren't already met by the tree
+      depth({
+        tree: pd,
+        getChildren: pd => pd.children,
+        visit: pd => {
+          const { placed, edge, canPlace: cpd, parent } = pd
+          // if we didn't place anything, nothing to do here
+          if (!placed) {
+            return
+          }
+
+          // we placed something, that means we changed the tree
+          if (placed.errors.length) {
+            this.#loadFailures.add(placed)
+          }
+          this.#mutateTree = true
+          if (cpd.canPlaceSelf === OK) {
+            for (const edgeIn of placed.edgesIn) {
+              if (edgeIn === edge) {
+                continue
+              }
+              const { from, valid, peerConflicted } = edgeIn
+              if (!peerConflicted && !valid) {
+                if (this.#depsSeen.has(from) && this.options.save) {
+                  // Re-queue already-processed nodes when a newly placed dep creates an invalid edge during npm install (save=true).
+                  // This handles the case where a peerOptional dep was valid (missing) when the node was first processed, but becomes invalid when the dep is later placed by another path with a version that doesn't satisfy the peer spec.
+                  // See npm/cli#8726.
+                  this.#depsSeen.delete(from)
+                  this.#depsQueue.push(from)
+                } else if (!this.#depsSeen.has(from)) {
+                  this.addTracker('idealTree', from.name, from.location)
+                  this.#depsQueue.push(from)
+                }
+              }
+            }
+          } else {
+            /* istanbul ignore else - should be only OK or REPLACE here */
+            if (cpd.canPlaceSelf === REPLACE) {
+              // this may also create some invalid edges, for example if we're
+              // intentionally causing something to get nested which was
+              // previously placed in this location.
+              for (const edgeIn of placed.edgesIn) {
+                if (edgeIn === edge) {
+                  continue
+                }
+
+                const { valid, peerConflicted } = edgeIn
+                if (!valid && !peerConflicted) {
+                  // if it's already been visited, we have to re-visit
+                  // otherwise, just enqueue normally.
+                  this.#depsSeen.delete(edgeIn.from)
+                  this.#depsQueue.push(edgeIn.from)
+                }
+              }
+            }
+          }
+
+          /* istanbul ignore if - should be impossible */
+          if (cpd.canPlaceSelf === CONFLICT) {
+            debug(() => {
+              const er = new Error('placed with canPlaceSelf=CONFLICT')
+              throw Object.assign(er, { placeDep: pd })
+            })
+            return
+          }
+
+          // lastly, also check for the missing deps of the node we placed, and any holes created by pruning out conflicted peer sets.
+          this.#depsQueue.push(placed)
+          for (const dep of pd.needEvaluation) {
+            this.#depsSeen.delete(dep)
+            this.#depsQueue.push(dep)
+          }
+
+          // pre-fetch any problem edges, since we'll need these soon
+          // if it fails at this point, though, don't worry because it may well be an optional dep that has gone missing
+          // it'll fail later anyway
+          for (const e of this.#problemEdges(placed)) {
+            // XXX This is somehow load bearing.  This makes tests that print the ideal tree of a tree with tarball dependencies fail
+            // This can't be changed or removed till we figure out why
+            // The test is named "tarball deps with transitive tarball deps"
+            promises.push(() =>
+              this.#fetchManifest(npa.resolve(e.name, e.spec, fromPath(placed, e)), parent)
+                .catch(() => null)
+            )
+          }
+        },
+      })
+    }
+
+    for (const { to } of node.edgesOut.values()) {
+      if (to && to.isLink && to.target) {
+        this.#linkNodes.add(to)
+      }
+    }
+
+    await promiseCallLimit(promises)
+    return this.#buildDepStep()
+  }
+
+  // loads a node from an edge, and then loads its peer deps (and their peer deps, on down the line) into a virtual root parent.
+  async #nodeFromEdge (edge, parent_, secondEdge, required) {
+    // create a virtual root node with the same deps as the node that is requesting this one, so that we can get all the peer deps in a context where they're likely to be resolvable.
+    // Note that the virtual root will also have virtual copies of the targets of any child Links, so that they resolve appropriately.
+    const parent = parent_ || this.#virtualRoot(edge.from)
+
+    const spec = npa.resolve(edge.name, edge.spec, edge.from.path)
+    const first = await this.#nodeFromSpec(edge.name, spec, parent, edge)
+
+    // we might have a case where the parent has a peer dependency on `foo@*` which resolves to v2, but another dep in the set has a peerDependency on `foo@1`.
+    // In that case, if we force it to be v2, we're unnecessarily triggering an ERESOLVE.
+    // If we have a second edge to worry about, and it's not satisfied by the first node, try a second and see if that satisfies the original edge here.
+    const spec2 = secondEdge && npa.resolve(
+      edge.name,
+      secondEdge.spec,
+      secondEdge.from.path
+    )
+    const second = secondEdge && !secondEdge.valid
+      ? await this.#nodeFromSpec(edge.name, spec2, parent, secondEdge)
+      : null
+
+    // pick the second one if they're both happy with that; otherwise, first
+    const node = second && edge.valid ? second : first
+    // ensure the one we want is the one that's placed
+    node.parent = parent
+
+    if (required.has(edge.from) && edge.type !== 'peerOptional' ||
+        secondEdge && (
+          required.has(secondEdge.from) && secondEdge.type !== 'peerOptional')) {
+      required.add(node)
+    }
+
+    // keep track of the thing that caused this node to be included.
+    const src = parent.sourceReference
+    this.#peerSetSource.set(node, src)
+
+    // do not load the peers along with the set if this is a global top pkg
+    // otherwise we'll be tempted to put peers as other top-level installed
+    // things, potentially clobbering what's there already, which is not
+    // what we want.  the missing edges will be picked up on the next pass.
+    if (this.options.global && edge.from.isProjectRoot) {
+      return node
+    }
+
+    // otherwise, we have to make sure that our peers can go along with us.
+    return this.#loadPeerSet(node, required)
+  }
+
+  #virtualRoot (node, reuse = false) {
+    if (reuse && this.#virtualRoots.has(node)) {
+      return this.#virtualRoots.get(node)
+    }
+
+    const vr = new Node({
+      path: node.realpath,
+      sourceReference: node,
+      installLinks: this.installLinks,
+      legacyPeerDeps: this.legacyPeerDeps,
+      overrides: node.overrides,
+    })
+
+    // also need to set up any targets from any link deps, so that
+    // they are properly reflected in the virtual environment
+    for (const child of node.children.values()) {
+      if (child.isLink) {
+        new Node({
+          path: child.realpath,
+          sourceReference: child.target,
+          root: vr,
+        })
+      }
+    }
+
+    this.#virtualRoots.set(node, vr)
+    return vr
+  }
+
+  #problemEdges (node) {
+    // skip over any bundled deps, they're not our problem.
+    // Note that this WILL fetch bundled meta-deps which are also dependencies
+    // but not listed as bundled deps.  When reifying, we first unpack any
+    // nodes that have bundleDependencies, then do a loadActual on them, move
+    // the nodes into the ideal tree, and then prune.  So, fetching those
+    // possibly-bundled meta-deps at this point doesn't cause any worse
+    // problems than a few unnecessary packument fetches.
+
+    // also skip over any nodes in the tree that failed to load, since those
+    // will crash the install later on anyway.
+    const bd = node.isProjectRoot || node.isWorkspace ? null
+      : node.package.bundleDependencies
+    const bundled = new Set(bd || [])
+
+    const problems = []
+    for (const edge of node.edgesOut.values()) {
+      // If it's included in a bundle, we take whatever is specified.
+      if (bundled.has(edge.name)) {
+        continue
+      }
+
+      // If it's already been logged as a load failure, skip it.
+      if (edge.to && this.#loadFailures.has(edge.to)) {
+        continue
+      }
+
+      // If it's shrinkwrapped, we use what the shrinkwap wants.
+      if (edge.to && edge.to.inShrinkwrap) {
+        continue
+      }
+
+      // If the edge has no destination, that's a problem, unless
+      // if it's peerOptional and not explicitly requested.
+      if (!edge.to) {
+        if (edge.type !== 'peerOptional' ||
+          this.#explicitRequests.has(edge)) {
+          problems.push(edge)
+        }
+        continue
+      }
+
+      // If the edge has an error, there's a problem, unless it's peerOptional and we're not saving (e.g. npm ci), in which case we trust the lockfile and skip re-resolution.
+      // When saving (npm install), peerOptional invalid edges ARE treated as problems so the lockfile gets fixed.
+      // See npm/cli#8726.
+      if (!edge.valid) {
+        if (edge.type !== 'peerOptional' || this.options.save !== false) {
+          problems.push(edge)
+        }
+        continue
+      }
+
+      // If the edge is a workspace, and it's valid, leave it alone
+      if (edge.to.isWorkspace) {
+        continue
+      }
+
+      // user explicitly asked to update this package by name, problem
+      if (this[_updateNames].includes(edge.name)) {
+        problems.push(edge)
+        continue
+      }
+
+      // fixing a security vulnerability with this package, problem
+      if (this.auditReport && this.auditReport.isVulnerable(edge.to)) {
+        problems.push(edge)
+        continue
+      }
+
+      // user has explicitly asked to install this package, problem
+      if (this.#explicitRequests.has(edge)) {
+        problems.push(edge)
+        continue
+      }
+    }
+    return problems
+  }
+
+  async #fetchManifest (spec, parent) {
+    const options = {
+      ...this.options,
+      avoid: this.#avoidRange(spec.name),
+      fullMetadata: true,
+      _isRoot: parent?.isProjectRoot || parent?.isWorkspace,
+    }
+    // get the intended spec and stored metadata from yarn.lock file,
+    // if available and valid.
+    spec = this.idealTree.meta.checkYarnLock(spec, options)
+
+    if (this.#manifests.has(spec.raw)) {
+      return this.#manifests.get(spec.raw)
+    } else {
+      log.silly('fetch manifest', spec.raw.replace(spec.rawSpec, redact(spec.rawSpec)))
+      const mani = await pacote.manifest(spec, options)
+      this.#manifests.set(spec.raw, mani)
+      return mani
+    }
+  }
+
+  async #nodeFromSpec (name, spec, parent, edge) {
+    // pacote will slap integrity on its options, so we have to clone the object so it doesn't get mutated.
+    // Don't bother to load the manifest for link deps, because the target might be within another package that doesn't exist yet.
+    const { installLinks, legacyPeerDeps } = this
+    const isWorkspace = this.idealTree.workspaces && this.idealTree.workspaces.has(spec.name)
+
+    // spec is a directory, link it if:
+    // - it's a workspace, OR
+    // - it's a project-internal file: dependency (always linked), OR
+    // - it's external and installLinks is false
+    // TODO post arborist refactor, will need to check for installStrategy=linked
+    let isProjectInternalFileSpec = false
+    if (edge?.rawSpec.startsWith('file:../') || edge?.rawSpec.startsWith('file:./')) {
+      const targetPath = resolve(parent.realpath, edge.rawSpec.slice(5))
+      const resolvedProjectRoot = resolve(this.idealTree.realpath)
+      // Check if the target is within the project root
+      isProjectInternalFileSpec = targetPath.startsWith(resolvedProjectRoot + sep) || targetPath === resolvedProjectRoot
+    }
+
+    // When using --install-links, we need to handle transitive file dependencies specially
+    // If the parent was installed (not linked) due to --install-links, and this is a file: dep, we should also install it rather than link it
+    const parentWasInstalled = parent && !parent.isLink && parent.resolved?.startsWith('file:')
+    const isTransitiveFileDep = spec.type === 'directory' && parentWasInstalled && installLinks
+
+    // Decide whether to link or copy the dependency
+    const shouldLink = (isWorkspace || isProjectInternalFileSpec || !installLinks) && !isTransitiveFileDep
+    if (spec.type === 'directory' && shouldLink) {
+      const realpath = spec.fetchSpec
+      const { content: pkg } = await PackageJson.normalize(realpath).catch(() => {
+        return { content: {} }
+      })
+      const link = new Link({ name, parent, realpath, pkg, installLinks, legacyPeerDeps })
+      this.#linkNodes.add(link)
+      return link
+    }
+
+    // if the spec matches a workspace name, then see if the workspace node will satisfy the edge. if it does, we return the workspace node to make sure it takes priority.
+    if (isWorkspace) {
+      const existingNode = this.idealTree.edgesOut.get(spec.name).to
+      if (existingNode && existingNode.isWorkspace && existingNode.satisfies(edge)) {
+        return existingNode
+      }
+    }
+
+    // For file: dependencies that we're installing (not linking), ensure proper resolution
+    if (isTransitiveFileDep && edge) {
+      // For transitive file deps, resolve relative to the parent's original source location
+      const parentOriginalPath = parent.resolved.slice(5) // Remove 'file:' prefix
+      const relativePath = edge.rawSpec.slice(5) // Remove 'file:' prefix
+      const absolutePath = resolve(parentOriginalPath, relativePath)
+      spec = npa.resolve(name, `file:${absolutePath}`)
+    }
+
+    // spec isn't a directory, and either isn't a workspace or the workspace we have
+    // doesn't satisfy the edge. try to fetch a manifest and build a node from that.
+    return this.#fetchManifest(spec, parent)
+      .then(pkg => new Node({ name, pkg, parent, installLinks, legacyPeerDeps }), error => {
+        error.requiredBy = edge.from.location || '.'
+
+        // failed to load the spec, either because of enotarget or
+        // fetch failure of some other sort.  save it so we can verify
+        // later that it's optional; otherwise, the error is fatal.
+        const n = new Node({
+          name,
+          parent,
+          error,
+          installLinks,
+          legacyPeerDeps,
+        })
+        this.#loadFailures.add(n)
+        return n
+      })
+  }
+
+  // load all peer deps and meta-peer deps into the node's parent
+  // At the end of this, the node's peer-type outward edges are all
+  // resolved, and so are all of theirs, but other dep types are not.
+  // We prefer to get peer deps that meet the requiring node's dependency,
+  // if possible, since that almost certainly works (since that package was
+  // developed with this set of deps) and will typically be more restrictive.
+  // Note that the peers in the set can conflict either with each other,
+  // or with a direct dependency from the virtual root parent!  In strict
+  // mode, this is always an error.  In force mode, it never is, and we
+  // prefer the parent's non-peer dep over a peer dep, or the version that
+  // gets placed first.  In non-strict mode, we behave strictly if the
+  // virtual root is based on the root project, and allow non-peer parent
+  // deps to override, but throw if no preference can be determined.
+  async #loadPeerSet (node, required) {
+    const peerEdges = [...node.edgesOut.values()]
+      // we typically only install non-optional peers, but we have to
+      // factor them into the peerSet so that we can avoid conflicts
+      .filter(e => e.peer && !(e.valid && e.to))
+      .sort(({ name: a }, { name: b }) => localeCompare(a, b))
+
+    for (const edge of peerEdges) {
+      // node.parent gets mutated during loop execution due to recursive #nodeFromEdge calls.
+      // When a compatible peer is found (e.g. a@1.1.0 replaces a@1.2.0), the original node loses its parent.
+      // if node is detached/removed from the tree, or has no parent, so no need to check remaining edgesOut for that node.
+      if (!node.parent) {
+        break
+      }
+      // already placed this one, and we're happy with it.
+      if (edge.valid && edge.to) {
+        continue
+      }
+
+      const parentEdge = node.parent.edgesOut.get(edge.name)
+      const { isProjectRoot, isWorkspace } = node.parent.sourceReference
+      const isMine = isProjectRoot || isWorkspace
+      const conflictOK = this.options.force || !isMine && !this.#strictPeerDeps
+
+      if (!edge.to) {
+        if (!parentEdge) {
+          // easy, just put the thing there
+          await this.#nodeFromEdge(edge, node.parent, null, required)
+          continue
+        } else {
+          // if the parent's edge is very broad like >=1, and the edge in
+          // question is something like 1.x, then we want to get a 1.x, not
+          // a 2.x.  pass along the child edge as an advisory guideline.
+          // if the parent edge doesn't satisfy the child edge, and the
+          // child edge doesn't satisfy the parent edge, then we have
+          // a conflict.  this is always a problem in strict mode, never
+          // in force mode, and a problem in non-strict mode if this isn't
+          // on behalf of our project.  in all such cases, we warn at least.
+          const dep = await this.#nodeFromEdge(
+            parentEdge,
+            node.parent,
+            edge,
+            required
+          )
+
+          // hooray! that worked!
+          if (edge.valid) {
+            continue
+          }
+
+          // allow it.  either we're overriding, or it's not something
+          // that will be installed by default anyway, and we'll fail when
+          // we get to the point where we need to, if we need to.
+          if (conflictOK || !required.has(dep)) {
+            edge.peerConflicted = true
+            continue
+          }
+
+          // problem
+          this.#failPeerConflict(edge, parentEdge)
+        }
+      }
+
+      // There is something present already, and we're not happy about it
+      // See if the thing we WOULD be happy with is also going to satisfy
+      // the other dependents on the current node.
+      const current = edge.to
+      const dep = await this.#nodeFromEdge(edge, null, null, required)
+      if (dep.canReplace(current)) {
+        await this.#nodeFromEdge(edge, node.parent, null, required)
+        continue
+      }
+
+      // at this point we know that there is a dep there, and
+      // we don't like it.  always fail strictly, always allow forcibly or
+      // in non-strict mode if it's not our fault.  don't warn here, because
+      // we are going to warn again when we place the deps, if we end up
+      // overriding for something else.  If the thing that has this dep
+      // isn't also required, then there's a good chance we won't need it,
+      // so allow it for now and let it conflict if it turns out to actually
+      // be necessary for the installation.
+      if (conflictOK || !required.has(edge.from)) {
+        continue
+      }
+
+      // ok, it's the root, or we're in unforced strict mode, so this is bad
+      this.#failPeerConflict(edge, parentEdge)
+    }
+    return node
+  }
+
+  #failPeerConflict (edge, currentEdge) {
+    const expl = this.#explainPeerConflict(edge, currentEdge)
+    throw Object.assign(new Error('unable to resolve dependency tree'), expl)
+  }
+
+  #explainPeerConflict (edge, currentEdge) {
+    const node = edge.from
+    const curNode = node.resolve(edge.name)
+    const current = curNode.explain()
+    return {
+      code: 'ERESOLVE',
+      current,
+      // it SHOULD be impossible to get here without a current node in place,
+      // but this at least gives us something report on when bugs creep into
+      // the tree handling logic.
+      currentEdge: currentEdge ? currentEdge.explain() : null,
+      edge: edge.explain(),
+      strictPeerDeps: this.#strictPeerDeps,
+      force: this.options.force,
+    }
+  }
+
+  // go through all the links in the this.#linkNodes set
+  // for each one:
+  // - if outside the root, ignore it, assume it's fine, it's not our problem
+  // - if a node in the tree already, assign the target to that node.
+  // - if a path under an existing node, then assign that as the fsParent,
+  //   and add it to the _depsQueue
+  //
+  // call buildDepStep if anything was added to the queue; otherwise, we're done
+  // XXX load-virtual also has a #resolveLinks, is there overlap?
+  #resolveLinks () {
+    for (const link of this.#linkNodes) {
+      this.#linkNodes.delete(link)
+
+      // link we never ended up placing, skip it
+      if (link.root !== this.idealTree) {
+        continue
+      }
+
+      const tree = this.idealTree.target
+      const external = !link.target.isDescendantOf(tree)
+
+      // outside the root, somebody else's problem, ignore it
+      if (external && !this.#follow) {
+        continue
+      }
+
+      // didn't find a parent for it or it has not been seen yet
+      // so go ahead and process it.
+      const unseenLink = (link.target.parent || link.target.fsParent) &&
+        !this.#depsSeen.has(link.target)
+
+      if (this.#follow &&
+          !link.target.parent &&
+          !link.target.fsParent ||
+          unseenLink) {
+        this.addTracker('idealTree', link.target.name, link.target.location)
+        this.#depsQueue.push(link.target)
+      }
+    }
+
+    if (this.#depsQueue.length) {
+      return this.#buildDepStep()
+    }
+  }
+
+  #fixDepFlags () {
+    const timeEnd = time.start('idealTree:fixDepFlags')
+    const metaFromDisk = this.idealTree.meta.loadedFromDisk
+    const flagsSuspect = this[_flagsSuspect]
+    const mutateTree = this.#mutateTree
+    // if the options set prune:false, then we don't prune, but we still
+    // mark the extraneous items in the tree if we modified it at all.
+    // If we did no modifications, we just iterate over the extraneous nodes.
+    // if we started with an empty tree, then the dep flags are already
+    // all set to true, and there can be nothing extraneous, so there's
+    // nothing to prune, because we built it from scratch.  if we didn't
+    // add or remove anything, then also nothing to do.
+    if (metaFromDisk && mutateTree) {
+      resetDepFlags(this.idealTree)
+    }
+
+    // update all the dev/optional/etc flags in the tree
+    // either we started with a fresh tree, or we
+    // reset all the flags to find the extraneous nodes.
+    //
+    // if we started from a blank slate, or changed something, then
+    // the dep flags will be all set to true.
+    if (!metaFromDisk || mutateTree) {
+      calcDepFlags(this.idealTree)
+    } else {
+      // otherwise just unset all the flags on the root node
+      // since they will sometimes have the default value
+      this.idealTree.unsetDepFlags()
+    }
+
+    // at this point, any node marked as extraneous should be pruned.
+    // if we started from a shrinkwrap, and then added/removed something,
+    // then the tree is suspect.  Prune what is marked as extraneous.
+    // otherwise, don't bother.
+    const needPrune = metaFromDisk && (mutateTree || flagsSuspect)
+    if (this.#prune && needPrune) {
+      this.#idealTreePrune()
+    }
+
+    timeEnd()
+  }
+
+  #applyRootOverridesToWorkspaces (tree) {
+    const rootOverrides = tree.root.package.overrides || {}
+
+    for (const node of tree.root.inventory.values()) {
+      if (!node.isWorkspace) {
+        continue
+      }
+
+      for (const depName of Object.keys(rootOverrides)) {
+        const edge = node.edgesOut.get(depName)
+        const rootNode = tree.root.children.get(depName)
+
+        // safely skip if either edge or rootNode doesn't exist yet
+        if (!edge || !rootNode) {
+          continue
+        }
+
+        const resolvedRootVersion = rootNode.package.version
+        if (!semver.satisfies(resolvedRootVersion, edge.spec)) {
+          edge.detach()
+          node.children.delete(depName)
+        }
+      }
+    }
+  }
+
+  #idealTreePrune () {
+    for (const node of this.idealTree.inventory.values()) {
+      if (node.extraneous) {
+        node.parent = null
+      }
+    }
+  }
+
+  #pruneFailedOptional () {
+    for (const node of this.#loadFailures) {
+      if (!node.optional) {
+        throw node.errors[0]
+      }
+
+      const set = optionalSet(node)
+      for (const node of set) {
+        node.inert = true
+      }
+    }
+  }
+
+  async prune (options = {}) {
+    // allow the user to set options on the ctor as well.
+    // XXX: deprecate separate method options objects.
+    options = { ...this.options, ...options }
+
+    await this.buildIdealTree(options)
+
+    this.#idealTreePrune()
+
+    if (!this.options.workspacesEnabled) {
+      const excludeNodes = this.excludeWorkspacesDependencySet(this.idealTree)
+      for (const node of this.idealTree.inventory.values()) {
+        if (
+          node.parent !== null
+          && !node.isProjectRoot
+          && !excludeNodes.has(node)
+          && !node.inert
+        ) {
+          this[_addNodeToTrashList](node)
+        }
+      }
+    }
+
+    return this.reify(options)
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/index.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..582cad68dab44fda888d06682ae5376473c4bfef
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/index.js
@@ -0,0 +1,310 @@
+// The arborist manages three trees:
+// - actual
+// - virtual
+// - ideal
+//
+// The actual tree is what's present on disk in the node_modules tree
+// and elsewhere that links may extend.
+//
+// The virtual tree is loaded from metadata (package.json and lock files).
+//
+// The ideal tree is what we WANT that actual tree to become.  This starts
+// with the virtual tree, and then applies the options requesting
+// add/remove/update actions.
+//
+// To reify a tree, we calculate a diff between the ideal and actual trees,
+// and then turn the actual tree into the ideal tree by taking the actions
+// required.  At the end of the reification process, the actualTree is
+// updated to reflect the changes.
+//
+// Each tree has an Inventory at the root.  Shrinkwrap is tracked by Arborist
+// instance.  It always refers to the actual tree, but is updated (and written
+// to disk) on reification.
+
+// Each of the mixin "classes" adds functionality, but are not dependent on
+// constructor call order.  So, we just load them in an array, and build up
+// the base class, so that the overall voltron class is easier to test and
+// cover, and separation of concerns can be maintained.
+
+const { resolve } = require('node:path')
+const { homedir } = require('node:os')
+const { depth } = require('treeverse')
+const mapWorkspaces = require('@npmcli/map-workspaces')
+const { log, time } = require('proc-log')
+const { saveTypeMap } = require('../add-rm-pkg-deps.js')
+const AuditReport = require('../audit-report.js')
+const relpath = require('../relpath.js')
+const PackumentCache = require('../packument-cache.js')
+
+const mixins = [
+  require('../tracker.js'),
+  require('./build-ideal-tree.js'),
+  require('./load-actual.js'),
+  require('./load-virtual.js'),
+  require('./rebuild.js'),
+  require('./reify.js'),
+  require('./isolated-reifier.js'),
+]
+
+const _setWorkspaces = Symbol.for('setWorkspaces')
+const Base = mixins.reduce((a, b) => b(a), require('node:events'))
+
+// if it's 1, 2, or 3, set it explicitly that.
+// if undefined or null, set it null
+// otherwise, throw.
+const lockfileVersion = lfv => {
+  if (lfv === 1 || lfv === 2 || lfv === 3) {
+    return lfv
+  }
+
+  if (lfv === undefined || lfv === null) {
+    return null
+  }
+
+  throw new TypeError('Invalid lockfileVersion config: ' + lfv)
+}
+
+class Arborist extends Base {
+  constructor (options = {}) {
+    const timeEnd = time.start('arborist:ctor')
+    super(options)
+
+    // normalize trailing slash
+    const registry = options.registry || 'https://registry.npmjs.org'
+    options.registry = this.registry = registry.replace(/(?<!\/)\/+$/, '') + '/'
+
+    // TODO as we consolidate constructors it's more apparent that we are not parsing options and using this.options consistently
+    const {
+      actualTree,
+      global,
+      idealTree = null,
+      installLinks = false,
+      legacyPeerDeps = false,
+      virtualTree,
+      workspaces,
+    } = options
+
+    if (workspaces?.length && global) {
+      throw new Error('Cannot operate on workspaces in global mode')
+    }
+
+    // the tree of nodes on disk
+    this.actualTree = actualTree
+    this.idealTree = idealTree
+    this.installLinks = installLinks
+    this.legacyPeerDeps = legacyPeerDeps
+    // the virtual tree we load from a shrinkwrap
+    this.virtualTree = virtualTree
+
+    this.options = {
+      nodeVersion: process.version,
+      ...options,
+      Arborist: this.constructor,
+      binLinks: 'binLinks' in options ? !!options.binLinks : true,
+      cache: options.cache || `${homedir()}/.npm/_cacache`,
+      dryRun: !!options.dryRun,
+      formatPackageLock: 'formatPackageLock' in options ? !!options.formatPackageLock : true,
+      force: !!options.force,
+      global: !!options.global,
+      ignoreScripts: !!options.ignoreScripts,
+      installStrategy: options.global ? 'shallow' : (options.installStrategy ? options.installStrategy : 'hoisted'),
+      lockfileVersion: lockfileVersion(options.lockfileVersion),
+      packageLockOnly: !!options.packageLockOnly,
+      packumentCache: options.packumentCache || new PackumentCache(),
+      path: options.path || '.',
+      rebuildBundle: 'rebuildBundle' in options ? !!options.rebuildBundle : true,
+      replaceRegistryHost: options.replaceRegistryHost,
+      savePrefix: 'savePrefix' in options ? options.savePrefix : '^',
+      scriptShell: options.scriptShell,
+      usePackageLock: 'packageLock' in options ? options.packageLock : true,
+      workspaces: options.workspaces || [],
+      workspacesEnabled: options.workspacesEnabled !== false,
+    }
+    // TODO we only ever look at this.options.replaceRegistryHost, not
+    // this.replaceRegistryHost.  Defaulting needs to be written back to
+    // this.options to work properly
+    this.replaceRegistryHost = this.options.replaceRegistryHost =
+      (!this.options.replaceRegistryHost || this.options.replaceRegistryHost === 'npmjs') ?
+        'registry.npmjs.org' : this.options.replaceRegistryHost
+
+    if (options.saveType && !saveTypeMap.get(options.saveType)) {
+      throw new Error(`Invalid saveType ${options.saveType}`)
+    }
+    this.cache = resolve(this.options.cache)
+    this.diff = null
+    this.path = resolve(this.options.path)
+    this.scriptsRun = new Set()
+    timeEnd()
+  }
+
+  // TODO: We should change these to static functions instead
+  //   of methods for the next major version
+
+  // Get the actual nodes corresponding to a root node's child workspaces,
+  // given a list of workspace names.
+  workspaceNodes (tree, workspaces) {
+    const wsMap = tree.workspaces
+    if (!wsMap) {
+      log.warn('workspaces', 'filter set, but no workspaces present')
+      return []
+    }
+
+    const nodes = []
+    for (const name of workspaces) {
+      const path = wsMap.get(name)
+      if (!path) {
+        log.warn('workspaces', `${name} in filter set, but not in workspaces`)
+        continue
+      }
+
+      const loc = relpath(tree.realpath, path)
+      const node = tree.inventory.get(loc)
+
+      if (!node) {
+        log.warn('workspaces', `${name} in filter set, but no workspace folder present`)
+        continue
+      }
+
+      nodes.push(node)
+    }
+
+    return nodes
+  }
+
+  // returns a set of workspace nodes and all their deps
+  // TODO why is includeWorkspaceRoot a param?
+  // TODO why is workspaces a param?
+  workspaceDependencySet (tree, workspaces, includeWorkspaceRoot) {
+    const wsNodes = this.workspaceNodes(tree, workspaces)
+    if (includeWorkspaceRoot) {
+      for (const edge of tree.edgesOut.values()) {
+        if (edge.type !== 'workspace' && edge.to) {
+          wsNodes.push(edge.to)
+        }
+      }
+    }
+    const wsDepSet = new Set(wsNodes)
+    const extraneous = new Set()
+    for (const node of wsDepSet) {
+      for (const edge of node.edgesOut.values()) {
+        const dep = edge.to
+        if (dep) {
+          wsDepSet.add(dep)
+          if (dep.isLink) {
+            wsDepSet.add(dep.target)
+          }
+        }
+      }
+      for (const child of node.children.values()) {
+        if (child.extraneous) {
+          extraneous.add(child)
+        }
+      }
+    }
+    for (const extra of extraneous) {
+      wsDepSet.add(extra)
+    }
+
+    return wsDepSet
+  }
+
+  // returns a set of root dependencies, excluding dependencies that are
+  // exclusively workspace dependencies
+  excludeWorkspacesDependencySet (tree) {
+    const rootDepSet = new Set()
+    depth({
+      tree,
+      visit: node => {
+        for (const { to } of node.edgesOut.values()) {
+          if (!to || to.isWorkspace) {
+            continue
+          }
+          for (const edgeIn of to.edgesIn.values()) {
+            if (edgeIn.from.isRoot || rootDepSet.has(edgeIn.from)) {
+              rootDepSet.add(to)
+            }
+          }
+        }
+        return node
+      },
+      filter: node => node,
+      getChildren: (node, tree) =>
+        [...tree.edgesOut.values()].map(edge => edge.to),
+    })
+    return rootDepSet
+  }
+
+  async [_setWorkspaces] (node) {
+    const workspaces = await mapWorkspaces({
+      cwd: node.path,
+      pkg: node.package,
+    })
+
+    if (node && workspaces.size) {
+      node.workspaces = workspaces
+    }
+
+    return node
+  }
+
+  async audit (options = {}) {
+    this.addTracker('audit')
+    if (this.options.global) {
+      throw Object.assign(
+        new Error('`npm audit` does not support testing globals'),
+        { code: 'EAUDITGLOBAL' }
+      )
+    }
+
+    // allow the user to set options on the ctor as well.
+    // XXX: deprecate separate method options objects.
+    options = { ...this.options, ...options }
+
+    const timeEnd = time.start('audit')
+    let tree
+    if (options.packageLock === false) {
+      // build ideal tree
+      await this.loadActual(options)
+      await this.buildIdealTree()
+      tree = this.idealTree
+    } else {
+      tree = await this.loadVirtual()
+    }
+    if (this.options.workspaces.length) {
+      options.filterSet = this.workspaceDependencySet(
+        tree,
+        this.options.workspaces,
+        this.options.includeWorkspaceRoot
+      )
+    }
+    if (!options.workspacesEnabled) {
+      options.filterSet =
+        this.excludeWorkspacesDependencySet(tree)
+    }
+    this.auditReport = await AuditReport.load(tree, options)
+    const ret = options.fix ? this.reify(options) : this.auditReport
+    timeEnd()
+    this.finishTracker('audit')
+    return ret
+  }
+
+  async dedupe (options = {}) {
+    // allow the user to set options on the ctor as well.
+    // XXX: deprecate separate method options objects.
+    options = { ...this.options, ...options }
+    const tree = await this.loadVirtual().catch(() => this.loadActual())
+    const names = []
+    for (const name of tree.inventory.query('name')) {
+      if (tree.inventory.query('name', name).size > 1) {
+        names.push(name)
+      }
+    }
+    return this.reify({
+      ...options,
+      preferDedupe: true,
+      update: { names },
+    })
+  }
+}
+
+module.exports = Arborist
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js
new file mode 100644
index 0000000000000000000000000000000000000000..510216d185a6464992a223143f632f36f741b8be
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js
@@ -0,0 +1,477 @@
+const { mkdirSync } = require('node:fs')
+const pacote = require('pacote')
+const { join } = require('node:path')
+const { depth } = require('treeverse')
+const crypto = require('node:crypto')
+const { IsolatedNode, IsolatedLink } = require('../isolated-classes.js')
+
+// generate short hash key based on the dependency tree starting at this node
+const getKey = (startNode) => {
+  const deps = []
+  const branch = []
+  depth({
+    tree: startNode,
+    getChildren: node => node.dependencies,
+    visit: node => {
+      branch.push(`${node.packageName}@${node.version}`)
+      deps.push(`${branch.join('->')}::${node.resolved}`)
+    },
+    leave: () => {
+      branch.pop()
+    },
+  })
+  deps.sort()
+  // TODO these replaces were originally to deal with node 14 not supporting base64url and likely don't need to happen anymore
+  // Changing this is a pretty significant breaking change, but removing parts of the hash increases collision possibilities (even if slight).
+  const hash = crypto.createHash('shake256', { outputLength: 16 })
+    .update(deps.join(','))
+    .digest('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/m, '')
+  return `${startNode.packageName}@${startNode.version}-${hash}`
+}
+
+module.exports = cls => class IsolatedReifier extends cls {
+  #externalProxies = new Map()
+  #omit = new Set()
+  #rootDeclaredDeps = new Set()
+  #processedEdges = new Set()
+  #workspaceProxies = new Map()
+
+  #generateChild (node, location, pkg, isInStore, root) {
+    const newChild = new IsolatedNode({
+      isInStore,
+      location,
+      name: node.packageName || node.name,
+      optional: node.optional,
+      package: pkg,
+      parent: root,
+      path: join(this.idealGraph.localPath, location),
+      resolved: node.resolved,
+      root,
+    })
+    // XXX top is from place-dep not lib/node.js
+    newChild.top = { path: this.idealGraph.localPath }
+    root.children.set(newChild.location, newChild)
+    root.inventory.set(newChild.location, newChild)
+  }
+
+  /**
+   * Create an ideal graph.
+   *
+   * An implementation of npm RFC-0042
+   * https://github.com/npm/rfcs/blob/main/accepted/0042-isolated-mode.md
+   *
+   * This entire file should be considered technical debt that will be resolved with an Arborist refactor or rewrite.
+   * Embedded logic in Nodes and Links, and the incremental state of building trees and reifying contains too many assumptions to do a linked mode properly.
+   *
+   * Instead, this approach takes a tree built from build-ideal-tree, and returns a new tree-like structure without the embedded logic of Node and Link classes.
+   *
+   * Since the RFC requires leaving the package-lock in place, this approach temporarily replaces the tree state for a couple of steps of reifying.
+   *
+   **/
+  async makeIdealGraph () {
+    const idealTree = this.idealTree
+    this.#omit = new Set(this.options.omit)
+    const omit = this.#omit
+
+    // npm auto-creates 'workspace' edges from root to all workspaces.
+    // For isolated/linked mode, only include workspaces that root explicitly declares as dependencies.
+    // When omitting dep types, exclude those from the declared set so their workspaces aren't hoisted.
+    const rootPkg = idealTree.package
+    this.#rootDeclaredDeps = new Set(Object.keys(Object.assign({},
+      rootPkg.dependencies,
+      (!omit.has('dev') && rootPkg.devDependencies),
+      (!omit.has('optional') && rootPkg.optionalDependencies),
+      (!omit.has('peer') && rootPkg.peerDependencies)
+    )))
+
+    // XXX this sometimes acts like a node too
+    this.idealGraph = {
+      external: [],
+      isProjectRoot: true,
+      localLocation: idealTree.location,
+      localPath: idealTree.path,
+      path: idealTree.path,
+    }
+    this.counter = 0
+
+    this.idealGraph.workspaces = await Promise.all(Array.from(idealTree.fsChildren.values(), w => this.#workspaceProxy(w)))
+    const processed = new Set()
+    const queue = [idealTree, ...idealTree.fsChildren]
+    while (queue.length !== 0) {
+      const next = queue.pop()
+      if (processed.has(next.location)) {
+        continue
+      }
+      processed.add(next.location)
+      next.edgesOut.forEach(edge => {
+        if (edge.to && !(next.package.bundleDependencies || next.package.bundledDependencies || []).includes(edge.to.name) && !edge.to.shouldOmit?.(omit)) {
+          queue.push(edge.to)
+        }
+      })
+      // local `file:` deps are in fsChildren but are not workspaces.
+      // they are already handled as workspace-like proxies above and should not go through the external/store extraction path.
+      // Links with file: resolved paths (from `npm link`) should also be treated as local dependencies and symlinked directly instead of being extracted into the store.
+      const isLocalFileDep = next.isLink && next.resolved?.startsWith('file:')
+      if (isLocalFileDep && !idealTree.fsChildren.has(next) && !idealTree.fsChildren.has(next.target)) {
+        this.idealGraph.workspaces.push(await this.#workspaceProxy(next.target))
+      } else if (!next.isProjectRoot && !next.isWorkspace && !next.inert && !idealTree.fsChildren.has(next) && !idealTree.fsChildren.has(next.target)) {
+        this.idealGraph.external.push(await this.#externalProxy(next))
+      }
+    }
+
+    await this.#assignCommonProperties(idealTree, this.idealGraph)
+  }
+
+  async #workspaceProxy (node) {
+    if (this.#workspaceProxies.has(node)) {
+      return this.#workspaceProxies.get(node)
+    }
+    const result = {}
+    // XXX this goes recursive if we don't set here because assignCommonProperties also calls this.#workspaceProxy
+    this.#workspaceProxies.set(node, result)
+    result.localLocation = node.location
+    result.localPath = node.path
+    result.isWorkspace = true
+    result.resolved = node.resolved
+    await this.#assignCommonProperties(node, result)
+    return result
+  }
+
+  async #externalProxy (node) {
+    if (this.#externalProxies.has(node)) {
+      return this.#externalProxies.get(node)
+    }
+    const result = {}
+    // XXX this goes recursive if we don't set here because assignCommonProperties also calls this.#externalProxy
+    this.#externalProxies.set(node, result)
+    await this.#assignCommonProperties(node, result, !node.hasShrinkwrap)
+    if (node.hasShrinkwrap) {
+      const dir = join(
+        node.root.path,
+        'node_modules',
+        '.store',
+        `${node.packageName}@${node.version}`
+      )
+      mkdirSync(dir, { recursive: true })
+      // TODO this approach feels wrong and shouldn't be necessary for shrinkwraps
+      await pacote.extract(node.resolved, dir, {
+        ...this.options,
+        resolved: node.resolved,
+        integrity: node.integrity,
+        // TODO _isRoot
+      })
+      const Arborist = this.constructor
+      const arb = new Arborist({ ...this.options, path: dir })
+      // Make sure that the ideal tree is build as the rest of the algorithm depends on it.
+      await arb.buildIdealTree({
+        complete: false,
+        dev: false,
+      })
+      await arb.makeIdealGraph()
+      this.idealGraph.external.push(...arb.idealGraph.external)
+      for (const edge of arb.idealGraph.external) {
+        edge.root = this.idealGraph
+        edge.id = `${node.id}=>${edge.id}`
+      }
+      result.localDependencies = []
+      result.externalDependencies = arb.idealGraph.externalDependencies
+      result.externalOptionalDependencies = arb.idealGraph.externalOptionalDependencies
+      result.dependencies = [
+        ...result.externalDependencies,
+        ...result.externalOptionalDependencies,
+      ]
+    }
+    result.optional = node.optional
+    result.resolved = node.resolved
+    result.version = node.version
+    return result
+  }
+
+  async #assignCommonProperties (node, result, populateDeps = true) {
+    result.root = this.idealGraph
+    // XXX does anything need this?
+    result.id = this.counter++
+    /* istanbul ignore next - packageName is always set for real packages */
+    result.name = result.isWorkspace ? (node.packageName || node.name) : node.name
+    result.packageName = node.packageName || node.name
+    result.package = { ...node.package }
+    result.package.bundleDependencies = undefined
+
+    if (!populateDeps) {
+      return
+    }
+
+    let edges = [...node.edgesOut.values()].filter(edge =>
+      edge.to?.target &&
+      !(node.package.bundledDependencies || node.package.bundleDependencies)?.includes(edge.to.name)
+    )
+
+    // Only omit edge types for root and workspace nodes (matching shouldOmit scope)
+    if ((node.isProjectRoot || node.isWorkspace) && this.#omit.size) {
+      edges = edges.filter(edge => {
+        if (edge.dev && this.#omit.has('dev')) {
+          return false
+        }
+        if (edge.optional && this.#omit.has('optional')) {
+          return false
+        }
+        if (edge.peer && this.#omit.has('peer')) {
+          return false
+        }
+        return true
+      })
+    }
+
+    let nonOptionalDeps = edges.filter(edge => !edge.optional).map(edge => edge.to.target)
+
+    // npm auto-creates 'workspace' edges from root to all workspaces.
+    // For isolated/linked mode, only include workspaces that root explicitly declares as dependencies.
+    if (node.isProjectRoot) {
+      nonOptionalDeps = nonOptionalDeps.filter(n => !n.isWorkspace || this.#rootDeclaredDeps.has(n.packageName))
+    }
+
+    // When legacyPeerDeps is enabled, peer dep edges are not created on the node.
+    // Resolve them from the tree so they get symlinked in the store.
+    const peerDeps = node.package.peerDependencies
+    if (peerDeps && node.legacyPeerDeps) {
+      const edgeNames = new Set(edges.map(edge => edge.name))
+      for (const peerName in peerDeps) {
+        if (!edgeNames.has(peerName)) {
+          const resolved = node.resolve(peerName)
+          if (resolved && resolved !== node && !resolved.inert) {
+            nonOptionalDeps.push(resolved.target)
+          }
+        }
+      }
+    }
+
+    // local `file:` deps (non-workspace fsChildren) should be treated as local dependencies, not external, so they get symlinked directly instead of being extracted into the store.
+    const isLocal = (n) => n.isWorkspace || node.fsChildren?.has(n)
+    const optionalDeps = edges.filter(edge => edge.optional).map(edge => edge.to.target)
+    result.localDependencies = await Promise.all(nonOptionalDeps.filter(isLocal).map(n => this.#workspaceProxy(n)))
+    result.externalDependencies = await Promise.all(nonOptionalDeps.filter(n => !isLocal(n) && !n.inert).map(n => this.#externalProxy(n)))
+    result.externalOptionalDependencies = await Promise.all(optionalDeps.filter(n => !n.inert).map(n => this.#externalProxy(n)))
+    result.dependencies = [
+      ...result.externalDependencies,
+      ...result.localDependencies,
+      ...result.externalOptionalDependencies,
+    ]
+  }
+
+  async #createBundledTree () {
+    // TODO: make sure that idealTree object exists
+    const idealTree = this.idealTree
+    // TODO: test workspaces having bundled deps
+    const queue = []
+
+    for (const [, edge] of idealTree.edgesOut) {
+      if (edge.to && (idealTree.package.bundleDependencies || idealTree.package.bundledDependencies || []).includes(edge.to.name)) {
+        queue.push({ from: idealTree, to: edge.to })
+      }
+    }
+    for (const child of idealTree.fsChildren) {
+      for (const [, edge] of child.edgesOut) {
+        if (edge.to && (child.package.bundleDependencies || child.package.bundledDependencies || []).includes(edge.to.name)) {
+          queue.push({ from: child, to: edge.to })
+        }
+      }
+    }
+
+    const processed = new Set()
+    const nodes = new Map()
+    const edges = []
+    while (queue.length !== 0) {
+      const nextEdge = queue.pop()
+      const key = `${nextEdge.from.location}=>${nextEdge.to.location}`
+      // should be impossible, unless bundled is duped
+      /* istanbul ignore next */
+      if (processed.has(key)) {
+        continue
+      }
+      processed.add(key)
+      const from = nextEdge.from
+      if (!from.isRoot && !from.isWorkspace) {
+        nodes.set(from.location, { location: from.location, resolved: from.resolved, name: from.name, optional: from.optional, pkg: { ...from.package, bundleDependencies: undefined } })
+      }
+      const to = nextEdge.to
+      nodes.set(to.location, { location: to.location, resolved: to.resolved, name: to.name, optional: to.optional, pkg: { ...to.package, bundleDependencies: undefined } })
+      edges.push({ from: from.isRoot ? 'root' : from.location, to: to.location })
+
+      to.edgesOut.forEach(edge => {
+        // an edge out should always have a to
+        /* istanbul ignore else */
+        if (edge.to) {
+          queue.push({ from: edge.from, to: edge.to })
+        }
+      })
+    }
+    return { edges, nodes }
+  }
+
+  async createIsolatedTree () {
+    await this.makeIdealGraph()
+    const bundledTree = await this.#createBundledTree()
+
+    const root = new IsolatedNode(this.idealGraph)
+    root.root = root
+    root.inventory.set('', root)
+    const processed = new Set()
+    for (const c of this.idealGraph.workspaces) {
+      const wsName = c.packageName
+      // XXX parent? root?
+      const workspace = new IsolatedNode({
+        location: c.localLocation,
+        name: wsName,
+        package: c.package,
+        path: c.localPath,
+        resolved: c.resolved,
+      })
+      root.fsChildren.add(workspace)
+      root.inventory.set(workspace.location, workspace)
+      root.workspaces.set(wsName, workspace.path)
+
+      // Create workspace Link. For root declared deps, link at root node_modules/. For undeclared deps, link at the workspace's own node_modules/ (self-link).
+      const isDeclared = this.#rootDeclaredDeps.has(wsName)
+      const wsLink = new IsolatedLink({
+        location: isDeclared ? join('node_modules', wsName) : join(c.localLocation, 'node_modules', wsName),
+        name: wsName,
+        package: workspace.package,
+        parent: root,
+        path: isDeclared ? join(root.path, 'node_modules', wsName) : join(root.path, c.localLocation, 'node_modules', wsName),
+        realpath: workspace.path,
+        root,
+        target: workspace,
+      })
+      if (!isDeclared) {
+        workspace.children.set(wsName, wsLink)
+      }
+      root.children.set(wsName, wsLink)
+      root.inventory.set(wsLink.location, wsLink)
+      workspace.linksIn.add(wsLink)
+    }
+
+    this.idealGraph.external.forEach(c => {
+      const key = getKey(c)
+      if (processed.has(key)) {
+        return
+      }
+      processed.add(key)
+      const location = join('node_modules', '.store', key, 'node_modules', c.packageName)
+      this.#generateChild(c, location, c.package, true, root)
+    })
+
+    bundledTree.nodes.forEach(node => {
+      this.#generateChild(node, node.location, node.pkg, false, root)
+    })
+
+    bundledTree.edges.forEach(edge => {
+      const from = edge.from === 'root' ? root : root.inventory.get(edge.from)
+      const to = root.inventory.get(edge.to)
+      // Maybe optional should be propagated from the original edge
+      const newEdge = { optional: false, from, to }
+      from.edgesOut.set(to.name, newEdge)
+      to.edgesIn.add(newEdge)
+    })
+
+    this.#processEdges(this.idealGraph, false, root)
+    for (const node of this.idealGraph.workspaces) {
+      this.#processEdges(node, false, root)
+    }
+    return root
+  }
+
+  #processEdges (node, externalEdge, root) {
+    const key = getKey(node)
+    if (this.#processedEdges.has(key)) {
+      return
+    }
+    this.#processedEdges.add(key)
+
+    let from, nmFolder
+    if (externalEdge) {
+      const fromLocation = join('node_modules', '.store', key, 'node_modules', node.packageName)
+      from = root.children.get(fromLocation)
+      nmFolder = join('node_modules', '.store', key, 'node_modules')
+    } else {
+      from = node.isProjectRoot ? root : root.inventory.get(node.localLocation)
+      nmFolder = join(node.localLocation, 'node_modules')
+    }
+    /* istanbul ignore next - strict-peer-deps can exclude nodes from the tree */
+    if (!from) {
+      return
+    }
+
+    for (const dep of node.localDependencies) {
+      this.#processEdges(dep, false, root)
+      // nonOptional, local
+      this.#processDeps(dep, false, false, root, from, nmFolder)
+    }
+    for (const dep of node.externalDependencies) {
+      this.#processEdges(dep, true, root)
+      // nonOptional, external
+      this.#processDeps(dep, false, true, root, from, nmFolder)
+    }
+    for (const dep of node.externalOptionalDependencies) {
+      this.#processEdges(dep, true, root)
+      // optional, external
+      this.#processDeps(dep, true, true, root, from, nmFolder)
+    }
+  }
+
+  #processDeps (dep, optional, external, root, from, nmFolder) {
+    const toKey = getKey(dep)
+
+    let target
+    if (external) {
+      const toLocation = join('node_modules', '.store', toKey, 'node_modules', dep.packageName)
+      target = root.children.get(toLocation)
+    } else {
+      target = root.inventory.get(dep.localLocation)
+    }
+    // TODO: we should no-op is an edge has already been created with the same fromKey and toKey
+    /* istanbul ignore next - strict-peer-deps can exclude nodes from the tree */
+    if (!target) {
+      return
+    }
+
+    if (dep.package.bin) {
+      for (const bn in dep.package.bin) {
+        target.binPaths.push(join(dep.root.localPath, nmFolder, '.bin', bn))
+      }
+    }
+
+    const pkg = {
+      _id: dep.package._id,
+      bin: target.package.bin,
+      bundleDependencies: undefined,
+      deprecated: undefined,
+      scripts: dep.package.scripts,
+      version: dep.package.version,
+    }
+    const link = new IsolatedLink({
+      isStoreLink: true,
+      location: join(nmFolder, dep.name),
+      name: toKey,
+      optional,
+      parent: root,
+      package: pkg,
+      path: join(dep.root.localPath, nmFolder, dep.name),
+      realpath: target.path,
+      resolved: external ? `file:.store/${toKey}/node_modules/${dep.packageName}` : dep.resolved,
+      root,
+      target,
+    })
+    // XXX top is from place-dep not lib/link.js
+    link.top = { path: dep.root.localPath }
+    const newEdge1 = { optional, from, to: link }
+    from.edgesOut.set(dep.name, newEdge1)
+    link.edgesIn.add(newEdge1)
+    const newEdge2 = { optional: false, from: link, to: target }
+    link.edgesOut.set(dep.name, newEdge2)
+    target.edgesIn.add(newEdge2)
+    root.children.set(link.location, link)
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/load-actual.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/load-actual.js
new file mode 100644
index 0000000000000000000000000000000000000000..86a85cac682cc0e8e04ec54c70bdb51ef4d7b6d3
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/load-actual.js
@@ -0,0 +1,429 @@
+// mix-in implementing the loadActual method
+
+const { dirname, join, normalize, relative, resolve } = require('node:path')
+
+const PackageJson = require('@npmcli/package-json')
+const { readdirScoped } = require('@npmcli/fs')
+const { walkUp } = require('walk-up-path')
+const { commonAncestorPath } = require('common-ancestor-path')
+const treeCheck = require('../tree-check.js')
+
+const Shrinkwrap = require('../shrinkwrap.js')
+const calcDepFlags = require('../calc-dep-flags.js')
+const Node = require('../node.js')
+const Link = require('../link.js')
+const realpath = require('../realpath.js')
+
+// public symbols
+const _changePath = Symbol.for('_changePath')
+const _setWorkspaces = Symbol.for('setWorkspaces')
+const _rpcache = Symbol.for('realpathCache')
+const _stcache = Symbol.for('statCache')
+
+module.exports = cls => class ActualLoader extends cls {
+  #actualTree
+  // ensure when walking the tree that we don't call loadTree on the same
+  // actual node more than one time.
+  #actualTreeLoaded = new Set()
+  #actualTreePromise
+
+  // cache of nodes when loading the actualTree, so that we avoid loaded the
+  // same node multiple times when symlinks attack.
+  #cache = new Map()
+  #filter
+
+  // cache of link targets for setting fsParent links
+  // We don't do fsParent as a magic getter/setter, because it'd be too costly
+  // to keep up to date along the walk.
+  // And, we know that it can ONLY be relevant when the node is a target of a
+  // link; otherwise, it'd be in a node_modules folder, so take advantage of
+  // that to limit the scans later.
+  #topNodes = new Set()
+  #transplantFilter
+
+  // public method
+  // TODO remove options param in next semver major
+  async loadActual (options = {}) {
+    // In the past this.actualTree was set as a promise that eventually
+    // resolved, and overwrite this.actualTree with the resolved value.  This
+    // was a problem because virtually no other code expects this.actualTree to
+    // be a promise.  Instead we only set it once resolved, and also return it
+    // from the promise so that it is what's returned from this function when
+    // awaited.
+    if (this.actualTree) {
+      return this.actualTree
+    }
+    if (!this.#actualTreePromise) {
+      // allow the user to set options on the ctor as well.
+      // XXX: deprecate separate method options objects.
+      options = { ...this.options, ...options }
+
+      this.#actualTreePromise = this.#loadActual(options)
+        .then(tree => {
+          // reset all deps to extraneous prior to recalc
+          if (!options.root) {
+            for (const node of tree.inventory.values()) {
+              node.extraneous = true
+            }
+          }
+
+          // only reset root flags if we're not re-rooting,
+          // otherwise leave as-is
+          calcDepFlags(tree, !options.root)
+          this.actualTree = treeCheck(tree)
+          return this.actualTree
+        })
+    }
+    return this.#actualTreePromise
+  }
+
+  // return the promise so that we don't ever have more than one going at the
+  // same time.  This is so that buildIdealTree can default to the actualTree
+  // if no shrinkwrap present, but reify() can still call buildIdealTree and
+  // loadActual in parallel safely.
+
+  async #loadActual (options) {
+    // mostly realpath to throw if the root doesn't exist
+    const {
+      global,
+      filter = () => true,
+      root = null,
+      transplantFilter = () => true,
+      ignoreMissing = false,
+      forceActual = false,
+    } = options
+    this.#filter = filter
+    this.#transplantFilter = transplantFilter
+
+    if (global) {
+      const real = await realpath(this.path, this[_rpcache], this[_stcache])
+      const params = {
+        path: this.path,
+        realpath: real,
+        pkg: {},
+        global,
+        loadOverrides: true,
+      }
+      if (this.path === real) {
+        this.#actualTree = this.#newNode(params)
+      } else {
+        this.#actualTree = await this.#newLink(params)
+      }
+    } else {
+      // not in global mode, hidden lockfile is allowed, load root pkg too
+      this.#actualTree = await this.#loadFSNode({
+        path: this.path,
+        real: await realpath(this.path, this[_rpcache], this[_stcache]),
+        loadOverrides: true,
+      })
+
+      this.#actualTree.assertRootOverrides()
+
+      // if forceActual is set, don't even try the hidden lockfile
+      if (!forceActual) {
+        // Note: hidden lockfile will be rejected if it's not the latest thing
+        // in the folder, or if any of the entries in the hidden lockfile are
+        // missing.
+        const meta = await Shrinkwrap.load({
+          path: this.#actualTree.path,
+          hiddenLockfile: true,
+          resolveOptions: this.options,
+        })
+
+        if (meta.loadedFromDisk) {
+          this.#actualTree.meta = meta
+          // have to load on a new Arborist object, so we don't assign
+          // the virtualTree on this one!  Also, the weird reference is because
+          // we can't easily get a ref to Arborist in this module, without
+          // creating a circular reference, since this class is a mixin used
+          // to build up the Arborist class itself.
+          await new this.constructor({ ...this.options }).loadVirtual({
+            root: this.#actualTree,
+          })
+          await this[_setWorkspaces](this.#actualTree)
+
+          this.#transplant(root)
+          return this.#actualTree
+        }
+      }
+
+      const meta = await Shrinkwrap.load({
+        path: this.#actualTree.path,
+        lockfileVersion: this.options.lockfileVersion,
+        resolveOptions: this.options,
+      })
+      this.#actualTree.meta = meta
+    }
+
+    await this.#loadFSTree(this.#actualTree)
+    await this[_setWorkspaces](this.#actualTree)
+
+    // if there are workspace targets without Link nodes created, load
+    // the targets, so that we know what they are.
+    if (this.#actualTree.workspaces && this.#actualTree.workspaces.size) {
+      const promises = []
+      for (const path of this.#actualTree.workspaces.values()) {
+        if (!this.#cache.has(path)) {
+          // workspace overrides use the root overrides
+          const p = this.#loadFSNode({ path, root: this.#actualTree, useRootOverrides: true })
+            .then(node => this.#loadFSTree(node))
+          promises.push(p)
+        }
+      }
+      await Promise.all(promises)
+    }
+
+    if (!ignoreMissing) {
+      await this.#findMissingEdges()
+    }
+
+    // try to find a node that is the parent in a fs tree sense, but not a
+    // node_modules tree sense, of any link targets.  this allows us to
+    // resolve deps that node will find, but a legacy npm view of the
+    // world would not have noticed.
+    for (const path of this.#topNodes) {
+      const node = this.#cache.get(path)
+      if (node && !node.parent && !node.fsParent) {
+        for (const p of walkUp(dirname(path))) {
+          if (this.#cache.has(p)) {
+            node.fsParent = this.#cache.get(p)
+            break
+          }
+        }
+      }
+    }
+
+    this.#transplant(root)
+
+    if (global) {
+      // need to depend on the children, or else all of them
+      // will end up being flagged as extraneous, since the
+      // global root isn't a "real" project
+      const tree = this.#actualTree
+      const actualRoot = tree.isLink ? tree.target : tree
+      const { dependencies = {} } = actualRoot.package
+      for (const [name, kid] of actualRoot.children.entries()) {
+        const def = kid.isLink ? `file:${kid.realpath}` : '*'
+        dependencies[name] = dependencies[name] || def
+      }
+      actualRoot.package = { ...actualRoot.package, dependencies }
+    }
+    return this.#actualTree
+  }
+
+  #transplant (root) {
+    if (!root || root === this.#actualTree) {
+      return
+    }
+
+    this.#actualTree[_changePath](root.path)
+    for (const node of this.#actualTree.children.values()) {
+      if (!this.#transplantFilter(node)) {
+        node.root = null
+      }
+    }
+
+    root.replace(this.#actualTree)
+    for (const node of this.#actualTree.fsChildren) {
+      node.root = this.#transplantFilter(node) ? root : null
+    }
+
+    this.#actualTree = root
+  }
+
+  async #loadFSNode ({ path, parent, real, root, loadOverrides, useRootOverrides }) {
+    if (!real) {
+      try {
+        real = await realpath(path, this[_rpcache], this[_stcache])
+      } catch (error) {
+        // if realpath fails, just provide a dummy error node
+        return new Node({
+          error,
+          path,
+          realpath: path,
+          parent,
+          root,
+          loadOverrides,
+        })
+      }
+    }
+
+    const cached = this.#cache.get(path)
+    let node
+    // missing edges get a dummy node, assign the parent and return it
+    if (cached && !cached.dummy) {
+      cached.parent = parent
+      return cached
+    } else {
+      const params = {
+        installLinks: this.installLinks,
+        legacyPeerDeps: this.legacyPeerDeps,
+        path,
+        realpath: real,
+        parent,
+        root,
+        loadOverrides,
+      }
+
+      try {
+        const { content: pkg } = await PackageJson.normalize(real)
+        params.pkg = pkg
+        if (useRootOverrides && root.overrides) {
+          params.overrides = root.overrides.getNodeRule({ name: pkg.name, version: pkg.version })
+        }
+      } catch (err) {
+        if (err.code === 'EJSONPARSE') {
+          // TODO @npmcli/package-json should be doing this
+          err.path = join(real, 'package.json')
+        }
+        params.error = err
+      }
+
+      // soldier on if read-package-json raises an error, passing it to the
+      // Node which will attach it to its errors array (Link passes it along to
+      // its target node)
+      if (normalize(path) === real) {
+        node = this.#newNode(params)
+      } else {
+        node = await this.#newLink(params)
+      }
+    }
+    this.#cache.set(path, node)
+    return node
+  }
+
+  #newNode (options) {
+    // check it for an fsParent if it's a tree top.  there's a decent chance
+    // it'll get parented later, making the fsParent scan a no-op, but better
+    // safe than sorry, since it's cheap.
+    const { parent, realpath } = options
+    if (!parent) {
+      this.#topNodes.add(realpath)
+    }
+    return new Node(options)
+  }
+
+  async #newLink (options) {
+    const { realpath } = options
+    this.#topNodes.add(realpath)
+    const target = this.#cache.get(realpath)
+    const link = new Link({ ...options, target })
+
+    if (!target) {
+      // Link set its target itself in this case
+      this.#cache.set(realpath, link.target)
+      // if a link target points at a node outside of the root tree's
+      // node_modules hierarchy, then load that node as well.
+      await this.#loadFSTree(link.target)
+    }
+
+    return link
+  }
+
+  async #loadFSTree (node) {
+    const did = this.#actualTreeLoaded
+    if (!node.isLink && !did.has(node.target.realpath)) {
+      did.add(node.target.realpath)
+      await this.#loadFSChildren(node.target)
+      return Promise.all(
+        [...node.target.children.entries()]
+          .filter(([, kid]) => !did.has(kid.realpath))
+          .map(([, kid]) => this.#loadFSTree(kid))
+      )
+    }
+  }
+
+  // create child nodes for all the entries in node_modules
+  // and attach them to the node as a parent
+  async #loadFSChildren (node) {
+    const nm = resolve(node.realpath, 'node_modules')
+    try {
+      const kids = await readdirScoped(nm).then(paths => paths.map(p => p.replace(/\\/g, '/')))
+      return Promise.all(
+        // ignore . dirs and retired scoped package folders
+        kids.filter(kid => !/^(@[^/]+\/)?\./.test(kid))
+          .filter(kid => this.#filter(node, kid))
+          .map(kid => this.#loadFSNode({
+            parent: node,
+            path: resolve(nm, kid),
+          })))
+    } catch {
+      // error in the readdir is not fatal, just means no kids
+    }
+  }
+
+  async #findMissingEdges () {
+    // try to resolve any missing edges by walking up the directory tree,
+    // checking for the package in each node_modules folder.  stop at the
+    // root directory.
+    // The tricky move here is that we load a "dummy" node for the folder
+    // containing the node_modules folder, so that it can be assigned as
+    // the fsParent.  It's a bad idea to *actually* load that full node,
+    // because people sometimes develop in ~/projects/node_modules/...
+    // so we'd end up loading a massive tree with lots of unrelated junk.
+    const nmContents = new Map()
+    const tree = this.#actualTree
+    for (const node of tree.inventory.values()) {
+      const ancestor = commonAncestorPath(node.realpath, this.path)
+
+      const depPromises = []
+      for (const [name, edge] of node.edgesOut.entries()) {
+        const notMissing = !edge.missing &&
+          !(edge.to && (edge.to.dummy || edge.to.parent !== node))
+        if (notMissing) {
+          continue
+        }
+
+        // start the walk from the dirname, because we would have found
+        // the dep in the loadFSTree step already if it was local.
+        for (const p of walkUp(dirname(node.realpath))) {
+          // only walk as far as the nearest ancestor
+          // this keeps us from going into completely unrelated
+          // places when a project is just missing something, but
+          // allows for finding the transitive deps of link targets.
+          // ie, if it has to go up and back out to get to the path
+          // from the nearest common ancestor, we've gone too far.
+          if (ancestor && /^\.\.(?:[\\/]|$)/.test(relative(ancestor, p))) {
+            break
+          }
+
+          let entries
+          if (!nmContents.has(p)) {
+            entries = await readdirScoped(p + '/node_modules')
+              .catch(() => []).then(paths => paths.map(p => p.replace(/\\/g, '/')))
+            nmContents.set(p, entries)
+          } else {
+            entries = nmContents.get(p)
+          }
+
+          if (!entries.includes(name)) {
+            continue
+          }
+
+          let d
+          if (!this.#cache.has(p)) {
+            d = new Node({ path: p, root: node.root, dummy: true })
+            this.#cache.set(p, d)
+          } else {
+            d = this.#cache.get(p)
+          }
+          if (d.dummy) {
+            // it's a placeholder, so likely would not have loaded this dep,
+            // unless another dep in the tree also needs it.
+            const depPath = normalize(`${p}/node_modules/${name}`)
+            const cached = this.#cache.get(depPath)
+            if (!cached || cached.dummy) {
+              depPromises.push(this.#loadFSNode({
+                path: depPath,
+                root: node.root,
+                parent: d,
+              }).then(node => this.#loadFSTree(node)))
+            }
+          }
+          break
+        }
+      }
+      await Promise.all(depPromises)
+    }
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/load-virtual.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/load-virtual.js
new file mode 100644
index 0000000000000000000000000000000000000000..54eb2679ed957687a5e41123cbc3a25ecdbe2141
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/load-virtual.js
@@ -0,0 +1,277 @@
+const { resolve } = require('node:path')
+// mixin providing the loadVirtual method
+const mapWorkspaces = require('@npmcli/map-workspaces')
+const PackageJson = require('@npmcli/package-json')
+const nameFromFolder = require('@npmcli/name-from-folder')
+
+const consistentResolve = require('../consistent-resolve.js')
+const Shrinkwrap = require('../shrinkwrap.js')
+const Node = require('../node.js')
+const Link = require('../link.js')
+const relpath = require('../relpath.js')
+const calcDepFlags = require('../calc-dep-flags.js')
+const treeCheck = require('../tree-check.js')
+
+const flagsSuspect = Symbol.for('flagsSuspect')
+const setWorkspaces = Symbol.for('setWorkspaces')
+
+module.exports = cls => class VirtualLoader extends cls {
+  #rootOptionProvided
+
+  // public method
+  async loadVirtual (options = {}) {
+    if (this.virtualTree) {
+      return this.virtualTree
+    }
+
+    // allow the user to set reify options on the ctor as well.
+    // XXX: deprecate separate reify() options object.
+    options = { ...this.options, ...options }
+
+    if (options.root && options.root.meta) {
+      await this.#loadFromShrinkwrap(options.root.meta, options.root)
+      return treeCheck(this.virtualTree)
+    }
+
+    const s = await Shrinkwrap.load({
+      path: this.path,
+      lockfileVersion: this.options.lockfileVersion,
+      resolveOptions: this.options,
+    })
+    if (!s.loadedFromDisk && !options.root) {
+      const er = new Error('loadVirtual requires existing shrinkwrap file')
+      throw Object.assign(er, { code: 'ENOLOCK' })
+    }
+
+    // when building the ideal tree, we pass in a root node to this function
+    // otherwise, load it from the root package json or the lockfile
+    const pkg = await PackageJson.normalize(this.path).then(p => p.content).catch(() => s.data.packages[''] || {})
+    // TODO clean this up
+    const {
+      root = await this[setWorkspaces](this.#loadNode('', pkg, true)),
+    } = options
+    this.#rootOptionProvided = options.root
+
+    await this.#loadFromShrinkwrap(s, root)
+    root.assertRootOverrides()
+    return treeCheck(this.virtualTree)
+  }
+
+  async #loadFromShrinkwrap (s, root) {
+    if (!this.#rootOptionProvided) {
+      // root is never any of these things, but might be a brand new
+      // baby Node object that never had its dep flags calculated.
+      root.unsetDepFlags()
+    } else {
+      this[flagsSuspect] = true
+    }
+
+    this.#checkRootEdges(s, root)
+    root.meta = s
+    this.virtualTree = root
+    // separate out link metadata, and create Node objects for nodes
+    const links = new Map()
+    const nodes = new Map([['', root]])
+    for (const [location, meta] of Object.entries(s.data.packages)) {
+      // skip the root because we already got it
+      if (!location) {
+        continue
+      }
+
+      if (meta.link) {
+        links.set(location, meta)
+      } else {
+        nodes.set(location, this.#loadNode(location, meta))
+      }
+    }
+    await this.#resolveLinks(links, nodes)
+    if (!(s.originalLockfileVersion >= 2)) {
+      this.#assignBundles(nodes)
+    }
+    if (this[flagsSuspect]) {
+      // reset all dep flags
+      // can't use inventory here, because virtualTree might not be root
+      for (const node of nodes.values()) {
+        if (node.isRoot || node === this.#rootOptionProvided) {
+          continue
+        }
+        node.resetDepFlags()
+      }
+      calcDepFlags(this.virtualTree, !this.#rootOptionProvided)
+    }
+    return root
+  }
+
+  // check the lockfile deps, and see if they match.  if they do not
+  // then we have to reset dep flags at the end.  for example, if the
+  // user manually edits their package.json file, then we need to know
+  // that the idealTree is no longer entirely trustworthy.
+  #checkRootEdges (s, root) {
+    // loaded virtually from tree, no chance of being out of sync
+    // ancient lockfiles are critically damaged by this process,
+    // so we need to just hope for the best in those cases.
+    if (!s.loadedFromDisk || s.ancientLockfile) {
+      return
+    }
+
+    const lock = s.get('')
+    const prod = lock.dependencies || {}
+    const dev = lock.devDependencies || {}
+    const optional = lock.optionalDependencies || {}
+    const peer = lock.peerDependencies || {}
+    const peerOptional = {}
+
+    if (lock.peerDependenciesMeta) {
+      for (const [name, meta] of Object.entries(lock.peerDependenciesMeta)) {
+        if (meta.optional && peer[name] !== undefined) {
+          peerOptional[name] = peer[name]
+          delete peer[name]
+        }
+      }
+    }
+
+    for (const name of Object.keys(optional)) {
+      delete prod[name]
+    }
+
+    const lockWS = {}
+    const workspaces = mapWorkspaces.virtual({
+      cwd: this.path,
+      lockfile: s.data,
+    })
+
+    for (const [name, path] of workspaces.entries()) {
+      lockWS[name] = `file:${path}`
+    }
+
+    // Should rootNames exclude optional?
+    const rootNames = new Set(root.edgesOut.keys())
+
+    const lockByType = ({ dev, optional, peer, peerOptional, prod, workspace: lockWS })
+
+    // Find anything in shrinkwrap deps that doesn't match root's type or spec
+    for (const type in lockByType) {
+      const deps = lockByType[type]
+      for (const name in deps) {
+        const edge = root.edgesOut.get(name)
+        if (!edge || edge.type !== type || edge.spec !== deps[name]) {
+          return this[flagsSuspect] = true
+        }
+        rootNames.delete(name)
+      }
+    }
+    // Something was in root that's not accounted for in shrinkwrap
+    if (rootNames.size) {
+      return this[flagsSuspect] = true
+    }
+  }
+
+  // links is the set of metadata, and nodes is the map of non-Link nodes
+  // Set the targets to nodes in the set, if we have them (we might not)
+  // XXX build-ideal-tree also has a #resolveLinks, is there overlap?
+  async #resolveLinks (links, nodes) {
+    for (const [location, meta] of links.entries()) {
+      const targetPath = resolve(this.path, meta.resolved)
+      const targetLoc = relpath(this.path, targetPath)
+      const target = nodes.get(targetLoc)
+
+      if (!target) {
+        const err = new Error(
+`Missing target in lock file: "${targetLoc}" is referenced by "${location}" but does not exist.
+To fix:
+1. rm package-lock.json
+2. npm install`
+        )
+        err.code = 'EMISSINGTARGET'
+        throw err
+      }
+
+      const link = this.#loadLink(location, targetLoc, target, meta)
+      nodes.set(location, link)
+      nodes.set(targetLoc, link.target)
+
+      // we always need to read the package.json for link targets
+      // outside node_modules because they can be changed by the local user
+      if (!link.target.parent) {
+        await PackageJson.normalize(link.realpath).then(p => link.target.package = p.content).catch(() => null)
+      }
+    }
+  }
+
+  #assignBundles (nodes) {
+    for (const [location, node] of nodes) {
+      // Skip assignment of parentage for the root package
+      if (!location || node.isLink && !node.target.location) {
+        continue
+      }
+      const { name, parent, package: { inBundle } } = node
+
+      if (!parent) {
+        continue
+      }
+
+      // read inBundle from package because 'package' here is
+      // actually a v2 lockfile metadata entry.
+      // If the *parent* is also bundled, though, or if the parent has
+      // no dependency on it, then we assume that it's being pulled in
+      // just by virtue of its parent or a transitive dep being bundled.
+      const { package: ppkg } = parent
+      const { inBundle: parentBundled } = ppkg
+      if (inBundle && !parentBundled && parent.edgesOut.has(node.name)) {
+        if (!ppkg.bundleDependencies) {
+          ppkg.bundleDependencies = [name]
+        } else {
+          ppkg.bundleDependencies.push(name)
+        }
+      }
+    }
+  }
+
+  #loadNode (location, sw, loadOverrides) {
+    const p = this.virtualTree ? this.virtualTree.realpath : this.path
+    const path = resolve(p, location)
+    // shrinkwrap doesn't include package name unless necessary
+    if (!sw.name) {
+      sw.name = nameFromFolder(path)
+    }
+
+    const node = new Node({
+      installLinks: this.installLinks,
+      legacyPeerDeps: this.legacyPeerDeps,
+      root: this.virtualTree,
+      path,
+      realpath: path,
+      integrity: sw.integrity,
+      resolved: consistentResolve(sw.resolved, this.path, path),
+      pkg: sw,
+      hasShrinkwrap: sw.hasShrinkwrap,
+      loadOverrides,
+      // cast to boolean because they're undefined in the lock file when false
+      extraneous: !!sw.extraneous,
+      devOptional: !!(sw.devOptional || sw.dev || sw.optional),
+      peer: !!sw.peer,
+      optional: !!sw.optional,
+      dev: !!sw.dev,
+    })
+
+    return node
+  }
+
+  #loadLink (location, targetLoc, target) {
+    const path = resolve(this.path, location)
+    const link = new Link({
+      installLinks: this.installLinks,
+      legacyPeerDeps: this.legacyPeerDeps,
+      path,
+      realpath: resolve(this.path, targetLoc),
+      target,
+      pkg: target && target.package,
+    })
+    link.extraneous = target.extraneous
+    link.devOptional = target.devOptional
+    link.peer = target.peer
+    link.optional = target.optional
+    link.dev = target.dev
+    return link
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/rebuild.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/rebuild.js
new file mode 100644
index 0000000000000000000000000000000000000000..23d57bf3161bcb21bcf64eb0a3dfbe6098edd028
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/rebuild.js
@@ -0,0 +1,406 @@
+// Arborist.rebuild({path = this.path}) will do all the binlinks and
+// bundle building needed.  Called by reify, and by `npm rebuild`.
+
+const PackageJson = require('@npmcli/package-json')
+const binLinks = require('bin-links')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const promiseAllRejectLate = require('promise-all-reject-late')
+const runScript = require('@npmcli/run-script')
+const { callLimit: promiseCallLimit } = require('promise-call-limit')
+const { depth: dfwalk } = require('treeverse')
+const { isNodeGypPackage, defaultGypInstallScript } = require('@npmcli/node-gyp')
+const { promiseRetry } = require('@gar/promise-retry')
+const { log, time } = require('proc-log')
+const { resolve } = require('node:path')
+
+const boolEnv = b => b ? '1' : ''
+const sortNodes = (a, b) => (a.depth - b.depth) || localeCompare(a.path, b.path)
+
+const _checkBins = Symbol.for('checkBins')
+
+// defined by reify mixin
+const _handleOptionalFailure = Symbol.for('handleOptionalFailure')
+const _trashList = Symbol.for('trashList')
+
+module.exports = cls => class Builder extends cls {
+  #doHandleOptionalFailure
+  #oldMeta = null
+  #queues = {
+    preinstall: [],
+    install: [],
+    postinstall: [],
+    prepare: [],
+    bin: [],
+  }
+
+  async rebuild ({ nodes, handleOptionalFailure = false } = {}) {
+    // nothing to do if we're not building anything!
+    if (this.options.ignoreScripts && !this.options.binLinks) {
+      return
+    }
+
+    // when building for the first time, as part of reify, we ignore
+    // failures in optional nodes, and just delete them.  however, when
+    // running JUST a rebuild, we treat optional failures as real fails
+    this.#doHandleOptionalFailure = handleOptionalFailure
+
+    if (!nodes) {
+      nodes = await this.#loadDefaultNodes()
+    }
+
+    // separates links nodes so that it can run
+    // prepare scripts and link bins in the expected order
+    const timeEnd = time.start('build')
+
+    const {
+      depNodes,
+      linkNodes,
+    } = this.#retrieveNodesByType(nodes)
+
+    // build regular deps
+    await this.#build(depNodes, {})
+
+    // build link deps
+    if (linkNodes.size) {
+      this.#queues = {
+        preinstall: [],
+        install: [],
+        postinstall: [],
+        prepare: [],
+        bin: [],
+      }
+      await this.#build(linkNodes, { type: 'links' })
+    }
+
+    timeEnd()
+  }
+
+  // if we don't have a set of nodes, then just rebuild
+  // the actual tree on disk.
+  async #loadDefaultNodes () {
+    let nodes
+    const tree = await this.loadActual()
+    let filterSet
+    if (!this.options.workspacesEnabled) {
+      filterSet = this.excludeWorkspacesDependencySet(tree)
+      nodes = tree.inventory.filter(node =>
+        filterSet.has(node) || node.isProjectRoot
+      )
+    } else if (this.options.workspaces.length) {
+      filterSet = this.workspaceDependencySet(
+        tree,
+        this.options.workspaces,
+        this.options.includeWorkspaceRoot
+      )
+      nodes = tree.inventory.filter(node => filterSet.has(node))
+    } else {
+      nodes = tree.inventory.values()
+    }
+    return nodes
+  }
+
+  #retrieveNodesByType (nodes) {
+    const depNodes = new Set()
+    const linkNodes = new Set()
+    const storeNodes = new Set()
+
+    for (const node of nodes) {
+      if (node.isStoreLink) {
+        storeNodes.add(node)
+      } else if (node.isLink) {
+        linkNodes.add(node)
+      } else {
+        depNodes.add(node)
+      }
+    }
+    // Make sure that store linked nodes are processed last.
+    // We can't process store links separately or else lifecycle scripts on
+    // standard nodes might not have bin links yet.
+    for (const node of storeNodes) {
+      depNodes.add(node)
+    }
+
+    // deduplicates link nodes and their targets, avoids
+    // calling lifecycle scripts twice when running `npm rebuild`
+    // ref: https://github.com/npm/cli/issues/2905
+    //
+    // we avoid doing so if global=true since `bin-links` relies
+    // on having the target nodes available in global mode.
+    if (!this.options.global) {
+      for (const node of linkNodes) {
+        depNodes.delete(node.target)
+      }
+    }
+
+    return {
+      depNodes,
+      linkNodes,
+    }
+  }
+
+  async #build (nodes, { type = 'deps' }) {
+    const timeEnd = time.start(`build:${type}`)
+
+    await this.#buildQueues(nodes)
+
+    if (!this.options.ignoreScripts) {
+      await this.#runScripts('preinstall')
+    }
+
+    // links should run prepare scripts and only link bins after that
+    if (type === 'links') {
+      if (!this.options.ignoreScripts) {
+        await this.#runScripts('prepare')
+      }
+    }
+    if (this.options.binLinks) {
+      await this.#linkAllBins()
+    }
+
+    if (!this.options.ignoreScripts) {
+      await this.#runScripts('install')
+      await this.#runScripts('postinstall')
+    }
+
+    timeEnd()
+  }
+
+  async #buildQueues (nodes) {
+    const timeEnd = time.start('build:queue')
+    const set = new Set()
+
+    const promises = []
+    for (const node of nodes) {
+      promises.push(this.#addToBuildSet(node, set))
+
+      // if it has bundle deps, add those too, if rebuildBundle
+      if (this.options.rebuildBundle !== false) {
+        const bd = node.package.bundleDependencies
+        if (bd && bd.length) {
+          dfwalk({
+            tree: node,
+            leave: node => promises.push(this.#addToBuildSet(node, set)),
+            getChildren: node => [...node.children.values()],
+            filter: node => node.inBundle,
+          })
+        }
+      }
+    }
+    await promiseAllRejectLate(promises)
+
+    // now sort into the queues for the 4 things we have to do
+    // run in the same predictable order that buildIdealTree uses
+    // there's no particular reason for doing it in this order rather
+    // than another, but sorting *somehow* makes it consistent.
+    const queue = [...set].sort(sortNodes)
+
+    for (const node of queue) {
+      const { package: { bin, scripts = {} } } = node.target
+      const { preinstall, install, postinstall, prepare } = scripts
+      const tests = { bin, preinstall, install, postinstall, prepare }
+      for (const [key, has] of Object.entries(tests)) {
+        if (has) {
+          this.#queues[key].push(node)
+        }
+      }
+    }
+    timeEnd()
+  }
+
+  async [_checkBins] (node) {
+    // if the node is a global top, and we're not in force mode, then
+    // any existing bins need to either be missing, or a symlink into
+    // the node path.  Otherwise a package can have a preinstall script
+    // that unlinks something, to allow them to silently overwrite system
+    // binaries, which is unsafe and insecure.
+    if (!node.globalTop || this.options.force) {
+      return
+    }
+    const { path, package: pkg } = node
+    await binLinks.checkBins({ pkg, path, top: true, global: true })
+  }
+
+  async #addToBuildSet (node, set, refreshed = false) {
+    if (set.has(node)) {
+      return
+    }
+
+    if (this.#oldMeta === null) {
+      const { root: { meta } } = node
+      this.#oldMeta = meta && meta.loadedFromDisk &&
+        !(meta.originalLockfileVersion >= 2)
+    }
+
+    const { package: pkg, hasInstallScript } = node.target
+    const { gypfile, bin, scripts = {} } = pkg
+
+    const { preinstall, install, postinstall, prepare } = scripts
+    const anyScript = preinstall || install || postinstall || prepare
+    if (!refreshed && !anyScript && (hasInstallScript || this.#oldMeta)) {
+      // we either have an old metadata (and thus might have scripts)
+      // or we have an indication that there's install scripts (but
+      // don't yet know what they are) so we have to load the package.json
+      // from disk to see what the deal is.  Failure here just means
+      // no scripts to add, probably borked package.json.
+      // add to the set then remove while we're reading the pj, so we
+      // don't accidentally hit it multiple times.
+      set.add(node)
+      const { content: pkg } = await PackageJson.normalize(node.path).catch(() => {
+        return { content: {} }
+      })
+      set.delete(node)
+
+      const { scripts = {} } = pkg
+      node.package.scripts = scripts
+      return this.#addToBuildSet(node, set, true)
+    }
+
+    // Rebuild node-gyp dependencies lacking an install or preinstall script
+    // note that 'scripts' might be missing entirely, and the package may
+    // set gypfile:false to avoid this automatic detection.
+    const isGyp = gypfile !== false &&
+      !install &&
+      !preinstall &&
+      await isNodeGypPackage(node.path)
+
+    if (bin || preinstall || install || postinstall || prepare || isGyp) {
+      if (bin) {
+        await this[_checkBins](node)
+      }
+      if (isGyp) {
+        scripts.install = defaultGypInstallScript
+        node.package.scripts = scripts
+      }
+      set.add(node)
+    }
+  }
+
+  async #runScripts (event) {
+    const queue = this.#queues[event]
+
+    if (!queue.length) {
+      return
+    }
+
+    const timeEnd = time.start(`build:run:${event}`)
+    const stdio = this.options.foregroundScripts ? 'inherit' : 'pipe'
+    const limit = this.options.foregroundScripts ? 1 : undefined
+    await promiseCallLimit(queue.map(node => async () => {
+      const {
+        path,
+        integrity,
+        resolved,
+        optional,
+        peer,
+        dev,
+        devOptional,
+        package: pkg,
+        location,
+      } = node.target
+
+      // skip any that we know we'll be deleting
+      // or links to store entries (their scripts run on the store
+      // entry itself, not through the link)
+      if (this[_trashList].has(path) || (node.isLink && node.target?.isInStore)) {
+        return
+      }
+
+      const timeEndLocation = time.start(`build:run:${event}:${location}`)
+      log.info('run', pkg._id, event, location, pkg.scripts[event])
+      const env = {
+        npm_package_resolved: resolved,
+        npm_package_integrity: integrity,
+        npm_package_json: resolve(path, 'package.json'),
+        npm_package_optional: boolEnv(optional),
+        npm_package_dev: boolEnv(dev),
+        npm_package_peer: boolEnv(peer),
+        npm_package_dev_optional:
+          boolEnv(devOptional && !dev && !optional),
+      }
+      const runOpts = {
+        event,
+        path,
+        pkg,
+        stdio,
+        env,
+        scriptShell: this.options.scriptShell,
+      }
+      const p = runScript(runOpts).catch(er => {
+        const { code, signal } = er
+        log.info('run', pkg._id, event, { code, signal })
+        throw er
+      }).then(({ args, code, signal, stdout, stderr }) => {
+        this.scriptsRun.add({
+          pkg,
+          path,
+          event,
+          // I do not know why this needs to be on THIS line but refactoring
+          // this function would be quite a process
+          // eslint-disable-next-line promise/always-return
+          cmd: args && args[args.length - 1],
+          env,
+          code,
+          signal,
+          stdout,
+          stderr,
+        })
+        log.info('run', pkg._id, event, { code, signal })
+      })
+
+      await (this.#doHandleOptionalFailure
+        ? this[_handleOptionalFailure](node, p)
+        : p)
+
+      timeEndLocation()
+    }), { limit })
+    timeEnd()
+  }
+
+  async #linkAllBins () {
+    const queue = this.#queues.bin
+    if (!queue.length) {
+      return
+    }
+
+    const timeEnd = time.start('build:link')
+    const promises = []
+    // sort the queue by node path, so that the module-local collision
+    // detector in bin-links will always resolve the same way.
+    for (const node of queue.sort(sortNodes)) {
+      // TODO these run before they're awaited
+      promises.push(this.#createBinLinks(node))
+    }
+
+    await promiseAllRejectLate(promises)
+    timeEnd()
+  }
+
+  async #createBinLinks (node) {
+    if (this[_trashList].has(node.path)) {
+      return
+    }
+
+    const timeEnd = time.start(`build:link:${node.location}`)
+
+    // On Windows, antivirus/indexer can transiently lock files, causing EPERM/EACCES/EBUSY on the rename inside write-file-atomic (used by bin-links/fix-bin.js), so, retry with backoff.
+    const p = promiseRetry((retry) => binLinks({
+      pkg: node.package,
+      path: node.path,
+      top: !!(node.isTop || node.globalTop),
+      force: this.options.force,
+      global: !!node.globalTop,
+    }).catch(/* istanbul ignore next - Windows-only transient antivirus locks */ err => {
+      if (process.platform === 'win32' &&
+          (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'EBUSY')) {
+        return retry(err)
+      }
+      throw err
+    }), { retries: 5, minTimeout: 500 })
+
+    await (this.#doHandleOptionalFailure
+      ? this[_handleOptionalFailure](node, p)
+      : p)
+
+    timeEnd()
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js
new file mode 100644
index 0000000000000000000000000000000000000000..24b46287dafcbe696d516b175efe96851834e7fe
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js
@@ -0,0 +1,1627 @@
+// mixin implementing the reify method
+const PackageJson = require('@npmcli/package-json')
+const hgi = require('hosted-git-info')
+const npa = require('npm-package-arg')
+const packageContents = require('@npmcli/installed-package-contents')
+const pacote = require('pacote')
+const promiseAllRejectLate = require('promise-all-reject-late')
+const runScript = require('@npmcli/run-script')
+const { callLimit: promiseCallLimit } = require('promise-call-limit')
+const { depth: dfwalk } = require('treeverse')
+const { dirname, resolve, relative, join, sep } = require('node:path')
+const { log, time } = require('proc-log')
+const { existsSync } = require('node:fs')
+const { lstat, mkdir, readdir, rm, symlink } = require('node:fs/promises')
+const { moveFile } = require('@npmcli/fs')
+const { subset, intersects } = require('semver')
+const { walkUp } = require('walk-up-path')
+
+const AuditReport = require('../audit-report.js')
+const Diff = require('../diff.js')
+const calcDepFlags = require('../calc-dep-flags.js')
+const debug = require('../debug.js')
+const onExit = require('../signal-handling.js')
+const optionalSet = require('../optional-set.js')
+const relpath = require('../relpath.js')
+const retirePath = require('../retire-path.js')
+const treeCheck = require('../tree-check.js')
+const { defaultLockfileVersion } = require('../shrinkwrap.js')
+const { saveTypeMap, hasSubKey } = require('../add-rm-pkg-deps.js')
+const { IsolatedNode, IsolatedLink } = require('../isolated-classes.js')
+
+// Part of steps (steps need refactoring before we can do anything about these)
+const _retireShallowNodes = Symbol.for('retireShallowNodes')
+const _loadBundlesAndUpdateTrees = Symbol.for('loadBundlesAndUpdateTrees')
+const _submitQuickAudit = Symbol('submitQuickAudit')
+const _unpackNewModules = Symbol.for('unpackNewModules')
+const _build = Symbol.for('build')
+
+// shared by rebuild mixin
+const _trashList = Symbol.for('trashList')
+const _handleOptionalFailure = Symbol.for('handleOptionalFailure')
+const _loadTrees = Symbol.for('loadTrees')
+// defined by rebuild mixin
+const _checkBins = Symbol.for('checkBins')
+
+// shared symbols for swapping out when testing
+// TODO tests should not be this deep into internals
+const _diffTrees = Symbol.for('diffTrees')
+const _createSparseTree = Symbol.for('createSparseTree')
+const _loadShrinkwrapsAndUpdateTrees = Symbol.for('loadShrinkwrapsAndUpdateTrees')
+const _reifyNode = Symbol.for('reifyNode')
+const _updateAll = Symbol.for('updateAll')
+const _updateNames = Symbol.for('updateNames')
+const _moveContents = Symbol.for('moveContents')
+const _moveBackRetiredUnchanged = Symbol.for('moveBackRetiredUnchanged')
+const _removeTrash = Symbol.for('removeTrash')
+const _renamePath = Symbol.for('renamePath')
+const _rollbackRetireShallowNodes = Symbol.for('rollbackRetireShallowNodes')
+const _rollbackCreateSparseTree = Symbol.for('rollbackCreateSparseTree')
+const _rollbackMoveBackRetiredUnchanged = Symbol.for('rollbackMoveBackRetiredUnchanged')
+const _saveIdealTree = Symbol.for('saveIdealTree')
+
+// defined by build-ideal-tree mixin
+const _resolvedAdd = Symbol.for('resolvedAdd')
+// used by build-ideal-tree mixin
+const _addNodeToTrashList = Symbol.for('addNodeToTrashList')
+
+module.exports = cls => class Reifier extends cls {
+  #bundleMissing = new Set() // child nodes we'd EXPECT to be included in a bundle, but aren't
+  #bundleUnpacked = new Set() // the nodes we unpack to read their bundles
+  #nmValidated = new Set()
+  #omit
+  #retiredPaths = {}
+  #retiredUnchanged = {}
+  #shrinkwrapInflated = new Set()
+  #sparseTreeDirs = new Set()
+  #sparseTreeRoots = new Set()
+  #linkedActualForDiff = null
+
+  constructor (options) {
+    super(options)
+
+    this[_trashList] = new Set()
+  }
+
+  // public method
+  async reify (options = {}) {
+    const linked = (options.installStrategy || this.options.installStrategy) === 'linked'
+
+    if (this.options.packageLockOnly && this.options.global) {
+      const er = new Error('cannot generate lockfile for global packages')
+      er.code = 'ESHRINKWRAPGLOBAL'
+      throw er
+    }
+
+    this.#omit = new Set(options.omit)
+
+    // start tracker block
+    this.addTracker('reify')
+    const timeEnd = time.start('reify')
+    // don't create missing dirs on dry runs
+    if (!this.options.packageLockOnly && !this.options.dryRun) {
+      // we do NOT want to set ownership on this folder, especially
+      // recursively, because it can have other side effects to do that
+      // in a project directory.  We just want to make it if it's missing.
+      await mkdir(resolve(this.path), { recursive: true })
+
+      // do not allow the top-level node_modules to be a symlink
+      await this.#validateNodeModules(resolve(this.path, 'node_modules'))
+    }
+    await this[_loadTrees](options)
+
+    const oldTree = this.idealTree
+    if (linked) {
+      // swap out the tree with the isolated tree
+      // this is currently technical debt which will be resolved in a refactor
+      // of Node/Link trees
+      log.warn('reify', 'The "linked" install strategy is EXPERIMENTAL and may contain bugs.')
+      this.idealTree = await this.createIsolatedTree()
+      if (this.actualTree) {
+        this.#linkedActualForDiff = this.#buildLinkedActualForDiff(
+          this.idealTree, this.actualTree
+        )
+      }
+    }
+    await this[_diffTrees]()
+    await this.#reifyPackages()
+    if (linked) {
+      await this.#cleanOrphanedStoreEntries()
+      // swap back in the idealTree
+      // so that the lockfile is preserved
+      this.idealTree = oldTree
+    }
+    await this[_saveIdealTree](options)
+    this.#linkedActualForDiff = null
+    // clean inert
+    for (const node of this.idealTree.inventory.values()) {
+      if (node.inert) {
+        node.parent = null
+      }
+    }
+    // clean up any trash that is still in the tree
+    for (const path of this[_trashList]) {
+      const loc = relpath(this.idealTree.realpath, path)
+      const node = this.idealTree.inventory.get(loc)
+      if (node && node.root === this.idealTree) {
+        node.parent = null
+      }
+    }
+
+    // if we filtered to only certain nodes, then anything ELSE needs
+    // to be untouched in the resulting actual tree, even if it differs
+    // in the idealTree.  Copy over anything that was in the actual and
+    // was not changed, delete anything in the ideal and not actual.
+    // Then we move the entire idealTree over to this.actualTree, and
+    // save the hidden lockfile.
+    if (this.diff && this.diff.filterSet.size && !linked) {
+      const reroot = new Set()
+
+      const { filterSet } = this.diff
+      const seen = new Set()
+      for (const [loc, ideal] of this.idealTree.inventory.entries()) {
+        seen.add(loc)
+
+        // if it's an ideal node from the filter set, then skip it
+        // because we already made whatever changes were necessary
+        if (filterSet.has(ideal)) {
+          continue
+        }
+
+        // otherwise, if it's not in the actualTree, then it's not a thing
+        // that we actually added.  And if it IS in the actualTree, then
+        // it's something that we left untouched, so we need to record
+        // that.
+        const actual = this.actualTree.inventory.get(loc)
+        if (!actual) {
+          ideal.root = null
+        } else {
+          if ([...actual.linksIn].some(link => filterSet.has(link))) {
+            seen.add(actual.location)
+            continue
+          }
+          const { realpath, isLink } = actual
+          if (isLink && ideal.isLink && ideal.realpath === realpath) {
+            continue
+          } else {
+            reroot.add(actual)
+          }
+        }
+      }
+
+      // now find any actual nodes that may not be present in the ideal
+      // tree, but were left behind by virtue of not being in the filter
+      for (const [loc, actual] of this.actualTree.inventory.entries()) {
+        if (seen.has(loc)) {
+          continue
+        }
+        seen.add(loc)
+
+        // we know that this is something that ISN'T in the idealTree,
+        // or else we will have addressed it in the previous loop.
+        // If it's in the filterSet, that means we intentionally removed
+        // it, so nothing to do here.
+        if (filterSet.has(actual)) {
+          continue
+        }
+
+        reroot.add(actual)
+      }
+
+      // go through the rerooted actual nodes, and move them over.
+      for (const actual of reroot) {
+        actual.root = this.idealTree
+      }
+
+      // prune out any tops that lack a linkIn, they are no longer relevant.
+      for (const top of this.idealTree.tops) {
+        if (top.linksIn.size === 0) {
+          top.root = null
+        }
+      }
+
+      // need to calculate dep flags, since nodes may have been marked
+      // as extraneous or otherwise incorrect during transit.
+      calcDepFlags(this.idealTree)
+    }
+
+    // save the ideal's meta as a hidden lockfile after we actualize it
+    this.idealTree.meta.filename =
+      this.idealTree.realpath + '/node_modules/.package-lock.json'
+    this.idealTree.meta.hiddenLockfile = true
+    this.idealTree.meta.lockfileVersion = defaultLockfileVersion
+
+    this.actualTree = this.idealTree
+    this.idealTree = null
+
+    if (!this.options.global) {
+      await this.actualTree.meta.save()
+      const ignoreScripts = !!this.options.ignoreScripts
+      // if we aren't doing a dry run or ignoring scripts and we actually made changes to the dep
+      // tree, then run the dependencies scripts
+      if (!this.options.dryRun && !ignoreScripts && this.diff && this.diff.children.length) {
+        const { path, package: pkg } = this.actualTree.target
+        const stdio = this.options.foregroundScripts ? 'inherit' : 'pipe'
+        const { scripts = {} } = pkg
+        for (const event of ['predependencies', 'dependencies', 'postdependencies']) {
+          if (Object.prototype.hasOwnProperty.call(scripts, event)) {
+            log.info('run', pkg._id, event, scripts[event])
+            await time.start(`reify:run:${event}`, () => runScript({
+              event,
+              path,
+              pkg,
+              stdio,
+              scriptShell: this.options.scriptShell,
+            }))
+          }
+        }
+      }
+    }
+    // This is a very bad pattern and I can't wait to stop doing it
+    this.auditReport = await this.auditReport
+
+    this.finishTracker('reify')
+    timeEnd()
+    return treeCheck(this.actualTree)
+  }
+
+  async #reifyPackages () {
+    // we don't submit the audit report or write to disk on dry runs
+    if (this.options.dryRun) {
+      return
+    }
+
+    if (this.options.packageLockOnly) {
+      // we already have the complete tree, so just audit it now,
+      // and that's all we have to do here.
+      return this[_submitQuickAudit]()
+    }
+
+    // ok, we're about to start touching the fs.  need to roll back
+    // if we get an early termination.
+    let reifyTerminated = null
+    const removeHandler = onExit(({ signal }) => {
+      // only call once.  if signal hits twice, we just terminate
+      removeHandler()
+      reifyTerminated = Object.assign(new Error('process terminated'), {
+        signal,
+      })
+      return false
+    })
+
+    // [rollbackfn, [...actions]]
+    // after each step, if the process was terminated, execute the rollback
+    // note that each rollback *also* calls the previous one when it's
+    // finished, and then the first one throws the error, so we only need
+    // a new rollback step when we have a new thing that must be done to
+    // revert the install.
+    const steps = [
+      [_rollbackRetireShallowNodes, [
+        _retireShallowNodes,
+      ]],
+      [_rollbackCreateSparseTree, [
+        _createSparseTree,
+        _loadShrinkwrapsAndUpdateTrees,
+        _loadBundlesAndUpdateTrees,
+        _submitQuickAudit,
+        _unpackNewModules,
+      ]],
+      [_rollbackMoveBackRetiredUnchanged, [
+        _moveBackRetiredUnchanged,
+        _build,
+      ]],
+    ]
+    for (const [rollback, actions] of steps) {
+      for (const action of actions) {
+        try {
+          await this[action]()
+          if (reifyTerminated) {
+            throw reifyTerminated
+          }
+        } catch (er) {
+          // TODO rollbacks shouldn't be relied on to throw err
+          await this[rollback](er)
+          /* istanbul ignore next - rollback throws, should never hit this */
+          throw er
+        }
+      }
+    }
+
+    // no rollback for this one, just exit with the error, since the
+    // install completed and can't be safely recovered at this point.
+    await this[_removeTrash]()
+    if (reifyTerminated) {
+      throw reifyTerminated
+    }
+
+    // done modifying the file system, no need to keep listening for sigs
+    removeHandler()
+  }
+
+  // when doing a local install, we load everything and figure it all out.
+  // when doing a global install, we *only* care about the explicit requests.
+  [_loadTrees] (options) {
+    const timeEnd = time.start('reify:loadTrees')
+    const bitOpt = {
+      ...options,
+      complete: this.options.packageLockOnly || this.options.dryRun,
+    }
+
+    // if we're only writing a package lock, then it doesn't matter what's here
+    if (this.options.packageLockOnly) {
+      return this.buildIdealTree(bitOpt).then(timeEnd)
+    }
+
+    const actualOpt = this.options.global ? {
+      ignoreMissing: true,
+      global: true,
+      filter: (node, kid) => {
+        // if it's not the project root, and we have no explicit requests,
+        // then we're already into a nested dep, so we keep it
+        if (this.explicitRequests.size === 0 || !node.isProjectRoot) {
+          return true
+        }
+
+        // if we added it as an edgeOut, then we want it
+        if (this.idealTree.edgesOut.has(kid)) {
+          return true
+        }
+
+        // if it's an explicit request, then we want it
+        const hasExplicit = [...this.explicitRequests]
+          .some(edge => edge.name === kid)
+        if (hasExplicit) {
+          return true
+        }
+
+        // ignore the rest of the global install folder
+        return false
+      },
+    } : { ignoreMissing: true }
+
+    if (!this.options.global) {
+      return Promise.all([
+        this.loadActual(actualOpt),
+        this.buildIdealTree(bitOpt),
+      ]).then(timeEnd)
+    }
+
+    // the global install space tends to have a lot of stuff in it.  don't
+    // load all of it, just what we care about.  we won't be saving a
+    // hidden lockfile in there anyway.  Note that we have to load ideal
+    // BEFORE loading actual, so that the actualOpt can use the
+    // explicitRequests which is set during buildIdealTree
+    return this.buildIdealTree(bitOpt)
+      .then(() => this.loadActual(actualOpt))
+      .then(timeEnd)
+  }
+
+  [_diffTrees] () {
+    if (this.options.packageLockOnly) {
+      return
+    }
+
+    const timeEnd = time.start('reify:diffTrees')
+    // XXX if we have an existing diff already, there should be a way
+    // to just invalidate the parts that changed, but avoid walking the
+    // whole tree again.
+
+    const includeWorkspaces = this.options.workspacesEnabled
+    const includeRootDeps = !includeWorkspaces
+      || this.options.includeWorkspaceRoot && this.options.workspaces.length > 0
+
+    const filterNodes = []
+    if (this.options.global && this.explicitRequests.size) {
+      const idealTree = this.idealTree.target
+      const actualTree = this.actualTree.target
+      // we ONLY are allowed to make changes in the global top-level
+      // children where there's an explicit request.
+      for (const { name } of this.explicitRequests) {
+        const ideal = idealTree.children.get(name)
+        if (ideal) {
+          filterNodes.push(ideal)
+        }
+        const actual = actualTree.children.get(name)
+        if (actual) {
+          filterNodes.push(actual)
+        }
+      }
+    } else {
+      if (includeWorkspaces) {
+        // add all ws nodes to filterNodes
+        for (const ws of this.options.workspaces) {
+          const ideal = this.idealTree.children.get(ws)
+          if (ideal) {
+            filterNodes.push(ideal)
+          }
+          // Skip actual-side filterNodes when using the linked diff wrapper.
+          // Those nodes have root===actualTree, not root===linkedActualForDiff, and Diff.calculate requires filterNode.root to match actual.
+          // The ideal filterNode alone is sufficient to scope the workspace diff.
+          if (!this.#linkedActualForDiff) {
+            const actual = this.actualTree.children.get(ws)
+            if (actual) {
+              filterNodes.push(actual)
+            }
+          }
+        }
+      }
+      if (includeRootDeps) {
+        // add all non-workspace nodes to filterNodes
+        for (const tree of [this.idealTree, this.actualTree]) {
+          for (const { type, to } of tree.edgesOut.values()) {
+            if (type !== 'workspace' && to) {
+              filterNodes.push(to)
+            }
+          }
+        }
+      }
+    }
+
+    // find all the nodes that need to change between the actual
+    // and ideal trees.
+    this.diff = Diff.calculate({
+      omit: this.#omit,
+      shrinkwrapInflated: this.#shrinkwrapInflated,
+      filterNodes,
+      actual: this.#linkedActualForDiff || this.actualTree,
+      ideal: this.idealTree,
+    })
+
+    // we don't have to add 'removed' folders to the trashlist, because
+    // they'll be moved aside to a retirement folder, and then the retired
+    // folder will be deleted at the end.  This is important when we have
+    // a folder like FOO being "removed" in favor of a folder like "foo",
+    // because if we remove node_modules/FOO on case-insensitive systems,
+    // it will remove the dep that we *want* at node_modules/foo.
+
+    timeEnd()
+  }
+
+  // add the node and all its bins to the list of things to be
+  // removed later on in the process.  optionally, also mark them
+  // as a retired paths, so that we move them out of the way and
+  // replace them when rolling back on failure.
+  [_addNodeToTrashList] (node, retire = false) {
+    const paths = [node.path, ...node.binPaths]
+    const moves = this.#retiredPaths
+    log.silly('reify', 'mark', retire ? 'retired' : 'deleted', paths)
+    for (const path of paths) {
+      if (retire) {
+        const retired = retirePath(path)
+        moves[path] = retired
+        this[_trashList].add(retired)
+      } else {
+        this[_trashList].add(path)
+      }
+    }
+  }
+
+  // move aside the shallowest nodes in the tree that have to be
+  // changed or removed, so that we can rollback if necessary.
+  [_retireShallowNodes] () {
+    const timeEnd = time.start('reify:retireShallow')
+    const moves = this.#retiredPaths = {}
+    for (const diff of this.diff.children) {
+      if (diff.action === 'CHANGE' || diff.action === 'REMOVE') {
+        // we'll have to clean these up at the end, so add them to the list
+        this[_addNodeToTrashList](diff.actual, true)
+      }
+    }
+    log.silly('reify', 'moves', moves)
+    const movePromises = Object.entries(moves)
+      .map(([from, to]) => this[_renamePath](from, to))
+    return promiseAllRejectLate(movePromises).then(timeEnd)
+  }
+
+  [_renamePath] (from, to, didMkdirp = false) {
+    return moveFile(from, to)
+      .catch(er => {
+        // Occasionally an expected bin file might not exist in the package,
+        // or a shim/symlink might have been moved aside.  If we've already
+        // handled the most common cause of ENOENT (dir doesn't exist yet),
+        // then just ignore any ENOENT.
+        if (er.code === 'ENOENT') {
+          return didMkdirp ? null : mkdir(dirname(to), { recursive: true }).then(() =>
+            this[_renamePath](from, to, true))
+        } else if (er.code === 'EEXIST' || er.code === 'ENOTEMPTY') {
+          return rm(to, { recursive: true, force: true }).then(() => moveFile(from, to))
+        } else {
+          throw er
+        }
+      })
+  }
+
+  [_rollbackRetireShallowNodes] (er) {
+    const timeEnd = time.start('reify:rollback:retireShallow')
+    const moves = this.#retiredPaths
+    const movePromises = Object.entries(moves)
+      .map(([from, to]) => this[_renamePath](to, from))
+    return promiseAllRejectLate(movePromises)
+      // ignore subsequent rollback errors
+      .catch(() => {})
+      .then(timeEnd)
+      .then(() => {
+        throw er
+      })
+  }
+
+  [_createSparseTree] () {
+    const timeEnd = time.start('reify:createSparse')
+    // if we call this fn again, we look for the previous list
+    // so that we can avoid making the same directory multiple times
+    const leaves = this.diff.leaves
+      .filter(diff => {
+        return (diff.action === 'ADD' || diff.action === 'CHANGE') &&
+          !this.#sparseTreeDirs.has(diff.ideal.path) &&
+          !diff.ideal.isLink
+      })
+      .map(diff => diff.ideal)
+
+    // we check this in parallel, so guard against multiple attempts to
+    // retire the same path at the same time.
+    const dirsChecked = new Set()
+    return promiseAllRejectLate(leaves.map(async node => {
+      for (const d of walkUp(node.path)) {
+        if (d === node.top.path) {
+          break
+        }
+        if (dirsChecked.has(d)) {
+          continue
+        }
+        dirsChecked.add(d)
+        const st = await lstat(d).catch(() => null)
+        // this can happen if we have a link to a package with a name
+        // that the filesystem treats as if it is the same thing.
+        // would be nice to have conditional istanbul ignores here...
+        /* istanbul ignore next - defense in depth */
+        if (st && !st.isDirectory()) {
+          const retired = retirePath(d)
+          this.#retiredPaths[d] = retired
+          this[_trashList].add(retired)
+          await this[_renamePath](d, retired)
+        }
+      }
+      this.#sparseTreeDirs.add(node.path)
+      const made = await mkdir(node.path, { recursive: true })
+      // if the directory already exists, made will be undefined. if that's the case
+      // we don't want to remove it because we aren't the ones who created it so we
+      // omit it from the #sparseTreeRoots
+      /* istanbul ignore next -- pre-existing: mkdir returns undefined when dir exists, covered in reify tests but lost in aggregate coverage merge */
+      if (made) {
+        this.#sparseTreeRoots.add(made)
+      }
+    })).then(timeEnd)
+  }
+
+  [_rollbackCreateSparseTree] (er) {
+    const timeEnd = time.start('reify:rollback:createSparse')
+    // cut the roots of the sparse tree that were created, not the leaves
+    const roots = this.#sparseTreeRoots
+    // also delete the moves that we retired, so that we can move them back
+    const failures = []
+    const targets = [...roots, ...Object.keys(this.#retiredPaths)]
+    const unlinks = targets
+      .map(path => rm(path, { recursive: true, force: true }).catch(er => failures.push([path, er])))
+    return promiseAllRejectLate(unlinks).then(() => {
+      // eslint-disable-next-line promise/always-return
+      if (failures.length) {
+        log.warn('cleanup', 'Failed to remove some directories', failures)
+      }
+    })
+      .then(timeEnd)
+      .then(() => this[_rollbackRetireShallowNodes](er))
+  }
+
+  // shrinkwrap nodes define their dependency branches with a file, so
+  // we need to unpack them, read that shrinkwrap file, and then update
+  // the tree by calling loadVirtual with the node as the root.
+  [_loadShrinkwrapsAndUpdateTrees] () {
+    const seen = this.#shrinkwrapInflated
+    const shrinkwraps = this.diff.leaves
+      .filter(d => (d.action === 'CHANGE' || d.action === 'ADD' || !d.action) &&
+        d.ideal.hasShrinkwrap && !seen.has(d.ideal) &&
+        !this[_trashList].has(d.ideal.path))
+
+    if (!shrinkwraps.length) {
+      return
+    }
+
+    const timeEnd = time.start('reify:loadShrinkwraps')
+
+    const Arborist = this.constructor
+    return promiseAllRejectLate(shrinkwraps.map(diff => {
+      const node = diff.ideal
+      seen.add(node)
+      return diff.action ? this[_reifyNode](node) : node
+    }))
+      .then(nodes => promiseAllRejectLate(nodes.map(node => new Arborist({
+        ...this.options,
+        path: node.path,
+      }).loadVirtual({ root: node }))))
+      // reload the diff and sparse tree because the ideal tree changed
+      .then(() => this[_diffTrees]())
+      .then(() => this[_createSparseTree]())
+      .then(() => this[_loadShrinkwrapsAndUpdateTrees]())
+      .then(timeEnd)
+  }
+
+  // create a symlink for Links, extract for Nodes
+  // return the node object, since we usually want that
+  // handle optional dep failures here
+  // If reifying fails, and the node is optional, add it and its optionalSet
+  // to the trash list
+  // Always return the node.
+  [_reifyNode] (node) {
+    const timeEnd = time.start(`reifyNode:${node.location}`)
+    this.addTracker('reify', node.name, node.location)
+
+    const p = Promise.resolve().then(async () => {
+      await this[_checkBins](node)
+      await this.#extractOrLink(node)
+      const { _id, deprecated } = node.package
+      // The .catch is in _handleOptionalFailure.  Not ideal, this should be cleaned up.
+      // eslint-disable-next-line promise/always-return
+      if (deprecated) {
+        log.warn('deprecated', `${_id}: ${deprecated}`)
+      }
+    })
+
+    return this[_handleOptionalFailure](node, p)
+      .then(() => {
+        this.finishTracker('reify', node.name, node.location)
+        timeEnd()
+        return node
+      })
+  }
+
+  // do not allow node_modules to be a symlink
+  async #validateNodeModules (nm) {
+    if (this.options.force || this.#nmValidated.has(nm)) {
+      return
+    }
+    const st = await lstat(nm).catch(() => null)
+    if (!st || st.isDirectory()) {
+      this.#nmValidated.add(nm)
+      return
+    }
+    log.warn('reify', 'Removing non-directory', nm)
+    await rm(nm, { recursive: true, force: true })
+  }
+
+  async #extractOrLink (node) {
+    const nm = resolve(node.parent.path, 'node_modules')
+    await this.#validateNodeModules(nm)
+
+    if (!node.isLink) {
+      // in normal cases, node.resolved should *always* be set by now.
+      // however, it is possible when a lockfile is damaged, or very old,
+      // or in some other race condition bugs in npm v6, that a previously
+      // bundled dependency will have just a version, but no resolved value,
+      // and no 'bundled: true' setting.
+      // Do the best with what we have, or else remove it from the tree
+      // entirely, since we can't possibly reify it.
+      let res = null
+      if (node.resolved) {
+        const registryResolved = this.#registryResolved(node.resolved)
+        if (registryResolved) {
+          res = `${node.name}@${registryResolved}`
+        }
+      } else if (node.package.name && node.version) {
+        res = `${node.package.name}@${node.version}`
+      }
+
+      // no idea what this thing is.  remove it from the tree.
+      if (!res) {
+        const warning = 'invalid or damaged lockfile detected\n' +
+          'please re-try this operation once it completes\n' +
+          'so that the damage can be corrected, or perform\n' +
+          'a fresh install with no lockfile if the problem persists.'
+        log.warn('reify', warning)
+        log.verbose('reify', 'unrecognized node in tree', node.path)
+        node.parent = null
+        node.fsParent = null
+        this[_addNodeToTrashList](node)
+        return
+      }
+      await debug(async () => {
+        const st = await lstat(node.path).catch(() => null)
+        if (st && !st.isDirectory()) {
+          debug.log('unpacking into a non-directory', node)
+          throw Object.assign(new Error('ENOTDIR: not a directory'), {
+            code: 'ENOTDIR',
+            path: node.path,
+          })
+        }
+      })
+      await pacote.extract(res, node.path, {
+        ...this.options,
+        resolved: node.resolved,
+        integrity: node.integrity,
+        _isRoot: node.parent?.isProjectRoot || node.parent?.isWorkspace,
+      })
+      // store nodes don't use Node class so node.package doesn't get updated
+      if (node.isInStore) {
+        const { content: pkg } = await PackageJson.normalize(node.path)
+        node.package.scripts = pkg.scripts
+      }
+      return
+    }
+
+    // node.isLink
+    await rm(node.path, { recursive: true, force: true })
+
+    // symlink
+    const dir = dirname(node.path)
+    const target = node.realpath
+
+    let rel
+    if (node.resolved?.startsWith('file:')) {
+      rel = this.#calculateRelativePath(node, dir, target, nm)
+    } else {
+      rel = relative(dir, target)
+    }
+
+    await mkdir(dir, { recursive: true })
+    return symlink(rel, node.path, 'junction')
+  }
+
+  // if the node is optional, then the failure of the promise is nonfatal
+  // just add it and its optional set to the trash list.
+  [_handleOptionalFailure] (node, p) {
+    return (node.optional ? p.catch(() => {
+      const set = optionalSet(node)
+      for (const node of set) {
+        log.verbose('reify', 'failed optional dependency', node.path)
+        node.inert = true
+        this[_addNodeToTrashList](node)
+      }
+    }) : p).then(() => node)
+  }
+
+  #calculateRelativePath (node, dir, target) {
+    // Check if the node is affected by a root override
+    let hasRootOverride = [...node.edgesIn].some(edge => edge.from.isRoot && edge.overrides)
+    // If not set via edges, see if the root package.json explicitly lists an override
+    if (!hasRootOverride && node.root) {
+      const rootPackage = node.root.target
+      hasRootOverride = !!(rootPackage &&
+        rootPackage.package.overrides &&
+        rootPackage.package.overrides[node.name])
+    }
+    if (!hasRootOverride) {
+      return relative(dir, target)
+    }
+    // If an override is detected, attempt to retrieve the override spec from the root package.json
+    const overrideSpec = node.root?.target?.package?.overrides?.[node.name]
+    if (typeof overrideSpec === 'string' && overrideSpec.startsWith('file:')) {
+      const overridePath = overrideSpec.replace(/^file:/, '')
+      const rootDir = node.root.target.path
+      return relative(dir, resolve(rootDir, overridePath))
+    }
+
+    // Fallback: derive the file path from node.resolved in a platform-agnostic way
+    const filePath = node.resolved.replace(/^file:/, '')
+    return join(filePath)
+  }
+
+  // Build a flat actual tree wrapper for linked installs so the diff can correctly match store entries that already exist on disk.
+  // The proxy tree from createIsolatedTree() is flat (all children on root), but loadActual() produces a nested tree where store entries are deep link targets.
+  // This wrapper surfaces them at the root level for comparison.
+  #buildLinkedActualForDiff (idealTree, actualTree) {
+    // Combined Map keyed by path (how allChildren() in diff.js keys)
+    const combined = new Map()
+
+    // Create synthetic actual entries for ALL ideal children that exist on disk.
+    // The isolated ideal tree is flat (all entries as root children), but loadActual() produces a nested tree where workspace deps are under fsChildren and store entries are deep link targets.
+    // Synthetic entries ensure the diff compares matching resolved/integrity values (e.g. workspace links have resolved=undefined in the ideal tree but resolved="file:../packages/..." in the actual tree).
+    for (const child of idealTree.children.values()) {
+      if (combined.has(child.path) || !existsSync(child.path)) {
+        continue
+      }
+      // Skip store links whose ideal realpath doesn't exist on disk yet — the store hash changed and the symlink needs recreating via ADD.
+      if (child.isLink && child.resolved?.startsWith('file:.store/') && !existsSync(child.realpath)) {
+        continue
+      }
+      let entry
+      if (child.isLink) {
+        entry = new IsolatedLink(child)
+      } else {
+        entry = new IsolatedNode(child)
+      }
+      if (child.isLink && combined.has(child.realpath)) {
+        entry.target = combined.get(child.realpath)
+      }
+      combined.set(child.path, entry)
+    }
+
+    // Proxy .get(name) to original actual tree for filterNodes compatibility
+    // (scoped workspace installs use .get(name), allChildren uses .values())
+    const origGet = actualTree.children.get.bind(actualTree.children)
+    const combinedGet = combined.get.bind(combined)
+    /* istanbul ignore next -- only reached during scoped workspace installs */
+    combined.get = (key) => combinedGet(key) || origGet(key)
+
+    let wrapper
+    /* istanbul ignore next - untested! */
+    if (actualTree.isLink) {
+      wrapper = new IsolatedLink(actualTree)
+    } else {
+      wrapper = new IsolatedNode(actualTree)
+    }
+    wrapper.root = wrapper
+    wrapper.binPaths = actualTree.binPaths
+    wrapper.children = combined
+    wrapper.edgesOut = actualTree.edgesOut
+    // Use empty fsChildren so that allChildren() only picks up entries from the combined map.
+    // The actual fsChildren have real children with different resolved values (e.g. file:../../../node_modules/.store/... vs file:.store/...) that would overwrite our synthetic entries in allChildren().
+    wrapper.fsChildren = new Set()
+    wrapper.integrity = actualTree.integrity
+    wrapper.inventory = actualTree.inventory
+
+    return wrapper
+  }
+
+  #registryResolved (resolved) {
+    // the default registry url is a magic value meaning "the currently
+    // configured registry".
+    // `resolved` must never be falsey.
+    //
+    // XXX: use a magic string that isn't also a valid value, like
+    // ${REGISTRY} or something.  This has to be threaded through the
+    // Shrinkwrap and Node classes carefully, so for now, just treat
+    // the default reg as the magical animal that it has been.
+    try {
+      const resolvedURL = hgi.parseUrl(resolved)
+
+      if ((this.options.replaceRegistryHost === resolvedURL.hostname) ||
+           this.options.replaceRegistryHost === 'always') {
+        const registryURL = new URL(this.registry)
+
+        // Replace the host with the registry host while keeping the path intact
+        resolvedURL.hostname = registryURL.hostname
+        resolvedURL.port = registryURL.port
+        resolvedURL.protocol = registryURL.protocol
+
+        // Make sure we don't double-include the path if it's already there
+        const registryPath = registryURL.pathname.replace(/\/$/, '')
+
+        if (registryPath && registryPath !== '/') {
+          // Check if the resolved pathname already starts with the registry path
+          // We need to ensure it's a proper path prefix, not just a string prefix
+          // e.g., registry path '/npm' should not match '/npm-run-path'
+          const hasRegistryPath = resolvedURL.pathname === registryPath ||
+                                  resolvedURL.pathname.startsWith(registryPath + '/')
+
+          if (!hasRegistryPath) {
+            // Since hostname is changed, we need to ensure the registry path is included
+            resolvedURL.pathname = registryPath + resolvedURL.pathname
+          }
+        }
+
+        return resolvedURL.toString()
+      }
+      return resolved
+    } catch (e) {
+      // if we could not parse the url at all then returning nothing
+      // here means it will get removed from the tree in the next step
+      return undefined
+    }
+  }
+
+  // bundles are *sort of* like shrinkwraps, in that the branch is defined
+  // by the contents of the package.  however, in their case, rather than
+  // shipping a virtual tree that must be reified, they ship an entire
+  // reified actual tree that must be unpacked and not modified.
+  [_loadBundlesAndUpdateTrees] (depth = 0, bundlesByDepth) {
+    let maxBundleDepth
+    if (!bundlesByDepth) {
+      bundlesByDepth = new Map()
+      maxBundleDepth = -1
+      dfwalk({
+        tree: this.diff,
+        visit: diff => {
+          const node = diff.ideal
+          if (!node) {
+            return
+          }
+          if (node.isProjectRoot) {
+            return
+          }
+
+          const { bundleDependencies } = node.package
+          if (bundleDependencies && bundleDependencies.length) {
+            maxBundleDepth = Math.max(maxBundleDepth, node.depth)
+            if (!bundlesByDepth.has(node.depth)) {
+              bundlesByDepth.set(node.depth, [node])
+            } else {
+              bundlesByDepth.get(node.depth).push(node)
+            }
+          }
+        },
+        getChildren: diff => diff.children,
+      })
+
+      bundlesByDepth.set('maxBundleDepth', maxBundleDepth)
+    } else {
+      maxBundleDepth = bundlesByDepth.get('maxBundleDepth')
+    }
+
+    if (depth === 0) {
+      time.start('reify:loadBundles')
+    }
+
+    if (depth > maxBundleDepth) {
+      // if we did something, then prune the tree and update the diffs
+      if (maxBundleDepth !== -1) {
+        this.#pruneBundledMetadeps(bundlesByDepth)
+        this[_diffTrees]()
+      }
+      time.end('reify:loadBundles')
+      return
+    }
+
+    // skip any that have since been removed from the tree, eg by a
+    // shallower bundle overwriting them with a bundled meta-dep.
+    const set = (bundlesByDepth.get(depth) || [])
+      .filter(node => node.root === this.idealTree &&
+        node.target !== node.root &&
+        !this[_trashList].has(node.path))
+
+    if (!set.length) {
+      return this[_loadBundlesAndUpdateTrees](depth + 1, bundlesByDepth)
+    }
+
+    // extract all the nodes with bundles
+    return promiseCallLimit(set.map(node => {
+      return () => {
+        this.#bundleUnpacked.add(node)
+        return this[_reifyNode](node)
+      }
+    }), { rejectLate: true })
+    // then load their unpacked children and move into the ideal tree
+      .then(nodes =>
+        promiseAllRejectLate(nodes.map(async node => {
+          const arb = new this.constructor({
+            ...this.options,
+            path: node.path,
+          })
+          const notTransplanted = new Set(node.children.keys())
+          await arb.loadActual({
+            root: node,
+            // don't transplant any sparse folders we created
+            // loadActual will set node.package to {} for empty directories
+            // if by chance there are some empty folders in the node_modules
+            // tree for some other reason, then ok, ignore those too.
+            transplantFilter: node => {
+              if (node.package._id) {
+                // it's actually in the bundle if it gets transplanted
+                notTransplanted.delete(node.name)
+                return true
+              } else {
+                return false
+              }
+            },
+          })
+          for (const name of notTransplanted) {
+            this.#bundleMissing.add(node.children.get(name))
+          }
+        })))
+    // move onto the next level of bundled items
+      .then(() => this[_loadBundlesAndUpdateTrees](depth + 1, bundlesByDepth))
+  }
+
+  // https://github.com/npm/cli/issues/1597#issuecomment-667639545
+  #pruneBundledMetadeps (bundlesByDepth) {
+    const bundleShadowed = new Set()
+
+    // Example dep graph:
+    // root -> (a, c)
+    // a -> BUNDLE(b)
+    // b -> c
+    // c -> b
+    //
+    // package tree:
+    // root
+    // +-- a
+    // |   +-- b(1)
+    // |   +-- c(1)
+    // +-- b(2)
+    // +-- c(2)
+    // 1. mark everything that's shadowed by anything in the bundle.  This
+    //    marks b(2) and c(2).
+    // 2. anything with edgesIn from outside the set, mark not-extraneous,
+    //    remove from set.  This unmarks c(2).
+    // 3. continue until no change
+    // 4. remove everything in the set from the tree.  b(2) is pruned
+
+    // create the list of nodes shadowed by children of bundlers
+    for (const bundles of bundlesByDepth.values()) {
+      // skip the 'maxBundleDepth' item
+      if (!Array.isArray(bundles)) {
+        continue
+      }
+      for (const node of bundles) {
+        for (const name of node.children.keys()) {
+          const shadow = node.parent.resolve(name)
+          if (!shadow) {
+            continue
+          }
+          bundleShadowed.add(shadow)
+          shadow.extraneous = true
+        }
+      }
+    }
+
+    // lib -> (a@1.x) BUNDLE(a@1.2.3 (b@1.2.3))
+    // a@1.2.3 -> (b@1.2.3)
+    // a@1.3.0 -> (b@2)
+    // b@1.2.3 -> ()
+    // b@2 -> (c@2)
+    //
+    // root
+    // +-- lib
+    // |   +-- a@1.2.3
+    // |   +-- b@1.2.3
+    // +-- b@2 <-- shadowed, now extraneous
+    // +-- c@2 <-- also shadowed, because only dependent is shadowed
+    for (const shadow of bundleShadowed) {
+      for (const shadDep of shadow.edgesOut.values()) {
+        /* istanbul ignore else - pretty unusual situation, just being
+         * defensive here. Would mean that a bundled dep has a dependency
+         * that is unmet. which, weird, but if you bundle it, we take
+         * whatever you put there and assume the publisher knows best. */
+        if (shadDep.to) {
+          bundleShadowed.add(shadDep.to)
+          shadDep.to.extraneous = true
+        }
+      }
+    }
+
+    let changed
+    do {
+      changed = false
+      for (const shadow of bundleShadowed) {
+        for (const edge of shadow.edgesIn) {
+          if (!bundleShadowed.has(edge.from)) {
+            shadow.extraneous = false
+            bundleShadowed.delete(shadow)
+            changed = true
+            break
+          }
+        }
+      }
+    } while (changed)
+
+    for (const shadow of bundleShadowed) {
+      this[_addNodeToTrashList](shadow)
+      shadow.root = null
+    }
+  }
+
+  async [_submitQuickAudit] () {
+    if (this.options.audit === false) {
+      this.auditReport = null
+      return
+    }
+
+    // we submit the quick audit at this point in the process, as soon as
+    // we have all the deps resolved, so that it can overlap with the other
+    // actions as much as possible.  Stash the promise, which we resolve
+    // before finishing the reify() and returning the tree.  Thus, we do
+    // NOT return the promise, as the intent is for this to run in parallel
+    // with the reification, and be resolved at a later time.
+    const timeEnd = time.start('reify:audit')
+    const options = { ...this.options }
+    const tree = this.idealTree
+
+    // if we're operating on a workspace, only audit the workspace deps
+    if (this.options.workspaces.length) {
+      options.filterSet = this.workspaceDependencySet(
+        tree,
+        this.options.workspaces,
+        this.options.includeWorkspaceRoot
+      )
+    }
+
+    this.auditReport = AuditReport.load(tree, options).then(res => {
+      timeEnd()
+      return res
+    })
+  }
+
+  // ok!  actually unpack stuff into their target locations!
+  // The sparse tree has already been created, so we walk the diff
+  // kicking off each unpack job.  If any fail, we rm the sparse
+  // tree entirely and try to put everything back where it was.
+  [_unpackNewModules] () {
+    const timeEnd = time.start('reify:unpack')
+    const unpacks = []
+    dfwalk({
+      tree: this.diff,
+      visit: diff => {
+        // no unpacking if we don't want to change this thing
+        if (diff.action !== 'CHANGE' && diff.action !== 'ADD') {
+          return
+        }
+
+        const node = diff.ideal
+        const bd = this.#bundleUnpacked.has(node)
+        const sw = this.#shrinkwrapInflated.has(node)
+        const bundleMissing = this.#bundleMissing.has(node)
+
+        // check whether we still need to unpack this one.
+        // test the inDepBundle last, since that's potentially a tree walk.
+        const doUnpack = node && // can't unpack if removed!
+          // root node already exists
+          !node.isRoot &&
+          // already unpacked to read bundle
+          !bd &&
+          // already unpacked to read sw
+          !sw &&
+          // already unpacked by another dep's bundle
+          (bundleMissing || !node.inDepBundle)
+
+        if (doUnpack) {
+          unpacks.push(this[_reifyNode](node))
+        }
+      },
+      getChildren: diff => diff.children,
+    })
+    return promiseAllRejectLate(unpacks).then(timeEnd)
+  }
+
+  // This is the part where we move back the unchanging nodes that were
+  // the children of a node that did change.  If this fails, the rollback
+  // is a three-step process.  First, we try to move the retired unchanged
+  // nodes BACK to their retirement folders, then delete the sparse tree,
+  // then move everything out of retirement.
+  [_moveBackRetiredUnchanged] () {
+    // get a list of all unchanging children of any shallow retired nodes
+    // if they are not the ancestor of any node in the diff set, then the
+    // directory won't already exist, so just rename it over.
+    // This is sort of an inverse diff tree, of all the nodes where
+    // the actualTree and idealTree _don't_ differ, starting from the
+    // shallowest nodes that we moved aside in the first place.
+    const timeEnd = time.start('reify:unretire')
+    const moves = this.#retiredPaths
+    this.#retiredUnchanged = {}
+    return promiseAllRejectLate(this.diff.children.map(diff => {
+      // skip if nothing was retired
+      if (diff.action !== 'CHANGE' && diff.action !== 'REMOVE') {
+        return
+      }
+
+      const { path: realFolder } = diff.actual
+      const retireFolder = moves[realFolder]
+      /* istanbul ignore next - should be impossible */
+      debug(() => {
+        if (!retireFolder) {
+          const er = new Error('trying to un-retire but not retired')
+          throw Object.assign(er, {
+            realFolder,
+            retireFolder,
+            actual: diff.actual,
+            ideal: diff.ideal,
+            action: diff.action,
+          })
+        }
+      })
+
+      this.#retiredUnchanged[retireFolder] = []
+      return promiseAllRejectLate(diff.unchanged.map(node => {
+        // no need to roll back links, since we'll just delete them anyway
+        if (node.isLink) {
+          return mkdir(dirname(node.path), { recursive: true, force: true })
+            .then(() => this[_reifyNode](node))
+        }
+
+        // will have been moved/unpacked along with bundler
+        if (node.inDepBundle && !this.#bundleMissing.has(node)) {
+          return
+        }
+
+        this.#retiredUnchanged[retireFolder].push(node)
+
+        const rel = relative(realFolder, node.path)
+        const fromPath = resolve(retireFolder, rel)
+        // if it has bundleDependencies, then make node_modules.  otherwise
+        // skip it.
+        const bd = node.package.bundleDependencies
+        const dir = bd && bd.length ? node.path + '/node_modules' : node.path
+        return mkdir(dir, { recursive: true }).then(() => this[_moveContents](node, fromPath))
+      }))
+    })).then(timeEnd)
+  }
+
+  // move the contents from the fromPath to the node.path
+  [_moveContents] (node, fromPath) {
+    return packageContents({
+      path: fromPath,
+      depth: 1,
+      packageJsonCache: new Map([[fromPath + '/package.json', node.package]]),
+    }).then(res => promiseAllRejectLate(res.map(path => {
+      const rel = relative(fromPath, path)
+      const to = resolve(node.path, rel)
+      return this[_renamePath](path, to)
+    })))
+  }
+
+  [_rollbackMoveBackRetiredUnchanged] (er) {
+    const moves = this.#retiredPaths
+    // flip the mapping around to go back
+    const realFolders = new Map(Object.entries(moves).map(([k, v]) => [v, k]))
+    const promises = Object.entries(this.#retiredUnchanged)
+      .map(([retireFolder, nodes]) => promiseAllRejectLate(nodes.map(node => {
+        const realFolder = realFolders.get(retireFolder)
+        const rel = relative(realFolder, node.path)
+        const fromPath = resolve(retireFolder, rel)
+        return this[_moveContents]({ ...node, path: fromPath }, node.path)
+      })))
+    return promiseAllRejectLate(promises)
+      .then(() => this[_rollbackCreateSparseTree](er))
+  }
+
+  [_build] () {
+    const timeEnd = time.start('reify:build')
+
+    // for all the things being installed, run their appropriate scripts
+    // run in tip->root order, so as to be more likely to build a node's
+    // deps before attempting to build it itself
+    const nodes = []
+    dfwalk({
+      tree: this.diff,
+      leave: diff => {
+        if (!diff.ideal.isProjectRoot) {
+          nodes.push(diff.ideal)
+        }
+      },
+      // process adds before changes, ignore removals
+      getChildren: diff => diff && diff.children,
+      filter: diff => diff.action === 'ADD' || diff.action === 'CHANGE',
+    })
+
+    // pick up link nodes from the unchanged list as we want to run their
+    // scripts in every install despite of having a diff status change
+    for (const node of this.diff.unchanged) {
+      const tree = node.root.target
+
+      // skip links that only live within node_modules as they are most
+      // likely managed by packages we installed, we only want to rebuild
+      // unchanged links we directly manage
+      const linkedFromRoot = (node.parent === tree && !node.inert) || node.target.fsTop === tree
+      if (node.isLink && linkedFromRoot) {
+        nodes.push(node)
+      }
+    }
+
+    return this.rebuild({ nodes, handleOptionalFailure: true }).then(timeEnd)
+  }
+
+  // the tree is pretty much built now, so it's cleanup time.
+  // remove the retired folders, and any deleted nodes
+  // If this fails, there isn't much we can do but tell the user about it.
+  // Thankfully, it's pretty unlikely that it'll fail, since rm is a node builtin.
+  async [_removeTrash] () {
+    const timeEnd = time.start('reify:trash')
+    const promises = []
+    const failures = []
+    const _rm = path => rm(path, { recursive: true, force: true }).catch(er => failures.push([path, er]))
+
+    for (const path of this[_trashList]) {
+      promises.push(_rm(path))
+    }
+
+    await promiseAllRejectLate(promises)
+    if (failures.length) {
+      log.warn('cleanup', 'Failed to remove some directories', failures)
+    }
+
+    timeEnd()
+  }
+
+  // After a linked install, scan node_modules/.store/ and remove any directories that are not referenced by the current ideal tree.
+  // Store entries become orphaned when dependencies are updated or removed, because the diff never sees the old store keys.
+  async #cleanOrphanedStoreEntries () {
+    const storeDir = resolve(this.path, 'node_modules', '.store')
+    let entries
+    try {
+      entries = await readdir(storeDir)
+    } catch {
+      return
+    }
+
+    // Collect valid store keys from the isolated ideal tree (location: node_modules/.store/{key}/node_modules/{pkg})
+    const validKeys = new Set()
+    for (const child of this.idealTree.children.values()) {
+      if (child.isInStore) {
+        const key = child.location.split(sep)[2]
+        validKeys.add(key)
+      }
+    }
+
+    const orphaned = entries.filter(e => !validKeys.has(e))
+    if (!orphaned.length) {
+      return
+    }
+
+    log.silly('reify', 'cleaning orphaned store entries', orphaned)
+    await promiseAllRejectLate(
+      orphaned.map(e =>
+        rm(resolve(storeDir, e), { recursive: true, force: true })
+          .catch(/* istanbul ignore next -- rm with force rarely fails */
+            er => log.warn('cleanup', `Failed to remove orphaned store entry ${e}`, er))
+      )
+    )
+  }
+
+  // last but not least, we save the ideal tree metadata to the package-lock
+  // or shrinkwrap file, and any additions or removals to package.json
+  async [_saveIdealTree] (options) {
+    // the ideal tree is actualized now, hooray!
+    // it still contains all the references to optional nodes that were removed
+    // for install failures.  Those still end up in the shrinkwrap, so we
+    // save it first, then prune out the optional trash, and then return it.
+
+    const save = !(options.save === false)
+
+    // we check for updates in order to make sure we run save ideal tree
+    // even though save=false since we want `npm update` to be able to
+    // write to package-lock files by default
+    const hasUpdates = this[_updateAll] || this[_updateNames].length
+
+    // we're going to completely skip save ideal tree in case of a global or
+    // dry-run install and also if the save option is set to false, EXCEPT for
+    // update since the expected behavior for npm7+ is for update to
+    // NOT save to package.json, we make that exception since we still want
+    // saveIdealTree to be able to write the lockfile by default.
+    const saveIdealTree = !(
+      (!save && !hasUpdates)
+      || this.options.global
+      || this.options.dryRun
+    )
+
+    if (!saveIdealTree) {
+      return false
+    }
+
+    const timeEnd = time.start('reify:save')
+
+    const updatedTrees = new Set()
+    const updateNodes = nodes => {
+      for (const { name, tree: addTree } of nodes) {
+        // addTree either the root, or a workspace
+        const edge = addTree.edgesOut.get(name)
+        const pkg = addTree.package
+        const req = npa.resolve(name, edge.spec, addTree.realpath)
+        const { rawSpec, subSpec } = req
+
+        const spec = subSpec ? subSpec.rawSpec : rawSpec
+        const child = edge.to
+
+        // if we tried to install an optional dep, but it was a version
+        // that we couldn't resolve, this MAY be missing.  if we haven't
+        // blown up by now, it's because it was not a problem, though, so
+        // just move on.
+        if (!child || !addTree.isTop) {
+          continue
+        }
+
+        let newSpec
+        // True if the dependency is getting installed from a local file path
+        // In this case it is not possible to do the normal version comparisons
+        // as the new version will be a file path
+        const isLocalDep = req.type === 'directory' || req.type === 'file'
+        if (req.registry) {
+          const version = child.version
+          const prefixRange = version ? this.options.savePrefix + version : '*'
+          // if we installed a range, then we save the range specified
+          // if it is not a subset of the ^x.y.z.  eg, installing a range
+          // of `1.x <1.2.3` will not be saved as `^1.2.0`, because that
+          // would allow versions outside the requested range.  Tags and
+          // specific versions save with the save-prefix.
+          const isRange = (subSpec || req).type === 'range'
+
+          let range = spec
+          if (
+            !isRange ||
+            spec === '*' ||
+            subset(prefixRange, spec, { loose: true })
+          ) {
+            range = prefixRange
+          }
+
+          const pname = child.packageName
+          const alias = name !== pname
+          newSpec = alias ? `npm:${pname}@${range}` : range
+        } else if (req.hosted) {
+          // save the git+https url if it has auth; otherwise, shortcut
+          const h = req.hosted
+          const opt = { noCommittish: false }
+          if (h.https && h.auth) {
+            newSpec = `git+${h.https(opt)}`
+          } else {
+            newSpec = h.shortcut(opt)
+          }
+        } else if (isLocalDep) {
+          // when finding workspace nodes, make sure that
+          // we save them using their version instead of
+          // using their relative path
+          if (edge.type === 'workspace') {
+            const { version } = edge.to.target
+            const prefixRange = version ? this.options.savePrefix + version : '*'
+            newSpec = prefixRange
+          } else {
+            // save the relative path in package.json
+            // Normally saveSpec is updated with the proper relative
+            // path already, but it's possible to specify a full absolute
+            // path initially, in which case we can end up with the wrong
+            // thing, so just get the ultimate fetchSpec and relativize it.
+            const p = req.fetchSpec.replace(/^file:/, '')
+            const rel = relpath(addTree.realpath, p)
+            newSpec = `file:${rel}`
+          }
+        } else {
+          newSpec = req.saveSpec
+        }
+
+        if (options.saveType) {
+          const depType = saveTypeMap.get(options.saveType)
+          pkg[depType][name] = newSpec
+          // PackageJson.normalize will have moved it here if it was in both, if it is empty it will be deleted later
+          if (options.saveType === 'prod' && pkg.optionalDependencies) {
+            delete pkg.optionalDependencies[name]
+          }
+        } else {
+          if (hasSubKey(pkg, 'dependencies', name)) {
+            pkg.dependencies[name] = newSpec
+          }
+
+          if (hasSubKey(pkg, 'devDependencies', name)) {
+            pkg.devDependencies[name] = newSpec
+            // don't update peer or optional if we don't have to
+            if (hasSubKey(pkg, 'peerDependencies', name) && (isLocalDep || !intersects(newSpec, pkg.peerDependencies[name]))) {
+              pkg.peerDependencies[name] = newSpec
+            }
+
+            if (hasSubKey(pkg, 'optionalDependencies', name) && (isLocalDep || !intersects(newSpec, pkg.optionalDependencies[name]))) {
+              pkg.optionalDependencies[name] = newSpec
+            }
+          } else {
+            if (hasSubKey(pkg, 'peerDependencies', name)) {
+              pkg.peerDependencies[name] = newSpec
+            }
+
+            if (hasSubKey(pkg, 'optionalDependencies', name)) {
+              pkg.optionalDependencies[name] = newSpec
+            }
+          }
+        }
+
+        updatedTrees.add(addTree)
+      }
+    }
+
+    // Returns true if any of the edges from this node has a semver
+    // range definition that is an exact match to the version installed
+    // e.g: should return true if for a given and installed version 1.0.0,
+    // range is either =1.0.0 or 1.0.0
+    const exactVersion = node => {
+      for (const edge of node.edgesIn) {
+        try {
+          if (subset(edge.spec, node.version)) {
+            return false
+          }
+        } catch {
+          // ignore errors
+        }
+      }
+      return true
+    }
+
+    // helper that retrieves an array of nodes that were
+    // potentially updated during the reify process, in order
+    // to limit the number of nodes to check and update, only
+    // select nodes from the inventory that are direct deps
+    // of a given package.json (project root or a workspace)
+    // and in ase of using a list of `names`, restrict nodes
+    // to only names that are found in this list
+    const retrieveUpdatedNodes = names => {
+      const filterDirectDependencies = node =>
+        !node.isRoot && node.resolveParent && node.resolveParent.isRoot
+        && (!names || names.includes(node.name))
+        && exactVersion(node) // skip update for exact ranges
+
+      const directDeps = this.idealTree.inventory
+        .filter(filterDirectDependencies)
+
+      // traverses the list of direct dependencies and collect all nodes
+      // to be updated, since any of them might have changed during reify
+      const nodes = []
+      for (const node of directDeps) {
+        for (const edgeIn of node.edgesIn) {
+          nodes.push({
+            name: node.name,
+            tree: edgeIn.from.target,
+          })
+        }
+      }
+      return nodes
+    }
+
+    if (save) {
+      // when using update all alongside with save, we'll make
+      // sure to refresh every dependency of the root idealTree
+      if (this[_updateAll]) {
+        const nodes = retrieveUpdatedNodes()
+        updateNodes(nodes)
+      } else {
+        // resolvedAdd is the list of user add requests, but with names added
+        // to things like git repos and tarball file/urls.  However, if the
+        // user requested 'foo@', and we have a foo@file:../foo, then we should
+        // end up saving the spec we actually used, not whatever they gave us.
+        if (this[_resolvedAdd].length) {
+          updateNodes(this[_resolvedAdd])
+        }
+
+        // if updating given dependencies by name, restrict the list of
+        // nodes to check to only those currently in _updateNames
+        if (this[_updateNames].length) {
+          const nodes = retrieveUpdatedNodes(this[_updateNames])
+          updateNodes(nodes)
+        }
+
+        // grab any from explicitRequests that had deps removed
+        for (const { from: tree } of this.explicitRequests) {
+          updatedTrees.add(tree)
+        }
+      }
+    }
+
+    if (save) {
+      for (const tree of updatedTrees) {
+        // refresh the edges so they have the correct specs
+        tree.package = tree.package
+        const pkgJson = await PackageJson.load(tree.path, { create: true })
+        const {
+          dependencies = {},
+          devDependencies = {},
+          optionalDependencies = {},
+          peerDependencies = {},
+          // bundleDependencies is not required by PackageJson like the other
+          // fields here PackageJson also doesn't omit an empty array for this
+          // field so defaulting this to an empty array would add that field to
+          // every package.json file.
+          bundleDependencies,
+        } = tree.package
+
+        pkgJson.update({
+          dependencies,
+          devDependencies,
+          optionalDependencies,
+          peerDependencies,
+          bundleDependencies,
+        })
+        await pkgJson.save()
+      }
+    }
+
+    // before now edge specs could be changing, affecting the `requires` field
+    // in the package lock, so we hold off saving to the very last action
+    if (this.options.usePackageLock) {
+      // preserve indentation, if possible
+      let format = this.idealTree.package[Symbol.for('indent')]
+      if (format === undefined) {
+        format = '  '
+      }
+
+      // TODO this ignores options.save
+      await this.idealTree.meta.save({
+        format: (this.options.formatPackageLock && format) ? format
+        : this.options.formatPackageLock,
+      })
+    }
+
+    timeEnd()
+    return true
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/audit-report.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/audit-report.js
new file mode 100644
index 0000000000000000000000000000000000000000..397629178dd9cedacfd1824dfaed92d296cd06ed
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/audit-report.js
@@ -0,0 +1,330 @@
+// an object representing the set of vulnerabilities in a tree
+
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const npa = require('npm-package-arg')
+const pickManifest = require('npm-pick-manifest')
+
+const Vuln = require('./vuln.js')
+const Calculator = require('@npmcli/metavuln-calculator')
+
+const { log, time } = require('proc-log')
+
+const npmFetch = require('npm-registry-fetch')
+
+class AuditReport extends Map {
+  #omit
+  error = null
+  topVulns = new Map()
+
+  static load (tree, opts) {
+    return new AuditReport(tree, opts).run()
+  }
+
+  get auditReportVersion () {
+    return 2
+  }
+
+  toJSON () {
+    const obj = {
+      auditReportVersion: this.auditReportVersion,
+      vulnerabilities: {},
+      metadata: {
+        vulnerabilities: {
+          info: 0,
+          low: 0,
+          moderate: 0,
+          high: 0,
+          critical: 0,
+          total: this.size,
+        },
+        dependencies: {
+          prod: 0,
+          dev: 0,
+          optional: 0,
+          peer: 0,
+          peerOptional: 0,
+          total: this.tree.inventory.size - 1,
+        },
+      },
+    }
+
+    for (const node of this.tree.inventory.values()) {
+      const { dependencies } = obj.metadata
+      let prod = true
+      for (const type of [
+        'dev',
+        'optional',
+        'peer',
+        'peerOptional',
+      ]) {
+        if (node[type]) {
+          dependencies[type]++
+          prod = false
+        }
+      }
+      if (prod) {
+        dependencies.prod++
+      }
+    }
+
+    // if it doesn't have any topVulns, then it's fixable with audit fix
+    // for each topVuln, figure out if it's fixable with audit fix --force,
+    // or if we have to just delete the thing, and if the fix --force will
+    // require a semver major update.
+    const vulnerabilities = []
+    for (const [name, vuln] of this.entries()) {
+      vulnerabilities.push([name, vuln.toJSON()])
+      obj.metadata.vulnerabilities[vuln.severity]++
+    }
+
+    obj.vulnerabilities = vulnerabilities
+      .sort(([a], [b]) => localeCompare(a, b))
+      .reduce((set, [name, vuln]) => {
+        set[name] = vuln
+        return set
+      }, {})
+
+    return obj
+  }
+
+  constructor (tree, opts = {}) {
+    super()
+    this.#omit = new Set(opts.omit || [])
+    this.calculator = new Calculator(opts)
+    this.options = opts
+    this.tree = tree
+    this.filterSet = opts.filterSet
+  }
+
+  async run () {
+    this.report = await this.#getReport()
+    log.silly('audit report', this.report)
+    if (this.report) {
+      await this.#init()
+    }
+    return this
+  }
+
+  isVulnerable (node) {
+    const vuln = this.get(node.packageName)
+    return !!(vuln && vuln.isVulnerable(node))
+  }
+
+  async #init () {
+    const timeEnd = time.start('auditReport:init')
+
+    const promises = []
+    for (const [name, advisories] of Object.entries(this.report)) {
+      for (const advisory of advisories) {
+        promises.push(this.calculator.calculate(name, advisory))
+      }
+    }
+
+    // now the advisories are calculated with a set of versions
+    // and the packument.  turn them into our style of vuln objects
+    // which also have the affected nodes, and also create entries
+    // for all the metavulns that we find from dependents.
+    const advisories = new Set(await Promise.all(promises))
+    const seen = new Set()
+    for (const advisory of advisories) {
+      const { name, range } = advisory
+      const k = `${name}@${range}`
+
+      const vuln = this.get(name) || new Vuln({ name, advisory })
+      if (this.has(name)) {
+        vuln.addAdvisory(advisory)
+      }
+      super.set(name, vuln)
+
+      // don't flag the exact same name/range more than once
+      // adding multiple advisories with the same range is fine, but no
+      // need to search for nodes we already would have added.
+      if (!seen.has(k)) {
+        const p = []
+        for (const node of this.tree.inventory.query('packageName', name)) {
+          if (!this.shouldAudit(node)) {
+            continue
+          }
+
+          // if not vulnerable by this advisory, keep searching
+          if (!advisory.testVersion(node.version)) {
+            continue
+          }
+
+          // we will have loaded the source already if this is a metavuln
+          if (advisory.type === 'metavuln') {
+            vuln.addVia(this.get(advisory.dependency))
+          }
+
+          // already marked this one, no need to do it again
+          if (vuln.nodes.has(node)) {
+            continue
+          }
+
+          // haven't marked this one yet.  get its dependents.
+          vuln.nodes.add(node)
+          for (const { from: dep, spec } of node.edgesIn) {
+            if (dep.isTop && !vuln.topNodes.has(dep)) {
+              vuln.fixAvailable = this.#fixAvailable(vuln, spec)
+              if (vuln.fixAvailable !== true) {
+                // now we know the top node is vulnerable, and cannot be
+                // upgraded out of the bad place without --force.  But, there's
+                // no need to add it to the actual vulns list, because nothing
+                // depends on root.
+                this.topVulns.set(vuln.name, vuln)
+                vuln.topNodes.add(dep)
+              }
+            } else {
+            // calculate a metavuln, if necessary
+              const calc = this.calculator.calculate(dep.packageName, advisory)
+              // eslint-disable-next-line promise/always-return
+              p.push(calc.then(meta => {
+                // eslint-disable-next-line promise/always-return
+                if (meta.testVersion(dep.version, spec)) {
+                  advisories.add(meta)
+                }
+              }))
+            }
+          }
+        }
+        await Promise.all(p)
+        seen.add(k)
+      }
+
+      // make sure we actually got something.  if not, remove it
+      // this can happen if you are loading from a lockfile created by
+      // npm v5, since it lists the current version of all deps,
+      // rather than the range that is actually depended upon,
+      // or if using --omit with the older audit endpoint.
+      if (this.get(name).nodes.size === 0) {
+        this.delete(name)
+        continue
+      }
+
+      // if the vuln is valid, but THIS advisory doesn't apply to any of
+      // the nodes it references, then remove it from the advisory list.
+      // happens when using omit with old audit endpoint.
+      for (const advisory of vuln.advisories) {
+        const relevant = [...vuln.nodes]
+          .some(n => advisory.testVersion(n.version))
+        if (!relevant) {
+          vuln.deleteAdvisory(advisory)
+        }
+      }
+    }
+
+    timeEnd()
+  }
+
+  // given the spec, see if there is a fix available at all, and note whether or not it's a semver major fix or not (i.e. will need --force)
+  #fixAvailable (vuln, spec) {
+    // TODO we return true, false, OR an object here. this is probably a bad pattern.
+    if (!vuln.testSpec(spec)) {
+      return true
+    }
+
+    // even if we HAVE a packument, if we're looking for it somewhere other than the registry and we have something vulnerable then we're stuck with it.
+    const specObj = npa(spec)
+    if (!specObj.registry) {
+      return false
+    }
+
+    if (specObj.subSpec) {
+      spec = specObj.subSpec.rawSpec
+    }
+
+    // we don't provide fixes for top nodes other than root, but we still check to see if the node is fixable with a different version, and note if that is a semver major bump.
+    try {
+      const {
+        _isSemVerMajor: isSemVerMajor,
+        version,
+        name,
+      } = pickManifest(vuln.packument, spec, {
+        ...this.options,
+        before: null,
+        avoid: vuln.range,
+        avoidStrict: true,
+      })
+      return { name, version, isSemVerMajor }
+    } catch (er) {
+      return false
+    }
+  }
+
+  set () {
+    throw new Error('do not call AuditReport.set() directly')
+  }
+
+  async #getReport () {
+    // if we're not auditing, just return false
+    if (this.options.audit === false || this.options.offline === true || this.tree.inventory.size === 1) {
+      return null
+    }
+
+    const timeEnd = time.start('auditReport:getReport')
+    try {
+      const body = this.prepareBulkData()
+      log.silly('audit', 'bulk request', body)
+
+      // no sense asking if we don't have anything to audit,
+      // we know it'll be empty
+      if (!Object.keys(body).length) {
+        return null
+      }
+
+      const res = await npmFetch('/-/npm/v1/security/advisories/bulk', {
+        ...this.options,
+        registry: this.options.auditRegistry || this.options.registry,
+        method: 'POST',
+        gzip: true,
+        body,
+      })
+
+      return await res.json()
+    } catch (er) {
+      log.verbose('audit error', er)
+      log.silly('audit error', String(er.body))
+      this.error = er
+      return null
+    } finally {
+      timeEnd()
+    }
+  }
+
+  // return true if we should audit this one
+  shouldAudit (node) {
+    if (
+      !node.version ||
+      node.isRoot ||
+      node.isLink ||
+      node.linksIn?.size > 0 ||
+      (this.filterSet && this.filterSet?.size !== 0 && !this.filterSet?.has(node))
+    ) {
+      return false
+    }
+    if (this.#omit.size === 0) {
+      return true
+    }
+    return !node.shouldOmit(this.#omit)
+  }
+
+  prepareBulkData () {
+    const payload = {}
+    for (const name of this.tree.inventory.query('packageName')) {
+      const set = new Set()
+      for (const node of this.tree.inventory.query('packageName', name)) {
+        if (!this.shouldAudit(node)) {
+          continue
+        }
+
+        set.add(node.version)
+      }
+      if (set.size) {
+        payload[name] = [...set]
+      }
+    }
+    return payload
+  }
+}
+
+module.exports = AuditReport
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/calc-dep-flags.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/calc-dep-flags.js
new file mode 100644
index 0000000000000000000000000000000000000000..37b5d3c6f5decae976794a8fd6b32255482d25ea
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/calc-dep-flags.js
@@ -0,0 +1,103 @@
+// Dep flag (dev, peer, etc.) calculation requires default or reset flags.
+// Flags are true by default and are unset to false as we walk deps.
+// We iterate outward edges looking for dep flags that can
+// be unset based on the current nodes flags and edge type.
+// Examples:
+// - a non-optional node with a non-optional edge out, the edge node should not be optional
+// - a non-peer node with a non-peer edge out, the edge node should not be peer
+// If a node is changed, we add to the queue and continue until no more changes.
+// Flags that remain after all this unsetting should be valid.
+// Examples:
+// - a node still flagged optional must only be reachable via optional edges
+// - a node still flagged peer must only be reachable via peer edges
+const calcDepFlags = (tree, resetRoot = true) => {
+  if (resetRoot) {
+    tree.unsetDepFlags()
+  }
+
+  const seen = new Set()
+  const queue = [tree]
+
+  let node
+  while (node = queue.pop()) {
+    seen.add(node)
+
+    // Unset extraneous from all parents to avoid removal of children.
+    if (!node.extraneous) {
+      for (let n = node.resolveParent; n?.extraneous; n = n.resolveParent) {
+        n.extraneous = false
+      }
+    }
+
+    // for links, map their hierarchy appropriately
+    if (node.isLink) {
+      // node.target can be null, we check to ensure it's not null before proceeding
+      if (node.target == null) {
+        continue
+      }
+      node.target.dev = node.dev
+      node.target.optional = node.optional
+      node.target.devOptional = node.devOptional
+      node.target.peer = node.peer
+      node.target.extraneous = node.extraneous
+      queue.push(node.target)
+      continue
+    }
+
+    for (const { peer, optional, dev, to } of node.edgesOut.values()) {
+      // if the dep is missing, then its flags are already maximally unset
+      if (!to) {
+        continue
+      }
+
+      let changed = false
+
+      // only optional peer dependencies should stay extraneous
+      if (to.extraneous && !node.extraneous && !(peer && optional)) {
+        to.extraneous = false
+        changed = true
+      }
+
+      if (to.dev && !node.dev && !dev) {
+        to.dev = false
+        changed = true
+      }
+
+      if (to.optional && !node.optional && !optional) {
+        to.optional = false
+        changed = true
+      }
+
+      // devOptional is the *overlap* of the dev and optional tree.
+      // A node may be depended on by separate dev and optional nodes.
+      // It SHOULD NOT be removed when pruning dev OR optional.
+      // It SHOULD be removed when pruning dev AND optional.
+      // We only unset here if a node is not dev AND not optional because
+      // if we did unset, it would prevent any overlap deeper in the tree.
+      // We correct this later by removing if dev OR optional is set.
+      if (to.devOptional && !node.devOptional && !node.dev && !node.optional && !dev && !optional) {
+        to.devOptional = false
+        changed = true
+      }
+
+      if (to.peer && !node.peer && !peer) {
+        to.peer = false
+        changed = true
+      }
+
+      if (changed) {
+        queue.push(to)
+      }
+    }
+  }
+
+  // Remove incorrect devOptional flags now that we have walked all deps.
+  seen.delete(tree)
+  for (const node of seen.values()) {
+    if (node.devOptional && (node.dev || node.optional)) {
+      node.devOptional = false
+    }
+  }
+}
+
+module.exports = calcDepFlags
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/can-place-dep.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/can-place-dep.js
new file mode 100644
index 0000000000000000000000000000000000000000..aac98642406b1a0bd3761fe030d2e7ff0d4b1e60
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/can-place-dep.js
@@ -0,0 +1,436 @@
+// Internal methods used by buildIdealTree.
+// Answer the question: "can I put this dep here?"
+//
+// IMPORTANT: *nothing* in this class should *ever* modify or mutate the tree
+// at all.  The contract here is strictly limited to read operations.  We call
+// this in the process of walking through the ideal tree checking many
+// different potential placement targets for a given node.  If a change is made
+// to the tree along the way, that can cause serious problems!
+//
+// In order to enforce this restriction, in debug mode, canPlaceDep() will
+// snapshot the tree at the start of the process, and then at the end, will
+// verify that it still matches the snapshot, and throw an error if any changes
+// occurred.
+//
+// The algorithm is roughly like this:
+// - check the node itself:
+//   - if there is no version present, and no conflicting edges from target,
+//     OK, provided all peers can be placed at or above the target.
+//   - if the current version matches, KEEP
+//   - if there is an older version present, which can be replaced, then
+//     - if satisfying and preferDedupe? KEEP
+//     - else: REPLACE
+//   - if there is a newer version present, and preferDedupe, REPLACE
+//   - if the version present satisfies the edge, KEEP
+//   - else: CONFLICT
+// - if the node is not in conflict, check each of its peers:
+//   - if the peer can be placed in the target, continue
+//   - else if the peer can be placed in a parent, and there is no other
+//     conflicting version shadowing it, continue
+//   - else CONFLICT
+// - If the peers are not in conflict, return the original node's value
+//
+// An exception to this logic is that if the target is the deepest location
+// that a node can be placed, and the conflicting node can be placed deeper,
+// then we will return REPLACE rather than CONFLICT, and Arborist will queue
+// the replaced node for resolution elsewhere.
+
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const semver = require('semver')
+const debug = require('./debug.js')
+const peerEntrySets = require('./peer-entry-sets.js')
+const deepestNestingTarget = require('./deepest-nesting-target.js')
+
+const CONFLICT = Symbol('CONFLICT')
+const OK = Symbol('OK')
+const REPLACE = Symbol('REPLACE')
+const KEEP = Symbol('KEEP')
+
+class CanPlaceDep {
+  // dep is a dep that we're trying to place.  it should already live in
+  // a virtual tree where its peer set is loaded as children of the root.
+  // target is the actual place where we're trying to place this dep
+  // in a node_modules folder.
+  // edge is the edge that we're trying to satisfy with this placement.
+  // parent is the CanPlaceDep object of the entry node when placing a peer.
+  constructor (options) {
+    const {
+      dep,
+      target,
+      edge,
+      preferDedupe,
+      parent = null,
+      peerPath = [],
+      explicitRequest = false,
+    } = options
+
+    debug(() => {
+      if (!dep) {
+        throw new Error('no dep provided to CanPlaceDep')
+      }
+
+      if (!target) {
+        throw new Error('no target provided to CanPlaceDep')
+      }
+
+      if (!edge) {
+        throw new Error('no edge provided to CanPlaceDep')
+      }
+
+      this._treeSnapshot = JSON.stringify([...target.root.inventory.entries()]
+        .map(([loc, { packageName, version, resolved }]) => {
+          return [loc, packageName, version, resolved]
+        }).sort(([a], [b]) => localeCompare(a, b)))
+    })
+
+    // the result of whether we can place it or not
+    this.canPlace = null
+    // if peers conflict, but this one doesn't, then that is useful info
+    this.canPlaceSelf = null
+
+    this.dep = dep
+    this.target = target
+    this.edge = edge
+    this.explicitRequest = explicitRequest
+
+    // preventing cycles when we check peer sets
+    this.peerPath = peerPath
+    // we always prefer to dedupe peers, because they are trying
+    // a bit harder to be singletons.
+    this.preferDedupe = !!preferDedupe || edge.peer
+    this.parent = parent
+    this.children = []
+
+    this.isSource = target === this.peerSetSource
+    this.name = edge.name
+    this.current = target.children.get(this.name)
+    this.targetEdge = target.edgesOut.get(this.name)
+    this.conflicts = new Map()
+
+    // check if this dep was already subject to a peerDep override while
+    // building the peerSet.
+    this.edgeOverride = !dep.satisfies(edge)
+
+    this.canPlace = this.checkCanPlace()
+    if (!this.canPlaceSelf) {
+      this.canPlaceSelf = this.canPlace
+    }
+
+    debug(() => {
+      const treeSnapshot = JSON.stringify([...target.root.inventory.entries()]
+        .map(([loc, { packageName, version, resolved }]) => {
+          return [loc, packageName, version, resolved]
+        }).sort(([a], [b]) => localeCompare(a, b)))
+      /* istanbul ignore if */
+      if (this._treeSnapshot !== treeSnapshot) {
+        throw Object.assign(new Error('tree changed in CanPlaceDep'), {
+          expect: this._treeSnapshot,
+          actual: treeSnapshot,
+        })
+      }
+    })
+  }
+
+  checkCanPlace () {
+    const { target, targetEdge, current, dep } = this
+
+    // if the dep failed to load, we're going to fail the build or
+    // prune it out anyway, so just move forward placing/replacing it.
+    if (dep.errors.length) {
+      return current ? REPLACE : OK
+    }
+
+    // cannot place peers inside their dependents, except for tops
+    if (targetEdge && targetEdge.peer && !target.isTop) {
+      return CONFLICT
+    }
+
+    // skip this test if there's a current node, because we might be able
+    // to dedupe against it anyway
+    if (!current &&
+        targetEdge &&
+        !dep.satisfies(targetEdge) &&
+        targetEdge !== this.edge) {
+      return CONFLICT
+    }
+
+    return current ? this.checkCanPlaceCurrent() : this.checkCanPlaceNoCurrent()
+  }
+
+  // we know that the target has a dep by this name in its node_modules
+  // already.  Can return KEEP, REPLACE, or CONFLICT.
+  checkCanPlaceCurrent () {
+    const { preferDedupe, explicitRequest, current, target, edge, dep } = this
+
+    if (dep.matches(current)) {
+      if (current.satisfies(edge) || this.edgeOverride) {
+        return explicitRequest ? REPLACE : KEEP
+      }
+    }
+
+    const { version: curVer } = current
+    const { version: newVer } = dep
+    const tryReplace = curVer && newVer && semver.gte(newVer, curVer)
+    if (tryReplace && dep.canReplace(current)) {
+      // It's extremely rare that a replaceable node would be a conflict, if
+      // the current one wasn't a conflict, but it is theoretically possible
+      // if peer deps are pinned.  In that case we treat it like any other
+      // conflict, and keep trying.
+      const cpp = this.canPlacePeers(REPLACE)
+      if (cpp !== CONFLICT) {
+        return cpp
+      }
+    }
+
+    // ok, can't replace the current with new one, but maybe current is ok?
+    if (current.satisfies(edge) && (!explicitRequest || preferDedupe)) {
+      return KEEP
+    }
+
+    // if we prefer deduping, then try replacing newer with older
+    if (preferDedupe && !tryReplace && dep.canReplace(current)) {
+      const cpp = this.canPlacePeers(REPLACE)
+      if (cpp !== CONFLICT) {
+        return cpp
+      }
+    }
+
+    // Check for interesting cases!
+    // First, is this the deepest place that this thing can go, and NOT the
+    // deepest place where the conflicting dep can go?  If so, replace it,
+    // and let it re-resolve deeper in the tree.
+    const myDeepest = this.deepestNestingTarget
+
+    // ok, i COULD be placed deeper, so leave the current one alone.
+    if (target !== myDeepest) {
+      return CONFLICT
+    }
+
+    // if we are not checking a peerDep, then we MUST place it here, in the
+    // target that has a non-peer dep on it.
+    if (!edge.peer && target === edge.from) {
+      return this.canPlacePeers(REPLACE)
+    }
+
+    // if we aren't placing a peer in a set, then we're done here.
+    // This is ignored because it SHOULD be redundant, as far as I can tell,
+    // with the deepest target and target===edge.from tests.  But until we
+    // can prove that isn't possible, this condition is here for safety.
+    /* istanbul ignore if - allegedly impossible */
+    if (!this.parent && !edge.peer) {
+      return CONFLICT
+    }
+
+    // check the deps in the peer group for each edge into that peer group
+    // if ALL of them can be pushed deeper, or if it's ok to replace its
+    // members with the contents of the new peer group, then we're good.
+    let canReplace = true
+    for (const [entryEdge, currentPeers] of peerEntrySets(current)) {
+      if (entryEdge === this.edge || entryEdge === this.peerEntryEdge) {
+        continue
+      }
+
+      // First, see if it's ok to just replace the peerSet entirely.
+      // we do this by walking out from the entryEdge, because in a case like
+      // this:
+      //
+      // v -> PEER(a@1||2)
+      // a@1 -> PEER(b@1)
+      // a@2 -> PEER(b@2)
+      // b@1 -> PEER(a@1)
+      // b@2 -> PEER(a@2)
+      //
+      // root
+      // +-- v
+      // +-- a@2
+      // +-- b@2
+      //
+      // Trying to place a peer group of (a@1, b@1) would fail to note that
+      // they can be replaced, if we did it by looping 1 by 1.  If we are
+      // replacing something, we don't have to check its peer deps, because
+      // the peerDeps in the placed peerSet will presumably satisfy.
+      const entryNode = entryEdge.to
+      const entryRep = dep.parent.children.get(entryNode.name)
+      if (entryRep) {
+        if (entryRep.canReplace(entryNode, dep.parent.children.keys())) {
+          continue
+        }
+      }
+
+      let canClobber = !entryRep
+      if (!entryRep) {
+        const peerReplacementWalk = new Set([entryNode])
+        OUTER: for (const currentPeer of peerReplacementWalk) {
+          for (const edge of currentPeer.edgesOut.values()) {
+            if (!edge.peer || !edge.valid) {
+              continue
+            }
+            const rep = dep.parent.children.get(edge.name)
+            if (!rep) {
+              if (edge.to) {
+                peerReplacementWalk.add(edge.to)
+              }
+              continue
+            }
+            if (!rep.satisfies(edge)) {
+              canClobber = false
+              break OUTER
+            }
+          }
+        }
+      }
+      if (canClobber) {
+        continue
+      }
+
+      // ok, we can't replace, but maybe we can nest the current set deeper?
+      let canNestCurrent = true
+      for (const currentPeer of currentPeers) {
+        if (!canNestCurrent) {
+          break
+        }
+
+        // still possible to nest this peerSet
+        const curDeep = deepestNestingTarget(entryEdge.from, currentPeer.name)
+        if (curDeep === target || target.isDescendantOf(curDeep)) {
+          canNestCurrent = false
+          canReplace = false
+        }
+        if (canNestCurrent) {
+          continue
+        }
+      }
+    }
+
+    // if we can nest or replace all the current peer groups, we can replace.
+    if (canReplace) {
+      return this.canPlacePeers(REPLACE)
+    }
+
+    return CONFLICT
+  }
+
+  checkCanPlaceNoCurrent () {
+    const { target, peerEntryEdge, dep, name } = this
+
+    // check to see what that name resolves to here, and who may depend on
+    // being able to reach it by crawling up past the parent.  we know
+    // that it's not the target's direct child node, and if it was a direct
+    // dep of the target, we would have conflicted earlier.
+    const current = target !== peerEntryEdge.from && target.resolve(name)
+    if (current) {
+      for (const edge of current.edgesIn.values()) {
+        if (edge.from.isDescendantOf(target) && edge.valid) {
+          if (!dep.satisfies(edge)) {
+            return CONFLICT
+          }
+        }
+      }
+    }
+
+    // no objections, so this is fine as long as peers are ok here.
+    return this.canPlacePeers(OK)
+  }
+
+  get deepestNestingTarget () {
+    const start = this.parent ? this.parent.deepestNestingTarget
+      : this.edge.from
+    return deepestNestingTarget(start, this.name)
+  }
+
+  get conflictChildren () {
+    return this.allChildren.filter(c => c.canPlace === CONFLICT)
+  }
+
+  get allChildren () {
+    const set = new Set(this.children)
+    for (const child of set) {
+      for (const grandchild of child.children) {
+        set.add(grandchild)
+      }
+    }
+    return [...set]
+  }
+
+  get top () {
+    return this.parent ? this.parent.top : this
+  }
+
+  // check if peers can go here.  returns state or CONFLICT
+  canPlacePeers (state) {
+    this.canPlaceSelf = state
+    if (this._canPlacePeers) {
+      return this._canPlacePeers
+    }
+
+    // TODO: represent peerPath in ERESOLVE error somehow?
+    const peerPath = [...this.peerPath, this.dep]
+    let sawConflict = false
+    for (const peerEdge of this.dep.edgesOut.values()) {
+      if (!peerEdge.peer || !peerEdge.to || peerPath.includes(peerEdge.to)) {
+        continue
+      }
+      const peer = peerEdge.to
+      // it may be the case that the *initial* dep can be nested, but a peer
+      // of that dep needs to be placed shallower, because the target has
+      // a peer dep on the peer as well.
+      const target = deepestNestingTarget(this.target, peer.name)
+      const cpp = new CanPlaceDep({
+        dep: peer,
+        target,
+        parent: this,
+        edge: peerEdge,
+        peerPath,
+        // always place peers in preferDedupe mode
+        preferDedupe: true,
+      })
+      /* istanbul ignore next */
+      debug(() => {
+        if (this.children.some(c => c.dep === cpp.dep)) {
+          throw new Error('checking same dep repeatedly')
+        }
+      })
+      this.children.push(cpp)
+
+      if (cpp.canPlace === CONFLICT) {
+        sawConflict = true
+      }
+    }
+
+    this._canPlacePeers = sawConflict ? CONFLICT : state
+    return this._canPlacePeers
+  }
+
+  // what is the node that is causing this peerSet to be placed?
+  get peerSetSource () {
+    return this.parent ? this.parent.peerSetSource : this.edge.from
+  }
+
+  get peerEntryEdge () {
+    return this.top.edge
+  }
+
+  static get CONFLICT () {
+    return CONFLICT
+  }
+
+  static get OK () {
+    return OK
+  }
+
+  static get REPLACE () {
+    return REPLACE
+  }
+
+  static get KEEP () {
+    return KEEP
+  }
+
+  get description () {
+    const { canPlace } = this
+    return canPlace && canPlace.description ||
+    /* istanbul ignore next - old node affordance */ canPlace
+  }
+}
+
+module.exports = CanPlaceDep
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js
new file mode 100644
index 0000000000000000000000000000000000000000..ca235857f746d7fbea8562ba299d134718fe0ded
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/case-insensitive-map.js
@@ -0,0 +1,50 @@
+// package children are represented with a Map object, but many file systems
+// are case-insensitive and unicode-normalizing, so we need to treat
+// node.children.get('FOO') and node.children.get('foo') as the same thing.
+
+module.exports = class CIMap extends Map {
+  #keys = new Map()
+
+  constructor (items = []) {
+    super()
+    for (const [key, val] of items) {
+      this.set(key, val)
+    }
+  }
+
+  #normKey (key) {
+    if (typeof key !== 'string') {
+      return key
+    }
+    return key.normalize('NFKD').toLowerCase()
+  }
+
+  get (key) {
+    const normKey = this.#normKey(key)
+    return this.#keys.has(normKey) ? super.get(this.#keys.get(normKey))
+      : undefined
+  }
+
+  set (key, val) {
+    const normKey = this.#normKey(key)
+    if (this.#keys.has(normKey)) {
+      super.delete(this.#keys.get(normKey))
+    }
+    this.#keys.set(normKey, key)
+    return super.set(key, val)
+  }
+
+  delete (key) {
+    const normKey = this.#normKey(key)
+    if (this.#keys.has(normKey)) {
+      const prevKey = this.#keys.get(normKey)
+      this.#keys.delete(normKey)
+      return super.delete(prevKey)
+    }
+  }
+
+  has (key) {
+    const normKey = this.#normKey(key)
+    return this.#keys.has(normKey) && super.has(this.#keys.get(normKey))
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/consistent-resolve.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/consistent-resolve.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b73a42bb71a7fd932f4deae8a7dd18674f0c892
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/consistent-resolve.js
@@ -0,0 +1,44 @@
+// take a path and a resolved value, and turn it into a resolution from
+// the given new path.  This is used with converting a package.json's
+// relative file: path into one suitable for a lockfile, or between
+// lockfiles, and for converting hosted git repos to a consistent url type.
+const npa = require('npm-package-arg')
+const relpath = require('./relpath.js')
+const consistentResolve = (resolved, fromPath, toPath, relPaths = false) => {
+  if (!resolved) {
+    return null
+  }
+
+  try {
+    const hostedOpt = { noCommittish: false }
+    const {
+      fetchSpec,
+      saveSpec,
+      type,
+      hosted,
+      rawSpec,
+      raw,
+    } = npa(resolved, fromPath)
+    if (type === 'file' || type === 'directory') {
+      if (relPaths && toPath) {
+        return `file:${relpath(toPath, fetchSpec)}`
+      }
+      return `file:${fetchSpec}`
+    }
+    if (hosted) {
+      return `git+${hosted.auth ? hosted.https(hostedOpt) : hosted.sshurl(hostedOpt)}`
+    }
+    if (type === 'git') {
+      return saveSpec
+    }
+    if (rawSpec === '*') {
+      return raw
+    }
+    return rawSpec
+  } catch (_) {
+    // whatever we passed in was not acceptable to npa.
+    // leave it 100% untouched.
+    return resolved
+  }
+}
+module.exports = consistentResolve
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/debug.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/debug.js
new file mode 100644
index 0000000000000000000000000000000000000000..7283076f7c3ccaf147617394461d5b6638ba4ea9
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/debug.js
@@ -0,0 +1,32 @@
+// certain assertions we should do only when testing arborist itself, because
+// they are too expensive or aggressive and would break user programs if we
+// miss a situation where they are actually valid.
+//
+// call like this:
+//
+// /* istanbul ignore next - debug check */
+// debug(() => {
+//   if (someExpensiveCheck)
+//     throw new Error('expensive check should have returned false')
+// })
+
+// run in debug mode if explicitly requested, running arborist tests,
+// or working in the arborist project directory.
+
+const debug = process.env.ARBORIST_DEBUG !== '0' && (
+  process.env.ARBORIST_DEBUG === '1' ||
+  /\barborist\b/.test(process.env.NODE_DEBUG || '') ||
+  process.env.npm_package_name === '@npmcli/arborist' &&
+  ['test', 'snap'].includes(process.env.npm_lifecycle_event) ||
+  process.cwd() === require('node:path').resolve(__dirname, '..')
+)
+
+module.exports = debug ? fn => fn() : () => {}
+const red = process.stderr.isTTY ? msg => `\x1B[31m${msg}\x1B[39m` : m => m
+module.exports.log = (...msg) => module.exports(() => {
+  const { format } = require('node:util')
+  const prefix = `\n${process.pid} ${red(format(msg.shift()))} `
+  msg = (prefix + format(...msg).trim().split('\n').join(prefix)).trim()
+  /* eslint-disable-next-line no-console */
+  console.error(msg)
+})
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/deepest-nesting-target.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/deepest-nesting-target.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb5f6b9497ee29671a30cb73a051e899439aa027
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/deepest-nesting-target.js
@@ -0,0 +1,18 @@
+// given a starting node, what is the *deepest* target where name could go?
+// This is not on the Node class for the simple reason that we sometimes
+// need to check the deepest *potential* target for a Node that is not yet
+// added to the tree where we are checking.
+const deepestNestingTarget = (start, name) => {
+  for (const target of start.ancestry()) {
+    // note: this will skip past the first target if edge is peer
+    if (target.isProjectRoot || !target.resolveParent || target.globalTop) {
+      return target
+    }
+    const targetEdge = target.edgesOut.get(name)
+    if (!targetEdge || !targetEdge.peer) {
+      return target
+    }
+  }
+}
+
+module.exports = deepestNestingTarget
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/dep-valid.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/dep-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd903c679c2c61b33912a31d0ef642e2c5a27f87
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/dep-valid.js
@@ -0,0 +1,150 @@
+// Do not rely on package._fields, so that we don't throw
+// false failures if a tree is generated by other clients.
+// Only relies on child.resolved, which MAY come from
+// client-specific package.json meta _fields, but most of
+// the time will be pulled out of a lockfile
+
+const semver = require('semver')
+const npa = require('npm-package-arg')
+const { relative } = require('node:path')
+const fromPath = require('./from-path.js')
+
+const depValid = (child, requested, requestor) => {
+  // NB: we don't do much to verify 'tag' type requests.
+  // Just verify that we got a remote resolution.  Presumably, it
+  // came from a registry and was tagged at some point.
+
+  if (typeof requested === 'string') {
+    try {
+      // tarball/dir must have resolved to the same tgz on disk, but for
+      // file: deps that depend on other files/dirs, we must resolve the
+      // location based on the *requestor* file/dir, not where it ends up.
+      // '' is equivalent to '*'
+      requested = npa.resolve(child.name, requested || '*', fromPath(requestor, requestor.edgesOut.get(child.name)))
+    } catch (er) {
+      // Not invalid because the child doesn't match, but because
+      // the spec itself is not supported.  Nothing would match,
+      // so the edge is definitely not valid and never can be.
+      er.dependency = child.name
+      er.requested = requested
+      requestor.errors.push(er)
+      return false
+    }
+  }
+
+  // if the lockfile is super old, or hand-modified,
+  // then it's possible to hit this state.
+  if (!requested) {
+    const er = new Error('Invalid dependency specifier')
+    er.dependency = child.name
+    er.requested = requested
+    requestor.errors.push(er)
+    return false
+  }
+
+  switch (requested.type) {
+    case 'range':
+      if (requested.fetchSpec === '*') {
+        return true
+      }
+      // fallthrough
+    case 'version':
+      // if it's a version or a range other than '*', semver it
+      return semver.satisfies(child.version, requested.fetchSpec, true)
+
+    case 'directory':
+      return linkValid(child, requested, requestor)
+
+    case 'file':
+      return tarballValid(child, requested, requestor)
+
+    case 'alias':
+      // check that the alias target is valid
+      return depValid(child, requested.subSpec, requestor)
+
+    case 'tag':
+      // if it's a tag, we just verify that it has a tarball resolution
+      // presumably, it came from the registry and was tagged at some point
+      return child.resolved && npa(child.resolved).type === 'remote'
+
+    case 'remote':
+      // verify that we got it from the desired location
+      return child.resolved === requested.fetchSpec
+
+    case 'git': {
+      // if it's a git type, verify that they're the same repo
+      //
+      // if it specifies a definite commit, then it must have the
+      // same commit to be considered the same repo
+      //
+      // if it has a #semver:<range> specifier, verify that the
+      // version in the package is in the semver range
+      const resRepo = npa(child.resolved || '')
+      const resHost = resRepo.hosted
+      const reqHost = requested.hosted
+      const reqCommit = /^[a-fA-F0-9]{40,64}$/.test(requested.gitCommittish || '')
+      const nc = { noCommittish: !reqCommit }
+      if (!resHost) {
+        if (resRepo.fetchSpec !== requested.fetchSpec) {
+          return false
+        }
+      } else {
+        if (reqHost?.ssh(nc) !== resHost.ssh(nc)) {
+          return false
+        }
+      }
+      if (!requested.gitRange) {
+        return true
+      }
+      return semver.satisfies(child.package.version, requested.gitRange, {
+        loose: true,
+      })
+    }
+
+    default: // impossible, just being cautious
+      break
+  }
+
+  const er = new Error('Unsupported dependency type')
+  er.dependency = child.name
+  er.requested = requested
+  requestor.errors.push(er)
+  return false
+}
+
+const linkValid = (child, requested, requestor) => {
+  const isLink = !!child.isLink
+  // if we're installing links and the node is a link, then it's invalid because we want
+  // a real node to be there.  Except for workspaces. They are always links.
+  if (requestor.installLinks && !child.isWorkspace) {
+    return !isLink
+  }
+
+  // directory must be a link to the specified folder
+  return isLink && relative(child.realpath, requested.fetchSpec) === ''
+}
+
+const tarballValid = (child, requested) => {
+  if (child.isLink) {
+    return false
+  }
+
+  if (child.resolved) {
+    return child.resolved.replace(/\\/g, '/') === `file:${requested.fetchSpec.replace(/\\/g, '/')}`
+  }
+
+  // if we have a legacy mutated package.json file.  we can't be 100%
+  // sure that it resolved to the same file, but if it was the same
+  // request, that's a pretty good indicator of sameness.
+  if (child.package._requested) {
+    return child.package._requested.saveSpec === requested.saveSpec
+  }
+
+  // ok, we're probably dealing with some legacy cruft here, not much
+  // we can do at this point unfortunately.
+  return false
+}
+
+module.exports = (child, requested, accept, requestor) =>
+  depValid(child, requested, requestor) ||
+  (typeof accept === 'string' ? depValid(child, accept, requestor) : false)
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/diff.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/diff.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f705d18eaab80898f75a1bea22959ced7b52be1
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/diff.js
@@ -0,0 +1,330 @@
+// a tree representing the difference between two trees
+// A Diff node's parent is not necessarily the parent of
+// the node location it refers to, but rather the highest level
+// node that needs to be either changed or removed.
+// Thus, the root Diff node is the shallowest change required
+// for a given branch of the tree being mutated.
+
+const { depth } = require('treeverse')
+const { existsSync } = require('node:fs')
+
+const ssri = require('ssri')
+
+class Diff {
+  constructor ({ actual, ideal, filterSet, shrinkwrapInflated, omit }) {
+    this.omit = omit
+    this.filterSet = filterSet
+    this.shrinkwrapInflated = shrinkwrapInflated
+    this.children = []
+    this.actual = actual
+    this.ideal = ideal
+    if (this.ideal) {
+      this.resolved = this.ideal.resolved
+      this.integrity = this.ideal.integrity
+    }
+    this.action = getAction(this)
+    this.parent = null
+    // the set of leaf nodes that we rake up to the top level
+    this.leaves = []
+    // the set of nodes that don't change in this branch of the tree
+    this.unchanged = []
+    // the set of nodes that will be removed in this branch of the tree
+    this.removed = []
+  }
+
+  static calculate ({
+    actual,
+    ideal,
+    filterNodes = [],
+    shrinkwrapInflated = new Set(),
+    omit = new Set(),
+  }) {
+    // if there's a filterNode, then:
+    // - get the path from the root to the filterNode.  The root or
+    //   root.target should have an edge either to the filterNode or
+    //   a link to the filterNode.  If not, abort.  Add the path to the
+    //   filterSet.
+    // - Add set of Nodes depended on by the filterNode to filterSet.
+    // - Anything outside of that set should be ignored by getChildren
+    const filterSet = new Set()
+    const extraneous = new Set()
+    for (const filterNode of filterNodes) {
+      const { root } = filterNode
+      if (root !== ideal && root !== actual) {
+        throw new Error('invalid filterNode: outside idealTree/actualTree')
+      }
+      const rootTarget = root.target
+      const edge = [...rootTarget.edgesOut.values()].filter(e => {
+        return e.to && (e.to === filterNode || e.to.target === filterNode)
+      })[0]
+      filterSet.add(root)
+      filterSet.add(rootTarget)
+      filterSet.add(ideal)
+      filterSet.add(actual)
+      if (edge && edge.to) {
+        filterSet.add(edge.to)
+        filterSet.add(edge.to.target)
+      }
+      filterSet.add(filterNode)
+
+      depth({
+        tree: filterNode,
+        visit: node => filterSet.add(node),
+        getChildren: node => {
+          const orig = node
+          node = node.target
+          const loc = node.location
+          const idealNode = ideal.inventory.get(loc)
+          const ideals = !idealNode ? []
+            : [...idealNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
+          const actualNode = actual.inventory.get(loc)
+          const actuals = !actualNode ? []
+            : [...actualNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
+          if (actualNode) {
+            for (const child of actualNode.children.values()) {
+              if (child.extraneous) {
+                extraneous.add(child)
+              }
+            }
+          }
+
+          const result = ideals.concat(actuals)
+          // Include link targets so store entries end up in filterSet
+          if (orig.isLink) {
+            result.push(node)
+          }
+          return result
+        },
+      })
+    }
+    for (const extra of extraneous) {
+      filterSet.add(extra)
+    }
+
+    return depth({
+      tree: new Diff({ actual, ideal, filterSet, shrinkwrapInflated, omit }),
+      getChildren,
+      leave,
+    })
+  }
+}
+
+const getAction = ({ actual, ideal }) => {
+  if (!ideal) {
+    return 'REMOVE'
+  }
+
+  // bundled meta-deps are copied over to the ideal tree when we visit it,
+  // so they'll appear to be missing here.  There's no need to handle them
+  // in the diff, though, because they'll be replaced at reify time anyway
+  // Otherwise, add the missing node.
+  if (!actual) {
+    return ideal.inDepBundle ? null : 'ADD'
+  }
+
+  // always ignore the root node
+  if (ideal.isRoot && actual.isRoot) {
+    return null
+  }
+
+  // if the versions don't match, it's a change no matter what
+  if (ideal.version !== actual.version) {
+    return 'CHANGE'
+  }
+
+  const binsExist = ideal.binPaths.every((path) => existsSync(path))
+
+  // top nodes, links, and git deps won't have integrity, but do have resolved
+  // if neither node has integrity, the bins exist, and either (a) neither
+  // node has a resolved value or (b) they both do and match, then we can
+  // leave this one alone since we already know the versions match due to
+  // the condition above.  The "neither has resolved" case (a) cannot be
+  // treated as a 'mark CHANGE and refetch', because shrinkwraps, bundles,
+  // and link deps may lack this information, and we don't want to try to
+  // go to the registry for something that isn't there.
+  const noIntegrity = !ideal.integrity && !actual.integrity
+  const noResolved = !ideal.resolved && !actual.resolved
+  const resolvedMatch = ideal.resolved && ideal.resolved === actual.resolved
+  if (noIntegrity && binsExist && (resolvedMatch || noResolved)) {
+    return null
+  }
+
+  // otherwise, verify that it's the same bits
+  // note that if ideal has integrity, and resolved doesn't, we treat
+  // that as a 'change', so that it gets re-fetched and locked down.
+  const integrityMismatch = !ideal.integrity || !actual.integrity ||
+    !ssri.parse(ideal.integrity).match(actual.integrity)
+  if (integrityMismatch || !binsExist) {
+    return 'CHANGE'
+  }
+
+  return null
+}
+
+const allChildren = node => {
+  if (!node) {
+    return new Map()
+  }
+
+  // if the node is root, and also a link, then what we really
+  // want is to traverse the target's children
+  if (node.isRoot && node.isLink) {
+    return allChildren(node.target)
+  }
+
+  const kids = new Map()
+  for (const n of [node, ...node.fsChildren]) {
+    for (const kid of n.children.values()) {
+      kids.set(kid.path, kid)
+    }
+  }
+  return kids
+}
+
+// functions for the walk options when we traverse the trees
+// to create the diff tree
+const getChildren = diff => {
+  const children = []
+  const {
+    actual,
+    ideal,
+    unchanged,
+    removed,
+    filterSet,
+    shrinkwrapInflated,
+    omit,
+  } = diff
+
+  // Note: we DON'T diff fsChildren themselves, because they are either
+  // included in the package contents, or part of some other project, and
+  // will never appear in legacy shrinkwraps anyway.  but we _do_ include the
+  // child nodes of fsChildren, because those are nodes that we are typically
+  // responsible for installing.
+  const actualKids = allChildren(actual)
+  const idealKids = allChildren(ideal)
+
+  if (ideal && ideal.hasShrinkwrap && !shrinkwrapInflated.has(ideal)) {
+    // Guaranteed to get a diff.leaves here, because we always
+    // be called with a proper Diff object when ideal has a shrinkwrap
+    // that has not been inflated.
+    diff.leaves.push(diff)
+    return children
+  }
+
+  const paths = new Set([...actualKids.keys(), ...idealKids.keys()])
+  for (const path of paths) {
+    const actual = actualKids.get(path)
+    const ideal = idealKids.get(path)
+    diffNode({
+      actual,
+      ideal,
+      children,
+      unchanged,
+      removed,
+      filterSet,
+      shrinkwrapInflated,
+      omit,
+    })
+  }
+
+  if (diff.leaves && !children.length) {
+    diff.leaves.push(diff)
+  }
+
+  return children
+}
+
+const diffNode = ({
+  actual,
+  ideal,
+  children,
+  unchanged,
+  removed,
+  filterSet,
+  shrinkwrapInflated,
+  omit,
+}) => {
+  if (filterSet.size && !(filterSet.has(ideal) || filterSet.has(actual))) {
+    return
+  }
+
+  if (ideal?.shouldOmit?.(omit)) {
+    ideal.inert = true
+  }
+
+  // Treat inert nodes as undefined for the purposes of diffing.
+  if (ideal?.inert) {
+    ideal = undefined
+  }
+  if (!actual && !ideal) {
+    return
+  }
+
+  const action = getAction({ actual, ideal })
+
+  // if it's a match, then get its children
+  // otherwise, this is the child diff node
+  if (action || (!shrinkwrapInflated.has(ideal) && ideal.hasShrinkwrap)) {
+    if (action === 'REMOVE') {
+      removed.push(actual)
+    }
+    children.push(new Diff({ actual, ideal, filterSet, shrinkwrapInflated, omit }))
+  } else {
+    unchanged.push(ideal)
+    // !*! Weird dirty hack warning !*!
+    //
+    // Bundled deps aren't loaded in the ideal tree, because we don't know
+    // what they are going to be without unpacking.  Swap them over now if
+    // the bundling node isn't changing, so we don't prune them later.
+    //
+    // It's a little bit dirty to be doing this here, since it means that
+    // diffing trees can mutate them, but otherwise we have to walk over
+    // all unchanging bundlers and correct the diff later, so it's more
+    // efficient to just fix it while we're passing through already.
+    //
+    // Note that moving over a bundled dep will break the links to other
+    // deps under this parent, which may have been transitively bundled.
+    // Breaking those links means that we'll no longer see the transitive
+    // dependency, meaning that it won't appear as bundled any longer!
+    // In order to not end up dropping transitively bundled deps, we have
+    // to get the list of nodes to move, then move them all at once, rather
+    // than moving them one at a time in the first loop.
+    const bd = ideal.package.bundleDependencies
+    if (actual && bd && bd.length) {
+      const bundledChildren = []
+      for (const node of actual.children.values()) {
+        if (node.inBundle) {
+          bundledChildren.push(node)
+        }
+      }
+      for (const node of bundledChildren) {
+        node.parent = ideal
+      }
+    }
+    children.push(...getChildren({
+      actual,
+      ideal,
+      unchanged,
+      removed,
+      filterSet,
+      shrinkwrapInflated,
+      omit,
+    }))
+  }
+}
+
+// set the parentage in the leave step so that we aren't attaching
+// child nodes only to remove them later.  also bubble up the unchanged
+// nodes so that we can move them out of staging in the reification step.
+const leave = (diff, children) => {
+  children.forEach(kid => {
+    kid.parent = diff
+    diff.leaves.push(...kid.leaves)
+    diff.unchanged.push(...kid.unchanged)
+    diff.removed.push(...kid.removed)
+  })
+  diff.children = children
+  return diff
+}
+
+module.exports = Diff
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/edge.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/edge.js
new file mode 100644
index 0000000000000000000000000000000000000000..374fcee4143d09a358624726c4083789a220b5d7
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/edge.js
@@ -0,0 +1,364 @@
+// An edge in the dependency graph
+// Represents a dependency relationship of some kind
+
+const util = require('node:util')
+const npa = require('npm-package-arg')
+const depValid = require('./dep-valid.js')
+const OverrideSet = require('./override-set.js')
+
+class ArboristEdge {
+  constructor (edge) {
+    this.name = edge.name
+    this.spec = edge.spec
+    this.type = edge.type
+
+    const edgeFrom = edge.from?.location
+    const edgeTo = edge.to?.location
+    const override = edge.overrides?.value
+
+    if (edgeFrom != null) {
+      this.from = edgeFrom
+    }
+    if (edgeTo) {
+      this.to = edgeTo
+    }
+    if (edge.error) {
+      this.error = edge.error
+    }
+    if (edge.peerConflicted) {
+      this.peerConflicted = true
+    }
+    if (override) {
+      this.overridden = override
+    }
+  }
+}
+
+class Edge {
+  #accept
+  #error
+  #explanation
+  #from
+  #name
+  #spec
+  #to
+  #type
+
+  static types = Object.freeze([
+    'prod',
+    'dev',
+    'optional',
+    'peer',
+    'peerOptional',
+    'workspace',
+  ])
+
+  // XXX where is this used?
+  static errors = Object.freeze([
+    'DETACHED',
+    'MISSING',
+    'PEER LOCAL',
+    'INVALID',
+  ])
+
+  constructor (options) {
+    const { type, name, spec, accept, from, overrides } = options
+
+    // XXX are all of these error states even possible?
+    if (typeof spec !== 'string') {
+      throw new TypeError('must provide string spec')
+    }
+    if (!Edge.types.includes(type)) {
+      throw new TypeError(`invalid type: ${type}\n(valid types are: ${Edge.types.join(', ')})`)
+    }
+    if (type === 'workspace' && npa(spec).type !== 'directory') {
+      throw new TypeError('workspace edges must be a symlink')
+    }
+    if (typeof name !== 'string') {
+      throw new TypeError('must provide dependency name')
+    }
+    if (!from) {
+      throw new TypeError('must provide "from" node')
+    }
+    if (accept !== undefined) {
+      if (typeof accept !== 'string') {
+        throw new TypeError('accept field must be a string if provided')
+      }
+      this.#accept = accept || '*'
+    }
+    if (overrides !== undefined) {
+      this.overrides = overrides
+    }
+
+    this.#name = name
+    this.#type = type
+    this.#spec = spec
+    this.#explanation = null
+    this.#from = from
+
+    from.edgesOut.get(this.#name)?.detach()
+    from.addEdgeOut(this)
+
+    this.reload(true)
+    this.peerConflicted = false
+  }
+
+  satisfiedBy (node) {
+    if (node.name !== this.#name || !this.#from) {
+      return false
+    }
+
+    // NOTE: this condition means we explicitly do not support overriding
+    // bundled or shrinkwrapped dependencies
+    if (node.hasShrinkwrap || node.inShrinkwrap || node.inBundle) {
+      return depValid(node, this.rawSpec, this.#accept, this.#from)
+    }
+
+    // If there's no override we just use the spec.
+    if (!this.overrides?.keySpec) {
+      return depValid(node, this.spec, this.#accept, this.#from)
+    }
+    // There's some override. If the target node satisfies the overriding spec
+    // then it's okay.
+    if (depValid(node, this.spec, this.#accept, this.#from)) {
+      return true
+    }
+    // If it doesn't, then it should at least satisfy the original spec.
+    if (!depValid(node, this.rawSpec, this.#accept, this.#from)) {
+      return false
+    }
+    // It satisfies the original spec, not the overriding spec. We need to make
+    // sure it doesn't use the overridden spec.
+    // For example:
+    //   we might have an ^8.0.0 rawSpec, and an override that makes
+    //   keySpec=8.23.0 and the override value spec=9.0.0.
+    //   If the node is 9.0.0, then it's okay because it's consistent with spec.
+    //   If the node is 8.24.0, then it's okay because it's consistent with the rawSpec.
+    //   If the node is 8.23.0, then it's not okay because even though it's consistent
+    //   with the rawSpec, it's also consistent with the keySpec.
+    //   So we're looking for ^8.0.0 or 9.0.0 and not 8.23.0.
+    return !depValid(node, this.overrides.keySpec, this.#accept, this.#from)
+  }
+
+  // return the edge data, and an explanation of how that edge came to be here
+  explain (seen = []) {
+    if (!this.#explanation) {
+      const explanation = {
+        type: this.#type,
+        name: this.#name,
+        spec: this.spec,
+      }
+      if (this.rawSpec !== this.spec) {
+        explanation.rawSpec = this.rawSpec
+        explanation.overridden = true
+      }
+      if (this.bundled) {
+        explanation.bundled = this.bundled
+      }
+      if (this.error) {
+        explanation.error = this.error
+      }
+      if (this.#from) {
+        explanation.from = this.#from.explain(null, seen)
+      }
+      this.#explanation = explanation
+    }
+    return this.#explanation
+  }
+
+  get bundled () {
+    return !!this.#from?.package?.bundleDependencies?.includes(this.#name)
+  }
+
+  get workspace () {
+    return this.#type === 'workspace'
+  }
+
+  get prod () {
+    return this.#type === 'prod'
+  }
+
+  get dev () {
+    return this.#type === 'dev'
+  }
+
+  get optional () {
+    return this.#type === 'optional' || this.#type === 'peerOptional'
+  }
+
+  get peer () {
+    return this.#type === 'peer' || this.#type === 'peerOptional'
+  }
+
+  get type () {
+    return this.#type
+  }
+
+  get name () {
+    return this.#name
+  }
+
+  get rawSpec () {
+    return this.#spec
+  }
+
+  get spec () {
+    if (this.overrides?.value && this.overrides.value !== '*' && this.overrides.name === this.#name) {
+      if (this.overrides.value.startsWith('$')) {
+        const ref = this.overrides.value.slice(1)
+        let pkg = this.#from?.sourceReference
+          ? this.#from?.sourceReference.root.package
+          : this.#from?.root?.package
+
+        let specValue = this.#calculateReferentialOverrideSpec(ref, pkg)
+
+        // If the package isn't found in the root package, fall back to the local package.
+        if (!specValue) {
+          pkg = this.#from?.package
+          specValue = this.#calculateReferentialOverrideSpec(ref, pkg)
+        }
+
+        if (specValue) {
+          return specValue
+        }
+        throw new Error(`Unable to resolve reference ${this.overrides.value}`)
+      }
+      return this.overrides.value
+    }
+    return this.#spec
+  }
+
+  #calculateReferentialOverrideSpec (ref, pkg) {
+    if (pkg.devDependencies?.[ref]) {
+      return pkg.devDependencies[ref]
+    }
+    if (pkg.optionalDependencies?.[ref]) {
+      return pkg.optionalDependencies[ref]
+    }
+    if (pkg.dependencies?.[ref]) {
+      return pkg.dependencies[ref]
+    }
+    if (pkg.peerDependencies?.[ref]) {
+      return pkg.peerDependencies[ref]
+    }
+  }
+
+  get accept () {
+    return this.#accept
+  }
+
+  get valid () {
+    return !this.error
+  }
+
+  get missing () {
+    return this.error === 'MISSING'
+  }
+
+  get invalid () {
+    return this.error === 'INVALID'
+  }
+
+  get peerLocal () {
+    return this.error === 'PEER LOCAL'
+  }
+
+  get error () {
+    if (!this.#error) {
+      if (!this.#to) {
+        if (this.optional) {
+          this.#error = null
+        } else {
+          this.#error = 'MISSING'
+        }
+      } else if (this.peer && this.#from === this.#to.parent && !this.#from?.isTop) {
+        this.#error = 'PEER LOCAL'
+      } else if (!this.satisfiedBy(this.#to)) {
+        this.#error = 'INVALID'
+      } else if (this.overrides && this.#to.overrides && this.#to.edgesOut.size && OverrideSet.doOverrideSetsConflict(this.overrides, this.#to.overrides)) {
+        // Check for conflicts between the edge's override set and the target node's override set.
+        // This catches cases where different parts of the tree have genuinely incompatible
+        // version requirements for the same package.
+        // The improved conflict detection uses semantic comparison (checking for incompatible
+        // version ranges) rather than pure structural equality, avoiding false positives from:
+        // - Reference overrides ($syntax) that resolve to compatible versions
+        // - Peer dependencies with different but compatible override contexts
+        // Note: We only check if the target has dependencies (edgesOut.size > 0), since
+        // override conflicts are only relevant if the target has its own dependencies.
+        this.#error = 'INVALID'
+      } else {
+        this.#error = 'OK'
+      }
+    }
+    if (this.#error === 'OK') {
+      return null
+    }
+    return this.#error
+  }
+
+  reload (hard = false) {
+    this.#explanation = null
+
+    let needToUpdateOverrideSet = false
+    let newOverrideSet
+    let oldOverrideSet
+    if (this.#from?.overrides) {
+      newOverrideSet = this.#from.overrides.getEdgeRule(this)
+      if (newOverrideSet && !newOverrideSet.isEqual(this.overrides)) {
+        // If there's a new different override set we need to propagate it to the nodes.
+        // If we're deleting the override set then there's no point propagating it right now since it will be filled with another value later.
+        needToUpdateOverrideSet = true
+        oldOverrideSet = this.overrides
+        this.overrides = newOverrideSet
+      }
+    } else {
+      delete this.overrides
+    }
+    const newTo = this.#from?.resolve(this.#name)
+    if (newTo !== this.#to) {
+      if (this.#to) {
+        this.#to.deleteEdgeIn(this)
+      }
+      this.#to = newTo
+      this.#error = null
+      if (this.#to) {
+        this.#to.addEdgeIn(this)
+      }
+    } else if (hard) {
+      this.#error = null
+    } else if (needToUpdateOverrideSet && this.#to) {
+      // Propagate the new override set to the target node.
+      this.#to.updateOverridesEdgeInRemoved(oldOverrideSet)
+      this.#to.updateOverridesEdgeInAdded(newOverrideSet)
+    }
+  }
+
+  detach () {
+    this.#explanation = null
+    if (this.#to) {
+      this.#to.deleteEdgeIn(this)
+    }
+    this.#from?.edgesOut.delete(this.#name)
+    this.#to = null
+    this.#error = 'DETACHED'
+    this.#from = null
+  }
+
+  get from () {
+    return this.#from
+  }
+
+  get to () {
+    return this.#to
+  }
+
+  toJSON () {
+    return new ArboristEdge(this)
+  }
+
+  [util.inspect.custom] () {
+    return this.toJSON()
+  }
+}
+
+module.exports = Edge
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/from-path.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/from-path.js
new file mode 100644
index 0000000000000000000000000000000000000000..012fd17aa881574a342411f6d0efb03619887e12
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/from-path.js
@@ -0,0 +1,30 @@
+// file dependencies need their dependencies resolved based on the location
+// where the tarball was found, not the location where they end up getting
+// installed.  directory (ie, symlink) deps also need to be resolved based on
+// their targets, but that's what realpath is
+
+const { dirname } = require('node:path')
+const npa = require('npm-package-arg')
+
+const fromPath = (node, edge) => {
+  if (edge && edge.overrides && edge.overrides.name === edge.name && edge.overrides.value) {
+    // fromPath could be called with a node that has a virtual root, if that
+    // happens we want to make sure we get the real root node when overrides
+    // are in use. this is to allow things like overriding a dependency with a
+    // tarball file that's a relative path from the project root
+    if (node.sourceReference) {
+      return node.sourceReference.root.realpath
+    }
+    return node.root.realpath
+  }
+
+  if (node.resolved) {
+    const spec = npa(node.resolved)
+    if (spec?.type === 'file') {
+      return dirname(spec.fetchSpec)
+    }
+  }
+  return node.realpath
+}
+
+module.exports = fromPath
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/gather-dep-set.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/gather-dep-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8cb60263b458b93cb99829b6bd93594da684e09
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/gather-dep-set.js
@@ -0,0 +1,43 @@
+// Given a set of nodes in a tree, and a filter function to test
+// incoming edges to the dep set that should be ignored otherwise.
+//
+// find the set of deps that are only depended upon by nodes in the set, or
+// their dependencies, or edges that are ignored.
+//
+// Used when figuring out what to prune when replacing a node with a newer
+// version, or when an optional dep fails to install.
+
+const gatherDepSet = (set, edgeFilter) => {
+  const deps = new Set(set)
+
+  // add the full set of dependencies.  note that this loop will continue
+  // as the deps set increases in size.
+  for (const node of deps) {
+    for (const edge of node.edgesOut.values()) {
+      if (edge.to && edgeFilter(edge)) {
+        deps.add(edge.to)
+      }
+    }
+  }
+
+  // now remove all nodes in the set that have a dependent outside the set
+  // if any change is made, then re-check
+  // continue until no changes made, or deps set evaporates fully.
+  let changed = true
+  while (changed === true && deps.size > 0) {
+    changed = false
+    for (const dep of deps) {
+      for (const edge of dep.edgesIn) {
+        if (!deps.has(edge.from) && edgeFilter(edge)) {
+          changed = true
+          deps.delete(dep)
+          break
+        }
+      }
+    }
+  }
+
+  return deps
+}
+
+module.exports = gatherDepSet
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/index.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..085b4bebf41463e52ac93920609f7f06d78c1453
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/index.js
@@ -0,0 +1,6 @@
+module.exports = require('./arborist/index.js')
+module.exports.Arborist = module.exports
+module.exports.Node = require('./node.js')
+module.exports.Link = require('./link.js')
+module.exports.Edge = require('./edge.js')
+module.exports.Shrinkwrap = require('./shrinkwrap.js')
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/inventory.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/inventory.js
new file mode 100644
index 0000000000000000000000000000000000000000..bb4cfa0ebcda1ed0a7f333bc513bd4ae1becad18
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/inventory.js
@@ -0,0 +1,137 @@
+// a class to manage an inventory and set of indexes of a set of objects based on specific fields.
+const { hasOwnProperty } = Object.prototype
+const debug = require('./debug.js')
+
+const keys = ['name', 'license', 'funding', 'realpath', 'packageName']
+class Inventory extends Map {
+  #index
+
+  constructor () {
+    super()
+    this.#index = new Map()
+    for (const key of keys) {
+      this.#index.set(key, new Map())
+    }
+  }
+
+  // XXX where is this used?
+  get primaryKey () {
+    return 'location'
+  }
+
+  // XXX where is this used?
+  get indexes () {
+    return [...keys]
+  }
+
+  * filter (fn) {
+    for (const node of this.values()) {
+      if (fn(node)) {
+        yield node
+      }
+    }
+  }
+
+  add (node) {
+    const root = super.get('')
+    if (root && node.root !== root && node.root !== root.root) {
+      debug(() => {
+        throw Object.assign(new Error('adding external node to inventory'), {
+          root: root.path,
+          node: node.path,
+          nodeRoot: node.root.path,
+        })
+      })
+      return
+    }
+
+    const current = super.get(node.location)
+    if (current) {
+      if (current === node) {
+        return
+      }
+      this.delete(current)
+    }
+    super.set(node.location, node)
+    for (const [key, map] of this.#index.entries()) {
+      let val
+      if (hasOwnProperty.call(node, key)) {
+        // if the node has the value, use it even if it's false
+        val = node[key]
+      } else if (key === 'license' && node.package) {
+        // handling for the outdated "licenses" array, just pick the first one
+        // also support the alternative spelling "licence"
+        if (node.package.license) {
+          val = node.package.license
+        } else if (node.package.licence) {
+          val = node.package.licence
+        } else if (Array.isArray(node.package.licenses)) {
+          val = node.package.licenses[0]
+        } else if (Array.isArray(node.package.licences)) {
+          val = node.package.licences[0]
+        }
+      } else if (node[key]) {
+        val = node[key]
+      } else {
+        val = node.package?.[key]
+      }
+      if (val && typeof val === 'object') {
+        // We currently only use license and funding
+        /* istanbul ignore next - not used */
+        if (key === 'license') {
+          val = val.type
+        } else if (key === 'funding') {
+          val = val.url
+        }
+      }
+      if (!map.has(val)) {
+        map.set(val, new Set())
+      }
+      map.get(val).add(node)
+    }
+  }
+
+  delete (node) {
+    if (!this.has(node)) {
+      return
+    }
+
+    super.delete(node.location)
+    for (const [key, map] of this.#index.entries()) {
+      let val
+      if (node[key] !== undefined) {
+        val = node[key]
+      } else {
+        val = node.package?.[key]
+      }
+      const set = map.get(val)
+      if (set) {
+        set.delete(node)
+        if (set.size === 0) {
+          map.delete(node[key])
+        }
+      }
+    }
+  }
+
+  query (key, val) {
+    const map = this.#index.get(key)
+    if (arguments.length === 2) {
+      if (map.has(val)) {
+        return map.get(val)
+      }
+      return new Set()
+    }
+    return map.keys()
+  }
+
+  has (node) {
+    return super.get(node.location) === node
+  }
+
+  set () {
+    throw new Error('direct set() not supported, use inventory.add(node)')
+  }
+}
+
+module.exports = Inventory
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/isolated-classes.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/isolated-classes.js
new file mode 100644
index 0000000000000000000000000000000000000000..0738d75d8de17efd2dc933b5f124a919b3fada2d
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/isolated-classes.js
@@ -0,0 +1,138 @@
+// Alternate versions of different classes that we use for isolated mode
+const CaseInsensitiveMap = require('./case-insensitive-map.js')
+const { resolve } = require('node:path')
+
+// fake lib/inventory.js
+class IsolatedInventory extends Map {
+  query () {
+    return []
+  }
+}
+
+// fake lib/node.js
+class IsolatedNode {
+  binPaths = []
+  children = new CaseInsensitiveMap()
+  edgesIn = new Set()
+  edgesOut = new CaseInsensitiveMap()
+  fsChildren = new Set()
+  hasShrinkwrap = false
+  integrity = null
+  inventory = new IsolatedInventory()
+  isInStore = false
+  linksIn = new Set()
+  meta = { loadedFromDisk: false }
+  optional = false
+  parent = null
+  root = null
+  tops = new Set()
+  workspaces = new Map()
+
+  constructor (options) {
+    this.location = options.location
+    this.name = options.name
+    this.package = options.package
+    this.path = options.path
+    this.realpath = !this.isLink ? this.path : resolve(options.realpath)
+
+    if (options.parent) {
+      this.parent = options.parent
+    }
+    if (options.resolved) {
+      this.resolved = options.resolved
+    }
+    if (options.root) {
+      this.root = options.root
+    }
+    if (options.isInStore) {
+      this.isInStore = true
+    }
+    if (options.optional) {
+      this.optional = true
+    }
+  }
+
+  get isRoot () {
+    return this === this.root
+  }
+
+  // The idealGraph is where this is set to true
+  get isProjectRoot () {
+    return false
+  }
+
+  get inDepBundle () {
+    return false
+  }
+
+  get isLink () {
+    return false
+  }
+
+  get isTop () {
+    return !this.parent
+  }
+
+  /* istanbul ignore next -- emulate lib/node.js */
+  get global () {
+    return false
+  }
+
+  get globalTop () {
+    return false
+  }
+
+  /* istanbul ignore next -- emulate lib/node.js */
+  set target (t) {
+    // nop
+    // In the real lib/node.js this throws in debug mode
+  }
+
+  get target () {
+    return this
+  }
+
+  /* istanbul ignore next -- emulate lib/node.js */
+  getBundler () {
+    return null
+  }
+
+  /* istanbul ignore next -- emulate lib/node.js */
+  get hasInstallScript () {
+    const { hasInstallScript, scripts } = this.package
+    const { install, preinstall, postinstall } = scripts || {}
+    return !!(hasInstallScript || install || preinstall || postinstall)
+  }
+
+  get version () {
+    return this.package.version
+  }
+}
+
+// fake lib/link.js
+class IsolatedLink extends IsolatedNode {
+  #target
+  isStoreLink = false
+
+  constructor (options) {
+    super(options)
+    this.#target = options.target
+    if (options.isStoreLink) {
+      this.isStoreLink = true
+    }
+  }
+
+  get isLink () {
+    return true
+  }
+
+  set target (t) {
+    this.#target = t
+  }
+
+  get target () {
+    return this.#target
+  }
+}
+
+module.exports = { IsolatedNode, IsolatedLink }
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/link.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/link.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac1278524dfdcdec7fcf660ab32fceda0a273463
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/link.js
@@ -0,0 +1,126 @@
+const relpath = require('./relpath.js')
+const Node = require('./node.js')
+const _loadDeps = Symbol.for('Arborist.Node._loadDeps')
+const _target = Symbol.for('_target')
+const { dirname } = require('node:path')
+// defined by Node class
+const _delistFromMeta = Symbol.for('_delistFromMeta')
+const _refreshLocation = Symbol.for('_refreshLocation')
+class Link extends Node {
+  constructor (options) {
+    const { root, realpath, target, parent, fsParent, isStoreLink } = options
+
+    if (!realpath && !(target && target.path)) {
+      throw new TypeError('must provide realpath for Link node')
+    }
+
+    super({
+      ...options,
+      realpath: realpath || target.path,
+      root: root || (parent ? parent.root
+      : fsParent ? fsParent.root
+      : target ? target.root
+      : null),
+    })
+
+    this.isStoreLink = isStoreLink || false
+
+    if (target) {
+      this.target = target
+    } else if (this.realpath === this.root.path) {
+      this.target = this.root
+    } else {
+      this.target = new Node({
+        ...options,
+        path: realpath,
+        parent: null,
+        fsParent: null,
+        root: this.root,
+      })
+    }
+  }
+
+  get version () {
+    return this.target ? this.target.version : this.package.version || ''
+  }
+
+  get target () {
+    return this[_target]
+  }
+
+  set target (target) {
+    const current = this[_target]
+    if (target === current) {
+      return
+    }
+
+    if (!target) {
+      if (current && current.linksIn) {
+        current.linksIn.delete(this)
+      }
+      if (this.path) {
+        this[_delistFromMeta]()
+        this[_target] = null
+        this.package = {}
+        this[_refreshLocation]()
+      } else {
+        this[_target] = null
+      }
+      return
+    }
+
+    if (!this.path) {
+      // temp node pending assignment to a tree
+      // we know it's not in the inventory yet, because no path.
+      if (target.path) {
+        this.realpath = target.path
+      } else {
+        target.path = target.realpath = this.realpath
+      }
+      target.root = this.root
+      this[_target] = target
+      target.linksIn.add(this)
+      this.package = target.package
+      return
+    }
+
+    // have to refresh metadata, because either realpath or package
+    // is very likely changing.
+    this[_delistFromMeta]()
+    this.package = target.package
+    this.realpath = target.path
+    this[_refreshLocation]()
+
+    target.root = this.root
+  }
+
+  // a link always resolves to the relative path to its target
+  get resolved () {
+    // the path/realpath guard is there for the benefit of setting
+    // these things in the "wrong" order
+    return this.path && this.realpath
+      ? `file:${relpath(dirname(this.path), this.realpath)}`
+      : null
+  }
+
+  set resolved (r) {}
+
+  // deps are resolved on the target, not the Link
+  // so this is a no-op
+  [_loadDeps] () {}
+
+  // links can't have children, only their targets can
+  // fix it to an empty list so that we can still call
+  // things that iterate over them, just as a no-op
+  get children () {
+    return new Map()
+  }
+
+  set children (c) {}
+
+  get isLink () {
+    return true
+  }
+}
+
+module.exports = Link
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/node.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/node.js
new file mode 100644
index 0000000000000000000000000000000000000000..47d5002bd82f2d9113708da661ba253cb64f0a8c
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/node.js
@@ -0,0 +1,1631 @@
+// inventory, path, realpath, root, and parent
+//
+// node.root is a reference to the root module in the tree (ie, typically the
+// cwd project folder)
+//
+// node.location is the /-delimited path from the root module to the node.  In
+// the case of link targets that may be outside of the root's package tree,
+// this can include some number of /../ path segments.  The location of the
+// root module is always '.'.  node.location thus never contains drive letters
+// or absolute paths, and is portable within a given project, suitable for
+// inclusion in lockfiles and metadata.
+//
+// node.path is the path to the place where this node lives on disk.  It is
+// system-specific and absolute.
+//
+// node.realpath is the path to where the module actually resides on disk.  In
+// the case of non-link nodes, node.realpath is equivalent to node.path.  In
+// the case of link nodes, it is equivalent to node.target.path.
+//
+// Setting node.parent will set the node's root to the parent's root, as well
+// as updating edgesIn and edgesOut to reload dependency resolutions as needed,
+// and setting node.path to parent.path/node_modules/name.
+//
+// node.inventory is a Map of name to a Set() of all the nodes under a given
+// root by that name.  It's empty for non-root nodes, and changing the root
+// reference will remove it from the old root's inventory and add it to the new
+// one.  This map is useful for cases like `npm update foo` or `npm ls foo`
+// where we need to quickly find all instances of a given package name within a
+// tree.
+
+const PackageJson = require('@npmcli/package-json')
+const nameFromFolder = require('@npmcli/name-from-folder')
+const npa = require('npm-package-arg')
+const semver = require('semver')
+const util = require('node:util')
+const { getPaths: getBinPaths } = require('bin-links')
+const { log } = require('proc-log')
+const { resolve, relative, dirname, basename } = require('node:path')
+const { walkUp } = require('walk-up-path')
+
+const CaseInsensitiveMap = require('./case-insensitive-map.js')
+const Edge = require('./edge.js')
+const Inventory = require('./inventory.js')
+const OverrideSet = require('./override-set.js')
+const consistentResolve = require('./consistent-resolve.js')
+const debug = require('./debug.js')
+const gatherDepSet = require('./gather-dep-set.js')
+const printableTree = require('./printable.js')
+const querySelectorAll = require('./query-selector-all.js')
+const relpath = require('./relpath.js')
+const treeCheck = require('./tree-check.js')
+
+const _package = Symbol('_package')
+const _parent = Symbol('_parent')
+const _target = Symbol.for('_target')
+const _fsParent = Symbol('_fsParent')
+const _reloadNamedEdges = Symbol('_reloadNamedEdges')
+// overridden by Link class
+const _loadDeps = Symbol.for('Arborist.Node._loadDeps')
+const _refreshLocation = Symbol.for('_refreshLocation')
+const _changePath = Symbol.for('_changePath')
+// used by Link class as well
+const _delistFromMeta = Symbol.for('_delistFromMeta')
+const _explain = Symbol('_explain')
+const _explanation = Symbol('_explanation')
+
+class Node {
+  #global
+  #meta
+  #root
+  #workspaces
+
+  constructor (options) {
+    // NB: path can be null if it's a link target
+    const {
+      children,
+      dev = true,
+      devOptional = true,
+      dummy = false,
+      error,
+      extraneous = true,
+      fsChildren,
+      fsParent,
+      global = false,
+      hasShrinkwrap,
+      inert = false,
+      installLinks = false,
+      integrity,
+      isInStore = false,
+      legacyPeerDeps = false,
+      linksIn,
+      loadOverrides = false,
+      meta,
+      name, // allow setting name explicitly when we haven't set a path yet
+      optional = true,
+      overrides,
+      parent,
+      path,
+      peer = true,
+      realpath,
+      resolved,
+      root,
+      sourceReference = null,
+    } = options
+    // this object gives querySelectorAll somewhere to stash context about a node
+    // while processing a query
+    this.queryContext = {}
+
+    // true if part of a global install
+    this.#global = global
+
+    this.#workspaces = null
+
+    this.errors = error ? [error] : []
+    this.isInStore = isInStore
+
+    // this will usually be null, except when modeling a
+    // package's dependencies in a virtual root.
+    this.sourceReference = sourceReference
+
+    // have to set the internal package ref before assigning the parent, because this.package is read when adding to inventory
+    if (sourceReference) {
+      this[_package] = sourceReference.package
+    } else {
+      // TODO if this came from pacote.manifest we don't have to do this, we can be told to skip this step
+      const pkg = new PackageJson()
+      let content = {}
+      // TODO this is overly guarded.  If pkg is not an object we should not allow it at all.
+      if (options.pkg && typeof options.pkg === 'object') {
+        content = options.pkg
+      }
+      pkg.fromContent(content)
+      pkg.syncNormalize()
+      this[_package] = pkg.content
+    }
+
+    this.name = name ||
+      nameFromFolder(path || this.package.name || realpath) ||
+      this.package.name ||
+      null
+
+    // should be equal if not a link
+    this.path = path ? resolve(path) : null
+
+    if (!this.name && (!this.path || this.path !== dirname(this.path))) {
+      throw new TypeError('could not detect node name from path or package')
+    }
+
+    this.realpath = !this.isLink ? this.path : resolve(realpath)
+
+    this.resolved = resolved || null
+    if (!this.resolved) {
+      // note: this *only* works for non-file: deps, so we avoid even
+      // trying here.
+      // file: deps are tracked in package.json will _resolved set to the
+      // full path to the tarball or link target.  However, if the package
+      // is checked into git or moved to another location, that's 100% not
+      // portable at all!  The _where and _location don't provide much help,
+      // since _location is just where the module ended up in the tree,
+      // and _where can be different than the actual root if it's a
+      // meta-dep deeper in the dependency graph.
+      //
+      // If we don't have the other oldest indicators of legacy npm, then it's
+      // probably what we're getting from pacote, which IS trustworthy.
+      //
+      // Otherwise, hopefully a shrinkwrap will help us out.
+      const resolved = consistentResolve(this.package._resolved)
+      if (resolved && !(/^file:/.test(resolved) && this.package._where)) {
+        this.resolved = resolved
+      }
+    }
+    this.integrity = integrity || this.package._integrity || null
+    this.hasShrinkwrap = hasShrinkwrap || this.package._hasShrinkwrap || false
+    this.installLinks = installLinks
+    this.legacyPeerDeps = legacyPeerDeps
+
+    this.children = new CaseInsensitiveMap()
+    this.fsChildren = new Set()
+    this.inventory = new Inventory()
+    this.tops = new Set()
+    this.linksIn = new Set(linksIn || [])
+
+    // these three are set by an Arborist taking a catalog
+    // after the tree is built.  We don't get this along the way,
+    // because they have a tendency to change as new children are
+    // added, especially when they're deduped.  Eg, a dev dep may be
+    // a 3-levels-deep dependency of a non-dev dep.  If we calc the
+    // flags along the way, then they'll tend to be invalid  by the
+    // time we need to look at them.
+    if (!dummy) {
+      this.dev = dev
+      this.optional = optional
+      this.devOptional = devOptional
+      this.peer = peer
+      this.extraneous = extraneous
+      this.dummy = false
+    } else {
+      // true if this is a placeholder for the purpose of serving as a
+      // fsParent to link targets that get their deps resolved outside
+      // the root tree folder.
+      this.dummy = true
+      this.dev = false
+      this.optional = false
+      this.devOptional = false
+      this.peer = false
+      this.extraneous = false
+    }
+
+    this.inert = inert
+
+    this.edgesIn = new Set()
+    this.edgesOut = new CaseInsensitiveMap()
+
+    if (overrides) {
+      this.overrides = overrides
+    } else if (loadOverrides) {
+      const overrides = this.package.overrides || {}
+      if (Object.keys(overrides).length > 0) {
+        this.overrides = new OverrideSet({
+          overrides: this.package.overrides,
+        })
+      }
+    }
+
+    // only relevant for the root and top nodes
+    this.meta = meta
+
+    // Note: this is _slightly_ less efficient for the initial tree
+    // building than it could be, but in exchange, it's a much simpler
+    // algorithm.
+    // If this node has a bunch of children, and those children satisfy
+    // its various deps, then we're going to _first_ create all the
+    // edges, and _then_ assign the children into place, re-resolving
+    // them all in _reloadNamedEdges.
+    // A more efficient, but more complicated, approach would be to
+    // flag this node as being a part of a tree build, so it could
+    // hold off on resolving its deps until its children are in place.
+
+    // call the parent setter
+    // Must be set prior to calling _loadDeps, because top-ness is relevant
+
+    // will also assign root if present on the parent
+    this[_parent] = null
+    this.parent = parent || null
+
+    this[_fsParent] = null
+    this.fsParent = fsParent || null
+
+    // see parent/root setters below.
+    // root is set to parent's root if we have a parent; otherwise, if it's
+    // null, then it's set to the node itself.
+    if (!parent && !fsParent) {
+      this.root = root || null
+    }
+
+    // mostly a convenience for testing, but also a way to create
+    // trees in a more declarative way than setting parent on each
+    if (children) {
+      for (const c of children) {
+        new Node({ ...c, parent: this })
+      }
+    }
+    if (fsChildren) {
+      for (const c of fsChildren) {
+        new Node({ ...c, fsParent: this })
+      }
+    }
+
+    // now load all the dep edges
+    this[_loadDeps]()
+  }
+
+  get meta () {
+    return this.#meta
+  }
+
+  set meta (meta) {
+    this.#meta = meta
+    if (meta) {
+      meta.add(this)
+    }
+  }
+
+  get global () {
+    if (this.#root === this) {
+      return this.#global
+    }
+    return this.#root.global
+  }
+
+  // true for packages installed directly in the global node_modules folder
+  get globalTop () {
+    return this.global && this.parent && this.parent.isProjectRoot
+  }
+
+  get workspaces () {
+    return this.#workspaces
+  }
+
+  set workspaces (workspaces) {
+    // deletes edges if they already exists
+    if (this.#workspaces) {
+      for (const name of this.#workspaces.keys()) {
+        if (!workspaces.has(name)) {
+          this.edgesOut.get(name).detach()
+        }
+      }
+    }
+
+    this.#workspaces = workspaces
+    this.#loadWorkspaces()
+    this[_loadDeps]()
+  }
+
+  get binPaths () {
+    if (!this.parent) {
+      return []
+    }
+
+    return getBinPaths({
+      pkg: this.package,
+      path: this.path,
+      global: this.global,
+      top: this.globalTop,
+    })
+  }
+
+  get hasInstallScript () {
+    const { hasInstallScript, scripts } = this.package
+    const { install, preinstall, postinstall } = scripts || {}
+    return !!(hasInstallScript || install || preinstall || postinstall)
+  }
+
+  get version () {
+    return this.package.version || ''
+  }
+
+  get packageName () {
+    return this.package.name || null
+  }
+
+  get pkgid () {
+    const { name = '', version = '' } = this.package
+    // root package will prefer package name over folder name,
+    // and never be called an alias.
+    const { isProjectRoot } = this
+    const myname = isProjectRoot ? name || this.name
+      : this.name
+    const alias = !isProjectRoot && name && myname !== name ? `npm:${name}@`
+      : ''
+    return `${myname}@${alias}${version}`
+  }
+
+  get overridden () {
+    if (!this.overrides) {
+      return false
+    }
+    if (!this.overrides.value) {
+      return false
+    }
+    if (this.overrides.name !== this.name) {
+      return false
+    }
+
+    // The overrides rule is for a package with this name, but some override rules only apply to specific
+    // versions. To make sure this package was actually overridden, we check whether any edge going in
+    // had the rule applied to it, in which case its overrides set is different than its source node.
+    for (const edge of this.edgesIn) {
+      if (edge.overrides && edge.overrides.name === this.name && edge.overrides.value === this.version) {
+        if (!edge.overrides.isEqual(edge.from.overrides)) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }
+
+  get package () {
+    return this[_package]
+  }
+
+  set package (pkg) {
+    // just detach them all.  we could make this _slightly_ more efficient
+    // by only detaching the ones that changed, but we'd still have to walk
+    // them all, and the comparison logic gets a bit tricky.  we generally
+    // only do this more than once at the root level, so the resolve() calls
+    // are only one level deep, and there's not much to be saved, anyway.
+    // simpler to just toss them all out.
+    for (const edge of this.edgesOut.values()) {
+      edge.detach()
+    }
+
+    this[_explanation] = null
+    /* istanbul ignore next - should be impossible */
+    if (!pkg || typeof pkg !== 'object') {
+      debug(() => {
+        throw new Error('setting Node.package to non-object')
+      })
+      pkg = {}
+    }
+    this[_package] = pkg
+    this.#loadWorkspaces()
+    this[_loadDeps]()
+    // do a hard reload, since the dependents may now be valid or invalid
+    // as a result of the package change.
+    this.edgesIn.forEach(edge => edge.reload(true))
+  }
+
+  // node.explain(nodes seen already, edge we're trying to satisfy
+  // if edge is not specified, it lists every edge into the node.
+  explain (edge = null, seen = []) {
+    if (this[_explanation]) {
+      return this[_explanation]
+    }
+
+    return this[_explanation] = this[_explain](edge, seen)
+  }
+
+  [_explain] (edge, seen) {
+    if (this.isProjectRoot && !this.sourceReference) {
+      return {
+        location: this.path,
+      }
+    }
+
+    const why = {
+      name: this.isProjectRoot || this.isTop ? this.packageName : this.name,
+      version: this.package.version,
+    }
+    if (this.errors.length || !this.packageName || !this.package.version) {
+      why.errors = this.errors.length ? this.errors : [
+        new Error('invalid package: lacks name and/or version'),
+      ]
+      why.package = this.package
+    }
+
+    if (this.root.sourceReference) {
+      const { name, version } = this.root.package
+      why.whileInstalling = {
+        name,
+        version,
+        path: this.root.sourceReference.path,
+      }
+    }
+
+    if (this.sourceReference) {
+      return this.sourceReference.explain(edge, seen)
+    }
+
+    if (seen.includes(this)) {
+      return why
+    }
+
+    why.location = this.location
+    why.isWorkspace = this.isWorkspace
+
+    // make a new list each time.  we can revisit, but not loop.
+    seen = seen.concat(this)
+
+    why.dependents = []
+    if (edge) {
+      why.dependents.push(edge.explain(seen))
+    } else {
+      // ignore invalid edges, since those aren't satisfied by this thing,
+      // and are not keeping it held in this spot anyway.
+      const edges = []
+      for (const edge of this.edgesIn) {
+        if (!edge.valid && !edge.from.isProjectRoot) {
+          continue
+        }
+
+        edges.push(edge)
+      }
+      for (const edge of edges) {
+        why.dependents.push(edge.explain(seen))
+      }
+    }
+
+    if (this.linksIn.size) {
+      why.linksIn = [...this.linksIn].map(link => link[_explain](edge, seen))
+    }
+
+    return why
+  }
+
+  isDescendantOf (node) {
+    for (let p = this; p; p = p.resolveParent) {
+      if (p === node) {
+        return true
+      }
+    }
+    return false
+  }
+
+  shouldOmit (omitSet) {
+    if (!omitSet.size) {
+      return false
+    }
+
+    const { top } = this
+
+    // if the top is not the root or workspace then we do not want to omit it
+    if (!top.isProjectRoot && !top.isWorkspace) {
+      return false
+    }
+
+    // omit node if the dep type matches any omit flags that were set
+    return (
+      this.peer && omitSet.has('peer') ||
+      this.dev && omitSet.has('dev') ||
+      this.optional && omitSet.has('optional') ||
+      this.devOptional && omitSet.has('optional') && omitSet.has('dev')
+    )
+  }
+
+  getBundler (path = []) {
+    // made a cycle, definitely not bundled!
+    if (path.includes(this)) {
+      return null
+    }
+
+    path.push(this)
+
+    const parent = this[_parent]
+    if (!parent) {
+      return null
+    }
+
+    const pBundler = parent.getBundler(path)
+    if (pBundler) {
+      return pBundler
+    }
+
+    const ppkg = parent.package
+    const bd = ppkg && ppkg.bundleDependencies
+    // explicit bundling
+    if (Array.isArray(bd) && bd.includes(this.name)) {
+      return parent
+    }
+
+    // deps that are deduped up to the bundling level are bundled.
+    // however, if they get their dep met further up than that,
+    // then they are not bundled.  Ie, installing a package with
+    // unmet bundled deps will not cause your deps to be bundled.
+    for (const edge of this.edgesIn) {
+      const eBundler = edge.from.getBundler(path)
+      if (!eBundler) {
+        continue
+      }
+
+      if (eBundler === parent) {
+        return eBundler
+      }
+    }
+
+    return null
+  }
+
+  get inBundle () {
+    return !!this.getBundler()
+  }
+
+  // when reifying, if a package is technically in a bundleDependencies list,
+  // but that list is the root project, we still have to install it.  This
+  // getter returns true if it's in a dependency's bundle list, not the root's.
+  get inDepBundle () {
+    const bundler = this.getBundler()
+    return !!bundler && bundler !== this.root
+  }
+
+  get isWorkspace () {
+    if (this.isProjectRoot) {
+      return false
+    }
+    const { root } = this
+    const { type, to } = root.edgesOut.get(this.packageName) || {}
+    return type === 'workspace' && to && (to.target === this || to === this)
+  }
+
+  get isRoot () {
+    return this === this.root
+  }
+
+  get isProjectRoot () {
+    // only treat as project root if it's the actual link that is the root, or the target of the root link, but NOT if it's another link to the same root that happens to be somewhere else.
+    return this === this.root || this === this.root.target
+  }
+
+  get isRegistryDependency () {
+    if (this.edgesIn.size === 0) {
+      return false
+    }
+    for (const edge of this.edgesIn) {
+      if (!npa(edge.spec).registry) {
+        return false
+      }
+    }
+    return true
+  }
+
+  * ancestry () {
+    for (let anc = this; anc; anc = anc.resolveParent) {
+      yield anc
+    }
+  }
+
+  set root (root) {
+    // setting to null means this is the new root
+    // should only ever be one step
+    while (root && root.root !== root) {
+      root = root.root
+    }
+
+    root = root || this
+
+    // delete from current root inventory
+    this[_delistFromMeta]()
+
+    // can't set the root (yet) if there's no way to determine location
+    // this allows us to do new Node({...}) and then set the root later.
+    // just make the assignment so we don't lose it, and move on.
+    if (!this.path || !root.realpath || !root.path) {
+      this.#root = root
+      return
+    }
+
+    // temporarily become a root node
+    this.#root = this
+
+    // break all linksIn, we're going to re-set them if needed later
+    for (const link of this.linksIn) {
+      link[_target] = null
+      this.linksIn.delete(link)
+    }
+
+    // temporarily break this link as well, we'll re-set if possible later
+    const { target } = this
+    if (this.isLink) {
+      if (target) {
+        target.linksIn.delete(this)
+        if (target.root === this) {
+          target[_delistFromMeta]()
+        }
+      }
+      this[_target] = null
+    }
+
+    // if this is part of a cascading root set, then don't do this bit
+    // but if the parent/fsParent is in a different set, we have to break
+    // that reference before proceeding
+    if (this.parent && this.parent.root !== root) {
+      this.parent.children.delete(this.name)
+      this[_parent] = null
+    }
+    if (this.fsParent && this.fsParent.root !== root) {
+      this.fsParent.fsChildren.delete(this)
+      this[_fsParent] = null
+    }
+
+    if (root === this) {
+      this[_refreshLocation]()
+    } else {
+      // setting to some different node.
+      const loc = relpath(root.realpath, this.path)
+      const current = root.inventory.get(loc)
+
+      // clobber whatever is there now
+      if (current) {
+        current.root = null
+      }
+
+      this.#root = root
+      // set this.location and add to inventory
+      this[_refreshLocation]()
+
+      // try to find our parent/fsParent in the new root inventory
+      for (const p of walkUp(dirname(this.path))) {
+        if (p === this.path) {
+          continue
+        }
+        const ploc = relpath(root.realpath, p)
+        const parent = root.inventory.get(ploc)
+        if (parent) {
+          /* istanbul ignore next - impossible */
+          if (parent.isLink) {
+            debug(() => {
+              throw Object.assign(new Error('assigning parentage to link'), {
+                path: this.path,
+                parent: parent.path,
+                parentReal: parent.realpath,
+              })
+            })
+            continue
+          }
+          const childLoc = `${ploc}${ploc ? '/' : ''}node_modules/${this.name}`
+          const isParent = this.location === childLoc
+          if (isParent) {
+            const oldChild = parent.children.get(this.name)
+            if (oldChild && oldChild !== this) {
+              oldChild.root = null
+            }
+            if (this.parent) {
+              this.parent.children.delete(this.name)
+              this.parent[_reloadNamedEdges](this.name)
+            }
+            parent.children.set(this.name, this)
+            this[_parent] = parent
+            // don't do it for links, because they don't have a target yet
+            // we'll hit them up a bit later on.
+            if (!this.isLink) {
+              parent[_reloadNamedEdges](this.name)
+            }
+          } else {
+            /* istanbul ignore if - should be impossible, since we break
+             * all fsParent/child relationships when moving? */
+            if (this.fsParent) {
+              this.fsParent.fsChildren.delete(this)
+            }
+            parent.fsChildren.add(this)
+            this[_fsParent] = parent
+          }
+          break
+        }
+      }
+
+      // if it doesn't have a parent, it's a top node
+      if (!this.parent) {
+        root.tops.add(this)
+      } else {
+        root.tops.delete(this)
+      }
+
+      // assign parentage for any nodes that need to have this as a parent
+      // this can happen when we have a node at nm/a/nm/b added *before*
+      // the node at nm/a, which might have the root node as a fsParent.
+      // we can't rely on the public setter here, because it calls into
+      // this function to set up these references!
+      // check dirname so that /foo isn't treated as the fsparent of /foo-bar
+      const nmloc = `${this.location}${this.location ? '/' : ''}node_modules/`
+      // only walk top nodes, since anything else already has a parent.
+      for (const child of root.tops) {
+        const isChild = child.location === nmloc + child.name
+        const isFsChild =
+          dirname(child.path).startsWith(this.path) &&
+          child !== this &&
+          !child.parent &&
+          (
+            !child.fsParent ||
+            child.fsParent === this ||
+            dirname(this.path).startsWith(child.fsParent.path)
+          )
+
+        if (!isChild && !isFsChild) {
+          continue
+        }
+
+        // set up the internal parentage links
+        if (this.isLink) {
+          child.root = null
+        } else {
+          // can't possibly have a parent, because it's in tops
+          if (child.fsParent) {
+            child.fsParent.fsChildren.delete(child)
+          }
+          child[_fsParent] = null
+          if (isChild) {
+            this.children.set(child.name, child)
+            child[_parent] = this
+            root.tops.delete(child)
+          } else {
+            this.fsChildren.add(child)
+            child[_fsParent] = this
+          }
+        }
+      }
+
+      // look for any nodes with the same realpath.  either they're links
+      // to that realpath, or a thing at that realpath if we're adding a link
+      // (if we're adding a regular node, we already deleted the old one)
+      for (const node of root.inventory.query('realpath', this.realpath)) {
+        if (node === this) {
+          continue
+        }
+
+        /* istanbul ignore next - should be impossible */
+        debug(() => {
+          if (node.root !== root) {
+            throw new Error('inventory contains node from other root')
+          }
+        })
+
+        if (this.isLink) {
+          const target = node.target
+          this[_target] = target
+          this[_package] = target.package
+          target.linksIn.add(this)
+          // reload edges here, because now we have a target
+          if (this.parent) {
+            this.parent[_reloadNamedEdges](this.name)
+          }
+          break
+        } else {
+          /* istanbul ignore else - should be impossible */
+          if (node.isLink) {
+            node[_target] = this
+            node[_package] = this.package
+            this.linksIn.add(node)
+            if (node.parent) {
+              node.parent[_reloadNamedEdges](node.name)
+            }
+          } else {
+            debug(() => {
+              throw Object.assign(new Error('duplicate node in root setter'), {
+                path: this.path,
+                realpath: this.realpath,
+                root: root.realpath,
+              })
+            })
+          }
+        }
+      }
+    }
+
+    // reload all edgesIn where the root doesn't match, so we don't have
+    // cross-tree dependency graphs
+    for (const edge of this.edgesIn) {
+      if (edge.from.root !== root) {
+        edge.reload()
+      }
+    }
+    // reload all edgesOut where root doesn't match, or is missing, since
+    // it might not be missing in the new tree
+    for (const edge of this.edgesOut.values()) {
+      if (!edge.to || edge.to.root !== root) {
+        edge.reload()
+      }
+    }
+
+    // now make sure our family comes along for the ride!
+    const family = new Set([
+      ...this.fsChildren,
+      ...this.children.values(),
+      ...this.inventory.values(),
+    ].filter(n => n !== this))
+
+    for (const child of family) {
+      if (child.root !== root) {
+        child[_delistFromMeta]()
+        child[_parent] = null
+        this.children.delete(child.name)
+        child[_fsParent] = null
+        this.fsChildren.delete(child)
+        for (const l of child.linksIn) {
+          l[_target] = null
+          child.linksIn.delete(l)
+        }
+      }
+    }
+    for (const child of family) {
+      if (child.root !== root) {
+        child.root = root
+      }
+    }
+
+    // if we had a target, and didn't find one in the new root, then bring
+    // it over as well, but only if we're setting the link into a new root,
+    // as we don't want to lose the target any time we remove a link.
+    if (this.isLink && target && !this.target && root !== this) {
+      target.root = root
+    }
+
+    // tree should always be valid upon root setter completion.
+    treeCheck(this)
+    if (this !== root) {
+      treeCheck(root)
+    }
+  }
+
+  get root () {
+    return this.#root || this
+  }
+
+  #loadWorkspaces () {
+    if (!this.#workspaces) {
+      return
+    }
+
+    for (const [name, path] of this.#workspaces.entries()) {
+      new Edge({ from: this, name, spec: `file:${path}`, type: 'workspace' })
+    }
+  }
+
+  [_loadDeps] () {
+    // Caveat!  Order is relevant!
+    // Packages in optionalDependencies are optional.
+    // Packages in both deps and devDeps are required.
+    // Note the subtle breaking change from v6: it is no longer possible
+    // to have a different spec for a devDep than production dep.
+
+    // Linked targets that are disconnected from the tree are tops,
+    // but don't have a 'path' field, only a 'realpath', because we
+    // don't know their canonical location. We don't need their devDeps.
+    const pd = this.package.peerDependencies
+    const ad = this.package.acceptDependencies || {}
+    if (pd && typeof pd === 'object' && !this.legacyPeerDeps) {
+      const pm = this.package.peerDependenciesMeta || {}
+      const peerDependencies = {}
+      const peerOptional = {}
+      for (const [name, dep] of Object.entries(pd)) {
+        if (pm[name]?.optional) {
+          peerOptional[name] = dep
+        } else {
+          peerDependencies[name] = dep
+        }
+      }
+      this.#loadDepType(peerDependencies, 'peer', ad)
+      this.#loadDepType(peerOptional, 'peerOptional', ad)
+    }
+
+    this.#loadDepType(this.package.dependencies, 'prod', ad)
+    this.#loadDepType(this.package.optionalDependencies, 'optional', ad)
+
+    const { globalTop, isTop, path, sourceReference } = this
+    const {
+      globalTop: srcGlobalTop,
+      isTop: srcTop,
+      path: srcPath,
+    } = sourceReference || {}
+    const thisDev = isTop && !globalTop && path
+    const srcDev = !sourceReference || srcTop && !srcGlobalTop && srcPath
+    if (thisDev && srcDev) {
+      this.#loadDepType(this.package.devDependencies, 'dev', ad)
+    }
+  }
+
+  #loadDepType (deps, type, ad) {
+    // Because of the order in which _loadDeps runs, we always want to
+    // prioritize a new edge over an existing one
+    for (const [name, spec] of Object.entries(deps || {})) {
+      const current = this.edgesOut.get(name)
+      if (!current || current.type !== 'workspace') {
+        new Edge({ from: this, name, spec, accept: ad[name], type })
+      }
+    }
+  }
+
+  get fsParent () {
+    // in debug setter prevents fsParent from being this
+    return this[_fsParent]
+  }
+
+  set fsParent (fsParent) {
+    if (!fsParent) {
+      if (this[_fsParent]) {
+        this.root = null
+      }
+      return
+    }
+
+    debug(() => {
+      if (fsParent === this) {
+        throw new Error('setting node to its own fsParent')
+      }
+
+      if (fsParent.realpath === this.realpath) {
+        throw new Error('setting fsParent to same path')
+      }
+
+      // the initial set MUST be an actual walk-up from the realpath
+      // subsequent sets will re-root on the new fsParent's path.
+      if (!this[_fsParent] && this.realpath.indexOf(fsParent.realpath) !== 0) {
+        throw Object.assign(new Error('setting fsParent improperly'), {
+          path: this.path,
+          realpath: this.realpath,
+          fsParent: {
+            path: fsParent.path,
+            realpath: fsParent.realpath,
+          },
+        })
+      }
+    })
+
+    if (fsParent.isLink) {
+      fsParent = fsParent.target
+    }
+
+    // setting a thing to its own fsParent is not normal, but no-op for safety
+    if (this === fsParent || fsParent.realpath === this.realpath) {
+      return
+    }
+
+    // nothing to do
+    if (this[_fsParent] === fsParent) {
+      return
+    }
+
+    const oldFsParent = this[_fsParent]
+    const newPath = !oldFsParent ? this.path
+      : resolve(fsParent.path, relative(oldFsParent.path, this.path))
+    const nmPath = resolve(fsParent.path, 'node_modules', this.name)
+
+    // this is actually the parent, set that instead
+    if (newPath === nmPath) {
+      this.parent = fsParent
+      return
+    }
+
+    const pathChange = newPath !== this.path
+
+    // remove from old parent/fsParent
+    const oldParent = this.parent
+    const oldName = this.name
+    if (this.parent) {
+      this.parent.children.delete(this.name)
+      this[_parent] = null
+    }
+    if (this.fsParent) {
+      this.fsParent.fsChildren.delete(this)
+      this[_fsParent] = null
+    }
+
+    // update this.path/realpath for this and all children/fsChildren
+    if (pathChange) {
+      this[_changePath](newPath)
+    }
+
+    if (oldParent) {
+      oldParent[_reloadNamedEdges](oldName)
+    }
+
+    // clobbers anything at that path, resets all appropriate references
+    this.root = fsParent.root
+  }
+
+  // is it safe to replace one node with another?  check the edges to
+  // make sure no one will get upset.  Note that the node might end up
+  // having its own unmet dependencies, if the new node has new deps.
+  // Note that there are cases where Arborist will opt to insert a node
+  // into the tree even though this function returns false!  This is
+  // necessary when a root dependency is added or updated, or when a
+  // root dependency brings peer deps along with it.  In that case, we
+  // will go ahead and create the invalid state, and then try to resolve
+  // it with more tree construction, because it's a user request.
+  canReplaceWith (node, ignorePeers) {
+    if (node.name !== this.name) {
+      return false
+    }
+
+    if (node.packageName !== this.packageName) {
+      return false
+    }
+
+    // If this node has no dependencies, then it's irrelevant to check the override
+    // rules of the replacement node.
+    if (this.edgesOut.size) {
+      // XXX need to check for two root nodes?
+      if (node.overrides) {
+        if (!node.overrides.isEqual(this.overrides)) {
+          return false
+        }
+      } else {
+        if (this.overrides) {
+          return false
+        }
+      }
+    }
+
+    ignorePeers = new Set(ignorePeers)
+
+    // gather up all the deps of this node and that are only depended
+    // upon by deps of this node.  those ones don't count, since
+    // they'll be replaced if this node is replaced anyway.
+    const depSet = gatherDepSet([this], e => e.to !== this && e.valid)
+
+    for (const edge of this.edgesIn) {
+      // when replacing peer sets, we need to be able to replace the entire
+      // peer group, which means we ignore incoming edges from other peers
+      // within the replacement set.
+      if (!this.isTop &&
+        edge.from.parent === this.parent &&
+        edge.peer &&
+        ignorePeers.has(edge.from.name)) {
+        continue
+      }
+
+      // only care about edges that don't originate from this node
+      if (!depSet.has(edge.from) && !edge.satisfiedBy(node)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  canReplace (node, ignorePeers) {
+    return node.canReplaceWith(this, ignorePeers)
+  }
+
+  // return true if it's safe to remove this node, because anything that
+  // is depending on it would be fine with the thing that they would resolve
+  // to if it was removed, or nothing is depending on it in the first place.
+  canDedupe (preferDedupe = false, explicitRequest = false) {
+    // not allowed to mess with shrinkwraps or bundles
+    if (this.inDepBundle || this.inShrinkwrap) {
+      return false
+    }
+
+    // it's a top level pkg, or a dep of one
+    if (!this.resolveParent || !this.resolveParent.resolveParent) {
+      return false
+    }
+
+    // no one wants it, remove it
+    if (this.edgesIn.size === 0) {
+      return true
+    }
+
+    const other = this.resolveParent.resolveParent.resolve(this.name)
+
+    // nothing else, need this one
+    if (!other) {
+      return false
+    }
+
+    // if it's the same thing, then always fine to remove
+    if (other.matches(this)) {
+      return true
+    }
+
+    // if the other thing can't replace this, then skip it
+    if (!other.canReplace(this)) {
+      return false
+    }
+
+    // if we prefer dedupe, or if the version is equal, take the other
+    if (preferDedupe || semver.eq(other.version, this.version)) {
+      return true
+    }
+
+    // if our current version isn't the result of an override, then prefer to take the greater version
+    if (!this.overridden && semver.gt(other.version, this.version)) {
+      return true
+    }
+
+    // if the other version was an explicit request, then prefer to take the other version
+    if (explicitRequest) {
+      return true
+    }
+
+    return false
+  }
+
+  satisfies (requested) {
+    if (requested instanceof Edge) {
+      return this.name === requested.name && requested.satisfiedBy(this)
+    }
+
+    const parsed = npa(requested)
+    const { name = this.name, rawSpec: spec } = parsed
+    return this.name === name && this.satisfies(new Edge({
+      from: new Node({ path: this.root.realpath }),
+      type: 'prod',
+      name,
+      spec,
+    }))
+  }
+
+  matches (node) {
+    // if the nodes are literally the same object, obviously a match.
+    if (node === this) {
+      return true
+    }
+
+    // if the names don't match, they're different things, even if
+    // the package contents are identical.
+    if (node.name !== this.name) {
+      return false
+    }
+
+    // if they're links, they match if the targets match
+    if (this.isLink) {
+      return node.isLink && this.target.matches(node.target)
+    }
+
+    // if they're two project root nodes, they're different if the paths differ
+    if (this.isProjectRoot && node.isProjectRoot) {
+      return this.path === node.path
+    }
+
+    // if the integrity matches, then they're the same.
+    if (this.integrity && node.integrity) {
+      return this.integrity === node.integrity
+    }
+
+    // if no integrity, check resolved
+    if (this.resolved && node.resolved) {
+      return this.resolved === node.resolved
+    }
+
+    // if no resolved, check both package name and version
+    // otherwise, conclude that they are different things
+    return this.packageName && node.packageName &&
+      this.packageName === node.packageName &&
+      this.version && node.version &&
+      this.version === node.version
+  }
+
+  // replace this node with the supplied argument
+  // Useful when mutating an ideal tree, so we can avoid having to call
+  // the parent/root setters more than necessary.
+  replaceWith (node) {
+    node.replace(this)
+  }
+
+  replace (node) {
+    this[_delistFromMeta]()
+
+    // if the name matches, but is not identical, we are intending to clobber
+    // something case-insensitively, so merely setting name and path won't
+    // have the desired effect.  just set the path so it'll collide in the
+    // parent's children map, and leave it at that.
+    if (node.parent?.children.get(this.name) === node) {
+      this.path = resolve(node.parent.path, 'node_modules', this.name)
+    } else {
+      this.path = node.path
+      this.name = node.name
+    }
+
+    if (!this.isLink) {
+      this.realpath = this.path
+    }
+    this[_refreshLocation]()
+
+    // keep children when a node replaces another
+    if (!this.isLink) {
+      for (const kid of node.children.values()) {
+        kid.parent = this
+      }
+      if (node.isLink && node.target) {
+        node.target.root = null
+      }
+    }
+
+    if (!node.isRoot) {
+      this.root = node.root
+    }
+
+    treeCheck(this)
+  }
+
+  get inShrinkwrap () {
+    return this.parent &&
+      (this.parent.hasShrinkwrap || this.parent.inShrinkwrap)
+  }
+
+  get parent () {
+    // setter prevents _parent from being this
+    return this[_parent]
+  }
+
+  // This setter keeps everything in order when we move a node from
+  // one point in a logical tree to another.  Edges get reloaded,
+  // metadata updated, etc.  It's also called when we *replace* a node
+  // with another by the same name (eg, to update or dedupe).
+  // This does a couple of walks out on the node_modules tree, recursing
+  // into child nodes.  However, as setting the parent is typically done
+  // with nodes that don't have many children, and (deduped) package
+  // trees tend to be broad rather than deep, it's not that bad.
+  // The only walk that starts from the parent rather than this node is
+  // limited by edge name.
+  set parent (parent) {
+    // when setting to null, just remove it from the tree entirely
+    if (!parent) {
+      // but only delete it if we actually had a parent in the first place
+      // otherwise it's just setting to null when it's already null
+      if (this[_parent]) {
+        this.root = null
+      }
+      return
+    }
+
+    if (parent.isLink) {
+      parent = parent.target
+    }
+
+    // setting a thing to its own parent is not normal, but no-op for safety
+    if (this === parent) {
+      return
+    }
+
+    const oldParent = this[_parent]
+
+    // nothing to do
+    if (oldParent === parent) {
+      return
+    }
+
+    // ok now we know something is actually changing, and parent is not a link
+    const newPath = resolve(parent.path, 'node_modules', this.name)
+    const pathChange = newPath !== this.path
+
+    // remove from old parent/fsParent
+    if (oldParent) {
+      oldParent.children.delete(this.name)
+      this[_parent] = null
+    }
+    if (this.fsParent) {
+      this.fsParent.fsChildren.delete(this)
+      this[_fsParent] = null
+    }
+
+    // update this.path/realpath for this and all children/fsChildren
+    if (pathChange) {
+      this[_changePath](newPath)
+    }
+
+    // clobbers anything at that path, resets all appropriate references
+    this.root = parent.root
+  }
+
+  // Call this before changing path or updating the _root reference.
+  // Removes the node from its root the metadata and inventory.
+  [_delistFromMeta] () {
+    const root = this.root
+    if (!root.realpath || !this.path) {
+      return
+    }
+    root.inventory.delete(this)
+    root.tops.delete(this)
+    if (root.meta) {
+      root.meta.delete(this.path)
+    }
+    /* istanbul ignore next - should be impossible */
+    debug(() => {
+      if ([...root.inventory.values()].includes(this)) {
+        throw new Error('failed to delist')
+      }
+    })
+  }
+
+  // update this.path/realpath and the paths of all children/fsChildren
+  [_changePath] (newPath) {
+    // have to de-list before changing paths
+    this[_delistFromMeta]()
+    const oldPath = this.path
+    this.path = newPath
+    const namePattern = /(?:^|\/|\\)node_modules[\\/](@[^/\\]+[\\/][^\\/]+|[^\\/]+)$/
+    const nameChange = newPath.match(namePattern)
+    if (nameChange && this.name !== nameChange[1]) {
+      this.name = nameChange[1].replace(/\\/g, '/')
+    }
+
+    // if we move a link target, update link realpaths
+    if (!this.isLink) {
+      this.realpath = newPath
+      for (const link of this.linksIn) {
+        link[_delistFromMeta]()
+        link.realpath = newPath
+        link[_refreshLocation]()
+      }
+    }
+    // if we move /x to /y, then a module at /x/a/b becomes /y/a/b
+    for (const child of this.fsChildren) {
+      child[_changePath](resolve(newPath, relative(oldPath, child.path)))
+    }
+    for (const [name, child] of this.children.entries()) {
+      child[_changePath](resolve(newPath, 'node_modules', name))
+    }
+
+    this[_refreshLocation]()
+  }
+
+  // Called whenever the root/parent is changed.
+  // NB: need to remove from former root's meta/inventory and then update
+  // this.path BEFORE calling this method!
+  [_refreshLocation] () {
+    const root = this.root
+    const loc = relpath(root.realpath, this.path)
+
+    this.location = loc
+
+    root.inventory.add(this)
+    if (root.meta) {
+      root.meta.add(this)
+    }
+  }
+
+  assertRootOverrides () {
+    if (!this.isProjectRoot || !this.overrides) {
+      return
+    }
+
+    for (const edge of this.edgesOut.values()) {
+      // if these differ an override has been applied, those are not allowed
+      // for top level dependencies so throw an error
+      if (edge.spec !== edge.rawSpec && !edge.spec.startsWith('$')) {
+        throw Object.assign(new Error(`Override for ${edge.name}@${edge.rawSpec} conflicts with direct dependency`), { code: 'EOVERRIDE' })
+      }
+    }
+  }
+
+  addEdgeOut (edge) {
+    if (this.overrides) {
+      edge.overrides = this.overrides.getEdgeRule(edge)
+    }
+
+    this.edgesOut.set(edge.name, edge)
+  }
+
+  recalculateOutEdgesOverrides () {
+    // For each edge out propagate the new overrides through.
+    for (const edge of this.edgesOut.values()) {
+      edge.reload(true)
+      if (edge.to) {
+        edge.to.updateOverridesEdgeInAdded(edge.overrides)
+      }
+    }
+  }
+
+  updateOverridesEdgeInRemoved (otherOverrideSet) {
+    // If this edge's overrides isn't equal to this node's overrides, then removing it won't change newOverrideSet later.
+    if (!this.overrides || !this.overrides.isEqual(otherOverrideSet)) {
+      return false
+    }
+    let newOverrideSet
+    for (const edge of this.edgesIn) {
+      if (newOverrideSet && edge.overrides) {
+        newOverrideSet = OverrideSet.findSpecificOverrideSet(edge.overrides, newOverrideSet)
+      } else {
+        newOverrideSet = edge.overrides
+      }
+    }
+    if (this.overrides.isEqual(newOverrideSet)) {
+      return false
+    }
+    this.overrides = newOverrideSet
+    if (this.overrides) {
+      // Optimization: if there's any override set at all, then no non-extraneous node has an empty override set. So if we temporarily have no
+      // override set (for example, we removed all the edges in), there's no use updating all the edges out right now. Let's just wait until
+      // we have an actual override set later.
+      this.recalculateOutEdgesOverrides()
+    }
+    return true
+  }
+
+  // This logic isn't perfect either. When we have two edges in that have different override sets, then we have to decide which set is correct.
+  // This function assumes the more specific override set is applicable, so if we have dependencies A->B->C and A->C
+  // and an override set that specifies what happens for C under A->B, this will work even if the new A->C edge comes along and tries to change
+  // the override set.
+  // The strictly correct logic is not to allow two edges with different overrides to point to the same node, because even if this node can satisfy
+  // both, one of its dependencies might need to be different depending on the edge leading to it.
+  // However, this might cause a lot of duplication, because the conflict in the dependencies might never actually happen.
+  updateOverridesEdgeInAdded (otherOverrideSet) {
+    if (!otherOverrideSet) {
+      // Assuming there are any overrides at all, the overrides field is never undefined for any node at the end state of the tree.
+      // So if the new edge's overrides is undefined it will be updated later. So we can wait with updating the node's overrides field.
+      return false
+    }
+    if (!this.overrides) {
+      this.overrides = otherOverrideSet
+      this.recalculateOutEdgesOverrides()
+      return true
+    }
+    if (this.overrides.isEqual(otherOverrideSet)) {
+      return false
+    }
+    const newOverrideSet = OverrideSet.findSpecificOverrideSet(this.overrides, otherOverrideSet)
+    if (newOverrideSet) {
+      if (!this.overrides.isEqual(newOverrideSet)) {
+        this.overrides = newOverrideSet
+        this.recalculateOutEdgesOverrides()
+        return true
+      }
+      return false
+    }
+    // This is an error condition. We can only get here if the new override set is in conflict with the existing.
+    log.silly('Conflicting override sets', this.name)
+  }
+
+  deleteEdgeIn (edge) {
+    this.edgesIn.delete(edge)
+    if (edge.overrides) {
+      this.updateOverridesEdgeInRemoved(edge.overrides)
+    }
+  }
+
+  addEdgeIn (edge) {
+    // We need to handle the case where the new edge in has an overrides field which is different from the current value.
+    if (!this.overrides || !this.overrides.isEqual(edge.overrides)) {
+      this.updateOverridesEdgeInAdded(edge.overrides)
+    }
+
+    this.edgesIn.add(edge)
+
+    // try to get metadata from the yarn.lock file
+    if (this.root.meta) {
+      this.root.meta.addEdge(edge)
+    }
+  }
+
+  [_reloadNamedEdges] (name, rootLoc = this.location) {
+    const edge = this.edgesOut.get(name)
+    // if we don't have an edge, do nothing, but keep descending
+    const rootLocResolved = edge && edge.to &&
+      edge.to.location === `${rootLoc}/node_modules/${edge.name}`
+    const sameResolved = edge && this.resolve(name) === edge.to
+    const recheck = rootLocResolved || !sameResolved
+    if (edge && recheck) {
+      edge.reload(true)
+    }
+    for (const c of this.children.values()) {
+      c[_reloadNamedEdges](name, rootLoc)
+    }
+
+    for (const c of this.fsChildren) {
+      c[_reloadNamedEdges](name, rootLoc)
+    }
+  }
+
+  get isLink () {
+    return false
+  }
+
+  get target () {
+    return this
+  }
+
+  set target (n) {
+    debug(() => {
+      throw Object.assign(new Error('cannot set target on non-Link Nodes'), {
+        path: this.path,
+      })
+    })
+  }
+
+  get depth () {
+    if (this.isTop) {
+      return 0
+    }
+    return this.parent.depth + 1
+  }
+
+  get isTop () {
+    return !this.parent || this.globalTop
+  }
+
+  get top () {
+    if (this.isTop) {
+      return this
+    }
+    return this.parent.top
+  }
+
+  get isFsTop () {
+    return !this.fsParent
+  }
+
+  get fsTop () {
+    if (this.isFsTop) {
+      return this
+    }
+    return this.fsParent.fsTop
+  }
+
+  get resolveParent () {
+    return this.parent || this.fsParent
+  }
+
+  resolve (name) {
+    /* istanbul ignore next - should be impossible,
+     * but I keep doing this mistake in tests */
+    debug(() => {
+      if (typeof name !== 'string' || !name) {
+        throw new Error('non-string passed to Node.resolve')
+      }
+    })
+    const mine = this.children.get(name)
+    if (mine) {
+      return mine
+    }
+    const resolveParent = this.resolveParent
+    if (resolveParent) {
+      return resolveParent.resolve(name)
+    }
+    return null
+  }
+
+  inNodeModules () {
+    const rp = this.realpath
+    const name = this.name
+    const scoped = name.charAt(0) === '@'
+    const d = dirname(rp)
+    const nm = scoped ? dirname(d) : d
+    const dir = dirname(nm)
+    const base = scoped ? `${basename(d)}/${basename(rp)}` : basename(rp)
+    return base === name && basename(nm) === 'node_modules' ? dir : false
+  }
+
+  // maybe accept both string value or array of strings
+  // seems to be what dom API does
+  querySelectorAll (query, opts) {
+    return querySelectorAll(this, query, opts)
+  }
+
+  toJSON () {
+    return printableTree(this)
+  }
+
+  [util.inspect.custom] () {
+    return this.toJSON()
+  }
+
+  resetDepFlags () {
+    this.extraneous = true
+    this.dev = true
+    this.optional = true
+    this.devOptional = true
+    this.peer = true
+  }
+
+  unsetDepFlags () {
+    this.extraneous = false
+    this.dev = false
+    this.optional = false
+    this.devOptional = false
+    this.peer = false
+  }
+}
+
+module.exports = Node
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/optional-set.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/optional-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..029f7820443ad5d2e5a49b4bd7e534b813ac803e
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/optional-set.js
@@ -0,0 +1,32 @@
+// when an optional dep fails to install, we need to remove the branch of the
+// graph up to the first optionalDependencies, as well as any nodes that are
+// only required by other nodes in the set.
+//
+// This function finds the set of nodes that will need to be removed in that
+// case.
+//
+// Note that this is *only* going to work with trees where calcDepFlags
+// has been called, because we rely on the node.optional flag.
+
+const gatherDepSet = require('./gather-dep-set.js')
+const optionalSet = node => {
+  // start with the node, then walk up the dependency graph until we
+  // get to the boundaries that define the optional set.  since the
+  // node is optional, we know that all paths INTO this area of the
+  // graph are optional, but there may be non-optional dependencies
+  // WITHIN the area.
+  const set = new Set([node])
+  for (const node of set) {
+    for (const edge of node.edgesIn) {
+      if (!edge.optional) {
+        set.add(edge.from)
+      }
+    }
+  }
+
+  // now that we've hit the boundary, gather the rest of the nodes in
+  // the optional section that don't have dependents outside the set.
+  return gatherDepSet(set, edge => !set.has(edge.to) && !edge.from?.inert)
+}
+
+module.exports = optionalSet
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/override-resolves.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/override-resolves.js
new file mode 100644
index 0000000000000000000000000000000000000000..facbabc8012cac55ceb11715049511f787633d5c
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/override-resolves.js
@@ -0,0 +1,11 @@
+function overrideResolves (resolved, opts) {
+  const { omitLockfileRegistryResolved = false } = opts
+
+  if (omitLockfileRegistryResolved) {
+    return undefined
+  }
+
+  return resolved
+}
+
+module.exports = { overrideResolves }
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/override-set.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/override-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..64c0c3e39029972d3485fa773adfe590bfd39aaa
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/override-set.js
@@ -0,0 +1,304 @@
+const npa = require('npm-package-arg')
+const semver = require('semver')
+const { log } = require('proc-log')
+
+class OverrideSet {
+  constructor ({ overrides, key, parent }) {
+    this.parent = parent
+    this.children = new Map()
+
+    if (typeof overrides === 'string') {
+      overrides = { '.': overrides }
+    }
+
+    // change a literal empty string to * so we can use truthiness checks on
+    // the value property later
+    if (overrides['.'] === '') {
+      overrides['.'] = '*'
+    }
+
+    if (parent) {
+      const spec = npa(key)
+      if (!spec.name) {
+        throw new Error(`Override without name: ${key}`)
+      }
+
+      this.name = spec.name
+      spec.name = ''
+      this.key = key
+      this.keySpec = spec.toString()
+      this.value = overrides['.'] || this.keySpec
+    }
+
+    for (const [key, childOverrides] of Object.entries(overrides)) {
+      if (key === '.') {
+        continue
+      }
+
+      const child = new OverrideSet({
+        parent: this,
+        key,
+        overrides: childOverrides,
+      })
+
+      this.children.set(child.key, child)
+    }
+  }
+
+  childrenAreEqual (other) {
+    if (this.children.size !== other.children.size) {
+      return false
+    }
+    for (const [key] of this.children) {
+      if (!other.children.has(key)) {
+        return false
+      }
+      if (this.children.get(key).value !== other.children.get(key).value) {
+        return false
+      }
+      if (!this.children.get(key).childrenAreEqual(other.children.get(key))) {
+        return false
+      }
+    }
+    return true
+  }
+
+  isEqual (other) {
+    if (this === other) {
+      return true
+    }
+    if (!other) {
+      return false
+    }
+    if (this.key !== other.key || this.value !== other.value) {
+      return false
+    }
+    if (!this.childrenAreEqual(other)) {
+      return false
+    }
+    if (!this.parent) {
+      return !other.parent
+    }
+    return this.parent.isEqual(other.parent)
+  }
+
+  getEdgeRule (edge) {
+    for (const rule of this.ruleset.values()) {
+      if (rule.name !== edge.name) {
+        continue
+      }
+
+      // if keySpec is * we found our override
+      if (rule.keySpec === '*') {
+        return rule
+      }
+
+      // We need to use the rawSpec here, because the spec has the overrides applied to it already.
+      // rawSpec can be undefined, so we need to use the fallback value of spec if it is.
+      let spec = npa(`${edge.name}@${edge.rawSpec || edge.spec}`)
+      if (spec.type === 'alias') {
+        spec = spec.subSpec
+      }
+
+      if (spec.type === 'git') {
+        if (spec.gitRange && semver.intersects(spec.gitRange, rule.keySpec)) {
+          return rule
+        }
+
+        continue
+      }
+
+      if (spec.type === 'range' || spec.type === 'version') {
+        if (semver.intersects(spec.fetchSpec, rule.keySpec)) {
+          return rule
+        }
+
+        continue
+      }
+
+      // if we got this far, the spec type is one of tag, directory or file
+      // which means we have no real way to make version comparisons, so we
+      // just accept the override
+      return rule
+    }
+
+    return this
+  }
+
+  getNodeRule (node) {
+    for (const rule of this.ruleset.values()) {
+      if (rule.name !== node.name) {
+        continue
+      }
+
+      if (semver.satisfies(node.version, rule.keySpec) ||
+        semver.satisfies(node.version, rule.value)) {
+        return rule
+      }
+    }
+
+    return this
+  }
+
+  getMatchingRule (node) {
+    for (const rule of this.ruleset.values()) {
+      if (rule.name !== node.name) {
+        continue
+      }
+
+      if (semver.satisfies(node.version, rule.keySpec) ||
+        semver.satisfies(node.version, rule.value)) {
+        return rule
+      }
+    }
+
+    return null
+  }
+
+  * ancestry () {
+    for (let ancestor = this; ancestor; ancestor = ancestor.parent) {
+      yield ancestor
+    }
+  }
+
+  get isRoot () {
+    return !this.parent
+  }
+
+  get ruleset () {
+    const ruleset = new Map()
+
+    for (const override of this.ancestry()) {
+      for (const kid of override.children.values()) {
+        if (!ruleset.has(kid.key)) {
+          ruleset.set(kid.key, kid)
+        }
+      }
+
+      if (!override.isRoot && !ruleset.has(override.key)) {
+        ruleset.set(override.key, override)
+      }
+    }
+
+    return ruleset
+  }
+
+  static findSpecificOverrideSet (first, second) {
+    for (let overrideSet = second; overrideSet; overrideSet = overrideSet.parent) {
+      if (overrideSet.isEqual(first)) {
+        return second
+      }
+    }
+    for (let overrideSet = first; overrideSet; overrideSet = overrideSet.parent) {
+      if (overrideSet.isEqual(second)) {
+        return first
+      }
+    }
+
+    // The override sets are incomparable (e.g. siblings like the "react" and "react-dom" children of the root override set). Check if they have semantically conflicting rules before treating this as an error.
+    if (this.haveConflictingRules(first, second)) {
+      log.silly('Conflicting override sets', first, second)
+      return undefined
+    }
+
+    // The override sets are structurally incomparable but have compatible rules. Fall back to their nearest common ancestor so the node still has a valid override set.
+    return this.findCommonAncestor(first, second)
+  }
+
+  static findCommonAncestor (first, second) {
+    const firstAncestors = []
+    for (const ancestor of first.ancestry()) {
+      firstAncestors.push(ancestor)
+    }
+    for (const secondAnc of second.ancestry()) {
+      for (const firstAnc of firstAncestors) {
+        if (firstAnc.isEqual(secondAnc)) {
+          return firstAnc
+        }
+      }
+    }
+    return null
+  }
+
+  static doOverrideSetsConflict (first, second) {
+    // If override sets contain one another then we can try to use the more specific one.
+    // If neither one is more specific, check for semantic conflicts.
+    const specificSet = this.findSpecificOverrideSet(first, second)
+    if (specificSet !== undefined) {
+      // One contains the other, so no conflict
+      return false
+    }
+
+    // The override sets are structurally incomparable, but this doesn't necessarily
+    // mean they conflict. We need to check if they have conflicting version requirements
+    // for any package that appears in both rulesets.
+    return this.haveConflictingRules(first, second)
+  }
+
+  static haveConflictingRules (first, second) {
+    // Get all rules from both override sets
+    const firstRules = first.ruleset
+    const secondRules = second.ruleset
+
+    // Check each package that appears in both rulesets
+    for (const [key, firstRule] of firstRules) {
+      const secondRule = secondRules.get(key)
+      if (!secondRule) {
+        // Package only appears in one ruleset, no conflict
+        continue
+      }
+
+      // Same rule object means no conflict
+      if (firstRule === secondRule || firstRule.isEqual(secondRule)) {
+        continue
+      }
+
+      // Both rulesets have rules for this package with different values.
+      // Check if the version requirements are actually incompatible.
+      const firstValue = firstRule.value
+      const secondValue = secondRule.value
+
+      // If either value is a reference (starts with $), we can't determine
+      // compatibility here - the reference might resolve to compatible versions.
+      // We defer to runtime resolution rather than failing early.
+      if (firstValue.startsWith('$') || secondValue.startsWith('$')) {
+        continue
+      }
+
+      // Check if the version ranges are compatible using semver
+      // If both specify version ranges, they conflict only if they have no overlap
+      try {
+        const firstSpec = npa(`${firstRule.name}@${firstValue}`)
+        const secondSpec = npa(`${secondRule.name}@${secondValue}`)
+
+        // For range/version types, check if they intersect
+        if ((firstSpec.type === 'range' || firstSpec.type === 'version') &&
+            (secondSpec.type === 'range' || secondSpec.type === 'version')) {
+          // Check if the ranges intersect
+          const firstRange = firstSpec.fetchSpec
+          const secondRange = secondSpec.fetchSpec
+
+          // If the ranges don't intersect, we have a real conflict
+          if (!semver.intersects(firstRange, secondRange)) {
+            log.silly('Found conflicting override rules', {
+              package: firstRule.name,
+              first: firstValue,
+              second: secondValue,
+            })
+            return true
+          }
+        }
+        // For other types (git, file, directory, tag), we can't easily determine
+        // compatibility, so we conservatively assume no conflict
+      } catch {
+        // If we can't parse the specs, conservatively assume no conflict
+        // Real conflicts will be caught during dependency resolution
+      }
+    }
+
+    // No conflicting rules found
+    return false
+  }
+}
+
+module.exports = OverrideSet
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/packument-cache.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/packument-cache.js
new file mode 100644
index 0000000000000000000000000000000000000000..da8c7b971edff4b6f3c3d9bb75052da35233287f
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/packument-cache.js
@@ -0,0 +1,77 @@
+const { LRUCache } = require('lru-cache')
+const { getHeapStatistics } = require('node:v8')
+const { log } = require('proc-log')
+
+// This is an in-memory cache that Pacote uses for packuments.
+// Packuments are usually cached on disk.  This allows for rapid re-requests
+// of the same packument to bypass disk reads.  The tradeoff here is memory
+// usage for disk reads.
+class PackumentCache extends LRUCache {
+  static #heapLimit = Math.floor(getHeapStatistics().heap_size_limit)
+
+  #sizeKey
+  #disposed = new Set()
+
+  #log (...args) {
+    log.silly('packumentCache', ...args)
+  }
+
+  constructor ({
+    // How much of this.#heapLimit to take up
+    heapFactor = 0.25,
+    // How much of this.#maxSize we allow any one packument to take up
+    // Anything over this is not cached
+    maxEntryFactor = 0.5,
+    sizeKey = '_contentLength',
+  } = {}) {
+    const maxSize = Math.floor(PackumentCache.#heapLimit * heapFactor)
+    const maxEntrySize = Math.floor(maxSize * maxEntryFactor)
+    super({
+      maxSize,
+      maxEntrySize,
+      sizeCalculation: (p) => {
+        // Don't cache if we don't know the size
+        // Some versions of pacote set this to `0`, newer versions set it to `null`
+        if (!p[sizeKey]) {
+          return maxEntrySize + 1
+        }
+        if (p[sizeKey] < 10_000) {
+          return p[sizeKey] * 2
+        }
+        if (p[sizeKey] < 1_000_000) {
+          return Math.floor(p[sizeKey] * 1.5)
+        }
+        // It is less beneficial to store a small amount of super large things
+        // at the cost of all other packuments.
+        return maxEntrySize + 1
+      },
+      dispose: (v, k) => {
+        this.#disposed.add(k)
+        this.#log(k, 'dispose')
+      },
+    })
+    this.#sizeKey = sizeKey
+    this.#log(`heap:${PackumentCache.#heapLimit} maxSize:${maxSize} maxEntrySize:${maxEntrySize}`)
+  }
+
+  set (k, v, ...args) {
+    // we use disposed only for a logging signal if we are setting packuments that
+    // have already been evicted from the cache previously. logging here could help
+    // us tune this in the future.
+    const disposed = this.#disposed.has(k)
+    /* istanbul ignore next - this doesnt happen consistently so hard to test without resorting to unit tests  */
+    if (disposed) {
+      this.#disposed.delete(k)
+    }
+    this.#log(k, 'set', `size:${v[this.#sizeKey]} disposed:${disposed}`)
+    return super.set(k, v, ...args)
+  }
+
+  has (k, ...args) {
+    const has = super.has(k, ...args)
+    this.#log(k, `cache-${has ? 'hit' : 'miss'}`)
+    return has
+  }
+}
+
+module.exports = PackumentCache
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/peer-entry-sets.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/peer-entry-sets.js
new file mode 100644
index 0000000000000000000000000000000000000000..262209bd8a992f348db663818d700820665b6dce
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/peer-entry-sets.js
@@ -0,0 +1,77 @@
+// Given a node in a tree, return all of the peer dependency sets that
+// it is a part of, with the entry (top or non-peer) edges into the sets
+// identified.
+//
+// With this information, we can determine whether it is appropriate to
+// replace the entire peer set with another (and remove the old one),
+// push the set deeper into the tree, and so on.
+//
+// Returns a Map of { edge => Set(peerNodes) },
+
+const peerEntrySets = node => {
+  // this is the union of all peer groups that the node is a part of
+  // later, we identify all of the entry edges, and create a set of
+  // 1 or more overlapping sets that this node is a part of.
+  const unionSet = new Set([node])
+  for (const node of unionSet) {
+    for (const edge of node.edgesOut.values()) {
+      if (edge.valid && edge.peer && edge.to) {
+        unionSet.add(edge.to)
+      }
+    }
+    for (const edge of node.edgesIn) {
+      if (edge.valid && edge.peer) {
+        unionSet.add(edge.from)
+      }
+    }
+  }
+  const entrySets = new Map()
+  for (const peer of unionSet) {
+    for (const edge of peer.edgesIn) {
+      // if not valid, it doesn't matter anyway.  either it's been previously
+      // peerConflicted, or it's the thing we're interested in replacing.
+      if (!edge.valid) {
+        continue
+      }
+      // this is the entry point into the peer set
+      if (!edge.peer || edge.from.isTop) {
+        // get the subset of peer brought in by this peer entry edge
+        const sub = new Set([peer])
+        for (const peer of sub) {
+          for (const edge of peer.edgesOut.values()) {
+            if (edge.valid && edge.peer && edge.to) {
+              sub.add(edge.to)
+            }
+          }
+        }
+        // if this subset does not include the node we are focused on,
+        // then it is not relevant for our purposes.  Example:
+        //
+        // a -> (b, c, d)
+        // b -> PEER(d) b -> d -> e -> f <-> g
+        // c -> PEER(f, h) c -> (f <-> g, h -> g)
+        // d -> PEER(e) d -> e -> f <-> g
+        // e -> PEER(f)
+        // f -> PEER(g)
+        // g -> PEER(f)
+        // h -> PEER(g)
+        //
+        // The unionSet(e) will include c, but we don't actually care about
+        // it.  We only expanded to the edge of the peer nodes in order to
+        // find the entry edges that caused the inclusion of peer sets
+        // including (e), so we want:
+        //   Map{
+        //     Edge(a->b) => Set(b, d, e, f, g)
+        //     Edge(a->d) => Set(d, e, f, g)
+        //   }
+        if (sub.has(node)) {
+          entrySets.set(edge, sub)
+        }
+      }
+    }
+  }
+
+  return entrySets
+}
+
+module.exports = peerEntrySets
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/place-dep.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/place-dep.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8d1e4e6ca73f9ba4f655a040a1b44d02fff5bf2
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/place-dep.js
@@ -0,0 +1,569 @@
+// Given a dep, a node that depends on it, and the edge representing that
+// dependency, place the dep somewhere in the node's tree, and all of its
+// peer dependencies.
+//
+// Handles all of the tree updating needed to place the dep, including
+// removing replaced nodes, pruning now-extraneous or invalidated nodes,
+// and saves a set of what was placed and what needs re-evaluation as
+// a result.
+
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { log } = require('proc-log')
+const { redact } = require('@npmcli/redact')
+const deepestNestingTarget = require('./deepest-nesting-target.js')
+const CanPlaceDep = require('./can-place-dep.js')
+const {
+  KEEP,
+  CONFLICT,
+} = CanPlaceDep
+const debug = require('./debug.js')
+
+const Link = require('./link.js')
+const gatherDepSet = require('./gather-dep-set.js')
+const peerEntrySets = require('./peer-entry-sets.js')
+
+class PlaceDep {
+  constructor (options) {
+    this.auditReport = options.auditReport
+    this.dep = options.dep
+    this.edge = options.edge
+    this.explicitRequest = options.explicitRequest
+    this.force = options.force
+    this.installLinks = options.installLinks
+    this.installStrategy = options.installStrategy
+    this.legacyPeerDeps = options.legacyPeerDeps
+    this.parent = options.parent || null
+    this.preferDedupe = options.preferDedupe
+    this.strictPeerDeps = options.strictPeerDeps
+    this.updateNames = options.updateNames
+
+    this.canPlace = null
+    this.canPlaceSelf = null
+    // XXX this only appears to be used by tests
+    this.checks = new Map()
+    this.children = []
+    this.needEvaluation = new Set()
+    this.peerConflict = null
+    this.placed = null
+    this.target = null
+
+    this.current = this.edge.to
+    this.name = this.edge.name
+    this.top = this.parent?.top || this
+
+    // nothing to do if the edge is fine as it is
+    if (this.edge.to &&
+        !this.edge.error &&
+        !this.explicitRequest &&
+        !this.updateNames.includes(this.edge.name) &&
+        !this.auditReport?.isVulnerable(this.edge.to)) {
+      return
+    }
+
+    // walk up the tree until we hit either a top/root node, or a place
+    // where the dep is not a peer dep.
+    const start = this.getStartNode()
+
+    for (const target of start.ancestry()) {
+      // if the current location has a peerDep on it, then we can't place here
+      // this is pretty rare to hit, since we always prefer deduping peers,
+      // and the getStartNode will start us out above any peers from the
+      // thing that depends on it.  but we could hit it with something like:
+      //
+      // a -> (b@1, c@1)
+      // +-- c@1
+      // +-- b -> PEEROPTIONAL(v) (c@2)
+      //     +-- c@2 -> (v)
+      //
+      // So we check if we can place v under c@2, that's fine.
+      // Then we check under b, and can't, because of the optional peer dep.
+      // but we CAN place it under a, so the correct thing to do is keep
+      // walking up the tree.
+      const targetEdge = target.edgesOut.get(this.edge.name)
+      if (!target.isTop && targetEdge && targetEdge.peer) {
+        continue
+      }
+
+      const cpd = new CanPlaceDep({
+        dep: this.dep,
+        edge: this.edge,
+        // note: this sets the parent's canPlace as the parent of this
+        // canPlace, but it does NOT add this canPlace to the parent's
+        // children.  This way, we can know that it's a peer dep, and
+        // get the top edge easily, while still maintaining the
+        // tree of checks that factored into the original decision.
+        parent: this.parent && this.parent.canPlace,
+        target,
+        preferDedupe: this.preferDedupe,
+        explicitRequest: this.explicitRequest,
+      })
+      this.checks.set(target, cpd)
+
+      // It's possible that a "conflict" is a conflict among the *peers* of
+      // a given node we're trying to place, but there actually is no current
+      // node.  Eg,
+      // root -> (a, b)
+      // a -> PEER(c)
+      // b -> PEER(d)
+      // d -> PEER(c@2)
+      // We place (a), and get a peer of (c) along with it.
+      // then we try to place (b), and get CONFLICT in the check, because
+      // of the conflicting peer from (b)->(d)->(c@2).  In that case, we
+      // should treat (b) and (d) as OK, and place them in the last place
+      // where they did not themselves conflict, and skip c@2 if conflict
+      // is ok by virtue of being forced or not ours and not strict.
+      if (cpd.canPlaceSelf !== CONFLICT) {
+        this.canPlaceSelf = cpd
+      }
+
+      // we found a place this can go, along with all its peer friends.
+      // we break when we get the first conflict
+      if (cpd.canPlace !== CONFLICT) {
+        this.canPlace = cpd
+      } else {
+        break
+      }
+
+      // if it's a load failure, just plop it in the first place attempted,
+      // since we're going to crash the build or prune it out anyway.
+      // but, this will frequently NOT be a successful canPlace, because
+      // it'll have no version or other information.
+      if (this.dep.errors.length) {
+        break
+      }
+
+      // nest packages like npm v1 and v2
+      // very disk-inefficient
+      if (this.installStrategy === 'nested') {
+        break
+      }
+
+      // when installing globally, or just in global style, we never place
+      // deps above the first level.
+      if (this.installStrategy === 'shallow') {
+        const rp = target.resolveParent
+        if (rp && rp.isProjectRoot) {
+          break
+        }
+      }
+    }
+
+    // if we can't find a target, that means that the last place checked,
+    // and all the places before it, had a conflict.
+    if (!this.canPlace) {
+      // if not forced, and it's our dep, or strictPeerDeps is set, then
+      // this is an ERESOLVE error.
+      if (!this.force && (this.isMine || this.strictPeerDeps)) {
+        return this.failPeerConflict()
+      }
+
+      // ok!  we're gonna allow the conflict, but we should still warn
+      // if we have a current, then we treat CONFLICT as a KEEP.
+      // otherwise, we just skip it.  Only warn on the one that actually
+      // could not be placed somewhere.
+      if (!this.canPlaceSelf) {
+        this.warnPeerConflict()
+        return
+      }
+
+      this.canPlace = this.canPlaceSelf
+    }
+
+    // now we have a target, a tree of CanPlaceDep results for the peer group,
+    // and we are ready to go
+
+    /* istanbul ignore next */
+    if (!this.canPlace) {
+      debug(() => {
+        throw new Error('canPlace not set, but trying to place in tree')
+      })
+      return
+    }
+
+    const { target } = this.canPlace
+
+    log.silly(
+      'placeDep',
+      target.location || 'ROOT',
+      `${this.dep.name}@${this.dep.version}`,
+      this.canPlace.description,
+      `for: ${this.edge.from.package._id || this.edge.from.location}`,
+      `want: ${redact(this.edge.spec || '*')}`
+    )
+
+    const placementType = this.canPlace.canPlace === CONFLICT
+      ? this.canPlace.canPlaceSelf
+      : this.canPlace.canPlace
+
+    // if we're placing in the tree with --force, we can get here even though
+    // it's a conflict.  Treat it as a KEEP, but warn and move on.
+    if (placementType === KEEP) {
+      // this was a peerConflicted peer dep
+      if (this.edge.peer && !this.edge.valid) {
+        this.warnPeerConflict()
+      }
+
+      // if we get a KEEP in an update scenario, then we MAY have something
+      // already duplicating this unnecessarily!  For example:
+      // ```
+      // root (dep: y@1)
+      // +-- x (dep: y@1.1)
+      // |   +-- y@1.1.0 (replacing with 1.1.2, got KEEP at the root)
+      // +-- y@1.1.2 (updated already from 1.0.0)
+      // ```
+      // Now say we do `reify({update:['y']})`, and the latest version is
+      // 1.1.2, which we now have in the root.  We'll try to place y@1.1.2
+      // first in x, then in the root, ending with KEEP, because we already
+      // have it.  In that case, we ought to REMOVE the nm/x/nm/y node, because
+      // it is an unnecessary duplicate.
+      this.pruneDedupable(target)
+      return
+    }
+
+    // we were told to place it here in the target, so either it does not
+    // already exist in the tree, OR it's shadowed.
+    // handle otherwise unresolvable dependency nesting loops by
+    // creating a symbolic link
+    // a1 -> b1 -> a2 -> b2 -> a1 -> ...
+    // instead of nesting forever, when the loop occurs, create
+    // a symbolic link to the earlier instance
+    for (let p = target; p; p = p.resolveParent) {
+      if (p.matches(this.dep) && !p.isTop) {
+        this.placed = new Link({ parent: target, target: p })
+        return
+      }
+    }
+
+    // XXX if we are replacing SOME of a peer entry group, we will need to
+    // remove any that are not being replaced and will now be invalid, and
+    // re-evaluate them deeper into the tree.
+
+    const virtualRoot = this.dep.parent
+    this.placed = new this.dep.constructor({
+      name: this.dep.name,
+      pkg: this.dep.package,
+      resolved: this.dep.resolved,
+      integrity: this.dep.integrity,
+      installLinks: this.installLinks,
+      legacyPeerDeps: this.legacyPeerDeps,
+      error: this.dep.errors[0],
+      ...(this.dep.overrides ? { overrides: this.dep.overrides } : {}),
+      ...(this.dep.isLink ? { target: this.dep.target, realpath: this.dep.realpath } : {}),
+    })
+
+    this.oldDep = target.children.get(this.name)
+    if (this.oldDep) {
+      this.replaceOldDep()
+    } else {
+      this.placed.parent = target
+    }
+
+    // if it's a peerConflicted peer dep, warn about it
+    if (this.edge.peer && !this.placed.satisfies(this.edge)) {
+      this.warnPeerConflict()
+    }
+
+    // If the edge is not an error, then we're updating something, and
+    // MAY end up putting a better/identical node further up the tree in
+    // a way that causes an unnecessary duplication.  If so, remove the
+    // now-unnecessary node.
+    if (this.edge.valid && this.edge.to && this.edge.to !== this.placed) {
+      this.pruneDedupable(this.edge.to, false)
+    }
+
+    // in case we just made some duplicates that can be removed,
+    // prune anything deeper in the tree that can be replaced by this
+    for (const node of target.root.inventory.query('name', this.name)) {
+      if (node.isDescendantOf(target) && !node.isTop) {
+        this.pruneDedupable(node, false)
+        // only walk the direct children of the ones we kept
+        if (node.root === target.root) {
+          for (const kid of node.children.values()) {
+            this.pruneDedupable(kid, false)
+          }
+        }
+      }
+    }
+
+    // also place its unmet or invalid peer deps at this location
+    // loop through any peer deps from the thing we just placed, and place
+    // those ones as well.  it's safe to do this with the virtual nodes,
+    // because we're copying rather than moving them out of the virtual root,
+    // otherwise they'd be gone and the peer set would change throughout
+    // this loop.
+    for (const peerEdge of this.placed.edgesOut.values()) {
+      if (peerEdge.valid || !peerEdge.peer || peerEdge.peerConflicted) {
+        continue
+      }
+
+      const peer = virtualRoot.children.get(peerEdge.name)
+
+      // Note: if the virtualRoot *doesn't* have the peer, then that means
+      // it's an optional peer dep.  If it's not being properly met (ie,
+      // peerEdge.valid is false), then this is likely heading for an
+      // ERESOLVE error, unless it can walk further up the tree.
+      if (!peer) {
+        continue
+      }
+
+      // peerConflicted peerEdge, just accept what's there already
+      if (!peer.satisfies(peerEdge)) {
+        continue
+      }
+
+      this.children.push(new PlaceDep({
+        auditReport: this.auditReport,
+        explicitRequest: this.explicitRequest,
+        force: this.force,
+        installLinks: this.installLinks,
+        installStrategy: this.installStrategy,
+        legacyPeerDeps: this.legacyPeerDeps,
+        preferDedupe: this.preferDedupe,
+        strictPeerDeps: this.strictPeerDeps,
+        updateNames: this.updateName,
+        parent: this,
+        dep: peer,
+        node: this.placed,
+        edge: peerEdge,
+      }))
+    }
+  }
+
+  replaceOldDep () {
+    const target = this.oldDep.parent
+
+    // XXX handle replacing an entire peer group?
+    // what about cases where we need to push some other peer groups deeper
+    // into the tree?  all the tree updating should be done here, and track
+    // all the things that we add and remove, so that we can know what
+    // to re-evaluate.
+
+    // if we're replacing, we should also remove any nodes for edges that
+    // are now invalid, and where this (or its deps) is the only dependent,
+    // and also recurse on that pruning.  Otherwise leaving that dep node
+    // around can result in spurious conflicts pushing nodes deeper into
+    // the tree than needed in the case of cycles that will be removed
+    // later anyway.
+    const oldDeps = []
+    for (const [name, edge] of this.oldDep.edgesOut.entries()) {
+      if (!this.placed.edgesOut.has(name) && edge.to) {
+        oldDeps.push(...gatherDepSet([edge.to], e => e.to !== edge.to))
+      }
+    }
+
+    // gather all peer edgesIn which are at this level, and will not be
+    // satisfied by the new dependency.  Those are the peer sets that need
+    // to be either warned about (if they cannot go deeper), or removed and
+    // re-placed (if they can).
+    const prunePeerSets = []
+    for (const edge of this.oldDep.edgesIn) {
+      if (this.placed.satisfies(edge) ||
+          !edge.peer ||
+          edge.from.parent !== target ||
+          edge.peerConflicted) {
+        // not a peer dep, not invalid, or not from this level, so it's fine
+        // to just let it re-evaluate as a problemEdge later, or let it be
+        // satisfied by the new dep being placed.
+        continue
+      }
+      for (const entryEdge of peerEntrySets(edge.from).keys()) {
+        // either this one needs to be pruned and re-evaluated, or marked
+        // as peerConflicted and warned about.  If the entryEdge comes in from
+        // the root or a workspace, then we have to leave it alone, and in that
+        // case, it will have already warned or crashed by getting to this point
+        const entryNode = entryEdge.to
+        const deepestTarget = deepestNestingTarget(entryNode)
+        if (deepestTarget !== target &&
+            !(entryEdge.from.isProjectRoot || entryEdge.from.isWorkspace)) {
+          prunePeerSets.push(...gatherDepSet([entryNode], e => {
+            return e.to !== entryNode && !e.peerConflicted
+          }))
+        } else {
+          this.warnPeerConflict(edge, this.dep)
+        }
+      }
+    }
+
+    this.placed.replace(this.oldDep)
+    this.pruneForReplacement(this.placed, oldDeps)
+    for (const dep of prunePeerSets) {
+      for (const edge of dep.edgesIn) {
+        this.needEvaluation.add(edge.from)
+      }
+      dep.root = null
+    }
+  }
+
+  pruneForReplacement (node, oldDeps) {
+    // gather up all the now-invalid/extraneous edgesOut, as long as they are
+    // only depended upon by the old node/deps
+    const invalidDeps = new Set([...node.edgesOut.values()]
+      .filter(e => e.to && !e.valid).map(e => e.to))
+    for (const dep of oldDeps) {
+      const set = gatherDepSet([dep], e => e.to !== dep && e.valid)
+      for (const dep of set) {
+        invalidDeps.add(dep)
+      }
+    }
+
+    // ignore dependency edges from the node being replaced, but
+    // otherwise filter the set down to just the set with no
+    // dependencies from outside the set, except the node in question.
+    const deps = gatherDepSet(invalidDeps, edge =>
+      edge.from !== node && edge.to !== node && edge.valid)
+
+    // now just delete whatever's left, because it's junk
+    for (const dep of deps) {
+      dep.root = null
+    }
+  }
+
+  // prune all the nodes in a branch of the tree that can be safely removed
+  // This is only the most basic duplication detection; it finds if there
+  // is another satisfying node further up the tree, and if so, dedupes.
+  // Even if installStrategy is nested, we do this amount of deduplication.
+  pruneDedupable (node, descend = true) {
+    if (node.canDedupe(this.preferDedupe, this.explicitRequest)) {
+      // gather up all deps that have no valid edges in from outside
+      // the dep set, except for this node we're deduping, so that we
+      // also prune deps that would be made extraneous.
+      const deps = gatherDepSet([node], e => e.to !== node && e.valid)
+      for (const node of deps) {
+        node.root = null
+      }
+      return
+    }
+    if (descend) {
+      // sort these so that they're deterministically ordered
+      // otherwise, resulting tree shape is dependent on the order
+      // in which they happened to be resolved.
+      const nodeSort = (a, b) => localeCompare(a.location, b.location)
+
+      const children = [...node.children.values()].sort(nodeSort)
+      for (const child of children) {
+        this.pruneDedupable(child)
+      }
+      const fsChildren = [...node.fsChildren].sort(nodeSort)
+      for (const topNode of fsChildren) {
+        const children = [...topNode.children.values()].sort(nodeSort)
+        for (const child of children) {
+          this.pruneDedupable(child)
+        }
+      }
+    }
+  }
+
+  get isMine () {
+    const { edge } = this.top
+    const { from: node } = edge
+
+    if (node.isWorkspace || node.isProjectRoot) {
+      return true
+    }
+
+    if (!edge.peer) {
+      return false
+    }
+
+    // re-entry case.  check if any non-peer edges come from the project,
+    // or any entryEdges on peer groups are from the root.
+    let hasPeerEdges = false
+    for (const edge of node.edgesIn) {
+      if (edge.peer) {
+        hasPeerEdges = true
+        continue
+      }
+      if (edge.from.isWorkspace || edge.from.isProjectRoot) {
+        return true
+      }
+    }
+    if (hasPeerEdges) {
+      for (const edge of peerEntrySets(node).keys()) {
+        if (edge.from.isWorkspace || edge.from.isProjectRoot) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }
+
+  warnPeerConflict (edge, dep) {
+    edge = edge || this.edge
+    dep = dep || this.dep
+    edge.peerConflicted = true
+    const expl = this.explainPeerConflict(edge, dep)
+    log.warn('ERESOLVE', 'overriding peer dependency', expl)
+  }
+
+  failPeerConflict (edge, dep) {
+    edge = edge || this.top.edge
+    dep = dep || this.top.dep
+    const expl = this.explainPeerConflict(edge, dep)
+    throw Object.assign(new Error('could not resolve'), expl)
+  }
+
+  explainPeerConflict (edge, dep) {
+    const { from: node } = edge
+    const curNode = node.resolve(edge.name)
+
+    // XXX decorate more with this.canPlace and this.canPlaceSelf,
+    // this.checks, this.children, walk over conflicted peers, etc.
+    const expl = {
+      code: 'ERESOLVE',
+      edge: edge.explain(),
+      dep: dep.explain(edge),
+      force: this.force,
+      isMine: this.isMine,
+      strictPeerDeps: this.strictPeerDeps,
+    }
+
+    if (this.parent) {
+      // this is the conflicted peer
+      expl.current = curNode && curNode.explain(edge)
+      expl.peerConflict = this.current && this.current.explain(this.edge)
+    } else {
+      expl.current = curNode && curNode.explain()
+      if (this.canPlaceSelf && this.canPlaceSelf.canPlaceSelf !== CONFLICT) {
+        // failed while checking for a child dep
+        const cps = this.canPlaceSelf
+        for (const peer of cps.conflictChildren) {
+          if (peer.current) {
+            expl.peerConflict = {
+              current: peer.current.explain(),
+              peer: peer.dep.explain(peer.edge),
+            }
+            break
+          }
+        }
+      } else {
+        expl.peerConflict = {
+          current: this.current && this.current.explain(),
+          peer: this.dep.explain(this.edge),
+        }
+      }
+    }
+
+    return expl
+  }
+
+  getStartNode () {
+    // if we are a peer, then we MUST be at least as shallow as the peer
+    // dependent
+    const from = this.parent?.getStartNode() || this.edge.from
+    return deepestNestingTarget(from, this.name)
+  }
+
+  // XXX this only appears to be used by tests
+  get allChildren () {
+    const set = new Set(this.children)
+    for (const child of set) {
+      for (const grandchild of child.children) {
+        set.add(grandchild)
+      }
+    }
+    return [...set]
+  }
+}
+
+module.exports = PlaceDep
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/printable.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/printable.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e520aac89aaa45d2e1452c8c505a4fce3c2da16
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/printable.js
@@ -0,0 +1,198 @@
+// helper function to output a clearer visualization
+// of the current node and its descendents
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const util = require('node:util')
+const relpath = require('./relpath.js')
+
+class ArboristNode {
+  constructor (tree, path) {
+    this.name = tree.name
+    if (tree.packageName && tree.packageName !== this.name) {
+      this.packageName = tree.packageName
+    }
+    if (tree.version) {
+      this.version = tree.version
+    }
+    this.location = tree.location
+    this.path = tree.path
+    if (tree.realpath !== this.path) {
+      this.realpath = tree.realpath
+    }
+    if (tree.resolved !== null) {
+      this.resolved = tree.resolved
+    }
+    if (tree.extraneous) {
+      this.extraneous = true
+    }
+    if (tree.dev) {
+      this.dev = true
+    }
+    if (tree.optional) {
+      this.optional = true
+    }
+    if (tree.devOptional && !tree.dev && !tree.optional) {
+      this.devOptional = true
+    }
+    if (tree.peer) {
+      this.peer = true
+    }
+    if (tree.inBundle) {
+      this.bundled = true
+    }
+    if (tree.inDepBundle) {
+      this.bundler = tree.getBundler().location
+    }
+    if (tree.isProjectRoot) {
+      this.isProjectRoot = true
+    }
+    if (tree.isWorkspace) {
+      this.isWorkspace = true
+    }
+    const bd = tree.package && tree.package.bundleDependencies
+    if (bd && bd.length) {
+      this.bundleDependencies = bd
+    }
+    if (tree.inShrinkwrap) {
+      this.inShrinkwrap = true
+    } else if (tree.hasShrinkwrap) {
+      this.hasShrinkwrap = true
+    }
+    if (tree.error) {
+      this.error = treeError(tree.error)
+    }
+    if (tree.errors && tree.errors.length) {
+      this.errors = tree.errors.map(treeError)
+    }
+
+    if (tree.overrides) {
+      this.overrides = new Map([...tree.overrides.ruleset.values()]
+        .map((override) => [override.key, override.value]))
+    }
+
+    // edgesOut sorted by name
+    if (tree.edgesOut.size) {
+      this.edgesOut = new Map([...tree.edgesOut.entries()]
+        .sort(([a], [b]) => localeCompare(a, b))
+        .map(([name, edge]) => [name, new EdgeOut(edge)]))
+    }
+
+    // edgesIn sorted by location
+    if (tree.edgesIn.size) {
+      this.edgesIn = new Set([...tree.edgesIn]
+        .sort((a, b) => localeCompare(a.from.location, b.from.location))
+        .map(edge => new EdgeIn(edge)))
+    }
+
+    if (tree.workspaces && tree.workspaces.size) {
+      this.workspaces = new Map([...tree.workspaces.entries()]
+        .map(([name, path]) => [name, relpath(tree.root.realpath, path)]))
+    }
+
+    // fsChildren sorted by path
+    if (tree.fsChildren.size) {
+      this.fsChildren = new Set([...tree.fsChildren]
+        .sort(({ path: a }, { path: b }) => localeCompare(a, b))
+        .map(tree => printableTree(tree, path)))
+    }
+
+    // children sorted by name
+    if (tree.children.size) {
+      this.children = new Map([...tree.children.entries()]
+        .sort(([a], [b]) => localeCompare(a, b))
+        .map(([name, tree]) => [name, printableTree(tree, path)]))
+    }
+  }
+}
+
+class ArboristVirtualNode extends ArboristNode {
+  constructor (tree, path) {
+    super(tree, path)
+    this.sourceReference = printableTree(tree.sourceReference, path)
+  }
+}
+
+class ArboristLink extends ArboristNode {
+  constructor (tree, path) {
+    super(tree, path)
+    this.target = printableTree(tree.target, path)
+  }
+}
+
+const treeError = ({ code, path }) => ({
+  code,
+  ...(path ? { path } : {}),
+})
+
+// print out edges without dumping the full node all over again
+// this base class will toJSON as a plain old object, but the
+// util.inspect() output will be a bit cleaner
+class Edge {
+  constructor (edge) {
+    this.type = edge.type
+    this.name = edge.name
+    this.spec = edge.rawSpec || '*'
+    if (edge.rawSpec !== edge.spec) {
+      this.override = edge.spec
+    }
+    if (edge.error) {
+      this.error = edge.error
+    }
+    if (edge.peerConflicted) {
+      this.peerConflicted = edge.peerConflicted
+    }
+  }
+}
+
+// don't care about 'from' for edges out
+class EdgeOut extends Edge {
+  constructor (edge) {
+    super(edge)
+    this.to = edge.to && edge.to.location
+  }
+
+  [util.inspect.custom] () {
+    return `{ ${this.type} ${this.name}@${this.spec}${
+      this.override ? ` overridden:${this.override}` : ''
+    }${
+      this.to ? ' -> ' + this.to : ''
+    }${
+      this.error ? ' ' + this.error : ''
+    }${
+      this.peerConflicted ? ' peerConflicted' : ''
+    } }`
+  }
+}
+
+// don't care about 'to' for edges in
+class EdgeIn extends Edge {
+  constructor (edge) {
+    super(edge)
+    this.from = edge.from && edge.from.location
+  }
+
+  [util.inspect.custom] () {
+    return `{ ${this.from || '""'} ${this.type} ${this.name}@${this.spec}${
+      this.error ? ' ' + this.error : ''
+    }${
+      this.peerConflicted ? ' peerConflicted' : ''
+    } }`
+  }
+}
+
+const printableTree = (tree, path = []) => {
+  if (!tree) {
+    return tree
+  }
+
+  const Cls = tree.isLink ? ArboristLink
+    : tree.sourceReference ? ArboristVirtualNode
+    : ArboristNode
+  if (path.includes(tree)) {
+    const obj = Object.create(Cls.prototype)
+    return Object.assign(obj, { location: tree.location })
+  }
+  path.push(tree)
+  return new Cls(tree, path)
+}
+
+module.exports = printableTree
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/query-selector-all.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/query-selector-all.js
new file mode 100644
index 0000000000000000000000000000000000000000..757675f3486a313ac9131801a96a74cfb1f57f22
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/query-selector-all.js
@@ -0,0 +1,958 @@
+'use strict'
+
+const { resolve } = require('node:path')
+const { parser, arrayDelimiter } = require('@npmcli/query')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { log } = require('proc-log')
+const { minimatch } = require('minimatch')
+const npa = require('npm-package-arg')
+const pacote = require('pacote')
+const semver = require('semver')
+const npmFetch = require('npm-registry-fetch')
+
+// handle results for parsed query asts, results are stored in a map that has a
+// key that points to each ast selector node and stores the resulting array of
+// arborist nodes as its value, that is essential to how we handle multiple
+// query selectors, e.g: `#a, #b, #c` <- 3 diff ast selector nodes
+class Results {
+  #currentAstSelector
+  #initialItems
+  #inventory
+  #outdatedCache = new Map()
+  #vulnCache
+  #pendingCombinator
+  #results = new Map()
+  #targetNode
+
+  constructor (opts) {
+    this.#currentAstSelector = opts.rootAstNode.nodes[0]
+    this.#inventory = opts.inventory
+    this.#initialItems = opts.initialItems
+    this.#vulnCache = opts.vulnCache
+    this.#targetNode = opts.targetNode
+
+    this.currentResults = this.#initialItems
+
+    // We get this when first called and need to pass it to pacote
+    this.flatOptions = opts.flatOptions || {}
+
+    // reset by rootAstNode walker
+    this.currentAstNode = opts.rootAstNode
+  }
+
+  get currentResults () {
+    return this.#results.get(this.#currentAstSelector)
+  }
+
+  set currentResults (value) {
+    this.#results.set(this.#currentAstSelector, value)
+  }
+
+  // retrieves the initial items to which start the filtering / matching
+  // for most of the different types of recognized ast nodes, e.g: class (aka
+  // depType), id, *, etc in different contexts we need to start with the
+  // current list of filtered results, for example a query for `.workspace`
+  // actually means the same as `*.workspace` so we want to start with the full
+  // inventory if that's the first ast node we're reading but if it appears in
+  // the middle of a query it should respect the previous filtered results,
+  // combinators are a special case in which we always want to have the
+  // complete inventory list in order to use the left-hand side ast node as a
+  // filter combined with the element on its right-hand side
+  get initialItems () {
+    const firstParsed =
+      (this.currentAstNode.parent.nodes[0] === this.currentAstNode) &&
+      (this.currentAstNode.parent.parent.type === 'root')
+
+    if (firstParsed) {
+      return this.#initialItems
+    }
+
+    if (this.currentAstNode.prev().type === 'combinator') {
+      return this.#inventory
+    }
+    return this.currentResults
+  }
+
+  // combinators need information about previously filtered items along
+  // with info of the items parsed / retrieved from the selector right
+  // past the combinator, for this reason combinators are stored and
+  // only ran as the last part of each selector logic
+  processPendingCombinator (nextResults) {
+    if (this.#pendingCombinator) {
+      const res = this.#pendingCombinator(this.currentResults, nextResults)
+      this.#pendingCombinator = null
+      this.currentResults = res
+    } else {
+      this.currentResults = nextResults
+    }
+  }
+
+  // when collecting results to a root astNode, we traverse the list of child
+  // selector nodes and collect all of their resulting arborist nodes into a
+  // single/flat Set of items, this ensures we also deduplicate items
+  collect (rootAstNode) {
+    return new Set(rootAstNode.nodes.flatMap(n => this.#results.get(n)))
+  }
+
+  // selector types map to the '.type' property of the ast nodes via `${astNode.type}Type`
+  //
+  // attribute selector [name=value], etc
+  attributeType () {
+    const nextResults = this.initialItems.filter(node =>
+      attributeMatch(this.currentAstNode, node.package)
+    )
+    this.processPendingCombinator(nextResults)
+  }
+
+  // dependency type selector (i.e. .prod, .dev, etc)
+  // css calls this class, we interpret is as dependency type
+  classType () {
+    const depTypeFn = depTypes[String(this.currentAstNode)]
+    if (!depTypeFn) {
+      throw Object.assign(
+        new Error(`\`${String(this.currentAstNode)}\` is not a supported dependency type.`),
+        { code: 'EQUERYNODEPTYPE' }
+      )
+    }
+    const nextResults = depTypeFn(this.initialItems)
+    this.processPendingCombinator(nextResults)
+  }
+
+  // combinators (i.e. '>', ' ', '~')
+  combinatorType () {
+    this.#pendingCombinator = combinators[String(this.currentAstNode)]
+  }
+
+  // name selectors (i.e. #foo)
+  // css calls this id, we interpret it as name
+  idType () {
+    const name = this.currentAstNode.value
+    const nextResults = this.initialItems.filter(node =>
+      (name === node.name) || (name === node.package.name)
+    )
+    this.processPendingCombinator(nextResults)
+  }
+
+  // pseudo selectors (prefixed with :)
+  async pseudoType () {
+    const pseudoFn = `${this.currentAstNode.value.slice(1)}Pseudo`
+    if (!this[pseudoFn]) {
+      throw Object.assign(
+        new Error(`\`${this.currentAstNode.value
+        }\` is not a supported pseudo selector.`),
+        { code: 'EQUERYNOPSEUDO' }
+      )
+    }
+    const nextResults = await this[pseudoFn]()
+    this.processPendingCombinator(nextResults)
+  }
+
+  selectorType () {
+    this.#currentAstSelector = this.currentAstNode
+    // starts a new array in which resulting items
+    // can be stored for each given ast selector
+    if (!this.currentResults) {
+      this.currentResults = []
+    }
+  }
+
+  universalType () {
+    this.processPendingCombinator(this.initialItems)
+  }
+
+  // pseudo selectors map to the 'value' property of the pseudo selectors in the ast nodes
+  // via selectors via `${value.slice(1)}Pseudo`
+  attrPseudo () {
+    const { lookupProperties, attributeMatcher } = this.currentAstNode
+
+    return this.initialItems.filter(node => {
+      let objs = [node.package]
+      for (const prop of lookupProperties) {
+        // if an isArray symbol is found that means we'll need to iterate
+        // over the previous found array to basically make sure we traverse
+        // all its indexes testing for possible objects that may eventually
+        // hold more keys specified in a selector
+        if (prop === arrayDelimiter) {
+          objs = objs.flat()
+          continue
+        }
+
+        // otherwise just maps all currently found objs
+        // to the next prop from the lookup properties list,
+        // filters out any empty key lookup
+        objs = objs.flatMap(obj => obj[prop] || [])
+
+        // in case there's no property found in the lookup
+        // just filters that item out
+        const noAttr = objs.every(obj => !obj)
+        if (noAttr) {
+          return false
+        }
+      }
+
+      // if any of the potential object matches
+      // that item should be in the final result
+      return objs.some(obj => attributeMatch(attributeMatcher, obj))
+    })
+  }
+
+  emptyPseudo () {
+    return this.initialItems.filter(node => node.edgesOut.size === 0)
+  }
+
+  extraneousPseudo () {
+    return this.initialItems.filter(node => node.extraneous)
+  }
+
+  async hasPseudo () {
+    const found = []
+    for (const item of this.initialItems) {
+      // This is the one time initialItems differs from inventory
+      const res = await retrieveNodesFromParsedAst({
+        flatOptions: this.flatOptions,
+        initialItems: [item],
+        inventory: this.#inventory,
+        rootAstNode: this.currentAstNode.nestedNode,
+        targetNode: item,
+        vulnCache: this.#vulnCache,
+      })
+      if (res.size > 0) {
+        found.push(item)
+      }
+    }
+    return found
+  }
+
+  invalidPseudo () {
+    const found = []
+    for (const node of this.initialItems) {
+      for (const edge of node.edgesIn) {
+        if (edge.invalid) {
+          found.push(node)
+          break
+        }
+      }
+    }
+    return found
+  }
+
+  async isPseudo () {
+    const res = await retrieveNodesFromParsedAst({
+      flatOptions: this.flatOptions,
+      initialItems: this.initialItems,
+      inventory: this.#inventory,
+      rootAstNode: this.currentAstNode.nestedNode,
+      targetNode: this.currentAstNode,
+      vulnCache: this.#vulnCache,
+    })
+    return [...res]
+  }
+
+  linkPseudo () {
+    return this.initialItems.filter(node => node.isLink || (node.isTop && !node.isRoot))
+  }
+
+  missingPseudo () {
+    return this.#inventory.reduce((res, node) => {
+      for (const edge of node.edgesOut.values()) {
+        if (edge.missing) {
+          const pkg = { name: edge.name, version: edge.spec }
+          const item = new this.#targetNode.constructor({ pkg })
+          item.queryContext = {
+            missing: true,
+          }
+          item.edgesIn = new Set([edge])
+          res.push(item)
+        }
+      }
+      return res
+    }, [])
+  }
+
+  async notPseudo () {
+    const res = await retrieveNodesFromParsedAst({
+      flatOptions: this.flatOptions,
+      initialItems: this.initialItems,
+      inventory: this.#inventory,
+      rootAstNode: this.currentAstNode.nestedNode,
+      targetNode: this.currentAstNode,
+      vulnCache: this.#vulnCache,
+    })
+    const internalSelector = new Set(res)
+    return this.initialItems.filter(node =>
+      !internalSelector.has(node))
+  }
+
+  overriddenPseudo () {
+    return this.initialItems.filter(node => node.overridden)
+  }
+
+  pathPseudo () {
+    return this.initialItems.filter(node => {
+      if (!this.currentAstNode.pathValue) {
+        return true
+      }
+      return minimatch(
+        node.realpath.replace(/\\+/g, '/'),
+        resolve(node.root.realpath, this.currentAstNode.pathValue).replace(/\\+/g, '/')
+      )
+    })
+  }
+
+  privatePseudo () {
+    return this.initialItems.filter(node => node.package.private)
+  }
+
+  rootPseudo () {
+    return this.initialItems.filter(node => node === this.#targetNode.root)
+  }
+
+  scopePseudo () {
+    return this.initialItems.filter(node => node === this.#targetNode)
+  }
+
+  semverPseudo () {
+    const {
+      attributeMatcher,
+      lookupProperties,
+      semverFunc = 'infer',
+      semverValue,
+    } = this.currentAstNode
+    const { qualifiedAttribute } = attributeMatcher
+
+    if (!semverValue) {
+      // DEPRECATED: remove this warning and throw an error as part of @npmcli/arborist@6
+      log.warn('query', 'usage of :semver() with no parameters is deprecated')
+      return this.initialItems
+    }
+
+    if (!semver.valid(semverValue) && !semver.validRange(semverValue)) {
+      throw Object.assign(
+        new Error(`\`${semverValue}\` is not a valid semver version or range`),
+        { code: 'EQUERYINVALIDSEMVER' })
+    }
+
+    const valueIsVersion = !!semver.valid(semverValue)
+
+    const nodeMatches = (node, obj) => {
+      // if we already have an operator, the user provided some test as part of the selector
+      // we evaluate that first because if it fails we don't want this node anyway
+      if (attributeMatcher.operator) {
+        if (!attributeMatch(attributeMatcher, obj)) {
+          // if the initial operator doesn't match, we're done
+          return false
+        }
+      }
+
+      const attrValue = obj[qualifiedAttribute]
+      // both valid and validRange return null for undefined, so this will skip both nodes that
+      // do not have the attribute defined as well as those where the attribute value is invalid
+      // and those where the value from the package.json is not a string
+      if ((!semver.valid(attrValue) && !semver.validRange(attrValue)) ||
+          typeof attrValue !== 'string') {
+        return false
+      }
+
+      const attrIsVersion = !!semver.valid(attrValue)
+
+      let actualFunc = semverFunc
+
+      // if we're asked to infer, we examine outputs to make a best guess
+      if (actualFunc === 'infer') {
+        if (valueIsVersion && attrIsVersion) {
+          // two versions -> semver.eq
+          actualFunc = 'eq'
+        } else if (!valueIsVersion && !attrIsVersion) {
+          // two ranges -> semver.intersects
+          actualFunc = 'intersects'
+        } else {
+          // anything else -> semver.satisfies
+          actualFunc = 'satisfies'
+        }
+      }
+
+      if (['eq', 'neq', 'gt', 'gte', 'lt', 'lte'].includes(actualFunc)) {
+        // both sides must be versions, but one is not
+        if (!valueIsVersion || !attrIsVersion) {
+          return false
+        }
+
+        return semver[actualFunc](attrValue, semverValue)
+      } else if (['gtr', 'ltr', 'satisfies'].includes(actualFunc)) {
+        // at least one side must be a version, but neither is
+        if (!valueIsVersion && !attrIsVersion) {
+          return false
+        }
+
+        return valueIsVersion
+          ? semver[actualFunc](semverValue, attrValue)
+          : semver[actualFunc](attrValue, semverValue)
+      } else if (['intersects', 'subset'].includes(actualFunc)) {
+        // these accept two ranges and since a version is also a range, anything goes
+        return semver[actualFunc](attrValue, semverValue)
+      } else {
+        // user provided a function we don't know about, throw an error
+        throw Object.assign(new Error(`\`semver.${actualFunc}\` is not a supported operator.`),
+          { code: 'EQUERYINVALIDOPERATOR' })
+      }
+    }
+
+    return this.initialItems.filter((node) => {
+      // no lookupProperties just means its a top level property, see if it matches
+      if (!lookupProperties.length) {
+        return nodeMatches(node, node.package)
+      }
+
+      // this code is mostly duplicated from attrPseudo to traverse into the package until we get
+      // to our deepest requested object
+      let objs = [node.package]
+      for (const prop of lookupProperties) {
+        if (prop === arrayDelimiter) {
+          objs = objs.flat()
+          continue
+        }
+
+        objs = objs.flatMap(obj => obj[prop] || [])
+        const noAttr = objs.every(obj => !obj)
+        if (noAttr) {
+          return false
+        }
+
+        return objs.some(obj => nodeMatches(node, obj))
+      }
+    })
+  }
+
+  typePseudo () {
+    if (!this.currentAstNode.typeValue) {
+      return this.initialItems
+    }
+    // TODO this differs subtly with `:type()` because it now iterates on edgesIn, which means extraneous deps won't show up
+    // note how "@npmcli/abbrev@2.0.0-beta.45" is in the `:type()` results in the test but not in any of the other results.
+    return this.initialItems
+      .flatMap(node => {
+        const found = []
+        const { typeValue } = this.currentAstNode
+        for (const edge of node.edgesIn) {
+          const parsedArg = npa(`${edge.name}@${edge.spec}`)
+          if (typeValue === 'registry') {
+            if (parsedArg.registry) {
+              found.push(edge.to)
+            }
+          } else if (parsedArg.type === typeValue) {
+            found.push(edge.to)
+          }
+        }
+        return found
+      })
+  }
+
+  dedupedPseudo () {
+    return this.initialItems.filter(node => node.target.edgesIn.size > 1)
+  }
+
+  async vulnPseudo () {
+    if (!this.initialItems.length) {
+      return this.initialItems
+    }
+    if (!this.#vulnCache) {
+      const packages = {}
+      // We have to map the items twice, once to get the request, and a second time to filter out the results of that request
+      this.initialItems.map((node) => {
+        if (node.isProjectRoot || node.package.private) {
+          return
+        }
+        if (!packages[node.name]) {
+          packages[node.name] = []
+        }
+        if (!packages[node.name].includes(node.version)) {
+          packages[node.name].push(node.version)
+        }
+      })
+      const res = await npmFetch('/-/npm/v1/security/advisories/bulk', {
+        ...this.flatOptions,
+        registry: this.flatOptions.auditRegistry || this.flatOptions.registry,
+        method: 'POST',
+        gzip: true,
+        body: packages,
+      })
+      this.#vulnCache = await res.json()
+    }
+    const advisories = this.#vulnCache
+    const { vulns } = this.currentAstNode
+    return this.initialItems.filter(item => {
+      const vulnerable = advisories[item.name]?.filter(advisory => {
+        // This could be for another version of this package elsewhere in the tree
+        if (!semver.intersects(advisory.vulnerable_versions, item.version)) {
+          return false
+        }
+        if (!vulns) {
+          return true
+        }
+        // vulns are OR with each other, if any one matches we're done
+        for (const vuln of vulns) {
+          if (vuln.severity && !vuln.severity.includes('*')) {
+            if (!vuln.severity.includes(advisory.severity)) {
+              continue
+            }
+          }
+
+          if (vuln?.cwe) {
+            // * is special, it means "has a cwe"
+            if (vuln.cwe.includes('*')) {
+              if (!advisory.cwe.length) {
+                continue
+              }
+            } else if (!vuln.cwe.every(cwe => advisory.cwe.includes(`CWE-${cwe}`))) {
+              continue
+            }
+          }
+          return true
+        }
+      })
+      if (vulnerable?.length) {
+        item.queryContext = {
+          advisories: vulnerable,
+        }
+        return true
+      }
+      return false
+    })
+  }
+
+  async outdatedPseudo () {
+    const { outdatedKind = 'any' } = this.currentAstNode
+
+    // filter the initialItems
+    // NOTE: this uses a Promise.all around a map without in-line concurrency handling
+    // since the only async action taken is retrieving the packument, which is limited
+    // based on the max-sockets config in make-fetch-happen
+    const initialResults = await Promise.all(this.initialItems.map(async (node) => {
+      // the root can't be outdated, skip it
+      if (node.isProjectRoot) {
+        return false
+      }
+
+      // private packages can't be published, skip them
+      if (node.package.private) {
+        return false
+      }
+
+      // we cache the promise representing the full versions list, this helps reduce the
+      // number of requests we send by keeping population of the cache in a single tick
+      // making it less likely that multiple requests for the same package will be inflight
+      if (!this.#outdatedCache.has(node.name)) {
+        this.#outdatedCache.set(node.name, getPackageVersions(node.name, this.flatOptions))
+      }
+      const availableVersions = await this.#outdatedCache.get(node.name)
+
+      // we attach _all_ versions to the queryContext to allow consumers to do their own
+      // filtering and comparisons
+      node.queryContext.versions = availableVersions
+
+      // next we further reduce the set to versions that are greater than the current one
+      const greaterVersions = availableVersions.filter((available) => {
+        return semver.gt(available, node.version)
+      })
+
+      // no newer versions than the current one, drop this node from the result set
+      if (!greaterVersions.length) {
+        return false
+      }
+
+      // if we got here, we know that newer versions exist, if the kind is 'any' we're done
+      if (outdatedKind === 'any') {
+        return node
+      }
+
+      // look for newer versions that differ from current by a specific part of the semver version
+      if (['major', 'minor', 'patch'].includes(outdatedKind)) {
+        // filter the versions greater than our current one based on semver.diff
+        const filteredVersions = greaterVersions.filter((version) => {
+          return semver.diff(node.version, version) === outdatedKind
+        })
+
+        // no available versions are of the correct diff type
+        if (!filteredVersions.length) {
+          return false
+        }
+
+        return node
+      }
+
+      // look for newer versions that satisfy at least one edgeIn to this node
+      if (outdatedKind === 'in-range') {
+        const inRangeContext = []
+        for (const edge of node.edgesIn) {
+          const inRangeVersions = greaterVersions.filter((version) => {
+            return semver.satisfies(version, edge.spec)
+          })
+
+          // this edge has no in-range candidates, just move on
+          if (!inRangeVersions.length) {
+            continue
+          }
+
+          inRangeContext.push({
+            from: edge.from.location,
+            versions: inRangeVersions,
+          })
+        }
+
+        // if we didn't find at least one match, drop this node
+        if (!inRangeContext.length) {
+          return false
+        }
+
+        // now add to the context each version that is in-range for each edgeIn
+        node.queryContext.outdated = {
+          ...node.queryContext.outdated,
+          inRange: inRangeContext,
+        }
+
+        return node
+      }
+
+      // look for newer versions that _do not_ satisfy at least one edgeIn
+      if (outdatedKind === 'out-of-range') {
+        const outOfRangeContext = []
+        for (const edge of node.edgesIn) {
+          const outOfRangeVersions = greaterVersions.filter((version) => {
+            return !semver.satisfies(version, edge.spec)
+          })
+
+          // this edge has no out-of-range candidates, skip it
+          if (!outOfRangeVersions.length) {
+            continue
+          }
+
+          outOfRangeContext.push({
+            from: edge.from.location,
+            versions: outOfRangeVersions,
+          })
+        }
+
+        // if we didn't add at least one thing to the context, this node is not a match
+        if (!outOfRangeContext.length) {
+          return false
+        }
+
+        // attach the out-of-range context to the node
+        node.queryContext.outdated = {
+          ...node.queryContext.outdated,
+          outOfRange: outOfRangeContext,
+        }
+
+        return node
+      }
+
+      // any other outdatedKind is unknown and will never match
+      return false
+    }))
+
+    // return an array with the holes for non-matching nodes removed
+    return initialResults.filter(Boolean)
+  }
+}
+
+// operators for attribute selectors
+const attributeOperators = {
+  // attribute value is equivalent
+  '=' ({ attr, value }) {
+    return attr === value
+  },
+  // attribute value contains word
+  '~=' ({ attr, value }) {
+    return (attr.match(/\w+/g) || []).includes(value)
+  },
+  // attribute value contains string
+  '*=' ({ attr, value }) {
+    return attr.includes(value)
+  },
+  // attribute value is equal or starts with
+  '|=' ({ attr, value }) {
+    return attr.startsWith(`${value}-`)
+  },
+  // attribute value starts with
+  '^=' ({ attr, value }) {
+    return attr.startsWith(value)
+  },
+  // attribute value ends with
+  '$=' ({ attr, value }) {
+    return attr.endsWith(value)
+  },
+}
+
+const attributeOperator = ({ attr, value, insensitive, operator }) => {
+  if (typeof attr === 'number') {
+    attr = String(attr)
+  }
+  if (typeof attr !== 'string') {
+    // It's an object or an array, bail
+    return false
+  }
+  if (insensitive) {
+    attr = attr.toLowerCase()
+  }
+
+  return attributeOperators[operator]({
+    attr,
+    insensitive,
+    value,
+  })
+}
+
+const attributeMatch = (matcher, obj) => {
+  const insensitive = !!matcher.insensitive
+  const operator = matcher.operator || ''
+  const attribute = matcher.qualifiedAttribute
+  let value = matcher.value || ''
+  // return early if checking existence
+  if (operator === '') {
+    return Boolean(obj[attribute])
+  }
+  if (insensitive) {
+    value = value.toLowerCase()
+  }
+  // in case the current object is an array
+  // then we try to match every item in the array
+  if (Array.isArray(obj[attribute])) {
+    return obj[attribute].find((i, index) => {
+      const attr = obj[attribute][index] || ''
+      return attributeOperator({ attr, value, insensitive, operator })
+    })
+  } else {
+    const attr = obj[attribute] || ''
+    return attributeOperator({ attr, value, insensitive, operator })
+  }
+}
+
+const edgeIsType = (node, type, seen = new Set()) => {
+  for (const edgeIn of node.edgesIn) {
+    // TODO Need a test with an infinite loop
+    if (seen.has(edgeIn)) {
+      continue
+    }
+    seen.add(edgeIn)
+    if (edgeIn.type === type || edgeIn.from[type] || edgeIsType(edgeIn.from, type, seen)) {
+      return true
+    }
+  }
+  return false
+}
+
+const filterByType = (nodes, type) => {
+  const found = []
+  for (const node of nodes) {
+    if (node[type] || edgeIsType(node, type)) {
+      found.push(node)
+    }
+  }
+  return found
+}
+
+const depTypes = {
+  // dependency
+  '.prod' (prevResults) {
+    const found = []
+    for (const node of prevResults) {
+      if (!node.dev) {
+        found.push(node)
+      }
+    }
+    return found
+  },
+  // devDependency
+  '.dev' (prevResults) {
+    return filterByType(prevResults, 'dev')
+  },
+  // optionalDependency
+  '.optional' (prevResults) {
+    return filterByType(prevResults, 'optional')
+  },
+  // peerDependency
+  '.peer' (prevResults) {
+    return filterByType(prevResults, 'peer')
+  },
+  // workspace
+  '.workspace' (prevResults) {
+    return prevResults.filter(node => node.isWorkspace)
+  },
+  // bundledDependency
+  '.bundled' (prevResults) {
+    return prevResults.filter(node => node.inBundle)
+  },
+}
+
+// checks if a given node has a direct parent in any of the nodes provided in
+// the compare nodes array
+const hasParent = (node, compareNodes) => {
+  // All it takes is one so we loop and return on the first hit
+  for (let compareNode of compareNodes) {
+    if (compareNode.isLink) {
+      compareNode = compareNode.target
+    }
+
+    // Follows logical parent for link ancestors (e.g. workspaces whose target lives outside node_modules).
+    // Only match if the node has a link whose parent is the compareNode. Without this check, nodes deep in the store (linked strategy) would incorrectly match as children of root via their fsParent chain.
+    if (node.isTop && (node.resolveParent === compareNode)) {
+      for (const link of node.linksIn) {
+        if (link.parent === compareNode) {
+          return true
+        }
+      }
+    }
+    // follows edges-in to check if they match a possible parent
+    for (const edge of node.edgesIn) {
+      if (edge && edge.from === compareNode) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// checks if a given node is a descendant of any of the nodes provided in the
+// compareNodes array
+const hasAscendant = (node, compareNodes, seen = new Set()) => {
+  // TODO (future) loop over ancestry property
+  if (hasParent(node, compareNodes)) {
+    return true
+  }
+
+  if (node.isTop && node.resolveParent) {
+    /* istanbul ignore if - investigate if linksIn check obviates need for this */
+    if (hasAscendant(node.resolveParent, compareNodes)) {
+      return true
+    }
+  }
+  for (const edge of node.edgesIn) {
+    // TODO Need a test with an infinite loop
+    if (seen.has(edge)) {
+      continue
+    }
+    seen.add(edge)
+    if (edge && edge.from && hasAscendant(edge.from, compareNodes, seen)) {
+      return true
+    }
+  }
+  for (const linkNode of node.linksIn) {
+    if (hasAscendant(linkNode, compareNodes, seen)) {
+      return true
+    }
+  }
+  return false
+}
+
+const combinators = {
+  // direct descendant
+  '>' (prevResults, nextResults) {
+    return nextResults.filter(node => hasParent(node, prevResults))
+  },
+  // any descendant
+  ' ' (prevResults, nextResults) {
+    return nextResults.filter(node => hasAscendant(node, prevResults))
+  },
+  // sibling
+  '~' (prevResults, nextResults) {
+    // Return any node in nextResults that is a sibling of (aka shares a
+    // parent with) a node in prevResults
+    const parentNodes = new Set() // Parents of everything in prevResults
+    for (const node of prevResults) {
+      for (const edge of node.edgesIn) {
+        // edge.from always exists cause it's from another node's edgesIn
+        parentNodes.add(edge.from)
+      }
+    }
+    return nextResults.filter(node =>
+      !prevResults.includes(node) && hasParent(node, [...parentNodes])
+    )
+  },
+}
+
+// get a list of available versions of a package filtered to respect --before
+// NOTE: this runs over each node and should not throw
+const getPackageVersions = async (name, opts) => {
+  let packument
+  try {
+    packument = await pacote.packument(name, {
+      ...opts,
+      fullMetadata: false, // we only need the corgi
+    })
+  } catch (err) {
+    // if the fetch fails, log a warning and pretend there are no versions
+    log.warn('query', `could not retrieve packument for ${name}: ${err.message}`)
+    return []
+  }
+
+  // start with a sorted list of all versions (lowest first)
+  let candidates = Object.keys(packument.versions).sort(semver.compare)
+
+  // if the packument has a time property, and the user passed a before flag, then
+  // we filter this list down to only those versions that existed before the specified date
+  if (packument.time && opts.before) {
+    candidates = candidates.filter((version) => {
+      // this version isn't found in the times at all, drop it
+      if (!packument.time[version]) {
+        return false
+      }
+
+      return Date.parse(packument.time[version]) <= opts.before
+    })
+  }
+
+  return candidates
+}
+
+const retrieveNodesFromParsedAst = async (opts) => {
+  // when we first call this it's the parsed query.  all other times it's
+  // results.currentNode.nestedNode
+  const rootAstNode = opts.rootAstNode
+
+  if (!rootAstNode.nodes) {
+    return new Set()
+  }
+
+  const results = new Results(opts)
+
+  const astNodeQueue = new Set()
+  // walk is sync, so we have to build up our async functions and then await them later
+  rootAstNode.walk((nextAstNode) => {
+    astNodeQueue.add(nextAstNode)
+  })
+
+  for (const nextAstNode of astNodeQueue) {
+    // This is the only place we reset currentAstNode
+    results.currentAstNode = nextAstNode
+    const updateFn = `${results.currentAstNode.type}Type`
+    if (typeof results[updateFn] !== 'function') {
+      throw Object.assign(
+        new Error(`\`${results.currentAstNode.type}\` is not a supported selector.`),
+        { code: 'EQUERYNOSELECTOR' }
+      )
+    }
+    await results[updateFn]()
+  }
+
+  return results.collect(rootAstNode)
+}
+
+const querySelectorAll = async (targetNode, query, flatOptions) => {
+  // This never changes ever we just pass it around. But we can't scope it to
+  // this whole file if we ever want to support concurrent calls to this
+  // function.
+  const inventory = [...targetNode.root.inventory.values()]
+  // res is a Set of items returned for each parsed css ast selector
+  const res = await retrieveNodesFromParsedAst({
+    initialItems: inventory,
+    inventory,
+    flatOptions,
+    rootAstNode: parser(query),
+    targetNode,
+  })
+
+  // returns nodes ordered by realpath
+  return [...res].sort((a, b) => localeCompare(a.location, b.location))
+}
+
+module.exports = querySelectorAll
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/realpath.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/realpath.js
new file mode 100644
index 0000000000000000000000000000000000000000..9440f860a07c438cb81817bb87c49e01e625925e
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/realpath.js
@@ -0,0 +1,95 @@
+// look up the realpath, but cache stats to minimize overhead
+// If the parent folder is in  the realpath cache, then we just
+// lstat the child, since there's no need to do a full realpath
+// This is not a separate module, and is much simpler than Node's
+// built-in fs.realpath, because we only care about symbolic links,
+// so we can handle many fewer edge cases.
+
+const { lstat, readlink } = require('node:fs/promises')
+const { resolve, basename, dirname } = require('node:path')
+
+const realpathCached = (path, rpcache, stcache, depth) => {
+  // just a safety against extremely deep eloops
+  /* istanbul ignore next */
+  if (depth > 2000) {
+    throw eloop(path)
+  }
+
+  path = resolve(path)
+  if (rpcache.has(path)) {
+    return Promise.resolve(rpcache.get(path))
+  }
+
+  const dir = dirname(path)
+  const base = basename(path)
+
+  if (base && rpcache.has(dir)) {
+    return realpathChild(dir, base, rpcache, stcache, depth)
+  }
+
+  // if it's the root, then we know it's real
+  if (!base) {
+    rpcache.set(dir, dir)
+    return Promise.resolve(dir)
+  }
+
+  // the parent, what is that?
+  // find out, and then come back.
+  return realpathCached(dir, rpcache, stcache, depth + 1).then(() =>
+    realpathCached(path, rpcache, stcache, depth + 1))
+}
+
+const lstatCached = (path, stcache) => {
+  if (stcache.has(path)) {
+    return Promise.resolve(stcache.get(path))
+  }
+
+  const p = lstat(path).then(st => {
+    stcache.set(path, st)
+    return st
+  })
+  stcache.set(path, p)
+  return p
+}
+
+// This is a slight fib, as it doesn't actually occur during a stat syscall.
+// But file systems are giant piles of lies, so whatever.
+const eloop = path =>
+  Object.assign(new Error(
+    `ELOOP: too many symbolic links encountered, stat '${path}'`), {
+    errno: -62,
+    syscall: 'stat',
+    code: 'ELOOP',
+    path: path,
+  })
+
+const realpathChild = (dir, base, rpcache, stcache, depth) => {
+  const realdir = rpcache.get(dir)
+  // that unpossible
+  /* istanbul ignore next */
+  if (typeof realdir === 'undefined') {
+    throw new Error('in realpathChild without parent being in realpath cache')
+  }
+
+  const realish = resolve(realdir, base)
+  return lstatCached(realish, stcache).then(st => {
+    if (!st.isSymbolicLink()) {
+      rpcache.set(resolve(dir, base), realish)
+      return realish
+    }
+
+    return readlink(realish).then(target => {
+      const resolved = resolve(realdir, target)
+      if (realish === resolved) {
+        throw eloop(realish)
+      }
+
+      return realpathCached(resolved, rpcache, stcache, depth + 1)
+    }).then(real => {
+      rpcache.set(resolve(dir, base), real)
+      return real
+    })
+  })
+}
+
+module.exports = realpathCached
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/relpath.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/relpath.js
new file mode 100644
index 0000000000000000000000000000000000000000..8bb8da28a880cdf1553df27e6b5c4b661ff86e6a
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/relpath.js
@@ -0,0 +1,3 @@
+const { relative } = require('node:path')
+const relpath = (from, to) => relative(from, to).replace(/\\/g, '/')
+module.exports = relpath
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/reset-dep-flags.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/reset-dep-flags.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb69086d4648953507ca6f81c3ec645fead5e0fa
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/reset-dep-flags.js
@@ -0,0 +1,11 @@
+// Sometimes we need to actually do a walk from the root, because you can
+// have a cycle of deps that all depend on each other, but no path from root.
+// Also, since the ideal tree is loaded from the shrinkwrap, it had extraneous
+// flags set false that might now be actually extraneous, and dev/optional
+// flags that are also now incorrect.  This method sets all flags to true, so
+// we can find the set that is actually extraneous.
+module.exports = tree => {
+  for (const node of tree.inventory.values()) {
+    node.resetDepFlags()
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/retire-path.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/retire-path.js
new file mode 100644
index 0000000000000000000000000000000000000000..ff9b9e9c19c95f07e590ee58088364da52fcd486
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/retire-path.js
@@ -0,0 +1,19 @@
+const crypto = require('node:crypto')
+const { dirname, basename, resolve } = require('node:path')
+
+// use sha1 because it's faster, and collisions extremely unlikely anyway
+const pathSafeHash = s =>
+  crypto.createHash('sha1')
+    .update(s)
+    .digest('base64')
+    .replace(/[^a-zA-Z0-9]+/g, '')
+    .slice(0, 8)
+
+const retirePath = from => {
+  const d = dirname(from)
+  const b = basename(from)
+  const hash = pathSafeHash(from)
+  return resolve(d, `.${b}-${hash}`)
+}
+
+module.exports = retirePath
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js
new file mode 100644
index 0000000000000000000000000000000000000000..f92d8202ff44350b43114ae51d37e15854592289
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js
@@ -0,0 +1,1182 @@
+// a module that manages a shrinkwrap file (npm-shrinkwrap.json or
+// package-lock.json).
+
+// Increment whenever the lockfile version updates
+// v1 - npm <=6
+// v2 - arborist v1, npm v7, backwards compatible with v1, add 'packages'
+// v3 will drop the 'dependencies' field, backwards comp with v2, not v1
+//
+// We cannot bump to v3 until npm v6 is out of common usage, and
+// definitely not before npm v8.
+
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const defaultLockfileVersion = 3
+
+// for comparing nodes to yarn.lock entries
+const mismatch = (a, b) => a && b && a !== b
+
+// this.tree => the root node for the tree (ie, same path as this)
+// - Set the first time we do `this.add(node)` for a path matching this.path
+//
+// this.add(node) =>
+// - decorate the node with the metadata we have, if we have it, and it matches
+// - add to the map of nodes needing to be committed, so that subsequent
+// changes are captured when we commit that location's metadata.
+//
+// this.commit() =>
+// - commit all nodes awaiting update to their metadata entries
+// - re-generate this.data and this.yarnLock based on this.tree
+//
+// Note that between this.add() and this.commit(), `this.data` will be out of
+// date!  Always call `commit()` before relying on it.
+//
+// After calling this.commit(), any nodes not present in the tree will have
+// been removed from the shrinkwrap data as well.
+
+const { log } = require('proc-log')
+const YarnLock = require('./yarn-lock.js')
+const {
+  readFile,
+  readdir,
+  readlink,
+  rm,
+  stat,
+  writeFile,
+} = require('node:fs/promises')
+
+const { resolve, basename, relative } = require('node:path')
+const specFromLock = require('./spec-from-lock.js')
+const versionFromTgz = require('./version-from-tgz.js')
+const npa = require('npm-package-arg')
+const pkgJson = require('@npmcli/package-json')
+const parseJSON = require('parse-conflict-json')
+const nameFromFolder = require('@npmcli/name-from-folder')
+
+const stringify = require('json-stringify-nice')
+const swKeyOrder = [
+  'name',
+  'version',
+  'lockfileVersion',
+  'resolved',
+  'integrity',
+  'requires',
+  'packages',
+  'dependencies',
+]
+
+// used to rewrite from yarn registry to npm registry
+const yarnRegRe = /^https?:\/\/registry\.yarnpkg\.com\//
+const npmRegRe = /^https?:\/\/registry\.npmjs\.org\//
+
+// sometimes resolved: is weird or broken, or something npa can't handle
+const specFromResolved = resolved => {
+  try {
+    return npa(resolved)
+  } catch (er) {
+    return {}
+  }
+}
+
+const relpath = require('./relpath.js')
+
+const consistentResolve = require('./consistent-resolve.js')
+const { overrideResolves } = require('./override-resolves.js')
+
+const pkgMetaKeys = [
+  // note: name is included if necessary, for alias packages
+  'version',
+  'dependencies',
+  'peerDependencies',
+  'peerDependenciesMeta',
+  'optionalDependencies',
+  'bundleDependencies',
+  'acceptDependencies',
+  'funding',
+  'engines',
+  'os',
+  'cpu',
+  'libc',
+  '_integrity',
+  'license',
+  '_hasShrinkwrap',
+  'hasInstallScript',
+  'bin',
+  'deprecated',
+  'workspaces',
+]
+
+const nodeMetaKeys = [
+  'integrity',
+  'inBundle',
+  'hasShrinkwrap',
+  'hasInstallScript',
+]
+
+const metaFieldFromPkg = (pkg, key) => {
+  const val = pkg[key]
+  if (val) {
+    // get only the license type, not the full object
+    if (key === 'license' && typeof val === 'object' && val.type) {
+      return val.type
+    }
+    // skip empty objects and falsey values
+    if (typeof val !== 'object' || Object.keys(val).length) {
+      return val
+    }
+  }
+  return null
+}
+
+// check to make sure that there are no packages newer than or missing from the hidden lockfile
+const assertNoNewer = async (path, data, lockTime, dir, seen) => {
+  const base = basename(dir)
+  const isNM = dir !== path && base === 'node_modules'
+  const isScope = dir !== path && base.startsWith('@')
+  const isParent = (dir === path) || isNM || isScope
+
+  const parent = isParent ? dir : resolve(dir, 'node_modules')
+  const rel = relpath(path, dir)
+  seen.add(rel)
+  let entries
+  if (dir === path) {
+    entries = [{ name: 'node_modules', isDirectory: () => true }]
+  } else {
+    const { mtime: dirTime } = await stat(dir)
+    if (dirTime > lockTime) {
+      throw new Error(`out of date, updated: ${rel}`)
+    }
+    if (!isScope && !isNM && !data.packages[rel]) {
+      throw new Error(`missing from lockfile: ${rel}`)
+    }
+    entries = await readdir(parent, { withFileTypes: true }).catch(() => [])
+  }
+
+  // TODO limit concurrency here, this is recursive
+  await Promise.all(entries.map(async dirent => {
+    const child = resolve(parent, dirent.name)
+    if (dirent.isDirectory() && !dirent.name.startsWith('.')) {
+      await assertNoNewer(path, data, lockTime, child, seen)
+    } else if (dirent.isSymbolicLink()) {
+      const target = resolve(parent, await readlink(child))
+      const tstat = await stat(target).catch(
+        /* istanbul ignore next - windows */ () => null)
+      seen.add(relpath(path, child))
+      /* istanbul ignore next - windows cannot do this */
+      if (tstat?.isDirectory() && !seen.has(relpath(path, target))) {
+        await assertNoNewer(path, data, lockTime, target, seen)
+      }
+    }
+  }))
+
+  if (dir !== path) {
+    return
+  }
+
+  // assert that all the entries in the lockfile were seen
+  for (const loc in data.packages) {
+    if (!seen.has(loc)) {
+      throw new Error(`missing from node_modules: ${loc}`)
+    }
+  }
+}
+
+class Shrinkwrap {
+  static get defaultLockfileVersion () {
+    return defaultLockfileVersion
+  }
+
+  static load (options) {
+    return new Shrinkwrap(options).load()
+  }
+
+  static get keyOrder () {
+    return swKeyOrder
+  }
+
+  static async reset (options) {
+    // still need to know if it was loaded from the disk, but don't
+    // bother reading it if we're gonna just throw it away.
+    const s = new Shrinkwrap(options)
+    s.reset()
+
+    const [sw, lock] = await s.resetFiles
+
+    // XXX this is duplicated in this.load(), but using loadFiles instead of resetFiles
+    if (s.hiddenLockfile) {
+      s.filename = resolve(s.path, 'node_modules/.package-lock.json')
+    } else if (s.shrinkwrapOnly || sw) {
+      s.filename = resolve(s.path, 'npm-shrinkwrap.json')
+    } else {
+      s.filename = resolve(s.path, 'package-lock.json')
+    }
+    s.loadedFromDisk = !!(sw || lock)
+    // TODO what uses this?
+    s.type = basename(s.filename)
+
+    return s
+  }
+
+  static metaFromNode (node, path, options = {}) {
+    if (node.isLink) {
+      return {
+        resolved: relpath(path, node.realpath),
+        link: true,
+      }
+    }
+
+    const meta = {}
+    for (const key of pkgMetaKeys) {
+      const val = metaFieldFromPkg(node.package, key)
+      if (val) {
+        meta[key.replace(/^_/, '')] = val
+      }
+    }
+    // we only include name if different from the node path name, and for the
+    // root to help prevent churn based on the name of the directory the
+    // project is in
+    const pname = node.packageName
+    // when Target package name and Target node share the same name, we include the name, target node should have name as per realpath.
+    if (pname && (node === node.root || pname !== node.name || nameFromFolder(node.realpath) !== pname)) {
+      meta.name = pname
+    }
+
+    if (node.isTop && node.package.devDependencies) {
+      meta.devDependencies = node.package.devDependencies
+    }
+
+    for (const key of nodeMetaKeys) {
+      if (node[key]) {
+        meta[key] = node[key]
+      }
+    }
+
+    const resolved = consistentResolve(node.resolved, node.path, path, true)
+    // hide resolved from registry dependencies.
+    if (!resolved) {
+      // no-op
+    } else if (node.isRegistryDependency) {
+      meta.resolved = overrideResolves(resolved, options)
+    } else {
+      meta.resolved = resolved
+    }
+
+    if (node.extraneous) {
+      meta.extraneous = true
+    } else {
+      if (node.peer) {
+        meta.peer = true
+      }
+      if (node.dev) {
+        meta.dev = true
+      }
+      if (node.optional) {
+        meta.optional = true
+      }
+      if (node.devOptional && !node.dev && !node.optional) {
+        meta.devOptional = true
+      }
+    }
+    return meta
+  }
+
+  #awaitingUpdate = new Map()
+
+  constructor (options = {}) {
+    const {
+      path,
+      indent = 2,
+      newline = '\n',
+      shrinkwrapOnly = false,
+      hiddenLockfile = false,
+      lockfileVersion,
+      resolveOptions = {},
+    } = options
+
+    if (hiddenLockfile) {
+      this.lockfileVersion = 3
+    } else if (lockfileVersion) {
+      this.lockfileVersion = parseInt(lockfileVersion, 10)
+    } else {
+      this.lockfileVersion = null
+    }
+
+    this.tree = null
+    this.path = resolve(path || '.')
+    this.filename = null
+    this.data = null
+    this.indent = indent
+    this.newline = newline
+    this.loadedFromDisk = false
+    this.type = null
+    this.yarnLock = null
+    this.hiddenLockfile = hiddenLockfile
+    this.loadingError = null
+    this.resolveOptions = resolveOptions
+    // only load npm-shrinkwrap.json in dep trees, not package-lock
+    this.shrinkwrapOnly = shrinkwrapOnly
+  }
+
+  // check to see if a spec is present in the yarn.lock file, and if so,
+  // if we should use it, and what it should resolve to.  This is only
+  // done when we did not load a shrinkwrap from disk.  Also, decorate
+  // the options object if provided with the resolved and integrity that
+  // we expect.
+  checkYarnLock (spec, options = {}) {
+    spec = npa(spec)
+    const { yarnLock, loadedFromDisk } = this
+    const useYarnLock = yarnLock && !loadedFromDisk
+    const fromYarn = useYarnLock && yarnLock.entries.get(spec.raw)
+    if (fromYarn && fromYarn.version) {
+      // if it's the yarn or npm default registry, use the version as
+      // our effective spec.  if it's any other kind of thing, use that.
+      const { resolved, version, integrity } = fromYarn
+      const isYarnReg = spec.registry && yarnRegRe.test(resolved)
+      const isnpmReg = spec.registry && !isYarnReg && npmRegRe.test(resolved)
+      const isReg = isnpmReg || isYarnReg
+      // don't use the simple version if the "registry" url is
+      // something else entirely!
+      const tgz = isReg && versionFromTgz(spec.name, resolved) || {}
+      let yspec = resolved
+      if (tgz.name === spec.name && tgz.version === version) {
+        yspec = version
+      } else if (isReg && tgz.name && tgz.version) {
+        yspec = `npm:${tgz.name}@${tgz.version}`
+      }
+      if (yspec) {
+        options.resolved = resolved.replace(yarnRegRe, 'https://registry.npmjs.org/')
+        options.integrity = integrity
+        return npa(`${spec.name}@${yspec}`)
+      }
+    }
+    return spec
+  }
+
+  // throw away the shrinkwrap data so we can start fresh
+  // still worth doing a load() first so we know which files to write.
+  reset () {
+    this.tree = null
+    this.#awaitingUpdate = new Map()
+    const lockfileVersion = this.lockfileVersion || defaultLockfileVersion
+    this.originalLockfileVersion = lockfileVersion
+
+    this.data = {
+      lockfileVersion,
+      requires: true,
+      packages: {},
+      dependencies: {},
+    }
+  }
+
+  // files to potentially read from and write to, in order of priority
+  get #filenameSet () {
+    if (this.shrinkwrapOnly) {
+      return [`${this.path}/npm-shrinkwrap.json`]
+    }
+    if (this.hiddenLockfile) {
+      return [`${this.path}/node_modules/.package-lock.json`]
+    }
+    return [
+      `${this.path}/npm-shrinkwrap.json`,
+      `${this.path}/package-lock.json`,
+      `${this.path}/yarn.lock`,
+    ]
+  }
+
+  get loadFiles () {
+    return Promise.all(
+      this.#filenameSet.map(file => file && readFile(file, 'utf8').then(d => d, er => {
+        /* istanbul ignore else - can't test without breaking module itself */
+        if (er.code === 'ENOENT') {
+          return ''
+        } else {
+          throw er
+        }
+      }))
+    )
+  }
+
+  get resetFiles () {
+    // slice out yarn, we only care about lock or shrinkwrap when checking
+    // this way, since we're not actually loading the full lock metadata
+    return Promise.all(this.#filenameSet.slice(0, 2)
+      .map(file => file && stat(file).then(st => st.isFile(), er => {
+        /* istanbul ignore else - can't test without breaking module itself */
+        if (er.code === 'ENOENT') {
+          return null
+        } else {
+          throw er
+        }
+      })
+      )
+    )
+  }
+
+  inferFormattingOptions (packageJSONData) {
+    const {
+      [Symbol.for('indent')]: indent,
+      [Symbol.for('newline')]: newline,
+    } = packageJSONData
+    if (indent !== undefined) {
+      this.indent = indent
+    }
+    if (newline !== undefined) {
+      this.newline = newline
+    }
+  }
+
+  async load () {
+    // we don't need to load package-lock.json except for top of tree nodes,
+    // only npm-shrinkwrap.json.
+    let data
+    try {
+      const [sw, lock, yarn] = await this.loadFiles
+      data = sw || lock || '{}'
+
+      // use shrinkwrap only for deps; otherwise, prefer package-lock
+      // and ignore npm-shrinkwrap if both are present.
+      // TODO: emit a warning here or something if both are present.
+      if (this.hiddenLockfile) {
+        this.filename = resolve(this.path, 'node_modules/.package-lock.json')
+      } else if (this.shrinkwrapOnly || sw) {
+        this.filename = resolve(this.path, 'npm-shrinkwrap.json')
+      } else {
+        this.filename = resolve(this.path, 'package-lock.json')
+      }
+      this.type = basename(this.filename)
+      this.loadedFromDisk = Boolean(sw || lock)
+
+      if (yarn) {
+        this.yarnLock = new YarnLock()
+        // ignore invalid yarn data.  we'll likely clobber it later anyway.
+        try {
+          this.yarnLock.parse(yarn)
+        } catch {
+          // ignore errors
+        }
+      }
+
+      data = parseJSON(data)
+      this.inferFormattingOptions(data)
+
+      if (this.hiddenLockfile && data.packages) {
+        // add a few ms just to account for jitter
+        const lockTime = +(await stat(this.filename)).mtime + 10
+        await assertNoNewer(this.path, data, lockTime, this.path, new Set())
+      }
+
+      // all good!  hidden lockfile is the newest thing in here.
+    } catch (er) {
+      /* istanbul ignore else */
+      if (typeof this.filename === 'string') {
+        const rel = relpath(this.path, this.filename)
+        log.verbose('shrinkwrap', `failed to load ${rel}`, er.message)
+      } else {
+        log.verbose('shrinkwrap', `failed to load ${this.path}`, er.message)
+      }
+      this.loadingError = er
+      this.loadedFromDisk = false
+      this.ancientLockfile = false
+      data = {}
+    }
+    // auto convert v1 lockfiles to v3
+    // leave v2 in place unless configured
+    // v3 by default
+    let lockfileVersion = defaultLockfileVersion
+    if (this.lockfileVersion) {
+      lockfileVersion = this.lockfileVersion
+    } else if (data.lockfileVersion && data.lockfileVersion !== 1) {
+      lockfileVersion = data.lockfileVersion
+    }
+
+    this.data = {
+      ...data,
+      lockfileVersion,
+      requires: true,
+      packages: data.packages || {},
+      dependencies: data.dependencies || {},
+    }
+
+    this.originalLockfileVersion = data.lockfileVersion
+
+    // use default if it wasn't explicitly set, and the current file is
+    // less than our default.  otherwise, keep whatever is in the file,
+    // unless we had an explicit setting already.
+    if (!this.lockfileVersion) {
+      this.lockfileVersion = this.data.lockfileVersion = lockfileVersion
+    }
+    this.ancientLockfile = this.loadedFromDisk &&
+      !(data.lockfileVersion >= 2) && !data.requires
+
+    // load old lockfile deps into the packages listing
+    if (data.dependencies && !data.packages) {
+      let pkg
+      try {
+        pkg = await pkgJson.normalize(this.path)
+        pkg = pkg.content
+      } catch {
+        pkg = {}
+      }
+      this.#loadAll('', null, this.data)
+      this.#fixDependencies(pkg)
+    }
+    return this
+  }
+
+  #loadAll (location, name, lock) {
+    // migrate a v1 package lock to the new format.
+    const meta = this.#metaFromLock(location, name, lock)
+    // dependencies nested under a link are actually under the link target
+    if (meta.link) {
+      location = meta.resolved
+    }
+    if (lock.dependencies) {
+      for (const name in lock.dependencies) {
+        const loc = location + (location ? '/' : '') + 'node_modules/' + name
+        this.#loadAll(loc, name, lock.dependencies[name])
+      }
+    }
+  }
+
+  // v1 lockfiles track the optional/dev flags, but they don't tell us
+  // which thing had what kind of dep on what other thing, so we need
+  // to correct that now, or every link will be considered prod
+  #fixDependencies (pkg) {
+    // we need the root package.json because legacy shrinkwraps just
+    // have requires:true at the root level, which is even less useful
+    // than merging all dep types into one object.
+    const root = this.data.packages['']
+    for (const key of pkgMetaKeys) {
+      const val = metaFieldFromPkg(pkg, key)
+      if (val) {
+        root[key.replace(/^_/, '')] = val
+      }
+    }
+
+    for (const loc in this.data.packages) {
+      const meta = this.data.packages[loc]
+      if (!meta.requires || !loc) {
+        continue
+      }
+
+      // resolve each require to a meta entry
+      // if this node isn't optional, but the dep is, then it's an optionalDep
+      // likewise for dev deps.
+      // This isn't perfect, but it's a pretty good approximation, and at
+      // least gets us out of having all 'prod' edges, which throws off the
+      // buildIdealTree process
+      for (const name in meta.requires) {
+        const dep = this.#resolveMetaNode(loc, name)
+        // this overwrites the false value set above
+        // default to dependencies if the dep just isn't in the tree, which
+        // maybe should be an error, since it means that the shrinkwrap is
+        // invalid, but we can't do much better without any info.
+        let depType = 'dependencies'
+        /* istanbul ignore else - dev deps are only for the root level */
+        if (dep?.optional && !meta.optional) {
+          depType = 'optionalDependencies'
+        } else if (dep?.dev && !meta.dev) {
+          // XXX is this even reachable?
+          depType = 'devDependencies'
+        }
+        if (!meta[depType]) {
+          meta[depType] = {}
+        }
+        meta[depType][name] = meta.requires[name]
+      }
+      delete meta.requires
+    }
+  }
+
+  #resolveMetaNode (loc, name) {
+    for (let path = loc; true; path = path.replace(/(^|\/)[^/]*$/, '')) {
+      const check = `${path}${path ? '/' : ''}node_modules/${name}`
+      if (this.data.packages[check]) {
+        return this.data.packages[check]
+      }
+
+      if (!path) {
+        break
+      }
+    }
+    return null
+  }
+
+  #lockFromLoc (lock, path, i = 0) {
+    if (!lock) {
+      return null
+    }
+
+    if (path[i] === '') {
+      i++
+    }
+
+    if (i >= path.length) {
+      return lock
+    }
+
+    if (!lock.dependencies) {
+      return null
+    }
+
+    return this.#lockFromLoc(lock.dependencies[path[i]], path, i + 1)
+  }
+
+  // pass in a path relative to the root path, or an absolute path,
+  // get back a /-normalized location based on root path.
+  #pathToLoc (path) {
+    return relpath(this.path, resolve(this.path, path))
+  }
+
+  delete (nodePath) {
+    if (!this.data) {
+      throw new Error('run load() before getting or setting data')
+    }
+    const location = this.#pathToLoc(nodePath)
+    this.#awaitingUpdate.delete(location)
+
+    delete this.data.packages[location]
+    const path = location.split(/(?:^|\/)node_modules\//)
+    const name = path.pop()
+    const pLock = this.#lockFromLoc(this.data, path)
+    if (pLock && pLock.dependencies) {
+      delete pLock.dependencies[name]
+    }
+  }
+
+  get (nodePath) {
+    if (!this.data) {
+      throw new Error('run load() before getting or setting data')
+    }
+
+    const location = this.#pathToLoc(nodePath)
+    if (this.#awaitingUpdate.has(location)) {
+      this.#updateWaitingNode(location)
+    }
+
+    // first try to get from the newer spot, which we know has
+    // all the things we need.
+    if (this.data.packages[location]) {
+      return this.data.packages[location]
+    }
+
+    // otherwise, fall back to the legacy metadata, and hope for the best
+    // get the node in the shrinkwrap corresponding to this spot
+    const path = location.split(/(?:^|\/)node_modules\//)
+    const name = path[path.length - 1]
+    const lock = this.#lockFromLoc(this.data, path)
+
+    return this.#metaFromLock(location, name, lock)
+  }
+
+  #metaFromLock (location, name, lock) {
+    // This function tries as hard as it can to figure out the metadata
+    // from a lockfile which may be outdated or incomplete.  Since v1
+    // lockfiles used the "version" field to contain a variety of
+    // different possible types of data, this gets a little complicated.
+    if (!lock) {
+      return {}
+    }
+
+    // try to figure out a npm-package-arg spec from the lockfile entry
+    // This will return null if we could not get anything valid out of it.
+    const spec = specFromLock(name, lock, this.path)
+
+    if (spec.type === 'directory') {
+      // the "version" was a file: url to a non-tarball path
+      // this is a symlink dep.  We don't store much metadata
+      // about symlinks, just the target.
+      const target = relpath(this.path, spec.fetchSpec)
+      this.data.packages[location] = {
+        link: true,
+        resolved: target,
+      }
+      // also save the link target, omitting version since we don't know
+      // what it is, but we know it isn't a link to itself!
+      if (!this.data.packages[target]) {
+        this.#metaFromLock(target, name, { ...lock, version: null })
+      }
+      return this.data.packages[location]
+    }
+
+    const meta = {}
+    // when calling loadAll we'll change these into proper dep objects
+    if (lock.requires && typeof lock.requires === 'object') {
+      meta.requires = lock.requires
+    }
+
+    if (lock.optional) {
+      meta.optional = true
+    }
+    if (lock.dev) {
+      meta.dev = true
+    }
+
+    // the root will typically have a name from the root project's
+    // package.json file.
+    if (location === '') {
+      meta.name = lock.name
+    }
+
+    // if we have integrity, save it now.
+    if (lock.integrity) {
+      meta.integrity = lock.integrity
+    }
+
+    if (lock.version && !lock.integrity) {
+      // this is usually going to be a git url or symlink, but it could
+      // also be a registry dependency that did not have integrity at
+      // the time it was saved.
+      // Symlinks were already handled above, so that leaves git.
+      //
+      // For git, always save the full SSH url.  we'll actually fetch the
+      // tgz most of the time, since it's faster, but it won't work for
+      // private repos, and we can't get back to the ssh from the tgz,
+      // so we store the ssh instead.
+      // For unknown git hosts, just resolve to the raw spec in lock.version
+      if (spec.type === 'git') {
+        meta.resolved = consistentResolve(spec, this.path, this.path)
+
+        // return early because there is nothing else we can do with this
+        return this.data.packages[location] = meta
+      } else if (spec.registry) {
+        // registry dep that didn't save integrity.  grab the version, and
+        // fall through to pick up the resolved and potentially name.
+        meta.version = lock.version
+      }
+      // only other possible case is a tarball without integrity.
+      // fall through to do what we can with the filename later.
+    }
+
+    // at this point, we know that the spec is either a registry dep
+    // (ie, version, because locking, which means a resolved url),
+    // or a remote dep, or file: url.  Remote deps and file urls
+    // have a fetchSpec equal to the fully resolved thing.
+    // Registry deps, we take what's in the lockfile.
+    if (lock.resolved || (spec.type && !spec.registry)) {
+      if (spec.registry) {
+        meta.resolved = lock.resolved
+      } else if (spec.type === 'file') {
+        meta.resolved = consistentResolve(spec, this.path, this.path, true)
+      } else if (spec.fetchSpec) {
+        meta.resolved = spec.fetchSpec
+      }
+    }
+
+    // at this point, if still we don't have a version, do our best to
+    // infer it from the tarball url/file.  This works a surprising
+    // amount of the time, even though it's not guaranteed.
+    if (!meta.version) {
+      if (spec.type === 'file' || spec.type === 'remote') {
+        const fromTgz = versionFromTgz(spec.name, spec.fetchSpec) ||
+          versionFromTgz(spec.name, meta.resolved)
+        if (fromTgz) {
+          meta.version = fromTgz.version
+          if (fromTgz.name !== name) {
+            meta.name = fromTgz.name
+          }
+        }
+      } else if (spec.type === 'alias') {
+        meta.name = spec.subSpec.name
+        meta.version = spec.subSpec.fetchSpec
+      } else if (spec.type === 'version') {
+        meta.version = spec.fetchSpec
+      }
+      // ok, I did my best!  good luck!
+    }
+
+    if (lock.bundled) {
+      meta.inBundle = true
+    }
+
+    // save it for next time
+    return this.data.packages[location] = meta
+  }
+
+  add (node) {
+    if (!this.data) {
+      throw new Error('run load() before getting or setting data')
+    }
+
+    // will be actually updated on read
+    const loc = relpath(this.path, node.path)
+    if (node.path === this.path) {
+      this.tree = node
+    }
+
+    // if we have metadata about this node, and it's a match, then
+    // try to decorate it.
+    if (node.resolved === null || node.integrity === null) {
+      const {
+        resolved,
+        integrity,
+        hasShrinkwrap,
+        version,
+      } = this.get(node.path)
+
+      let pathFixed = null
+      if (resolved) {
+        if (!/^file:/.test(resolved)) {
+          pathFixed = resolved
+        } else {
+          pathFixed = `file:${resolve(this.path, resolved.slice(5))}`
+        }
+      }
+
+      // if we have one, only set the other if it matches
+      // otherwise it could be for a completely different thing.
+      const resolvedOk = !resolved || !node.resolved ||
+        node.resolved === pathFixed
+      const integrityOk = !integrity || !node.integrity ||
+        node.integrity === integrity
+      const versionOk = !version || !node.version || version === node.version
+
+      const allOk = (resolved || integrity || version) &&
+        resolvedOk && integrityOk && versionOk
+
+      if (allOk) {
+        node.resolved = node.resolved || pathFixed || null
+        node.integrity = node.integrity || integrity || null
+        node.hasShrinkwrap = node.hasShrinkwrap || hasShrinkwrap || false
+      } else {
+        // try to read off the package or node itself
+        const {
+          resolved,
+          integrity,
+          hasShrinkwrap,
+        } = Shrinkwrap.metaFromNode(node, this.path, this.resolveOptions)
+        node.resolved = node.resolved || resolved || null
+        node.integrity = node.integrity || integrity || null
+        node.hasShrinkwrap = node.hasShrinkwrap || hasShrinkwrap || false
+      }
+    }
+    this.#awaitingUpdate.set(loc, node)
+  }
+
+  addEdge (edge) {
+    if (!this.yarnLock || !edge.valid) {
+      return
+    }
+
+    const { to: node } = edge
+
+    // if it's already set up, nothing to do
+    if (node.resolved !== null && node.integrity !== null) {
+      return
+    }
+
+    // if the yarn lock is empty, nothing to do
+    if (!this.yarnLock.entries || !this.yarnLock.entries.size) {
+      return
+    }
+
+    // we relativize the path here because that's how it shows up in the lock
+    // XXX why is this different from pathFixed in this.add??
+    let pathFixed = null
+    if (node.resolved) {
+      if (!/file:/.test(node.resolved)) {
+        pathFixed = node.resolved
+      } else {
+        pathFixed = consistentResolve(node.resolved, node.path, this.path, true)
+      }
+    }
+
+    const spec = npa(`${node.name}@${edge.spec}`)
+    const entry = this.yarnLock.entries.get(`${node.name}@${edge.spec}`)
+
+    if (!entry ||
+        mismatch(node.version, entry.version) ||
+        mismatch(node.integrity, entry.integrity) ||
+        mismatch(pathFixed, entry.resolved)) {
+      return
+    }
+
+    if (entry.resolved && yarnRegRe.test(entry.resolved) && spec.registry) {
+      entry.resolved = entry.resolved.replace(yarnRegRe, 'https://registry.npmjs.org/')
+    }
+
+    node.integrity = node.integrity || entry.integrity || null
+    node.resolved = node.resolved ||
+      consistentResolve(entry.resolved, this.path, node.path) || null
+
+    this.#awaitingUpdate.set(relpath(this.path, node.path), node)
+  }
+
+  #updateWaitingNode (loc) {
+    const node = this.#awaitingUpdate.get(loc)
+    this.#awaitingUpdate.delete(loc)
+    this.data.packages[loc] = Shrinkwrap.metaFromNode(
+      node,
+      this.path,
+      this.resolveOptions)
+  }
+
+  commit () {
+    if (this.tree) {
+      if (this.yarnLock) {
+        this.yarnLock.fromTree(this.tree)
+      }
+      const root = Shrinkwrap.metaFromNode(
+        this.tree.target,
+        this.path,
+        this.resolveOptions)
+      this.data.packages = {}
+      if (Object.keys(root).length) {
+        this.data.packages[''] = root
+      }
+      for (const node of this.tree.root.inventory.values()) {
+        // only way this.tree is not root is if the root is a link to it
+        if (node === this.tree || node.isRoot || node.location === '') {
+          continue
+        }
+        const loc = relpath(this.path, node.path)
+        this.data.packages[loc] = Shrinkwrap.metaFromNode(
+          node,
+          this.path,
+          this.resolveOptions)
+      }
+    } else if (this.#awaitingUpdate.size > 0) {
+      for (const loc of this.#awaitingUpdate.keys()) {
+        this.#updateWaitingNode(loc)
+      }
+    }
+
+    // if we haven't set it by now, use the default
+    if (!this.lockfileVersion) {
+      this.lockfileVersion = defaultLockfileVersion
+    }
+    this.data.lockfileVersion = this.lockfileVersion
+
+    // hidden lockfiles don't include legacy metadata or a root entry
+    if (this.hiddenLockfile) {
+      delete this.data.packages['']
+      delete this.data.dependencies
+    } else if (this.tree && this.lockfileVersion <= 3) {
+      this.#buildLegacyLockfile(this.tree, this.data)
+    }
+
+    // lf version 1 = dependencies only
+    // lf version 2 = dependencies and packages
+    // lf version 3 = packages only
+    if (this.lockfileVersion >= 3) {
+      const { dependencies, ...data } = this.data
+      return data
+    } else if (this.lockfileVersion < 2) {
+      const { packages, ...data } = this.data
+      return data
+    } else {
+      return { ...this.data }
+    }
+  }
+
+  #buildLegacyLockfile (node, lock, path = []) {
+    if (node === this.tree) {
+      // the root node
+      lock.name = node.packageName || node.name
+      if (node.version) {
+        lock.version = node.version
+      }
+    }
+
+    // npm v6 and before tracked 'from', meaning "the request that led
+    // to this package being installed".  However, that's inherently
+    // racy and non-deterministic in a world where deps are deduped
+    // ahead of fetch time.  In order to maintain backwards compatibility
+    // with v6 in the lockfile, we do this trick where we pick a valid
+    // dep link out of the edgesIn set.  Choose the edge with the fewest
+    // number of `node_modules` sections in the requestor path, and then
+    // lexically sort afterwards.
+    const edge = [...node.edgesIn].filter(e => e.valid).sort((a, b) => {
+      const aloc = a.from.location.split('node_modules')
+      const bloc = b.from.location.split('node_modules')
+      /* istanbul ignore next - sort calling order is indeterminate */
+      if (aloc.length > bloc.length) {
+        return 1
+      }
+      if (bloc.length > aloc.length) {
+        return -1
+      }
+      return localeCompare(aloc[aloc.length - 1], bloc[bloc.length - 1])
+    })[0]
+
+    const res = consistentResolve(node.resolved, this.path, this.path, true)
+    const rSpec = specFromResolved(res)
+
+    // if we don't have anything (ie, it's extraneous) then use the resolved
+    // value as if that was where we got it from, since at least it's true.
+    // if we don't have either, just an empty object so nothing matches below.
+    // This will effectively just save the version and resolved, as if it's
+    // a standard version/range dep, which is a reasonable default.
+    let spec = rSpec
+    if (edge) {
+      spec = npa.resolve(node.name, edge.spec, edge.from.realpath)
+    }
+
+    if (node.isLink) {
+      lock.version = `file:${relpath(this.path, node.realpath)}`
+    } else if (spec && (spec.type === 'file' || spec.type === 'remote')) {
+      lock.version = spec.saveSpec
+    } else if (spec && spec.type === 'git' || rSpec.type === 'git') {
+      lock.version = node.resolved
+      /* istanbul ignore else - don't think there are any cases where a git
+       * spec (or indeed, ANY npa spec) doesn't have a .raw member */
+      if (spec.raw) {
+        lock.from = spec.raw
+      }
+    } else if (!node.isRoot &&
+        node.package &&
+        node.packageName &&
+        node.packageName !== node.name) {
+      lock.version = `npm:${node.packageName}@${node.version}`
+    } else if (node.package && node.version) {
+      lock.version = node.version
+    }
+
+    if (node.inDepBundle) {
+      lock.bundled = true
+    }
+
+    // when we didn't resolve to git, file, or dir, and didn't request
+    // git, file, dir, or remote, then the resolved value is necessary.
+    if (node.resolved &&
+        !node.isLink &&
+        rSpec.type !== 'git' &&
+        rSpec.type !== 'file' &&
+        rSpec.type !== 'directory' &&
+        spec.type !== 'directory' &&
+        spec.type !== 'git' &&
+        spec.type !== 'file' &&
+        spec.type !== 'remote') {
+      lock.resolved = overrideResolves(node.resolved, this.resolveOptions)
+    }
+
+    if (node.integrity) {
+      lock.integrity = node.integrity
+    }
+
+    if (node.extraneous) {
+      lock.extraneous = true
+    } else if (!node.isLink) {
+      if (node.peer) {
+        lock.peer = true
+      }
+
+      if (node.devOptional && !node.dev && !node.optional) {
+        lock.devOptional = true
+      }
+
+      if (node.dev) {
+        lock.dev = true
+      }
+
+      if (node.optional) {
+        lock.optional = true
+      }
+    }
+
+    const depender = node.target
+    if (depender.edgesOut.size > 0) {
+      if (node !== this.tree) {
+        const entries = [...depender.edgesOut.entries()]
+        lock.requires = entries.reduce((set, [k, v]) => {
+          // omit peer deps from legacy lockfile requires field, because
+          // npm v6 doesn't handle peer deps, and this triggers some bad
+          // behavior if the dep can't be found in the dependencies list.
+          const { spec, peer } = v
+          if (peer) {
+            return set
+          }
+          if (spec.startsWith('file:')) {
+            // turn absolute file: paths into relative paths from the node
+            // this especially shows up with workspace edges when the root
+            // node is also a workspace in the set.
+            const p = resolve(node.realpath, spec.slice('file:'.length))
+            set[k] = `file:${relpath(node.realpath, p)}`
+          } else {
+            set[k] = spec
+          }
+          return set
+        }, {})
+      } else {
+        lock.requires = true
+      }
+    }
+
+    // now we walk the children, putting them in the 'dependencies' object
+    const { children } = node.target
+    if (!children.size) {
+      delete lock.dependencies
+    } else {
+      const kidPath = [...path, node.realpath]
+      const dependencies = {}
+      // skip any that are already in the descent path, so cyclical link
+      // dependencies don't blow up with ELOOP.
+      let found = false
+      for (const [name, kid] of children.entries()) {
+        if (path.includes(kid.realpath)) {
+          continue
+        }
+        dependencies[name] = this.#buildLegacyLockfile(kid, {}, kidPath)
+        found = true
+      }
+      if (found) {
+        lock.dependencies = dependencies
+      }
+    }
+    return lock
+  }
+
+  toJSON () {
+    if (!this.data) {
+      throw new Error('run load() before getting or setting data')
+    }
+
+    return this.commit()
+  }
+
+  toString (options = {}) {
+    const data = this.toJSON()
+    const { format = true } = options
+    const defaultIndent = this.indent || 2
+    const indent = format === true ? defaultIndent
+      : format || 0
+    const eol = format ? this.newline || '\n' : ''
+    return stringify(data, swKeyOrder, indent).replace(/\n/g, eol)
+  }
+
+  save (options = {}) {
+    if (!this.data) {
+      throw new Error('run load() before saving data')
+    }
+
+    // This must be called before the lockfile conversion check below since it sets properties as part of `commit()`
+    const json = this.toString(options)
+    if (
+      !this.hiddenLockfile
+      && this.originalLockfileVersion !== undefined
+      && this.originalLockfileVersion !== this.lockfileVersion
+    ) {
+      log.warn(
+        'shrinkwrap',
+        `Converting lock file (${relative(process.cwd(), this.filename)}) from v${this.originalLockfileVersion} -> v${this.lockfileVersion}`
+      )
+    }
+
+    return Promise.all([
+      writeFile(this.filename, json).catch(er => {
+        if (this.hiddenLockfile) {
+          // well, we did our best.
+          // if we reify, and there's nothing there, then it might be lacking
+          // a node_modules folder, but then the lockfile is not important.
+          // Remove the file, so that in case there WERE deps, but we just
+          // failed to update the file for some reason, it's not out of sync.
+          return rm(this.filename, { recursive: true, force: true })
+        }
+        throw er
+      }),
+      this.yarnLock && this.yarnLock.entries.size &&
+        writeFile(this.path + '/yarn.lock', this.yarnLock.toString()),
+    ])
+  }
+}
+
+module.exports = Shrinkwrap
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/signal-handling.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/signal-handling.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb97eac992ec906b1716ea27ff109288d58e3a0c
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/signal-handling.js
@@ -0,0 +1,74 @@
+const signals = require('./signals.js')
+
+// for testing, expose the process being used
+module.exports = Object.assign(fn => setup(fn), { process })
+
+// do all of this in a setup function so that we can call it
+// multiple times for multiple reifies that might be going on.
+// Otherwise, Arborist.reify() is a global action, which is a
+// new constraint we'd be adding with this behavior.
+const setup = fn => {
+  const { process } = module.exports
+
+  const sigListeners = { loaded: false }
+
+  const unload = () => {
+    if (!sigListeners.loaded) {
+      return
+    }
+    for (const sig of signals) {
+      try {
+        process.removeListener(sig, sigListeners[sig])
+      } catch {
+        // ignore errors
+      }
+    }
+    process.removeListener('beforeExit', onBeforeExit)
+    sigListeners.loaded = false
+  }
+
+  const onBeforeExit = () => {
+    // this trick ensures that we exit with the same signal we caught
+    // Ie, if you press ^C and npm gets a SIGINT, we'll do the rollback
+    // and then exit with a SIGINT signal once we've removed the handler.
+    // The timeout is there because signals are asynchronous, so we need
+    // the process to NOT exit on its own, which means we have to have
+    // something keeping the event loop looping.  Hence this hack.
+    unload()
+    process.kill(process.pid, signalReceived)
+    setTimeout(() => {}, 500)
+  }
+
+  let signalReceived = null
+  const listener = (sig, fn) => () => {
+    signalReceived = sig
+
+    // if we exit normally, but caught a signal which would have been fatal,
+    // then re-send it once we're done with whatever cleanup we have to do.
+    unload()
+    if (process.listeners(sig).length < 1) {
+      process.once('beforeExit', onBeforeExit)
+    }
+
+    fn({ signal: sig })
+  }
+
+  // do the actual loading here
+  for (const sig of signals) {
+    sigListeners[sig] = listener(sig, fn)
+    const max = process.getMaxListeners()
+    try {
+      // if we call this a bunch of times, avoid triggering the warning
+      const { length } = process.listeners(sig)
+      if (length >= max) {
+        process.setMaxListeners(length + 1)
+      }
+      process.on(sig, sigListeners[sig])
+    } catch {
+      // ignore errors
+    }
+  }
+  sigListeners.loaded = true
+
+  return unload
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/signals.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/signals.js
new file mode 100644
index 0000000000000000000000000000000000000000..105a2db627a3481ab27f211433140249fc501ed7
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/signals.js
@@ -0,0 +1,58 @@
+// copied from signal-exit
+
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems.  Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL.  It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+
+const platform = global.__ARBORIST_FAKE_PLATFORM__ || process.platform
+
+module.exports = [
+  'SIGABRT',
+  'SIGALRM',
+  'SIGHUP',
+  'SIGINT',
+  'SIGTERM',
+]
+
+if (platform !== 'win32') {
+  module.exports.push(
+    'SIGVTALRM',
+    'SIGXCPU',
+    'SIGXFSZ',
+    'SIGUSR2',
+    'SIGTRAP',
+    'SIGSYS',
+    'SIGQUIT',
+    'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  )
+}
+
+if (platform === 'linux') {
+  module.exports.push(
+    'SIGIO',
+    'SIGPOLL',
+    'SIGPWR',
+    'SIGSTKFLT',
+    'SIGUNUSED'
+  )
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/spec-from-lock.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/spec-from-lock.js
new file mode 100644
index 0000000000000000000000000000000000000000..0470a4f3f376d5ae222f8c55c3a58ee77bb44446
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/spec-from-lock.js
@@ -0,0 +1,34 @@
+const npa = require('npm-package-arg')
+
+// extracted from npm v6 lib/install/realize-shrinkwrap-specifier.js
+const specFromLock = (name, lock, where) => {
+  try {
+    if (lock.version) {
+      const spec = npa.resolve(name, lock.version, where)
+      if (lock.integrity || spec.type === 'git') {
+        return spec
+      }
+    }
+    if (lock.from) {
+      // legacy metadata includes "from", but not integrity
+      const spec = npa.resolve(name, lock.from, where)
+      if (spec.registry && lock.version) {
+        return npa.resolve(name, lock.version, where)
+      } else if (!lock.resolved) {
+        return spec
+      }
+    }
+    if (lock.resolved) {
+      return npa.resolve(name, lock.resolved, where)
+    }
+  } catch {
+    // ignore errors
+  }
+  try {
+    return npa.resolve(name, lock.version, where)
+  } catch {
+    return {}
+  }
+}
+
+module.exports = specFromLock
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/tracker.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/tracker.js
new file mode 100644
index 0000000000000000000000000000000000000000..818c766912bbed82c24117297dc98dbed22a90da
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/tracker.js
@@ -0,0 +1,86 @@
+const proggy = require('proggy')
+
+module.exports = cls => class Tracker extends cls {
+  #progress = new Map()
+
+  #createTracker (key, name) {
+    const tracker = new proggy.Tracker(name ?? key)
+    tracker.on('done', () => this.#progress.delete(key))
+    this.#progress.set(key, tracker)
+  }
+
+  addTracker (section, subsection = null, key = null) {
+    if (section === null || section === undefined) {
+      this.#onError(`Tracker can't be null or undefined`)
+    }
+
+    if (key === null) {
+      key = subsection
+    }
+
+    const hasTracker = this.#progress.has(section)
+    const hasSubtracker = this.#progress.has(`${section}:${key}`)
+
+    if (hasTracker && subsection === null) {
+      // 0. existing tracker, no subsection
+      this.#onError(`Tracker "${section}" already exists`)
+    } else if (!hasTracker && subsection === null) {
+      // 1. no existing tracker, no subsection
+      // Create a new progress tracker
+      this.#createTracker(section)
+    } else if (!hasTracker && subsection !== null) {
+      // 2. no parent tracker and subsection
+      this.#onError(`Parent tracker "${section}" does not exist`)
+    } else if (!hasTracker || !hasSubtracker) {
+      // 3. existing parent tracker, no subsection tracker
+      // Create a new subtracker and update parents
+      const parentTracker = this.#progress.get(section)
+      parentTracker.update(parentTracker.value, parentTracker.total + 1)
+      this.#createTracker(`${section}:${key}`, `${section}:${subsection}`)
+    }
+    // 4. existing parent tracker, existing subsection tracker
+    // skip it
+  }
+
+  finishTracker (section, subsection = null, key = null) {
+    if (section === null || section === undefined) {
+      this.#onError(`Tracker can't be null or undefined`)
+    }
+
+    if (key === null) {
+      key = subsection
+    }
+
+    const hasTracker = this.#progress.has(section)
+    const hasSubtracker = this.#progress.has(`${section}:${key}`)
+
+    // 0. parent tracker exists, no subsection
+    // Finish parent tracker and remove from this.#progress
+    if (hasTracker && subsection === null) {
+      // check if parent tracker does
+      // not have any remaining children
+      const keys = this.#progress.keys()
+      for (const key of keys) {
+        if (key.match(new RegExp(section + ':'))) {
+          this.finishTracker(section, key)
+        }
+      }
+      // remove parent tracker
+      this.#progress.get(section).finish()
+    } else if (!hasTracker && subsection === null) {
+      // 1. no existing parent tracker, no subsection
+      this.#onError(`Tracker "${section}" does not exist`)
+    } else if (!hasTracker || hasSubtracker) {
+      // 2. subtracker exists
+      // Finish subtracker and remove from this.#progress
+      const parentTracker = this.#progress.get(section)
+      parentTracker.update(parentTracker.value + 1)
+      this.#progress.get(`${section}:${key}`).finish()
+    }
+    // 3. existing parent tracker, no subsection
+  }
+
+  #onError (msg) {
+    throw new Error(msg)
+  }
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/tree-check.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/tree-check.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f88e0c464710af6bccad9de875b574b1255e3bb
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/tree-check.js
@@ -0,0 +1,155 @@
+const debug = require('./debug.js')
+
+const checkTree = (tree, checkUnreachable = true) => {
+  const log = [['START TREE CHECK', tree.path]]
+
+  // this can only happen in tests where we have a "tree" object
+  // that isn't actually a tree.
+  if (!tree.root || !tree.root.inventory) {
+    return tree
+  }
+
+  const { inventory } = tree.root
+  const seen = new Set()
+  const check = (node, via = tree, viaType = 'self') => {
+    log.push([
+      'CHECK',
+      node && node.location,
+      via && via.location,
+      viaType,
+      'seen=' + seen.has(node),
+      'promise=' + !!(node && node.then),
+      'root=' + !!(node && node.isRoot),
+    ])
+
+    if (!node || seen.has(node) || node.then) {
+      return
+    }
+
+    seen.add(node)
+
+    if (node.isRoot && node !== tree.root) {
+      throw Object.assign(new Error('double root'), {
+        node: node.path,
+        realpath: node.realpath,
+        tree: tree.path,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        log,
+      })
+    }
+
+    if (node.root !== tree.root) {
+      throw Object.assign(new Error('node from other root in tree'), {
+        node: node.path,
+        realpath: node.realpath,
+        tree: tree.path,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        otherRoot: node.root && node.root.path,
+        log,
+      })
+    }
+
+    if (!node.isRoot && node.inventory.size !== 0) {
+      throw Object.assign(new Error('non-root has non-zero inventory'), {
+        node: node.path,
+        tree: tree.path,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        inventory: [...node.inventory.values()].map(node =>
+          [node.path, node.location]),
+        log,
+      })
+    }
+
+    if (!node.isRoot && !inventory.has(node) && !node.dummy) {
+      throw Object.assign(new Error('not in inventory'), {
+        node: node.path,
+        tree: tree.path,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        log,
+      })
+    }
+
+    const devEdges = [...node.edgesOut.values()].filter(e => e.dev)
+    if (!node.isTop && devEdges.length) {
+      throw Object.assign(new Error('dev edges on non-top node'), {
+        node: node.path,
+        tree: tree.path,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        devEdges: devEdges.map(e => [e.type, e.name, e.spec, e.error]),
+        log,
+      })
+    }
+
+    if (node.path === tree.root.path && node !== tree.root && !tree.root.isLink) {
+      throw Object.assign(new Error('node with same path as root'), {
+        node: node.path,
+        tree: tree.path,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        log,
+      })
+    }
+
+    if (!node.isLink && node.path !== node.realpath) {
+      throw Object.assign(new Error('non-link with mismatched path/realpath'), {
+        node: node.path,
+        tree: tree.path,
+        realpath: node.realpath,
+        root: tree.root.path,
+        via: via.path,
+        viaType,
+        log,
+      })
+    }
+
+    const { parent, fsParent, target } = node
+    check(parent, node, 'parent')
+    check(fsParent, node, 'fsParent')
+    check(target, node, 'target')
+    log.push(['CHILDREN', node.location, ...node.children.keys()])
+    for (const kid of node.children.values()) {
+      check(kid, node, 'children')
+    }
+    for (const kid of node.fsChildren) {
+      check(kid, node, 'fsChildren')
+    }
+    for (const link of node.linksIn) {
+      check(link, node, 'linksIn')
+    }
+    for (const top of node.tops) {
+      check(top, node, 'tops')
+    }
+    log.push(['DONE', node.location])
+  }
+  check(tree)
+  if (checkUnreachable) {
+    for (const node of inventory.values()) {
+      if (!seen.has(node) && node !== tree.root) {
+        throw Object.assign(new Error('unreachable in inventory'), {
+          node: node.path,
+          realpath: node.realpath,
+          location: node.location,
+          root: tree.root.path,
+          tree: tree.path,
+          log,
+        })
+      }
+    }
+  }
+  return tree
+}
+
+// should only ever run this check in debug mode
+module.exports = tree => tree
+debug(() => module.exports = checkTree)
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/version-from-tgz.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/version-from-tgz.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bc6a8c34a7ab084affc5a7b2b6118f3b9e46c65
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/version-from-tgz.js
@@ -0,0 +1,47 @@
+const semver = require('semver')
+const { basename } = require('node:path')
+const { URL } = require('node:url')
+module.exports = (name, tgz) => {
+  const base = basename(tgz)
+  if (!base.endsWith('.tgz')) {
+    return null
+  }
+
+  if (tgz.startsWith('http:/') || tgz.startsWith('https:/')) {
+    const u = new URL(tgz)
+    // registry url?  check for most likely pattern.
+    // either /@foo/bar/-/bar-1.2.3.tgz or
+    // /foo/-/foo-1.2.3.tgz, and fall through to
+    // basename checking.  Note that registries can
+    // be mounted below the root url, so /a/b/-/x/y/foo/-/foo-1.2.3.tgz
+    // is a potential option.
+    const tfsplit = u.pathname.slice(1).split('/-/')
+    if (tfsplit.length > 1) {
+      const afterTF = tfsplit.pop()
+      if (afterTF === base) {
+        const pre = tfsplit.pop()
+        const preSplit = pre.split(/\/|%2f/i)
+        const project = preSplit.pop()
+        const scope = preSplit.pop()
+        return versionFromBaseScopeName(base, scope, project)
+      }
+    }
+  }
+
+  const split = name.split(/\/|%2f/i)
+  const project = split.pop()
+  const scope = split.pop()
+  return versionFromBaseScopeName(base, scope, project)
+}
+
+const versionFromBaseScopeName = (base, scope, name) => {
+  if (!base.startsWith(name + '-')) {
+    return null
+  }
+
+  const parsed = semver.parse(base.substring(name.length + 1, base.length - 4))
+  return parsed ? {
+    name: scope && scope.charAt(0) === '@' ? `${scope}/${name}` : name,
+    version: parsed.version,
+  } : null
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/vuln.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/vuln.js
new file mode 100644
index 0000000000000000000000000000000000000000..597dab4e31eb889cdd47e94d71cb17c69b176f46
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/vuln.js
@@ -0,0 +1,214 @@
+// An object representing a vulnerability either as the result of an
+// advisory or due to the package in question depending exclusively on
+// vulnerable versions of a dep.
+//
+// - name: package name
+// - range: Set of vulnerable versions
+// - nodes: Set of nodes affected
+// - effects: Set of vulns triggered by this one
+// - advisories: Set of advisories (including metavulns) causing this vuln.
+//   All of the entries in via are vulnerability objects returned by
+//   @npmcli/metavuln-calculator
+// - via: dependency vulns which cause this one
+
+const { satisfies, simplifyRange } = require('semver')
+const semverOpt = { loose: true, includePrerelease: true }
+
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const npa = require('npm-package-arg')
+
+const severities = new Map([
+  ['info', 0], [0, 'info'],
+  ['low', 1], [1, 'low'],
+  ['moderate', 2], [2, 'moderate'],
+  ['high', 3], [3, 'high'],
+  ['critical', 4], [4, 'critical'],
+  [null, -1], [-1, null],
+])
+
+class Vuln {
+  #range = null
+  #simpleRange = null
+  // assume a fix is available unless it hits a top node
+  // that locks it in place, setting this false or {isSemVerMajor, version}.
+  #fixAvailable = true
+
+  constructor ({ name, advisory }) {
+    this.name = name
+    this.via = new Set()
+    this.advisories = new Set()
+    this.severity = null
+    this.effects = new Set()
+    this.topNodes = new Set()
+    this.nodes = new Set()
+    this.addAdvisory(advisory)
+    this.packument = advisory.packument
+    this.versions = advisory.versions
+  }
+
+  get fixAvailable () {
+    return this.#fixAvailable
+  }
+
+  set fixAvailable (f) {
+    this.#fixAvailable = f
+    // if there's a fix available for this at the top level, it means that
+    // it will also fix the vulns that led to it being there.  to get there,
+    // we set the vias to the most "strict" of fix availables.
+    // - false: no fix is available
+    // - {name, version, isSemVerMajor} fix requires -f, is semver major
+    // - {name, version} fix requires -f, not semver major
+    // - true: fix does not require -f
+    // TODO: duped entries may require different fixes but the current
+    // structure does not support this, so the case were a top level fix
+    // corrects a duped entry may mean you have to run fix more than once
+    for (const v of this.via) {
+      // don't blow up on loops
+      if (v.fixAvailable === f) {
+        continue
+      }
+
+      if (f === false) {
+        v.fixAvailable = f
+      } else if (v.fixAvailable === true) {
+        v.fixAvailable = f
+      } else if (typeof f === 'object' && (
+        typeof v.fixAvailable !== 'object' || !v.fixAvailable.isSemVerMajor)) {
+        v.fixAvailable = f
+      }
+    }
+  }
+
+  get isDirect () {
+    for (const node of this.nodes.values()) {
+      for (const edge of node.edgesIn) {
+        if (edge.from.isProjectRoot || edge.from.isWorkspace) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  testSpec (spec) {
+    const specObj = npa(spec)
+    if (!specObj.registry) {
+      return true
+    }
+
+    if (specObj.subSpec) {
+      spec = specObj.subSpec.rawSpec
+    }
+
+    for (const v of this.versions) {
+      if (satisfies(v, spec) && !satisfies(v, this.range, semverOpt)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  toJSON () {
+    return {
+      name: this.name,
+      severity: this.severity,
+      isDirect: this.isDirect,
+      // just loop over the advisories, since via is only Vuln objects,
+      // and calculated advisories have all the info we need
+      via: [...this.advisories].map(v => v.type === 'metavuln' ? v.dependency : {
+        ...v,
+        versions: undefined,
+        vulnerableVersions: undefined,
+        id: undefined,
+      }).sort((a, b) =>
+        localeCompare(String(a.source || a), String(b.source || b))),
+      effects: [...this.effects].map(v => v.name).sort(localeCompare),
+      range: this.simpleRange,
+      nodes: [...this.nodes].map(n => n.location).sort(localeCompare),
+      fixAvailable: this.#fixAvailable,
+    }
+  }
+
+  addVia (v) {
+    this.via.add(v)
+    v.effects.add(this)
+    // call the setter since we might add vias _after_ setting fixAvailable
+    this.fixAvailable = this.fixAvailable
+  }
+
+  deleteVia (v) {
+    this.via.delete(v)
+    v.effects.delete(this)
+  }
+
+  deleteAdvisory (advisory) {
+    this.advisories.delete(advisory)
+    // make sure we have the max severity of all the vulns causing this one
+    this.severity = null
+    this.#range = null
+    this.#simpleRange = null
+    // refresh severity
+    for (const advisory of this.advisories) {
+      this.addAdvisory(advisory)
+    }
+
+    // remove any effects that are no longer relevant
+    const vias = new Set([...this.advisories].map(a => a.dependency))
+    for (const via of this.via) {
+      if (!vias.has(via.name)) {
+        this.deleteVia(via)
+      }
+    }
+  }
+
+  addAdvisory (advisory) {
+    this.advisories.add(advisory)
+    const sev = severities.get(advisory.severity)
+    this.#range = null
+    this.#simpleRange = null
+    if (sev > severities.get(this.severity)) {
+      this.severity = advisory.severity
+    }
+  }
+
+  get range () {
+    if (!this.#range) {
+      this.#range = [...this.advisories].map(v => v.range).join(' || ')
+    }
+    return this.#range
+  }
+
+  get simpleRange () {
+    if (this.#simpleRange && this.#simpleRange === this.#range) {
+      return this.#simpleRange
+    }
+
+    const versions = [...this.advisories][0].versions
+    const range = this.range
+    this.#simpleRange = simplifyRange(versions, range, semverOpt)
+    this.#range = this.#simpleRange
+    return this.#simpleRange
+  }
+
+  isVulnerable (node) {
+    if (this.nodes.has(node)) {
+      return true
+    }
+
+    const { version } = node.package
+    if (!version) {
+      return false
+    }
+
+    for (const v of this.advisories) {
+      if (v.testVersion(version)) {
+        this.nodes.add(node)
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+module.exports = Vuln
diff --git a/node/node_modules/npm/node_modules/@npmcli/arborist/lib/yarn-lock.js b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/yarn-lock.js
new file mode 100644
index 0000000000000000000000000000000000000000..a50c8f637b6d17ace77a5c06ae2197479f5ff5dc
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/arborist/lib/yarn-lock.js
@@ -0,0 +1,377 @@
+// parse a yarn lock file
+// basic format
+//
+// <request spec>[, <request spec> ...]:
+//   <key> <value>
+//   <subkey>:
+//     <key> <value>
+//
+// Assume that any key or value might be quoted, though that's only done
+// in practice if certain chars are in the string. When writing back, we follow
+// Yarn's rules for quoting, to cause minimal friction.
+//
+// The data format would support nested objects, but at this time, it
+// appears that yarn does not use that for anything, so in the interest
+// of a simpler parser algorithm, this implementation only supports a
+// single layer of sub objects.
+//
+// This doesn't deterministically define the shape of the tree, and so
+// cannot be used (on its own) for Arborist.loadVirtual.
+// But it can give us resolved, integrity, and version, which is useful
+// for Arborist.loadActual and for building the ideal tree.
+//
+// At the very least, when a yarn.lock file is present, we update it
+// along the way, and save it back in Shrinkwrap.save()
+//
+// NIHing this rather than using @yarnpkg/lockfile because that module
+// is an impenetrable 10kloc of webpack flow output, which is overkill
+// for something relatively simple and tailored to Arborist's use case.
+
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const consistentResolve = require('./consistent-resolve.js')
+const { dirname } = require('node:path')
+const { breadth } = require('treeverse')
+
+// Sort Yarn entries respecting the yarn.lock sort order
+const yarnEntryPriorities = {
+  name: 1,
+  version: 2,
+  uid: 3,
+  resolved: 4,
+  integrity: 5,
+  registry: 6,
+  dependencies: 7,
+}
+
+const priorityThenLocaleCompare = (a, b) => {
+  if (!yarnEntryPriorities[a] && !yarnEntryPriorities[b]) {
+    return localeCompare(a, b)
+  }
+  /* istanbul ignore next */
+  return (yarnEntryPriorities[a] || 100) > (yarnEntryPriorities[b] || 100) ? 1 : -1
+}
+
+const quoteIfNeeded = val => {
+  if (
+    typeof val === 'boolean' ||
+    typeof val === 'number' ||
+    val.startsWith('true') ||
+    val.startsWith('false') ||
+    /[:\s\n\\",[\]]/g.test(val) ||
+    !/^[a-zA-Z]/g.test(val)
+  ) {
+    return JSON.stringify(val)
+  }
+
+  return val
+}
+
+// sort a key/value object into a string of JSON stringified keys and vals
+const sortKV = obj => Object.keys(obj)
+  .sort(localeCompare)
+  .map(k => `    ${quoteIfNeeded(k)} ${quoteIfNeeded(obj[k])}`)
+  .join('\n')
+
+// for checking against previous entries
+const match = (p, n) =>
+  p.integrity && n.integrity ? p.integrity === n.integrity
+  : p.resolved && n.resolved ? p.resolved === n.resolved
+  : p.version && n.version ? p.version === n.version
+  : true
+
+const prefix =
+`# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+`
+
+const nullSymbol = Symbol('null')
+class YarnLock {
+  static parse (data) {
+    return new YarnLock().parse(data)
+  }
+
+  static fromTree (tree) {
+    return new YarnLock().fromTree(tree)
+  }
+
+  constructor () {
+    this.entries = null
+    this.endCurrent()
+  }
+
+  endCurrent () {
+    this.current = null
+    this.subkey = nullSymbol
+  }
+
+  parse (data) {
+    const ENTRY_START = /^[^\s].*:$/
+    const SUBKEY = /^ {2}[^\s]+:$/
+    const SUBVAL = /^ {4}[^\s]+ .+$/
+    const METADATA = /^ {2}[^\s]+ .+$/
+    this.entries = new Map()
+    this.current = null
+    const linere = /([^\r\n]*)\r?\n/gm
+    let match
+    let lineNum = 0
+    if (!/\n$/.test(data)) {
+      data += '\n'
+    }
+    while (match = linere.exec(data)) {
+      const line = match[1]
+      lineNum++
+      if (line.charAt(0) === '#') {
+        continue
+      }
+      if (line === '') {
+        this.endCurrent()
+        continue
+      }
+      if (ENTRY_START.test(line)) {
+        this.endCurrent()
+        const specs = this.splitQuoted(line.slice(0, -1), /, */)
+        this.current = new YarnLockEntry(specs)
+        specs.forEach(spec => this.entries.set(spec, this.current))
+        continue
+      }
+      if (SUBKEY.test(line)) {
+        this.subkey = line.slice(2, -1)
+        this.current[this.subkey] = {}
+        continue
+      }
+      if (SUBVAL.test(line) && this.current && this.current[this.subkey]) {
+        const subval = this.splitQuoted(line.trimLeft(), ' ')
+        if (subval.length === 2) {
+          this.current[this.subkey][subval[0]] = subval[1]
+          continue
+        }
+      }
+      // any other metadata
+      if (METADATA.test(line) && this.current) {
+        const metadata = this.splitQuoted(line.trimLeft(), ' ')
+        if (metadata.length === 2) {
+          // strip off the legacy shasum hashes
+          if (metadata[0] === 'resolved') {
+            metadata[1] = metadata[1].replace(/#.*/, '')
+          }
+          this.current[metadata[0]] = metadata[1]
+          continue
+        }
+      }
+
+      throw Object.assign(new Error('invalid or corrupted yarn.lock file'), {
+        position: match.index,
+        content: match[0],
+        line: lineNum,
+      })
+    }
+    this.endCurrent()
+    return this
+  }
+
+  splitQuoted (str, delim) {
+    // a,"b,c",d"e,f => ['a','"b','c"','d"e','f'] => ['a','b,c','d"e','f']
+    const split = str.split(delim)
+    const out = []
+    let o = 0
+    for (let i = 0; i < split.length; i++) {
+      const chunk = split[i]
+      if (/^".*"$/.test(chunk)) {
+        out[o++] = chunk.trim().slice(1, -1)
+      } else if (/^"/.test(chunk)) {
+        let collect = chunk.trimLeft().slice(1)
+        while (++i < split.length) {
+          const n = split[i]
+          // something that is not a slash, followed by an even number
+          // of slashes then a " then end => ending on an unescaped "
+          if (/[^\\](\\\\)*"$/.test(n)) {
+            collect += n.trimRight().slice(0, -1)
+            break
+          } else {
+            collect += n
+          }
+        }
+        out[o++] = collect
+      } else {
+        out[o++] = chunk.trim()
+      }
+    }
+    return out
+  }
+
+  toString () {
+    return prefix + [...new Set([...this.entries.values()])]
+      .map(e => e.toString())
+      .sort((a, b) => localeCompare(a.replace(/"/g, ''), b.replace(/"/g, ''))).join('\n\n') + '\n'
+  }
+
+  fromTree (tree) {
+    this.entries = new Map()
+    // walk the tree in a deterministic order, breadth-first, alphabetical
+    breadth({
+      tree,
+      visit: node => this.addEntryFromNode(node),
+      getChildren: node => [...node.children.values(), ...node.fsChildren]
+        .sort((a, b) => a.depth - b.depth || localeCompare(a.name, b.name)),
+    })
+    return this
+  }
+
+  addEntryFromNode (node) {
+    const specs = [...node.edgesIn]
+      .map(e => `${node.name}@${e.spec}`)
+      .sort(localeCompare)
+
+    // Note:
+    // yarn will do excessive duplication in a case like this:
+    // root -> (x@1.x, y@1.x, z@1.x)
+    // y@1.x -> (x@1.1, z@2.x)
+    // z@1.x -> ()
+    // z@2.x -> (x@1.x)
+    //
+    // where x@1.2 exists, because the "x@1.x" spec will *always* resolve
+    // to x@1.2, which doesn't work for y's dep on x@1.1, so you'll get this:
+    //
+    // root
+    // +-- x@1.2.0
+    // +-- y
+    // |   +-- x@1.1.0
+    // |   +-- z@2
+    // |       +-- x@1.2.0
+    // +-- z@1
+    //
+    // instead of this more deduped tree that arborist builds by default:
+    //
+    // root
+    // +-- x@1.2.0 (dep is x@1.x, from root)
+    // +-- y
+    // |   +-- x@1.1.0
+    // |   +-- z@2 (dep on x@1.x deduped to x@1.1.0 under y)
+    // +-- z@1
+    //
+    // In order to not create an invalid yarn.lock file with conflicting
+    // entries, AND not tell yarn to create an invalid tree, we need to
+    // ignore the x@1.x spec coming from z, since it's already in the entries.
+    //
+    // So, if the integrity and resolved don't match a previous entry, skip it.
+    // We call this method on shallower nodes first, so this is fine.
+    const n = this.entryDataFromNode(node)
+    let priorEntry = null
+    const newSpecs = []
+    for (const s of specs) {
+      const prev = this.entries.get(s)
+      // no previous entry for this spec at all, so it's new
+      if (!prev) {
+        // if we saw a match already, then assign this spec to it as well
+        if (priorEntry) {
+          priorEntry.addSpec(s)
+        } else {
+          newSpecs.push(s)
+        }
+        continue
+      }
+
+      const m = match(prev, n)
+      // there was a prior entry, but a different thing.  skip this one
+      if (!m) {
+        continue
+      }
+
+      // previous matches, but first time seeing it, so already has this spec.
+      // go ahead and add all the previously unseen specs, though
+      if (!priorEntry) {
+        priorEntry = prev
+        for (const s of newSpecs) {
+          priorEntry.addSpec(s)
+          this.entries.set(s, priorEntry)
+        }
+        newSpecs.length = 0
+        continue
+      }
+
+      // have a prior entry matching n, and matching the prev we just saw
+      // add the spec to it
+      priorEntry.addSpec(s)
+      this.entries.set(s, priorEntry)
+    }
+
+    // if we never found a matching prior, then this is a whole new thing
+    if (!priorEntry) {
+      const entry = Object.assign(new YarnLockEntry(newSpecs), n)
+      for (const s of newSpecs) {
+        this.entries.set(s, entry)
+      }
+    } else {
+      // pick up any new info that we got for this node, so that we can
+      // decorate with integrity/resolved/etc.
+      Object.assign(priorEntry, n)
+    }
+  }
+
+  entryDataFromNode (node) {
+    const n = {}
+    if (node.package.dependencies) {
+      n.dependencies = node.package.dependencies
+    }
+    if (node.package.optionalDependencies) {
+      n.optionalDependencies = node.package.optionalDependencies
+    }
+    if (node.version) {
+      n.version = node.version
+    }
+    if (node.resolved) {
+      n.resolved = consistentResolve(
+        node.resolved,
+        node.isLink ? dirname(node.path) : node.path,
+        node.root.path,
+        true
+      )
+    }
+    if (node.integrity) {
+      n.integrity = node.integrity
+    }
+
+    return n
+  }
+
+  static get Entry () {
+    return YarnLockEntry
+  }
+}
+
+class YarnLockEntry {
+  #specs
+  constructor (specs) {
+    this.#specs = new Set(specs)
+    this.resolved = null
+    this.version = null
+    this.integrity = null
+    this.dependencies = null
+    this.optionalDependencies = null
+  }
+
+  toString () {
+    // sort objects to the bottom, then alphabetical
+    return ([...this.#specs]
+      .sort(localeCompare)
+      .map(quoteIfNeeded).join(', ') +
+      ':\n' +
+      Object.getOwnPropertyNames(this)
+        .filter(prop => this[prop] !== null)
+        .sort(priorityThenLocaleCompare)
+        .map(prop =>
+          typeof this[prop] !== 'object'
+            ? `  ${prop} ${prop === 'integrity' ? this[prop] : JSON.stringify(this[prop])}\n`
+            : Object.keys(this[prop]).length === 0 ? ''
+            : `  ${prop}:\n` + sortKV(this[prop]) + '\n')
+        .join('')).trim()
+  }
+
+  addSpec (spec) {
+    this.#specs.add(spec)
+  }
+}
+
+module.exports = YarnLock
diff --git a/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/definition.js b/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/definition.js
new file mode 100644
index 0000000000000000000000000000000000000000..1bb04e6f2302fc25790bd2576cbfcf29feff0487
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/definition.js
@@ -0,0 +1,255 @@
+// class that describes a config key we know about
+// this keeps us from defining a config key and not
+// providing a default, description, etc.
+//
+// TODO: some kind of categorization system, so we can
+// say "these are for registry access", "these are for
+// version resolution" etc.
+
+const required = ['type', 'description', 'default', 'key']
+
+const allowed = [
+  'default',
+  'defaultDescription',
+  'deprecated',
+  'description',
+  'exclusive',
+  'flatten',
+  'hint',
+  'key',
+  'short',
+  'type',
+  'typeDescription',
+  'usage',
+  'envExport',
+  'alias',
+  'required',
+]
+
+const {
+  semver: { type: semver },
+  Umask: { type: Umask },
+  url: { type: url },
+  path: { type: path },
+} = require('../type-defs.js')
+
+class Definition {
+  constructor (key, def) {
+    this.key = key
+    // if it's set falsey, don't export it; otherwise, we do by default
+    this.envExport = true
+    Object.assign(this, def)
+    this.validate()
+    if (!this.defaultDescription) {
+      this.defaultDescription = describeValue(this.default)
+    }
+    if (!this.typeDescription) {
+      this.typeDescription = describeType(this.type)
+    }
+    // hint is only used for non-boolean values
+    if (!this.hint) {
+      if (this.type === Number) {
+        this.hint = '<number>'
+      } else {
+        this.hint = `<${this.key}>`
+      }
+    }
+    if (!this.usage) {
+      this.usage = describeUsage(this)
+    }
+  }
+
+  validate () {
+    for (const req of required) {
+      if (!Object.prototype.hasOwnProperty.call(this, req)) {
+        throw new Error(`config lacks ${req}: ${this.key}`)
+      }
+    }
+    if (!this.key) {
+      throw new Error(`config lacks key: ${this.key}`)
+    }
+    for (const field of Object.keys(this)) {
+      if (!allowed.includes(field)) {
+        throw new Error(`config defines unknown field ${field}: ${this.key}`)
+      }
+    }
+  }
+
+  // a textual description of this config, suitable for help output
+  describe () {
+    const description = unindent(this.description)
+    const noEnvExport = this.envExport
+      ? ''
+      : `
+This value is not exported to the environment for child processes.
+`
+    const deprecated = !this.deprecated ? '' : `* DEPRECATED: ${unindent(this.deprecated)}\n`
+    /* eslint-disable-next-line max-len */
+    const exclusive = !this.exclusive ? '' : `\nThis config cannot be used with: \`${this.exclusive.join('`, `')}\``
+    return wrapAll(`#### \`${this.key}\`
+
+* Default: ${unindent(this.defaultDescription)}
+* Type: ${unindent(this.typeDescription)}
+${deprecated}
+${description}
+${exclusive}
+${noEnvExport}`)
+  }
+}
+
+const describeUsage = def => {
+  let key = ''
+
+  // Single type
+  if (!Array.isArray(def.type)) {
+    if (def.short) {
+      key = `-${def.short}|`
+    }
+
+    if (def.type === Boolean && def.default !== false) {
+      key = `${key}--no-${def.key}`
+    } else {
+      key = `${key}--${def.key}`
+    }
+
+    if (def.type !== Boolean) {
+      key = `${key} ${def.hint}`
+    }
+
+    return key
+  }
+
+  key = `--${def.key}`
+  if (def.short) {
+    key = `-${def.short}|--${def.key}`
+  }
+
+  // Multiple types
+  let types = def.type
+  const multiple = types.includes(Array)
+  const bool = types.includes(Boolean)
+
+  // null type means optional and doesn't currently affect usage output since
+  // all non-optional params have defaults so we render everything as optional
+  types = types.filter(t => t !== null && t !== Array && t !== Boolean)
+
+  if (!types.length) {
+    return key
+  }
+
+  let description
+  if (!types.some(t => typeof t !== 'string')) {
+    // Specific values, use specifics given
+    description = `<${types.filter(d => d).join('|')}>`
+  } else {
+    // Generic values, use hint
+    description = def.hint
+  }
+
+  if (bool) {
+    // Currently none of our multi-type configs with boolean values default to
+    // false so all their hints should show `--no-`, if we ever add ones that
+    // default to false we can branch the logic here
+    key = `--no-${def.key}|${key}`
+  }
+
+  const usage = `${key} ${description}`
+  if (multiple) {
+    return `${usage} [${usage} ...]`
+  } else {
+    return usage
+  }
+}
+
+const describeType = type => {
+  if (Array.isArray(type)) {
+    const descriptions = type.filter(t => t !== Array).map(t => describeType(t))
+
+    // [a] => "a"
+    // [a, b] => "a or b"
+    // [a, b, c] => "a, b, or c"
+    // [a, Array] => "a (can be set multiple times)"
+    // [a, Array, b] => "a or b (can be set multiple times)"
+    const last = descriptions.length > 1 ? [descriptions.pop()] : []
+    const oxford = descriptions.length > 1 ? ', or ' : ' or '
+    const words = [descriptions.join(', ')].concat(last).join(oxford)
+    const multiple = type.includes(Array) ? ' (can be set multiple times)' : ''
+    return `${words}${multiple}`
+  }
+
+  // Note: these are not quite the same as the description printed
+  // when validation fails.  In that case, we want to give the user
+  // a bit more information to help them figure out what's wrong.
+  switch (type) {
+    case String:
+      return 'String'
+    case Number:
+      return 'Number'
+    case Umask:
+      return 'Octal numeric string in range 0000..0777 (0..511)'
+    case Boolean:
+      return 'Boolean'
+    case Date:
+      return 'Date'
+    case path:
+      return 'Path'
+    case semver:
+      return 'SemVer string'
+    case url:
+      return 'URL'
+    default:
+      return describeValue(type)
+  }
+}
+
+// if it's a string, quote it.  otherwise, just cast to string.
+const describeValue = val => (typeof val === 'string' ? JSON.stringify(val) : String(val))
+
+const unindent = s => {
+  // get the first \n followed by a bunch of spaces, and pluck off
+  // that many spaces from the start of every line.
+  const match = s.match(/\n +/)
+  return !match ? s.trim() : s.split(match[0]).join('\n').trim()
+}
+
+const wrap = s => {
+  const cols = Math.min(Math.max(20, process.stdout.columns) || 80, 80) - 5
+  return unindent(s)
+    .split(/[ \n]+/)
+    .reduce((left, right) => {
+      const last = left.split('\n').pop()
+      const join = last.length && last.length + right.length > cols ? '\n' : ' '
+      return left + join + right
+    })
+}
+
+const wrapAll = s => {
+  let inCodeBlock = false
+  return s
+    .split('\n\n')
+    .map(block => {
+      if (inCodeBlock || block.startsWith('```')) {
+        inCodeBlock = !block.endsWith('```')
+        return block
+      }
+
+      if (block.charAt(0) === '*') {
+        return (
+          '* ' +
+          block
+            .slice(1)
+            .trim()
+            .split('\n* ')
+            .map(li => {
+              return wrap(li).replace(/\n/g, '\n  ')
+            })
+            .join('\n* ')
+        )
+      } else {
+        return wrap(block)
+      }
+    })
+    .join('\n\n')
+}
+
+module.exports = Definition
diff --git a/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/definitions.js b/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/definitions.js
new file mode 100644
index 0000000000000000000000000000000000000000..00d477ced02cbe19ee8ed37d40f315f2eb77bc72
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/definitions.js
@@ -0,0 +1,2472 @@
+const Definition = require('./definition.js')
+
+const ciInfo = require('ci-info')
+const querystring = require('node:querystring')
+const { join } = require('node:path')
+
+const isWindows = process.platform === 'win32'
+
+// used by cafile flattening to flatOptions.ca
+const { readFileSync } = require('node:fs')
+const maybeReadFile = file => {
+  try {
+    return readFileSync(file, 'utf8')
+  } catch (er) {
+    if (er.code !== 'ENOENT') {
+      throw er
+    }
+    return null
+  }
+}
+
+const buildOmitList = obj => {
+  const include = obj.include || []
+  const omit = obj.omit || []
+
+  const only = obj.only
+  if (/^prod(uction)?$/.test(only) || obj.production) {
+    omit.push('dev')
+  } else if (obj.production === false) {
+    include.push('dev')
+  }
+
+  if (/^dev/.test(obj.also)) {
+    include.push('dev')
+  }
+
+  if (obj.dev) {
+    include.push('dev')
+  }
+
+  if (obj.optional === false) {
+    omit.push('optional')
+  } else if (obj.optional === true) {
+    include.push('optional')
+  }
+
+  obj.omit = [...new Set(omit)].filter(type => !include.includes(type))
+  obj.include = [...new Set(include)]
+
+  if (obj.omit.includes('dev')) {
+    process.env.NODE_ENV = 'production'
+  }
+
+  return obj.omit
+}
+
+const editor = process.env.EDITOR ||
+  process.env.VISUAL ||
+  (isWindows ? `${process.env.SYSTEMROOT}\\notepad.exe` : 'vi')
+
+const shell = isWindows ? process.env.ComSpec || 'cmd'
+  : process.env.SHELL || 'sh'
+
+const { networkInterfaces } = require('node:os')
+const getLocalAddresses = () => {
+  try {
+    return Object.values(networkInterfaces()).map(
+      int => int.map(({ address }) => address)
+    ).reduce((set, addrs) => set.concat(addrs), [null])
+  } catch (e) {
+    return [null]
+  }
+}
+
+const unicode = /UTF-?8$/i.test(
+  process.env.LC_ALL ||
+  process.env.LC_CTYPE ||
+  process.env.LANG
+)
+
+// use LOCALAPPDATA on Windows, if set
+// https://github.com/npm/cli/pull/899
+const cacheRoot = (isWindows && process.env.LOCALAPPDATA) || '~'
+const cacheExtra = isWindows ? 'npm-cache' : '.npm'
+const cache = `${cacheRoot}/${cacheExtra}`
+
+// TODO: refactor these type definitions so that they are less
+// weird to pull out of the config module.
+// TODO: use better type definition/validation API, nopt's is so weird.
+const {
+  semver: { type: Semver },
+  Umask: { type: Umask },
+  url: { type: url },
+  path: { type: path },
+} = require('../type-defs.js')
+
+// basic flattening function, just copy it over camelCase
+const flatten = (key, obj, flatOptions) => {
+  const camel = key.replace(/-([a-z])/g, (_0, _1) => _1.toUpperCase())
+  flatOptions[camel] = obj[key]
+}
+
+// TODO:
+// Instead of having each definition provide a flatten method,
+// provide the (?list of?) flat option field(s?) that it impacts.
+// When that config is set, we mark the relevant flatOption fields
+// dirty.  Then, a getter for that field defines how we actually
+// set it.
+//
+// So, `save-dev`, `save-optional`, `save-prod`, et al would indicate
+// that they affect the `saveType` flat option.  Then the config.flat
+// object has a `get saveType () { ... }` that looks at the "real"
+// config settings from files etc and returns the appropriate value.
+//
+// Getters will also (maybe?) give us a hook to audit flat option
+// usage, so we can document and group these more appropriately.
+//
+// This will be a problem with cases where we currently do:
+// const opts = { ...npm.flatOptions, foo: 'bar' }, but we can maybe
+// instead do `npm.config.set('foo', 'bar')` prior to passing the
+// config object down where it needs to go.
+//
+// This way, when we go hunting for "where does saveType come from anyway!?"
+// while fixing some Arborist bug, we won't have to hunt through too
+// many places.
+
+// XXX: We should really deprecate all these `--save-blah` switches
+// in favor of a single `--save-type` option.  The unfortunate shortcut
+// we took for `--save-peer --save-optional` being `--save-type=peerOptional`
+// makes this tricky, and likely a breaking change.
+
+// Define all config keys we know about.  They are indexed by their own key for
+// ease of lookup later.  This duplication is an optimization so that we don't
+// have to do an extra function call just to "reuse" the key in both places.
+
+const definitions = {
+  _auth: new Definition('_auth', {
+    default: null,
+    type: [null, String],
+    description: `
+    A basic-auth string to use when authenticating against the npm registry.
+    This will ONLY be used to authenticate against the npm registry.  For other
+    registries you will need to scope it like "//other-registry.tld/:_auth"
+
+    Warning: This should generally not be set via a command-line option.  It
+    is safer to use a registry-provided authentication bearer token stored in
+    the ~/.npmrc file by running \`npm login\`.
+  `,
+    flatten,
+  }),
+  access: new Definition('access', {
+    default: null,
+    defaultDescription: `
+    'public' for new packages, existing packages it will not change the current level
+  `,
+    type: [null, 'restricted', 'public'],
+    description: `
+    If you do not want your scoped package to be publicly viewable (and
+    installable) set \`--access=restricted\`.
+
+    Unscoped packages cannot be set to \`restricted\`.
+
+    Note: This defaults to not changing the current access level for existing
+    packages.  Specifying a value of \`restricted\` or \`public\` during
+    publish will change the access for an existing package the same way that
+    \`npm access set status\` would.
+  `,
+    flatten,
+  }),
+  all: new Definition('all', {
+    default: false,
+    type: Boolean,
+    short: 'a',
+    description: `
+    When running \`npm outdated\` and \`npm ls\`, setting \`--all\` will show
+    all outdated or installed packages, rather than only those directly
+    depended upon by the current project.
+  `,
+    flatten,
+  }),
+  'allow-same-version': new Definition('allow-same-version', {
+    default: false,
+    type: Boolean,
+    description: `
+    Prevents throwing an error when \`npm version\` is used to set the new
+    version to the same value as the current version.
+  `,
+    flatten,
+  }),
+  'allow-git': new Definition('allow-git', {
+    default: 'all',
+    type: ['all', 'none', 'root'],
+    description: `
+      Limits the ability for npm to fetch dependencies from git references.
+      That is, dependencies that point to a git repo instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+
+      \`all\` allows any git dependencies to be fetched and installed.
+      \`none\` prevents any git dependencies from being fetched and installed.
+      \`root\` only allows git dependencies defined in your project's package.json to be fetched installed.  Also allows git dependencies to be fetched for other commands like \`npm view\`
+  `,
+    flatten,
+  }),
+  also: new Definition('also', {
+    default: null,
+    type: [null, 'dev', 'development'],
+    description: `
+      When set to \`dev\` or \`development\`, this is an alias for
+      \`--include=dev\`.
+    `,
+    deprecated: 'Please use --include=dev instead.',
+    flatten (key, obj, flatOptions) {
+      definitions.omit.flatten('omit', obj, flatOptions)
+    },
+  }),
+  audit: new Definition('audit', {
+    default: true,
+    type: Boolean,
+    description: `
+      When "true" submit audit reports alongside the current npm command to the
+      default registry and all registries configured for scopes.  See the
+      documentation for [\`npm audit\`](/commands/npm-audit) for details on what
+      is submitted.
+    `,
+    flatten,
+  }),
+  'audit-level': new Definition('audit-level', {
+    default: null,
+    type: [null, 'info', 'low', 'moderate', 'high', 'critical', 'none'],
+    description: `
+    The minimum level of vulnerability for \`npm audit\` to exit with
+    a non-zero exit code.
+    `,
+    flatten,
+  }),
+  'auth-type': new Definition('auth-type', {
+    default: 'web',
+    type: ['legacy', 'web'],
+    description: `
+      What authentication strategy to use with \`login\`.
+      Note that if an \`otp\` config is given, this value will always be set to \`legacy\`.
+    `,
+    flatten,
+  }),
+  before: new Definition('before', {
+    default: null,
+    hint: '<date>',
+    type: [null, Date],
+    exclusive: ['min-release-age'],
+    description: `
+      If passed to \`npm install\`, will rebuild the npm tree such that only
+      versions that were available **on or before** the given date are
+      installed.  If there are no versions available for the current set of
+      dependencies, the command will error.
+
+      If the requested version is a \`dist-tag\` and the given tag does not
+      pass the \`--before\` filter, the most recent version less than or equal
+      to that tag will be used. For example, \`foo@latest\` might install
+      \`foo@1.2\` even though \`latest\` is \`2.0\`.
+    `,
+    flatten,
+  }),
+  'bin-links': new Definition('bin-links', {
+    default: true,
+    type: Boolean,
+    description: `
+      Tells npm to create symlinks (or \`.cmd\` shims on Windows) for package
+      executables.
+
+      Set to false to have it not do this.  This can be used to work around the
+      fact that some file systems don't support symlinks, even on ostensibly
+      Unix systems.
+    `,
+    flatten,
+  }),
+  browser: new Definition('browser', {
+    default: null,
+    defaultDescription: `
+    macOS: \`"open"\`, Windows: \`"start"\`, Others: \`"xdg-open"\`
+    `,
+    type: [null, Boolean, String],
+    description: `
+    The browser that is called by npm commands to open websites.
+
+    Set to \`false\` to suppress browser behavior and instead print urls to
+    terminal.
+
+    Set to \`true\` to use default system URL opener.
+    `,
+    flatten,
+  }),
+  'bypass-2fa': new Definition('bypass-2fa', {
+    default: false,
+    type: Boolean,
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      setting this to true will allow the token to bypass two-factor
+      authentication. This is useful for automation and CI/CD workflows.
+    `,
+    flatten,
+  }),
+  ca: new Definition('ca', {
+    default: null,
+    type: [null, String, Array],
+    description: `
+    The Certificate Authority signing certificate that is trusted for SSL
+    connections to the registry. Values should be in PEM format (Windows
+      calls it "Base-64 encoded X.509 (.CER)") with newlines replaced by the
+    string "\\n". For example:
+
+    \`\`\`ini
+    ca="-----BEGIN CERTIFICATE-----\\nXXXX\\nXXXX\\n-----END CERTIFICATE-----"
+    \`\`\`
+
+    Set to \`null\` to only allow "known" registrars, or to a specific CA
+    cert to trust only that specific signing authority.
+
+    Multiple CAs can be trusted by specifying an array of certificates:
+
+    \`\`\`ini
+    ca[]="..."
+    ca[]="..."
+    \`\`\`
+
+    See also the \`strict-ssl\` config.
+  `,
+    flatten,
+  }),
+  cache: new Definition('cache', {
+    default: cache,
+    defaultDescription: `
+      Windows: \`%LocalAppData%\\npm-cache\`, Posix: \`~/.npm\`
+    `,
+    type: path,
+    description: `
+      The location of npm's cache directory.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.cache = join(obj.cache, '_cacache')
+      flatOptions.npxCache = join(obj.cache, '_npx')
+      flatOptions.tufCache = join(obj.cache, '_tuf')
+    },
+  }),
+  'cache-max': new Definition('cache-max', {
+    default: Infinity,
+    type: Number,
+    description: `
+      \`--cache-max=0\` is an alias for \`--prefer-online\`
+    `,
+    deprecated: `
+      This option has been deprecated in favor of \`--prefer-online\`
+    `,
+    flatten (key, obj, flatOptions) {
+      if (obj[key] <= 0) {
+        flatOptions.preferOnline = true
+      }
+    },
+  }),
+  'cache-min': new Definition('cache-min', {
+    default: 0,
+    type: Number,
+    description: `
+      \`--cache-min=9999 (or bigger)\` is an alias for \`--prefer-offline\`.
+    `,
+    deprecated: `
+      This option has been deprecated in favor of \`--prefer-offline\`.
+    `,
+    flatten (key, obj, flatOptions) {
+      if (obj[key] >= 9999) {
+        flatOptions.preferOffline = true
+      }
+    },
+  }),
+  cafile: new Definition('cafile', {
+    default: null,
+    type: path,
+    description: `
+      A path to a file containing one or multiple Certificate Authority signing
+      certificates. Similar to the \`ca\` setting, but allows for multiple
+      CA's, as well as for the CA information to be stored in a file on disk.
+    `,
+    flatten (key, obj, flatOptions) {
+      // always set to null in defaults
+      if (!obj.cafile) {
+        return
+      }
+
+      const raw = maybeReadFile(obj.cafile)
+      if (!raw) {
+        return
+      }
+
+      const delim = '-----END CERTIFICATE-----'
+      flatOptions.ca = raw.replace(/\r\n/g, '\n').split(delim)
+        .filter(section => section.trim())
+        .map(section => section.trimLeft() + delim)
+    },
+  }),
+  call: new Definition('call', {
+    default: '',
+    type: String,
+    short: 'c',
+    description: `
+      Optional companion option for \`npm exec\`, \`npx\` that allows for
+      specifying a custom command to be run along with the installed packages.
+
+      \`\`\`bash
+      npm exec --package yo --package generator-node --call "yo node"
+      \`\`\`
+    `,
+    flatten,
+  }),
+  cert: new Definition('cert', {
+    default: null,
+    type: [null, String],
+    description: `
+      A client certificate to pass when accessing the registry.  Values should
+      be in PEM format (Windows calls it "Base-64 encoded X.509 (.CER)") with
+      newlines replaced by the string "\\n". For example:
+
+      \`\`\`ini
+      cert="-----BEGIN CERTIFICATE-----\\nXXXX\\nXXXX\\n-----END CERTIFICATE-----"
+      \`\`\`
+
+      It is _not_ the path to a certificate file, though you can set a registry-scoped
+      "certfile" path like "//other-registry.tld/:certfile=/path/to/cert.pem".
+    `,
+    deprecated: `
+      \`key\` and \`cert\` are no longer used for most registry operations.
+      Use registry scoped \`keyfile\` and \`certfile\` instead.
+      Example:
+      //other-registry.tld/:keyfile=/path/to/key.pem
+      //other-registry.tld/:certfile=/path/to/cert.crt
+    `,
+    flatten,
+  }),
+  cidr: new Definition('cidr', {
+    default: null,
+    type: [null, String, Array],
+    description: `
+      This is a list of CIDR address to be used when configuring limited access
+      tokens with the \`npm token create\` command.
+    `,
+    flatten,
+  }),
+  // This should never be directly used, the flattened value is the derived value
+  // and is sent to other modules, and is also exposed as `npm.color` for use
+  // inside npm itself.
+  color: new Definition('color', {
+    default: !process.env.NO_COLOR || process.env.NO_COLOR === '0',
+    usage: '--color|--no-color|--color always',
+    defaultDescription: `
+      true unless the NO_COLOR environ is set to something other than '0'
+    `,
+    type: ['always', Boolean],
+    description: `
+      If false, never shows colors.  If \`"always"\` then always shows colors.
+      If true, then only prints color codes for tty file descriptors.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.color = !obj.color ? false
+        : obj.color === 'always' ? true
+        : !!process.stdout.isTTY
+      flatOptions.logColor = !obj.color ? false
+        : obj.color === 'always' ? true
+        : !!process.stderr.isTTY
+    },
+  }),
+  'commit-hooks': new Definition('commit-hooks', {
+    default: true,
+    type: Boolean,
+    description: `
+      Run git commit hooks when using the \`npm version\` command.
+    `,
+    flatten,
+  }),
+  cpu: new Definition('cpu', {
+    default: null,
+    type: [null, String],
+    description: `
+      Override CPU architecture of native modules to install.
+      Acceptable values are same as \`cpu\` field of package.json,
+      which comes from \`process.arch\`.
+    `,
+    flatten,
+  }),
+  depth: new Definition('depth', {
+    default: null,
+    defaultDescription: `
+      \`Infinity\` if \`--all\` is set; otherwise, \`0\`
+    `,
+    type: [null, Number],
+    description: `
+      The depth to go when recursing packages for \`npm ls\`.
+
+      If not set, \`npm ls\` will show only the immediate dependencies of the
+      root project.  If \`--all\` is set, then npm will show all dependencies
+      by default.
+    `,
+    flatten,
+  }),
+  description: new Definition('description', {
+    default: true,
+    type: Boolean,
+    usage: '--no-description',
+    description: `
+      Show the description in \`npm search\`
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.search = flatOptions.search || { limit: 20 }
+      flatOptions.search[key] = obj[key]
+    },
+  }),
+  dev: new Definition('dev', {
+    default: false,
+    type: Boolean,
+    description: `
+      Alias for \`--include=dev\`.
+    `,
+    deprecated: 'Please use --include=dev instead.',
+    flatten (key, obj, flatOptions) {
+      definitions.omit.flatten('omit', obj, flatOptions)
+    },
+  }),
+  diff: new Definition('diff', {
+    default: [],
+    hint: '<package-spec>',
+    type: [String, Array],
+    description: `
+      Define arguments to compare in \`npm diff\`.
+    `,
+    flatten,
+  }),
+  'diff-ignore-all-space': new Definition('diff-ignore-all-space', {
+    default: false,
+    type: Boolean,
+    description: `
+      Ignore whitespace when comparing lines in \`npm diff\`.
+    `,
+    flatten,
+  }),
+  'diff-name-only': new Definition('diff-name-only', {
+    default: false,
+    type: Boolean,
+    description: `
+      Prints only filenames when using \`npm diff\`.
+    `,
+    flatten,
+  }),
+  'diff-no-prefix': new Definition('diff-no-prefix', {
+    default: false,
+    type: Boolean,
+    description: `
+      Do not show any source or destination prefix in \`npm diff\` output.
+
+      Note: this causes \`npm diff\` to ignore the \`--diff-src-prefix\` and
+      \`--diff-dst-prefix\` configs.
+    `,
+    flatten,
+  }),
+  'diff-dst-prefix': new Definition('diff-dst-prefix', {
+    default: 'b/',
+    hint: '<path>',
+    type: String,
+    description: `
+      Destination prefix to be used in \`npm diff\` output.
+    `,
+    flatten,
+  }),
+  'diff-src-prefix': new Definition('diff-src-prefix', {
+    default: 'a/',
+    hint: '<path>',
+    type: String,
+    description: `
+      Source prefix to be used in \`npm diff\` output.
+    `,
+    flatten,
+  }),
+  'diff-text': new Definition('diff-text', {
+    default: false,
+    type: Boolean,
+    description: `
+      Treat all files as text in \`npm diff\`.
+    `,
+    flatten,
+  }),
+  'diff-unified': new Definition('diff-unified', {
+    default: 3,
+    type: Number,
+    description: `
+      The number of lines of context to print in \`npm diff\`.
+    `,
+    flatten,
+  }),
+  'dry-run': new Definition('dry-run', {
+    default: false,
+    type: Boolean,
+    description: `
+      Indicates that you don't want npm to make any changes and that it should
+      only report what it would have done.  This can be passed into any of the
+      commands that modify your local installation, eg, \`install\`,
+      \`update\`, \`dedupe\`, \`uninstall\`, as well as \`pack\` and
+      \`publish\`.
+
+      Note: This is NOT honored by other network related commands, eg
+      \`dist-tags\`, \`owner\`, etc.
+    `,
+    flatten,
+  }),
+  editor: new Definition('editor', {
+    default: editor,
+    defaultDescription: `
+      The EDITOR or VISUAL environment variables, or '%SYSTEMROOT%\\notepad.exe' on Windows,
+      or 'vi' on Unix systems
+    `,
+    type: String,
+    description: `
+      The command to run for \`npm edit\` and \`npm config edit\`.
+    `,
+    flatten,
+  }),
+  'engine-strict': new Definition('engine-strict', {
+    default: false,
+    type: Boolean,
+    description: `
+      If set to true, then npm will stubbornly refuse to install (or even
+      consider installing) any package that claims to not be compatible with
+      the current Node.js version.
+
+      This can be overridden by setting the \`--force\` flag.
+    `,
+    flatten,
+  }),
+  'expect-result-count': new Definition('expect-result-count', {
+    default: null,
+    type: [null, Number],
+    hint: '<count>',
+    exclusive: ['expect-results'],
+    description: `
+      Tells to expect a specific number of results from the command.
+    `,
+  }),
+  'expect-results': new Definition('expect-results', {
+    default: null,
+    type: [null, Boolean],
+    exclusive: ['expect-result-count'],
+    description: `
+      Tells npm whether or not to expect results from the command.
+      Can be either true (expect some results) or false (expect no results).
+    `,
+  }),
+  expires: new Definition('expires', {
+    default: null,
+    type: [null, Number],
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this sets the expiration in days. If not specified, the server
+      will determine the default expiration.
+    `,
+    flatten,
+  }),
+  'fetch-retries': new Definition('fetch-retries', {
+    default: 2,
+    type: Number,
+    description: `
+      The "retries" config for the \`retry\` module to use when fetching
+      packages from the registry.
+
+      npm will retry idempotent read requests to the registry in the case
+      of network failures or 5xx HTTP errors.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.retry = flatOptions.retry || {}
+      flatOptions.retry.retries = obj[key]
+    },
+  }),
+  'fetch-retry-factor': new Definition('fetch-retry-factor', {
+    default: 10,
+    type: Number,
+    description: `
+      The "factor" config for the \`retry\` module to use when fetching
+      packages.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.retry = flatOptions.retry || {}
+      flatOptions.retry.factor = obj[key]
+    },
+  }),
+  'fetch-retry-maxtimeout': new Definition('fetch-retry-maxtimeout', {
+    default: 60000,
+    defaultDescription: '60000 (1 minute)',
+    type: Number,
+    description: `
+      The "maxTimeout" config for the \`retry\` module to use when fetching
+      packages.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.retry = flatOptions.retry || {}
+      flatOptions.retry.maxTimeout = obj[key]
+    },
+  }),
+  'fetch-retry-mintimeout': new Definition('fetch-retry-mintimeout', {
+    default: 10000,
+    defaultDescription: '10000 (10 seconds)',
+    type: Number,
+    description: `
+      The "minTimeout" config for the \`retry\` module to use when fetching
+      packages.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.retry = flatOptions.retry || {}
+      flatOptions.retry.minTimeout = obj[key]
+    },
+  }),
+  'fetch-timeout': new Definition('fetch-timeout', {
+    default: 5 * 60 * 1000,
+    defaultDescription: `${5 * 60 * 1000} (5 minutes)`,
+    type: Number,
+    description: `
+      The maximum amount of time to wait for HTTP requests to complete.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.timeout = obj[key]
+    },
+  }),
+  force: new Definition('force', {
+    default: false,
+    type: Boolean,
+    short: 'f',
+    description: `
+      Removes various protections against unfortunate side effects, common
+      mistakes, unnecessary performance degradation, and malicious input.
+
+      * Allow clobbering non-npm files in global installs.
+      * Allow the \`npm version\` command to work on an unclean git repository.
+      * Allow deleting the cache folder with \`npm cache clean\`.
+      * Allow installing packages that have an \`engines\` declaration
+        requiring a different version of npm.
+      * Allow installing packages that have an \`engines\` declaration
+        requiring a different version of \`node\`, even if \`--engine-strict\`
+        is enabled.
+      * Allow \`npm audit fix\` to install modules outside your stated
+        dependency range (including SemVer-major changes).
+      * Allow unpublishing all versions of a published package.
+      * Allow conflicting peerDependencies to be installed in the root project.
+      * Implicitly set \`--yes\` during \`npm init\`.
+      * Allow clobbering existing values in \`npm pkg\`
+      * Allow unpublishing of entire packages (not just a single version).
+
+      If you don't have a clear idea of what you want to do, it is strongly
+      recommended that you do not use this option!
+    `,
+    flatten,
+  }),
+  'foreground-scripts': new Definition('foreground-scripts', {
+    default: false,
+    defaultDescription: `\`false\` unless when using \`npm pack\` or \`npm publish\` where it
+    defaults to \`true\``,
+    type: Boolean,
+    description: `
+      Run all build scripts (ie, \`preinstall\`, \`install\`, and
+      \`postinstall\`) scripts for installed packages in the foreground
+      process, sharing standard input, output, and error with the main npm
+      process.
+
+      Note that this will generally make installs run slower, and be much
+      noisier, but can be useful for debugging.
+    `,
+    flatten,
+  }),
+  'format-package-lock': new Definition('format-package-lock', {
+    default: true,
+    type: Boolean,
+    description: `
+      Format \`package-lock.json\` or \`npm-shrinkwrap.json\` as a human
+      readable file.
+    `,
+    flatten,
+  }),
+  fund: new Definition('fund', {
+    default: true,
+    type: Boolean,
+    description: `
+      When "true" displays the message at the end of each \`npm install\`
+      acknowledging the number of dependencies looking for funding.
+      See [\`npm fund\`](/commands/npm-fund) for details.
+    `,
+    flatten,
+  }),
+  git: new Definition('git', {
+    default: 'git',
+    type: String,
+    description: `
+      The command to use for git commands.  If git is installed on the
+      computer, but is not in the \`PATH\`, then set this to the full path to
+      the git binary.
+    `,
+    flatten,
+  }),
+  'git-tag-version': new Definition('git-tag-version', {
+    default: true,
+    type: Boolean,
+    description: `
+      Tag the commit when using the \`npm version\` command.  Setting this to
+      false results in no commit being made at all.
+    `,
+    flatten,
+  }),
+  global: new Definition('global', {
+    default: false,
+    type: Boolean,
+    short: 'g',
+    description: `
+      Operates in "global" mode, so that packages are installed into the
+      \`prefix\` folder instead of the current working directory.  See
+      [folders](/configuring-npm/folders) for more on the differences in
+      behavior.
+
+      * packages are installed into the \`{prefix}/lib/node_modules\` folder,
+        instead of the current working directory.
+      * bin files are linked to \`{prefix}/bin\`
+      * man pages are linked to \`{prefix}/share/man\`
+    `,
+    flatten: (key, obj, flatOptions) => {
+      flatten(key, obj, flatOptions)
+      if (flatOptions.global) {
+        flatOptions.location = 'global'
+      }
+    },
+  }),
+  // the globalconfig has its default defined outside of this module
+  globalconfig: new Definition('globalconfig', {
+    type: path,
+    default: '',
+    defaultDescription: `
+      The global --prefix setting plus 'etc/npmrc'. For example,
+      '/usr/local/etc/npmrc'
+    `,
+    description: `
+      The config file to read for global config options.
+    `,
+    flatten,
+  }),
+  'global-style': new Definition('global-style', {
+    default: false,
+    type: Boolean,
+    description: `
+      Only install direct dependencies in the top level \`node_modules\`,
+      but hoist on deeper dependencies.
+      Sets \`--install-strategy=shallow\`.
+    `,
+    deprecated: `
+      This option has been deprecated in favor of \`--install-strategy=shallow\`
+    `,
+    flatten (key, obj, flatOptions) {
+      if (obj[key]) {
+        obj['install-strategy'] = 'shallow'
+        flatOptions.installStrategy = 'shallow'
+      }
+    },
+  }),
+  heading: new Definition('heading', {
+    default: 'npm',
+    type: String,
+    description: `
+      The string that starts all the debugging log output.
+    `,
+    flatten,
+  }),
+  'https-proxy': new Definition('https-proxy', {
+    default: null,
+    type: [null, url],
+    description: `
+      A proxy to use for outgoing https requests. If the \`HTTPS_PROXY\` or
+      \`https_proxy\` or \`HTTP_PROXY\` or \`http_proxy\` environment variables
+      are set, proxy settings will be honored by the underlying
+      \`make-fetch-happen\` library.
+    `,
+    flatten,
+  }),
+  'if-present': new Definition('if-present', {
+    default: false,
+    type: Boolean,
+    envExport: false,
+    description: `
+      If true, npm will not exit with an error code when \`run\` is
+      invoked for a script that isn't defined in the \`scripts\` section of
+      \`package.json\`. This option can be used when it's desirable to
+      optionally run a script when it's present and fail if the script fails.
+      This is useful, for example, when running scripts that may only apply for
+      some builds in an otherwise generic CI setup.
+    `,
+    flatten,
+  }),
+  'ignore-scripts': new Definition('ignore-scripts', {
+    default: false,
+    type: Boolean,
+    description: `
+      If true, npm does not run scripts specified in package.json files.
+
+      Note that commands explicitly intended to run a particular script, such
+      as \`npm start\`, \`npm stop\`, \`npm restart\`, \`npm test\`, and \`npm
+      run\` will still run their intended script if \`ignore-scripts\` is
+      set, but they will *not* run any pre- or post-scripts.
+    `,
+    flatten,
+  }),
+  include: new Definition('include', {
+    default: [],
+    type: [Array, 'prod', 'dev', 'optional', 'peer'],
+    description: `
+      Option that allows for defining which types of dependencies to install.
+
+      This is the inverse of \`--omit=<type>\`.
+
+      Dependency types specified in \`--include\` will not be omitted,
+      regardless of the order in which omit/include are specified on the
+      command-line.
+    `,
+    flatten (key, obj, flatOptions) {
+      // just call the omit flattener, it reads from obj.include
+      definitions.omit.flatten('omit', obj, flatOptions)
+    },
+  }),
+  'include-staged': new Definition('include-staged', {
+    default: false,
+    type: Boolean,
+    description: `
+      Allow installing "staged" published packages, as defined by [npm RFC PR
+      #92](https://github.com/npm/rfcs/pull/92).
+
+      This is experimental, and not implemented by the npm public registry.
+    `,
+    flatten,
+  }),
+  'include-workspace-root': new Definition('include-workspace-root', {
+    default: false,
+    type: Boolean,
+    envExport: false,
+    description: `
+      Include the workspace root when workspaces are enabled for a command.
+
+      When false, specifying individual workspaces via the \`workspace\` config,
+      or all workspaces via the \`workspaces\` flag, will cause npm to operate only
+      on the specified workspaces, and not on the root project.
+    `,
+    flatten,
+  }),
+  'include-attestations': new Definition('include-attestations', {
+    default: false,
+    type: Boolean,
+    description: `
+      When used with \`npm audit signatures --json\`, includes the full
+      sigstore attestation bundles in the JSON output for each verified
+      package. The bundles contain DSSE envelopes, verification material,
+      and transparency log entries.
+    `,
+    flatten,
+  }),
+  'init-author-email': new Definition('init-author-email', {
+    default: '',
+    hint: '<email>',
+    type: String,
+    description: `
+      The value \`npm init\` should use by default for the package author's
+      email.
+    `,
+  }),
+  'init-author-name': new Definition('init-author-name', {
+    default: '',
+    hint: '<name>',
+    type: String,
+    description: `
+      The value \`npm init\` should use by default for the package author's name.
+    `,
+  }),
+  'init-author-url': new Definition('init-author-url', {
+    default: '',
+    type: ['', url],
+    hint: '<url>',
+    description: `
+      The value \`npm init\` should use by default for the package author's homepage.
+    `,
+  }),
+  'init-license': new Definition('init-license', {
+    default: 'ISC',
+    hint: '<license>',
+    type: String,
+    description: `
+      The value \`npm init\` should use by default for the package license.
+    `,
+  }),
+  'init-module': new Definition('init-module', {
+    default: '~/.npm-init.js',
+    type: path,
+    hint: '<module>',
+    description: `
+      A module that will be loaded by the \`npm init\` command.  See the
+      documentation for the
+      [init-package-json](https://github.com/npm/init-package-json) module for
+      more information, or [npm init](/commands/npm-init).
+    `,
+  }),
+  'init-type': new Definition('init-type', {
+    default: 'commonjs',
+    type: String,
+    hint: '<type>',
+    description: `
+      The value that \`npm init\` should use by default for the package.json type field.
+    `,
+  }),
+  'init-version': new Definition('init-version', {
+    default: '1.0.0',
+    type: Semver,
+    hint: '<version>',
+    description: `
+      The value that \`npm init\` should use by default for the package
+      version number, if not already set in package.json.
+    `,
+  }),
+  'init-private': new Definition('init-private', {
+    default: false,
+    type: Boolean,
+    description: `
+      The value \`npm init\` should use by default for the package's private flag.
+    `,
+    flatten,
+  }),
+  // these "aliases" are historically supported in .npmrc files, unfortunately
+  // They should be removed in a future npm version.
+  'init.author.email': new Definition('init.author.email', {
+    default: '',
+    type: String,
+    deprecated: `
+      Use \`--init-author-email\` instead.`,
+    description: `
+      Alias for \`--init-author-email\`
+    `,
+  }),
+  'init.author.name': new Definition('init.author.name', {
+    default: '',
+    type: String,
+    deprecated: `
+      Use \`--init-author-name\` instead.
+    `,
+    description: `
+      Alias for \`--init-author-name\`
+    `,
+  }),
+  'init.author.url': new Definition('init.author.url', {
+    default: '',
+    type: ['', url],
+    deprecated: `
+      Use \`--init-author-url\` instead.
+    `,
+    description: `
+      Alias for \`--init-author-url\`
+    `,
+  }),
+  'init.license': new Definition('init.license', {
+    default: 'ISC',
+    type: String,
+    deprecated: `
+      Use \`--init-license\` instead.
+    `,
+    description: `
+      Alias for \`--init-license\`
+    `,
+  }),
+  'init.module': new Definition('init.module', {
+    default: '~/.npm-init.js',
+    type: path,
+    deprecated: `
+      Use \`--init-module\` instead.
+    `,
+    description: `
+      Alias for \`--init-module\`
+    `,
+  }),
+  'init.version': new Definition('init.version', {
+    default: '1.0.0',
+    type: Semver,
+    deprecated: `
+      Use \`--init-version\` instead.
+    `,
+    description: `
+      Alias for \`--init-version\`
+    `,
+  }),
+  'install-links': new Definition('install-links', {
+    default: false,
+    type: Boolean,
+    description: `
+      When set file: protocol dependencies will be packed and installed as
+      regular dependencies instead of creating a symlink. This option has
+      no effect on workspaces.
+    `,
+    flatten,
+  }),
+  'install-strategy': new Definition('install-strategy', {
+    default: 'hoisted',
+    type: ['hoisted', 'nested', 'shallow', 'linked'],
+    description: `
+      Sets the strategy for installing packages in node_modules.
+      hoisted (default): Install non-duplicated in top-level, and duplicated as
+        necessary within directory structure.
+      nested: (formerly --legacy-bundling) install in place, no hoisting.
+      shallow (formerly --global-style) only install direct deps at top-level.
+      linked: (experimental) install in node_modules/.store, link in place,
+        unhoisted.
+    `,
+    flatten,
+  }),
+  json: new Definition('json', {
+    default: false,
+    type: Boolean,
+    description: `
+      Whether or not to output JSON data, rather than the normal output.
+
+      * In \`npm pkg set\` it enables parsing set values with JSON.parse()
+      before saving them to your \`package.json\`.
+
+      Not supported by all npm commands.
+    `,
+    flatten,
+  }),
+  key: new Definition('key', {
+    default: null,
+    type: [null, String],
+    description: `
+      A client key to pass when accessing the registry.  Values should be in
+      PEM format with newlines replaced by the string "\\n". For example:
+
+      \`\`\`ini
+      key="-----BEGIN PRIVATE KEY-----\\nXXXX\\nXXXX\\n-----END PRIVATE KEY-----"
+      \`\`\`
+
+      It is _not_ the path to a key file, though you can set a registry-scoped
+      "keyfile" path like "//other-registry.tld/:keyfile=/path/to/key.pem".
+    `,
+    deprecated: `
+      \`key\` and \`cert\` are no longer used for most registry operations.
+      Use registry scoped \`keyfile\` and \`certfile\` instead.
+      Example:
+      //other-registry.tld/:keyfile=/path/to/key.pem
+      //other-registry.tld/:certfile=/path/to/cert.crt
+    `,
+    flatten,
+  }),
+  'legacy-bundling': new Definition('legacy-bundling', {
+    default: false,
+    type: Boolean,
+    description: `
+      Instead of hoisting package installs in \`node_modules\`, install packages
+      in the same manner that they are depended on. This may cause very deep
+      directory structures and duplicate package installs as there is no
+      de-duplicating.
+      Sets \`--install-strategy=nested\`.
+    `,
+    deprecated: `
+      This option has been deprecated in favor of \`--install-strategy=nested\`
+    `,
+    flatten (key, obj, flatOptions) {
+      if (obj[key]) {
+        obj['install-strategy'] = 'nested'
+        flatOptions.installStrategy = 'nested'
+      }
+    },
+  }),
+  'legacy-peer-deps': new Definition('legacy-peer-deps', {
+    default: false,
+    type: Boolean,
+    description: `
+      Causes npm to completely ignore \`peerDependencies\` when building a
+      package tree, as in npm versions 3 through 6.
+
+      If a package cannot be installed because of overly strict
+      \`peerDependencies\` that collide, it provides a way to move forward
+      resolving the situation.
+
+      This differs from \`--omit=peer\`, in that \`--omit=peer\` will avoid
+      unpacking \`peerDependencies\` on disk, but will still design a tree such
+      that \`peerDependencies\` _could_ be unpacked in a correct place.
+
+      Use of \`legacy-peer-deps\` is not recommended, as it will not enforce
+      the \`peerDependencies\` contract that meta-dependencies may rely on.
+    `,
+    flatten,
+  }),
+  libc: new Definition('libc', {
+    default: null,
+    type: [null, String],
+    description: `
+      Override libc of native modules to install.
+      Acceptable values are same as \`libc\` field of package.json
+    `,
+    flatten,
+  }),
+  link: new Definition('link', {
+    default: false,
+    type: Boolean,
+    description: `
+      Used with \`npm ls\`, limiting output to only those packages that are
+      linked.
+    `,
+  }),
+  'local-address': new Definition('local-address', {
+    default: null,
+    type: getLocalAddresses(),
+    typeDescription: 'IP Address',
+    description: `
+      The IP address of the local interface to use when making connections to
+      the npm registry.  Must be IPv4 in versions of Node prior to 0.12.
+    `,
+    flatten,
+  }),
+  location: new Definition('location', {
+    default: 'user',
+    short: 'L',
+    type: [
+      'global',
+      'user',
+      'project',
+    ],
+    defaultDescription: `
+      "user" unless \`--global\` is passed, which will also set this value to "global"
+    `,
+    description: `
+      When passed to \`npm config\` this refers to which config file to use.
+
+      When set to "global" mode, packages are installed into the \`prefix\` folder
+      instead of the current working directory. See
+      [folders](/configuring-npm/folders) for more on the differences in behavior.
+
+      * packages are installed into the \`{prefix}/lib/node_modules\` folder,
+        instead of the current working directory.
+      * bin files are linked to \`{prefix}/bin\`
+      * man pages are linked to \`{prefix}/share/man\`
+    `,
+    flatten: (key, obj, flatOptions) => {
+      flatten(key, obj, flatOptions)
+      if (flatOptions.global) {
+        flatOptions.location = 'global'
+      }
+      if (obj.location === 'global') {
+        flatOptions.global = true
+      }
+    },
+  }),
+  'lockfile-version': new Definition('lockfile-version', {
+    default: null,
+    type: [null, 1, 2, 3, '1', '2', '3'],
+    defaultDescription: `
+      Version 3 if no lockfile, auto-converting v1 lockfiles to v3; otherwise,
+      maintain current lockfile version.`,
+    description: `
+      Set the lockfile format version to be used in package-lock.json and
+      npm-shrinkwrap-json files.  Possible options are:
+
+      1: The lockfile version used by npm versions 5 and 6.  Lacks some data that
+      is used during the install, resulting in slower and possibly less
+      deterministic installs.  Prevents lockfile churn when interoperating with
+      older npm versions.
+
+      2: The default lockfile version used by npm version 7 and 8.  Includes both
+      the version 1 lockfile data and version 3 lockfile data, for maximum
+      determinism and interoperability, at the expense of more bytes on disk.
+
+      3: Only the new lockfile information introduced in npm version 7.  Smaller
+      on disk than lockfile version 2, but not interoperable with older npm
+      versions.  Ideal if all users are on npm version 7 and higher.
+    `,
+    flatten: (key, obj, flatOptions) => {
+      flatOptions.lockfileVersion = obj[key] && parseInt(obj[key], 10)
+    },
+  }),
+  loglevel: new Definition('loglevel', {
+    default: 'notice',
+    type: [
+      'silent',
+      'error',
+      'warn',
+      'notice',
+      'http',
+      'info',
+      'verbose',
+      'silly',
+    ],
+    description: `
+      What level of logs to report.  All logs are written to a debug log,
+      with the path to that file printed if the execution of a command fails.
+
+      Any logs of a higher level than the setting are shown. The default is
+      "notice".
+
+      See also the \`foreground-scripts\` config.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.silent = obj[key] === 'silent'
+    },
+  }),
+  'logs-dir': new Definition('logs-dir', {
+    default: null,
+    type: [null, path],
+    defaultDescription: `
+      A directory named \`_logs\` inside the cache
+  `,
+    description: `
+      The location of npm's log directory.  See [\`npm
+      logging\`](/using-npm/logging) for more information.
+    `,
+  }),
+  'logs-max': new Definition('logs-max', {
+    default: 10,
+    type: Number,
+    description: `
+      The maximum number of log files to store.
+
+      If set to 0, no log files will be written for the current run.
+    `,
+  }),
+  long: new Definition('long', {
+    default: false,
+    type: Boolean,
+    short: 'l',
+    description: `
+      Show extended information in \`ls\`, \`search\`, and \`help-search\`.
+    `,
+  }),
+  name: new Definition('name', {
+    default: null,
+    type: [null, String],
+    hint: '<name>',
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this sets the name/description for the token.
+    `,
+    flatten,
+  }),
+  maxsockets: new Definition('maxsockets', {
+    default: 15,
+    type: Number,
+    description: `
+      The maximum number of connections to use per origin (protocol/host/port
+      combination).
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.maxSockets = obj[key]
+    },
+  }),
+  message: new Definition('message', {
+    default: '%s',
+    type: String,
+    short: 'm',
+    description: `
+      Commit message which is used by \`npm version\` when creating version commit.
+
+      Any "%s" in the message will be replaced with the version number.
+    `,
+    flatten,
+  }),
+  'min-release-age': new Definition('min-release-age', {
+    default: null,
+    hint: '<days>',
+    type: [null, Number],
+    exclusive: ['before'],
+    envExport: false,
+    description: `
+       If set, npm will build the npm tree such that only versions that were
+       available more than the given number of days ago will be installed.  If
+       there are no versions available for the current set of dependencies, the
+       command will error.
+
+       This flag is a complement to \`before\`, which accepts an exact date
+       instead of a relative number of days.
+    `,
+    flatten: (key, obj, flatOptions) => {
+      if (obj['min-release-age'] !== null) {
+        flatOptions.before = new Date(Date.now() - (86400000 * obj['min-release-age']))
+        obj.before = flatOptions.before
+        delete obj['min-release-age']
+      }
+    },
+  }),
+  'node-gyp': new Definition('node-gyp', {
+    default: (() => {
+      try {
+        return require.resolve('node-gyp/bin/node-gyp.js')
+      } catch {
+        return ''
+      }
+    })(),
+    defaultDescription: `
+      The path to the node-gyp bin that ships with npm
+    `,
+    type: path,
+    description: `
+      This is the location of the "node-gyp" bin.  By default it uses one that ships with npm itself.
+
+      You can use this config to specify your own "node-gyp" to run when it is required to build a package.
+    `,
+    flatten,
+  }),
+  'node-options': new Definition('node-options', {
+    default: null,
+    type: [null, String],
+    description: `
+      Options to pass through to Node.js via the \`NODE_OPTIONS\` environment
+      variable.  This does not impact how npm itself is executed but it does
+      impact how lifecycle scripts are called.
+    `,
+  }),
+  noproxy: new Definition('noproxy', {
+    default: '',
+    defaultDescription: `
+      The value of the NO_PROXY environment variable
+    `,
+    type: [String, Array],
+    description: `
+      Domain extensions that should bypass any proxies.
+
+      Also accepts a comma-delimited string.
+    `,
+    flatten (key, obj, flatOptions) {
+      if (Array.isArray(obj[key])) {
+        flatOptions.noProxy = obj[key].join(',')
+      } else {
+        flatOptions.noProxy = obj[key]
+      }
+    },
+  }),
+  offline: new Definition('offline', {
+    default: false,
+    type: Boolean,
+    description: `
+      Force offline mode: no network requests will be done during install. To allow
+      the CLI to fill in missing cache data, see \`--prefer-offline\`.
+    `,
+    flatten,
+  }),
+  omit: new Definition('omit', {
+    default: process.env.NODE_ENV === 'production' ? ['dev'] : [],
+    defaultDescription: `
+      'dev' if the \`NODE_ENV\` environment variable is set to 'production';
+      otherwise, empty.
+    `,
+    type: [Array, 'dev', 'optional', 'peer'],
+    description: `
+      Dependency types to omit from the installation tree on disk.
+
+      Note that these dependencies _are_ still resolved and added to the
+      \`package-lock.json\` or \`npm-shrinkwrap.json\` file.  They are just
+      not physically installed on disk.
+
+      If a package type appears in both the \`--include\` and \`--omit\`
+      lists, then it will be included.
+
+      If the resulting omit list includes \`'dev'\`, then the \`NODE_ENV\`
+      environment variable will be set to \`'production'\` for all lifecycle
+      scripts.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.omit = buildOmitList(obj)
+    },
+  }),
+  'omit-lockfile-registry-resolved': new Definition('omit-lockfile-registry-resolved', {
+    default: false,
+    type: Boolean,
+    description: `
+      This option causes npm to create lock files without a \`resolved\` key for
+      registry dependencies. Subsequent installs will need to resolve tarball
+      endpoints with the configured registry, likely resulting in a longer install
+      time.
+    `,
+    flatten,
+  }),
+  only: new Definition('only', {
+    default: null,
+    type: [null, 'prod', 'production'],
+    deprecated: `
+      Use \`--omit=dev\` to omit dev dependencies from the install.
+    `,
+    description: `
+      When set to \`prod\` or \`production\`, this is an alias for
+      \`--omit=dev\`.
+    `,
+    flatten (key, obj, flatOptions) {
+      definitions.omit.flatten('omit', obj, flatOptions)
+    },
+  }),
+  orgs: new Definition('orgs', {
+    default: null,
+    type: [null, String, Array],
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this limits the token access to specific organizations.
+    `,
+    flatten,
+  }),
+  optional: new Definition('optional', {
+    default: null,
+    type: [null, Boolean],
+    deprecated: `
+      Use \`--omit=optional\` to exclude optional dependencies, or
+      \`--include=optional\` to include them.
+
+      Default value does install optional deps unless otherwise omitted.
+    `,
+    description: `
+      Alias for --include=optional or --omit=optional
+    `,
+    flatten (key, obj, flatOptions) {
+      definitions.omit.flatten('omit', obj, flatOptions)
+    },
+  }),
+  os: new Definition('os', {
+    default: null,
+    type: [null, String],
+    description: `
+      Override OS of native modules to install.
+      Acceptable values are same as \`os\` field of package.json,
+      which comes from \`process.platform\`.
+    `,
+    flatten,
+  }),
+  otp: new Definition('otp', {
+    default: null,
+    type: [null, String],
+    description: `
+      This is a one-time password from a two-factor authenticator.  It's needed
+      when publishing or changing package permissions with \`npm access\`.
+
+      If not set, and a registry response fails with a challenge for a one-time
+      password, npm will prompt on the command line for one.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatten(key, obj, flatOptions)
+      if (obj.otp) {
+        obj['auth-type'] = 'legacy'
+        flatten('auth-type', obj, flatOptions)
+      }
+    },
+  }),
+  package: new Definition('package', {
+    default: [],
+    hint: '<package-spec>',
+    type: [String, Array],
+    description: `
+      The package or packages to install for [\`npm exec\`](/commands/npm-exec)
+    `,
+    flatten,
+  }),
+  'package-lock': new Definition('package-lock', {
+    default: true,
+    type: Boolean,
+    description: `
+      If set to false, then ignore \`package-lock.json\` files when installing.
+      This will also prevent _writing_ \`package-lock.json\` if \`save\` is
+      true.
+    `,
+    flatten: (key, obj, flatOptions) => {
+      flatten(key, obj, flatOptions)
+      if (flatOptions.packageLockOnly) {
+        flatOptions.packageLock = true
+      }
+    },
+  }),
+  'package-lock-only': new Definition('package-lock-only', {
+    default: false,
+    type: Boolean,
+    description: `
+      If set to true, the current operation will only use the \`package-lock.json\`,
+      ignoring \`node_modules\`.
+
+      For \`update\` this means only the \`package-lock.json\` will be updated,
+      instead of checking \`node_modules\` and downloading dependencies.
+
+      For \`list\` this means the output will be based on the tree described by the
+      \`package-lock.json\`, rather than the contents of \`node_modules\`.
+    `,
+    flatten: (key, obj, flatOptions) => {
+      flatten(key, obj, flatOptions)
+      if (flatOptions.packageLockOnly) {
+        flatOptions.packageLock = true
+      }
+    },
+  }),
+  'pack-destination': new Definition('pack-destination', {
+    default: '.',
+    type: String,
+    description: `
+      Directory in which \`npm pack\` will save tarballs.
+    `,
+    flatten,
+  }),
+  packages: new Definition('packages', {
+    default: [],
+    type: [null, String, Array],
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this limits the token access to specific packages.
+    `,
+    flatten,
+  }),
+  parseable: new Definition('parseable', {
+    default: false,
+    type: Boolean,
+    short: 'p',
+    description: `
+      Output parseable results from commands that write to standard output. For
+      \`npm search\`, this will be tab-separated table format.
+    `,
+    flatten,
+  }),
+  'prefer-dedupe': new Definition('prefer-dedupe', {
+    default: false,
+    type: Boolean,
+    description: `
+      Prefer to deduplicate packages if possible, rather than
+      choosing a newer version of a dependency.
+    `,
+    flatten,
+  }),
+  'prefer-offline': new Definition('prefer-offline', {
+    default: false,
+    type: Boolean,
+    description: `
+      If true, staleness checks for cached data will be bypassed, but missing
+      data will be requested from the server. To force full offline mode, use
+      \`--offline\`.
+    `,
+    flatten,
+  }),
+  'prefer-online': new Definition('prefer-online', {
+    default: false,
+    type: Boolean,
+    description: `
+      If true, staleness checks for cached data will be forced, making the CLI
+      look for updates immediately even for fresh package data.
+    `,
+    flatten,
+  }),
+  // `prefix` has its default defined outside of this module
+  prefix: new Definition('prefix', {
+    type: path,
+    short: 'C',
+    default: '',
+    defaultDescription: `
+      In global mode, the folder where the node executable is installed.
+      Otherwise, the nearest parent folder containing either a package.json
+      file or a node_modules folder.
+    `,
+    description: `
+      The location to install global items.  If set on the command line, then
+      it forces non-global commands to run in the specified folder.
+    `,
+  }),
+  preid: new Definition('preid', {
+    default: '',
+    hint: 'prerelease-id',
+    type: String,
+    description: `
+      The "prerelease identifier" to use as a prefix for the "prerelease" part
+      of a semver. Like the \`rc\` in \`1.2.0-rc.8\`.
+    `,
+    flatten,
+  }),
+  production: new Definition('production', {
+    default: null,
+    type: [null, Boolean],
+    deprecated: 'Use `--omit=dev` instead.',
+    description: 'Alias for `--omit=dev`',
+    flatten (key, obj, flatOptions) {
+      definitions.omit.flatten('omit', obj, flatOptions)
+    },
+  }),
+  progress: new Definition('progress', {
+    default: !(ciInfo.isCI || !process.stderr.isTTY || !process.stdout.isTTY || process.env.TERM === 'dumb'),
+    defaultDescription: `
+      \`true\` when not in CI and both stderr and stdout are TTYs and not in a dumb terminal
+    `,
+    type: Boolean,
+    description: `
+      When set to \`true\`, npm will display a progress bar during time
+      intensive operations, if \`process.stderr\` and \`process.stdout\` are a TTY.
+
+      Set to \`false\` to suppress the progress bar.
+    `,
+    flatten (key, obj, flatOptions) {
+      // Only show progress if explicitly enabled AND we have proper TTY environment
+      flatOptions.progress = !!obj.progress && !!process.stderr.isTTY && !!process.stdout.isTTY && process.env.TERM !== 'dumb'
+    },
+  }),
+  provenance: new Definition('provenance', {
+    default: false,
+    type: Boolean,
+    exclusive: ['provenance-file'],
+    description: `
+      When publishing from a supported cloud CI/CD system, the package will be
+      publicly linked to where it was built and published from.
+    `,
+    flatten,
+  }),
+  'provenance-file': new Definition('provenance-file', {
+    default: null,
+    type: path,
+    hint: '<file>',
+    exclusive: ['provenance'],
+    description: `
+      When publishing, the provenance bundle at the given path will be used.
+    `,
+    flatten,
+  }),
+  proxy: new Definition('proxy', {
+    default: null,
+    type: [null, false, url], // allow proxy to be disabled explicitly
+    description: `
+      A proxy to use for outgoing http requests. If the \`HTTP_PROXY\` or
+      \`http_proxy\` environment variables are set, proxy settings will be
+      honored by the underlying \`request\` library.
+    `,
+    flatten,
+  }),
+  'read-only': new Definition('read-only', {
+    default: false,
+    type: Boolean,
+    description: `
+      This is used to mark a token as unable to publish when configuring
+      limited access tokens with the \`npm token create\` command.
+    `,
+    flatten,
+  }),
+  'rebuild-bundle': new Definition('rebuild-bundle', {
+    default: true,
+    type: Boolean,
+    description: `
+      Rebuild bundled dependencies after installation.
+    `,
+    flatten,
+  }),
+  registry: new Definition('registry', {
+    default: 'https://registry.npmjs.org/',
+    type: url,
+    description: `
+      The base URL of the npm registry.
+    `,
+    flatten,
+  }),
+  'replace-registry-host': new Definition('replace-registry-host', {
+    default: 'npmjs',
+    hint: '<npmjs|never|always> | hostname',
+    type: ['npmjs', 'never', 'always', String],
+    description: `
+      Defines behavior for replacing the registry host in a lockfile with the
+      configured registry.
+
+      The default behavior is to replace package dist URLs from the default
+      registry (https://registry.npmjs.org) to the configured registry. If set to
+      "never", then use the registry value. If set to "always", then replace the
+      registry host with the configured host every time.
+
+      You may also specify a bare hostname (e.g., "registry.npmjs.org").
+    `,
+    flatten,
+  }),
+  save: new Definition('save', {
+    default: true,
+    defaultDescription: `\`true\` unless when using \`npm update\` where it
+    defaults to \`false\``,
+    usage: '-S|--save|--no-save|--save-prod|--save-dev|--save-optional|--save-peer|--save-bundle',
+    type: Boolean,
+    short: 'S',
+    description: `
+      Save installed packages to a \`package.json\` file as dependencies.
+
+      When used with the \`npm rm\` command, removes the dependency from
+      \`package.json\`.
+
+      Will also prevent writing to \`package-lock.json\` if set to \`false\`.
+    `,
+    flatten,
+  }),
+  'save-bundle': new Definition('save-bundle', {
+    default: false,
+    type: Boolean,
+    short: 'B',
+    description: `
+      If a package would be saved at install time by the use of \`--save\`,
+      \`--save-dev\`, or \`--save-optional\`, then also put it in the
+      \`bundleDependencies\` list.
+
+      Ignored if \`--save-peer\` is set, since peerDependencies cannot be bundled.
+    `,
+    flatten (key, obj, flatOptions) {
+      // XXX update arborist to just ignore it if resulting saveType is peer
+      // otherwise this won't have the expected effect:
+      //
+      // npm config set save-peer true
+      // npm i foo --save-bundle --save-prod <-- should bundle
+      flatOptions.saveBundle = obj['save-bundle'] && !obj['save-peer']
+    },
+  }),
+  'save-dev': new Definition('save-dev', {
+    default: false,
+    type: Boolean,
+    short: 'D',
+    exclusive: ['save-optional', 'save-peer', 'save-prod'],
+    description: `
+      Save installed packages to a package.json file as \`devDependencies\`.
+    `,
+    flatten (key, obj, flatOptions) {
+      if (!obj[key]) {
+        if (flatOptions.saveType === 'dev') {
+          delete flatOptions.saveType
+        }
+        return
+      }
+
+      flatOptions.saveType = 'dev'
+    },
+  }),
+  'save-exact': new Definition('save-exact', {
+    default: false,
+    type: Boolean,
+    short: 'E',
+    description: `
+      Dependencies saved to package.json will be configured with an exact
+      version rather than using npm's default semver range operator.
+    `,
+    flatten (key, obj, flatOptions) {
+      // just call the save-prefix flattener, it reads from obj['save-exact']
+      definitions['save-prefix'].flatten('save-prefix', obj, flatOptions)
+    },
+  }),
+  'save-optional': new Definition('save-optional', {
+    default: false,
+    type: Boolean,
+    short: 'O',
+    exclusive: ['save-dev', 'save-peer', 'save-prod'],
+    description: `
+      Save installed packages to a package.json file as
+      \`optionalDependencies\`.
+    `,
+    flatten (key, obj, flatOptions) {
+      if (!obj[key]) {
+        if (flatOptions.saveType === 'optional') {
+          delete flatOptions.saveType
+        } else if (flatOptions.saveType === 'peerOptional') {
+          flatOptions.saveType = 'peer'
+        }
+        return
+      }
+
+      if (flatOptions.saveType === 'peerOptional') {
+        return
+      }
+
+      if (flatOptions.saveType === 'peer') {
+        flatOptions.saveType = 'peerOptional'
+      } else {
+        flatOptions.saveType = 'optional'
+      }
+    },
+  }),
+  'save-peer': new Definition('save-peer', {
+    default: false,
+    type: Boolean,
+    exclusive: ['save-dev', 'save-optional', 'save-prod'],
+    description: `
+      Save installed packages to a package.json file as \`peerDependencies\`
+    `,
+    flatten (key, obj, flatOptions) {
+      if (!obj[key]) {
+        if (flatOptions.saveType === 'peer') {
+          delete flatOptions.saveType
+        } else if (flatOptions.saveType === 'peerOptional') {
+          flatOptions.saveType = 'optional'
+        }
+        return
+      }
+
+      if (flatOptions.saveType === 'peerOptional') {
+        return
+      }
+
+      if (flatOptions.saveType === 'optional') {
+        flatOptions.saveType = 'peerOptional'
+      } else {
+        flatOptions.saveType = 'peer'
+      }
+    },
+  }),
+  'save-prefix': new Definition('save-prefix', {
+    default: '^',
+    type: String,
+    description: `
+      Configure how versions of packages installed to a package.json file via
+      \`--save\` or \`--save-dev\` get prefixed.
+
+      For example if a package has version \`1.2.3\`, by default its version is
+      set to \`^1.2.3\` which allows minor upgrades for that package, but after
+      \`npm config set save-prefix='~'\` it would be set to \`~1.2.3\` which
+      only allows patch upgrades.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.savePrefix = obj['save-exact'] ? '' : obj['save-prefix']
+      obj['save-prefix'] = flatOptions.savePrefix
+    },
+  }),
+  'save-prod': new Definition('save-prod', {
+    default: false,
+    type: Boolean,
+    short: 'P',
+    exclusive: ['save-dev', 'save-optional', 'save-peer'],
+    description: `
+      Save installed packages into \`dependencies\` specifically. This is
+      useful if a package already exists in \`devDependencies\` or
+      \`optionalDependencies\`, but you want to move it to be a non-optional
+      production dependency.
+
+      This is the default behavior if \`--save\` is true, and neither
+      \`--save-dev\` or \`--save-optional\` are true.
+    `,
+    flatten (key, obj, flatOptions) {
+      if (!obj[key]) {
+        if (flatOptions.saveType === 'prod') {
+          delete flatOptions.saveType
+        }
+        return
+      }
+
+      flatOptions.saveType = 'prod'
+    },
+  }),
+  'sbom-format': new Definition('sbom-format', {
+    default: null,
+    type: [
+      'cyclonedx',
+      'spdx',
+    ],
+    description: `
+      SBOM format to use when generating SBOMs.
+    `,
+    flatten,
+  }),
+  'sbom-type': new Definition('sbom-type', {
+    default: 'library',
+    type: [
+      'library',
+      'application',
+      'framework',
+    ],
+    description: `
+      The type of package described by the generated SBOM. For SPDX, this is the
+      value for the \`primaryPackagePurpose\` field. For CycloneDX, this is the
+      value for the \`type\` field.
+    `,
+    flatten,
+  }),
+  scope: new Definition('scope', {
+    default: '',
+    defaultDescription: `
+      the scope of the current project, if any, or ""
+    `,
+    type: String,
+    hint: '<@scope>',
+    description: `
+      Associate an operation with a scope for a scoped registry.
+
+      Useful when logging in to or out of a private registry:
+
+      \`\`\`
+      # log in, linking the scope to the custom registry
+      npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+      # log out, removing the link and the auth token
+      npm logout --scope=@mycorp
+      \`\`\`
+
+      This will cause \`@mycorp\` to be mapped to the registry for future
+      installation of packages specified according to the pattern
+      \`@mycorp/package\`.
+
+      This will also cause \`npm init\` to create a scoped package.
+
+      \`\`\`
+      # accept all defaults, and create a package named "@foo/whatever",
+      # instead of just named "whatever"
+      npm init --scope=@foo --yes
+      \`\`\`
+    `,
+    flatten (key, obj, flatOptions) {
+      const value = obj[key]
+      const scope = value && !/^@/.test(value) ? `@${value}` : value
+      flatOptions.scope = scope
+      // projectScope is kept for compatibility with npm-registry-fetch
+      flatOptions.projectScope = scope
+    },
+  }),
+  scopes: new Definition('scopes', {
+    default: null,
+    type: [null, String, Array],
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this limits the token access to specific scopes. Provide
+      a scope name (with or without @ prefix).
+    `,
+    flatten,
+  }),
+  'packages-all': new Definition('packages-all', {
+    default: false,
+    type: Boolean,
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      grants the token access to all packages instead of limiting to
+      specific packages.
+    `,
+    flatten,
+  }),
+  'packages-and-scopes-permission': new Definition('packages-and-scopes-permission', {
+    default: null,
+    type: [null, 'read-only', 'read-write', 'no-access'],
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      sets the permission level for packages and scopes. Options are
+      "read-only", "read-write", or "no-access".
+    `,
+    flatten,
+  }),
+  'orgs-permission': new Definition('orgs-permission', {
+    default: null,
+    type: [null, 'read-only', 'read-write', 'no-access'],
+    description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      sets the permission level for organizations. Options are
+      "read-only", "read-write", or "no-access".
+    `,
+    flatten,
+  }),
+  password: new Definition('password', {
+    default: null,
+    type: [null, String],
+    description: `
+      Password for authentication. Can be provided via command line when
+      creating tokens, though it's generally safer to be prompted for it.
+    `,
+    flatten,
+  }),
+  'token-description': new Definition('token-description', {
+    default: null,
+    type: [null, String],
+    description: `
+      Description text for the token when using \`npm token create\`.
+    `,
+    flatten,
+  }),
+  'script-shell': new Definition('script-shell', {
+    default: null,
+    defaultDescription: `
+      '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+    `,
+    type: [null, String],
+    description: `
+      The shell to use for scripts run with the \`npm exec\`,
+      \`npm run\` and \`npm init <package-spec>\` commands.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.scriptShell = obj[key] || undefined
+    },
+  }),
+  searchexclude: new Definition('searchexclude', {
+    default: '',
+    type: String,
+    description: `
+      Space-separated options that limit the results from search.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.search = flatOptions.search || { limit: 20 }
+      flatOptions.search.exclude = obj[key].toLowerCase()
+    },
+  }),
+  searchlimit: new Definition('searchlimit', {
+    default: 20,
+    type: Number,
+    description: `
+      Number of items to limit search results to. Will not apply at all to
+      legacy searches.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.search = flatOptions.search || {}
+      flatOptions.search.limit = obj[key]
+    },
+  }),
+  searchopts: new Definition('searchopts', {
+    default: '',
+    type: String,
+    description: `
+      Space-separated options that are always passed to search.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.search = flatOptions.search || { limit: 20 }
+      flatOptions.search.opts = querystring.parse(obj[key])
+    },
+  }),
+  searchstaleness: new Definition('searchstaleness', {
+    default: 15 * 60,
+    type: Number,
+    description: `
+      The age of the cache, in seconds, before another registry request is made
+      if using legacy search endpoint.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.search = flatOptions.search || { limit: 20 }
+      flatOptions.search.staleness = obj[key]
+    },
+  }),
+  shell: new Definition('shell', {
+    default: shell,
+    defaultDescription: `
+      SHELL environment variable, or "bash" on Posix, or "cmd.exe" on Windows
+    `,
+    type: String,
+    description: `
+      The shell to run for the \`npm explore\` command.
+    `,
+    flatten,
+  }),
+  shrinkwrap: new Definition('shrinkwrap', {
+    default: true,
+    type: Boolean,
+    deprecated: `
+      Use the --package-lock setting instead.
+    `,
+    description: `
+      Alias for --package-lock
+    `,
+    flatten (key, obj, flatOptions) {
+      obj['package-lock'] = obj.shrinkwrap
+      definitions['package-lock'].flatten('package-lock', obj, flatOptions)
+    },
+  }),
+  'sign-git-commit': new Definition('sign-git-commit', {
+    default: false,
+    type: Boolean,
+    description: `
+      If set to true, then the \`npm version\` command will commit the new
+      package version using \`-S\` to add a signature.
+
+      Note that git requires you to have set up GPG keys in your git configs
+      for this to work properly.
+    `,
+    flatten,
+  }),
+  'sign-git-tag': new Definition('sign-git-tag', {
+    default: false,
+    type: Boolean,
+    description: `
+      If set to true, then the \`npm version\` command will tag the version
+      using \`-s\` to add a signature.
+
+      Note that git requires you to have set up GPG keys in your git configs
+      for this to work properly.
+    `,
+    flatten,
+  }),
+  'strict-peer-deps': new Definition('strict-peer-deps', {
+    default: false,
+    type: Boolean,
+    description: `
+      If set to \`true\`, and \`--legacy-peer-deps\` is not set, then _any_
+      conflicting \`peerDependencies\` will be treated as an install failure,
+      even if npm could reasonably guess the appropriate resolution based on
+      non-peer dependency relationships.
+
+      By default, conflicting \`peerDependencies\` deep in the dependency graph
+      will be resolved using the nearest non-peer dependency specification,
+      even if doing so will result in some packages receiving a peer dependency
+      outside the range set in their package's \`peerDependencies\` object.
+
+      When such an override is performed, a warning is printed, explaining the
+      conflict and the packages involved.  If \`--strict-peer-deps\` is set,
+      then this warning is treated as a failure.
+    `,
+    flatten,
+  }),
+  'strict-ssl': new Definition('strict-ssl', {
+    default: true,
+    type: Boolean,
+    description: `
+      Whether or not to do SSL key validation when making requests to the
+      registry via https.
+
+      See also the \`ca\` config.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.strictSSL = obj[key]
+    },
+  }),
+  tag: new Definition('tag', {
+    default: 'latest',
+    type: String,
+    description: `
+      If you ask npm to install a package and don't tell it a specific version,
+      then it will install the specified tag.
+
+      It is the tag added to the package@version specified in the
+      \`npm dist-tag add\` command, if no explicit tag is given.
+
+      When used by the \`npm diff\` command, this is the tag used to fetch the
+      tarball that will be compared with the local files by default.
+
+      If used in the \`npm publish\` command, this is the tag that will be
+      added to the package submitted to the registry.
+    `,
+    flatten (key, obj, flatOptions) {
+      flatOptions.defaultTag = obj[key]
+    },
+  }),
+  'tag-version-prefix': new Definition('tag-version-prefix', {
+    default: 'v',
+    type: String,
+    description: `
+      If set, alters the prefix used when tagging a new version when performing
+      a version increment using  \`npm version\`. To remove the prefix
+      altogether, set it to the empty string: \`""\`.
+
+      Because other tools may rely on the convention that npm version tags look
+      like \`v1.0.0\`, _only use this property if it is absolutely necessary_.
+      In particular, use care when overriding this setting for public packages.
+    `,
+    flatten,
+  }),
+  timing: new Definition('timing', {
+    default: false,
+    type: Boolean,
+    description: `
+      If true, writes timing information to a process specific json file in
+      the cache or \`logs-dir\`. The file name ends with \`-timing.json\`.
+
+      You can quickly view it with this [json](https://npm.im/json) command
+      line: \`cat ~/.npm/_logs/*-timing.json | npm exec -- json -g\`.
+
+      Timing information will also be reported in the terminal. To suppress this
+      while still writing the timing file, use \`--silent\`.
+    `,
+  }),
+  umask: new Definition('umask', {
+    default: 0,
+    type: Umask,
+    description: `
+      The "umask" value to use when setting the file creation mode on files and
+      folders.
+
+      Folders and executables are given a mode which is \`0o777\` masked
+      against this value.  Other files are given a mode which is \`0o666\`
+      masked against this value.
+
+      Note that the underlying system will _also_ apply its own umask value to
+      files and folders that are created, and npm does not circumvent this, but
+      rather adds the \`--umask\` config to it.
+
+      Thus, the effective default umask value on most POSIX systems is 0o22,
+      meaning that folders and executables are created with a mode of 0o755 and
+      other files are created with a mode of 0o644.
+    `,
+    flatten,
+  }),
+  unicode: new Definition('unicode', {
+    default: unicode,
+    defaultDescription: `
+      false on windows, true on mac/unix systems with a unicode locale, as
+      defined by the \`LC_ALL\`, \`LC_CTYPE\`, or \`LANG\` environment variables.
+    `,
+    type: Boolean,
+    description: `
+      When set to true, npm uses unicode characters in the tree output.  When
+      false, it uses ascii characters instead of unicode glyphs.
+    `,
+    flatten,
+  }),
+  'update-notifier': new Definition('update-notifier', {
+    default: true,
+    type: Boolean,
+    description: `
+      Set to false to suppress the update notification when using an older
+      version of npm than the latest.
+    `,
+  }),
+  usage: new Definition('usage', {
+    default: false,
+    type: Boolean,
+    short: ['?', 'H', 'h'],
+    description: `
+      Show short usage output about the command specified.
+    `,
+  }),
+  'user-agent': new Definition('user-agent', {
+    default: 'npm/{npm-version} ' +
+            'node/{node-version} ' +
+            '{platform} ' +
+            '{arch} ' +
+            'workspaces/{workspaces} ' +
+            '{ci}',
+    type: String,
+    description: `
+      Sets the User-Agent request header.  The following fields are replaced
+      with their actual counterparts:
+
+      * \`{npm-version}\` - The npm version in use
+      * \`{node-version}\` - The Node.js version in use
+      * \`{platform}\` - The value of \`process.platform\`
+      * \`{arch}\` - The value of \`process.arch\`
+      * \`{workspaces}\` - Set to \`true\` if the \`workspaces\` or \`workspace\`
+        options are set.
+      * \`{ci}\` - The value of the \`ci-name\` config, if set, prefixed with
+        \`ci/\`, or an empty string if \`ci-name\` is empty.
+    `,
+    flatten (key, obj, flatOptions) {
+      const value = obj[key]
+      const ciName = ciInfo.name?.toLowerCase().split(' ').join('-') || null
+      let inWorkspaces = false
+      if (obj.workspaces || obj.workspace && obj.workspace.length) {
+        inWorkspaces = true
+      }
+      flatOptions.userAgent =
+        value.replace(/\{node-version\}/gi, process.version)
+          .replace(/\{npm-version\}/gi, obj['npm-version'])
+          .replace(/\{platform\}/gi, process.platform)
+          .replace(/\{arch\}/gi, process.arch)
+          .replace(/\{workspaces\}/gi, inWorkspaces)
+          .replace(/\{ci\}/gi, ciName ? `ci/${ciName}` : '')
+          .trim()
+
+      // We can't clobber the original or else subsequent flattening will fail
+      // (i.e. when we change the underlying config values)
+      // obj[key] = flatOptions.userAgent
+
+      // user-agent is a unique kind of config item that gets set from a template
+      // and ends up translated.  Because of this, the normal "should we set this
+      // to process.env also doesn't work
+      process.env.npm_config_user_agent = flatOptions.userAgent
+    },
+  }),
+  userconfig: new Definition('userconfig', {
+    default: '~/.npmrc',
+    type: path,
+    description: `
+      The location of user-level configuration settings.
+
+      This may be overridden by the \`npm_config_userconfig\` environment
+      variable or the \`--userconfig\` command line option, but may _not_
+      be overridden by settings in the \`globalconfig\` file.
+    `,
+  }),
+  version: new Definition('version', {
+    default: false,
+    type: Boolean,
+    short: 'v',
+    description: `
+      If true, output the npm version and exit successfully.
+
+      Only relevant when specified explicitly on the command line.
+    `,
+  }),
+  versions: new Definition('versions', {
+    default: false,
+    type: Boolean,
+    description: `
+      If true, output the npm version as well as node's \`process.versions\`
+      map and the version in the current working directory's \`package.json\`
+      file if one exists, and exit successfully.
+
+      Only relevant when specified explicitly on the command line.
+    `,
+  }),
+  viewer: new Definition('viewer', {
+    default: isWindows ? 'browser' : 'man',
+    defaultDescription: `
+      "man" on Posix, "browser" on Windows
+    `,
+    type: String,
+    description: `
+      The program to use to view help content.
+
+      Set to \`"browser"\` to view html help content in the default web browser.
+    `,
+  }),
+  which: new Definition('which', {
+    default: null,
+    hint: '<fundingSourceNumber>',
+    type: [null, Number],
+    description: `
+      If there are multiple funding sources, which 1-indexed source URL to open.
+    `,
+  }),
+  workspace: new Definition('workspace', {
+    default: [],
+    type: [String, Array],
+    hint: '<workspace-name>',
+    short: 'w',
+    envExport: false,
+    description: `
+      Enable running a command in the context of the configured workspaces of the
+      current project while filtering by running only the workspaces defined by
+      this configuration option.
+
+      Valid values for the \`workspace\` config are either:
+
+      * Workspace names
+      * Path to a workspace directory
+      * Path to a parent workspace directory (will result in selecting all
+        workspaces within that folder)
+
+      When set for the \`npm init\` command, this may be set to the folder of
+      a workspace which does not yet exist, to create the folder and set it
+      up as a brand new workspace within the project.
+    `,
+    flatten: (key, obj, flatOptions) => {
+      definitions['user-agent'].flatten('user-agent', obj, flatOptions)
+    },
+  }),
+  workspaces: new Definition('workspaces', {
+    default: null,
+    type: [null, Boolean],
+    envExport: false,
+    description: `
+      Set to true to run the command in the context of **all** configured
+      workspaces.
+
+      Explicitly setting this to false will cause commands like \`install\` to
+      ignore workspaces altogether.
+      When not set explicitly:
+
+      - Commands that operate on the \`node_modules\` tree (install, update,
+        etc.) will link workspaces into the \`node_modules\` folder.
+      - Commands that do other things (test, exec, publish, etc.) will operate
+        on the root project, _unless_ one or more workspaces are specified in
+        the \`workspace\` config.
+    `,
+    flatten: (key, obj, flatOptions) => {
+      definitions['user-agent'].flatten('user-agent', obj, flatOptions)
+
+      // TODO: this is a derived value, and should be reworked when we have a
+      // pattern for derived value
+
+      // workspacesEnabled is true whether workspaces is null or true
+      // commands contextually work with workspaces or not regardless of
+      // configuration, so we need an option specifically to disable workspaces
+      flatOptions.workspacesEnabled = obj[key] !== false
+    },
+  }),
+  'workspaces-update': new Definition('workspaces-update', {
+    default: true,
+    type: Boolean,
+    description: `
+      If set to true, the npm cli will run an update after operations that may
+      possibly change the workspaces installed to the \`node_modules\` folder.
+    `,
+    flatten,
+  }),
+  yes: new Definition('yes', {
+    default: null,
+    type: [null, Boolean],
+    short: 'y',
+    description: `
+      Automatically answer "yes" to any prompts that npm might print on
+      the command line.
+    `,
+  }),
+}
+
+module.exports = definitions
diff --git a/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/index.js b/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a44fd40eba895f6f50208540b95f88902bb9c8ab
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/config/lib/definitions/index.js
@@ -0,0 +1,88 @@
+const definitions = require('./definitions.js')
+
+// use the defined flattening function, and copy over any scoped
+// registries and registry-specific "nerfdart" configs verbatim
+//
+// TODO: make these getters so that we only have to make dirty
+// the thing that changed, and then flatten the fields that
+// could have changed when a config.set is called.
+//
+// TODO: move nerfdart auth stuff into a nested object that
+// is only passed along to paths that end up calling npm-registry-fetch.
+const flatten = (obj, flat = {}) => {
+  for (const [key, val] of Object.entries(obj)) {
+    const def = definitions[key]
+    if (def && def.flatten) {
+      def.flatten(key, obj, flat)
+    } else if (/@.*:registry$/i.test(key) || /^\/\//.test(key)) {
+      flat[key] = val
+    }
+  }
+  return flat
+}
+
+const definitionProps = Object.entries(definitions)
+  .reduce((acc, [key, { short = [], default: d }]) => {
+  // can be either an array or string
+    for (const s of [].concat(short)) {
+      acc.shorthands[s] = [`--${key}`]
+    }
+    acc.defaults[key] = d
+    return acc
+  }, { shorthands: {}, defaults: {} })
+
+// aliases where they get expanded into a completely different thing
+// these are NOT supported in the environment or npmrc files, only
+// expanded on the CLI.
+// TODO: when we switch off of nopt, use an arg parser that supports
+// more reasonable aliasing and short opts right in the definitions set.
+const shorthands = {
+  'enjoy-by': ['--before'],
+  d: ['--loglevel', 'info'],
+  dd: ['--loglevel', 'verbose'],
+  ddd: ['--loglevel', 'silly'],
+  quiet: ['--loglevel', 'warn'],
+  q: ['--loglevel', 'warn'],
+  s: ['--loglevel', 'silent'],
+  silent: ['--loglevel', 'silent'],
+  verbose: ['--loglevel', 'verbose'],
+  desc: ['--description'],
+  help: ['--usage'],
+  local: ['--no-global'],
+  n: ['--no-yes'],
+  no: ['--no-yes'],
+  porcelain: ['--parseable'],
+  readonly: ['--read-only'],
+  reg: ['--registry'],
+  iwr: ['--include-workspace-root'],
+  ws: ['--workspaces'],
+  ...definitionProps.shorthands,
+}
+
+// These are the configs that we can nerf-dart. Only _auth even has a config definition so we have to explicitly validate them here.
+// This is used to validate during "npm config set" and to not warn on loading unknown configs when we see these.
+const nerfDarts = [
+  '_auth', // Has a config
+  '_authToken', // Does not have a config
+  '_password', // Does not have a config
+  'certfile', // Does not have a config
+  'email', // Does not have a config
+  'keyfile', // Does not have a config
+  'username', // Does not have a config
+]
+
+const proxyEnv = [
+  'http_proxy',
+  'https_proxy',
+  'proxy',
+  'no_proxy',
+]
+
+module.exports = {
+  defaults: definitionProps.defaults,
+  definitions,
+  flatten,
+  nerfDarts,
+  proxyEnv,
+  shorthands,
+}
diff --git a/node/node_modules/npm/node_modules/@npmcli/config/lib/type-defs.js b/node/node_modules/npm/node_modules/@npmcli/config/lib/type-defs.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba2d9d9bd1a8407c64d389ca868a64efe9632fb8
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/config/lib/type-defs.js
@@ -0,0 +1,61 @@
+const nopt = require('nopt')
+
+const { validate: validateUmask } = require('./umask.js')
+
+class Umask {}
+class Semver {}
+const semverValid = require('semver/functions/valid')
+const validateSemver = (data, k, val) => {
+  const valid = semverValid(val)
+  if (!valid) {
+    return false
+  }
+  data[k] = valid
+}
+
+const noptValidatePath = nopt.typeDefs.path.validate
+const validatePath = (data, k, val) => {
+  if (typeof val !== 'string') {
+    return false
+  }
+  return noptValidatePath(data, k, val)
+}
+
+// add descriptions so we can validate more usefully
+module.exports = {
+  ...nopt.typeDefs,
+  semver: {
+    type: Semver,
+    validate: validateSemver,
+    description: 'full valid SemVer string',
+  },
+  Umask: {
+    type: Umask,
+    validate: validateUmask,
+    description: 'octal number in range 0o000..0o777 (0..511)',
+  },
+  url: {
+    ...nopt.typeDefs.url,
+    description: 'full url with "http://"',
+  },
+  path: {
+    ...nopt.typeDefs.path,
+    validate: validatePath,
+    description: 'valid filesystem path',
+  },
+  Number: {
+    ...nopt.typeDefs.Number,
+    description: 'numeric value',
+  },
+  Boolean: {
+    ...nopt.typeDefs.Boolean,
+    description: 'boolean value (true or false)',
+  },
+  Date: {
+    ...nopt.typeDefs.Date,
+    description: 'valid Date string',
+  },
+}
+
+// TODO: make nopt less of a global beast so this kludge isn't necessary
+nopt.typeDefs = module.exports
diff --git a/node/node_modules/npm/node_modules/@npmcli/config/lib/type-description.js b/node/node_modules/npm/node_modules/@npmcli/config/lib/type-description.js
new file mode 100644
index 0000000000000000000000000000000000000000..595a9ef5df2aa27fabef0d39e726cb8b57f9cc39
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/config/lib/type-description.js
@@ -0,0 +1,21 @@
+// return the description of the valid values of a field
+// returns a string for one thing, or an array of descriptions
+const typeDefs = require('./type-defs.js')
+const typeDescription = t => {
+  if (!t || typeof t !== 'function' && typeof t !== 'object') {
+    return t
+  }
+
+  if (Array.isArray(t)) {
+    return t.map(t => typeDescription(t))
+  }
+
+  for (const { type, description } of Object.values(typeDefs)) {
+    if (type === t) {
+      return description || type
+    }
+  }
+
+  return t
+}
+module.exports = t => [].concat(typeDescription(t)).filter(t => t !== undefined)
diff --git a/node/node_modules/npm/node_modules/@npmcli/config/lib/umask.js b/node/node_modules/npm/node_modules/@npmcli/config/lib/umask.js
new file mode 100644
index 0000000000000000000000000000000000000000..e0bf1bd08528c65bf49dc37d98b8de258f74fbe0
--- /dev/null
+++ b/node/node_modules/npm/node_modules/@npmcli/config/lib/umask.js
@@ -0,0 +1,35 @@
+const parse = val => {
+  // this is run via nopt and parse field where everything is
+  // converted to a string first, ignoring coverage for now
+  // instead of figuring out what is happening under the hood in nopt
+  // istanbul ignore else
+  if (typeof val === 'string') {
+    if (/^0o?[0-7]+$/.test(val)) {
+      return parseInt(val.replace(/^0o?/, ''), 8)
+    } else if (/^[1-9][0-9]*$/.test(val)) {
+      return parseInt(val, 10)
+    } else {
+      throw new Error(`invalid umask value: ${val}`)
+    }
+  } else {
+    if (typeof val !== 'number') {
+      throw new Error(`invalid umask value: ${val}`)
+    }
+    val = Math.floor(val)
+    if (val < 0 || val > 511) {
+      throw new Error(`invalid umask value: ${val}`)
+    }
+    return val
+  }
+}
+
+const validate = (data, k, val) => {
+  try {
+    data[k] = parse(val)
+    return true
+  } catch (er) {
+    return false
+  }
+}
+
+module.exports = { parse, validate }