@teamscale/javascript-instrumenter 0.0.1-alpha.20 → 0.0.1-beta.1

package/dist/src/instrumenter/Instrumenter.js

@@ -1,17 +1,39 @@
-import { SourceMapFileReference, TaskResult } from './Task';
-import { Contract, IllegalArgumentException } from '@cqse/commons';
-import * as istanbul from 'istanbul-lib-instrument';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as convertSourceMap from 'convert-source-map';
-export const IS_INSTRUMENTED_TOKEN = '/** $IS_JS_PROFILER_INSTRUMENTED=true **/';
+"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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const convertSourceMap = __importStar(require("convert-source-map"));
+exports.IS_INSTRUMENTED_TOKEN = '/** $IS_JS_PROFILER_INSTRUMENTED=true **/';
 /**
  * An instrumenter based on the IstanbulJs instrumentation and coverage framework.
  */
-export class IstanbulInstrumenter {
+class IstanbulInstrumenter {
     constructor(vaccineFilePath, logger) {
-        this.vaccineFilePath = Contract.requireNonEmpty(vaccineFilePath);
-        Contract.require(fs.existsSync(vaccineFilePath), `The vaccine file to inject "${vaccineFilePath}" must exist!\nCWD:${process.cwd()}`);
+        this.vaccineFilePath = commons_1.Contract.requireNonEmpty(vaccineFilePath);
+        commons_1.Contract.require(fs.existsSync(vaccineFilePath), `The vaccine file to inject "${vaccineFilePath}" must exist!\nCWD:${process.cwd()}`);
         this.logger = logger;
     }
     /**
@@ -23,7 +45,7 @@ export class IstanbulInstrumenter {
         // 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), TaskResult.neutral());
+            .reduce((prev, current) => current.withIncrement(prev), Task_1.TaskResult.neutral());
         return Promise.resolve(result);
     }
     /**
@@ -34,20 +56,21 @@ export class IstanbulInstrumenter {
      * @param sourcePattern - A pattern to restrict the instrumentation to only a fraction of the task element.
      */
     instrumentOne(collector, taskElement, sourcePattern) {
+        var _a, _b, _c;
         const inputFileSource = fs.readFileSync(taskElement.fromFile, 'utf8');
         // We skip files that we have already instrumented
-        if (inputFileSource.startsWith(IS_INSTRUMENTED_TOKEN)) {
+        if (inputFileSource.startsWith(exports.IS_INSTRUMENTED_TOKEN)) {
             if (!taskElement.isInPlace()) {
                 fs.writeFileSync(taskElement.toFile, inputFileSource);
             }
-            return new TaskResult(0, 0, 1, 0, 0, 0);
+            return new Task_1.TaskResult(0, 0, 1, 0, 0, 0);
         }
         // Not all file types are supported by the instrumenter
         if (!this.isFileTypeSupported(taskElement.fromFile)) {
-            return new TaskResult(0, 0, 0, 1, 0, 0);
+            return new Task_1.TaskResult(0, 0, 0, 1, 0, 0);
         }
         // Report progress
-        this.logger.info(path.basename(taskElement.fromFile));
+        this.logger.info(`Instrumenting "${path.basename(taskElement.fromFile)}"`);
         let finalSourceMap;
         let instrumentedSource;
         // We try to perform the instrumentation with different
@@ -58,24 +81,23 @@ export class IstanbulInstrumenter {
             try {
                 const instrumenter = istanbul.createInstrumenter(configurationAlternatives[i]);
                 inputSourceMap = this.loadInputSourceMap(inputFileSource, taskElement);
-                // 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:', instrumenter.lastSourceMap().sources);
                 // 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.
                 //
-                // TODO: Why is this check not done after `loadInputSourceMap`?
-                if (this.shouldExcludeFromInstrumentation(sourcePattern, taskElement.fromFile, instrumenter.lastSourceMap().sources)) {
+                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 TaskResult(1, 0, 0, 0, 0, 0);
+                    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.
                 //
-                // TODO: Check the actual semantics of `lastSourceMap`
+                // `lastSourceMap` === Sourcemap for the last file that was instrumented.
                 finalSourceMap = convertSourceMap.fromObject(instrumenter.lastSourceMap()).toComment();
                 break;
             }
@@ -84,34 +106,42 @@ export class IstanbulInstrumenter {
                 // we emit a corresponding warning or signal an error.
                 if (i === configurationAlternatives.length - 1) {
                     if (!inputSourceMap) {
-                        return TaskResult.warning(`Failed loading input source map for ${taskElement.fromFile}: ${e.message}`);
+                        return Task_1.TaskResult.warning(`Failed loading input source map for ${taskElement.fromFile}: ${e.message}`);
                     }
                     fs.writeFileSync(taskElement.toFile, inputFileSource);
-                    return TaskResult.error(e);
+                    return Task_1.TaskResult.error(e);
                 }
             }
         }
         // We now can glue together the final version of the instrumented file.
         //
+        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);
+    }
+    /**
+     * 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
         // actual values, for example, the collector to send the coverage information to.
-        const vaccineSource = fs
+        return fs
             .readFileSync(this.vaccineFilePath, 'utf8')
             .replace(/\$REPORT_TO_HOST/g, collector.host)
             .replace(/\$REPORT_TO_PORT/g, `${collector.port}`);
-        fs.writeFileSync(taskElement.toFile, `${IS_INSTRUMENTED_TOKEN} ${vaccineSource} ${instrumentedSource} \n${finalSourceMap}`);
-        return new TaskResult(1, 0, 0, 0, 0, 0);
     }
     /**
      * 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.
+     * @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);
+    shouldExcludeFromInstrumentation(pattern, sourceFile, originSourceFiles) {
+        return !pattern.isAnyIncluded(originSourceFiles);
     }
     /**
      * @returns whether the given file is supported for instrumentation.
@@ -131,8 +161,8 @@ export class IstanbulInstrumenter {
             produceSourceMap: true
         };
         return [
-            Object.assign(Object.assign({}, baseConfig), { esModules: true }),
-            Object.assign(Object.assign({}, baseConfig), { esModules: false })
+            { ...baseConfig, ...{ esModules: true } },
+            { ...baseConfig, ...{ esModules: false } }
         ];
     }
     /**
@@ -144,8 +174,8 @@ export class IstanbulInstrumenter {
     loadInputSourceMap(inputSource, taskElement) {
         if (taskElement.externalSourceMapFile.isPresent()) {
             const sourceMapOrigin = taskElement.externalSourceMapFile.get();
-            if (!(sourceMapOrigin instanceof SourceMapFileReference)) {
-                throw new IllegalArgumentException('Type of source map not yet supported!');
+            if (!(sourceMapOrigin instanceof Task_1.SourceMapFileReference)) {
+                throw new commons_1.IllegalArgumentException('Type of source map not yet supported!');
             }
             return sourceMapFromMapFile(sourceMapOrigin.sourceMapFilePath);
         }
@@ -154,6 +184,7 @@ export class IstanbulInstrumenter {
         }
     }
 }
+exports.IstanbulInstrumenter = IstanbulInstrumenter;
 /**
  * Extract a sourcemap for a given code comment.
  *
@@ -165,17 +196,38 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
     // or `//# sourceMappingURL=data:application/json;base64,eyJ2ZXJ ...`
     //
     // "It is reasonable for tools to also accept “//@” but “//#” is preferred."
-    const re = /\/\/[#@]\s(source(?:Mapping)?URL)=\s*(\S+)/;
-    const matched = re.exec(sourcecode);
-    if (!matched) {
-        return undefined;
-    }
-    const sourceMapComment = matched[0];
-    if (sourceMapComment.slice(0, 50).indexOf('data:application/json') > 0) {
-        return convertSourceMap.fromComment(sourceMapComment).toObject();
+    const re = /\/\/[#@]\s(source(?:Mapping)?URL)=\s*(\S+)/g;
+    let failedLoading = 0;
+    let result;
+    let matched;
+    do {
+        matched = re.exec(sourcecode);
+        if (matched) {
+            const sourceMapComment = matched[0];
+            try {
+                if (sourceMapComment.slice(0, 50).indexOf('data:application/json') > 0) {
+                    result = convertSourceMap.fromComment(sourceMapComment).toObject();
+                }
+                else {
+                    result = convertSourceMap
+                        .fromMapFileComment(sourceMapComment, path.dirname(sourceFilePath))
+                        .toObject();
+                }
+            }
+            catch (e) {
+                // One JS file can refer to several source map files in its comments.
+                failedLoading++;
+            }
+            if (result) {
+                return result;
+            }
+        }
+    } while (matched);
+    if (failedLoading > 0) {
+        throw new commons_1.IllegalArgumentException('None of the referenced source map files loaded!');
     }
     else {
-        return convertSourceMap.fromMapFileComment(sourceMapComment, path.dirname(sourceFilePath)).toObject();
+        return undefined;
     }
 }
 /**

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

@@ -40,10 +40,10 @@ export declare class CollectorSpecifier {
  * are used to determine the original file names.
  */
 export declare class OriginSourcePattern {
-    /** Set of files in the origin for that coverage should be produced. */
+    /** Glob pattern describing the set of files in the origin for that coverage should be produced. */
     private readonly include;
     /**
-     * Set of files in the origin for that coverage should EXPLICITLY NOT be produced.
+     * Glob pattern describing the set of files in the origin for that coverage should EXPLICITLY NOT be produced.
      * An exclude is stronger than an include.
      */
     private readonly exclude;
@@ -129,3 +129,4 @@ export declare class SourceMapFileReference extends SourceMapReference {
     readonly sourceMapFilePath: string;
     constructor(sourceMapFilePath: string);
 }
+//# sourceMappingURL=Task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/Task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAI/C;;GAEG;AACH,8BAAsB,kBAAkB;CAAG;AAE3C;;;GAGG;AACH,qBAAa,WAAW;IACvB,sBAAsB;IACtB,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC,2BAA2B;IAC3B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,gEAAgE;IAChE,SAAgB,qBAAqB,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAC;gBAExD,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,kBAAkB;IAMpF;;OAEG;IACI,SAAS,IAAI,OAAO;CAK3B;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC9B,2CAA2C;IAC3C,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,gDAAgD;IAChD,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEjB,SAAS,EAAE,MAAM;CAK7B;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAC/B,mGAAmG;IACnG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS;IAKpE;;;;;;;OAOG;IACI,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO;CAepD;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC/B;;OAEG;IACH,SAAgB,SAAS,EAAE,kBAAkB,CAAC;IAE9C;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAE1C;;;OAGG;IACH,SAAgB,mBAAmB,EAAE,mBAAmB,CAAC;gBAE7C,SAAS,EAAE,kBAAkB,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,mBAAmB,EAAE,mBAAmB;IAM5G;;OAEG;IACH,IAAI,QAAQ,IAAI,WAAW,EAAE,CAI5B;CACD;AAED;;GAEG;AACH,qBAAa,UAAU;IACtB,iEAAiE;IACjE,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC,8DAA8D;IAC9D,SAAgB,mBAAmB,EAAE,MAAM,CAAC;IAE5C,uDAAuD;IACvD,SAAgB,mBAAmB,EAAE,MAAM,CAAC;IAE5C,sDAAsD;IACtD,SAAgB,WAAW,EAAE,MAAM,CAAC;IAEpC,6DAA6D;IAC7D,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,+EAA+E;IAC/E,SAAgB,QAAQ,EAAE,MAAM,CAAC;gBAGhC,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,MAAM,EAC3B,mBAAmB,EAAE,MAAM,EAC3B,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM;IAgBjB;;;;OAIG;IACI,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU;IAWnD;;OAEG;WACW,OAAO,IAAI,UAAU;IAInC;;;;OAIG;WACW,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,UAAU;IAKzC;;;;OAIG;WACW,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;CAI9C;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC7D,2CAA2C;IAC3C,SAAgB,iBAAiB,EAAE,MAAM,CAAC;gBAE9B,iBAAiB,EAAE,MAAM;CAIrC"}

package/dist/src/instrumenter/Task.js

@@ -1,20 +1,43 @@
-import { Optional } from 'typescript-optional';
-import { Contract } from '@cqse/commons';
-import * as matching from 'micromatch';
+"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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapFileReference = exports.TaskResult = exports.InstrumentationTask = exports.OriginSourcePattern = exports.CollectorSpecifier = exports.TaskElement = exports.SourceMapReference = void 0;
+const typescript_optional_1 = require("typescript-optional");
+const commons_1 = require("@cqse/commons");
+const matching = __importStar(require("micromatch"));
 /**
  * An abstract source map type.
  */
-export class SourceMapReference {
+class SourceMapReference {
 }
+exports.SourceMapReference = SourceMapReference;
 /**
  * One element of an instrumentation task.
  * It corresponds to instrumenting a single file.
  */
-export class TaskElement {
+class TaskElement {
     constructor(fromFile, toFile, externalSourceMap) {
-        this.fromFile = Contract.requireDefined(fromFile);
-        this.toFile = Contract.requireDefined(toFile);
-        this.externalSourceMapFile = Optional.ofNullable(externalSourceMap);
+        this.fromFile = commons_1.Contract.requireDefined(fromFile);
+        this.toFile = commons_1.Contract.requireDefined(toFile);
+        this.externalSourceMapFile = typescript_optional_1.Optional.ofNullable(externalSourceMap);
     }
     /**
      * Is it an in-place instrumentation task?
@@ -25,17 +48,19 @@ export class TaskElement {
         return this.fromFile === this.toFile;
     }
 }
+exports.TaskElement = TaskElement;
 /**
  * Specifies the collector that is supposed to
  * receive the coverage information.
  */
-export class CollectorSpecifier {
+class CollectorSpecifier {
     constructor(collector) {
-        Contract.requireStringPattern(collector, '.+:[0-9]+', 'Invalid collector pattern used!');
+        commons_1.Contract.requireStringPattern(collector, '.+:[0-9]+', 'Invalid collector pattern used!');
         this.host = collector.split(':')[0];
         this.port = Number.parseInt(collector.split(':')[1]);
     }
 }
+exports.CollectorSpecifier = CollectorSpecifier;
 /**
  * Patterns that define which parts of a given bundle to instrument or not.
  *
@@ -43,7 +68,7 @@ export class CollectorSpecifier {
  * that is, before conducting all the transpilation steps. The source maps
  * are used to determine the original file names.
  */
-export class OriginSourcePattern {
+class OriginSourcePattern {
     constructor(include, exclude) {
         this.include = include;
         this.exclude = exclude;
@@ -71,14 +96,15 @@ export class OriginSourcePattern {
         return true;
     }
 }
+exports.OriginSourcePattern = OriginSourcePattern;
 /**
  * The actual instrumentation task.
  */
-export class InstrumentationTask {
+class InstrumentationTask {
     constructor(collector, elements, originSourcePattern) {
-        this.collector = Contract.requireDefined(collector);
-        this.originSourcePattern = Contract.requireDefined(originSourcePattern);
-        this._elements = Contract.requireDefined(elements).slice();
+        this.collector = commons_1.Contract.requireDefined(collector);
+        this.originSourcePattern = commons_1.Contract.requireDefined(originSourcePattern);
+        this._elements = commons_1.Contract.requireDefined(elements).slice();
     }
     /**
      * @returns the elements of the task.
@@ -89,17 +115,18 @@ export class InstrumentationTask {
         return this._elements.slice();
     }
 }
+exports.InstrumentationTask = InstrumentationTask;
 /**
  * A summary of executing the instrumentation task.
  */
-export class TaskResult {
+class TaskResult {
     constructor(translated, translatedFromCache, alreadyInstrumented, unsupported, failed, warnings) {
-        Contract.require(translated > -1);
-        Contract.require(translatedFromCache > -1);
-        Contract.require(alreadyInstrumented > -1);
-        Contract.require(unsupported > -1);
-        Contract.require(failed > -1);
-        Contract.require(warnings > -1);
+        commons_1.Contract.require(translated > -1);
+        commons_1.Contract.require(translatedFromCache > -1);
+        commons_1.Contract.require(alreadyInstrumented > -1);
+        commons_1.Contract.require(unsupported > -1);
+        commons_1.Contract.require(failed > -1);
+        commons_1.Contract.require(warnings > -1);
         this.translated = translated;
         this.translatedFromCache = translatedFromCache;
         this.alreadyInstrumented = alreadyInstrumented;
@@ -140,12 +167,14 @@ export class TaskResult {
         return new TaskResult(0, 0, 0, 0, 0, 1);
     }
 }
+exports.TaskResult = TaskResult;
 /**
  * A source map in an external file.
  */
-export class SourceMapFileReference extends SourceMapReference {
+class SourceMapFileReference extends SourceMapReference {
     constructor(sourceMapFilePath) {
         super();
         this.sourceMapFilePath = sourceMapFilePath;
     }
 }
+exports.SourceMapFileReference = SourceMapFileReference;

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

@@ -37,8 +37,26 @@ export declare class TaskBuilder {
      * @param config - The configuration based on that the task is built.
      */
     addFromConfig(config: ConfigurationParameters): this;
+    /**
+     * Adds instrumentation tasks based on a given pattern `inputs` describing the set of
+     * input files and produces the output files in the specified output folder `target.
+     *
+     * @param inputs - Glob pattern describing set of input files
+     * @param target - Target folder
+     * @param sourceMapInfo - Source map file for all the input files.
+     */
+    private addInstrumentationTasksFromPatternWithTarget;
+    /**
+     * Adds in-place instrumentation tasks for the set of files described
+     * by the `inputs` pattern.
+     *
+     * @param inputs - Glob pattern.
+     * @param sourceMapInfo - Source map for the files described by the pattern.
+     */
+    private addInPlaceTasksFromPattern;
     /**
      * Build the instrumentation task.
      */
     build(): InstrumentationTask;
 }
+//# sourceMappingURL=TaskBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TaskBuilder.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/TaskBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,mBAAmB,EAGnB,kBAAkB,EAElB,MAAM,QAAQ,CAAC;AAMhB,2DAA2D;AAC3D,oBAAY,uBAAuB,GAAG;IACrC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAElB,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAkBF;;GAEG;AACH,qBAAa,WAAW;IACvB,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IAEzC,6CAA6C;IAC7C,OAAO,CAAC,SAAS,CAA4B;IAE7C,0BAA0B;IAC1B,OAAO,CAAC,0BAA0B,CAAqB;IAEvD,0BAA0B;IAC1B,OAAO,CAAC,0BAA0B,CAAqB;;IAOvD,0EAA0E;IAC1E,sBAAsB,CAAC,sBAAsB,EAAE,MAAM,GAAG,IAAI;IAM5D,8BAA8B;IAC9B,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAKhE,6BAA6B;IAC7B,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAKhE,yBAAyB;IACzB,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAKlG;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;IAkCpD;;;;;;;OAOG;IACH,OAAO,CAAC,4CAA4C;IA8BpD;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IASlC;;OAEG;IACI,KAAK,IAAI,mBAAmB;CAInC"}