@govtechsg/oobee 0.10.42 → 0.10.45

package/src/constants/common.ts

@@ -15,15 +15,20 @@ import safe from 'safe-regex';
 import * as https from 'https';
 import os from 'os';
 import { minimatch } from 'minimatch';
-import { globSync } from 'glob';
-import { LaunchOptions, devices, webkit } from 'playwright';
+import { globSync, GlobOptionsWithFileTypesFalse } from 'glob';
+import { LaunchOptions, Locator, Page, devices, webkit } from 'playwright';
 import printMessage from 'print-message';
+// @ts-ignore
+import * as Sentry from '@sentry/node';
 import constants, {
   getDefaultChromeDataDir,
   getDefaultEdgeDataDir,
   getDefaultChromiumDataDir,
   proxy,
+  sentryConfig,
+    // Legacy code start - Google Sheets submission
   formDataFields,
+    // Legacy code end - Google Sheets submission
   ScannerTypes,
   BrowserTypes,
 } from './constants.js';
@@ -31,6 +36,7 @@ import { silentLogger } from '../logs.js';
 import { isUrlPdf } from '../crawlers/commonCrawlerFunc.js';
 import { randomThreeDigitNumberString } from '../utils.js';
 import { Answers, Data } from '../index.js';
+import { DeviceDescriptor } from '../types/types.js';
 
 // validateDirPath validates a provided directory path
 // returns null if no error
@@ -252,7 +258,7 @@ export const getUrlMessage = (scanner: ScannerTypes): string => {
   }
 };
 
