docs: function matchFileNames(fileNames, include, exclude, basePath, options, host, errors) {
          basePath = ts.normalizePath(basePath);
          // The exclude spec list is converted into a regular expression, which allows us to quickly
          // test whether a file or directory should be excluded before recursively traversing the
          // file system.
          var keyMapper = host.useCaseSensitiveFileNames ? caseSensitiveKeyMapper : caseInsensitiveKeyMapper;
          // Literal file names (provided via the "files" array in tsconfig.json) are stored in a
          // file map with a possibly case insensitive key. We use this map later when when including
          // wildcard paths.
          var literalFileMap = ts.createMap();
          // Wildcard paths (provided via the "includes" array in tsconfig.json) are stored in a
          // file map with a possibly case insensitive key. We use this map to store paths matched
          // via wildcard, and to handle extension priority.
          var wildcardFileMap = ts.createMap();
          if (include) {
              include = validateSpecs(include, errors, /*allowTrailingRecursion*/ false);
          }
          if (exclude) {
              exclude = validateSpecs(exclude, errors, /*allowTrailingRecursion*/ true);
          }
          // Wildcard directories (provided as part of a wildcard path) are stored in a
          // file map that marks whether it was a regular wildcard match (with a `*` or `?` token),
          // or a recursive directory. This information is used by filesystem watchers to monitor for
          // new entries in these paths.
          var wildcardDirectories = getWildcardDirectories(include, exclude, basePath, host.useCaseSensitiveFileNames);
          // Rather than requery this for each file and filespec, we query the supported extensions
          // once and store it on the expansion context.
          var supportedExtensions = ts.getSupportedExtensions(options);
          // Literal files are always included verbatim. An "include" or "exclude" specification cannot
          // remove a literal file.
          if (fileNames) {
              for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
                  var fileName = fileNames_1[_i];
                  var file = ts.combinePaths(basePath, fileName);
                  literalFileMap[keyMapper(file)] = file;
              }
          }
          if (include && include.length > 0) {
              for (var _a = 0, _b = host.readDirectory(basePath, supportedExtensions, exclude, include); _a < _b.length; _a++) {
                  var file = _b[_a];
                  // If we have already included a literal or wildcard path with a
                  // higher priority extension, we should skip this file.
                  //
                  // This handles cases where we may encounter both <file>.ts and
                  // <file>.d.ts (or <file>.js if "allowJs" is enabled) in the same
                  // directory when they are compilation outputs.
                  if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
                      continue;
                  }
                  // We may have included a wildcard path with a lower priority
                  // extension due to the user-defined order of entries in the
                  // "include" array. If there is a lower priority extension in the
                  // same directory, we should remove it.
                  removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
                  var key = keyMapper(file);
                  if (!(key in literalFileMap) && !(key in wildcardFileMap)) {
                      wildcardFileMap[key] = file;
                  }
              }
          }
          var literalFiles = ts.reduceProperties(literalFileMap, addFileToOutput, []);
          var wildcardFiles = ts.reduceProperties(wildcardFileMap, addFileToOutput, []);
          wildcardFiles.sort(host.useCaseSensitiveFileNames ? ts.compareStrings : ts.compareStringsCaseInsensitive);
          return {
              fileNames: literalFiles.concat(wildcardFiles),
              wildcardDirectories: wildcardDirectories
          };
      }