Deployed the page to Github Pages.

node_modules/jasmine-spec-reporter/built/configuration-parser.d.ts

@@ -0,0 +1,2 @@
+import { Configuration } from "./configuration";
+export declare function parse(conf?: Configuration): Configuration;

node_modules/jasmine-spec-reporter/built/configuration-parser.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+var configuration_1 = require("./configuration");
+function parse(conf) {
+    return merge(defaultConfiguration, conf);
+}
+exports.parse = parse;
+var isWindows = process && process.platform === "win32";
+var defaultConfiguration = {
+    colors: {
+        enabled: true,
+        failed: "red",
+        pending: "yellow",
+        successful: "green",
+        prettyStacktraceFilename: "cyan",
+        prettyStacktraceLineNumber: "yellow",
+        prettyStacktraceColumnNumber: "yellow",
+        prettyStacktraceError: "red",
+    },
+    customProcessors: [],
+    prefixes: {
+        failed: isWindows ? "\u00D7 " : "✗ ",
+        pending: "* ",
+        successful: isWindows ? "\u221A " : "✓ ",
+    },
+    print: function (stuff) { return console.log(stuff); },
+    spec: {
+        displayDuration: false,
+        displayErrorMessages: true,
+        displayFailed: true,
+        displayPending: false,
+        displayStacktrace: configuration_1.StacktraceOption.NONE,
+        displaySuccessful: true,
+    },
+    stacktrace: {
+        filter: function (stacktrace) {
+            var lines = stacktrace.split("\n");
+            var filtered = [];
+            for (var i = 1; i < lines.length; i++) {
+                if (!/(jasmine[^\/]*\.js|Timer\.listOnTimeout)/.test(lines[i])) {
+                    filtered.push(lines[i]);
+                }
+            }
+            return filtered.join("\n");
+        }
+    },
+    suite: {
+        displayNumber: false,
+    },
+    summary: {
+        displayDuration: true,
+        displayErrorMessages: true,
+        displayFailed: true,
+        displayPending: true,
+        displayStacktrace: configuration_1.StacktraceOption.NONE,
+        displaySuccessful: false,
+    },
+};
+function merge(template, override) {
+    var result = {};
+    for (var key in template) {
+        if (template[key] instanceof Object
+            && !(template[key] instanceof Array)
+            && !(template[key] instanceof Function)
+            && override instanceof Object
+            && override[key] instanceof Object
+            && !(override[key] instanceof Array)
+            && !(override[key] instanceof Function)) {
+            result[key] = merge(template[key], override[key]);
+        }
+        else if (override instanceof Object
+            && Object.keys(override).indexOf(key) !== -1) {
+            result[key] = override[key];
+            if (key === "displayStacktrace" && typeof override[key] === "boolean") {
+                console.warn("WARN: jasmine-spec-reporter 'displayStacktrace' option supports value ('none', 'raw', 'pretty'), default to 'none'\n");
+                result[key] = configuration_1.StacktraceOption.NONE;
+            }
+        }
+        else {
+            result[key] = template[key];
+        }
+    }
+    if (override instanceof Object && override.customOptions) {
+        result.customOptions = override.customOptions;
+    }
+    return result;
+}
+//# sourceMappingURL=configuration-parser.js.map

node_modules/jasmine-spec-reporter/built/configuration.d.ts

@@ -0,0 +1,139 @@
+import { DisplayProcessor } from "./display-processor";
+export declare enum StacktraceOption {
+    NONE = "none",
+    RAW = "raw",
+    PRETTY = "pretty"
+}
+export declare class Configuration {
+    suite?: {
+        /**
+         * display each suite number (hierarchical)
+         */
+        displayNumber?: boolean;
+    };
+    spec?: {
+        /**
+         * display error messages for each failed assertion
+         */
+        displayErrorMessages?: boolean;
+        /**
+         * display stacktrace for each failed assertion
+         */
+        displayStacktrace?: StacktraceOption;
+        /**
+         * display each successful spec
+         */
+        displaySuccessful?: boolean;
+        /**
+         * display each failed spec
+         */
+        displayFailed?: boolean;
+        /**
+         * display each pending spec
+         */
+        displayPending?: boolean;
+        /**
+         * display each spec duration
+         */
+        displayDuration?: boolean;
+    };
+    summary?: {
+        /**
+         * display error messages for each failed assertion
+         */
+        displayErrorMessages?: boolean;
+        /**
+         * display stacktrace for each failed assertion
+         */
+        displayStacktrace?: StacktraceOption;
+        /**
+         * display summary of all successes after execution
+         */
+        displaySuccessful?: boolean;
+        /**
+         * display summary of all failures after execution
+         */
+        displayFailed?: boolean;
+        /**
+         * display summary of all pending specs after execution
+         */
+        displayPending?: boolean;
+        /**
+         * display execution duration
+         */
+        displayDuration?: boolean;
+    };
+    /**
+     * Colors are displayed in the console via colors package: https://github.com/Marak/colors.js.
+     * You can see all available colors on the project page.
+     */
+    colors?: {
+        /**
+         * enable colors
+         */
+        enabled?: boolean;
+        /**
+         * color for successful spec
+         */
+        successful?: string;
+        /**
+         * color for failing spec
+         */
+        failed?: string;
+        /**
+         * color for pending spec
+         */
+        pending?: string;
+        /**
+         * color for pretty stacktrace filename
+         */
+        prettyStacktraceFilename?: string;
+        /**
+         * color for pretty stacktrace line number
+         */
+        prettyStacktraceLineNumber?: string;
+        /**
+         * color for pretty stacktrace column number
+         */
+        prettyStacktraceColumnNumber?: string;
+        /**
+         * color for pretty stacktrace error
+         */
+        prettyStacktraceError?: string;
+    };
+    prefixes?: {
+        /**
+         * prefix for successful spec
+         */
+        successful?: string;
+        /**
+         * prefix for failing spec
+         */
+        failed?: string;
+        /**
+         * prefix for pending spec
+         */
+        pending?: string;
+    };
+    stacktrace?: {
+        /**
+         * Customize stacktrace filtering
+         */
+        filter?(stacktrace: string): string;
+    };
+    /**
+     * list of display processor to customize output
+     * see https://github.com/bcaudan/jasmine-spec-reporter/blob/master/docs/customize-output.md
+     */
+    customProcessors?: (typeof DisplayProcessor)[];
+    /**
+     * options for custom processors
+     */
+    customOptions?: any;
+    /**
+     * Low-level printing function, defaults to console.log.
+     * Use process.stdout.write(log + '\n'); to avoid output to
+     * devtools console while still reporting to command line.
+     */
+    print?: (log: string) => void;
+}