-export const isInputValid = inputString => {
+export const isInputValid = (inputString: string): boolean => {
   if (!validator.isEmpty(inputString)) {
     const removeBlackListCharacters = validator.escape(inputString);
 
@@ -373,12 +379,12 @@ const requestToUrl = async (
 };
 
 const checkUrlConnectivityWithBrowser = async (
-  url,
-  browserToRun,
-  clonedDataDir,
-  playwrightDeviceDetailsObject,
-  isCustomFlow,
-  extraHTTPHeaders,
+  url: string,
+  browserToRun: string,
+  clonedDataDir: string,
+  playwrightDeviceDetailsObject: DeviceDescriptor,
+  isCustomFlow: boolean,
+  extraHTTPHeaders: Record<string, string>,
 ) => {
   const res = new RES();
 
@@ -468,7 +474,6 @@ const checkUrlConnectivityWithBrowser = async (
         res.content = responseFromUrl.content;
       }
     } catch (error) {
-
       // But this does work with the headless=new flag
       if (error.message.includes('net::ERR_INVALID_AUTH_CREDENTIALS')) {
         res.status = constants.urlCheckStatuses.unauthorised.code;
@@ -510,13 +515,13 @@ export const isSitemapContent = (content: string) => {
 };
 
 export const checkUrl = async (
-  scanner,
-  url,
-  browser,
-  clonedDataDir,
-  playwrightDeviceDetailsObject,
-  isCustomFlow,
-  extraHTTPHeaders,
+  scanner: ScannerTypes,
+  url: string,
+  browser: string,
+  clonedDataDir: string,
+  playwrightDeviceDetailsObject: DeviceDescriptor,
+  isCustomFlow: boolean,
+  extraHTTPHeaders: Record<string, string>,
 ) => {
   const res = await checkUrlConnectivityWithBrowser(
     url,
@@ -548,7 +553,7 @@ export const parseHeaders = (header?: string): Record<string, string> => {
   // parse HTTP headers from string
   if (!header) return {};
   const headerValues = header.split(', ');
-  const allHeaders = {};
+  const allHeaders: Record<string, string> = {};
   headerValues.map((headerValue: string) => {
     const headerValuePair = headerValue.split(/ (.*)/s);
     if (headerValuePair.length < 2) {
@@ -776,11 +781,11 @@ export const getLinksFromSitemap = async (
   password: string,
 ) => {
   const scannedSitemaps = new Set<string>();
-  const urls = {}; // dictionary of requests to urls to be scanned
+  const urls: Record<string, Request> = {}; // dictionary of requests to urls to be scanned
 
   const isLimitReached = () => Object.keys(urls).length >= maxLinksCount;
 
-  const addToUrlList = url => {
+  const addToUrlList = (url: string) => {
     if (!url) return;
     if (isDisallowedInRobotsTxt(url)) return;
 
@@ -803,14 +808,14 @@ export const getLinksFromSitemap = async (
     urls[url] = request;
   };
 
-  const addBasicAuthCredentials = (url, username, password) => {
+  const addBasicAuthCredentials = (url: string, username: string, password: string) => {
     const urlObject = new URL(url);
     urlObject.username = username;
     urlObject.password = password;
     return urlObject.toString();
   };
 
-  const calculateCloseness = sitemapUrl => {
+  const calculateCloseness = (sitemapUrl: string) => {
     // Remove 'http://', 'https://', and 'www.' prefixes from the URLs
     const normalizedSitemapUrl = sitemapUrl.replace(/^(https?:\/\/)?(www\.)?/, '');
     const normalizedUserUrlInput = userUrlInput
@@ -825,10 +830,16 @@ export const getLinksFromSitemap = async (
     }
     return 0;
   };
-  const processXmlSitemap = async ($, sitemapType, linkSelector, dateSelector, sectionSelector) => {
-    const urlList = [];
+  const processXmlSitemap = async (
+    $: cheerio.CheerioAPI,
+    sitemapType: number,
+    linkSelector: string,
+    dateSelector: string,
+    sectionSelector: string,
+  ) => {
+    const urlList: { url: string; lastModifiedDate: Date }[] = [];
     // Iterate through each URL element in the sitemap, collect url and modified date
-    $(sectionSelector).each((index, urlElement) => {
+    $(sectionSelector).each((_index, urlElement) => {
       let url;
       if (sitemapType === constants.xmlSitemapTypes.atom) {
         url = $(urlElement).find(linkSelector).prop('href');
@@ -850,8 +861,7 @@ export const getLinksFromSitemap = async (
         }
 
         // If closeness is the same, sort by last modified date in descending order
-        const dateDifference = (b.lastModifiedDate || 0) - (a.lastModifiedDate || 0);
-        return dateDifference !== 0 ? dateDifference : 0; // Maintain original order for equal dates
+        return (b.lastModifiedDate?.getTime() || 0) - (a.lastModifiedDate?.getTime() || 0);
       });
     }
 
@@ -861,7 +871,7 @@ export const getLinksFromSitemap = async (
     }
   };
 
-  const processNonStandardSitemap = data => {
+  const processNonStandardSitemap = (data: string) => {
     const urlsFromData = crawlee
       .extractUrls({ string: data, urlRegExp: new RegExp('^(http|https):/{2}.+$', 'gmi') })
       .slice(0, maxLinksCount);
@@ -934,7 +944,7 @@ export const getLinksFromSitemap = async (
         const sitemapIndex = page.locator('sitemapindex');
         const rss = page.locator('rss');
         const feed = page.locator('feed');
-        const isRoot = async locator => (await locator.count()) > 0;
+        const isRoot = async (locator: Locator) => (await locator.count()) > 0;
 
         if (await isRoot(urlSet)) {
           data = await urlSet.evaluate(elem => elem.outerHTML);
@@ -1054,14 +1064,14 @@ export const getLinksFromSitemap = async (
   return requestList;
 };
 
-export const validEmail = email => {
+export const validEmail = (email: string) => {
   const emailRegex = /^.+@.+\..+$/u;
 
   return emailRegex.test(email);
 };
 
 // For new user flow.
-export const validName = name => {
+export const validName = (name: string) => {
   // Allow only printable characters from any language
   const regex = /^[\p{L}\p{N}\s'".,()\[\]{}!?:؛،؟…]+$/u;
 
@@ -1213,11 +1223,11 @@ export const getEdgeData = () => {
  * @param {*} destDir destination directory
  * @returns boolean indicating whether the operation was successful
  */
-const cloneChromeProfileCookieFiles = (options, destDir) => {
+const cloneChromeProfileCookieFiles = (options: GlobOptionsWithFileTypesFalse, destDir: string) => {
   let profileCookiesDir;
   // Cookies file per profile is located in .../User Data/<profile name>/Network/Cookies for windows
   // and ../Chrome/<profile name>/Cookies for mac
-  let profileNamesRegex;
+  let profileNamesRegex: RegExp;
   if (os.platform() === 'win32') {
     profileCookiesDir = globSync('**/Network/Cookies', {
       ...options,
@@ -1288,11 +1298,11 @@ const cloneChromeProfileCookieFiles = (options, destDir) => {
  * @param {*} destDir destination directory
  * @returns boolean indicating whether the operation was successful
  */
-const cloneEdgeProfileCookieFiles = (options, destDir) => {
+const cloneEdgeProfileCookieFiles = (options: GlobOptionsWithFileTypesFalse, destDir: string) => {
   let profileCookiesDir;
   // Cookies file per profile is located in .../User Data/<profile name>/Network/Cookies for windows
   // and ../Chrome/<profile name>/Cookies for mac
-  let profileNamesRegex;
+  let profileNamesRegex: RegExp;
   // Ignores the cloned oobee directory if exists
   if (os.platform() === 'win32') {
     profileCookiesDir = globSync('**/Network/Cookies', {
@@ -1361,7 +1371,7 @@ const cloneEdgeProfileCookieFiles = (options, destDir) => {
  * @param {string} destDir - destination directory
  * @returns boolean indicating whether the operation was successful
  */
-const cloneLocalStateFile = (options, destDir) => {
+const cloneLocalStateFile = (options: GlobOptionsWithFileTypesFalse, destDir: string) => {
   const localState = globSync('**/*Local State', {
     ...options,
     maxDepth: 1,
@@ -1647,8 +1657,9 @@ export const getPlaywrightDeviceDetailsObject = (
   deviceChosen: string,
   customDevice: string,
   viewportWidth: number,
-) => {
-  let playwrightDeviceDetailsObject = {};
+): DeviceDescriptor => {
+  let playwrightDeviceDetailsObject = devices['Desktop Chrome']; // default to Desktop Chrome
+
   if (deviceChosen === 'Mobile' || customDevice === 'iPhone 11') {
     playwrightDeviceDetailsObject = devices['iPhone 11'];
   } else if (customDevice === 'Samsung Galaxy S9+') {
@@ -1656,6 +1667,11 @@ export const getPlaywrightDeviceDetailsObject = (
   } else if (viewportWidth) {
     playwrightDeviceDetailsObject = {
       viewport: { width: viewportWidth, height: 720 },
+      isMobile: false,
+      hasTouch: false,
+      userAgent: devices['Desktop Chrome'].userAgent,
+      deviceScaleFactor: 1,
+      defaultBrowserType: 'chromium',
     };
   } else if (customDevice) {
     playwrightDeviceDetailsObject = devices[customDevice.replace(/_/g, ' ')];
@@ -1742,49 +1758,171 @@ export const submitForm = async (
   numberOfPagesNotScanned: number,
   metadata: string,
 ) => {
-  const additionalPageDataJson = JSON.stringify({
-    redirectsScanned: numberOfRedirectsScanned,
+  // Initialize Sentry
+  Sentry.init(sentryConfig);
+
+  // Format the data as you want it to appear in Sentry
+  const additionalPageData = {
     pagesNotScanned: numberOfPagesNotScanned,
-  });
+    redirectsScanned: numberOfRedirectsScanned
+  };
 
-  let finalUrl =
-    `${formDataFields.formUrl}?` +
-    `${formDataFields.entryUrlField}=${entryUrl}&` +
-    `${formDataFields.scanTypeField}=${scanType}&` +
-    `${formDataFields.emailField}=${email}&` +
-    `${formDataFields.nameField}=${name}&` +
-    `${formDataFields.resultsField}=${encodeURIComponent(scanResultsJson)}&` +
-    `${formDataFields.numberOfPagesScannedField}=${numberOfPagesScanned}&` +
-    `${formDataFields.additionalPageDataField}=${encodeURIComponent(additionalPageDataJson)}&` +
-    `${formDataFields.metadataField}=${encodeURIComponent(metadata)}`;
+  // Extract issue occurrences from scan results if possible
+  const issueOccurrences = extractIssueOccurrences(scanResultsJson);
+  
+  // Determine if it's a government website
+  const isGov = entryUrl.includes('.gov');
+  
+  // Get email domain/tag
+  const emailTag = email.split('@')[1] || '';
+  
+  // Format timestamp 
+  const timestamp = new Date().toISOString();
+  
+  // Prepare redirect URL if different from entry URL
+  const redirectUrl = scannedUrl !== entryUrl ? scannedUrl : null;
+  
+  try {
+    // Capture the scan data as a Sentry event with each field as a separate entry
+    Sentry.captureEvent({
+      message: `Accessibility scan completed for ${entryUrl}`,
+      level: 'info',
+      tags: {
+        scanType: scanType,
+        browser: browserToRun,
+        isGov: isGov,
+        emailDomain: emailTag,
+      },
+      user: {
+        email: email,
+        username: name,
+      },
+      extra: {
+        // Top-level fields as shown in your screenshot
+        entryUrl: entryUrl,
+        websiteUrl: scannedUrl,
+        scanType: scanType,
+        numberOfPagesScanned: numberOfPagesScanned,
+        metadata: metadata ? JSON.parse(metadata) : {},
+        scanResults: scanResultsJson.length > 8000 ? 
+          scanResultsJson.substring(0, 8000) + '...[truncated]' : 
+          scanResultsJson,
+        
+        // Additional fields you requested
+        additionalPageData: additionalPageData,
+        additionalScan: additionalPageData,
+        additionalPagesData: additionalPageData,
+        
+        // Individual fields as requested
+        timestamp: timestamp,
+        redirectUrl: redirectUrl,
+        isGov: isGov,
+        emailTag: emailTag,
+        consolidatedScanType: scanType.toLowerCase(),
+        email: email,
+        name: name,
+        filledNoPagesScanned: numberOfPagesScanned > 0,
+        redirectsScanned: numberOfRedirectsScanned,
+        pagesNotScanned: numberOfPagesNotScanned,
+        issueOccurrences: issueOccurrences
+      }
+    });
 
-  if (scannedUrl !== entryUrl) {
-    finalUrl += `&${formDataFields.redirectUrlField}=${scannedUrl}`;
+    // IMPORTANT: Wait for the event to be sent
+    await Sentry.flush(2000); // Wait up to 2 seconds for the event to be sent
+    
+  } catch (error) {
+    console.error('Error sending data to Sentry:', error);
   }
 
-  if (proxy) {
-    await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
-  } else {
-    try {
-      await axios.get(finalUrl, { timeout: 2000 });
-    } catch (error) {
-      if (error.code === 'ECONNABORTED') {
-        if (browserToRun || constants.launcher === webkit) {
-          await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
+  // Legacy code start - Google Sheets submission
+  try {
+    const additionalPageDataJson = JSON.stringify({
+      redirectsScanned: numberOfRedirectsScanned,
+      pagesNotScanned: numberOfPagesNotScanned,
+    });
+
+    let finalUrl =
+      `${formDataFields.formUrl}?` +
+      `${formDataFields.entryUrlField}=${entryUrl}&` +
+      `${formDataFields.scanTypeField}=${scanType}&` +
+      `${formDataFields.emailField}=${email}&` +
+      `${formDataFields.nameField}=${name}&` +
+      `${formDataFields.resultsField}=${encodeURIComponent(scanResultsJson)}&` +
+      `${formDataFields.numberOfPagesScannedField}=${numberOfPagesScanned}&` +
+      `${formDataFields.additionalPageDataField}=${encodeURIComponent(additionalPageDataJson)}&` +
+      `${formDataFields.metadataField}=${encodeURIComponent(metadata)}`;
+
+    if (scannedUrl !== entryUrl) {
+      finalUrl += `&${formDataFields.redirectUrlField}=${scannedUrl}`;
+    }
+
+    if (proxy) {
+      await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
+    } else {
+      try {
+        await axios.get(finalUrl, { timeout: 2000 });
+      } catch (error) {
+        if (error.code === 'ECONNABORTED') {
+          if (browserToRun || constants.launcher === webkit) {
+            await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
+          }
         }
       }
     }
+    console.log('Legacy Google Sheets form submitted successfully');
+  } catch (legacyError) {
+    console.error('Error submitting legacy Google Sheets form:', legacyError);
   }
+  // Legacy code end - Google Sheets submission
 };
 
-export async function initModifiedUserAgent(browser?: string, playwrightDeviceDetailsObject?: object) {
+// Helper function to extract issue occurrences from scan results
+function extractIssueOccurrences(scanResultsJson: string): number {
+  try {
+    const results = JSON.parse(scanResultsJson);
+    // Count total occurrences from all issues in the scan results
+    // This may need adjustment based on your specific JSON structure
+    let totalOccurrences = 0;
+    
+    // Try to parse the format shown in your screenshot
+    if (typeof results === 'object') {
+      // Loop through all keys that have "occurrences" properties
+      Object.keys(results).forEach(key => {
+        if (results[key] && typeof results[key] === 'object' && 'occurrences' in results[key]) {
+          totalOccurrences += parseInt(results[key].occurrences, 10) || 0;
+        }
+      });
+      
+      // If we found any occurrences, return the total
+      if (totalOccurrences > 0) {
+        return totalOccurrences;
+      }
+    }
+    
+    // Fallback to direct occurrences property if available
+    if (results && results.occurrences) {
+      return parseInt(results.occurrences, 10) || 0;
+    }
+    
+    return 0;
+  } catch (e) {
+    console.error('Error extracting issue occurrences:', e);
+    return 0;
+  }
+}
+
+export async function initModifiedUserAgent(
+  browser?: string,
+  playwrightDeviceDetailsObject?: object,
+) {
   const isHeadless = process.env.CRAWLEE_HEADLESS === '1';
-  
+
   // If headless mode is enabled, ensure the headless flag is set.
   if (isHeadless && !constants.launchOptionsArgs.includes('--headless=new')) {
     constants.launchOptionsArgs.push('--headless=new');
   }
-  
+
   // Build the launch options using your production settings.
   // headless is forced to false as in your persistent context, and we merge in getPlaywrightLaunchOptions and device details.
   const launchOptions = {
@@ -1803,17 +1941,16 @@ export async function initModifiedUserAgent(browser?: string, playwrightDeviceDe
 
   // Modify the UA:
   // Replace "HeadlessChrome" with "Chrome" if present.
-  let modifiedUA = defaultUA.includes('HeadlessChrome')
+  const modifiedUA = defaultUA.includes('HeadlessChrome')
     ? defaultUA.replace('HeadlessChrome', 'Chrome')
     : defaultUA;
-    
+
   // Push the modified UA flag into your global launch options.
   constants.launchOptionsArgs.push(`--user-agent=${modifiedUA}`);
   // Optionally log the modified UA.
   // console.log('Modified User Agent:', modifiedUA);
 }
 
-
 /**
  * @param {string} browser browser name ("chrome" or "edge", null for chromium, the default Playwright browser)
  * @returns playwright launch options object. For more details: https://playwright.dev/docs/api/class-browsertype#browser-type-launch
@@ -1856,25 +1993,25 @@ export const urlWithoutAuth = (url: string): string => {
   return parsedUrl.toString();
 };
 
-export const waitForPageLoaded = async (page, timeout = 10000) => {
+export const waitForPageLoaded = async (page: Page, timeout = 10000) => {
   const OBSERVER_TIMEOUT = timeout; // Ensure observer timeout does not exceed the main timeout
 
   return Promise.race([
     page.waitForLoadState('load'), // Ensure page load completes
     page.waitForLoadState('networkidle'), // Wait for network requests to settle
     new Promise(resolve => setTimeout(resolve, timeout)), // Hard timeout as a fallback
-    page.evaluate((OBSERVER_TIMEOUT) => {
-      return new Promise((resolve) => {
+    page.evaluate(OBSERVER_TIMEOUT => {
+      return new Promise(resolve => {
         // Skip mutation check for PDFs
         if (document.contentType === 'application/pdf') {
           resolve('Skipping DOM mutation check for PDF.');
           return;
         }
 
-        let timeout;
+        let timeout: NodeJS.Timeout;
         let mutationCount = 0;
         const MAX_MUTATIONS = 250; // Limit max mutations
-        const mutationHash = {};
+        const mutationHash: Record<string, number> = {};
 
         const observer = new MutationObserver(mutationsList => {
           clearTimeout(timeout);
@@ -1916,14 +2053,17 @@ export const waitForPageLoaded = async (page, timeout = 10000) => {
           resolve('Observer timeout reached, exiting.');
         }, OBSERVER_TIMEOUT);
 
-        observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true });
+        observer.observe(document.documentElement, {
+          childList: true,
+          subtree: true,
+          attributes: true,
+        });
       });
     }, OBSERVER_TIMEOUT), // Pass OBSERVER_TIMEOUT dynamically to the browser context
   ]);
 };
 
-
-function isValidHttpUrl(urlString) {
+function isValidHttpUrl(urlString: string) {
   const pattern = /^(http|https):\/\/[^ "]+$/;
   return pattern.test(urlString);
 }

package/src/constants/constants.ts

@@ -6,6 +6,7 @@ import which from 'which';
 import os from 'os';
 import { spawnSync, execSync } from 'child_process';
 import { chromium } from 'playwright';
+import * as Sentry from '@sentry/node';
 import { silentLogger } from '../logs.js';
 import { PageInfo } from '../mergeAxeResults.js';
 
@@ -29,6 +30,7 @@ export const blackListedFileExtensions = [
   'zip',
   'webp',
   'json',
+  'xml'
 ];
 
 export const getIntermediateScreenshotsPath = (datasetsPath: string): string =>
@@ -217,7 +219,7 @@ export const guiInfoStatusTypes = {
   DUPLICATE: 'duplicate',
 };
 
-let launchOptionsArgs = [];
+let launchOptionsArgs: string[] = [];
 
 // Check if running in docker container
 if (fs.existsSync('/.dockerenv')) {
@@ -273,6 +275,12 @@ export const impactOrder = {
   critical: 3,
 };
 
+export const sentryConfig = {
+  dsn: "https://e4ab99e457c531e7bde4a8dc3dd2b1ab@o4509047624761344.ingest.us.sentry.io/4509192349548544",
+  tracesSampleRate: 1.0, // Capture 100% of transactions for performance monitoring
+  profilesSampleRate: 1.0, // Capture 100% of profiles
+};
+  // Legacy code start - Google Sheets submission
 export const formDataFields = {
   formUrl: `https://docs.google.com/forms/d/e/1FAIpQLSem5C8fyNs5TiU5Vv2Y63-SH7CHN86f-LEPxeN_1u_ldUbgUA/formResponse`, // prod
   entryUrlField: 'entry.1562345227',
@@ -285,6 +293,7 @@ export const formDataFields = {
   additionalPageDataField: 'entry.2090887881',
   metadataField: 'entry.1027769131',
 };
+  // Legacy code end - Google Sheets submission
 
 export const sitemapPaths = [
   '/sitemap.xml',
@@ -444,3 +453,82 @@ export enum RuleFlags {
   DISABLE_OOBEE = 'disable-oobee',
   ENABLE_WCAG_AAA = 'enable-wcag-aaa',
 }
+
+// Note: Not all status codes will appear as Crawler will handle it as best effort first. E.g. try to handle redirect
+export const STATUS_CODE_METADATA: Record<number,string> = {
+  // Custom Codes for Oobee's use
+  0: 'Page Excluded',
+  1: 'Not A Supported Document',
+  2: 'Web Crawler Errored',
+
+  // 599 is set because Crawlee returns response status 100, 102, 103 as 599
+  599: 'Uncommon Response Status Code Received',
+
+  // This is Status OK but thrown when the crawler cannot scan the page
+  200: '200 - However Page Could Not Be Scanned', 
+  
+  // 1xx - Informational
+  100: '100 - Continue',
+  101: '101 - Switching Protocols',
+  102: '102 - Processing',
+  103: '103 - Early Hints',
+
+  // 2xx - Browser Doesn't Support
+  204: '204 - No Content',
+  205: '205 - Reset Content',
+
+  // 3xx - Redirection
+  300: '300 - Multiple Choices',
+  301: '301 - Moved Permanently',
+  302: '302 - Found',
+  303: '303 - See Other',
+  304: '304 - Not Modified',
+  305: '305 - Use Proxy',
+  307: '307 - Temporary Redirect',
+  308: '308 - Permanent Redirect',
+  
+  // 4xx - Client Error
+  400: '400 - Bad Request',
+  401: '401 - Unauthorized',
+  402: '402 - Payment Required',
+  403: '403 - Forbidden',
+  404: '404 - Not Found',
+  405: '405 - Method Not Allowed',
+  406: '406 - Not Acceptable',
+  407: '407 - Proxy Authentication Required',
+  408: '408 - Request Timeout',
+  409: '409 - Conflict',
+  410: '410 - Gone',
+  411: '411 - Length Required',
+  412: '412 - Precondition Failed',
+  413: '413 - Payload Too Large',
+  414: '414 - URI Too Long',
+  415: '415 - Unsupported Media Type',
+  416: '416 - Range Not Satisfiable',
+  417: '417 - Expectation Failed',
+  418: "418 - I'm a teapot",
+  421: '421 - Misdirected Request',
+  422: '422 - Unprocessable Content',
+  423: '423 - Locked',
+  424: '424 - Failed Dependency',
+  425: '425 - Too Early',
+  426: '426 - Upgrade Required',
+  428: '428 - Precondition Required',
+  429: '429 - Too Many Requests',
+  431: '431 - Request Header Fields Too Large',
+  451: '451 - Unavailable For Legal Reasons',
+
+  // 5xx - Server Error
+  500: '500 - Internal Server Error',
+  501: '501 - Not Implemented',
+  502: '502 - Bad Gateway',
+  503: '503 - Service Unavailable',
+  504: '504 - Gateway Timeout',
+  505: '505 - HTTP Version Not Supported',
+  506: '506 - Variant Also Negotiates',
+  507: '507 - Insufficient Storage',
+  508: '508 - Loop Detected',
+  510: '510 - Not Extended',
+  511: '511 - Network Authentication Required',
+
+};