@teamscale/javascript-instrumenter 0.0.1-beta.9 → 0.1.0-beta.2

package/dist/src/instrumenter/FileSystem.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -22,10 +26,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expandToFileSet = exports.isDirectoryEmpty = exports.ensureExistingDirectory = exports.isExistingDirectory = exports.isExistingFile = void 0;
+exports.sourceMapFromMapFile = exports.expandToFileSet = exports.isDirectoryEmpty = exports.findSubFolders = exports.ensureExistingDirectory = exports.isExistingDirectory = exports.isExistingFile = void 0;
 const commons_1 = require("@cqse/commons");
 const fs = __importStar(require("fs"));
-const mkdirp_1 = __importDefault(require("mkdirp"));
+const mkdirp = __importStar(require("mkdirp"));
 const path_1 = __importDefault(require("path"));
 const glob_1 = require("glob");
 /**
@@ -47,13 +51,32 @@ exports.isExistingDirectory = isExistingDirectory;
  */
 function ensureExistingDirectory(path) {
     if (!fs.existsSync(path)) {
-        mkdirp_1.default.sync(path);
+        mkdirp.sync(path);
     }
     if (!fs.lstatSync(path).isDirectory()) {
         throw new commons_1.InvalidConfigurationException(`The specified path '${path}' does not point to an existing directory!`);
     }
 }
 exports.ensureExistingDirectory = ensureExistingDirectory;
+/**
+ * Given a root folder find a folder with a given name.
+ */
+function findSubFolders(startFromFolder, folderName) {
+    const matches = [];
+    const entries = fs.readdirSync(startFromFolder, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(startFromFolder, entry.name);
+        if (entry.name === folderName && entry.isDirectory()) {
+            matches.push(fullPath);
+        }
+        if (entry.isDirectory()) {
+            const nestedMatches = findSubFolders(fullPath, folderName);
+            matches.push(...nestedMatches);
+        }
+    }
+    return matches;
+}
+exports.findSubFolders = findSubFolders;
 /**
  * Is the given directory empty?
  */
@@ -80,3 +103,13 @@ function expandToFileSet(toExpand) {
     return glob_1.glob.sync(globPattern, { nodir: true });
 }
 exports.expandToFileSet = expandToFileSet;
+/**
+ * Read a source map from a source map file.
+ *
+ * @param mapFilePath
+ */
+function sourceMapFromMapFile(mapFilePath) {
+    const content = fs.readFileSync(mapFilePath, 'utf8');
+    return JSON.parse(content);
+}
+exports.sourceMapFromMapFile = sourceMapFromMapFile;

package/dist/src/instrumenter/Instrumenter.d.ts

@@ -1,6 +1,8 @@
-import { CollectorSpecifier, InstrumentationTask, OriginSourcePattern, TaskElement, TaskResult } from './Task';
-import { Logger } from 'winston';
-export declare const IS_INSTRUMENTED_TOKEN = "/** $IS_JS_PROFILER_INSTRUMENTED=true **/";
+import { CollectorSpecifier, FileExcludePattern, InstrumentationTask, OriginSourcePattern, SourceMapReference, TaskElement, TaskResult } from './Task';
+import { RawSourceMap, SourceMapConsumer } from 'source-map';
+import { Optional } from 'typescript-optional';
+import Logger from 'bunyan';
+export declare const IS_INSTRUMENTED_TOKEN = "$IS_JS_PROFILER_INSTRUMENTED=true";
 /**
  * An instrumenter that can conduct a {@code InstrumentationTask}.
  */