node_modules/jasmine-spec-reporter/built/configuration.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = exports.StacktraceOption = void 0;
+var StacktraceOption;
+(function (StacktraceOption) {
+    StacktraceOption["NONE"] = "none";
+    StacktraceOption["RAW"] = "raw";
+    StacktraceOption["PRETTY"] = "pretty";
+})(StacktraceOption = exports.StacktraceOption || (exports.StacktraceOption = {}));
+var Configuration = /** @class */ (function () {
+    function Configuration() {
+    }
+    return Configuration;
+}());
+exports.Configuration = Configuration;
+//# sourceMappingURL=configuration.js.map

node_modules/jasmine-spec-reporter/built/display-processor.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="jasmine" />
+import { Configuration } from "./configuration";
+import { CustomReporterResult } from "./spec-reporter";
+import { Theme } from "./theme";
+import SuiteInfo = jasmine.SuiteInfo;
+export declare class DisplayProcessor {
+    protected configuration: Configuration;
+    protected theme: Theme;
+    constructor(configuration: Configuration, theme: Theme);
+    displayJasmineStarted(info: SuiteInfo, log: string): string;
+    displaySuite(suite: CustomReporterResult, log: string): string;
+    displaySpecStarted(spec: CustomReporterResult, log: string): string;
+    displaySuccessfulSpec(spec: CustomReporterResult, log: string): string;
+    displayFailedSpec(spec: CustomReporterResult, log: string): string;
+    displaySpecErrorMessages(spec: CustomReporterResult, log: string): string;
+    displaySummaryErrorMessages(spec: CustomReporterResult, log: string): string;
+    displayPendingSpec(spec: CustomReporterResult, log: string): string;
+}

