diff --git a/EcoSonar-API/dataBase/lighthouseRepository.js b/EcoSonar-API/dataBase/lighthouseRepository.js index 30f9ae7..3f0821a 100644 --- a/EcoSonar-API/dataBase/lighthouseRepository.js +++ b/EcoSonar-API/dataBase/lighthouseRepository.js @@ -180,7 +180,8 @@ const LighthouseRepository = function () { speedIndex: 1, totalBlockingTime: 1, interactive: 1, - dateLighthouseAnalysis: 1 + dateLighthouseAnalysis: 1, + mobile: 1 } ) .sort({ dateLighthouseAnalysis: 1 }) diff --git a/EcoSonar-API/dataBase/models/lighthouses.js b/EcoSonar-API/dataBase/models/lighthouses.js index 9a2b290..1de8fe0 100644 --- a/EcoSonar-API/dataBase/models/lighthouses.js +++ b/EcoSonar-API/dataBase/models/lighthouses.js @@ -1,7 +1,7 @@ const mongoose = require('mongoose') const Schema = mongoose.Schema -const lighthouseSchema = new Schema({ +const reportSchema = { idLighthouseAnalysis: { type: String, required: true, @@ -119,6 +119,14 @@ const lighthouseSchema = new Schema({ required: true } } +} + +const lighthouseSchema = new Schema({ + ...reportSchema, + mobile: { + type: reportSchema, + required: false + } }) const lighthouse = mongoose.model('lighthouses', lighthouseSchema) diff --git a/EcoSonar-API/jest.config.js b/EcoSonar-API/jest.config.js new file mode 100644 index 0000000..272807e --- /dev/null +++ b/EcoSonar-API/jest.config.js @@ -0,0 +1,198 @@ +/** + * For a detailed explanation regarding each configuration property, visit: + * https://jestjs.io/docs/configuration + */ + +/** @type {import('jest').Config} */ +const config = { + // All imported modules in your tests should be mocked automatically + // automock: false, + + // Stop running tests after `n` failures + // bail: 0, + + // The directory where Jest should store its cached dependency information + // cacheDirectory: "/tmp/jest_rs", + + // Automatically clear mock calls, instances, contexts and results before every test + clearMocks: true, + + // Indicates whether the coverage information should be collected while executing the test + // collectCoverage: false, + + // An array of glob patterns indicating a set of files for which coverage information should be collected + // collectCoverageFrom: undefined, + + // The directory where Jest should output its coverage files + // coverageDirectory: undefined, + + // An array of regexp pattern strings used to skip coverage collection + // coveragePathIgnorePatterns: [ + // "/node_modules/" + // ], + + // Indicates which provider should be used to instrument code for coverage + coverageProvider: "v8", + + // A list of reporter names that Jest uses when writing coverage reports + // coverageReporters: [ + // "json", + // "text", + // "lcov", + // "clover" + // ], + + // An object that configures minimum threshold enforcement for coverage results + // coverageThreshold: undefined, + + // A path to a custom dependency extractor + // dependencyExtractor: undefined, + + // Make calling deprecated APIs throw helpful error messages + // errorOnDeprecated: false, + + // The default configuration for fake timers + // fakeTimers: { + // "enableGlobally": false + // }, + + // Force coverage collection from ignored files using an array of glob patterns + // forceCoverageMatch: [], + + // A path to a module which exports an async function that is triggered once before all test suites + // globalSetup: undefined, + + // A path to a module which exports an async function that is triggered once after all test suites + // globalTeardown: undefined, + + // A set of global variables that need to be available in all test environments + // globals: {}, + + // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers. + // maxWorkers: "50%", + + // An array of directory names to be searched recursively up from the requiring module's location + // moduleDirectories: [ + // "node_modules" + // ], + + // An array of file extensions your modules use + // moduleFileExtensions: [ + // "js", + // "mjs", + // "cjs", + // "jsx", + // "ts", + // "tsx", + // "json", + // "node" + // ], + + // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module + // moduleNameMapper: {}, + + // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader + // modulePathIgnorePatterns: [], + + // Activates notifications for test results + // notify: false, + + // An enum that specifies notification mode. Requires { notify: true } + // notifyMode: "failure-change", + + // A preset that is used as a base for Jest's configuration + // preset: undefined, + + // Run tests from one or more projects + // projects: undefined, + + // Use this configuration option to add custom reporters to Jest + // reporters: undefined, + + // Automatically reset mock state before every test + // resetMocks: false, + + // Reset the module registry before running each individual test + // resetModules: false, + + // A path to a custom resolver + // resolver: undefined, + + // Automatically restore mock state and implementation before every test + // restoreMocks: false, + + // The root directory that Jest should scan for tests and modules within + // rootDir: undefined, + + // A list of paths to directories that Jest should use to search for files in + // roots: [ + // "" + // ], + + // Allows you to use a custom runner instead of Jest's default test runner + // runner: "jest-runner", + + // The paths to modules that run some code to configure or set up the testing environment before each test + // setupFiles: [], + + // A list of paths to modules that run some code to configure or set up the testing framework before each test + // setupFilesAfterEnv: [], + + // The number of seconds after which a test is considered as slow and reported as such in the results. + // slowTestThreshold: 5, + + // A list of paths to snapshot serializer modules Jest should use for snapshot testing + // snapshotSerializers: [], + + // The test environment that will be used for testing + // testEnvironment: "jest-environment-node", + + // Options that will be passed to the testEnvironment + // testEnvironmentOptions: {}, + + // Adds a location field to test results + // testLocationInResults: false, + + // The glob patterns Jest uses to detect test files + // testMatch: [ + // "**/__tests__/**/*.[jt]s?(x)", + // "**/?(*.)+(spec|test).[tj]s?(x)" + // ], + + // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped + // testPathIgnorePatterns: [ + // "/node_modules/" + // ], + + // The regexp pattern or array of patterns that Jest uses to detect test files + // testRegex: [], + + // This option allows the use of a custom results processor + // testResultsProcessor: undefined, + + // This option allows use of a custom test runner + // testRunner: "jest-circus/runner", + + // A map from regular expressions to paths to transformers + // transform: undefined, + + // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation + // transformIgnorePatterns: [ + // "/node_modules/", + // "\\.pnp\\.[^\\/]+$" + // ], + + // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them + // unmockedModulePathPatterns: undefined, + + // Indicates whether each individual test should be reported during the run + // verbose: undefined, + + // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode + // watchPathIgnorePatterns: [], + + // Whether to use watchman for file crawling + // watchman: true, +}; + +module.exports = config; diff --git a/EcoSonar-API/package.json b/EcoSonar-API/package.json index e75d895..1086280 100644 --- a/EcoSonar-API/package.json +++ b/EcoSonar-API/package.json @@ -9,7 +9,7 @@ "main": "app.js", "scripts": { "postinstall": "node builder.js", - "test": "echo \"Error: no test specified\" && exit 1", + "test": "jest", "build": "node builder.js", "start": "nodemon server.js", "lint": "eslint --fix --ext .js ." @@ -45,6 +45,7 @@ "eslint-plugin-n": "^15.6.1", "eslint-plugin-node": "^11.1.0", "eslint-plugin-promise": "^6.1.1", + "jest": "^29.7.0", "nodemon": "^3.0.1" } } diff --git a/EcoSonar-API/routes/app.js b/EcoSonar-API/routes/app.js index 671524b..bd7d606 100644 --- a/EcoSonar-API/routes/app.js +++ b/EcoSonar-API/routes/app.js @@ -2,7 +2,7 @@ const express = require('express') const cors = require('cors') const dotenv = require('dotenv') const urlConfigurationService = require('../services/urlConfigurationService') -const analysisService = require('../services/analysisService') +const { analysisService } = require('../services/analysisService') const retrieveAnalysisService = require('../services/retrieveAnalysisService') const retrieveBestPracticesService = require('../services/retrieveBestPracticesService') const crawlerService = require('../services/crawler/crawlerService') diff --git a/EcoSonar-API/services/analysisService.js b/EcoSonar-API/services/analysisService.js index 16e167d..960c378 100644 --- a/EcoSonar-API/services/analysisService.js +++ b/EcoSonar-API/services/analysisService.js @@ -12,68 +12,69 @@ const w3cRepository = require('../dataBase/w3cRepository') const formatW3cBestPractices = require('./format/formatW3cBestPractices') const formatW3cAnalysis = require('./format/formatW3cAnalysis') -class AnalysisService {} - -/** - * Insert a new analysis into database - * @param {string} projectName - * @param {boolean} autoscroll is used to enable autoscrolling for each tab opened during analysis - */ -AnalysisService.prototype.insert = async function (projectName, autoscroll) { - const allowExternalAPI = process.env.ECOSONAR_ENV_ALLOW_EXTERNAL_API - let urlProjectList = [] - let reports = [] - let systemError = false +class AnalysisService { + + /** + * Insert a new analysis into database + * @param {string} projectName + * @param {boolean} autoscroll is used to enable autoscrolling for each tab opened during analysis + */ + async insert (projectName, autoscroll) { + const allowExternalAPI = process.env.ECOSONAR_ENV_ALLOW_EXTERNAL_API + let urlProjectList = [] + let reports = [] + let systemError = false - try { - urlProjectList = await urlsProjectRepository.findAll(projectName, true) - } catch (error) { - console.log('GREENIT INSERT - can not retrieved urls from project') - systemError = true - } - - if (systemError || urlProjectList.length === 0) { - console.log('GREENIT INSERT - project has no url to do the audit. Audit stopped') - } else { - reports = await launchAuditsToUrlList(urlProjectList, autoscroll, projectName, allowExternalAPI) - const reportsFormatted = formatAuditsToBeSaved(reports, urlProjectList) - - greenItRepository - .insertAll(reportsFormatted.greenitAnalysisFormatted) - .then(() => { - console.log('GREENIT INSERT - analysis has been insert') - }) - .catch(() => { - console.log('GREENIT INSERT - greenit insertion failed') - }) - - lighthouseRepository - .insertAll(reportsFormatted.analysisLighthouseFormatted) - .then(() => { - console.log('LIGHTHOUSE INSERT - analysis has been insert') - }) - .catch(() => { - console.log('LIGHTHOUSE INSERT - lighthouse insertion failed') - }) - - if (allowExternalAPI === 'true') { - w3cRepository.insertAll(reportsFormatted.w3cAnalysisFormatted) - .then(() => { - console.log('W3C INSERT - analysis has been insert') - }) - .catch(() => { - console.log('W3C INSERT - w3c insertion failed') - }) + try { + urlProjectList = await urlsProjectRepository.findAll(projectName, true) + } catch (error) { + console.log('GREENIT INSERT - can not retrieved urls from project') + systemError = true } - bestPracticesRepository - .insertBestPractices(reportsFormatted.bestPracticesFormatted) - .then(() => { - console.log('BEST PRACTICES INSERT - best practices have been inserted') - }) - .catch(() => { - console.log('BEST PRACTICES INSERT : best practice insertion failed') - }) + if (systemError || urlProjectList.length === 0) { + console.log('GREENIT INSERT - project has no url to do the audit. Audit stopped') + } else { + reports = await launchAuditsToUrlList(urlProjectList, autoscroll, projectName, allowExternalAPI) + const reportsFormatted = formatAuditsToBeSaved(reports, urlProjectList) + + greenItRepository + .insertAll(reportsFormatted.greenitAnalysisFormatted) + .then(() => { + console.log('GREENIT INSERT - analysis has been insert') + }) + .catch(() => { + console.log('GREENIT INSERT - greenit insertion failed') + }) + + lighthouseRepository + .insertAll(reportsFormatted.analysisLighthouseFormatted) + .then(() => { + console.log('LIGHTHOUSE INSERT - analysis has been insert') + }) + .catch(() => { + console.log('LIGHTHOUSE INSERT - lighthouse insertion failed') + }) + + if (allowExternalAPI === 'true') { + w3cRepository.insertAll(reportsFormatted.w3cAnalysisFormatted) + .then(() => { + console.log('W3C INSERT - analysis has been insert') + }) + .catch(() => { + console.log('W3C INSERT - w3c insertion failed') + }) + } + + bestPracticesRepository + .insertBestPractices(reportsFormatted.bestPracticesFormatted) + .then(() => { + console.log('BEST PRACTICES INSERT - best practices have been inserted') + }) + .catch(() => { + console.log('BEST PRACTICES INSERT : best practice insertion failed') + }) + } } } @@ -109,6 +110,25 @@ async function launchAuditsToUrlList (urlProjectList, autoscroll, projectName, a } } +function createLighthouseAudit(lighthouseReport, urlProjectList, date) { + const formattedLighthouseMetrics = formatLighthouseMetrics.formatLighthouseMetrics(lighthouseReport) + const urlProjectAudited = urlProjectList.filter((urlProject) => urlProject.urlName === lighthouseReport.url) + const lighthouseAudit = { + idLighthouseAnalysis: uniqid(), + idUrlLighthouse: urlProjectAudited[0].idKey, + dateLighthouseAnalysis: date, + performance: formattedLighthouseMetrics.performance, + accessibility: formattedLighthouseMetrics.accessibility, + largestContentfulPaint: formattedLighthouseMetrics.largestContentfulPaint, + cumulativeLayoutShift: formattedLighthouseMetrics.cumulativeLayoutShift, + firstContentfulPaint: formattedLighthouseMetrics.firstContentfulPaint, + speedIndex: formattedLighthouseMetrics.speedIndex, + totalBlockingTime: formattedLighthouseMetrics.totalBlockingTime, + interactive: formattedLighthouseMetrics.interactive + } + return lighthouseAudit; +} + function formatAuditsToBeSaved (reports, urlProjectList) { const greenitAnalysisFormatted = [] const analysisLighthouseFormatted = [] @@ -140,22 +160,9 @@ function formatAuditsToBeSaved (reports, urlProjectList) { // Format Lighthouse Analysis for (const lighthouseReport of reports.reportsLighthouse) { if (lighthouseReport?.runtimeError === undefined) { - const formattedLighthouseMetrics = formatLighthouseMetrics.formatLighthouseMetrics(lighthouseReport) - const urlProjectAudited = urlProjectList.filter((urlProject) => urlProject.urlName === lighthouseReport.url) - const lighthouseAudit = { - idLighthouseAnalysis: uniqid(), - idUrlLighthouse: urlProjectAudited[0].idKey, - dateLighthouseAnalysis: date, - performance: formattedLighthouseMetrics.performance, - accessibility: formattedLighthouseMetrics.accessibility, - largestContentfulPaint: formattedLighthouseMetrics.largestContentfulPaint, - cumulativeLayoutShift: formattedLighthouseMetrics.cumulativeLayoutShift, - firstContentfulPaint: formattedLighthouseMetrics.firstContentfulPaint, - speedIndex: formattedLighthouseMetrics.speedIndex, - totalBlockingTime: formattedLighthouseMetrics.totalBlockingTime, - interactive: formattedLighthouseMetrics.interactive - } - analysisLighthouseFormatted.push(lighthouseAudit) + const lighthouseAudit = createLighthouseAudit(lighthouseReport, urlProjectList, date); + const lighthouseAuditMobile = createLighthouseAudit(lighthouseReport.mobile, urlProjectList, date); + analysisLighthouseFormatted.push({ ...lighthouseAudit, mobile: lighthouseAuditMobile }) lighthousePerformanceBestPractices.push(formatLighthouseBestPractices.formatPerformance(lighthouseReport)) lighthouseAccessibilityBestPractices.push(formatLighthouseBestPractices.formatAccessibility(lighthouseReport)) } @@ -209,4 +216,4 @@ function formatAuditsToBeSaved (reports, urlProjectList) { } const analysisService = new AnalysisService() -module.exports = analysisService +module.exports = { analysisService, formatAuditsToBeSaved } diff --git a/EcoSonar-API/services/analysisService.test.js b/EcoSonar-API/services/analysisService.test.js new file mode 100644 index 0000000..00159a5 --- /dev/null +++ b/EcoSonar-API/services/analysisService.test.js @@ -0,0 +1,141 @@ +const { formatAuditsToBeSaved } = require('./analysisService'); +const uniqid = require('uniqid') +const lighthouseDesktopJson = require('../test/lighthouse-report-desktop-test.json') +const lighthouseMobileJson = require('../test/lighthouse-report-mobile-test.json') + +jest.mock('uniqid'); +describe('analysis service', () => { + const dateMock = 123456789 + const uniqIdMock = 123456 + + beforeEach(() => { + jest.spyOn(Date, 'now').mockReturnValue(dateMock) + }) + + afterEach(() => { + jest.clearAllMocks(); + }) + + describe('formatAuditsToBeSaved', () => { + + it('should format lighthouse audit with mobile', () => { + uniqid.mockReturnValue(uniqIdMock) + + const reports = { + reportsLighthouse: [ + { + ...lighthouseDesktopJson, + url: 'http://example.com', + mobile: { + ...lighthouseMobileJson, + url: 'http://example.com', + } + } + ], + reportsGreenit: [ + ], + reportsW3c:[] + }; + + const urlProjectList = [ + { + idKey: 'idKey', + urlName: 'http://example.com' + } + ]; + + const formattedAudits = formatAuditsToBeSaved(reports, urlProjectList) + + expect(formattedAudits.analysisLighthouseFormatted).toStrictEqual([ + { + accessibility: { + complianceLevel: "A", + score: 100 + }, + cumulativeLayoutShift: { + complianceLevel: "A", + displayValue: 0.006, + score: 100 + }, + dateLighthouseAnalysis: dateMock, + firstContentfulPaint: { + complianceLevel: "A", + displayValue: 0.3, + score: 100 + }, + idLighthouseAnalysis: uniqIdMock, + idUrlLighthouse: "idKey", + interactive: { + complianceLevel: "A", + displayValue: 2.8, + score: 84 + }, + largestContentfulPaint: { + complianceLevel: "E", + displayValue: 2.9, + score: 37 + }, + performance: { + complianceLevel: "C", + score: 67 + }, + speedIndex: { + complianceLevel: "A", + displayValue: 1, + score: 97 + }, + totalBlockingTime: { + complianceLevel: "D", + displayValue: 350, + score: 50 + }, + mobile: { + accessibility: { + complianceLevel: "G", + score: 50 + }, + cumulativeLayoutShift: { + complianceLevel: "A", + displayValue: 0.006, + score: 100 + }, + dateLighthouseAnalysis: dateMock, + firstContentfulPaint: { + complianceLevel: "A", + displayValue: 0.3, + score: 100 + }, + idLighthouseAnalysis: uniqIdMock, + idUrlLighthouse: "idKey", + interactive: { + complianceLevel: "A", + displayValue: 2.8, + score: 84 + }, + largestContentfulPaint: { + complianceLevel: "E", + displayValue: 2.9, + score: 37 + }, + performance: { + complianceLevel: "F", + score: 20 + }, + speedIndex: { + complianceLevel: "A", + displayValue: 1, + score: 97 + }, + totalBlockingTime: { + complianceLevel: "D", + displayValue: 350, + score: 50 + } + } + } + ]) + + }) + + }) +}) \ No newline at end of file diff --git a/EcoSonar-API/services/format/formatLighthouseAnalysis.js b/EcoSonar-API/services/format/formatLighthouseAnalysis.js index dd3ff65..e523f23 100644 --- a/EcoSonar-API/services/format/formatLighthouseAnalysis.js +++ b/EcoSonar-API/services/format/formatLighthouseAnalysis.js @@ -1,5 +1,188 @@ const formatCompliance = require('./formatCompliance') -class FormatLighthouseAnalysis {} +class FormatLighthouseAnalysis { + + lighthouseAnalysisFormattedDeployments(res) { + let j = 0 + const deployments = [] + + let formattedMetrics + + try { + while (j < res.length) { + formattedMetrics = { + performanceScore: res[j].performance.score, + accessibilityScore: res[j].accessibility.score, + dateAnalysis: res[j].dateLighthouseAnalysis, + largestContentfulPaint: res[j].largestContentfulPaint.score, + cumulativeLayoutShift: res[j].cumulativeLayoutShift.score, + firstContentfulPaint: res[j].firstContentfulPaint.score, + speedIndex: res[j].speedIndex.score, + totalBlockingTime: res[j].totalBlockingTime.score, + interactive: res[j].interactive.score, + mobile: { + performanceScore: res[j].mobile.performance.score, + accessibilityScore: res[j].mobile.accessibility.score, + dateAnalysis: res[j].mobile.dateLighthouseAnalysis, + largestContentfulPaint: res[j].mobile.largestContentfulPaint.score, + cumulativeLayoutShift: res[j].mobile.cumulativeLayoutShift.score, + firstContentfulPaint: res[j].mobile.firstContentfulPaint.score, + speedIndex: res[j].mobile.speedIndex.score, + totalBlockingTime: res[j].mobile.totalBlockingTime.score, + interactive: res[j].mobile.interactive.score + } + } + + deployments[j] = formattedMetrics + + j++ + } + return this.formatDeploymentsForGraphs(deployments) + } catch (err) { + console.log(err) + console.log('LIGHTHOUSE - error during the formatting of project analysis') + } + } + + lighthouseProjectLastAnalysisFormatted(res) { + let analysisDesktop, analysisMobile + let j = 0 + let count, dateAnalysis, desktop, mobile + + try { + while (j < res.length) { + count = 0 + dateAnalysis = res[j].dateLighthouseAnalysis + + // Creating clones + desktop = createClone(res[j]) + mobile = createClone(res[j].mobile) + + while (j < res.length && dateAnalysis.getTime() === res[j].dateLighthouseAnalysis.getTime()) { + desktop.performance.score += res[j].performance.score + desktop.accessibility.score += res[j].accessibility.score + desktop.largestContentfulPaint.displayValue += res[j].largestContentfulPaint.displayValue + desktop.largestContentfulPaint.score += res[j].largestContentfulPaint.score + desktop.cumulativeLayoutShift.displayValue += res[j].cumulativeLayoutShift.displayValue + desktop.cumulativeLayoutShift.score += res[j].cumulativeLayoutShift.score + desktop.firstContentfulPaint.displayValue += res[j].firstContentfulPaint.displayValue + desktop.firstContentfulPaint.score += res[j].firstContentfulPaint.score + desktop.speedIndex.displayValue += res[j].speedIndex.displayValue + desktop.speedIndex.score += res[j].speedIndex.score + desktop.totalBlockingTime.displayValue += res[j].totalBlockingTime.displayValue + desktop.totalBlockingTime.score += res[j].totalBlockingTime.score + desktop.interactive.displayValue += res[j].interactive.displayValue + desktop.interactive.score += res[j].interactive.score + + mobile.performance.score += res[j].mobile.performance.score + mobile.accessibility.score += res[j].mobile.accessibility.score + mobile.largestContentfulPaint.displayValue += res[j].mobile.largestContentfulPaint.displayValue + mobile.largestContentfulPaint.score += res[j].mobile.largestContentfulPaint.score + mobile.cumulativeLayoutShift.displayValue += res[j].mobile.cumulativeLayoutShift.displayValue + mobile.cumulativeLayoutShift.score += res[j].mobile.cumulativeLayoutShift.score + mobile.firstContentfulPaint.displayValue += res[j].mobile.firstContentfulPaint.displayValue + mobile.firstContentfulPaint.score += res[j].mobile.firstContentfulPaint.score + mobile.speedIndex.displayValue += res[j].mobile.speedIndex.displayValue + mobile.speedIndex.score += res[j].mobile.speedIndex.score + mobile.totalBlockingTime.displayValue += res[j].mobile.totalBlockingTime.displayValue + mobile.totalBlockingTime.score += res[j].mobile.totalBlockingTime.score + mobile.interactive.displayValue += res[j].mobile.interactive.displayValue + mobile.interactive.score += res[j].mobile.interactive.score + + count++ + j++ + } + + desktop.largestContentfulPaint.score = calculateAverageScore(desktop.largestContentfulPaint.score) + desktop.cumulativeLayoutShift.score = calculateAverageScore(desktop.cumulativeLayoutShift.score) + desktop.firstContentfulPaint.score = calculateAverageScore(desktop.firstContentfulPaint.score) + desktop.speedIndex.score = calculateAverageScore(desktop.speedIndex.score) + desktop.totalBlockingTime.score = calculateAverageScore(desktop.totalBlockingTime.score) + desktop.interactive.score = calculateAverageScore(desktop.interactive.score) + desktop.performance.score = calculateAverageScore(desktop.performance.score) + desktop.accessibility.score = calculateAverageScore(desktop.accessibility.score) + + mobile.largestContentfulPaint.score = calculateAverageScore(mobile.largestContentfulPaint.score) + mobile.cumulativeLayoutShift.score = calculateAverageScore(mobile.cumulativeLayoutShift.score) + mobile.firstContentfulPaint.score = calculateAverageScore(mobile.firstContentfulPaint.score) + mobile.speedIndex.score = calculateAverageScore(mobile.speedIndex.score) + mobile.totalBlockingTime.score = calculateAverageScore(mobile.totalBlockingTime.score) + mobile.interactive.score = calculateAverageScore(mobile.interactive.score) + mobile.performance.score = calculateAverageScore(mobile.performance.score) + mobile.accessibility.score = calculateAverageScore(mobile.accessibility.score) + + analysisDesktop = createAnalysis(desktop) + analysisMobile = createAnalysis(mobile) + + } + return { ...analysisDesktop, mobile: analysisMobile } + } catch (err) { + console.log(err) + console.log('LIGHTHOUSE - error during the formatting of project analysis') + } + + function createClone(report) { + return { + performance: { ...report.performance, score: 0 }, + accessibility: { ...report.accessibility, score: 0 }, + largestContentfulPaint: { ...report.largestContentfulPaint, score: 0, displayValue: 0 }, + cumulativeLayoutShift: { ...report.cumulativeLayoutShift, score: 0, displayValue: 0 }, + firstContentfulPaint: { ...report.firstContentfulPaint, score: 0, displayValue: 0 }, + speedIndex: { ...report.speedIndex, score: 0, displayValue: 0 }, + totalBlockingTime: { ...report.totalBlockingTime, score: 0, displayValue: 0 }, + interactive: { ...report.interactive, score: 0, displayValue: 0 }, + } + } + + function createAnalysis(rawReport) { + return { + performance: { + displayValue: Math.trunc(parseFloat(rawReport.performance.score)), + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.performance.score) + }, + accessibility: { + displayValue: Math.trunc(parseFloat(rawReport.accessibility.score)), + complianceLevel: formatCompliance.getAccessibilityGrade(rawReport.accessibility.score) + }, + dateAnalysis, + largestContentfulPaint: { + displayValue: calculateAverageScore(rawReport.largestContentfulPaint.displayValue, 1) + ' s', + score: rawReport.largestContentfulPaint.score, + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.largestContentfulPaint.score) + }, + cumulativeLayoutShift: { + displayValue: calculateAverageScore(rawReport.cumulativeLayoutShift.displayValue, 3), + score: rawReport.cumulativeLayoutShift.score, + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.cumulativeLayoutShift.score) + }, + firstContentfulPaint: { + displayValue: calculateAverageScore(rawReport.firstContentfulPaint.displayValue, 1) + ' s', + score: rawReport.firstContentfulPaint.score, + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.firstContentfulPaint.score) + }, + speedIndex: { + displayValue: calculateAverageScore(rawReport.speedIndex.displayValue, 1) + ' s', + score: rawReport.speedIndex.score, + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.speedIndex.score) + }, + totalBlockingTime: { + displayValue: calculateAverageScore(rawReport.totalBlockingTime.displayValue, 0) + ' ms', + score: rawReport.totalBlockingTime.score, + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.totalBlockingTime.score) + }, + interactive: { + displayValue: calculateAverageScore(rawReport.interactive.displayValue, 1) + ' s', + score: rawReport.interactive.score, + complianceLevel: formatCompliance.getEcodesignGrade(rawReport.interactive.score) + } + } + } + + function calculateAverageScore (score, toFixParam) { + return (score / count).toFixed(toFixParam) + } + } + +} FormatLighthouseAnalysis.prototype.lighthouseUrlAnalysisFormatted = function (analysis) { let formattedAnalysis @@ -46,146 +229,6 @@ FormatLighthouseAnalysis.prototype.lighthouseUrlAnalysisFormatted = function (an return formattedAnalysis } -FormatLighthouseAnalysis.prototype.lighthouseProjectLastAnalysisFormatted = function (res) { - let analysis - let j = 0 - let count, performance, dateAnalysis, accessibility, largestContentfulPaint, cumulativeLayoutShift, firstContentfulPaint, speedIndex, totalBlockingTime, interactive - - try { - while (j < res.length) { - count = 0 - dateAnalysis = res[j].dateLighthouseAnalysis - - // Creating clones - performance = JSON.parse(JSON.stringify(res[j].performance)) - accessibility = JSON.parse(JSON.stringify(res[j].accessibility)) - largestContentfulPaint = JSON.parse(JSON.stringify(res[j].largestContentfulPaint)) - cumulativeLayoutShift = JSON.parse(JSON.stringify(res[j].cumulativeLayoutShift)) - firstContentfulPaint = JSON.parse(JSON.stringify(res[j].firstContentfulPaint)) - speedIndex = JSON.parse(JSON.stringify(res[j].speedIndex)) - totalBlockingTime = JSON.parse(JSON.stringify(res[j].totalBlockingTime)) - interactive = JSON.parse(JSON.stringify(res[j].interactive)) - - performance.score = 0 - accessibility.score = 0 - largestContentfulPaint.displayValue = 0 - largestContentfulPaint.score = 0 - cumulativeLayoutShift.displayValue = 0 - cumulativeLayoutShift.score = 0 - firstContentfulPaint.displayValue = 0 - firstContentfulPaint.score = 0 - speedIndex.displayValue = 0 - speedIndex.score = 0 - totalBlockingTime.displayValue = 0 - totalBlockingTime.score = 0 - interactive.displayValue = 0 - interactive.score = 0 - - while (j < res.length && dateAnalysis.getTime() === res[j].dateLighthouseAnalysis.getTime()) { - performance.score += res[j].performance.score - accessibility.score += res[j].accessibility.score - largestContentfulPaint.displayValue += res[j].largestContentfulPaint.displayValue - largestContentfulPaint.score += res[j].largestContentfulPaint.score - cumulativeLayoutShift.displayValue += res[j].cumulativeLayoutShift.displayValue - cumulativeLayoutShift.score += res[j].cumulativeLayoutShift.score - firstContentfulPaint.displayValue += res[j].firstContentfulPaint.displayValue - firstContentfulPaint.score += res[j].firstContentfulPaint.score - speedIndex.displayValue += res[j].speedIndex.displayValue - speedIndex.score += res[j].speedIndex.score - totalBlockingTime.displayValue += res[j].totalBlockingTime.displayValue - totalBlockingTime.score += res[j].totalBlockingTime.score - interactive.displayValue += res[j].interactive.displayValue - interactive.score += res[j].interactive.score - count++ - j++ - } - - largestContentfulPaint.score = calculateAverageScore(largestContentfulPaint.score) - cumulativeLayoutShift.score = calculateAverageScore(cumulativeLayoutShift.score) - firstContentfulPaint.score = calculateAverageScore(firstContentfulPaint.score) - speedIndex.score = calculateAverageScore(speedIndex.score) - totalBlockingTime.score = calculateAverageScore(totalBlockingTime.score) - interactive.score = calculateAverageScore(interactive.score) - performance.score = calculateAverageScore(performance.score) - accessibility.score = calculateAverageScore(accessibility.score) - - analysis = { - performance: { displayValue: Math.trunc(parseFloat(performance.score)), complianceLevel: formatCompliance.getEcodesignGrade(performance.score) }, - accessibility: { displayValue: Math.trunc(parseFloat(accessibility.score)), complianceLevel: formatCompliance.getAccessibilityGrade(accessibility.score) }, - dateAnalysis, - largestContentfulPaint: { - displayValue: calculateAverageScore(largestContentfulPaint.displayValue, 1) + ' s', - score: largestContentfulPaint.score, - complianceLevel: formatCompliance.getEcodesignGrade(largestContentfulPaint.score) - }, - cumulativeLayoutShift: { - displayValue: calculateAverageScore(cumulativeLayoutShift.displayValue, 3), - score: cumulativeLayoutShift.score, - complianceLevel: formatCompliance.getEcodesignGrade(cumulativeLayoutShift.score) - }, - firstContentfulPaint: { - displayValue: calculateAverageScore(firstContentfulPaint.displayValue, 1) + ' s', - score: firstContentfulPaint.score, - complianceLevel: formatCompliance.getEcodesignGrade(firstContentfulPaint.score) - }, - speedIndex: { - displayValue: calculateAverageScore(speedIndex.displayValue, 1) + ' s', - score: speedIndex.score, - complianceLevel: formatCompliance.getEcodesignGrade(speedIndex.score) - }, - totalBlockingTime: { - displayValue: calculateAverageScore(totalBlockingTime.displayValue, 0) + ' ms', - score: totalBlockingTime.score, - complianceLevel: formatCompliance.getEcodesignGrade(totalBlockingTime.score) - }, - interactive: { - displayValue: calculateAverageScore(interactive.displayValue, 1) + ' s', - score: interactive.score, - complianceLevel: formatCompliance.getEcodesignGrade(interactive.score) - } - } - } - return analysis - } catch (err) { - console.log(err) - console.log('LIGHTHOUSE - error during the formatting of project analysis') - } - function calculateAverageScore (score, toFixParam) { - return (score / count).toFixed(toFixParam) - } -} - -FormatLighthouseAnalysis.prototype.lighthouseAnalysisFormattedDeployments = function (res) { - let j = 0 - const deployments = [] - - let formattedMetrics - - try { - while (j < res.length) { - formattedMetrics = { - performanceScore: res[j].performance.score, - accessibilityScore: res[j].accessibility.score, - dateAnalysis: res[j].dateLighthouseAnalysis, - largestContentfulPaint: res[j].largestContentfulPaint.score, - cumulativeLayoutShift: res[j].cumulativeLayoutShift.score, - firstContentfulPaint: res[j].firstContentfulPaint.score, - speedIndex: res[j].speedIndex.score, - totalBlockingTime: res[j].totalBlockingTime.score, - interactive: res[j].interactive.score - } - - deployments[j] = formattedMetrics - - j++ - } - return this.formatDeploymentsForGraphs(deployments) - } catch (err) { - console.log(err) - console.log('LIGHTHOUSE - error during the formatting of project analysis') - } -} - FormatLighthouseAnalysis.prototype.formatDeploymentsForGraphs = function (deployments) { const duplicatedDeployments = [] @@ -202,7 +245,19 @@ FormatLighthouseAnalysis.prototype.formatDeploymentsForGraphs = function (deploy speedIndex: 0, totalBlockingTime: 0, interactive: 0, - numberOfValues: 0 + numberOfValues: 0, + mobile: { + performanceScore: 0, + accessibilityScore: 0, + dateAnalysis: duplicatedValuesArray[0].dateAnalysis, + largestContentfulPaint: 0, + cumulativeLayoutShift: 0, + firstContentfulPaint: 0, + speedIndex: 0, + totalBlockingTime: 0, + interactive: 0, + numberOfValues: 0 + } } // We add up every element with the same date (only DD/MM/YYYY) in one (sumElement) @@ -216,6 +271,15 @@ FormatLighthouseAnalysis.prototype.formatDeploymentsForGraphs = function (deploy sumElement.totalBlockingTime += element.totalBlockingTime sumElement.interactive += element.interactive sumElement.numberOfValues++ + sumElement.mobile.performanceScore += element.mobile.performanceScore + sumElement.mobile.accessibilityScore += element.mobile.accessibilityScore + sumElement.mobile.largestContentfulPaint += element.mobile.largestContentfulPaint + sumElement.mobile.cumulativeLayoutShift += element.mobile.cumulativeLayoutShift + sumElement.mobile.firstContentfulPaint += element.mobile.firstContentfulPaint + sumElement.mobile.speedIndex += element.mobile.speedIndex + sumElement.mobile.totalBlockingTime += element.mobile.totalBlockingTime + sumElement.mobile.interactive += element.mobile.interactive + sumElement.mobile.numberOfValues++ }) duplicatedDeployments.push(sumElement) @@ -238,7 +302,16 @@ FormatLighthouseAnalysis.prototype.formatDeploymentsForGraphs = function (deploy i.speedIndex = Math.round(i.speedIndex / i.numberOfValues) i.totalBlockingTime = Math.round(i.totalBlockingTime / i.numberOfValues) i.interactive = Math.round(i.interactive / i.numberOfValues) + i.mobile.performanceScore = Math.round(i.mobile.performanceScore / i.mobile.numberOfValues) + i.mobile.accessibilityScore = Math.round(i.mobile.accessibilityScore / i.mobile.numberOfValues) + i.mobile.largestContentfulPaint = Math.round(i.mobile.largestContentfulPaint / i.mobile.numberOfValues) + i.mobile.cumulativeLayoutShift = Math.round(i.mobile.cumulativeLayoutShift / i.mobile.numberOfValues) + i.mobile.firstContentfulPaint = Math.round(i.mobile.firstContentfulPaint / i.mobile.numberOfValues) + i.mobile.speedIndex = Math.round(i.mobile.speedIndex / i.mobile.numberOfValues) + i.mobile.totalBlockingTime = Math.round(i.mobile.totalBlockingTime / i.mobile.numberOfValues) + i.mobile.interactive = Math.round(i.mobile.interactive / i.mobile.numberOfValues) delete i.numberOfValues + delete i.mobile.numberOfValues } function compareFullDate (firstDate, secondDate) { diff --git a/EcoSonar-API/services/format/formatLighthouseAnalysis.test.js b/EcoSonar-API/services/format/formatLighthouseAnalysis.test.js new file mode 100644 index 0000000..c581df7 --- /dev/null +++ b/EcoSonar-API/services/format/formatLighthouseAnalysis.test.js @@ -0,0 +1,134 @@ +const formatLighthouseAnalysis = require('./formatLighthouseAnalysis') +const lighthouseReportsDto = require('../../test/lighthouse-report-dto-test.json') +describe('format lighthouse analysis', () => { + + afterEach(() => { + jest.clearAllMocks(); + }) + + describe('lighthouseAnalysisFormattedDeployments', () => { + + it('should present lighthouse report', () => { + lighthouseReportsDto.deployments[0].dateLighthouseAnalysis = new Date(lighthouseReportsDto.deployments[0].dateLighthouseAnalysis) + lighthouseReportsDto.deployments[0].mobile.dateLighthouseAnalysis = new Date(lighthouseReportsDto.deployments[0].mobile.dateLighthouseAnalysis) + const presentedReports = formatLighthouseAnalysis.lighthouseAnalysisFormattedDeployments(lighthouseReportsDto.deployments) + expect(presentedReports).toStrictEqual([ + { + accessibilityScore: 94, + cumulativeLayoutShift: 1, + dateAnalysis: new Date('2024-02-02T10:57:24.843Z'), + firstContentfulPaint: 100, + interactive: 18, + largestContentfulPaint: 0, + performanceScore: 15, + speedIndex: 33, + totalBlockingTime: 0, + mobile: { + accessibilityScore: 94, + cumulativeLayoutShift: 1, + dateAnalysis: new Date('2024-02-02T10:57:24.843Z'), + firstContentfulPaint: 100, + interactive: 19, + largestContentfulPaint: 0, + performanceScore: 16, + speedIndex: 37, + totalBlockingTime: 0 + } + } + ]) + }) + + }) + + describe('lighthouseProjectLastAnalysisFormatted', () => { + + it('should present lighthouse last analysis', () => { + lighthouseReportsDto.lastAnalysis[0].dateLighthouseAnalysis = new Date(lighthouseReportsDto.lastAnalysis[0].dateLighthouseAnalysis) + lighthouseReportsDto.lastAnalysis[0].mobile.dateLighthouseAnalysis = new Date(lighthouseReportsDto.lastAnalysis[0].mobile.dateLighthouseAnalysis) + const presentedReports = formatLighthouseAnalysis.lighthouseProjectLastAnalysisFormatted(lighthouseReportsDto.lastAnalysis) + expect(presentedReports).toStrictEqual({ + accessibility: { + complianceLevel: "B", + displayValue: 94 + }, + cumulativeLayoutShift: { + complianceLevel: "G", + displayValue: "1.162", + score: "1" + }, + dateAnalysis: new Date('2024-02-02T10:57:24.843Z'), + firstContentfulPaint: { + complianceLevel: "A", + displayValue: "0.8 s", + score: "100" + }, + interactive: { + complianceLevel: "F", + displayValue: "11.5 s", + score: "18" + }, + largestContentfulPaint: { + complianceLevel: "G", + displayValue: "11.2 s", + score: "0" + }, + performance: { + complianceLevel: "F", + displayValue: 15 + }, + speedIndex: { + complianceLevel: "E", + displayValue: "6.9 s", + score: "33" + }, + totalBlockingTime: { + complianceLevel: "G", + displayValue: "10330 ms", + score: "0" + }, + mobile: { + accessibility: { + complianceLevel: "B", + displayValue: 94 + }, + cumulativeLayoutShift: { + complianceLevel: "G", + displayValue: "1.198", + score: "1" + }, + dateAnalysis: new Date('2024-02-02T10:57:24.843Z'), + firstContentfulPaint: { + complianceLevel: "A", + displayValue: "0.8 s", + score: "100" + }, + interactive: { + complianceLevel: "F", + displayValue: "11.4 s", + score: "19" + }, + largestContentfulPaint: { + complianceLevel: "G", + displayValue: "11.1 s", + score: "0" + }, + performance: { + complianceLevel: "F", + displayValue: 16 + }, + speedIndex: { + complianceLevel: "E", + displayValue: "6.6 s", + score: "37" + }, + totalBlockingTime: { + complianceLevel: "G", + displayValue: "10260 ms", + score: "0" + } + } + }) + }) + + }) +}) \ No newline at end of file diff --git a/EcoSonar-API/services/lighthouse/lighthouse.js b/EcoSonar-API/services/lighthouse/lighthouse.js index 36dfb5c..5345a21 100644 --- a/EcoSonar-API/services/lighthouse/lighthouse.js +++ b/EcoSonar-API/services/lighthouse/lighthouse.js @@ -7,66 +7,91 @@ const viewPortParams = require('../../utils/viewportParams') module.exports = { lighthouseAnalysis: async function (urlList, projectName) { - const browserArgs = [ + const browserArgsDesktop = [ '--no-sandbox', // can't run inside docker without '--disable-setuid-sandbox', // but security issues '--ignore-certificate-errors', '--window-size=1920,1080', '--start-maximized' ] + const configDesktop = { ...config } + const results = await lighthouseAnalysisWithSpecifiedConfig(urlList, projectName, browserArgsDesktop, configDesktop) + const browserArgsMobile = [ + '--no-sandbox', // can't run inside docker without + '--disable-setuid-sandbox', // but security issues + '--ignore-certificate-errors', + '--window-size=430,932', + '--start-maximized' + ] + const configMobile = { ...config } + configMobile.screenEmulation.width = 430 + configMobile.screenEmulation.height = 932 - const proxyConfiguration = await authenticationService.useProxyIfNeeded(projectName) - if (proxyConfiguration) { - browserArgs.push(proxyConfiguration) - } - - // start browser - const browser = await puppeteer.launch({ - headless: true, - args: browserArgs, - ignoreHTTPSErrors: true, - // Keep gpu horsepower in headless - ignoreDefaultArgs: [ - '--disable-gpu' - ], - defaultViewport: viewPortParams.viewPortParams + const resultsMobile = await lighthouseAnalysisWithSpecifiedConfig(urlList, projectName, browserArgsMobile, configMobile) + results.forEach((result) => { + const currentResultMobile = resultsMobile.find((resultMobile) => result.url === resultMobile.url) + if (currentResultMobile) { + result.mobile = currentResultMobile + } }) + return results + } +} + +async function lighthouseAnalysisWithSpecifiedConfig (urlList, projectName, browserArgs, config) { - const results = [] - const options = { logLevel: 'error', output: 'json', onlyCategories: ['performance', 'accessibility'], port: (new URL(browser.wsEndpoint())).port, disableStorageReset: true } - try { - let lighthouseResults - let userJourney - const loginSucceeded = await authenticationService.loginIfNeeded(browser, projectName) - if (loginSucceeded) { - for (const [index, url] of urlList.entries()) { - try { - console.log('Lighthouse Analysis launched for url ' + url) - await userJourneyService.getUserFlow(projectName, url) + const proxyConfiguration = await authenticationService.useProxyIfNeeded(projectName) + if (proxyConfiguration) { + browserArgs.push(proxyConfiguration) + } + + // start browser + const browser = await puppeteer.launch({ + headless: true, + args: browserArgs, + ignoreHTTPSErrors: true, + // Keep gpu horsepower in headless + ignoreDefaultArgs: [ + '--disable-gpu' + ], + defaultViewport: viewPortParams.viewPortParams + }) + + const results = [] + const options = { logLevel: 'error', output: 'json', onlyCategories: ['performance', 'accessibility'], port: (new URL(browser.wsEndpoint())).port, disableStorageReset: true } + + try { + let lighthouseResults + let userJourney + const loginSucceeded = await authenticationService.loginIfNeeded(browser, projectName) + if (loginSucceeded) { + for (const [index, url] of urlList.entries()) { + try { + console.log('Lighthouse Analysis launched for url ' + url) + await userJourneyService.getUserFlow(projectName, url) .then((userflow) => { userJourney = userflow }).catch((error) => { console.log(error.message) }) - if (userJourney) { - lighthouseResults = await userJourneyService.playUserFlowLighthouse(url, browser, userJourney) - } else { - lighthouseResults = await lighthouse(url, options, config) - } - console.log('Lighthouse Analysis ended for url ' + url) - results[index] = { ...lighthouseResults.lhr, url } - } catch (error) { - console.log('LIGHTHOUSE ANALYSIS - An error occured when auditing ' + url) - console.error('\x1b[31m%s\x1b[0m', error) + if (userJourney) { + lighthouseResults = await userJourneyService.playUserFlowLighthouse(url, browser, userJourney) + } else { + lighthouseResults = await lighthouse(url, options, config) } + console.log('Lighthouse Analysis ended for url ' + url) + results[index] = { ...lighthouseResults.lhr, url } + } catch (error) { + console.log('LIGHTHOUSE ANALYSIS - An error occured when auditing ' + url) + console.error('\x1b[31m%s\x1b[0m', error) } } - } catch (error) { - console.error('\x1b[31m%s\x1b[0m', error) - } finally { - await browser.close() } - return results + } catch (error) { + console.error('\x1b[31m%s\x1b[0m', error) + } finally { + await browser.close() } -} + return results +} \ No newline at end of file diff --git a/EcoSonar-API/services/lighthouse/lighthouse.test.js b/EcoSonar-API/services/lighthouse/lighthouse.test.js new file mode 100644 index 0000000..6f81935 --- /dev/null +++ b/EcoSonar-API/services/lighthouse/lighthouse.test.js @@ -0,0 +1,75 @@ +const puppeteer = require('puppeteer'); +const lighthouse = require('lighthouse') +const authenticationService = require('../authenticationService'); +const userJourneyService = require('../userJourneyService'); +const lighthouseAnalysis = require('./lighthouse'); + +jest.mock('puppeteer'); +jest.mock('lighthouse'); +jest.mock('../authenticationService'); +jest.mock('../userJourneyService'); + +describe('lighthouseAnalysis function', () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + + it('should analyze URLs with Lighthouse', async () => { + // given + puppeteer.launch.mockResolvedValue({ + close: jest.fn(), + wsEndpoint: jest.fn().mockReturnValue('ws://example.com'), + }); + authenticationService.loginIfNeeded.mockResolvedValue(true); + + userJourneyService.getUserFlow.mockResolvedValue(undefined); + userJourneyService.playUserFlowLighthouse.mockResolvedValue({ /* lighthouse results */ }); + + lighthouse.mockResolvedValueOnce({ + lhr: { + categories: [ + { + speedIndex: { + score: 50 + } + } + ] + } + }).mockResolvedValueOnce({ + lhr: { + categories: [ + { + speedIndex: { + score: 30 + } + } + ] + } + }) + + // when + const result = await lighthouseAnalysis.lighthouseAnalysis(['http://example.com'], 'projectName'); + + // then + expect(result).toStrictEqual([{ + categories: [ + { + speedIndex: { + score: 50 + } + } + ], + mobile: { + categories: [ + { + speedIndex: { + score: 30 + } + } + ], + url: 'http://example.com' + }, + url: 'http://example.com' + }]); + }); +}); \ No newline at end of file diff --git a/EcoSonar-API/services/retrieveAnalysisService.js b/EcoSonar-API/services/retrieveAnalysisService.js index 3f30af4..a4b213c 100644 --- a/EcoSonar-API/services/retrieveAnalysisService.js +++ b/EcoSonar-API/services/retrieveAnalysisService.js @@ -129,7 +129,6 @@ RetrieveAnalysisService.prototype.getProjectAnalysis = async function (projectNa if (res.deployments.length !== 0) { // deployments lighthouseAnalysisDeployments = formatLighthouseAnalysis.lighthouseAnalysisFormattedDeployments(res.deployments) - // lastAnalysis lighthouseProjectLastAnalysis = formatLighthouseAnalysis.lighthouseProjectLastAnalysisFormatted(res.lastAnalysis) } else { diff --git a/EcoSonar-API/test/lighthouse-report-desktop-test.json b/EcoSonar-API/test/lighthouse-report-desktop-test.json new file mode 100644 index 0000000..9eed8d9 --- /dev/null +++ b/EcoSonar-API/test/lighthouse-report-desktop-test.json @@ -0,0 +1,6655 @@ +{ + "lighthouseVersion": "9.3.0", + "requestedUrl": "http://localhost:3000/", + "finalUrl": "http://localhost:3000/", + "fetchTime": "2024-02-01T09:46:26.034Z", + "gatherMode": "navigation", + "runWarnings": [], + "userAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/121.0.6167.85 Safari/537.36", + "environment": { + "networkUserAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4695.0 Safari/537.36 Chrome-Lighthouse", + "hostUserAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/121.0.6167.85 Safari/537.36", + "benchmarkIndex": 2259.5, + "credits": { + "axe-core": "4.3.5" + } + }, + "audits": { + "is-on-https": { + "id": "is-on-https", + "title": "Uses HTTPS", + "description": "All sites should be protected with HTTPS, even ones that don't handle sensitive data. This includes avoiding [mixed content](https://developers.google.com/web/fundamentals/security/prevent-mixed-content/what-is-mixed-content), where some resources are loaded over HTTP despite the initial request being served over HTTPS. HTTPS prevents intruders from tampering with or passively listening in on the communications between your app and your users, and is a prerequisite for HTTP/2 and many new web platform APIs. [Learn more](https://web.dev/is-on-https/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "viewport": { + "id": "viewport", + "title": "Has a `` tag with `width` or `initial-scale`", + "description": "A `` not only optimizes your app for mobile screen sizes, but also prevents [a 300 millisecond delay to user input](https://developers.google.com/web/updates/2013/12/300ms-tap-delay-gone-away). [Learn more](https://web.dev/viewport/).", + "score": 1, + "scoreDisplayMode": "binary", + "warnings": [] + }, + "first-contentful-paint": { + "id": "first-contentful-paint", + "title": "First Contentful Paint", + "description": "First Contentful Paint marks the time at which the first text or image is painted. [Learn more](https://web.dev/first-contentful-paint/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 250.27999999999997, + "numericUnit": "millisecond", + "displayValue": "0.3 s" + }, + "largest-contentful-paint": { + "id": "largest-contentful-paint", + "title": "Largest Contentful Paint", + "description": "Largest Contentful Paint marks the time at which the largest text or image is painted. [Learn more](https://web.dev/lighthouse-largest-contentful-paint/)", + "score": 0.37, + "scoreDisplayMode": "numeric", + "numericValue": 2853.9699999999993, + "numericUnit": "millisecond", + "displayValue": "2.9 s" + }, + "first-meaningful-paint": { + "id": "first-meaningful-paint", + "title": "First Meaningful Paint", + "description": "First Meaningful Paint measures when the primary content of a page is visible. [Learn more](https://web.dev/first-meaningful-paint/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 250.27999999999997, + "numericUnit": "millisecond", + "displayValue": "0.3 s" + }, + "speed-index": { + "id": "speed-index", + "title": "Speed Index", + "description": "Speed Index shows how quickly the contents of a page are visibly populated. [Learn more](https://web.dev/speed-index/).", + "score": 0.97, + "scoreDisplayMode": "numeric", + "numericValue": 1020.5271856668203, + "numericUnit": "millisecond", + "displayValue": "1.0 s" + }, + "screenshot-thumbnails": { + "id": "screenshot-thumbnails", + "title": "Screenshot Thumbnails", + "description": "This is what the load of your site looked like.", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "filmstrip", + "scale": 3000, + "items": [ + { + "timing": 300, + "timestamp": 6398103028, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAFMAeAMBEQACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AP1ToAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD//Z" + }, + { + "timing": 600, + "timestamp": 6398403028, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAFMAeAMBEQACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AP1ToAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD//Z" + }, + { + "timing": 900, + "timestamp": 6398703028, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAFMAeAMBEQACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AP1ToAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD//Z" + }, + { + "timing": 1200, + "timestamp": 6399003028, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAFMAeAMBEQACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AP1ToAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD//Z" + }, + { + "timing": 1500, + "timestamp": 6399303028, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAFMAeAMBEQACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AP1ToAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgAoAKACgD//Z" + }, + { + "timing": 1800, + "timestamp": 6399603028, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 2100, + "timestamp": 6399903028, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 2400, + "timestamp": 6400203028, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 2700, + "timestamp": 6400503028, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 3000, + "timestamp": 6400803028, + "data": "data:image/jpeg;base64,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" + } + ] + } + }, + "final-screenshot": { + "id": "final-screenshot", + "title": "Final Screenshot", + "description": "The last screenshot captured of the pageload.", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "screenshot", + "timing": 1641, + "timestamp": 6399444012, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAFcAfQDASIAAhEBAxEB/8QAHQABAAEFAQEBAAAAAAAAAAAAAAECBAUGBwMICf/EAFUQAAEDAwEDBQoKCAMECgIDAAEAAgMEBRESBiExBxMUQVEiU1VhkZOUlbHTGDJSVHFzgZLR0ggVIyY0NVbUFkKhMzeysxckNmJydHWiwfBDgmSD8f/EABoBAQADAQEBAAAAAAAAAAAAAAABAwQCBQb/xAAzEQEAAQIDBgQGAQQDAQAAAAAAAQIRAwQhEhMxUWGRBRVB8CJTcYGh0bEUMlLBI0PhM//aAAwDAQACEQMRAD8A+qUREBEXGNneUfa26crlbs5PbKKCx01ZND0jo03Ovjbq0kHVp34GTjG9W4WDVixVNPpF5RNUQ7Oi5rsnttervt/WWippIRa4+dMVQ2CRhcGnuclxxw8S6Us9GJGJF6WnM5XEy1UUYnGYie4iIu2cRFbVtYyka3LXySPOGRsGXOP/AN6zuSZsmImZtC5RYdl4mDpOdoJGsicGyFj2vMe7O8D6erKy0b2yMa9jg5jhkEcCFEVRPB1Xh1UcVSIilwIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAvGseI6WV7vitaSV7K1u38rq/qnexBiLfWsnpy4y84Q4guDNP+mfGixdg/g3/WH2BEG6oiIC5beqy9/wCKq2KLai3wUobUcxDIS0wvbHnJ7nDtIy47/s3ZXUlo98tVnnuUr6qz0kz2ukLpH1YjcTIAHAjO8OAAI4Y3Y4oMNPc7y6anZR7WWySGmmp5JZHPAfPC5jScsDDpLi9mACc6vsXjebxtDHawYNoLeysigiikZHOzPPOY0h/dR4dqAe4M7nOeO5bbTbF7Pywc9DQNp5ZGkCSnndmPewjS4HdpMbNONzcbsZOfeXYmwSiXnKEufMMSyc/Jrk3OHdO1Zduc4bydxwgttjZLxWVc1dXV9NU2+SNzY2QOLgyQSvO4lrdQDSwZ8RW2Kys9qo7NQto7dEYqZpLmsL3OwScne4kq9QFgbtVVNNXVEtO2mfzEDZHNe52sMydWBjG/Hb1LPLEX6jgqAyY1jaKqhBDJiRjDuLXA7nNOOHi3EFd0WmfiTE24NE5NLttRXXS5uuFFrikPOCWQc1HnOAGuAOodnH6eC6FZJTLSyYDQxkz2M0nIwHEbvtyPsWEp6K4wUNPbzdrfSUTWiJjqaIiQt4ANL3kA7jv3lbFbY6aGhhioSw00bdDC12oYG7j1q7M1UV1TXRTEdINqZ4rlERZkNYodtLdWVVREGvhjp6mWmkmmlia0OjEhccB5cB+ydxA3b+Gce8G19lmujaJtbCC+FssUjngNky57SB4xzZz9IXtPsxaZ6QU01MXwc7PMWl53um1iTO/r5x/0Z3cF5v2TtUsbmVMc9TqEbXGed8hcGPc5oJJyRl7vs3ILtl/tT7a+4NuFOaNjgx0of3IccYH0nIwOvI7Vb2bai1XYU4p6qJs9RqMcLnjU4Nc4ZGO3Q4jxA9i86PZGz0dmda6WCSKlMrZxolcHtkaRpcHZyCNI8iot2xlkt1yp7hS0rxWQNLWyulc4nOrecnee7dvPagvTtDaA6VpuFPmMvDu64FhAcPsLgPpKtRthYnzU8UNximknm6OwRZd3ZDiAccPinf4laVmxdDPc6WpjwyKOuNwma7U50soGG4Jdhrc4JGDnA7Fex7KWqOSnkjilZJT81zbmzOBbzfOaevslkB7Q5Ba0m29lqrZSVrKqJsc7mtex8rWuhLml3dAnqxvx4+xZKTaOzx55y5UrcSmA5ePjjcR9nX2LGVWwez1VHAyooi8QRxxRkyOy1rAQ0cexx/8AoU1ewtgq6h09RRukldOaguMrvjHGevgcDd4h2IMvfLxSWW2y11a/EETmNkII7nW8NBOSMDLgT4sqwo9sLHVc+Y7jTiKOo6M2UyNLJX6GOOggnIGsAnqKvq2y26sZUNmpYgah8ckz2N0ukMbg5mpw3nBA4rH3HY2x3GqNRV0euYz9I1a3DuyxjD18CI2bvEgU211skZNJUytpI4jjVM9oyecljwADnjE48OH0HGVorpQ100sVFVwzyRhrniNwdgOALTu7QQfoIWLfshaHEuEU8chcHiSOd7HtOqV2Q4HI3zSfY7CurTs9bbTVyVFBAYpHwxwEa3FoYwYaACeoBBlkREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBabtPt/R2Day3bPyWy6VlXWsbIH0kIfHEwuLdTzqBAGCSccFuS1raDYbZ3aG+0F4u9vFRcaHT0ebnpGaNLtQ3NcAd+/eFbhThxV/yXt0RN7aMhdb7SWuqihqxI1rgHOmAGiMFwYC45yMuIHD6cBeVNtRZ56XpDa6IR78nVnGCR1Z37iccQN5wr6stlDWzxzVlJBPLGMMdIwOLevrXgdn7QY9BtlGWEacc0MY7FEbFtb3NXmdpLMH6TcacHU5m92AC0gHf2ZIGeGThUt2ns8jWuir4JGkaiWvHct7rujnq7hw+kHsOLt9ntr866CldkYOYgc90Hf8QB+kLzFhtIbgW2kwW6D+yHxd4x9G8+Up/x9TVXQ3i319Q6Cjq4pZmglzGneMYz9o1DI6sjKv1aUltoqN4dSUkELgCMsYAd+nPl0t8gV2uJtfRIrW7fyur+qd7FdK1u38rq/qnexQNUsH8G/wCsPsCJYP4N/wBYfYEQbqipMsY4vaPtUc9F3xn3ggrWEq7G+etfO2amAcd7X0jXnG/dn7fasxz0XfWfeCc9F31n3ggtaCmqoHu6RVtmjxhjGxBgb/qr1Uc9F31n3gnPRd9Z94IK0VHPRd9Z94Jz0XfWfeCCtY242WjuEvO1DHc53OHNdgjSSR7Vf89F31n3gnPRd9Z94Kaappm8SMb+oqMv1O51x8burJdj6Mkq9oKOKhpmwU4IjaSQCc4Xrz0XfWfeCc9F31n3gpmuqYtMitFRz0XfWfeCc9F31n3guRWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFaKjnou+s+8E56LvrPvBBWio56LvrPvBOei76z7wQVoqOei76z7wTnou+s+8EFatbt/K6v6p3sXvz0XfGfeCtbpIx1sqg17SeadwPiQavYP4N/1h9gRLB/Bv+sPsCINrdRRuOSFT0CLsV4iCz6BF2J0CLsV4uHXflV2oZtXc7RZrNT1ppZ5I2tjhkkeWtdjJDT9C0ZfLYmYmYw/TXjZnx8zRl4ia/V2XoEXYnQIuxcLuXK9tlajELpYKej53Ojn6eWPVjGcZO/iF3JsdxLQel0u//wDjO/OusfJ4mXiJxLWnhrfh9HOBm6MeZii+nH0VdAi7E6BF2KOauPzul9Gd+dOauPzul9Gd+dZrdWi88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2KOauPzul9Gd+dOauPzul9Gd+dLdS88k9Ai7E6BF2LyMlbBV0jJpqeSOaQsIbCWEdw52c6j8lZFJiyYm6z6BF2LwuNKyO3VTmjhE72LJq1u38rq/qnexQlqlg/g3/WH2BEsH8G/wCsPsCIN1REQF857L7Q2zZrll2lrLzUGnpnSVEQfoc/ujICBhoJ6ivoxaXceTDZK419RWVlrMlTUPMkj+kSjU4nJOA7C3ZLHwcLbpxr2qi2lr8erFnMDFxdirCtemb6uM8sO1Fov9u2bprTcOnS0THtnkEL4xkhgBw4DjpK+gLnS3SSYyWyWCMvgbHrkcctIdnc3SQcjdnq471rv/RJsX4HPpU351uQoYwMc5Ueed+KszuYwMXDw8LBvam/G3rr6OMpl8bDrrxMW16rcL+n1Ymut96qY442V0bGmmax7t2oTZ3vb3PZn/TcFVHSX0MrA6uhBfE0U/8Am0OwM5OkZ353+Ph1LKdBj75Ueed+KdBj75Ueed+K87RvvLFUdDe21sElZWskhY5pLGvxkaCHZwwZ7rBA+nhwXgLdf21b5mVsGXyRBxc7OY2ueXADRuyHDdv4fGWc6DH3yo8878U6DH3yo8878U0Lyxtvo73DND0uvZPEGnnM4BJ0N4YaP84cfoIVu2n2jhgqXS1UErhRyNjbHguM3+R29oHb+CzXQY++VHnnfinQY++VHnnfimheWFZbb42WSo6ewTGPQGFwLd3OYydA4Fzd4A4HOeultFtNhubjTbnMLsdYAcCPif8AhP2Hgs50GPvlR5534p0GPvlR5534poXlg7hQXuufcY21McdM/LIWvIPUzBGG5H+ffk8erCqkt9/dJI5txjbjWIxkYGWuw4jRvwSzuTngTkrNdBj75Ueed+KdBj75Ueed+KaF5WjKa4utfMzzxvqjE9pfkFuonud2neAP/wDDxVjJb75HFSRUddCyOKlEbweJkAI1ZLTkfF7OHjWZ6DH3yo8878U6DH3yo8878U0LyxsVBdG0rGvrS6ZtVzxdzm50ZzlvxeAzw68DeM7rOel2ijt9QH1MVQ5zHANGHOB07gO4AOp2eOMDtWe6DH3yo8878U6DH3yo8878U0LyxUVLf21DnOrIHQudjScZa3VkuGGdmBp39Z1KYqO+spJ2OuET53QxiORwG6QfH4NGAerj/wDCynQY++VHnnfinQY++VHnnfimheWNp6O9Mim524MfI+FzWZAwyTS0NI7kdesnOeI3dS8jQ358ozcGxxEszhzXODct1AfsxvwHd148Y61l+gx98qPPO/FOgx98qPPO/FNC8sJ+r9oHd0+4xh4iLWlrsAOMeNRGjBw8ZA8f2K46JfBN/GxuhbJuw4Nc5mXnJOggHDmDAG/TxGVk+gx98qPPO/FOgx98qPPO/FNC8sJDbb7CKcNr4yGNayRznAueQfjElm/dnud3HjuyfV1FfhbWRR3KN1UJWudK9o7pnNgOG5uB3eSN3DAWW6DH3yo8878U6DH3yo8878U0LysI6O6x01LGysaXsmdzznnUXx6sjHc/GwAMcACd5wFbGgvstvpY562nM7J9cpH+ZgOQAdPEHxfasx0GPvlR5534p0GPvlR5534poXlgqq27QVFI+GS4QEyROjfjuWg4IBxpycjSeIwc8RuXtPSbRPfFzdfTxta4hwAyXt3YdnTuPHLfHxWX6DH3yo8878U6DH3yo8878U0LyxV0t14npubpbg0fsWMcJA3u3ZdrJOndnucbsbju35Vrb4topZpukTNYzniMPAAEetpGnDd50tcD1d3kHcs/0GPvlR5534p0GPvlR5534poXlr1HZr7TmBouELI2sYx5jA1YEmTxacktOMnr8quIbdtA5uKi7NBDjvia3uhlvUWbtwdu8fErM9Bj75Ueed+KdBj75Ueed+KaF5YaCh2i1SGoucPHUwRtAB47iCzhwzv346llrRDVU1I2GskEr2budL9Tn7zx3DG7Hb/pk19Bj75Ueed+KdBj75Ueed+KaF5XSK16DH3yo8878U6DH3yo8878U0LyukVr0GPvlR5534p0GPvlR5534poXldIrXoMffKjzzvxToMffKjzzvxTQvK6RWvQY++VHnnfinQY++VHnnfimheV0itegx98qPPO/FOgx98qPPO/FNC8rpFa9Bj75Ueed+KdBj75Ueed+KaF5XSK16DH3yo8878U6DH3yo8878U0LyukVr0GPvlR5534p0GPvlR5534poXldIrXoMffKjzzvxToMffKjzzvxTQvK6RWvQY++VHnnfinQY++VHnnfimheXncP422fXu/5T1fK1bQxNmjlJlc6MlzdUjiAcEcM9hKuklEROtxWt2/ldX9U72K6Vrdv5XV/VO9ih01Swfwb/AKw+wIlg/g3/AFh9gRBuqIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiL5p5Utu9oLNt5tjFQbQXOl/VopHUNJDStlp3F7Gl4lcW4Y3fnJI4lB9LIuXzbUWq1ba1Vzuc9d0iDZllwnMNRrozHzn/42dby7g7OCD41Tsxyv0l3uDqSstZo5JKKSupebrYqjnWMbqLXhh/Zvxv0nxoOpIuX7N8q77vcbEyq2ZuFutt8Dm2+tmmY4SyBpdpLW72g4OCePYr2l5UqCpstoq4rfVdOuF0NpFAXN52GZriH6urDQA4+IhB0NFyaXlstjL26FtAXWdld+r3V3TIg/nNWnUIM6zHn/N/ovW+crkluq74YNlrjV2yx1XR7hXMmja2Mbu6a0nL+O8bsDG/eg6oi1WDbSkn2gu9rip5XOt9BHcDNkaZGPBIAHHO5arXcsdEy3WGS320z192pDXMpqisipmwxAluXSPOnJIIAHHBQdURYDYnamj2u2Wpb5QMkjgmDg6N+C5jmktc3duOCDvHFadZOVlt02cvN/wD1BUR2igp5KhkzaqJ7pNDiCxzAdUbzjODnd1oOoItSn23pYbtYKA0kxfd6GWujdqGI2sYHlp8Z1Ly5N9s6nba3uuQsNXbbW9jXU1RUSscag5Idhrd4AIG88coNyRcbl5S49nOVva+27Q1VfJbYo6Q0cEFK6YRExAv+ICRkkcV5bG8qMYouUHaK7VVXPZbdWsFHE+LQ9rHDDWBpAIJcRxQdpRcYuXKh+vtlNsLcKV1qvNLZZq6B1NXx1ALNJGoSRHuXg43cRlXFj2ltdovFPX3epupqafZCnr6l76jXA6PIyQw7zKXdfXnxoOvouaWflSlluFuhv+zFxstJdWOkt1TLIyUT6W69Lmt3scW8AeKyvJtt1LtvBLVR2aSjt+kPgqOlRTB4JI0ua05Y/dktI3dqDdkWjMuNyPLbJbDVSfqgWAVIp92nnukFurtzp3LeUBERAREQEREBERAREQEREBERAREQEREBWt2/ldX9U72K6Vrdv5XV/VO9iDVLB/Bv+sPsCJYP4N/1h9gRBuqIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAuV7Tcltzu20u0lwoNqnW6h2giigraVlAyRzo2R6MCRzt2Rq3gda6oiDnM3JVbpqqZr6uX9WybPssAp9PdtY1+oSa8/G4bscR9ittl+Te52oyRV14tc9K2iko4uj2eKCV2pukPkkBJJA6hjPWunog0Gl5OxBa9h6P9Z6v8Mytl18xjpGGFuMau54561b2zkupqHlQqNrRcHvp3PkqIbdzWGQ1EjGsklDs7yQ09XX4l0ZEHJ6TknqrZeZXWi626Kzy1prDDUWmKeojy7U6Nkrv8pPDIyMrMVfJyKixbbW79Z6f8S1L6jnOYz0fU1oxjV3XxeO7iugIg5ntDydXWa6m4bNbRNtc9TbWWutEtIJhLG0EB7e6Gl2Ce1W105I42R7Py7P11NBXWmhFuzcKJtVFURZz3TCRh2rJyO3C6qiDC7J2eosmztPb6mrhqalgcXTw0rKdhJJO6Nu4AZ/03rQ7dyTSyXC+1V+u1PO6526S3SGhoW0pkD3Z56UAkOkHaAF1ZEHM9mOTm60l4pK/aPaJt0dbqB9vt7I6QQiNjgGl7+6Op2AAtt2C2d/wnshbLF0npXQo+b57Ro17yc6cnHHtWfRBq9k2TFr272j2k6Zzv64ZTs6PzWOa5pmn42e6zx4DC1+s5LKWvodtKStuD3xbR1TKoFkQaaZ7cFuN51YIB6uxdIRBy+38m10NpvlDdbxa3C4W99vY6hs8dOWahgyOIOXH/u5AV1NyXUtXUyGvr3y00uzsdgfE2LS7DXaudDsnBz1Y+0royIOX2jk4vZudmn2k2q/WdNY2u/V0TKJsREmnS2SQ5OotHV2/bm+2A5P6vZzae4Xy43Kkqaqqp20zmUVEKVkmHaudkaHEOkPDIx19q6EiDAts9cNuH3k18Jt5oRSij6K3WH69WvnfjY/7vDrWeREBERAREQEREBERAREQEREBERAREQEREBWt2/ldX9U72K6Vrdv5XV/VO9iDVLB/Bv8ArD7AiWD+Df8AWH2BEG6oiICIiAiIgIiICIiAiIgIiIMTtHXV1FSxG2Uj6qdz8ljQDhgBJ4kDfgNG/wDzZwcYXgL7O6bS23S6DIWBztYOAcZI0cTxAzjHEhZ1EGpRbS3J0cTn2aoa46pHM0kuLcPIa3AxnuWg5I3kbt6vKS/1c8VQ91qfG6GmdNoLyXOcCcMHc4OcZyCeI3LYUQa1PtLUQ1UlO61yOew4BaX4fjOQ3uN5yN3AHIOd6om2iuEUzw20zyNjYSWgODnnLADnGA3ujvyT3J3bls5a0uDi0FzeBxvClBrhv9eIXTGyTlgYX6GvJkJAPc6dOM5GOPXlUf4guT6bnWWZzDqa3EkjvlN1Hc07tLic+LgtmRBgay9Vsd1fSQ2uR0LHxg1D3ENcHackAAndq/0PDCVV6rWV8kEFtkk0FzQSSGuwWYOrScfGdu38FnkQatNtJW5mgjtb21LYOcAy5+8h+nA0jI7nfkjjgZXqzaC4STOjZZJhiQs1SSFoI1tYDuaflZ+gE71sYY0PLw0ayAC7G8gcB/qfKpQaw3aSueHFtiqQAA7u3YJHNl53Bp37tIHWT1K5fd62Okglkojzjqx0D4ow93cBxGrOnswezxq4vF+prTKI6iOZ5LDJ+zAO7fwBIJO7qBxxOBvXhX7SU1PRxzRMdLzrpGR900NOh2knJO8Z4YyT2cUHpFdan9bGifRvLXF+mUBwaAM6c7sb8cc9Y3b1i6a+3g21/P27FdzJkHcv0F3NNcGtGnfvODnH2rJS7QxQTOppIJZKxh0vihLTg9weLiPljecZwexeMe1tBJS1tQyKrMdKWB37Le/U7SNIz29uO1B6U98q31U0MtoqGCKJ7y9pyHuaSNLcgZBxuO7iNy8rdfa2evip5rZII5Xu/bNyGMAG74wBO/PUOI4qW7UwSGn5qkqdEzw1r36GjBB3/G6iAMcd+7KopNqoaieihNNMySpldHvAIAAHdbicZLm7jvwUEs2iqpHMiZapekOAdpc8hoaZNGSdPUSDw4ZPUqYr3c5JyTa9MLSCW6natJY1xPxcZBLhjrx1L0j2hoRUSBlPI+rLxG4RtaHOw5jRkkjdmQcexytmbY0ztDuZk5oQGZ7u5zu07g3OR8Y8ccN2RvQRFtNcBSmSWx1Rky7SzgfjNxnccYDt56tJV7UXWvkqqGmpqMwmojD3yStc4Rksecbhjc5rc5I4jtVB2tt4hdI5k40tc7SNLyQ3nM40uIOOaPDtHasva6+G5UbKmn1BruLXbnNPYR1FBjG3upfNGyO2TFucSOdqboOpoOO5341Z6hgHevCW+3Blzli/VcgpY5ubMj9WS0NedQDQc5LQB9I6ytkRBqse0VwmLw22SM1MOjLXktcNe89yAWnQMHIPdN3b16DaOsbEC6z1L3iPWQ0HJPN6sY08ScjGd32hbMiDXIL/AF8hYXWWZrCQHftCXD4mSBpwfj7t+/S7hheI2kuclHJLHYpmPEReGyPPxtLyBgN/7mD1guAwtpRBrd12iqKOp6PT0HSJOYbJlsuO6cSA0AjJwAXHhuBOF4VG1VRTwxmW1SNe/AHOv5sNOnUdRLcAbjjBO4HOFs5p4TUCcwx8+G6RJpGrHZnjhKinhqWBlRDHKwHUGvaHAHt3oNeq9pKilLOctjsPDcOD3YBdIGNydHjzuyfEoF+uIbNI61TGPU0xhgJeRiPUMED5bsHdw3gYWyvY14Ae0OAIOCM7wcg+VSg1yPaSZ0UrhbJ5JGagGQ6nayG5IBLRg8OOM5WYtNXJXUEVRNTuppH5zE45LcEjj9mVdNY1pcWtALjk4HE9qlAREQEREBERAREQEREBERAVrdv5XV/VO9iula3b+V1f1TvYg1Swfwb/AKw+wIlg/g3/AFh9gRBuqIiAiIgIiICIiAiIgIiICK3qJ3RvAaBwzvXl0t/Y1BeorLpb+xqdLf2NQXqKy6W/sanS39jUF6isulv7Gp0t/Y1BeorLpb+xqdLf2NQXqKy6W/sanS39jUF6isulv7Gp0t/Y1BekAkEgZCjS3AGBgcNys+lv7Gp0t/Y1Be4Gc4GVGlu/cN/HcrPpb+xqdLf2NQXmkdgQsaeoKz6W/sanS39jUFxT08VPCyKFgaxowBx/1PFemluc4HkVn0t/Y1Olv7GoLmKCKIERsa0Elxx2k5K9AABgABWXS39jU6W/sagvUVl0t/Y1Olv7GoL1FZdLf2NTpb+xqC9Rcz5a+UC5bB7JQXW2U1JUTyVbKctqA4t0lrzncQc9yFw74T21fgiyfcl/Ot2X8NzGZo28KLx9YcVYlNM2l9eovkL4T21fgiyfcl/Onwntq/BFk+5L+daPJM5/j+Yc76h9eovkL4T21fgiyfcl/Onwntq/BFk+5L+dPJM5/j+YN9Q+vUXyF8J7avwRZPuS/nT4T21fgiyfcl/Onkmc/wAfzBvqH16i+QvhPbV+CLJ9yX867XyB8o9w5RrPdKm60dLTTUc7Yx0bUGua5ueDiTnd2qnH8MzGXonExKdI6wmnEpqm0OpIiLz1giIgIiICIiAiIgK1u38rq/qnexXStbt/K6v6p3sQapYP4N/1h9gRLB/Bv+sPsCIN1REQEREBERAREQEREBERBZVv+1H0LWqiW8xV1S+CJssDnARNeRhoxvO7fxH/ALvEsxe/1x0ln6qoaGoi0906orHQkHPAARPyPHlY796fBFn9aSf266imZRdQ6oupkjkZTs0jUHREYzvbjus9Q1HP+iRVV3c1hkpYW5wHaQXY+NvxkdjR/wDtnqwq/wB6fBFn9aSf26fvT4Is/rST+3TYn3MF3kKm8R6B0WOUOeXFxOCG7iG7uvBO/wASuJ6i4x82xlPHI9zGkvG5odvzuznd3PlKo/enwRZ/Wkn9un70+CLP60k/t02J9zBd6Sz3FscJjp43O0kyA7snOBjfu3ZPX2LyNTdXPyyljbH2PHdHj493AeXxYU/vT4Is/rST+3T96fBFn9aSf26bE+5gu8oam8aHvkpo25dnT8bSO5GBvGcd0T29S9JnXKR8T2tMQEcetjSD3Tnd390Kf3p8EWf1pJ/bp+9Pgiz+tJP7dNifcwXWVMb0ZIGVPOBmpmt7Q3eCHFw3cMEtb9njVxRuuRqoOe6QYtb9eoMAxjuTu37sYx485wF6/vT4Is/rST+3T96fBFn9aSf26bE+5guU9XcnvjEtG1ocd5+TvbnO/qBdv6yBuVMFRdQ+rElMwsa17oSTvec5aD1Y347d3jVX70+CLP60k/t0/enwRZ/Wkn9umxPuYLqTVXUPDBSRneWl2N2MkB3H6Djx8VWKm5CjLn0zOe1AANHAFoJOM79+7j7FH70+CLP60k/t0/enwRZ/Wkn9umxPuYLqWSXSJkcQjEshDC+V4GBnc7cCOHH7Cqauou55nmKdjP2Gt5PdYkIPc48Rx178+Jen70+CLP60k/t0/enwRZ/Wkn9umxPuYLvKWquxnAjpu4Y84On44xjB7rdk78/6KIKm7NaNdNqLmtPdDODkAjcR4yP/AIXt+9Pgiz+tJP7dP3p8EWf1pJ/bpsT7mC7yZVXl8eXUkEbsnLd7urcOI8f07lWyquzpXh1HCxgfuOSctzjxbzuOereqv3p8EWf1pJ/bp+9Pgiz+tJP7dNifcwXXtudUOpGOrMCc51AN0438OJVysT+9Pgiz+tJP7dP3p8EWf1pJ/bpsT7mC7LIsT+9Pgiz+tJP7dP3p8EWf1pJ/bpsT7mC7LIsT+9Pgiz+tJP7dP3p8EWf1pJ/bpsT7mC7ln6WP+7Wk/wDUov8AlyL5FX2tyu7D7Wbf7MQ2mOnstC6OqbUc66vkkzhrhjHMj5X+i498GTbLwjYfPy+7X0/hGdwMvl9jFqtN5Z8Wiqqq8Q1ERur5KyGCotsmz76OXoVG2aES6xETGBHnWJQ8DUcd1h28ggHA7KS2NtlvMV4bEayXSykL2k6TzU2/UN7Rr5reOvA4ZXTPgybZeEbD5+X3afBk2y8I2Hz8vu1tjP5S0073lzV7uvk0Cst2x0Gt1Bc6mpcxjC0TuEYce6y7cx2eDO4OD3R39ntNRbEVU9bUfrCspdbi6KBmkhn7SQcdA3aWxkADcH9eFvPwZNsvCNh8/L7tPgybZeEbD5+X3af1+U+d77G7q5OeU0eylO3pAM07HR1DXQyVA1tOmQMA/ZYzujIfni7GndlVVtu2Mp6KSSnuddVVDXTYjBawOAc8M36D1Bh4b8nh1dB+DJtl4RsPn5fdp8GTbLwjYfPy+7U+YZS997/P6N3VycKX1b+hl/2e2l/81F/wFaP8GTbLwjYfPy+7XbP0fuTq7cndqu9Neqiinkq5mSMNK9zgAGkHOpoWTxXxDL42Wqow67zp/LvCoqiq8w6uiIvk2oREQEREBERAREQFa3b+V1f1TvYrpWt2/ldX9U72INUsH8G/6w+wIlg/g3/WH2BEG6oiICItGvW3FczaCutGzGzlTfai3NYa57ahlPHCXDU1gL/jPxvwO0b0G8otan22slB+rYr3VstNfXRtkZR1jg2RmrcA/BIbv3ZJxlW975RNmbQbtHUXJj6y1xOlqaWNpMjQNO7GMby9oG/G/wARwG2otQg5SNlX7OUV7qLtDSUVX3MfPgteXYBc3TjJIzvIyPGrm7bebL2mkpqquvVIynqYuehewmQPjzjX3IPc5OM8M7kGzItX/wCkDZUVj6V97pWVDIRUvY/LS2MxiTUcjcNJB3+1Dt/sqLMLsb5SC3GcU3PEnDZSM6CMZBwM70G0ItBv/KXZqO22S6W2voam01lxFFU1JecQDm3uJI4h3cjcR1rKt2vpK2t2ddZqy3VVtujpwZjK4PPNsLv2YAwSCDqDiMAINpRYSw7V2LaCpnp7LdKasmhGp7InZOnONQ7W53ZGQs2gIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiArW7fyur+qd7FdK1u38rq/qnexBqlg/g3/WH2BEsH8G/6w+wIg3VERAWh3XY29QbSXK77I7QRWt10DDWQVNGKhhka3SJGd03S7SACN4OFviIOX7c8nF82npRSybVOdTuo46eUTQOGqRrtRl0xvY06t25zXYxuWxUexrYqfa+CepDmbQTPeXMZh0TXQtix4yNJP2rbkQc2j2DvsEGz9TT32gbebPTPoY5n0BdDJTuDR3TOcyHjQDqDt+8Ywud7YbG1ez1fb7fRtrKqlprW4Od0ColiuUzqh8phcKcjQA7g1x0gO696+jUQc+o9k7rWUG0lf00Wi7bRQUzyGR63UT2Qta5mc91vyMjGM7t+9abfdgL1Z46R8FwbWV9w2joqrnW00srKfRE5up4fI5zm5AyS77RuXc0Qc3o+Tiq/WFPc7ldIKi5OvMd2qjHTc3E7RC6JrGM1HG4g6iSSQkfJmTWwyT3AGnbX3KrfGyMtJZVsLdAOdxbnOetdIRBznk35OJNkLmKmatpatsNJ0KB7YZGy6NTT3RdK5v+UbmtaF0ZEQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAVrdv5XV/VO9iula3b+V1f1TvYg1Swfwb/AKw+wIlg/g3/AFh9gRBuqIiAqGsaRvaPIq1DPihA0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCNDfkt8iaG/Jb5FKII0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCNDfkt8iaG/Jb5FKII0N+S3yJob8lvkUogjQ35LfImhvyW+RaZWbbSU92njbbBJbKevjtkk4qAJjO8Nxpi0725e0Z1A8TjAysPZuU2eqfBJcLJU01JJTxVGqMc4889MYoWtA4kkbyg6Xob8lvkTQ35LfItat+3Fjro7xJDUPEdpY99U90Zw1rS4OIxxwWOGOO7sIJxVLylWv8AWMtJcYqijldWCmp45IiJHDm4XFzm9XdTtG7O7fwzgN60N+S3yJob8lvkWuXjbO1Wmrr6arM4mo42SSNDMag4gDTkjPEb+HVnIIWKq+U2zRwSyUdPX1elrHM5uHS2UO5r4rnYG4Txkg44oN40N+S3yJob8lvkWs2nbGgue0FxttO7fRQ65AWnUHtOJGnqGnLRx3knHBWI5Stnxbm1kzquCJ3NO0zQFrgyRpcyTHW0hp4ZO47kG6aG/Jb5E0N+S3yLXRtfQOtba9tPXOhfWGhjaIDqlkDi3uR1tyCM+JYRnKjYuj1dUZJJadlS2ngEEZc6XLHOB34GSWPw3Odw6yAg33Q35LfImhvyW+RajR7d218jIaoTMmdO6F3NxOcyL/rD4I9bsbi58ZH0+LespsttPQbTUz5re2oYGNjeWzxGNxa9upjgDxBHX4kGa0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCNDfkt8iaG/Jb5FKII0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCNDfkt8iaG/Jb5FKII0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCNDfkt8iaG/Jb5FKII0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCNDfkt8iaG/Jb5FKII0N+S3yJob8lvkUogjQ35LfImhvyW+RSiCgtaC0hoG/sVah3Fv0qUBWt2/ldX9U72K6Vrdv5XV/VO9iDVLB/Bv8ArD7AiWD+Df8AWH2BEG6oiIChnxQpUM+KEESPDG6ncFUN4REBFh9rtoqDZTZ2tvV2e5tHSM1P0DLnEkANA7SSB9q5Gzl9ngFPXXfYa90Gz0zmgXF4JaGu+K7GgA58TvoytGDlcXGjaoi8e+HP7OZrini7ouLbY7ZbX7R8oVZsbyby0VIbdCJK641LdQY447hu4jdkdRJOeGFd7UcuFtp7i217G2ur2quT42ygUO+JocMjLgCc7xndu4EgpyF7MbR2+87VbS7U0cNuqL7OyVtEx+p0eC45JycfG4cdxzhaMLBnL0VY2LEXt8MT6zfl9L8dHM1bU2hgK/Z7lX2Inpb5QbQT7XlzyK22PbpYG44sBP8AwgHONxGQui8l3KRaNv7Q2eleylubMiot75AZIiOvqJb48f6reFzDbnkV2b2muDblRmex3XXrkqredBk7cjhk/KG/tyojHwseNnHjZn0qiP5iLR941Nmaf7XSLhVw0FDUVlU/RTwRukkd2NAySub2blZirrrRQ1dkrKK3V0vM0tZI7LXuzjhjt3bicLT9h7jc9kdrazk026mqq613TW2019RLqL4yCNBPHeN2M7juxghe2x2yXPcoc9jrblVVNt2fe2opoXbgXEhw3dW878cfEvNz+Hi5fEopom8VcJ5+9fu9zwrCymNgY1WPHxUxf10jhpb12pp46Wu7w9oe0tPAo0aWgDgFKLt44iIgxz7HapLu26vttG65tGG1RhaZQMY+NjPDcpZZbYxsbWW+la2NsbWARDuRG7XGB4mu3jsO9WVXbbm6rmlpa5rWAkwNdk6dTTnOQQe60kbtwyFTUUN8mIYa6BsJ1teAN7gQdP8Al3EEjr6uvKDIU9mtlO+sfBb6SN1ZnpJbE0c9nOde7uuJ49pVpBsps/TtibBZLbG2KXn4w2mYNEmANQ3bj3Ld/iHYrd9FtC0tEFwpgxrCNJYBk6ABv07hqBP2/Yvea33ItEsVYW1IgijJLtxcC7Ufi435G/T1cB1B712ztmr55Z661UNRNKAJHywNc5wGMZJHVgeQKP8ADll6Oaf9VUPMFhjMfMN06S1rSMY4EMYP/wBR2LHU9kutPNUzxXUmaVr8amgtDi6QjdjgNTOv/LjgvesoL3K2jMVwiZJFH3Z07nSaXDONO8ZLezGOBzgBfQ2O2U81RPS0FNT1E8fNSTRRNa9zcYwTjfwHkCxdu2G2bobPTW0Wagmgga0Zlp2Fz3Bobrdu3uIG8q5qaW+lkHR66BrhC1shc0YMgO9w7ngf/uF4VNtvr4HtZdGOe5mnu2gN36M7g3xPHiBHFBmW26ibDFC2lgEUUnPRsDBhj8k6gOo5JOfGVru0GwNkvFO2JsAoP2xqHPo4o2l7y1zcnLSM4c7B4gnIIWSqbfcprg+YVobE2BzYWt3aZCG4JGN4BaTvPXjHb4zUW0Dg90VzgY57yQwxgtY3dhoOnO7ut5zndwQXTNnLMyWll/VlG6emLnQyvha57C5xc4hxGclxJJ7SSryht1HQNxQ0sFONDI8RMDe5YMNbu6gNw7Fir1SXtzpJrdWRnRreyFzBx0ANAOPlauPb4sLypaO/vga6SuZFI9vdZa0kO0AZ+Lg7xkcMdeeADZEWGqaS8PdStguMbGNa5sziwannqPDGeHUBlKykvDqVopbhGydsbWlzmAhzs9074vEjHi47uwMyiwRob02JwiuY1atxeGndl+/4njZu/wC7jIzlUTUe0Lo5BFcqdry0BvcDcRgZ+L190SOo4A3ZQbAixFNR3RlayWor+dh7vMYAbjJ3f5d+MDx7zvPBWsNDf4omt/WUTy2IMy8A6naQNROnty7rzkDdjJDYUWBqqC9PghdDXwsq2CRpeW5Dg57S3djGQ1pHDr+1KygvU9PCxlwijeHyF7wzfpPxMbuIHi9m8M8i1x9vvr6psjq+JsbQA1oOSBu1Z7jfw8X0hSLdfooGR09xgZpGMuZnfl2/GnfuLevq8obEi14UG0HNOJu0Ym0kAc00sBw0D/Lk79R49n0KptBfP2bpLm0uDgXNa1rR8UDGdHaXHf4uCDPotfrqC+TdCdDXwxyQsBfu3Ok0vBONO8HUOzGOBXtU0l6c2EQ18TcQtEncAF0nWQdJAH2dXVncGaRa+aC/NjeIrqzVry3WwEaS95P+XduLAOPxT25VxVUVylrecjrebjZIHxtGMadJBaRp7fGfFhBmEWBhor6xzXSV8D3B7C7uR3TBnU3Ondk7+G7hv4rPDOBnigIiICIiAiIgIiICIiCHcW/SpUO4t+lSgK1u38rq/qnexXStbt/K6v6p3sQapYP4N/1h9gRLB/Bv+sPsCIN1REQFDPihSoZ8UILO93ahsdqqbldallNQ0zNcsr+DR/8AJ6sDiuOv5Z73tHUyR8m+xlbd6aMkOrao8zET4uryuB8S3blt2dn2p5Mr3baMnpRjE0Tc/HdG4P0/bpx9qsORfa6mvfJRQV8cMcctBTmCenhI3OiGNwHDUAHAeNbcKnDowJxqqdqb246RppOms319fRxN5q2Yco5V9pOUqu2JrrftfsVTw2yu0xslopOckilDg5hIa527IA3gceK67yTPbtVyP2im2gtzi00vQqinqoyOcEfcZwe0NBWlUXKVtO2SgvNXLbZLRWVfRhQx452MZ49ucdZPZu3ru6pjxHDzOFu8OjZmJvpf1jrf+fRuzvhmNkKo3sxN7xprrHGPrHuWrbF7AbN7FzVsuzduFG+r0iU869+Q3OANROBvPBZy93SlstqqbjcJObpadut7sZP0Dxk7lerD7X2OPaTZyttUshibUNAEgGdLgQQcde8BU42JiV3qmb1dVGBTh7ymMTSm8Xty9WubI8pdr2ku7ba2lrKKolYZIOktAEzRv3EHsBP2Le1xDkms9bedp3112r+ebs451vp42sAzgOaDkdQGe08F29ZstXXXRtVvQ8Xy2Blsfd4HKL63i88pmI9LTw4sVednbReq621l0oIamqt0vP0kjwcxP3bx5Bx7B2I+x0sNTcq62xRUt2rY9DqrTqOoDDSRnBxu3deFp9Ta+Up3KA2qgvtnbsnz7XGkMP7bmsDU34nxuO/V4/EuirZiU22b1RP+u7y6a6ovEaX49Xz3Lf8AlE2F5QdlbXtLtFQ36mvNRzDqaGnayRjC5rec3MBGNWeOO5K+hFw7Z6L/ABD+lDtDWVgaW2GgZT0zCMkFzR3X/vk8oXcVpzsxeiLRE7MTNotx14R0mHFHqIiLE7EREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERBDuLfpUqHcW/SpQFa3b+V1f1TvYrpWt2/ldX9U72INUsH8G/6w+wIlg/g3/WH2BEG6oiIChnxQpUM+KEErVtmdgtntmL3c7pZKLotTccc+1r3c3xJ7lucDJPUtpRdRXVTExE6TxRZxixbLWyHlxuNOy3NFFTUzaqFhB0MlOg6h9pdgfguzrV+UWr2pobAKjYigo6+5slaXwVLsB0W/Vp3jus44nhlYHkk5Szt1JdaCutMtqvFqeI6qFz9bckuBwcDBBacg+UqMHJ1UYVWJRa19eGl+jZnc/Xm66ZxL6UxGs34R/vi2rbRu0D9naluyElFHeSW8y6sBMYGoas468ZwrTk+ZtZHZZBt1Lbpbnzx0GhBDebwMZyBvzq4dWFs6LvefBsWj6+vdjtrdibBs9brDJXvtsTo3Vs5qJsuLsvPZngOK1rlP2ruNhfaLfY4oDcbnKY45J/iMwWjy5cFva0nlhtFHcth7jUVUHOT0UTp6d4JBY78PEsuNExhzsaPRyFdGJm6JzPxRM2116R9YibaX4RZ5cmO1dxv0l3t18igbcbZKI5JKf4j86h5ctKjlb5Q6fYOzwmGDp17rn81Q0Lc5ldkDJxv0jI4cSQOvd68jtoo7bsPb6ilgEdRWxNmqHkkl7vt9iwn6QGw9PtLsjUXamLKe+2eM1VLV6ywtazu3NznsBIJ4HHjWnw6KaqqIzE6T7j/wBV+KbuMxiRl4tETbtpPO15vMR6KeRnYq+Wm43rarbKaI7Q3stMkEWNMDBwbu3Z4DdnAA3neuqLUOSTamXbLk/tN6qYuaqZmOZMBwL2OLHEeIluftW3qzNVV1YtW80mNPpbS32YaYi2giIqHQiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiIIdxb9KlQ7i36VKArW7fyur+qd7FdK1u38rq/qnexBqlg/g3/AFh9gRLB/Bv+sPsCIN1REQFDPihSoZ8UIJREQFxD9G1vPXblFr4j/wBVqL29sYHDc559jwu0V1RHSUVRUzO0xQxukeewAZK47+ifTyM5OK2skGG11zmnZnjpw1vH6WlbcHTLYs89mP5n/Tif7odpXzFfbvXm7XirrrvdafaWCu5ujo4w7mzHq8mMdXXu45X06tAvOztfU8rtlvUVM11ugpXMll1DuXYfjdx/zBeRm8OquI2ef8+v2e94Jm8LLYlc4sRPwzOtvTXZ1idKuE+rdrW+olttK+tYGVTommVo4NfjePKtTj5Ttj6jat2zDbq113551MYDDJgyDi3Vp09RHFbqsd+pbRFcHXP9W0LK7e41XMMEnDBOvGeHjW3D2IvtxM8vr2eJVeZvDINaGtDWgBoGAB1K2u0VNNa6uK4RCajfC9s0ZbqD2EHUMdeRncsZadr7Bd7g6htt1pqirbn9mx284447fsWdcMggHHjVdNUTrTLvEwq8OdnEiYnq4f8Aonyc5sntB0Vzxam3aQUcUjsujZpacHs3EfbldwXzLW2W+ch20dlrKLaN11t17uZiq7e6EMdJqI7sDJy7B4jG/SOBwvppej4jTE4u+om9NXD7cVGHw2Z9BEReesEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERBDuLfpUqHcW/SpQFa3b+V1f1TvYrpWt2/ldX9U72INUsH8G/6w+wIlg/g3/WH2BEG6oiIChnxQpUM+KEEoipL2h4aeJQcj/SgrrrRcm4bbHzRUlRVMhuEsLcuZTkHP2E6Qfpx1rc+Sxuz0ewlqi2PqBUWaOMtik36nHJLi7O8O1EkjA3lbRNFHPE+KZjZIngtcxwyHA8QQuH3rkov2x9e+9ckt1mhcZudlslTL/1eUHiG5IHiwd+ODhgLdhVUYuDuKp2ZibxPpP15dJ4K5iYnadzRcNZyq7fWMug2r5N66eRp3z2wufHjxYDx/7lXbOXlsV/gg2s2auGztmrNQpa6sa4ZLQM6m6eGTxBOMj6VHl+PMXpiJ+kxP8AEp3lLt61zaCak2ktN/sNquVM65sgMMsbJAXQOe06dYG8ZWMPKtsIIpZDtVatMXxgJgSfoHF32ZXO/wBHSogr9uuUe42rXU2errWSwVr2FpeS6RxaM78DV7O1cRk6pwq68SJi0cucxH+3VOLsV0zTxY7YWx11y2qtNBDa6a3T7PzZuFXG8a5u6yA7tzgjr4n6F2vbPa207JWOquN0q4GczE6SOF0rWvncBkMYDxJ4farG1bEw0d02mqZKyWSK9jS5jBodECHA4cDnPdHB3YWo2P8AR+2IttWKiqhrrq9py1tdPqaPsaGg/QchY/D8DCw6Z30zGvpEa/mLaWer4zn/AOtxqasO1oiOfGdauN5/umftwYDYWybQ8qe01p272wLKKyUT+ftFsiOSd+57j2ZaDk7zgbgOPe1RBDFTwRwwRsihjaGMYwYa0DcAB1BSx4eXAcW7itOYx5xqr2tEaRHKPfq8mmnZVIiKh0+ftq/0kIdn9prrZ3bMyTmgqZKYyitDdehxGcaDjOOGVifhUQf0lL6ePdrhXKz/ALz9q/8A1So/5jlRaH7Nu2fZSXN8rK6SoEz544cljA5reb1f+EvduBBOnfuwvssLwrKTg0V1UXmYj1nl9WOcSu86u8fCog/pKX08e7T4VEH9JS+nj3a4VS0myOuFtTcK34/NyFjTpOIyTIDozpMhAAxkAEnir6mtOyUtDUVfS6nmoZImYdOA9wOgyOA0Z3anADG/GRwIUz4Zko/65/P7N5Xzdn+FRB/SUvp492nwqIP6Sl9PHu1wWePZiOno56Soqn1HSIjNDMMtbGQC8fFGrByM5BOOHWsvcqrY2tnjkYx9MOe53ETNOB+waWPAZgg4mcC3h2ZOEnwvJ/KnvP7N5Xzdj+FRB/SUvp492nwqIP6Sl9PHu1xCSLY6avHOVNZGx7tb5Ix3AJDu5a3mwQ3Vp34zp/y53KLLLstBBWQ1pfI+Sr1QSPhL+bijc0tBO492C9pAb8knCnyvJ2/+U/n9m8r5u4fCog/pKX08e7T4VEH9JS+nj3a4nPb9kIpY2zV9SHOpRKeacXNEhZG4NJ5vdvdIMDUNzckb1rN7joIrg5tpmfLSaWkOfnOdI1DeBnByM4CmjwrJV/8AXPef2b2vm+6eR3lHZykWivro7Y63ClnEGh0/O6stDs50jHFaBth+kbDs3tTdLM7ZmSoNDUPgMorQ3XpOM40HHlXl+hr/ANkL/wD+fb/ywvn3lk/3qbVf+oS/8S83LeH5evPYmDVT8MRprPRZVXVFES7f8KiD+kpfTx7tPhUQf0lL6ePdrg9insItLYroY255wTgQl1Q4kDm3Rv4NDTvIJGd/xsjFbItl4Hvf0iSQAyjQHudqHNHRpzEOL9xJwR1DdqXpT4Vk4mY3c95/ave183dfhUQf0lL6ePdp8KiD+kpfTx7tcPnp9jmiaYVVU88+/RTwucBzeo6e6dH1DSftKsr3Fs6LXrtlXUS14dGzQ5mhpaI26jjT8rVvzn6eKiPC8lM23c/n9m8r5vpnYn9ImHajay2WRuzUlMa6YRCY1ofoz140DPlW8csfKWzk1t9tqpLW64isldFpbPzWjSAc/FOeK+Q+Q/8A3tbL/wDnG+wrun6Zv/Z7Zr/zUv8AwBefmPD8vRnsPBpp+GY11nqsprqmiZWfwqIP6Sl9PHu0+FRB/SUvp492vnvYqe2U20UEt8ZE+hbHLqbK0uaXFjg3OGu/zY36ThZWlZsX0l0k8ta6NksR5vJaJWF2ZMANJGBkYz1biV6NXhWTpm27mfvP7V72vm7f8KiD+kpfTx7tPhUQf0lL6ePdrjFqsuytbA8/rJ/SmQzPMZkMbC8OaIxqcwbsFxJ7AM4WPrKfZI0te6jqq4TsYRTMech5D3jJOjraIzg4xk71EeGZKZtu5/P7N5Xzd7g/Skgmnjj/AMJyjW4Nz08bsn6tdo5TtsG7C7H1V+fRGtED42cyJObzqcG8cHt7F+fVB/H031rfaF9r/pQ/7m7p9dT/APNavPz/AIfl8HHwaKKbRVOus84WUV1TTMy0H4VEH9JS+nj3afCog/pKX08e7XzbYZKWK+W6S4tDqJlTG6cFuoGMOGrI692dy2mGDZW9E1Esstumc4ukgiI0xRsjdl29oaXOLW7m43ybhuwvRr8KydE64c2+s/tXva+btPwqIP6Sl9PHu0+FRB/SUvp492uFWqLZZl7on1dRMaIQRSytfqIE2sa2EiMkjTqxhuM4GetUBmzMVVQuiqJnxy0soqudYTzUpiw3ADep5OCCdwHDeo8qyd7bufz+ze183ePhUQf0lL6ePdp8KiD+kpfTx7tcGqINnWzXKClrv+rA074JpY3l7gGnnWt7njk4GrAOBvVy+HY9pijNVWPj5zuzHxaC6MZDjGC7DdZwQN4+88ryfy5/P7N5Xzdw+FRB/SUvp492uw8ke3jeUTZma8Mt7reI6l1NzTpuczpa05zgfK4Y6l8FXhlFHcp2WyR8tGD+ze7OSMb+IHXnqX13+iD/ALsKz/1SX/lxLB4t4fl8vl4xMKm03j1l3hV1VVWmXcERF800iIiAiIgIiIIdxb9KlQ7i36VKArW7fyur+qd7FdLyq2NkppGPGWubgjxINPsH8G/6w+wIs3BRwQMLYow1pOcZPFEGaREQFDPihSoZ8UIJREQEREBWF7s1tvtC6jvNBTV1K45MVRGHtz27+B8av0UxMxN4Gj/9E2wfORP/AMLWzMXxRze4/SODvtytvt1BR2ykZS22lgpKZnxYoIwxjfoA3K5Rd14teJ/fVM/WURERwERFWkREQEREHGtov0edlb9frhdqu4XplRXTvqJGxSxBoc4kkDMZON/asf8ABj2O8J37z0Xu13VFspz+ZpiIjEm0dXG7p5OFfBj2O8J37z0Xu0+DHsd4Tv3novdruqKfMc18ye5u6eThXwY9jvCd+89F7tPgx7HeE7956L3a7qieY5r5k9zd08nCvgx7HeE7956L3afBj2O8J37z0Xu13VE8xzXzJ7m7p5OFfBj2O8J37z0Xu0+DHsd4Tv3novdruqJ5jmvmT3N3TyabyZ8ntq5PLbWUVmqK2eKqlEzzVPa4ggAbtLRu3LTtpv0fNltodoLhd6yvvLKmtmdPI2KWMMDnHJwDGTj7V2NFVTmsamucSKp2p4ynYiYtZwr4Mex3hO/eei92nwY9jvCd+89F7td1RW+Y5r5k90bunk4V8GPY7wnfvPRe7T4Mex3hO/eei92u6onmOa+ZPc3dPJx/ZX9H/ZfZraKgvNDX3iSpopRLG2aWMsJHaBGDj7VtnKbyc2nlEo6GmvVRWwMo5HSMNK9rSSRg51NPYt0RVVZvGqrjEmqdqPVOxFrWcK+DHsd4Tv3novdp8GPY7wnfvPRe7XdUVvmOa+ZPdG7p5OFfBj2O8J37z0Xu0+DHsd4Tv3novdruqJ5jmvmT3N3TycMh/Rn2PilZI25X3UxwcMzRdX/9a6lt7slQ7bbM1FjuktTDSzOY9z6dwa8Frg4YJBHEdi2FFVXm8bEqiquqZmOHRMUUxpEOFfBj2O8J37z0Xu0+DHsd4Tv3novdruqK3zHNfMnujd08nCvgx7HeE7956L3afBj2O8J37z0Xu13VE8xzXzJ7m7p5OFfBj2O8J37z0Xu0+DHsd4Tv3novdruqJ5jmvmT3N3TycK+DHsd4Tv3novdrpfJxsPbdgLDJabPPVzU8k7qguqXNc7UQ0Edy0DHcjqW1IqsXN4+NTs4lczCYopjWIERFndCIiAiIgIiIIdxb9KlQ7i36VKAqJ/8AYu+hVqif/Yu+hBYIiIMkiIgKNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjT4z5U0+M+VSiCNPjPlTT4z5VKII0+M+VNPjPlUogjTvG87lKIgKif8A2LvoVaon/wBi76EFgiIgtehbQ+GqH1cfep0LaHw1Q+rj71ZxF3vJ6doRZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qdC2h8NUPq4+9WcRN5PTtBZg+hbQ+GqH1cfep0LaHw1Q+rj71ZxE3k9O0FmD6FtD4aofVx96nQtofDVD6uPvVnETeT07QWYPoW0Phqh9XH3qqjpL0x4dVXWjmgHx42UJYXDxO5w48izSon/ANi76E256doLLBERcJZJERAXyXtbyycoEHKNebBY6qlcyGvmpqaN1NHnS15AGo+Ida+tFolx5JNh7jdam5VlhjkrqmR0ssvPytLnOJLjueBvyVuyGPg4Nczj07UW00idfurxIqmPhlbwXu+R8jbL3PWsfe+hipkkMcegP4uaAO5IAyAd+eK1Pkq5QtodotsYLfdamGSlfFI8tbC1pyBkbwup1myVhrLPT2qotkBt9OcxQty0MPaMEHO8+VeFk2H2dsdwbXWq2Mp6prS0SCR5wDx3EkLysxRiYmPFdE2p5f8AnB7uSzeTwcliYONh7WJVwm0aac73/DY0RFe8YREQEREBFiNo6iaKKlihkMfSJhE57fjAYJ3dh3LGfqiiN+FIY5C3o3O84Zn69WrGdWpV1VzE2iF9GFTNO1VNvtf/AHDakWH2enlc6tppZHStppAxjn73EYzvPWswu6Z2ourxKJoqmmRERS4EREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQFRP/sXfQq1RUf7F/wBCCwRW9DR09BTiCjhZDCCXBjBgZJyUQf/Z" + } + }, + "total-blocking-time": { + "id": "total-blocking-time", + "title": "Total Blocking Time", + "description": "Sum of all time periods between FCP and Time to Interactive, when task length exceeded 50ms, expressed in milliseconds. [Learn more](https://web.dev/lighthouse-total-blocking-time/).", + "score": 0.5, + "scoreDisplayMode": "numeric", + "numericValue": 347.43000000000006, + "numericUnit": "millisecond", + "displayValue": "350 ms" + }, + "max-potential-fid": { + "id": "max-potential-fid", + "title": "Max Potential First Input Delay", + "description": "The maximum potential First Input Delay that your users could experience is the duration of the longest task. [Learn more](https://web.dev/lighthouse-max-potential-fid/).", + "score": 0.17, + "scoreDisplayMode": "numeric", + "numericValue": 400, + "numericUnit": "millisecond", + "displayValue": "400 ms" + }, + "cumulative-layout-shift": { + "id": "cumulative-layout-shift", + "title": "Cumulative Layout Shift", + "description": "Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more](https://web.dev/cls/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 0.005971847054303684, + "numericUnit": "unitless", + "displayValue": "0.006", + "details": { + "type": "debugdata", + "items": [ + { + "cumulativeLayoutShiftMainFrame": 0.005971847054303684, + "totalCumulativeLayoutShift": 0.005971847054303684 + } + ] + } + }, + "errors-in-console": { + "id": "errors-in-console", + "title": "No browser errors logged to the console", + "description": "Errors logged to the console indicate unresolved problems. They can come from network request failures and other browser concerns. [Learn more](https://web.dev/errors-in-console/)", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "server-response-time": { + "id": "server-response-time", + "title": "Reduce initial server response time", + "description": "Keep the server response time for the main document short because all other requests depend on it. [Learn more](https://web.dev/time-to-first-byte/).", + "score": 0, + "scoreDisplayMode": "binary", + "numericValue": 845.798, + "numericUnit": "millisecond", + "displayValue": "Root document took 850 ms", + "details": { + "type": "opportunity", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "responseTime", + "valueType": "timespanMs", + "label": "Time Spent" + } + ], + "items": [ + { + "url": "http://localhost:3000/", + "responseTime": 845.798 + } + ], + "overallSavingsMs": 745.798 + } + }, + "interactive": { + "id": "interactive", + "title": "Time to Interactive", + "description": "Time to interactive is the amount of time it takes for the page to become fully interactive. [Learn more](https://web.dev/interactive/).", + "score": 0.84, + "scoreDisplayMode": "numeric", + "numericValue": 2806.2599999999998, + "numericUnit": "millisecond", + "displayValue": "2.8 s" + }, + "user-timings": { + "id": "user-timings", + "title": "User Timing marks and measures", + "description": "Consider instrumenting your app with the User Timing API to measure your app's real-world performance during key user experiences. [Learn more](https://web.dev/user-timings/).", + "score": null, + "scoreDisplayMode": "informative", + "displayValue": "7 user timings", + "details": { + "type": "table", + "headings": [ + { + "key": "name", + "itemType": "text", + "text": "Name" + }, + { + "key": "timingType", + "itemType": "text", + "text": "Type" + }, + { + "key": "startTime", + "itemType": "ms", + "granularity": 0.01, + "text": "Start Time" + }, + { + "key": "duration", + "itemType": "ms", + "granularity": 0.01, + "text": "Duration" + } + ], + "items": [ + { + "name": "Next.js-before-hydration", + "startTime": 0, + "duration": 1475.503, + "timingType": "Measure" + }, + { + "name": "Next.js-hydration", + "startTime": 1475.503, + "duration": 105.613, + "timingType": "Measure" + }, + { + "name": "sentry-tracing-init", + "startTime": 1395.599, + "timingType": "Mark" + }, + { + "name": "beforeRender", + "startTime": 1475.503, + "timingType": "Mark" + }, + { + "name": "routeChange", + "startTime": 1579.918, + "timingType": "Mark" + }, + { + "name": "afterHydrate", + "startTime": 1581.116, + "timingType": "Mark" + }, + { + "name": "routeChange", + "startTime": 1587.205, + "timingType": "Mark" + } + ] + } + }, + "critical-request-chains": { + "id": "critical-request-chains", + "title": "Avoid chaining critical requests", + "description": "The Critical Request Chains below show you what resources are loaded with a high priority. Consider reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load. [Learn more](https://web.dev/critical-request-chains/).", + "score": null, + "scoreDisplayMode": "informative", + "displayValue": "1 chain found", + "details": { + "type": "criticalrequestchain", + "chains": { + "52F76661D21D971A1BA55CE39E941E82": { + "request": { + "url": "http://localhost:3000/", + "startTime": 6397.803832, + "endTime": 6398.666501, + "responseReceivedTime": 6398.665719, + "transferSize": 2483 + }, + "children": { + "11724.8": { + "request": { + "url": "http://localhost:3000/_next/static/chunks/react-refresh.js?ts=1706780787914", + "startTime": 6398.679814, + "endTime": 6398.697017, + "responseReceivedTime": 6398.692729, + "transferSize": 25050 + } + } + } + } + }, + "longestChain": { + "duration": 893.1850000008126, + "length": 2, + "transferSize": 25050 + } + } + }, + "redirects": { + "id": "redirects", + "title": "Avoid multiple page redirects", + "description": "Redirects introduce additional delays before the page can be loaded. [Learn more](https://web.dev/redirects/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 0, + "numericUnit": "millisecond", + "displayValue": "", + "details": { + "type": "opportunity", + "headings": [], + "items": [], + "overallSavingsMs": 0 + } + }, + "image-aspect-ratio": { + "id": "image-aspect-ratio", + "title": "Displays images with correct aspect ratio", + "description": "Image display dimensions should match natural aspect ratio. [Learn more](https://web.dev/image-aspect-ratio/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "image-size-responsive": { + "id": "image-size-responsive", + "title": "Serves images with appropriate resolution", + "description": "Image natural dimensions should be proportional to the display size and the pixel ratio to maximize image clarity. [Learn more](https://web.dev/serve-responsive-images/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "preload-fonts": { + "id": "preload-fonts", + "title": "Fonts with `font-display: optional` are preloaded", + "description": "Preload `optional` fonts so first-time visitors may use them. [Learn more](https://web.dev/preload-optional-fonts/)", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "deprecations": { + "id": "deprecations", + "title": "Avoids deprecated APIs", + "description": "Deprecated APIs will eventually be removed from the browser. [Learn more](https://web.dev/deprecations/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "mainthread-work-breakdown": { + "id": "mainthread-work-breakdown", + "title": "Minimizes main-thread work", + "description": "Consider reducing the time spent parsing, compiling and executing JS. You may find delivering smaller JS payloads helps with this. [Learn more](https://web.dev/mainthread-work-breakdown/)", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 658.9429999999979, + "numericUnit": "millisecond", + "displayValue": "0.7 s", + "details": { + "type": "table", + "headings": [ + { + "key": "groupLabel", + "itemType": "text", + "text": "Category" + }, + { + "key": "duration", + "itemType": "ms", + "granularity": 1, + "text": "Time Spent" + } + ], + "items": [ + { + "group": "scriptEvaluation", + "groupLabel": "Script Evaluation", + "duration": 373.36299999999693 + }, + { + "group": "other", + "groupLabel": "Other", + "duration": 96.67700000000102 + }, + { + "group": "scriptParseCompile", + "groupLabel": "Script Parsing & Compilation", + "duration": 96.459 + }, + { + "group": "styleLayout", + "groupLabel": "Style & Layout", + "duration": 82.516 + }, + { + "group": "paintCompositeRender", + "groupLabel": "Rendering", + "duration": 5.801999999999999 + }, + { + "group": "parseHTML", + "groupLabel": "Parse HTML & CSS", + "duration": 2.986999999999999 + }, + { + "group": "garbageCollection", + "groupLabel": "Garbage Collection", + "duration": 1.1389999999999993 + } + ] + } + }, + "bootup-time": { + "id": "bootup-time", + "title": "JavaScript execution time", + "description": "Consider reducing the time spent parsing, compiling, and executing JS. You may find delivering smaller JS payloads helps with this. [Learn more](https://web.dev/bootup-time/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 375.2089999999986, + "numericUnit": "millisecond", + "displayValue": "0.4 s", + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "itemType": "url", + "text": "URL" + }, + { + "key": "total", + "granularity": 1, + "itemType": "ms", + "text": "Total CPU Time" + }, + { + "key": "scripting", + "granularity": 1, + "itemType": "ms", + "text": "Script Evaluation" + }, + { + "key": "scriptParseCompile", + "granularity": 1, + "itemType": "ms", + "text": "Script Parse" + } + ], + "items": [ + { + "url": "http://localhost:3000/_next/static/chunks/pages/_app.js?ts=1706780787914", + "total": 202.8379999999986, + "scripting": 156.7539999999986, + "scriptParseCompile": 46.084 + }, + { + "url": "http://localhost:3000/_next/static/chunks/main.js?ts=1706780787914", + "total": 181.40799999999996, + "scripting": 124.61199999999997, + "scriptParseCompile": 43.391 + }, + { + "url": "http://localhost:3000/", + "total": 102.02900000000001, + "scripting": 2.244999999999999, + "scriptParseCompile": 0.576 + }, + { + "url": "Unattributable", + "total": 57.05400000000007, + "scripting": 1.547, + "scriptParseCompile": 0 + } + ], + "summary": { + "wastedMs": 375.2089999999986 + } + } + }, + "uses-rel-preload": { + "id": "uses-rel-preload", + "title": "Preload key requests", + "description": "Consider using `` to prioritize fetching resources that are currently requested later in page load. [Learn more](https://web.dev/uses-rel-preload/).", + "score": null, + "scoreDisplayMode": "notApplicable", + "details": { + "type": "opportunity", + "headings": [], + "items": [], + "overallSavingsMs": 0 + } + }, + "uses-rel-preconnect": { + "id": "uses-rel-preconnect", + "title": "Preconnect to required origins", + "description": "Consider adding `preconnect` or `dns-prefetch` resource hints to establish early connections to important third-party origins. [Learn more](https://web.dev/uses-rel-preconnect/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 0, + "numericUnit": "millisecond", + "displayValue": "", + "warnings": [], + "details": { + "type": "opportunity", + "headings": [], + "items": [], + "overallSavingsMs": 0 + } + }, + "font-display": { + "id": "font-display", + "title": "All text remains visible during webfont loads", + "description": "Leverage the font-display CSS feature to ensure text is user-visible while webfonts are loading. [Learn more](https://web.dev/font-display/).", + "score": 1, + "scoreDisplayMode": "binary", + "warnings": [], + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "diagnostics": { + "id": "diagnostics", + "title": "Diagnostics", + "description": "Collection of useful page vitals.", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "debugdata", + "items": [ + { + "numRequests": 21, + "numScripts": 8, + "numStylesheets": 0, + "numFonts": 6, + "numTasks": 884, + "numTasksOver10ms": 3, + "numTasksOver25ms": 3, + "numTasksOver50ms": 2, + "numTasksOver100ms": 1, + "numTasksOver500ms": 0, + "rtt": 0.10199999999999998, + "throughput": 117042188.37154868, + "maxRtt": 0.10199999999999998, + "maxServerLatency": 5.14, + "totalByteWeight": 2402025, + "totalTaskTime": 658.9429999999998, + "mainDocumentTransferSize": 2483 + } + ] + } + }, + "network-requests": { + "id": "network-requests", + "title": "Network Requests", + "description": "Lists the network requests that were made during page load.", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "itemType": "url", + "text": "URL" + }, + { + "key": "protocol", + "itemType": "text", + "text": "Protocol" + }, + { + "key": "startTime", + "itemType": "ms", + "granularity": 1, + "text": "Start Time" + }, + { + "key": "endTime", + "itemType": "ms", + "granularity": 1, + "text": "End Time" + }, + { + "key": "transferSize", + "itemType": "bytes", + "displayUnit": "kb", + "granularity": 1, + "text": "Transfer Size" + }, + { + "key": "resourceSize", + "itemType": "bytes", + "displayUnit": "kb", + "granularity": 1, + "text": "Resource Size" + }, + { + "key": "statusCode", + "itemType": "text", + "text": "Status Code" + }, + { + "key": "mimeType", + "itemType": "text", + "text": "MIME Type" + }, + { + "key": "resourceType", + "itemType": "text", + "text": "Resource Type" + } + ], + "items": [ + { + "url": "http://localhost:3000/", + "protocol": "http/1.1", + "startTime": 0, + "endTime": 862.6690000000963, + "finished": true, + "transferSize": 2483, + "resourceSize": 7190, + "statusCode": 200, + "mimeType": "text/html", + "resourceType": "Document" + }, + { + "url": "http://localhost:3000/_next/static/chunks/webpack.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 875.2880000001824, + "endTime": 890.4860000002373, + "finished": true, + "transferSize": 9638, + "resourceSize": 48521, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/chunks/main.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 875.583000000006, + "endTime": 1041.363000000274, + "finished": true, + "transferSize": 1112197, + "resourceSize": 4585314, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/_app.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 881.6160000005766, + "endTime": 1023.8990000007107, + "finished": true, + "transferSize": 989804, + "resourceSize": 4273958, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/chunks/pages/index.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 882.1729999999661, + "endTime": 904.6750000006796, + "finished": true, + "transferSize": 47223, + "resourceSize": 296625, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/development/_buildManifest.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 882.5320000005377, + "endTime": 896.3940000003277, + "finished": true, + "transferSize": 633, + "resourceSize": 296, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/development/_ssgManifest.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 890.6810000007681, + "endTime": 899.3960000007064, + "finished": true, + "transferSize": 411, + "resourceSize": 76, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/chunks/react-refresh.js?ts=1706780787914", + "protocol": "http/1.1", + "startTime": 875.9820000004765, + "endTime": 893.1850000008126, + "finished": true, + "transferSize": 25050, + "resourceSize": 77113, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + }, + { + "url": "http://localhost:3000/_next/static/development/_devMiddlewareManifest.json", + "protocol": "http/1.1", + "startTime": 1435.5080000004818, + "endTime": 1439.740000000711, + "finished": true, + "transferSize": 491, + "resourceSize": 1102, + "statusCode": 200, + "mimeType": "application/json", + "resourceType": "Fetch" + }, + { + "url": "data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 44 18'%3E%3Cp", + "protocol": "data", + "startTime": 1479.9930000008317, + "endTime": 1480.0780000005034, + "finished": true, + "transferSize": 0, + "resourceSize": 3398, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image" + }, + { + "url": "data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 252 180'%3E%3", + "protocol": "data", + "startTime": 1482.1799999999712, + "endTime": 1482.2780000004059, + "finished": true, + "transferSize": 0, + "resourceSize": 5348, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image" + }, + { + "url": "http://localhost:3000/_next/static/media/Marianne-Bold.f0ef9bad.woff2", + "protocol": "http/1.1", + "startTime": 1590.991000000031, + "endTime": 1598.1870000005074, + "finished": true, + "transferSize": 42382, + "resourceSize": 42092, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font" + }, + { + "url": "data:font/truetype;charset=utf-8;base64,d09GRgABAAAAADvoAAsAAAAAd/wAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABH", + "protocol": "data", + "startTime": 1484.3760000003385, + "endTime": 1589.9380000000747, + "finished": true, + "transferSize": 15336, + "resourceSize": 15336, + "statusCode": 200, + "mimeType": "font/truetype", + "resourceType": "Font" + }, + { + "url": "http://localhost:3000/_next/static/media/Marianne-Medium.452138fa.woff2", + "protocol": "http/1.1", + "startTime": 1591.272000000572, + "endTime": 1598.6090000005788, + "finished": true, + "transferSize": 42230, + "resourceSize": 41940, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font" + }, + { + "url": "data:font/truetype;charset=utf-8;base64,d09GRgABAAAAAAc8AAsAAAAADAgAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABH", + "protocol": "data", + "startTime": 1484.6290000004956, + "endTime": 1590.8920000001672, + "finished": true, + "transferSize": 1852, + "resourceSize": 1852, + "statusCode": 200, + "mimeType": "font/truetype", + "resourceType": "Font" + }, + { + "url": "http://localhost:3000/_next/static/media/Marianne-Regular.119b3a3e.woff2", + "protocol": "http/1.1", + "startTime": 1591.536000000815, + "endTime": 1598.7700000005134, + "finished": true, + "transferSize": 41618, + "resourceSize": 41328, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font" + }, + { + "url": "http://localhost:3000/_next/static/media/Marianne-Regular_Italic.db8a6f8b.woff2", + "protocol": "http/1.1", + "startTime": 1591.6980000001786, + "endTime": 1598.8590000006297, + "finished": true, + "transferSize": 44574, + "resourceSize": 44284, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font" + }, + { + "url": "http://localhost:3000/logo.svg", + "protocol": "http/1.1", + "startTime": 1553.9290000006076, + "endTime": 1559.573000000455, + "finished": true, + "transferSize": 2660, + "resourceSize": 5508, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image" + }, + { + "url": "http://localhost:3000/_next/static/media/carte-france.11cfe763.svg", + "protocol": "http/1.1", + "startTime": 1554.135000000315, + "endTime": 1559.3680000001768, + "finished": true, + "transferSize": 7159, + "resourceSize": 16521, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image" + }, + { + "url": "http://localhost:3000/_next/static/development/_devPagesManifest.json", + "protocol": "http/1.1", + "startTime": 1580.1060000003417, + "endTime": 1582.647000000179, + "finished": true, + "transferSize": 562, + "resourceSize": 349, + "statusCode": 200, + "mimeType": "application/json", + "resourceType": "Fetch" + }, + { + "url": "http://localhost:3000/dsfr-1.4.1.module.min.js", + "protocol": "http/1.1", + "startTime": 1632.6090000002296, + "endTime": 1636.6530000004786, + "finished": true, + "transferSize": 15722, + "resourceSize": 57644, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script" + } + ] + } + }, + "network-rtt": { + "id": "network-rtt", + "title": "Network Round Trip Times", + "description": "Network round trip times (RTT) have a large impact on performance. If the RTT to an origin is high, it's an indication that servers closer to the user could improve performance. [Learn more](https://hpbn.co/primer-on-latency-and-bandwidth/).", + "score": null, + "scoreDisplayMode": "informative", + "numericValue": 0.10199999999999998, + "numericUnit": "millisecond", + "displayValue": "0 ms", + "details": { + "type": "table", + "headings": [ + { + "key": "origin", + "itemType": "text", + "text": "URL" + }, + { + "key": "rtt", + "itemType": "ms", + "granularity": 1, + "text": "Time Spent" + } + ], + "items": [ + { + "origin": "http://localhost:3000", + "rtt": 0.10199999999999998 + } + ] + } + }, + "network-server-latency": { + "id": "network-server-latency", + "title": "Server Backend Latencies", + "description": "Server latencies can impact web performance. If the server latency of an origin is high, it's an indication the server is overloaded or has poor backend performance. [Learn more](https://hpbn.co/primer-on-web-performance/#analyzing-the-resource-waterfall).", + "score": null, + "scoreDisplayMode": "informative", + "numericValue": 5.14, + "numericUnit": "millisecond", + "displayValue": "10 ms", + "details": { + "type": "table", + "headings": [ + { + "key": "origin", + "itemType": "text", + "text": "URL" + }, + { + "key": "serverResponseTime", + "itemType": "ms", + "granularity": 1, + "text": "Time Spent" + } + ], + "items": [ + { + "origin": "http://localhost:3000", + "serverResponseTime": 5.14 + } + ] + } + }, + "main-thread-tasks": { + "id": "main-thread-tasks", + "title": "Tasks", + "description": "Lists the toplevel main thread tasks that executed during page load.", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "startTime", + "itemType": "ms", + "granularity": 1, + "text": "Start Time" + }, + { + "key": "duration", + "itemType": "ms", + "granularity": 1, + "text": "End Time" + } + ], + "items": [ + { + "duration": 5.746, + "startTime": 877.934 + }, + { + "duration": 7.104, + "startTime": 902.148 + }, + { + "duration": 400.165, + "startTime": 1057.869 + }, + { + "duration": 80.401, + "startTime": 1479.468 + }, + { + "duration": 35.214, + "startTime": 1559.909 + } + ] + } + }, + "metrics": { + "id": "metrics", + "title": "Metrics", + "description": "Collects all available metrics.", + "score": null, + "scoreDisplayMode": "informative", + "numericValue": 2806, + "numericUnit": "millisecond", + "details": { + "type": "debugdata", + "items": [ + { + "firstContentfulPaint": 250, + "firstMeaningfulPaint": 250, + "largestContentfulPaint": 2854, + "interactive": 2806, + "speedIndex": 1021, + "totalBlockingTime": 347, + "maxPotentialFID": 400, + "cumulativeLayoutShift": 0.005971847054303684, + "cumulativeLayoutShiftMainFrame": 0.005971847054303684, + "totalCumulativeLayoutShift": 0.005971847054303684, + "observedTimeOrigin": 0, + "observedTimeOriginTs": 6397803028, + "observedNavigationStart": 0, + "observedNavigationStartTs": 6397803028, + "observedFirstPaint": 1584, + "observedFirstPaintTs": 6399387404, + "observedFirstContentfulPaint": 1584, + "observedFirstContentfulPaintTs": 6399387404, + "observedFirstContentfulPaintAllFrames": 1584, + "observedFirstContentfulPaintAllFramesTs": 6399387404, + "observedFirstMeaningfulPaint": 1584, + "observedFirstMeaningfulPaintTs": 6399387404, + "observedLargestContentfulPaint": 1642, + "observedLargestContentfulPaintTs": 6399445235, + "observedLargestContentfulPaintAllFrames": 1642, + "observedLargestContentfulPaintAllFramesTs": 6399445235, + "observedTraceEnd": 3933, + "observedTraceEndTs": 6401736398, + "observedLoad": 1455, + "observedLoadTs": 6399258229, + "observedDomContentLoaded": 1450, + "observedDomContentLoadedTs": 6399252648, + "observedCumulativeLayoutShift": 0.005971847054303684, + "observedCumulativeLayoutShiftMainFrame": 0.005971847054303684, + "observedTotalCumulativeLayoutShift": 0.005971847054303684, + "observedFirstVisualChange": 1574, + "observedFirstVisualChangeTs": 6399377028, + "observedLastVisualChange": 1640, + "observedLastVisualChangeTs": 6399443028, + "observedSpeedIndex": 1588, + "observedSpeedIndexTs": 6399391014 + }, + { + "lcpInvalidated": false + } + ] + } + }, + "performance-budget": { + "id": "performance-budget", + "title": "Performance budget", + "description": "Keep the quantity and size of network requests under the targets set by the provided performance budget. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/budgets).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "timing-budget": { + "id": "timing-budget", + "title": "Timing budget", + "description": "Set a timing budget to help you keep an eye on the performance of your site. Performant sites load fast and respond to user input events quickly. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/budgets).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "resource-summary": { + "id": "resource-summary", + "title": "Keep request counts low and transfer sizes small", + "description": "To set budgets for the quantity and size of page resources, add a budget.json file. [Learn more](https://web.dev/use-lighthouse-for-performance-budgets/).", + "score": null, + "scoreDisplayMode": "informative", + "displayValue": "17 requests • 2,329 KiB", + "details": { + "type": "table", + "headings": [ + { + "key": "label", + "itemType": "text", + "text": "Resource Type" + }, + { + "key": "requestCount", + "itemType": "numeric", + "text": "Requests" + }, + { + "key": "transferSize", + "itemType": "bytes", + "text": "Transfer Size" + } + ], + "items": [ + { + "resourceType": "total", + "label": "Total", + "requestCount": 17, + "transferSize": 2384837 + }, + { + "resourceType": "script", + "label": "Script", + "requestCount": 8, + "transferSize": 2200678 + }, + { + "resourceType": "font", + "label": "Font", + "requestCount": 4, + "transferSize": 170804 + }, + { + "resourceType": "image", + "label": "Image", + "requestCount": 2, + "transferSize": 9819 + }, + { + "resourceType": "document", + "label": "Document", + "requestCount": 1, + "transferSize": 2483 + }, + { + "resourceType": "other", + "label": "Other", + "requestCount": 2, + "transferSize": 1053 + }, + { + "resourceType": "stylesheet", + "label": "Stylesheet", + "requestCount": 0, + "transferSize": 0 + }, + { + "resourceType": "media", + "label": "Media", + "requestCount": 0, + "transferSize": 0 + }, + { + "resourceType": "third-party", + "label": "Third-party", + "requestCount": 0, + "transferSize": 0 + } + ] + } + }, + "third-party-summary": { + "id": "third-party-summary", + "title": "Minimize third-party usage", + "description": "Third-party code can significantly impact load performance. Limit the number of redundant third-party providers and try to load third-party code after your page has primarily finished loading. [Learn more](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/loading-third-party-javascript/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "third-party-facades": { + "id": "third-party-facades", + "title": "Lazy load third-party resources with facades", + "description": "Some third-party embeds can be lazy loaded. Consider replacing them with a facade until they are required. [Learn more](https://web.dev/third-party-facades/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "largest-contentful-paint-element": { + "id": "largest-contentful-paint-element", + "title": "Largest Contentful Paint element", + "description": "This is the largest contentful element painted within the viewport. [Learn More](https://web.dev/lighthouse-largest-contentful-paint/)", + "score": null, + "scoreDisplayMode": "informative", + "displayValue": "1 element found", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "itemType": "node", + "text": "Element" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "page-1-IMG", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,2,SECTION,1,DIV,1,DIV,0,IMG", + "selector": "section > div.fr-card > div.fr-card__header > img", + "boundingRect": { + "top": 520, + "bottom": 820, + "left": 68, + "right": 368, + "width": 300, + "height": 300 + }, + "snippet": "\"\"", + "nodeLabel": "section > div.fr-card > div.fr-card__header > img" + } + } + ] + } + }, + "lcp-lazy-loaded": { + "id": "lcp-lazy-loaded", + "title": "Largest Contentful Paint image was lazily loaded", + "description": "Above-the-fold images that are lazily loaded render later in the page lifecycle, which can delay the largest contentful paint. [Learn more](https://web.dev/lcp-lazy-loading/).", + "score": 0, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "itemType": "node", + "text": "Element" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "page-1-IMG", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,2,SECTION,1,DIV,1,DIV,0,IMG", + "selector": "section > div.fr-card > div.fr-card__header > img", + "boundingRect": { + "top": 520, + "bottom": 820, + "left": 68, + "right": 368, + "width": 300, + "height": 300 + }, + "snippet": "\"\"", + "nodeLabel": "section > div.fr-card > div.fr-card__header > img" + } + } + ] + } + }, + "layout-shift-elements": { + "id": "layout-shift-elements", + "title": "Avoid large layout shifts", + "description": "These DOM elements contribute most to the CLS of the page.", + "score": null, + "scoreDisplayMode": "informative", + "displayValue": "5 elements found", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "itemType": "node", + "text": "Element" + }, + { + "key": "score", + "itemType": "numeric", + "granularity": 0.001, + "text": "CLS Contribution" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "page-3-H2", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,2,SECTION,0,H2", + "selector": "div#__next > main.fr-container > section > h2.Cartographie_titre___MSjT", + "boundingRect": { + "top": 456, + "bottom": 496, + "left": 68, + "right": 1268, + "width": 1200, + "height": 40 + }, + "snippet": "

", + "nodeLabel": "Cartographie" + }, + "score": 0.0019098926619498077 + }, + { + "node": { + "type": "node", + "lhId": "page-4-H1", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,1,DIV,0,SECTION,0,H1", + "selector": "main.fr-container > div.fr-grid-row > section.fr-col-8 > h1", + "boundingRect": { + "top": 232, + "bottom": 280, + "left": 268, + "right": 1068, + "width": 800, + "height": 48 + }, + "snippet": "

", + "nodeLabel": "Bienvenue sur Helios !" + }, + "score": 0.0016033666791677396 + }, + { + "node": { + "type": "node", + "lhId": "page-5-P", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,0,DIV,0,P", + "selector": "div#__next > main.fr-container > div.fr-alert > p", + "boundingRect": { + "top": 168, + "bottom": 192, + "left": 116, + "right": 1232, + "width": 1116, + "height": 24 + }, + "snippet": "

", + "nodeLabel": "Le site est dans sa phase pilote : il est toujours en construction et va évolue…" + }, + "score": 0.0008881000878066606 + }, + { + "node": { + "type": "node", + "lhId": "page-6-H3", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,2,SECTION,1,DIV,0,DIV,0,DIV,0,H3", + "selector": "div.fr-card > div.fr-card__body > div.fr-card__content > h3.fr-card__title", + "boundingRect": { + "top": 544, + "bottom": 572, + "left": 392, + "right": 1244, + "width": 852, + "height": 28 + }, + "snippet": "

", + "nodeLabel": "Offre de santé par région" + }, + "score": 0.0008537927566568214 + }, + { + "node": { + "type": "node", + "lhId": "page-7-DIV", + "path": "1,HTML,1,BODY,0,DIV,0,HEADER,0,DIV,0,DIV,0,DIV,1,DIV", + "selector": "div.fr-header__body > div.fr-container > div.fr-header__body-row > div.fr-header__tools", + "boundingRect": { + "top": 48, + "bottom": 80, + "left": 569, + "right": 1284, + "width": 714, + "height": 32 + }, + "snippet": "
", + "nodeLabel": "Déconnexion" + }, + "score": 0.0006743571621205494 + } + ] + } + }, + "long-tasks": { + "id": "long-tasks", + "title": "Avoid long main-thread tasks", + "description": "Lists the longest tasks on the main thread, useful for identifying worst contributors to input delay. [Learn more](https://web.dev/long-tasks-devtools/)", + "score": null, + "scoreDisplayMode": "informative", + "displayValue": "1 long task found", + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "itemType": "url", + "text": "URL" + }, + { + "key": "startTime", + "itemType": "ms", + "granularity": 1, + "text": "Start Time" + }, + { + "key": "duration", + "itemType": "ms", + "granularity": 1, + "text": "Duration" + } + ], + "items": [ + { + "url": "http://localhost:3000/_next/static/chunks/main.js?ts=1706780787914", + "duration": 400, + "startTime": 2517.0999999999995 + } + ] + } + }, + "no-unload-listeners": { + "id": "no-unload-listeners", + "title": "Avoids `unload` event listeners", + "description": "The `unload` event does not fire reliably and listening for it can prevent browser optimizations like the Back-Forward Cache. Use `pagehide` or `visibilitychange` events instead. [Learn more](https://web.dev/bfcache/#never-use-the-unload-event)", + "score": 1, + "scoreDisplayMode": "binary" + }, + "non-composited-animations": { + "id": "non-composited-animations", + "title": "Avoid non-composited animations", + "description": "Animations which are not composited can be janky and increase CLS. [Learn more](https://web.dev/non-composited-animations)", + "score": null, + "scoreDisplayMode": "notApplicable", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "unsized-images": { + "id": "unsized-images", + "title": "Image elements have explicit `width` and `height`", + "description": "Set an explicit width and height on image elements to reduce layout shifts and improve CLS. [Learn more](https://web.dev/optimize-cls/#images-without-dimensions)", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "valid-source-maps": { + "id": "valid-source-maps", + "title": "Missing source maps for large first-party JavaScript", + "description": "Source maps translate minified code to the original source code. This helps developers debug in production. In addition, Lighthouse is able to provide further insights. Consider deploying source maps to take advantage of these benefits. [Learn more](https://developers.google.com/web/tools/chrome-devtools/javascript/source-maps).", + "score": 0, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "scriptUrl", + "itemType": "url", + "subItemsHeading": { + "key": "error" + }, + "text": "URL" + }, + { + "key": "sourceMapUrl", + "itemType": "url", + "text": "Map URL" + } + ], + "items": [ + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/pages/_app.js?ts=1706780787914", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/_next/static/chunks/main.js?ts=1706780787914", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Large JavaScript file is missing a source map" + } + ] + } + }, + { + "scriptUrl": "http://localhost:3000/dsfr-1.4.1.module.min.js", + "sourceMapUrl": "http://localhost:3000/dsfr.module.min.js.map", + "subItems": { + "type": "subitems", + "items": [ + { + "error": "Error: Failed fetching source map (404)" + } + ] + } + } + ] + } + }, + "preload-lcp-image": { + "id": "preload-lcp-image", + "title": "Preload Largest Contentful Paint image", + "description": "Preload the image used by the LCP element in order to improve your LCP time. [Learn more](https://web.dev/optimize-lcp/#preload-important-resources).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 0, + "numericUnit": "millisecond", + "displayValue": "", + "details": { + "type": "opportunity", + "headings": [ + { + "key": "node", + "valueType": "node", + "label": "" + }, + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "wastedMs", + "valueType": "timespanMs", + "label": "Potential Savings" + } + ], + "items": [ + { + "node": { + "type": "node", + "lhId": "page-1-IMG", + "path": "1,HTML,1,BODY,0,DIV,1,MAIN,2,SECTION,1,DIV,1,DIV,0,IMG", + "selector": "section > div.fr-card > div.fr-card__header > img", + "boundingRect": { + "top": 520, + "bottom": 820, + "left": 68, + "right": 368, + "width": 300, + "height": 300 + }, + "snippet": "\"\"", + "nodeLabel": "section > div.fr-card > div.fr-card__header > img" + }, + "url": "http://localhost:3000/_next/static/media/carte-france.11cfe763.svg", + "wastedMs": 0 + } + ], + "overallSavingsMs": 0 + } + }, + "csp-xss": { + "id": "csp-xss", + "title": "Ensure CSP is effective against XSS attacks", + "description": "A strong Content Security Policy (CSP) significantly reduces the risk of cross-site scripting (XSS) attacks. [Learn more](https://web.dev/csp-xss/)", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "itemType": "text", + "subItemsHeading": { + "key": "description" + }, + "text": "Description" + }, + { + "key": "directive", + "itemType": "code", + "subItemsHeading": { + "key": "directive" + }, + "text": "Directive" + }, + { + "key": "severity", + "itemType": "text", + "subItemsHeading": { + "key": "severity" + }, + "text": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No CSP found in enforcement mode" + } + ] + } + }, + "full-page-screenshot": { + "id": "full-page-screenshot", + "title": "Full-page screenshot", + "description": "A full-height screenshot of the final rendered page", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "full-page-screenshot", + "screenshot": { + "data": "data:image/jpeg;base64,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", + "width": 1335, + "height": 1146 + }, + "nodes": { + "page-0-IMG": { + "top": 24, + "bottom": 104, + "left": 183, + "right": 263, + "width": 80, + "height": 80 + }, + "page-1-IMG": { + "top": 520, + "bottom": 820, + "left": 68, + "right": 368, + "width": 300, + "height": 300 + }, + "page-2-IMG": { + "top": 918, + "bottom": 1018, + "left": 242, + "right": 342, + "width": 100, + "height": 100 + }, + "page-3-H2": { + "top": 456, + "bottom": 496, + "left": 68, + "right": 1268, + "width": 1200, + "height": 40 + }, + "page-4-H1": { + "top": 232, + "bottom": 280, + "left": 268, + "right": 1068, + "width": 800, + "height": 48 + }, + "page-5-P": { + "top": 168, + "bottom": 192, + "left": 116, + "right": 1232, + "width": 1116, + "height": 24 + }, + "page-6-H3": { + "top": 544, + "bottom": 572, + "left": 392, + "right": 1244, + "width": 852, + "height": 28 + }, + "page-7-DIV": { + "top": 48, + "bottom": 80, + "left": 569, + "right": 1284, + "width": 714, + "height": 32 + }, + "4-0-META": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-1-META": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-2-META": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-3-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-4-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-5-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-6-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-7-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-8-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-9-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-10-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-11-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-12-SCRIPT": { + "top": 0, + "bottom": 0, + "left": 0, + "right": 0, + "width": 0, + "height": 0 + }, + "4-13-BR": { + "top": 43, + "bottom": 62, + "left": 143, + "right": 143, + "width": 0, + "height": 19 + }, + "4-14-BODY": { + "top": 0, + "bottom": 1146, + "left": 0, + "right": 1335, + "width": 1335, + "height": 1146 + }, + "4-15-A": { + "top": 48, + "bottom": 80, + "left": 1137, + "right": 1283, + "width": 145, + "height": 32 + } + } + } + }, + "script-treemap-data": { + "id": "script-treemap-data", + "title": "Script Treemap Data", + "description": "Used for treemap app", + "score": null, + "scoreDisplayMode": "informative", + "details": { + "type": "treemap-data", + "nodes": [ + { + "name": "http://localhost:3000/", + "resourceBytes": 145 + }, + { + "name": "http://localhost:3000/_next/static/chunks/polyfills.js?ts=1706780787914", + "resourceBytes": 71 + }, + { + "name": "http://localhost:3000/_next/static/chunks/webpack.js?ts=1706780787914", + "resourceBytes": 48521, + "unusedBytes": 30474 + }, + { + "name": "http://localhost:3000/_next/static/chunks/main.js?ts=1706780787914", + "resourceBytes": 4585283, + "unusedBytes": 25579 + }, + { + "name": "http://localhost:3000/_next/static/chunks/pages/_app.js?ts=1706780787914", + "resourceBytes": 4272998, + "unusedBytes": 410856 + }, + { + "name": "http://localhost:3000/_next/static/chunks/pages/index.js?ts=1706780787914", + "resourceBytes": 296413, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/development/_buildManifest.js?ts=1706780787914", + "resourceBytes": 296, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/development/_ssgManifest.js?ts=1706780787914", + "resourceBytes": 76, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/_next/static/chunks/react-refresh.js?ts=1706780787914", + "resourceBytes": 77113, + "unusedBytes": 0 + }, + { + "name": "http://localhost:3000/dsfr-1.4.1.module.min.js", + "resourceBytes": 57640, + "unusedBytes": 30524 + } + ] + } + }, + "accesskeys": { + "id": "accesskeys", + "title": "`[accesskey]` values are unique", + "description": "Access keys let users quickly focus a part of the page. For proper navigation, each access key must be unique. [Learn more](https://web.dev/accesskeys/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-allowed-attr": { + "id": "aria-allowed-attr", + "title": "`[aria-*]` attributes match their roles", + "description": "Each ARIA `role` supports a specific subset of `aria-*` attributes. Mismatching these invalidates the `aria-*` attributes. [Learn more](https://web.dev/aria-allowed-attr/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-command-name": { + "id": "aria-command-name", + "title": "`button`, `link`, and `menuitem` elements have accessible names", + "description": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-hidden-body": { + "id": "aria-hidden-body", + "title": "`[aria-hidden=\"true\"]` is not present on the document ``", + "description": "Assistive technologies, like screen readers, work inconsistently when `aria-hidden=\"true\"` is set on the document ``. [Learn more](https://web.dev/aria-hidden-body/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-hidden-focus": { + "id": "aria-hidden-focus", + "title": "`[aria-hidden=\"true\"]` elements do not contain focusable descendents", + "description": "Focusable descendents within an `[aria-hidden=\"true\"]` element prevent those interactive elements from being available to users of assistive technologies like screen readers. [Learn more](https://web.dev/aria-hidden-focus/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-input-field-name": { + "id": "aria-input-field-name", + "title": "ARIA input fields have accessible names", + "description": "When an input field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-meter-name": { + "id": "aria-meter-name", + "title": "ARIA `meter` elements have accessible names", + "description": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-progressbar-name": { + "id": "aria-progressbar-name", + "title": "ARIA `progressbar` elements have accessible names", + "description": "When a `progressbar` element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-required-attr": { + "id": "aria-required-attr", + "title": "`[role]`s have all required `[aria-*]` attributes", + "description": "Some ARIA roles have required attributes that describe the state of the element to screen readers. [Learn more](https://web.dev/aria-required-attr/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-required-children": { + "id": "aria-required-children", + "title": "Elements with an ARIA `[role]` that require children to contain a specific `[role]` have all required children.", + "description": "Some ARIA parent roles must contain specific child roles to perform their intended accessibility functions. [Learn more](https://web.dev/aria-required-children/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-required-parent": { + "id": "aria-required-parent", + "title": "`[role]`s are contained by their required parent element", + "description": "Some ARIA child roles must be contained by specific parent roles to properly perform their intended accessibility functions. [Learn more](https://web.dev/aria-required-parent/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-roles": { + "id": "aria-roles", + "title": "`[role]` values are valid", + "description": "ARIA roles must have valid values in order to perform their intended accessibility functions. [Learn more](https://web.dev/aria-roles/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-toggle-field-name": { + "id": "aria-toggle-field-name", + "title": "ARIA toggle fields have accessible names", + "description": "When a toggle field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-tooltip-name": { + "id": "aria-tooltip-name", + "title": "ARIA `tooltip` elements have accessible names", + "description": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-treeitem-name": { + "id": "aria-treeitem-name", + "title": "ARIA `treeitem` elements have accessible names", + "description": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more](https://web.dev/aria-name/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-valid-attr-value": { + "id": "aria-valid-attr-value", + "title": "`[aria-*]` attributes have valid values", + "description": "Assistive technologies, like screen readers, can't interpret ARIA attributes with invalid values. [Learn more](https://web.dev/aria-valid-attr-value/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "aria-valid-attr": { + "id": "aria-valid-attr", + "title": "`[aria-*]` attributes are valid and not misspelled", + "description": "Assistive technologies, like screen readers, can't interpret ARIA attributes with invalid names. [Learn more](https://web.dev/aria-valid-attr/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "button-name": { + "id": "button-name", + "title": "Buttons have an accessible name", + "description": "When a button doesn't have an accessible name, screen readers announce it as \"button\", making it unusable for users who rely on screen readers. [Learn more](https://web.dev/button-name/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "bypass": { + "id": "bypass", + "title": "The page contains a heading, skip link, or landmark region", + "description": "Adding ways to bypass repetitive content lets keyboard users navigate the page more efficiently. [Learn more](https://web.dev/bypass/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "color-contrast": { + "id": "color-contrast", + "title": "Background and foreground colors have a sufficient contrast ratio", + "description": "Low-contrast text is difficult or impossible for many users to read. [Learn more](https://web.dev/color-contrast/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [], + "items": [] + } + }, + "definition-list": { + "id": "definition-list", + "title": "`
`'s contain only properly-ordered `
` and `
` groups, `