Function getPathBufferFromURLWin32

lib/internal/url.js:1510–1578

(url)

}

function getPathBufferFromURLWin32(url) {
  const hostname = url.hostname;
  let pathname = url.pathname;
  // In the getPathFromURLWin32 variant, we scan the input for backslash (\)
  // and forward slash (/) characters, specifically looking for the ASCII/UTF8
  // encoding these and forbidding their use. This is a bit tricky
  // because these may conflict with non-UTF8 encodings. For instance,
  // in shift-jis, %5C identifies the symbol for the Japanese Yen and not the
  // backslash. If we have a url like file:///foo/%5c/bar, then we really have
  // no way of knowing if that %5c is meant to be a backslash \ or a yen sign.
  // Passing in an encoding option does not help since our Buffer encoding only
  // knows about certain specific text encodings and a single file path might
  // actually contain segments that use multiple encodings. It's tricky! So,
  // for this variation where we are producing a buffer, we won't scan for the
  // slashes at all, and instead will decode the bytes literally into the
  // returned Buffer. That said, that can also be tricky because, on windows,
  // the file path separator *is* the ASCII backslash. This is a known issue
  // on windows specific to the Shift-JIS encoding that we're not really going
  // to solve here. Instead, we're going to do the best we can and just
  // interpret the input url as a sequence of bytes.

  // Because we are converting to a Windows file path here, we need to replace
  // the explicit forward slash separators with backslashes. Note that this
  // intentionally disregards any percent-encoded forward slashes in the path.
  pathname = SideEffectFreeRegExpPrototypeSymbolReplace(FORWARD_SLASH, pathname, '\\');

  // Now, let's start to build our Buffer. We will initially start with a
  // Buffer allocated to fit in the entire string. Worst case there are no
  // percent encoded characters and we take the string as is. Any invalid
  // percent encodings, e.g. `%ZZ` are ignored and are passed through
  // literally.
  const decodedu8 = percentDecode(Buffer.from(pathname, 'utf8'));
  const decodedPathname = Buffer.from(TypedArrayPrototypeGetBuffer(decodedu8),
                                      TypedArrayPrototypeGetByteOffset(decodedu8),
                                      TypedArrayPrototypeGetByteLength(decodedu8));
  if (hostname !== '') {
    // If hostname is set, then we have a UNC path
    // Pass the hostname through domainToUnicode just in case
    // it is an IDN using punycode encoding. We do not need to worry
    // about percent encoding because the URL parser will have
    // already taken care of that for us. Note that this only
    // causes IDNs with an appropriate `xn--` prefix to be decoded.

    // This is a bit tricky because of the need to convert to a Buffer
    // followed by concatenation of the results.
    const prefix = Buffer.from('\\\\', 'ascii');
    const domain = Buffer.from(domainToUnicode(hostname), 'utf8');

    return Buffer.concat([prefix, domain, decodedPathname]);
  }
  // Otherwise, it's a local path that requires a drive letter
  // In this case we're only going to pay attention to the second and
  // third bytes in the decodedPathname. If first byte is either an ASCII
  // uppercase letter between 'A' and 'Z' or lowercase letter between
  // 'a' and 'z', and the second byte must be an ASCII `:` or the
  // operation will fail.

  const letter = decodedPathname[1] | 0x20;