pentest-tool-lite 3.9.3 → 3.10.8

package/dist/html/CSS.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const csso_1 = __importDefault(require("csso"));
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+const functions_1 = require("../functions");
+class CSS extends Test_1.default {
+    name = 'CSS';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const response = await request_1.default.get(url);
+        const html = await (0, functions_1.parseHtml)(response);
+        const stylesheets = (0, functions_1.getStylesheets)(html);
+        const subTests = await this.check(stylesheets);
+        return {
+            status: this.getStatus(subTests.map(test => test.status)),
+            title: this.constructor.name,
+            description: '',
+            results: subTests,
+        };
+    }
+    async check(stylesheets) {
+        const results = [];
+        for (const stylesheet of stylesheets) {
+            const filename = stylesheet.substring(stylesheet.lastIndexOf('/') + 1);
+            logger_1.default.verbose(`Checking ${filename}...`);
+            const result = await request_1.default.get(stylesheet);
+            const isFileAvailabe = {
+                status: this.isFileAvailable(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Available',
+                description: '',
+            };
+            const isCached = {
+                status: this.isCached(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Cached',
+                description: '',
+            };
+            const hasXContentTypeOptionsHeader = {
+                status: this.hasXContentTypeOptionsHeader(result) ? 'SUCCESS' : 'WARNING',
+                title: 'X-Content-Type-Options',
+                description: '',
+            };
+            const isMinified = {
+                status: this.isMinified(result) ? 'SUCCESS' : 'WARNING',
+                title: 'Minified',
+                description: '',
+            };
+            results.push({
+                status: this.getStatus([
+                    isFileAvailabe.status,
+                    isCached.status,
+                    hasXContentTypeOptionsHeader.status,
+                    isMinified.status,
+                ]), // eslint-disable-line  @typescript-eslint/no-explicit-any
+                title: filename,
+                description: '',
+                results: [
+                    isFileAvailabe,
+                    isCached,
+                    hasXContentTypeOptionsHeader,
+                    isMinified,
+                ],
+            });
+        }
+        return results;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isFileAvailable(result) {
+        if (result.response.statusCode === 404 || result.response.statusCode === 500) {
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isCached(result) {
+        return result.response.headers.has('cache-control');
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    hasXContentTypeOptionsHeader(result) {
+        return result.response.headers.has('x-content-type-options');
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isMinified(result) {
+        const r = csso_1.default.minify(result.body, { restructure: false }).css;
+        return r.length === result.body.length;
+    }
+}
+exports.default = CSS;

package/dist/html/DuplicateId.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+const functions_1 = require("../functions");
+class DuplicateId extends Test_1.default {
+    name = 'Duplicate ID';
+    async test({ url }) {
+        logger_1.default.info('Starting DuplicateId test...');
+        const response = await request_1.default.get(url);
+        const duplicates = await (0, functions_1.getDuplicates)(response);
+        if (duplicates.length > 0) {
+            return {
+                status: 'WARNING',
+                title: 'Duplicate IDs',
+                description: '',
+                results: duplicates.map(duplicate => ({
+                    status: 'WARNING',
+                    title: `<${duplicate.name} id="${duplicate.attribs.id}" ... />`,
+                    description: '',
+                }))
+            };
+        }
+        return {
+            status: 'SUCCESS',
+            title: 'Duplicate IDs',
+            description: ''
+        };
+    }
+}
+exports.default = DuplicateId;

package/dist/html/Generator.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+const functions_1 = require("../functions");
+class Generator extends Test_1.default {
+    name = 'Generator';
+    async test({ url }) {
+        logger_1.default.info('Starting DuplicateId test...');
+        const response = await request_1.default.get(url);
+        const html = await (0, functions_1.parseHtml)(response);
+        const generators = await (0, functions_1.getGenerator)(html);
+        if (generators.length > 0) {
+            return {
+                status: 'WARNING',
+                title: this.name,
+                description: 'Page contains inmformation about its generator!',
+            };
+        }
+        return {
+            status: 'SUCCESS',
+            title: this.name,
+            description: 'Page doesn\t contain any information about its generator.',
+        };
+    }
+}
+exports.default = Generator;

package/dist/html/Image.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+const functions_1 = require("../functions");
+class Image extends Test_1.default {
+    name = 'Image';
+    async test({ url }) {
+        logger_1.default.info('Starting Image test...');
+        const response = await request_1.default.get(url);
+        const html = await (0, functions_1.parseHtml)(response);
+        const images = (0, functions_1.getImages)(html);
+        const subTests = await this.checkImages(images);
+        return {
+            status: this.getStatus(subTests.map(test => test.status)),
+            title: 'Image',
+            description: '',
+            results: subTests,
+        };
+    }
+    async checkImages(images) {
+        const results = [];
+        for (const image of images) {
+            const filename = image.substring(image.lastIndexOf('/') + 1);
+            logger_1.default.verbose(`Checking ${filename}...`);
+            const result = await request_1.default.get(image);
+            const isFileAvailabe = {
+                status: this.isFileAvailable(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Available',
+                description: '',
+            };
+            const isCached = {
+                status: this.isCached(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Cached',
+                description: '',
+            };
+            const hasXContentTypeOptionsHeader = {
+                status: this.hasXContentTypeOptionsHeader(result) ? 'SUCCESS' : 'WARNING',
+                title: 'X-Content-Type-Options',
+                description: '',
+            };
+            results.push({
+                status: this.getStatus([
+                    isFileAvailabe.status,
+                    isCached.status,
+                    hasXContentTypeOptionsHeader.status,
+                ]), // eslint-disable-line  @typescript-eslint/no-explicit-any
+                title: filename,
+                description: '',
+                results: [
+                    isFileAvailabe,
+                    isCached,
+                    hasXContentTypeOptionsHeader,
+                ],
+            });
+        }
+        return results;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isFileAvailable(result) {
+        if (result.response.statusCode === 404 || result.response.statusCode === 500) {
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isCached(result) {
+        return result.response.headers.has('cache-control');
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    hasXContentTypeOptionsHeader(result) {
+        return result.response.headers.has('x-content-type-options');
+    }
+}
+exports.default = Image;

package/dist/html/JavaScript.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uglify_js_1 = __importDefault(require("uglify-js"));
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+const functions_1 = require("../functions");
+class JavaScript extends Test_1.default {
+    name = 'JavaScript';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const response = await request_1.default.get(url);
+        const html = await (0, functions_1.parseHtml)(response);
+        const scripts = (0, functions_1.getScripts)(html);
+        const subTests = await this.check(scripts);
+        return {
+            status: this.getStatus(subTests.map(test => test.status)),
+            title: this.constructor.name,
+            description: '',
+            results: subTests,
+        };
+    }
+    async check(scripts) {
+        const results = [];
+        for (const script of scripts) {
+            const filename = script.substr(script.lastIndexOf('/') + 1);
+            logger_1.default.verbose(`Checking ${filename}...`);
+            const result = await request_1.default.get(script);
+            const isFileAvailabe = {
+                status: this.isFileAvailable(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Available',
+                description: '',
+            };
+            const isCached = {
+                status: this.isCached(result) ? 'SUCCESS' : 'ERROR',
+                title: 'Cached',
+                description: '',
+            };
+            const hasXContentTypeOptionsHeader = {
+                status: this.hasXContentTypeOptionsHeader(result) ? 'SUCCESS' : 'WARNING',
+                title: 'X-Content-Type-Options',
+                description: '',
+            };
+            const isMinified = {
+                status: this.isMinified(result) ? 'SUCCESS' : 'WARNING',
+                title: 'Minified',
+                description: '',
+            };
+            const hasConsoleLogs = {
+                status: this.hasConsoleLogs(result) ? 'SUCCESS' : 'WARNING',
+                title: 'ConsoleLogs',
+                description: '',
+            };
+            results.push({
+                status: this.getStatus([
+                    isFileAvailabe.status,
+                    isCached.status,
+                    hasXContentTypeOptionsHeader.status,
+                    isMinified.status,
+                    hasConsoleLogs.status,
+                ]), // eslint-disable-line  @typescript-eslint/no-explicit-any
+                title: filename,
+                description: '',
+                results: [
+                    isFileAvailabe,
+                    isCached,
+                    hasXContentTypeOptionsHeader,
+                    isMinified,
+                    hasConsoleLogs,
+                ],
+            });
+        }
+        return results;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isFileAvailable(result) {
+        if (result.response.statusCode === 404 || result.response.statusCode === 500) {
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isCached(result) {
+        return result.response.headers.has('cache-control');
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    hasXContentTypeOptionsHeader(result) {
+        return result.response.headers.has('x-content-type-options');
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    isMinified(result) {
+        const r = uglify_js_1.default.minify(result.body, { mangle: false, output: { comments: true } });
+        if (Object.prototype.hasOwnProperty.call(r, 'error')) {
+            logger_1.default.error('JavaScript syntax error!');
+            throw r.error;
+        }
+        return result.body.length /* - (result.body.length * 0.05)*/ <= r.code.length;
+    }
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    hasConsoleLogs(result) {
+        return result.body.indexOf('console.log') !== -1 && result.body.indexOf('console.error') !== -1;
+    }
+}
+exports.default = JavaScript;

package/{src → dist}/html/__TESTS__/Generator.test.js

@@ -1,42 +1,35 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Generator_1 = __importDefault(require("../Generator"));
 const request_1 = __importDefault(require("../../request"));
-test('Generator test without generator metatag', () => __awaiter(void 0, void 0, void 0, function* () {
+test('Generator test without generator metatag', async () => {
     const generator = new Generator_1.default();
-    const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    const mock = jest.spyOn(request_1.default, 'get').mockImplementation(async () => {
         return new Promise((resolve) => {
             resolve({
                 body: '<html><body><meta name="description" content="Generator is not here" /></body></html>'
             });
         });
-    }));
-    const result = yield generator.run({ url: 'https://juffalow.com' });
+    });
+    const result = await generator.run({ url: 'https://juffalow.com' });
     expect(result.status).toEqual('SUCCESS');
     mock.mockRestore();
-}));
-test('Generator test with generator metatag', () => __awaiter(void 0, void 0, void 0, function* () {
+});
+test('Generator test with generator metatag', async () => {
     const generator = new Generator_1.default();
-    const mock = jest.spyOn(request_1.default, 'get').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+    /* eslint-disable-next-line  @typescript-eslint/no-explicit-any */
+    const mock = jest.spyOn(request_1.default, 'get').mockImplementation(async () => {
         return new Promise((resolve) => {
             resolve({
                 body: '<html><body><meta name="description" content="Generator is not here" /><meta name="generator" content="Whatever" /></body></html>'
             });
         });
-    }));
-    const result = yield generator.run({ url: 'https://juffalow.com' });
+    });
+    const result = await generator.run({ url: 'https://juffalow.com' });
     expect(result.status).toEqual('WARNING');
     mock.mockRestore();
-}));
+});

package/dist/html/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const Image_1 = __importDefault(require("./Image"));
+const DuplicateId_1 = __importDefault(require("./DuplicateId"));
+const CSS_1 = __importDefault(require("./CSS"));
+const JavaScript_1 = __importDefault(require("./JavaScript"));
+const Anchor_1 = __importDefault(require("./Anchor"));
+const Generator_1 = __importDefault(require("./Generator"));
+class HTML extends Test_1.default {
+    name = 'HTML';
+    constructor() {
+        super();
+        this.tests = [
+            new JavaScript_1.default(),
+            new CSS_1.default(),
+            new Image_1.default(),
+            new Anchor_1.default(),
+            new DuplicateId_1.default(),
+            new Generator_1.default(),
+        ];
+    }
+    async test(params) {
+        const tests = this.getTests();
+        const results = [];
+        for (const test of tests) {
+            let result = null;
+            try {
+                result = await test.run(params);
+            }
+            catch {
+                result = {
+                    status: 'ERROR',
+                    title: test.name,
+                    description: 'Test failed or cannot be run!',
+                };
+            }
+            results.push(result);
+        }
+        return {
+            status: this.getStatus(results.map(result => result.status)),
+            title: this.name,
+            description: '',
+            results,
+        };
+    }
+}
+exports.default = HTML;

package/{src → dist}/index

@@ -16,22 +16,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -57,32 +58,42 @@ program
     .option('--logger <level>', 'DEBUG, INFO, VERBOSE, WARNING, ERROR, NONE', 'NONE')
     .option('--reportType <type>', 'SHORT, FULL', 'SHORT')
     .option('--reportFormat <format>', 'CMD, JSON', 'CMD')
-    .action((url, options) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (url, options) => {
     (0, config_1.mergeConfig)({
         exclude: options.exclude,
         grep: options.grep,
-        logger: Object.assign(Object.assign({}, config_1.default.logger), { level: options.logger }),
-        report: Object.assign(Object.assign({}, config_1.default.report), { type: options.reportType, format: options.reportFormat }),
-        request: Object.assign(Object.assign({}, config_1.default.request), { cache: {
+        logger: {
+            ...config_1.default.logger,
+            level: options.logger,
+        },
+        report: {
+            ...config_1.default.report,
+            type: options.reportType,
+            format: options.reportFormat,
+        },
+        request: {
+            ...config_1.default.request,
+            cache: {
                 type: options.cache ? 'UNLIMITED' : 'BLACK_HOLE',
-            } }),
+            },
+        },
     });
     const pentest = new Pentest_1.default();
-    const results = yield pentest.run(url);
+    const results = await pentest.run(url);
     const report = report_1.default.get(config_1.default.report.format);
-    report.write([results.security, results.dns, results.html, results.seo, results.wordpress]);
-}));
+    report.write([results.security, results.dns, results.html, results.seo, results.wordpress, results.metadata]);
+});
 program
     .command('sitemap <URL>')
     .description(`
     List all URLs in sitemap.
   `)
     .option('--path', 'path to sitemap', 'sitemap.xml')
-    .action((url) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (url) => {
     const sitemap = new Sitemap_1.default();
-    const urls = yield sitemap.run(url);
+    const urls = await sitemap.run(url);
     urls.forEach((sitemapUrl) => console.log(sitemapUrl));
-}));
+});
 program
     .command('random')
     .description(`
@@ -102,7 +113,7 @@ program
                 console.log(line);
             }
         }
-        catch (_a) {
+        catch {
             return;
         }
     });

package/dist/logger/Console.d.ts

@@ -0,0 +1,14 @@
+import Logger from './Logger';
+export default class Console implements Logger {
+    protected levels: string[];
+    debug(message: string, ...args: unknown[]): void;
+    verbose(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warning(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * What a terrible failure
+     * @param message
+     */
+    wtf(message: string, ...args: unknown[]): void;
+}

package/{src → dist}/logger/Console.js

@@ -5,45 +5,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = __importDefault(require("../config"));
 class Console {
-    constructor() {
-        this.levels = ['ALL', 'DEBUG', 'VERBOSE', 'INFO', 'WARNING', 'ERROR', 'NONE'];
-    }
-    debug(message) {
+    levels = ['ALL', 'DEBUG', 'VERBOSE', 'INFO', 'WARNING', 'ERROR', 'NONE'];
+    debug(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 1) {
             return;
         }
-        console.log(message);
+        console.log(message, ...args);
     }
-    verbose(message) {
+    verbose(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 2) {
             return;
         }
-        console.log(message);
+        console.log(message, ...args);
     }
-    info(message) {
+    info(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 3) {
             return;
         }
-        console.log(message);
+        console.log(message, ...args);
     }
-    warning(message) {
+    warning(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 4) {
             return;
         }
-        console.warn(message);
+        console.warn(message, ...args);
     }
-    error(message) {
+    error(message, ...args) {
         if (this.levels.indexOf(config_1.default.logger.level) > 5) {
             return;
         }
-        console.error(message);
+        console.error(message, ...args);
     }
     /**
      * What a terrible failure
      * @param message
      */
-    wtf(message) {
-        console.error(message);
+    wtf(message, ...args) {
+        console.error(message, ...args);
     }
 }
 exports.default = Console;

package/dist/metadata/HTML.d.ts

@@ -0,0 +1,6 @@
+import Test, { TestParameters, Result } from '../Test';
+declare class HTML extends Test {
+    name: string;
+    test({ url }: TestParameters): Promise<Result>;
+}
+export default HTML;

package/dist/metadata/HTML.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Test_1 = __importDefault(require("../Test"));
+const request_1 = __importDefault(require("../request"));
+const logger_1 = __importDefault(require("../logger"));
+class HTML extends Test_1.default {
+    name = 'HTML';
+    async test({ url }) {
+        logger_1.default.info(`Starting ${this.constructor.name} test...`);
+        const response = await request_1.default.get(url);
+        const html = response.body;
+        return {
+            status: 'SUCCESS',
+            title: this.constructor.name,
+            description: '',
+            metadata: {
+                html,
+            },
+            results: [],
+        };
+    }
+}
+exports.default = HTML;