node_modules/jasmine-spec-reporter/built/display-processor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisplayProcessor = void 0;
+var DisplayProcessor = /** @class */ (function () {
+    function DisplayProcessor(configuration, theme) {
+        this.configuration = configuration;
+        this.theme = theme;
+    }
+    DisplayProcessor.prototype.displayJasmineStarted = function (info, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displaySuite = function (suite, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displaySpecStarted = function (spec, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displaySuccessfulSpec = function (spec, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displayFailedSpec = function (spec, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displaySpecErrorMessages = function (spec, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displaySummaryErrorMessages = function (spec, log) {
+        return log;
+    };
+    DisplayProcessor.prototype.displayPendingSpec = function (spec, log) {
+        return log;
+    };
+    return DisplayProcessor;
+}());
+exports.DisplayProcessor = DisplayProcessor;
+//# sourceMappingURL=display-processor.js.map

node_modules/jasmine-spec-reporter/built/display/colors-display.d.ts

@@ -0,0 +1,2 @@
+import { Configuration } from "../configuration";
+export declare function init(configuration: Configuration): void;

node_modules/jasmine-spec-reporter/built/display/colors-display.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+// tslint:disable-next-line:no-submodule-imports
+var colors = require("colors/safe");
+function init(configuration) {
+    colors.enabled = configuration.colors.enabled;
+    colors.setTheme({
+        failed: configuration.colors.failed,
+        pending: configuration.colors.pending,
+        successful: configuration.colors.successful,
+        prettyStacktraceFilename: configuration.colors.prettyStacktraceFilename,
+        prettyStacktraceLineNumber: configuration.colors.prettyStacktraceLineNumber,
+        prettyStacktraceColumnNumber: configuration.colors.prettyStacktraceColumnNumber,
+        prettyStacktraceError: configuration.colors.prettyStacktraceError,
+    });
+}
+exports.init = init;
+//# sourceMappingURL=colors-display.js.map

node_modules/jasmine-spec-reporter/built/display/colors-theme.d.ts

@@ -0,0 +1,9 @@
+interface String {
+    successful: string;
+    failed: string;
+    pending: string;
+    prettyStacktraceFilename: string;
+    prettyStacktraceLineNumber: string;
+    prettyStacktraceColumnNumber: string;
+    prettyStacktraceError: string;
+}

node_modules/jasmine-spec-reporter/built/display/colors-theme.js

@@ -0,0 +1 @@
+//# sourceMappingURL=colors-theme.js.map

node_modules/jasmine-spec-reporter/built/display/execution-display.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="jasmine" />
+import { Configuration } from "../configuration";
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult, ExecutedSpecs } from "../spec-reporter";
+import { Logger } from "./logger";
+import SuiteInfo = jasmine.SuiteInfo;
+export declare class ExecutionDisplay {
+    private configuration;
+    private logger;
+    private specs;
+    private static hasCustomDisplaySpecStarted;
+    private suiteHierarchy;
+    private suiteHierarchyDisplayed;
+    private hasCustomDisplaySpecStarted;
+    constructor(configuration: Configuration, logger: Logger, specs: ExecutedSpecs, displayProcessors: DisplayProcessor[]);
+    jasmineStarted(suiteInfo: SuiteInfo): void;
+    specStarted(result: CustomReporterResult): void;
+    successful(result: CustomReporterResult): void;
+    failed(result: CustomReporterResult): void;
+    pending(result: CustomReporterResult): void;
+    suiteStarted(result: CustomReporterResult): void;
+    suiteDone(result: CustomReporterResult): void;
+    private ensureSuiteDisplayed;
+    private displaySuite;
+    private computeSuiteIndent;
+}

node_modules/jasmine-spec-reporter/built/display/execution-display.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionDisplay = void 0;
+var ExecutionDisplay = /** @class */ (function () {
+    function ExecutionDisplay(configuration, logger, specs, displayProcessors) {
+        this.configuration = configuration;
+        this.logger = logger;
+        this.specs = specs;
+        this.suiteHierarchy = [];
+        this.suiteHierarchyDisplayed = [];
+        this.hasCustomDisplaySpecStarted = ExecutionDisplay.hasCustomDisplaySpecStarted(displayProcessors);
+    }
+    ExecutionDisplay.hasCustomDisplaySpecStarted = function (processors) {
+        var isDisplayed = false;
+        processors.forEach(function (processor) {
+            var log = "foo";
+            var result = processor.displaySpecStarted({ id: "bar", description: "bar", fullName: "bar" }, log);
+            isDisplayed = isDisplayed || result !== log;
+        });
+        return isDisplayed;
+    };
+    ExecutionDisplay.prototype.jasmineStarted = function (suiteInfo) {
+        this.logger.process(suiteInfo, function (displayProcessor, object, log) {
+            return displayProcessor.displayJasmineStarted(object, log);
+        });
+    };
+    ExecutionDisplay.prototype.specStarted = function (result) {
+        if (this.hasCustomDisplaySpecStarted) {
+            this.ensureSuiteDisplayed();
+            this.logger.process(result, function (displayProcessor, object, log) {
+                return displayProcessor.displaySpecStarted(object, log);
+            });
+        }
+    };
+    ExecutionDisplay.prototype.successful = function (result) {
+        this.specs.successful.push(result);
+        if (this.configuration.spec.displaySuccessful) {
+            this.ensureSuiteDisplayed();
+            this.logger.process(result, function (displayProcessor, object, log) {
+                return displayProcessor.displaySuccessfulSpec(object, log);
+            });
+        }
+    };
+    ExecutionDisplay.prototype.failed = function (result) {
+        this.specs.failed.push(result);
+        if (this.configuration.spec.displayFailed) {
+            this.ensureSuiteDisplayed();
+            this.logger.process(result, function (displayProcessor, object, log) {
+                return displayProcessor.displayFailedSpec(object, log);
+            });
+            if (this.configuration.spec.displayErrorMessages) {
+                this.logger.increaseIndent();
+                this.logger.process(result, function (displayProcessor, object, log) {
+                    return displayProcessor.displaySpecErrorMessages(object, log);
+                });
+                this.logger.decreaseIndent();
+            }
+        }
+    };
+    ExecutionDisplay.prototype.pending = function (result) {
+        this.specs.pending.push(result);
+        if (this.configuration.spec.displayPending) {
+            this.ensureSuiteDisplayed();
+            this.logger.process(result, function (displayProcessor, object, log) {
+                return displayProcessor.displayPendingSpec(object, log);
+            });
+        }
+    };
+    ExecutionDisplay.prototype.suiteStarted = function (result) {
+        this.suiteHierarchy.push(result);
+    };
+    ExecutionDisplay.prototype.suiteDone = function (result) {
+        if (result && result.failedExpectations && result.failedExpectations.length) {
+            this.failed(result);
+        }
+        var suite = this.suiteHierarchy.pop();
+        if (this.suiteHierarchyDisplayed[this.suiteHierarchyDisplayed.length - 1] === suite) {
+            this.suiteHierarchyDisplayed.pop();
+        }
+        this.logger.newLine();
+        this.logger.decreaseIndent();
+    };
+    ExecutionDisplay.prototype.ensureSuiteDisplayed = function () {
+        if (this.suiteHierarchy.length !== 0) {
+            for (var i = this.suiteHierarchyDisplayed.length; i < this.suiteHierarchy.length; i++) {
+                this.suiteHierarchyDisplayed.push(this.suiteHierarchy[i]);
+                this.displaySuite(this.suiteHierarchy[i]);
+            }
+        }
+        else {
+            var name = "Top level suite";
+            var topLevelSuite = {
+                description: name,
+                fullName: name,
+                id: name,
+            };
+            this.suiteHierarchy.push(topLevelSuite);
+            this.suiteHierarchyDisplayed.push(topLevelSuite);
+            this.displaySuite(topLevelSuite);
+        }
+    };
+    ExecutionDisplay.prototype.displaySuite = function (suite) {
+        this.logger.newLine();
+        this.computeSuiteIndent();
+        this.logger.process(suite, function (displayProcessor, object, log) {
+            return displayProcessor.displaySuite(object, log);
+        });
+        this.logger.increaseIndent();
+    };
+    ExecutionDisplay.prototype.computeSuiteIndent = function () {
+        var _this = this;
+        this.logger.resetIndent();
+        this.suiteHierarchyDisplayed.forEach(function () { return _this.logger.increaseIndent(); });
+    };
+    return ExecutionDisplay;
+}());
+exports.ExecutionDisplay = ExecutionDisplay;
+//# sourceMappingURL=execution-display.js.map

node_modules/jasmine-spec-reporter/built/display/logger.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="jasmine" />
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+import SuiteInfo = jasmine.SuiteInfo;
+export declare type ProcessFunction = (displayProcessor: DisplayProcessor, object: ProcessObject, log: string) => string;
+export declare type ProcessObject = SuiteInfo | CustomReporterResult;
+export declare class Logger {
+    private displayProcessors;
+    private print;
+    private indent;
+    private currentIndent;
+    private lastWasNewLine;
+    constructor(displayProcessors: DisplayProcessor[], print: (line: string) => void);
+    log(stuff: string): void;
+    process(object: ProcessObject, processFunction: ProcessFunction): void;
+    newLine(): void;
+    resetIndent(): void;
+    increaseIndent(): void;
+    decreaseIndent(): void;
+}

node_modules/jasmine-spec-reporter/built/display/logger.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+var Logger = /** @class */ (function () {
+    function Logger(displayProcessors, print) {
+        this.displayProcessors = displayProcessors;
+        this.print = print;
+        this.indent = "  ";
+        this.currentIndent = "";
+        this.lastWasNewLine = false;
+    }
+    Logger.prototype.log = function (stuff) {
+        var _this = this;
+        stuff.split("\n").forEach(function (line) {
+            _this.print(line !== "" ? _this.currentIndent + line : line);
+        });
+        this.lastWasNewLine = false;
+    };
+    Logger.prototype.process = function (object, processFunction) {
+        var log = "";
+        this.displayProcessors.forEach(function (displayProcessor) {
+            log = processFunction(displayProcessor, object, log);
+        });
+        this.log(log);
+    };
+    Logger.prototype.newLine = function () {
+        if (!this.lastWasNewLine) {
+            this.log("");
+            this.lastWasNewLine = true;
+        }
+    };
+    Logger.prototype.resetIndent = function () {
+        this.currentIndent = "";
+    };
+    Logger.prototype.increaseIndent = function () {
+        this.currentIndent += this.indent;
+    };
+    Logger.prototype.decreaseIndent = function () {
+        this.currentIndent = this.currentIndent.substr(0, this.currentIndent.length - this.indent.length);
+    };
+    return Logger;
+}());
+exports.Logger = Logger;
+//# sourceMappingURL=logger.js.map

node_modules/jasmine-spec-reporter/built/display/summary-display.d.ts

@@ -0,0 +1,21 @@
+import { Configuration } from "../configuration";
+import { ExecutionMetrics } from "../execution-metrics";
+import { ExecutedSpecs } from "../spec-reporter";
+import { Theme } from "../theme";
+import { Logger } from "./logger";
+export declare class SummaryDisplay {
+    private configuration;
+    private theme;
+    private logger;
+    private specs;
+    constructor(configuration: Configuration, theme: Theme, logger: Logger, specs: ExecutedSpecs);
+    display(metrics: ExecutionMetrics): void;
+    private successesSummary;
+    private successfulSummary;
+    private failuresSummary;
+    private failedSummary;
+    private pendingsSummary;
+    private pendingSummary;
+    private errorsSummary;
+    private errorSummary;
+}

node_modules/jasmine-spec-reporter/built/display/summary-display.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryDisplay = void 0;
+var SummaryDisplay = /** @class */ (function () {
+    function SummaryDisplay(configuration, theme, logger, specs) {
+        this.configuration = configuration;
+        this.theme = theme;
+        this.logger = logger;
+        this.specs = specs;
+    }
+    SummaryDisplay.prototype.display = function (metrics) {
+        var pluralizedSpec = (metrics.totalSpecsDefined === 1 ? " spec" : " specs");
+        var execution = "Executed " + metrics.executedSpecs + " of " + metrics.totalSpecsDefined + pluralizedSpec;
+        var status = "";
+        if (metrics.failedSpecs === 0 && metrics.globalErrors.length === 0) {
+            status = (metrics.totalSpecsDefined === metrics.executedSpecs) ?
+                this.theme.successful(" SUCCESS") : this.theme.pending(" INCOMPLETE");
+        }
+        var failed = (metrics.failedSpecs > 0) ? " (" + metrics.failedSpecs + " FAILED)" : "";
+        var pending = (metrics.pendingSpecs > 0) ? " (" + metrics.pendingSpecs + " PENDING)" : "";
+        var skipped = (metrics.skippedSpecs > 0) ? " (" + metrics.skippedSpecs + " SKIPPED)" : "";
+        var errors = (metrics.globalErrors.length > 1) ? " (" + metrics.globalErrors.length + " ERRORS)" : "";
+        errors = (metrics.globalErrors.length === 1) ? " (" + metrics.globalErrors.length + " ERROR)" : errors;
+        var duration = this.configuration.summary.displayDuration ? " in " + metrics.duration : "";
+        this.logger.resetIndent();
+        this.logger.newLine();
+        if (this.configuration.summary.displaySuccessful && metrics.successfulSpecs > 0) {
+            this.successesSummary();
+        }
+        if (this.configuration.summary.displayFailed && metrics.failedSpecs > 0) {
+            this.failuresSummary();
+        }
+        if (this.configuration.summary.displayFailed && metrics.globalErrors.length > 0) {
+            this.errorsSummary(metrics.globalErrors);
+        }
+        if (this.configuration.summary.displayPending && metrics.pendingSpecs > 0) {
+            this.pendingsSummary();
+        }
+        this.logger.log(execution + status + this.theme.failed(errors) + this.theme.failed(failed)
+            + this.theme.pending(pending) + this.theme.pending(skipped) + duration + ".");
+        if (metrics.random) {
+            this.logger.log("Randomized with seed " + metrics.seed + ".");
+        }
+    };
+    SummaryDisplay.prototype.successesSummary = function () {
+        this.logger.log("**************************************************");
+        this.logger.log("*                   Successes                    *");
+        this.logger.log("**************************************************");
+        this.logger.newLine();
+        for (var i = 0; i < this.specs.successful.length; i++) {
+            this.successfulSummary(this.specs.successful[i], i + 1);
+            this.logger.newLine();
+        }
+        this.logger.newLine();
+        this.logger.resetIndent();
+    };
+    SummaryDisplay.prototype.successfulSummary = function (spec, index) {
+        this.logger.log(index + ") " + spec.fullName);
+    };
+    SummaryDisplay.prototype.failuresSummary = function () {
+        this.logger.log("**************************************************");
+        this.logger.log("*                    Failures                    *");
+        this.logger.log("**************************************************");
+        this.logger.newLine();
+        for (var i = 0; i < this.specs.failed.length; i++) {
+            this.failedSummary(this.specs.failed[i], i + 1);
+            this.logger.newLine();
+        }
+        this.logger.newLine();
+        this.logger.resetIndent();
+    };
+    SummaryDisplay.prototype.failedSummary = function (spec, index) {
+        this.logger.log(index + ") " + spec.fullName);
+        if (this.configuration.summary.displayErrorMessages) {
+            this.logger.increaseIndent();
+            this.logger.process(spec, function (displayProcessor, object, log) {
+                return displayProcessor.displaySummaryErrorMessages(object, log);
+            });
+            this.logger.decreaseIndent();
+        }
+    };
+    SummaryDisplay.prototype.pendingsSummary = function () {
+        this.logger.log("**************************************************");
+        this.logger.log("*                    Pending                     *");
+        this.logger.log("**************************************************");
+        this.logger.newLine();
+        for (var i = 0; i < this.specs.pending.length; i++) {
+            this.pendingSummary(this.specs.pending[i], i + 1);
+            this.logger.newLine();
+        }
+        this.logger.newLine();
+        this.logger.resetIndent();
+    };
+    SummaryDisplay.prototype.pendingSummary = function (spec, index) {
+        this.logger.log(index + ") " + spec.fullName);
+        this.logger.increaseIndent();
+        var pendingReason = spec.pendingReason ? spec.pendingReason : "No reason given";
+        this.logger.log(this.theme.pending(pendingReason));
+        this.logger.resetIndent();
+    };
+    SummaryDisplay.prototype.errorsSummary = function (errors) {
+        this.logger.log("**************************************************");
+        this.logger.log("*                     Errors                     *");
+        this.logger.log("**************************************************");
+        this.logger.newLine();
+        for (var i = 0; i < errors.length; i++) {
+            this.errorSummary(errors[i], i + 1);
+            this.logger.newLine();
+        }
+        this.logger.newLine();
+        this.logger.resetIndent();
+    };
+    SummaryDisplay.prototype.errorSummary = function (error, index) {
+        this.logger.log(index + ") " + error.fullName);
+        this.logger.increaseIndent();
+        this.logger.process(error, function (displayProcessor, object, log) {
+            return displayProcessor.displaySummaryErrorMessages(object, log);
+        });
+        this.logger.decreaseIndent();
+    };
+    return SummaryDisplay;
+}());
+exports.SummaryDisplay = SummaryDisplay;
+//# sourceMappingURL=summary-display.js.map

node_modules/jasmine-spec-reporter/built/execution-metrics.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="jasmine" />
+import { CustomReporterResult } from "./spec-reporter";
+import SuiteInfo = jasmine.SuiteInfo;
+import RunDetails = jasmine.RunDetails;
+export declare class ExecutionMetrics {
+    private static pluralize;
+    successfulSpecs: number;
+    failedSpecs: number;
+    pendingSpecs: number;
+    skippedSpecs: number;
+    totalSpecsDefined: number;
+    executedSpecs: number;
+    globalErrors: CustomReporterResult[];
+    duration: string;
+    random: boolean;
+    seed: string;
+    private startTime;
+    private specStartTime;
+    start(suiteInfo: SuiteInfo): void;
+    stop(runDetails: RunDetails): void;
+    startSpec(): void;
+    stopSpec(result: CustomReporterResult): void;
+    private formatDuration;
+}

node_modules/jasmine-spec-reporter/built/execution-metrics.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionMetrics = void 0;
+var ExecutionMetrics = /** @class */ (function () {
+    function ExecutionMetrics() {
+        this.successfulSpecs = 0;
+        this.failedSpecs = 0;
+        this.pendingSpecs = 0;
+        this.skippedSpecs = 0;
+        this.totalSpecsDefined = 0;
+        this.executedSpecs = 0;
+        this.globalErrors = [];
+        this.random = false;
+    }
+    ExecutionMetrics.pluralize = function (count) {
+        return count > 1 ? "s" : "";
+    };
+    ExecutionMetrics.prototype.start = function (suiteInfo) {
+        this.startTime = (new Date()).getTime();
+        this.totalSpecsDefined = suiteInfo && suiteInfo.totalSpecsDefined ? suiteInfo.totalSpecsDefined : 0;
+    };
+    ExecutionMetrics.prototype.stop = function (runDetails) {
+        var totalSpecs = this.failedSpecs + this.successfulSpecs + this.pendingSpecs;
+        this.duration = this.formatDuration((new Date()).getTime() - this.startTime);
+        this.executedSpecs = this.failedSpecs + this.successfulSpecs;
+        this.totalSpecsDefined = this.totalSpecsDefined ? this.totalSpecsDefined : totalSpecs;
+        this.skippedSpecs = this.totalSpecsDefined - totalSpecs;
+        this.random = runDetails.order.random;
+        this.seed = runDetails.order.seed;
+    };
+    ExecutionMetrics.prototype.startSpec = function () {
+        this.specStartTime = (new Date()).getTime();
+    };
+    ExecutionMetrics.prototype.stopSpec = function (result) {
+        result.duration = this.formatDuration((new Date()).getTime() - this.specStartTime);
+    };
+    ExecutionMetrics.prototype.formatDuration = function (durationInMs) {
+        var duration = "";
+        var durationInSecs = durationInMs / 1000;
+        var durationInMins;
+        var durationInHrs;
+        if (durationInSecs < 1) {
+            return durationInSecs + " sec" + ExecutionMetrics.pluralize(durationInSecs);
+        }
+        durationInSecs = Math.round(durationInSecs);
+        if (durationInSecs < 60) {
+            return durationInSecs + " sec" + ExecutionMetrics.pluralize(durationInSecs);
+        }
+        durationInMins = Math.floor(durationInSecs / 60);
+        durationInSecs = durationInSecs % 60;
+        if (durationInSecs) {
+            duration = " " + durationInSecs + " sec" + ExecutionMetrics.pluralize(durationInSecs);
+        }
+        if (durationInMins < 60) {
+            return durationInMins + " min" + ExecutionMetrics.pluralize(durationInMins) + duration;
+        }
+        durationInHrs = Math.floor(durationInMins / 60);
+        durationInMins = durationInMins % 60;
+        if (durationInMins) {
+            duration = " " + durationInMins + " min" + ExecutionMetrics.pluralize(durationInMins) + duration;
+        }
+        return durationInHrs + " hour" + ExecutionMetrics.pluralize(durationInHrs) + duration;
+    };
+    return ExecutionMetrics;
+}());
+exports.ExecutionMetrics = ExecutionMetrics;
+//# sourceMappingURL=execution-metrics.js.map

node_modules/jasmine-spec-reporter/built/main.d.ts

@@ -0,0 +1,3 @@
+export { SpecReporter } from "./spec-reporter";
+export { DisplayProcessor } from "./display-processor";
+export { StacktraceOption } from "./configuration";

node_modules/jasmine-spec-reporter/built/main.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var spec_reporter_1 = require("./spec-reporter");
+Object.defineProperty(exports, "SpecReporter", { enumerable: true, get: function () { return spec_reporter_1.SpecReporter; } });
+var display_processor_1 = require("./display-processor");
+Object.defineProperty(exports, "DisplayProcessor", { enumerable: true, get: function () { return display_processor_1.DisplayProcessor; } });
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "StacktraceOption", { enumerable: true, get: function () { return configuration_1.StacktraceOption; } });
+//# sourceMappingURL=main.js.map

node_modules/jasmine-spec-reporter/built/processors/default-processor.d.ts

@@ -0,0 +1,13 @@
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+export declare class DefaultProcessor extends DisplayProcessor {
+    private static displaySpecDescription;
+    displayJasmineStarted(): string;
+    displaySuite(suite: CustomReporterResult): string;
+    displaySuccessfulSpec(spec: CustomReporterResult): string;
+    displayFailedSpec(spec: CustomReporterResult): string;
+    displaySpecErrorMessages(spec: CustomReporterResult): string;
+    displaySummaryErrorMessages(spec: CustomReporterResult): string;
+    displayPendingSpec(spec: CustomReporterResult): string;
+    private displayErrorMessages;
+}

node_modules/jasmine-spec-reporter/built/processors/default-processor.js

@@ -0,0 +1,62 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultProcessor = void 0;
+var configuration_1 = require("../configuration");
+var display_processor_1 = require("../display-processor");
+var DefaultProcessor = /** @class */ (function (_super) {
+    __extends(DefaultProcessor, _super);
+    function DefaultProcessor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DefaultProcessor.displaySpecDescription = function (spec) {
+        return spec.description;
+    };
+    DefaultProcessor.prototype.displayJasmineStarted = function () {
+        return "Jasmine started";
+    };
+    DefaultProcessor.prototype.displaySuite = function (suite) {
+        return suite.description;
+    };
+    DefaultProcessor.prototype.displaySuccessfulSpec = function (spec) {
+        return DefaultProcessor.displaySpecDescription(spec);
+    };
+    DefaultProcessor.prototype.displayFailedSpec = function (spec) {
+        return DefaultProcessor.displaySpecDescription(spec);
+    };
+    DefaultProcessor.prototype.displaySpecErrorMessages = function (spec) {
+        return this.displayErrorMessages(spec, this.configuration.spec.displayStacktrace);
+    };
+    DefaultProcessor.prototype.displaySummaryErrorMessages = function (spec) {
+        return this.displayErrorMessages(spec, this.configuration.summary.displayStacktrace);
+    };
+    DefaultProcessor.prototype.displayPendingSpec = function (spec) {
+        return DefaultProcessor.displaySpecDescription(spec);
+    };
+    DefaultProcessor.prototype.displayErrorMessages = function (spec, stacktraceOption) {
+        var logs = [];
+        for (var _i = 0, _a = spec.failedExpectations; _i < _a.length; _i++) {
+            var failedExpectation = _a[_i];
+            logs.push(this.theme.failed("- ") + this.theme.failed(failedExpectation.message));
+            if (stacktraceOption === configuration_1.StacktraceOption.RAW && failedExpectation.stack) {
+                logs.push(this.configuration.stacktrace.filter(failedExpectation.stack));
+            }
+        }
+        return logs.join("\n");
+    };
+    return DefaultProcessor;
+}(display_processor_1.DisplayProcessor));
+exports.DefaultProcessor = DefaultProcessor;
+//# sourceMappingURL=default-processor.js.map

node_modules/jasmine-spec-reporter/built/processors/pretty-stacktrace-processor.d.ts

@@ -0,0 +1,9 @@
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+export declare class PrettyStacktraceProcessor extends DisplayProcessor {
+    displaySpecErrorMessages(spec: CustomReporterResult, log: string): string;
+    displaySummaryErrorMessages(spec: CustomReporterResult, log: string): string;
+    private displayErrorMessages;
+    private prettifyStack;
+    private retrieveErrorContext;
+}

node_modules/jasmine-spec-reporter/built/processors/pretty-stacktrace-processor.js

@@ -0,0 +1,83 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrettyStacktraceProcessor = void 0;
+var fs = require("fs");
+var configuration_1 = require("../configuration");
+var display_processor_1 = require("../display-processor");
+var STACK_REG_EXP = /\((.*):(\d+):(\d+)\)/;
+var CONTEXT = 2;
+var PrettyStacktraceProcessor = /** @class */ (function (_super) {
+    __extends(PrettyStacktraceProcessor, _super);
+    function PrettyStacktraceProcessor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PrettyStacktraceProcessor.prototype.displaySpecErrorMessages = function (spec, log) {
+        return this.configuration.spec.displayStacktrace === configuration_1.StacktraceOption.PRETTY ? this.displayErrorMessages(spec) : log;
+    };
+    PrettyStacktraceProcessor.prototype.displaySummaryErrorMessages = function (spec, log) {
+        return this.configuration.summary.displayStacktrace === configuration_1.StacktraceOption.PRETTY ? this.displayErrorMessages(spec) : log;
+    };
+    PrettyStacktraceProcessor.prototype.displayErrorMessages = function (spec) {
+        var logs = [];
+        for (var _i = 0, _a = spec.failedExpectations; _i < _a.length; _i++) {
+            var failedExpectation = _a[_i];
+            logs.push(this.theme.failed("- ") + this.theme.failed(failedExpectation.message));
+            if (failedExpectation.stack) {
+                logs.push(this.prettifyStack(failedExpectation.stack));
+            }
+        }
+        return logs.join("\n");
+    };
+    PrettyStacktraceProcessor.prototype.prettifyStack = function (stack) {
+        var _this = this;
+        var logs = [];
+        var filteredStack = this.configuration.stacktrace.filter(stack);
+        var stackRegExp = new RegExp(STACK_REG_EXP);
+        filteredStack.split("\n").forEach(function (stackLine) {
+            if (stackRegExp.test(stackLine)) {
+                var _a = stackLine.match(stackRegExp), filename = _a[1], lineNumber = _a[2], columnNumber = _a[3];
+                var errorContext = _this.retrieveErrorContext(filename, parseInt(lineNumber, 10), parseInt(columnNumber, 10));
+                logs.push(_this.theme.prettyStacktraceFilename(filename) + ":" + _this.theme.prettyStacktraceLineNumber(lineNumber) + ":" + _this.theme.prettyStacktraceColumnNumber(columnNumber));
+                logs.push(errorContext + "\n");
+            }
+        });
+        return "\n" + logs.join("\n");
+    };
+    PrettyStacktraceProcessor.prototype.retrieveErrorContext = function (filename, lineNb, columnNb) {
+        var logs = [];
+        var fileLines;
+        try {
+            fileLines = fs.readFileSync(filename, "utf-8")
+                .split("\n");
+        }
+        catch (error) {
+            return "jasmine-spec-reporter: unable to open '" + filename + "'\n" + error;
+        }
+        for (var i = 0; i < fileLines.length; i++) {
+            var errorLine = lineNb - 1;
+            if (i >= errorLine - CONTEXT && i <= errorLine + CONTEXT) {
+                logs.push(fileLines[i]);
+            }
+            if (i === errorLine) {
+                logs.push(" ".repeat(columnNb - 1) + this.theme.prettyStacktraceError("~"));
+            }
+        }
+        return logs.join("\n");
+    };
+    return PrettyStacktraceProcessor;
+}(display_processor_1.DisplayProcessor));
+exports.PrettyStacktraceProcessor = PrettyStacktraceProcessor;
+//# sourceMappingURL=pretty-stacktrace-processor.js.map

node_modules/jasmine-spec-reporter/built/processors/spec-colors-processor.d.ts

@@ -0,0 +1,7 @@
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+export declare class SpecColorsProcessor extends DisplayProcessor {
+    displaySuccessfulSpec(spec: CustomReporterResult, log: string): string;
+    displayFailedSpec(spec: CustomReporterResult, log: string): string;
+    displayPendingSpec(spec: CustomReporterResult, log: string): string;
+}

node_modules/jasmine-spec-reporter/built/processors/spec-colors-processor.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecColorsProcessor = void 0;
+var display_processor_1 = require("../display-processor");
+var SpecColorsProcessor = /** @class */ (function (_super) {
+    __extends(SpecColorsProcessor, _super);
+    function SpecColorsProcessor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpecColorsProcessor.prototype.displaySuccessfulSpec = function (spec, log) {
+        return this.theme.successful(log);
+    };
+    SpecColorsProcessor.prototype.displayFailedSpec = function (spec, log) {
+        return this.theme.failed(log);
+    };
+    SpecColorsProcessor.prototype.displayPendingSpec = function (spec, log) {
+        return this.theme.pending(log);
+    };
+    return SpecColorsProcessor;
+}(display_processor_1.DisplayProcessor));
+exports.SpecColorsProcessor = SpecColorsProcessor;
+//# sourceMappingURL=spec-colors-processor.js.map

node_modules/jasmine-spec-reporter/built/processors/spec-durations-processor.d.ts

@@ -0,0 +1,7 @@
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+export declare class SpecDurationsProcessor extends DisplayProcessor {
+    private static displayDuration;
+    displaySuccessfulSpec(spec: CustomReporterResult, log: string): string;
+    displayFailedSpec(spec: CustomReporterResult, log: string): string;
+}

node_modules/jasmine-spec-reporter/built/processors/spec-durations-processor.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecDurationsProcessor = void 0;
+var display_processor_1 = require("../display-processor");
+var SpecDurationsProcessor = /** @class */ (function (_super) {
+    __extends(SpecDurationsProcessor, _super);
+    function SpecDurationsProcessor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpecDurationsProcessor.displayDuration = function (spec, log) {
+        return log + " (" + spec.duration + ")";
+    };
+    SpecDurationsProcessor.prototype.displaySuccessfulSpec = function (spec, log) {
+        return SpecDurationsProcessor.displayDuration(spec, log);
+    };
+    SpecDurationsProcessor.prototype.displayFailedSpec = function (spec, log) {
+        return SpecDurationsProcessor.displayDuration(spec, log);
+    };
+    return SpecDurationsProcessor;
+}(display_processor_1.DisplayProcessor));
+exports.SpecDurationsProcessor = SpecDurationsProcessor;
+//# sourceMappingURL=spec-durations-processor.js.map

node_modules/jasmine-spec-reporter/built/processors/spec-prefixes-processor.d.ts

@@ -0,0 +1,7 @@
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+export declare class SpecPrefixesProcessor extends DisplayProcessor {
+    displaySuccessfulSpec(spec: CustomReporterResult, log: string): string;
+    displayFailedSpec(spec: CustomReporterResult, log: string): string;
+    displayPendingSpec(spec: CustomReporterResult, log: string): string;
+}

node_modules/jasmine-spec-reporter/built/processors/spec-prefixes-processor.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecPrefixesProcessor = void 0;
+var display_processor_1 = require("../display-processor");
+var SpecPrefixesProcessor = /** @class */ (function (_super) {
+    __extends(SpecPrefixesProcessor, _super);
+    function SpecPrefixesProcessor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpecPrefixesProcessor.prototype.displaySuccessfulSpec = function (spec, log) {
+        return this.configuration.prefixes.successful + log;
+    };
+    SpecPrefixesProcessor.prototype.displayFailedSpec = function (spec, log) {
+        return this.configuration.prefixes.failed + log;
+    };
+    SpecPrefixesProcessor.prototype.displayPendingSpec = function (spec, log) {
+        return this.configuration.prefixes.pending + log;
+    };
+    return SpecPrefixesProcessor;
+}(display_processor_1.DisplayProcessor));
+exports.SpecPrefixesProcessor = SpecPrefixesProcessor;
+//# sourceMappingURL=spec-prefixes-processor.js.map

node_modules/jasmine-spec-reporter/built/processors/suite-numbering-processor.d.ts

@@ -0,0 +1,10 @@
+import { DisplayProcessor } from "../display-processor";
+import { CustomReporterResult } from "../spec-reporter";
+export declare class SuiteNumberingProcessor extends DisplayProcessor {
+    private static getParentName;
+    private suiteHierarchy;
+    displaySuite(suite: CustomReporterResult, log: string): string;
+    private computeNumber;
+    private computeHierarchy;
+    private computeHierarchyNumber;
+}

node_modules/jasmine-spec-reporter/built/processors/suite-numbering-processor.js

@@ -0,0 +1,60 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiteNumberingProcessor = void 0;
+var display_processor_1 = require("../display-processor");
+var SuiteNumberingProcessor = /** @class */ (function (_super) {
+    __extends(SuiteNumberingProcessor, _super);
+    function SuiteNumberingProcessor() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.suiteHierarchy = [];
+        return _this;
+    }
+    SuiteNumberingProcessor.getParentName = function (element) {
+        return element.fullName.replace(element.description, "").trim();
+    };
+    SuiteNumberingProcessor.prototype.displaySuite = function (suite, log) {
+        return this.computeNumber(suite) + " " + log;
+    };
+    SuiteNumberingProcessor.prototype.computeNumber = function (suite) {
+        this.computeHierarchy(suite);
+        return this.computeHierarchyNumber();
+    };
+    SuiteNumberingProcessor.prototype.computeHierarchy = function (suite) {
+        var parentName = SuiteNumberingProcessor.getParentName(suite);
+        var i = 0;
+        for (; i < this.suiteHierarchy.length; i++) {
+            if (this.suiteHierarchy[i].name === parentName) {
+                this.suiteHierarchy[i].number++;
+                this.suiteHierarchy.splice(i + 1, this.suiteHierarchy.length - i - 1);
+                break;
+            }
+        }
+        if (i === this.suiteHierarchy.length) {
+            this.suiteHierarchy.push({ name: parentName, number: 1 });
+        }
+    };
+    SuiteNumberingProcessor.prototype.computeHierarchyNumber = function () {
+        var hierarchyNumber = "";
+        for (var _i = 0, _a = this.suiteHierarchy; _i < _a.length; _i++) {
+            var suite = _a[_i];
+            hierarchyNumber += suite.number + ".";
+        }
+        return hierarchyNumber.substring(0, hierarchyNumber.length - 1);
+    };
+    return SuiteNumberingProcessor;
+}(display_processor_1.DisplayProcessor));
+exports.SuiteNumberingProcessor = SuiteNumberingProcessor;
+//# sourceMappingURL=suite-numbering-processor.js.map

node_modules/jasmine-spec-reporter/built/spec-reporter.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="jasmine" />
+import { Configuration } from "./configuration";
+import CustomReporter = jasmine.CustomReporter;
+import SuiteInfo = jasmine.SuiteInfo;
+import RunDetails = jasmine.RunDetails;
+export interface CustomReporterResult extends jasmine.CustomReporterResult {
+    duration?: string;
+}
+export interface ExecutedSpecs {
+    failed: CustomReporterResult[];
+    pending: CustomReporterResult[];
+    successful: CustomReporterResult[];
+}
+export declare class SpecReporter implements CustomReporter {
+    private static initProcessors;
+    private logger;
+    private specs;
+    private display;
+    private summary;
+    private metrics;
+    private configuration;
+    private theme;
+    constructor(configuration?: Configuration);
+    jasmineStarted(suiteInfo: SuiteInfo): void;
+    jasmineDone(runDetails: RunDetails): void;
+    suiteStarted(result: CustomReporterResult): void;
+    suiteDone(result: CustomReporterResult): void;
+    specStarted(result: CustomReporterResult): void;
+    specDone(result: CustomReporterResult): void;
+    private runDetailsToResult;
+}

node_modules/jasmine-spec-reporter/built/spec-reporter.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecReporter = void 0;
+var ConfigurationParser = require("./configuration-parser");
+var execution_display_1 = require("./display/execution-display");
+var logger_1 = require("./display/logger");
+var summary_display_1 = require("./display/summary-display");
+var execution_metrics_1 = require("./execution-metrics");
+var default_processor_1 = require("./processors/default-processor");
+var pretty_stacktrace_processor_1 = require("./processors/pretty-stacktrace-processor");
+var spec_colors_processor_1 = require("./processors/spec-colors-processor");
+var spec_durations_processor_1 = require("./processors/spec-durations-processor");
+var spec_prefixes_processor_1 = require("./processors/spec-prefixes-processor");
+var suite_numbering_processor_1 = require("./processors/suite-numbering-processor");
+var theme_1 = require("./theme");
+var SpecReporter = /** @class */ (function () {
+    function SpecReporter(configuration) {
+        this.specs = {
+            failed: [],
+            pending: [],
+            successful: []
+        };
+        this.configuration = ConfigurationParser.parse(configuration);
+        this.theme = new theme_1.Theme(this.configuration);
+        var displayProcessors = SpecReporter.initProcessors(this.configuration, this.theme);
+        var print = this.configuration.print;
+        this.logger = new logger_1.Logger(displayProcessors, print);
+        this.display = new execution_display_1.ExecutionDisplay(this.configuration, this.logger, this.specs, displayProcessors);
+        this.summary = new summary_display_1.SummaryDisplay(this.configuration, this.theme, this.logger, this.specs);
+        this.metrics = new execution_metrics_1.ExecutionMetrics();
+    }
+    SpecReporter.initProcessors = function (configuration, theme) {
+        var displayProcessors = [
+            new default_processor_1.DefaultProcessor(configuration, theme),
+            new spec_prefixes_processor_1.SpecPrefixesProcessor(configuration, theme),
+            new spec_colors_processor_1.SpecColorsProcessor(configuration, theme),
+            new pretty_stacktrace_processor_1.PrettyStacktraceProcessor(configuration, theme)
+        ];
+        if (configuration.spec.displayDuration) {
+            displayProcessors.push(new spec_durations_processor_1.SpecDurationsProcessor(configuration, theme));
+        }
+        if (configuration.suite.displayNumber) {
+            displayProcessors.push(new suite_numbering_processor_1.SuiteNumberingProcessor(configuration, theme));
+        }
+        if (configuration.customProcessors) {
+            configuration.customProcessors.forEach(function (Processor) {
+                displayProcessors.push(new Processor(configuration, theme));
+            });
+        }
+        return displayProcessors;
+    };
+    SpecReporter.prototype.jasmineStarted = function (suiteInfo) {
+        this.metrics.start(suiteInfo);
+        this.display.jasmineStarted(suiteInfo);
+    };
+    SpecReporter.prototype.jasmineDone = function (runDetails) {
+        this.metrics.stop(runDetails);
+        if (runDetails.failedExpectations && runDetails.failedExpectations.length) {
+            var error = this.runDetailsToResult(runDetails);
+            this.metrics.globalErrors.push(error);
+            this.display.failed(error);
+        }
+        this.summary.display(this.metrics);
+    };
+    SpecReporter.prototype.suiteStarted = function (result) {
+        this.display.suiteStarted(result);
+    };
+    SpecReporter.prototype.suiteDone = function (result) {
+        this.display.suiteDone(result);
+        if (result.failedExpectations.length) {
+            this.metrics.globalErrors.push(result);
+        }
+    };
+    SpecReporter.prototype.specStarted = function (result) {
+        this.metrics.startSpec();
+        this.display.specStarted(result);
+    };
+    SpecReporter.prototype.specDone = function (result) {
+        this.metrics.stopSpec(result);
+        if (result.status === "pending") {
+            this.metrics.pendingSpecs++;
+            this.display.pending(result);
+        }
+        else if (result.status === "passed") {
+            this.metrics.successfulSpecs++;
+            this.display.successful(result);
+        }
+        else if (result.status === "failed") {
+            this.metrics.failedSpecs++;
+            this.display.failed(result);
+        }
+    };
+    SpecReporter.prototype.runDetailsToResult = function (runDetails) {
+        return {
+            description: "Non-spec failure",
+            failedExpectations: runDetails.failedExpectations.map(function (expectation) {
+                return {
+                    actual: "",
+                    expected: "",
+                    matcherName: "",
+                    message: expectation.message,
+                    passed: false,
+                    stack: expectation.stack,
+                };
+            }),
+            fullName: "Non-spec failure",
+            id: "Non-spec failure",
+        };
+    };
+    return SpecReporter;
+}());
+exports.SpecReporter = SpecReporter;
+//# sourceMappingURL=spec-reporter.js.map

node_modules/jasmine-spec-reporter/built/theme.d.ts

@@ -0,0 +1,11 @@
+import { Configuration } from "./configuration";
+export declare class Theme {
+    constructor(configuration: Configuration);
+    successful(str: string): string;
+    failed(str: string): string;
+    pending(str: string): string;
+    prettyStacktraceFilename(str: string): string;
+    prettyStacktraceLineNumber(str: string): string;
+    prettyStacktraceColumnNumber(str: string): string;
+    prettyStacktraceError(str: string): string;
+}

node_modules/jasmine-spec-reporter/built/theme.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Theme = void 0;
+// tslint:disable-next-line:no-submodule-imports
+var colors = require("colors/safe");
+var colorsTheme = colors;
+var Theme = /** @class */ (function () {
+    function Theme(configuration) {
+        configuration.colors.enabled ? colors.enable() : colors.disable();
+        colors.setTheme({
+            failed: configuration.colors.failed,
+            pending: configuration.colors.pending,
+            successful: configuration.colors.successful,
+            prettyStacktraceFilename: configuration.colors.prettyStacktraceFilename,
+            prettyStacktraceLineNumber: configuration.colors.prettyStacktraceLineNumber,
+            prettyStacktraceColumnNumber: configuration.colors.prettyStacktraceColumnNumber,
+            prettyStacktraceError: configuration.colors.prettyStacktraceError,
+        });
+    }
+    Theme.prototype.successful = function (str) {
+        return colorsTheme.successful(str);
+    };
+    Theme.prototype.failed = function (str) {
+        return colorsTheme.failed(str);
+    };
+    Theme.prototype.pending = function (str) {
+        return colorsTheme.pending(str);
+    };
+    Theme.prototype.prettyStacktraceFilename = function (str) {
+        return colorsTheme.prettyStacktraceFilename(str);
+    };
+    Theme.prototype.prettyStacktraceLineNumber = function (str) {
+        return colorsTheme.prettyStacktraceLineNumber(str);
+    };
+    Theme.prototype.prettyStacktraceColumnNumber = function (str) {
+        return colorsTheme.prettyStacktraceColumnNumber(str);
+    };
+    Theme.prototype.prettyStacktraceError = function (str) {
+        return colorsTheme.prettyStacktraceError(str);
+    };
+    return Theme;
+}());
+exports.Theme = Theme;
+//# sourceMappingURL=theme.js.map