@@ -17,16 +19,16 @@ export interface IInstrumenter {
  */
 export declare class IstanbulInstrumenter implements IInstrumenter {
     /**
-     * The path to the vaccine to inject. The vaccine is a JavaScript
+     * The vaccine to inject. The vaccine is a JavaScript
      * file with the code to forward the coverage information
      * produced by the Istanbul instrumentation.
      */
-    private readonly vaccineFilePath;
+    private readonly vaccineSource;
     /**
      * The logger instance to log to.
      */
     private logger;
-    constructor(vaccineFilePath: string, logger: Logger);
+    constructor(vaccineFilePath: string, logger: Logger, collector: CollectorSpecifier);
     /**
      * {@inheritDoc #IInstrumenter.instrument}
      */
@@ -36,24 +38,19 @@ export declare class IstanbulInstrumenter implements IInstrumenter {
      *
      * @param collector - The collector to send the coverage information to.
      * @param taskElement - The task element to perform the instrumentation for.
+     * @param excludeBundles - A exclude pattern to restrict which bundles should be instrumented
      * @param sourcePattern - A pattern to restrict the instrumentation to only a fraction of the task element.
+     * @param dumpOriginsFile - A file path where all origins from the source map should be dumped in json format, or undefined if no origins should be dumped
      */
-    instrumentOne(collector: CollectorSpecifier, taskElement: TaskElement, sourcePattern: OriginSourcePattern): TaskResult;
+    instrumentOne(taskElement: TaskElement, excludeBundles: FileExcludePattern, sourcePattern: OriginSourcePattern, dumpOriginsFile: string | undefined): Promise<TaskResult>;
+    private instrumentBundle;
+    private writeBundleFile;
     /**
      * Loads the vaccine from the vaccine file and adjusts some template parameters.
      *
      * @param collector - The collector to send coverage information to.
      */
     private loadVaccine;
-    /**
-     * Should the given file be excluded from the instrumentation,
-     * based on the source files that have been transpiled into it?
-     *
-     * @param pattern - The pattern to match the origin source files.
-     * @param sourceFile - The bundle file name.
-     * @param originSourceFiles - The list of files that were transpiled into the bundle.
-     */
-    private shouldExcludeFromInstrumentation;
     /**
      * @returns whether the given file is supported for instrumentation.
      */
@@ -63,12 +60,31 @@ export declare class IstanbulInstrumenter implements IInstrumenter {
      * given task element.
      */
     private configurationAlternativesFor;
-    /**
-     * Given a source code file and the task element, load the corresponding sourcemap.
-     *
-     * @param inputSource - The source code that might contain sourcemap comments.
-     * @param taskElement - The task element that can have a reference to an external sourcemap.
-     */
-    private loadInputSourceMap;
+    /** Appends all origins from the source map to a given file. Creates the file if it does not exist yet. */
+    private dumpOrigins;
+    /** Clears the dump origins file if it exists, such that it is now ready to be appended for every instrumented file. */
+    private clearDumpOriginsFileIfNeeded;
 }
+/**
+ * Extract the sourcemap from the given source code.
+ *
+ * @param instrumentedSource - The source code.
+ * @param instrumentedSourceFileName - The file name to assume for the file name.
+ */
+export declare function loadSourceMap(instrumentedSource: string, instrumentedSourceFileName: string): Promise<SourceMapConsumer | undefined>;
+/**
+ * Given a source code file, load the corresponding sourcemap.
+ *
+ * @param inputSource - The source code that might contain sourcemap comments.
+ * @param taskFile - The name of the file the `inputSource` is from.
+ * @param externalSourceMapFile - An external source map file to consider.
+ */
+export declare function loadInputSourceMap(inputSource: string, taskFile: string, externalSourceMapFile: Optional<SourceMapReference>): RawSourceMap | undefined;
+/**
+ * Extract a sourcemap for a given code comment.
+ *
+ * @param sourcecode - The source code that is scanned for source map comments.
+ * @param sourceFilePath - The file name the code was loaded from.
+ */
+export declare function sourceMapFromCodeComment(sourcecode: string, sourceFilePath: string): RawSourceMap | undefined;
 //# sourceMappingURL=Instrumenter.d.ts.map

package/dist/src/instrumenter/Instrumenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Instrumenter.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/Instrumenter.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EAEnB,WAAW,EACX,UAAU,EACV,MAAM,QAAQ,CAAC;AAOhB,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,eAAO,MAAM,qBAAqB,8CAA8C,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3D;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,aAAa;IACzD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAS;gBAEX,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IASnD;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAW1D;;;;;;OAMG;IACH,aAAa,CACZ,SAAS,EAAE,kBAAkB,EAC7B,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,mBAAmB,GAChC,UAAU;IAuFb;;;;OAIG;IACH,OAAO,CAAC,WAAW;IASnB;;;;;;;OAOG;IACH,OAAO,CAAC,gCAAgC;IAQxC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAcpC;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;CAW1B"}
+{"version":3,"file":"Instrumenter.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/Instrumenter.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,kBAAkB,EAClB,kBAAkB,EAElB,mBAAmB,EACnB,mBAAmB,EAEnB,kBAAkB,EAElB,WAAW,EACX,UAAU,EACV,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAM7D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,MAAM,MAAM,QAAQ,CAAC;AAQ5B,eAAO,MAAM,qBAAqB,sCAAsC,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3D;AA0BD;;GAEG;AACH,qBAAa,oBAAqB,YAAW,aAAa;IACzD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAS;gBAEX,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB;IAUlF;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBhE;;;;;;;;OAQG;IACG,aAAa,CAClB,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,kBAAkB,EAClC,aAAa,EAAE,mBAAmB,EAClC,eAAe,EAAE,MAAM,GAAG,SAAS,GACjC,OAAO,CAAC,UAAU,CAAC;YAsER,gBAAgB;IA8C9B,OAAO,CAAC,eAAe;IA0BvB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAMnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAepC,0GAA0G;IAC1G,OAAO,CAAC,WAAW;IASnB,uHAAuH;IACvH,OAAO,CAAC,4BAA4B;CASpC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAClC,kBAAkB,EAAE,MAAM,EAC1B,0BAA0B,EAAE,MAAM,GAChC,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAUxC;AAsBD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,qBAAqB,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACjD,YAAY,GAAG,SAAS,CAU1B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAwC7G"}

package/dist/src/instrumenter/Instrumenter.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -18,135 +22,194 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IstanbulInstrumenter = exports.IS_INSTRUMENTED_TOKEN = void 0;
+exports.sourceMapFromCodeComment = exports.loadInputSourceMap = exports.loadSourceMap = exports.IstanbulInstrumenter = exports.IS_INSTRUMENTED_TOKEN = void 0;
 const Task_1 = require("./Task");
 const commons_1 = require("@cqse/commons");
-const istanbul = __importStar(require("istanbul-lib-instrument"));
+const source_map_1 = require("source-map");
+const istanbul = __importStar(require("@teamscale/lib-instrument"));
 const fs = __importStar(require("fs"));
+const mkdirp = __importStar(require("mkdirp"));
 const path = __importStar(require("path"));
 const convertSourceMap = __importStar(require("convert-source-map"));
-exports.IS_INSTRUMENTED_TOKEN = '/** $IS_JS_PROFILER_INSTRUMENTED=true **/';
+const typescript_optional_1 = require("typescript-optional");
+const async_1 = __importDefault(require("async"));
+const WebToolkit_1 = require("./WebToolkit");
+const FileSystem_1 = require("./FileSystem");
+exports.IS_INSTRUMENTED_TOKEN = '$IS_JS_PROFILER_INSTRUMENTED=true';
+function readBundle(bundleContent, taskElement) {
+    const baseNameMatch = path.basename(taskElement.fromFile).match('^([a-zA-Z0-9]*).cache.js');
+    const directories = path.dirname(taskElement.fromFile).split(path.sep);
+    if (baseNameMatch && directories.length > 1) {
+        const fragmentId = (0, WebToolkit_1.determineGwtFileUid)(taskElement.fromFile);
+        const functionCall = bundleContent.match('^([^(]+)\\((.*)\\);*\\s*$');
+        if (fragmentId && functionCall && functionCall.length === 3) {
+            const callInfos = (0, WebToolkit_1.extractGwtCallInfos)(bundleContent);
+            if (callInfos) {
+                return {
+                    type: 'gwt',
+                    content: bundleContent,
+                    fragmentId,
+                    functionName: callInfos.functionName,
+                    codeAsArrayArgument: callInfos.codeAsArrayArgument,
+                    codeArguments: callInfos.codeArguments
+                };
+            }
+        }
+    }
+    return { type: 'javascript', content: bundleContent, codeArguments: [bundleContent] };
+}
 /**
  * An instrumenter based on the IstanbulJs instrumentation and coverage framework.
  */
 class IstanbulInstrumenter {
-    constructor(vaccineFilePath, logger) {
-        this.vaccineFilePath = commons_1.Contract.requireNonEmpty(vaccineFilePath);
+    constructor(vaccineFilePath, logger, collector) {
         commons_1.Contract.require(fs.existsSync(vaccineFilePath), `The vaccine file to inject "${vaccineFilePath}" must exist!\nCWD:${process.cwd()}`);
+        this.vaccineSource = this.loadVaccine(commons_1.Contract.requireNonEmpty(vaccineFilePath), collector);
         this.logger = logger;
     }
     /**
      * {@inheritDoc #IInstrumenter.instrument}
      */
-    instrument(task) {
-        fs.existsSync(this.vaccineFilePath);
-        // ATTENTION: Here is potential for parallelization. Maybe we can
-        // run several instrumentation workers in parallel?
-        const result = task.elements
-            .map(e => this.instrumentOne(task.collector, e, task.originSourcePattern))
-            .reduce((prev, current) => current.withIncrement(prev), Task_1.TaskResult.neutral());
-        return Promise.resolve(result);
+    async instrument(task) {
+        this.clearDumpOriginsFileIfNeeded(task.dumpOriginsFile);
+        // We limit the number of instrumentations in parallel to one to
+        // not overuse memory (NodeJS has only limited mem to use).
+        return async_1.default
+            .mapLimit(task.elements, 1, async (taskElement) => {
+            return await this.instrumentOne(taskElement, task.excludeFilesPattern, task.originSourcePattern, task.dumpOriginsFile);
+        })
+            .then(results => {
+            return results.reduce((prev, curr) => {
+                return prev.withIncrement(curr);
+            }, Task_1.TaskResult.neutral());
+        });
     }
     /**
      * Perform the instrumentation for one given task element (file to instrument).
      *
      * @param collector - The collector to send the coverage information to.
      * @param taskElement - The task element to perform the instrumentation for.
+     * @param excludeBundles - A exclude pattern to restrict which bundles should be instrumented
      * @param sourcePattern - A pattern to restrict the instrumentation to only a fraction of the task element.
+     * @param dumpOriginsFile - A file path where all origins from the source map should be dumped in json format, or undefined if no origins should be dumped
      */
-    instrumentOne(collector, taskElement, sourcePattern) {
-        var _a, _b, _c;
-        const inputFileSource = fs.readFileSync(taskElement.fromFile, 'utf8');
+    async instrumentOne(taskElement, excludeBundles, sourcePattern, dumpOriginsFile) {
+        // Not all file types are supported by the instrumenter
+        if (!this.isFileTypeSupported(taskElement.fromFile)) {
+            if (!taskElement.isInPlace()) {
+                copyToFile(taskElement.toFile, taskElement.fromFile);
+            }
+            return new Task_1.TaskResult(0, 0, 0, 0, 1, 0, 0);
+        }
+        // Read the (supported) file
+        const bundleContent = fs.readFileSync(taskElement.fromFile, 'utf8');
+        const inputBundle = readBundle(bundleContent, taskElement);
         // We skip files that we have already instrumented
-        if (inputFileSource.startsWith(exports.IS_INSTRUMENTED_TOKEN)) {
+        if (inputBundle.content.substring(0, Math.min(inputBundle.content.length, 100)).includes(exports.IS_INSTRUMENTED_TOKEN)) {
             if (!taskElement.isInPlace()) {
-                fs.writeFileSync(taskElement.toFile, inputFileSource);
+                writeToFile(taskElement.toFile, inputBundle.content);
             }
-            return new Task_1.TaskResult(0, 0, 1, 0, 0, 0);
+            return new Task_1.TaskResult(0, 0, 0, 1, 0, 0, 0);
         }
-        // Not all file types are supported by the instrumenter
-        if (!this.isFileTypeSupported(taskElement.fromFile)) {
-            return new Task_1.TaskResult(0, 0, 0, 1, 0, 0);
+        // We might want to skip the instrumentation of the file
+        if (excludeBundles.isExcluded(taskElement.fromFile)) {
+            if (!taskElement.isInPlace()) {
+                copyToFile(taskElement.toFile, taskElement.fromFile);
+            }
+            return new Task_1.TaskResult(0, 1, 0, 0, 0, 0, 0);
         }
         // Report progress
         this.logger.info(`Instrumenting "${path.basename(taskElement.fromFile)}"`);
-        let finalSourceMap;
-        let instrumentedSource;
+        // Load the bundles source maps
+        const inputSourceMaps = loadInputSourceMaps(taskElement.fromFile, inputBundle, taskElement.externalSourceMapFile);
+        if (inputSourceMaps.length === 0) {
+            return Task_1.TaskResult.warning(`Failed loading input source map for ${taskElement.fromFile}.`);
+        }
         // We try to perform the instrumentation with different
         // alternative configurations of the instrumenter.
         const configurationAlternatives = this.configurationAlternativesFor(taskElement);
         for (let i = 0; i < configurationAlternatives.length; i++) {
-            let inputSourceMap;
+            const configurationAlternative = configurationAlternatives[i];
             try {
-                const instrumenter = istanbul.createInstrumenter(configurationAlternatives[i]);
-                inputSourceMap = this.loadInputSourceMap(inputFileSource, taskElement);
-                // Based on the source maps of the file to instrument, we can now
-                // decide if we should NOT write an instrumented version of it
-                // and use the original code instead and write it to the target path.
-                //
-                if (this.shouldExcludeFromInstrumentation(sourcePattern, taskElement.fromFile, (_b = (_a = instrumenter.lastSourceMap()) === null || _a === void 0 ? void 0 : _a.sources) !== null && _b !== void 0 ? _b : [])) {
-                    fs.writeFileSync(taskElement.toFile, inputFileSource);
-                    return new Task_1.TaskResult(1, 0, 0, 0, 0, 0);
-                }
-                // The main instrumentation (adding coverage statements) is performed now:
-                instrumentedSource = instrumenter
-                    .instrumentSync(inputFileSource, taskElement.fromFile, inputSourceMap)
-                    .replace(/return actualCoverage/g, 'return makeCoverageInterceptor(actualCoverage)')
-                    .replace(/new Function\("return this"\)\(\)/g, "typeof window === 'object' ? window : this");
-                this.logger.debug('Instrumentation source maps to:', (_c = instrumenter.lastSourceMap()) === null || _c === void 0 ? void 0 : _c.sources);
-                // The process also can result in a new source map that we will append in the result.
-                //
-                // `lastSourceMap` === Sourcemap for the last file that was instrumented.
-                finalSourceMap = convertSourceMap.fromObject(instrumenter.lastSourceMap()).toComment();
-                break;
+                return await this.instrumentBundle(taskElement, inputBundle, inputSourceMaps, configurationAlternative, dumpOriginsFile, sourcePattern);
             }
             catch (e) {
                 // If also the last configuration alternative failed,
                 // we emit a corresponding warning or signal an error.
                 if (i === configurationAlternatives.length - 1) {
-                    if (!inputSourceMap) {
-                        return Task_1.TaskResult.warning(`Failed loading input source map for ${taskElement.fromFile}: ${e.message}`);
-                    }
-                    fs.writeFileSync(taskElement.toFile, inputFileSource);
+                    writeToFile(taskElement.toFile, inputBundle.content);
                     return Task_1.TaskResult.error(e);
                 }
             }
         }
-        // We now can glue together the final version of the instrumented file.
+        return new Task_1.TaskResult(0, 0, 0, 0, 0, 1, 0);
+    }
+    async instrumentBundle(taskElement, inputBundle, inputSourceMaps, configurationAlternative, dumpOriginsFile, sourcePattern) {
+        var _a;
+        // Based on the source maps of the file to instrument, we can now
+        // decide if we should NOT write an instrumented version of it
+        // and use the original code instead and write it to the target path.
         //
-        const vaccineSource = this.loadVaccine(collector);
-        fs.writeFileSync(taskElement.toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${vaccineSource} ${instrumentedSource} \n${finalSourceMap}`);
-        return new Task_1.TaskResult(1, 0, 0, 0, 0, 0);
+        for (const inputSourceMap of inputSourceMaps.filter(map => map)) {
+            const originSourceFiles = (_a = inputSourceMap === null || inputSourceMap === void 0 ? void 0 : inputSourceMap.sources) !== null && _a !== void 0 ? _a : [];
+            if (dumpOriginsFile) {
+                this.dumpOrigins(dumpOriginsFile, originSourceFiles);
+            }
+        }
+        // The main instrumentation (adding coverage statements) is performed now:
+        const instrumenter = istanbul.createInstrumenter(configurationAlternative);
+        const instrumentedSources = [];
+        for (let i = 0; i < inputBundle.codeArguments.length; i++) {
+            const shouldInstrument = (node, originLocation) => {
+                if (!originLocation.filename) {
+                    return false;
+                }
+                return sourcePattern.isIncluded(originLocation.filename);
+            };
+            const instrumented = await instrumenter.instrument(inputBundle.codeArguments[i], taskElement.fromFile, inputSourceMaps[i], shouldInstrument);
+            instrumentedSources.push(instrumented);
+        }
+        this.writeBundleFile(taskElement.toFile, inputBundle, instrumentedSources);
+        return new Task_1.TaskResult(1, 0, 0, 0, 0, 0, 0);
+    }
+    writeBundleFile(toFile, inputBundle, instrumentedSources) {
+        if (inputBundle.type === 'gwt') {
+            commons_1.Contract.require(instrumentedSources.length === 1, 'Assuming only one code fragment to be passed as argument.');
+            const processedCodeString = JSON.stringify(`${this.vaccineSource} ${instrumentedSources[0]}`);
+            if (inputBundle.codeAsArrayArgument) {
+                writeToFile(toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${inputBundle.functionName}([${processedCodeString}]);`);
+            }
+            else {
+                writeToFile(toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${inputBundle.functionName}(${processedCodeString});`);
+            }
+        }
+        else {
+            commons_1.Contract.require(instrumentedSources.length === 1, 'Assuming only one code fragment to be passed as argument for JavaScript bundles.');
+            writeToFile(toFile, instrumentedSources[0]);
+        }
     }
     /**
      * Loads the vaccine from the vaccine file and adjusts some template parameters.
      *
      * @param collector - The collector to send coverage information to.
      */
-    loadVaccine(collector) {
-        // We first replace some of the parameters in the file with the
+    loadVaccine(filePath, collector) {
+        // We first replace parameters in the file with the
         // actual values, for example, the collector to send the coverage information to.
-        return fs
-            .readFileSync(this.vaccineFilePath, 'utf8')
-            .replace(/\$REPORT_TO_HOST/g, collector.host)
-            .replace(/\$REPORT_TO_PORT/g, `${collector.port}`);
-    }
-    /**
-     * Should the given file be excluded from the instrumentation,
-     * based on the source files that have been transpiled into it?
-     *
-     * @param pattern - The pattern to match the origin source files.
-     * @param sourceFile - The bundle file name.
-     * @param originSourceFiles - The list of files that were transpiled into the bundle.
-     */
-    shouldExcludeFromInstrumentation(pattern, sourceFile, originSourceFiles) {
-        return !pattern.isAnyIncluded(originSourceFiles);
+        return fs.readFileSync(filePath, 'utf8').replace(/\$REPORT_TO_URL/g, collector.url);
     }
     /**
      * @returns whether the given file is supported for instrumentation.
      */
     isFileTypeSupported(fileName) {
+        if (fileName.endsWith('.devmode.js') || fileName.endsWith('.nocache.js')) {
+            // GWT dev mode files.
+            return false;
+        }
         const ext = path.extname(fileName).toLowerCase();
         return ext === '.js' || ext === '.mjs';
     }
@@ -157,34 +220,82 @@ class IstanbulInstrumenter {
     configurationAlternativesFor(taskElement) {
         this.logger.debug(`Determining configuration alternatives for ${taskElement.fromFile}`);
         const baseConfig = {
-            coverageVariable: '__coverage__',
-            produceSourceMap: true
+            isInstrumentedToken: exports.IS_INSTRUMENTED_TOKEN,
+            produceSourceMap: 'external',
+            codeToPrepend: this.vaccineSource
         };
         return [
             { ...baseConfig, ...{ esModules: true } },
             { ...baseConfig, ...{ esModules: false } }
         ];
     }
-    /**
-     * Given a source code file and the task element, load the corresponding sourcemap.
-     *
-     * @param inputSource - The source code that might contain sourcemap comments.
-     * @param taskElement - The task element that can have a reference to an external sourcemap.
-     */
-    loadInputSourceMap(inputSource, taskElement) {
-        if (taskElement.externalSourceMapFile.isPresent()) {
-            const sourceMapOrigin = taskElement.externalSourceMapFile.get();
-            if (!(sourceMapOrigin instanceof Task_1.SourceMapFileReference)) {
-                throw new commons_1.IllegalArgumentException('Type of source map not yet supported!');
+    /** Appends all origins from the source map to a given file. Creates the file if it does not exist yet. */
+    dumpOrigins(dumpOriginsFile, originSourceFiles) {
+        const jsonContent = JSON.stringify(originSourceFiles, null, 2);
+        fs.writeFile(dumpOriginsFile, jsonContent + '\n', { flag: 'a' }, error => {
+            if (error) {
+                this.logger.warn('Could not dump origins file');
+            }
+        });
+    }
+    /** Clears the dump origins file if it exists, such that it is now ready to be appended for every instrumented file. */
+    clearDumpOriginsFileIfNeeded(dumpOriginsFile) {
+        if (dumpOriginsFile && fs.existsSync(dumpOriginsFile)) {
+            try {
+                fs.unlinkSync(dumpOriginsFile);
+            }
+            catch (err) {
+                this.logger.warn('Could not clear origins file: ' + err);
             }
-            return sourceMapFromMapFile(sourceMapOrigin.sourceMapFilePath);
-        }
-        else {
-            return sourceMapFromCodeComment(inputSource, taskElement.fromFile);
         }
     }
 }
 exports.IstanbulInstrumenter = IstanbulInstrumenter;
+/**
+ * Extract the sourcemap from the given source code.
+ *
+ * @param instrumentedSource - The source code.
+ * @param instrumentedSourceFileName - The file name to assume for the file name.
+ */
+async function loadSourceMap(instrumentedSource, instrumentedSourceFileName) {
+    const instrumentedSourceMap = loadInputSourceMap(instrumentedSource, instrumentedSourceFileName, typescript_optional_1.Optional.empty());
+    if (instrumentedSourceMap) {
+        return await new source_map_1.SourceMapConsumer(instrumentedSourceMap);
+    }
+    return undefined;
+}
+exports.loadSourceMap = loadSourceMap;
+function loadInputSourceMaps(taskFile, bundleFile, externalSourceMapFile) {
+    if ((0, WebToolkit_1.isGwtBundle)(bundleFile)) {
+        return (0, WebToolkit_1.loadInputSourceMapsGwt)(taskFile, bundleFile);
+    }
+    else {
+        return loadInputSourceMapsStandard(taskFile, bundleFile, externalSourceMapFile);
+    }
+}
+function loadInputSourceMapsStandard(taskFile, bundleFile, externalSourceMapFile) {
+    return bundleFile.codeArguments.map(code => loadInputSourceMap(code, taskFile, externalSourceMapFile));
+}
+/**
+ * Given a source code file, load the corresponding sourcemap.
+ *
+ * @param inputSource - The source code that might contain sourcemap comments.
+ * @param taskFile - The name of the file the `inputSource` is from.
+ * @param externalSourceMapFile - An external source map file to consider.
+ */
+function loadInputSourceMap(inputSource, taskFile, externalSourceMapFile) {
+    if (externalSourceMapFile.isPresent()) {
+        const sourceMapOrigin = externalSourceMapFile.get();
+        if (!(sourceMapOrigin instanceof Task_1.SourceMapFileReference)) {
+            throw new commons_1.IllegalArgumentException('Type of source map not yet supported!');
+        }
+        return (0, FileSystem_1.sourceMapFromMapFile)(sourceMapOrigin.sourceMapFilePath);
+    }
+    else {
+        return sourceMapFromCodeComment(inputSource, taskFile);
+    }
+}
+exports.loadInputSourceMap = loadInputSourceMap;
 /**
  * Extract a sourcemap for a given code comment.
  *
@@ -210,7 +321,9 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
                 }
                 else {
                     result = convertSourceMap
-                        .fromMapFileComment(sourceMapComment, path.dirname(sourceFilePath))
+                        .fromMapFileComment(sourceMapComment, function (filename) {
+                        return fs.readFileSync(path.resolve(path.dirname(sourceFilePath), filename), 'utf-8');
+                    })
                         .toObject();
                 }
             }
@@ -218,11 +331,11 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
                 // One JS file can refer to several source map files in its comments.
                 failedLoading++;
             }
-            if (result) {
-                return result;
-            }
         }
     } while (matched);
+    if (result) {
+        return result;
+    }
     if (failedLoading > 0) {
         throw new commons_1.IllegalArgumentException('None of the referenced source map files loaded!');
     }
@@ -230,12 +343,12 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
         return undefined;
     }
 }
-/**
- * Read a source map from a source map file.
- *
- * @param mapFilePath
- */
-function sourceMapFromMapFile(mapFilePath) {
-    const content = fs.readFileSync(mapFilePath, 'utf8');
-    return JSON.parse(content);
+exports.sourceMapFromCodeComment = sourceMapFromCodeComment;
+function writeToFile(filePath, fileContent) {
+    mkdirp.sync(path.dirname(filePath));
+    fs.writeFileSync(filePath, fileContent);
+}
+function copyToFile(targetFilePath, sourceFilePath) {
+    mkdirp.sync(path.dirname(targetFilePath));
+    fs.copyFileSync(sourceFilePath, targetFilePath);
 }