@teamscale/lib-instrument 0.1.0-beta.2

package/LICENSE

@@ -0,0 +1,24 @@
+Copyright 2012-2015 Yahoo! Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Yahoo! Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL YAHOO! INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,3 @@
+## Lib Instrument
+
+Forked and evolved version of [Istanbul Lib Instrument](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-lib-instrument).

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import { Instrumenter, InstrumenterOptions } from './instrumenter';
+export type { InstrumenterOptions } from './instrumenter';
+export { programVisitor } from './visitor';
+/**
+ * Creates a new coverage instrumenter.
+ *
+ * @param opts - instrumenter options
+ */
+export declare function createInstrumenter(opts: InstrumenterOptions): Instrumenter;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAEjE,YAAY,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAC,cAAc,EAAC,MAAM,WAAW,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CAE1E"}

package/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstrumenter = exports.programVisitor = void 0;
+const instrumenter_1 = require("./instrumenter");
+var visitor_1 = require("./visitor");
+Object.defineProperty(exports, "programVisitor", { enumerable: true, get: function () { return visitor_1.programVisitor; } });
+/**
+ * Creates a new coverage instrumenter.
+ *
+ * @param opts - instrumenter options
+ */
+function createInstrumenter(opts) {
+    return new instrumenter_1.Instrumenter(opts);
+}
+exports.createInstrumenter = createInstrumenter;

package/lib/instrumenter.d.ts

@@ -0,0 +1,45 @@
+import { NodePath } from '@babel/core';
+import { SourceLocation } from "@babel/types";
+import { ParserPlugin as PluginConfig } from '@babel/parser';
+import { RawSourceMap } from "source-map";
+import { InstrumentationOptions } from "./utils";
+/**
+ * Options for configuring the coverage instrumenter.
+ */
+export type InstrumenterOptions = InstrumentationOptions & Partial<{
+    /** Preserve comments in output */
+    preserveComments: boolean;
+    /** Generate compact code */
+    compact: boolean;
+    /** Set to true to instrument ES6 modules */
+    esModules: boolean;
+    /** Set to true to allow `return` statements outside of functions */
+    autoWrap: boolean;
+    /** Approach to produce a source map for the instrumented code */
+    produceSourceMap: 'none' | 'inline' | 'external';
+    /** Turn debugging on */
+    debug: boolean;
+    /** Set babel parser plugins */
+    parserPlugins: PluginConfig[];
+}>;
+/**
+ * The main class of the instrumenter.
+ */
+export declare class Instrumenter {
+    private readonly opts;
+    constructor(opts?: Partial<InstrumenterOptions>);
+    /**
+     * Instrument the supplied code with coverage statements.
+     * To instrument EcmaScript modules, make sure to set the
+     * `esModules` option to `true` when creating the instrumenter.
+     *
+     * @param code - the code to instrument
+     * @param filename - the name of the file the code stems from.
+     * @param inputSourceMap - the source map that maps the not instrumented code back to its original
+     * @param shouldInstrumentCallback - a callback to decide if a given code fragment should be instrumented
+     *
+     * @returns the instrumented code.
+     */
+    instrument(code: string, filename: string | undefined, inputSourceMap: RawSourceMap | undefined, shouldInstrumentCallback?: (path: NodePath, location: SourceLocation) => boolean): Promise<string>;
+}
+//# sourceMappingURL=instrumenter.d.ts.map

package/lib/instrumenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumenter.d.ts","sourceRoot":"","sources":["../src/instrumenter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAgB,MAAM,aAAa,CAAC;AACpD,OAAO,EAAC,cAAc,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAC,YAAY,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAC,YAAY,EAAoB,MAAM,YAAY,CAAC;AAG3D,OAAO,EAAC,sBAAsB,EAAC,MAAM,SAAS,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,GAAG,OAAO,CAAC;IAC/D,kCAAkC;IAClC,gBAAgB,EAAE,OAAO,CAAC;IAE1B,4BAA4B;IAC5B,OAAO,EAAE,OAAO,CAAC;IAEjB,4CAA4C;IAC5C,SAAS,EAAE,OAAO,CAAC;IAEnB,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAElB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;IAEjD,wBAAwB;IACxB,KAAK,EAAE,OAAO,CAAC;IAEf,+BAA+B;IAC/B,aAAa,EAAE,YAAY,EAAE,CAAC;CACjC,CAAC,CAAC;AAYH;;GAEG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;gBAE/B,IAAI,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC;IAI/C;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,cAAc,EAAE,YAAY,GAAG,SAAS,EACpF,wBAAwB,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CA0DtH"}

package/lib/instrumenter.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instrumenter = void 0;
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const core_1 = require("@babel/core");
+const source_map_1 = require("source-map");
+const visitor_1 = require("./visitor");
+function mapSourceMapsOption(produceSourceMap) {
+    if (produceSourceMap === "none") {
+        return false;
+    }
+    if (produceSourceMap === "external") {
+        return "both";
+    }
+    return produceSourceMap;
+}
+/**
+ * The main class of the instrumenter.
+ */
+class Instrumenter {
+    constructor(opts) {
+        this.opts = { ...opts };
+    }
+    /**
+     * Instrument the supplied code with coverage statements.
+     * To instrument EcmaScript modules, make sure to set the
+     * `esModules` option to `true` when creating the instrumenter.
+     *
+     * @param code - the code to instrument
+     * @param filename - the name of the file the code stems from.
+     * @param inputSourceMap - the source map that maps the not instrumented code back to its original
+     * @param shouldInstrumentCallback - a callback to decide if a given code fragment should be instrumented
+     *
+     * @returns the instrumented code.
+     */
+    async instrument(code, filename, inputSourceMap, shouldInstrumentCallback) {
+        filename = filename ?? String(new Date().getTime()) + '.js';
+        const { opts } = this;
+        const sourceMapToUse = inputSourceMap ?? opts.inputSourceMap;
+        let inputSourceMapConsumer = undefined;
+        if (sourceMapToUse) {
+            inputSourceMapConsumer = await new source_map_1.SourceMapConsumer(sourceMapToUse);
+        }
+        const babelOpts = {
+            configFile: false,
+            babelrc: false,
+            ast: true,
+            filename,
+            inputSourceMap,
+            sourceMaps: mapSourceMapsOption(opts.produceSourceMap),
+            compact: opts.compact,
+            comments: opts.preserveComments,
+            parserOpts: {
+                allowAwaitOutsideFunction: true,
+                allowReturnOutsideFunction: opts.autoWrap,
+                sourceType: (opts.esModules ? 'module' : 'script'),
+                plugins: opts.parserPlugins
+            },
+            plugins: [
+                [
+                    ({ types }) => {
+                        const ee = (0, visitor_1.programVisitor)(types, inputSourceMapConsumer, {
+                            reportLogic: opts.reportLogic,
+                            coverageGlobalScopeFunc: opts.coverageGlobalScopeFunc,
+                            ignoreClassMethods: opts.ignoreClassMethods,
+                            inputSourceMap,
+                            isInstrumentedToken: opts.isInstrumentedToken,
+                            codeToPrepend: opts.codeToPrepend,
+                            shouldInstrumentCallback: shouldInstrumentCallback ?? opts.shouldInstrumentCallback
+                        });
+                        return {
+                            visitor: {
+                                Program: {
+                                    enter: ee.enter,
+                                    exit(path) {
+                                        ee.exit(path);
+                                    }
+                                }
+                            }
+                        };
+                    }
+                ]
+            ]
+        };
+        return (0, core_1.transformSync)(code, babelOpts).code;
+    }
+}
+exports.Instrumenter = Instrumenter;

package/lib/origins.d.ts

@@ -0,0 +1,32 @@
+import { SourceLocation } from "@babel/types";
+import { SourceMapConsumer } from "source-map";
+/**
+ * Generator for identifiers that are unique across files to instrument.
+ * Relevant in case no Ecmascript modules are used.
+ *
+ * We assume that the files to be executed in a browser can
+ * stem from different runs of the instrumenter. We have to decrease
+ * the probability of colliding identifiers.
+ */
+export declare const fileIdSeqGenerator: {
+    next: () => string;
+};
+/**
+ * Mapping source locations to their origins, before the last transpilation,
+ * based on the source map.
+ */
+export declare class SourceOrigins {
+    private readonly sourceMap?;
+    /**
+     * The mapping of file ids to the file names in the transpiler origin,
+     * that is, the file names found in the source map.
+     */
+    readonly originToIdMap: Map<string, string>;
+    constructor(sourceMap: SourceMapConsumer | undefined);
+    /**
+     * Register source origin file and retrieve a unique identifier for it; furthermore, map
+     * the given location to the location in the origin.
+     */
+    ensureKnownOrigin(loc: SourceLocation): [string, SourceLocation];
+}
+//# sourceMappingURL=origins.d.ts.map

package/lib/origins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origins.d.ts","sourceRoot":"","sources":["../src/origins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAyB,iBAAiB,EAAC,MAAM,YAAY,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE;IAAE,IAAI,EAAE,MAAM,MAAM,CAAA;CAkBjD,CAAC;AAEL;;;GAGG;AACH,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAoB;IAE/C;;;OAGG;IACH,SAAgB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAEvC,SAAS,EAAE,iBAAiB,GAAG,SAAS;IAKpD;;;OAGG;IACH,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;CA6BnE"}

package/lib/origins.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceOrigins = exports.fileIdSeqGenerator = void 0;
+/**
+ * Generator for identifiers that are unique across files to instrument.
+ * Relevant in case no Ecmascript modules are used.
+ *
+ * We assume that the files to be executed in a browser can
+ * stem from different runs of the instrumenter. We have to decrease
+ * the probability of colliding identifiers.
+ */
+exports.fileIdSeqGenerator = (() => {
+    const instrumenterRunId = process.pid;
+    let fileIdSeq = 0;
+    return {
+        next: () => {
+            fileIdSeq++;
+            let num;
+            if (fileIdSeq < 10000) {
+                num = instrumenterRunId * 10000 + fileIdSeq;
+            }
+            else if (fileIdSeq < 100000) {
+                num = instrumenterRunId * 100000 + fileIdSeq;
+            }
+            else {
+                throw new Error(`Not more that 100k files supported to be instrumented in one run.`);
+            }
+            return num.toString(36);
+        }
+    };
+})();
+/**
+ * Mapping source locations to their origins, before the last transpilation,
+ * based on the source map.
+ */
+class SourceOrigins {
+    constructor(sourceMap) {
+        this.originToIdMap = new Map();
+        this.sourceMap = sourceMap;
+    }
+    /**
+     * Register source origin file and retrieve a unique identifier for it; furthermore, map
+     * the given location to the location in the origin.
+     */
+    ensureKnownOrigin(loc) {
+        let startPos = undefined;
+        let endPos = undefined;
+        let filename = loc.filename ?? '';
+        if (this.sourceMap) {
+            startPos = this.sourceMap.originalPositionFor({ line: loc.start.line, column: loc.start.column });
+            endPos = this.sourceMap.originalPositionFor({ line: loc.end.line, column: loc.end.column });
+            filename = startPos.source ?? loc.filename;
+        }
+        if (!startPos || !endPos) {
+            startPos = { line: loc.start.line, column: loc.start.column, source: null, name: null };
+            endPos = { line: loc.end.line, column: loc.end.column, source: null, name: null };
+        }
+        let id = this.originToIdMap.get(filename);
+        if (!id) {
+            id = `_$o${exports.fileIdSeqGenerator.next()}`;
+            this.originToIdMap.set(filename, id);
+        }
+        return [id, {
+                start: { line: startPos.line, column: startPos.column, index: -1 },
+                end: { line: endPos.line, column: endPos.column, index: -1 },
+                filename,
+                identifierName: startPos.name
+            }];
+    }
+}
+exports.SourceOrigins = SourceOrigins;

package/lib/utils.d.ts

@@ -0,0 +1,36 @@
+import { SourceLocation } from "@babel/types";
+import { RawSourceMap } from "source-map";
+import { NodePath } from "@babel/core";
+/**
+ * Options to configure the instrumenter.
+ */
+export type InstrumentationOptions = Partial<{
+    /** Report boolean value of logical expressions */
+    reportLogic: boolean;
+    /** Use an evaluated function to find coverageGlobalScope */
+    coverageGlobalScopeFunc: boolean;
+    /** Names of methods to ignore by default on classes */
+    ignoreClassMethods: string[];
+    /** The input source map, that maps the uninstrumented code back to the original code */
+    inputSourceMap?: RawSourceMap;
+    /** Token to add in the very beginning to indicate that the instrumentation has been performed */
+    isInstrumentedToken?: string;
+    /** Code to add before the instrumented input code */
+    codeToPrepend?: string;
+    /** Callback for determining if a given code fragment should be instrument */
+    shouldInstrumentCallback?: (path: NodePath, loc: SourceLocation) => boolean;
+}>;
+/**
+ * Source code fragment within on file.
+ */
+export type CodeRange = {
+    start: {
+        line?: number;
+        column?: number;
+    };
+    end: {
+        line?: number;
+        column?: number;
+    };
+};
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AACxC,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAErC;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC;IACzC,kDAAkD;IAClD,WAAW,EAAE,OAAO,CAAC;IAErB,4DAA4D;IAC5D,uBAAuB,EAAE,OAAO,CAAC;IAEjC,uDAAuD;IACvD,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAE7B,wFAAwF;IACxF,cAAc,CAAC,EAAE,YAAY,CAAC;IAE9B,iGAAiG;IACjG,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,6EAA6E;IAC7E,wBAAwB,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC;CAC/E,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACpB,KAAK,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,GAAG,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C,CAAC"}

package/lib/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/visitor.d.ts

@@ -0,0 +1,30 @@
+import { NodePath } from '@babel/core';
+import { Program } from "@babel/types";
+type BabelTypes = typeof import("@babel/types");
+import { SourceMapConsumer } from "source-map";
+import { InstrumentationOptions } from "./utils";
+/**
+ * `programVisitor` is a `babel` adaptor for instrumentation.
+ *
+ * It returns an object with two methods `enter` and `exit`.
+ * These should be assigned to or called from `Program` entry and exit functions
+ * in a babel visitor.
+ *
+ * These functions do not make assumptions about the state set by Babel and thus
+ * can be used in a context other than a Babel plugin.
+ *
+ * The exit function returns an object that currently has the following keys:
+ *
+ * `fileCoverage` - the file coverage object created for the source file.
+ * `sourceMappingURL` - any source mapping URL found when processing the file.
+ *
+ * @param types - an instance of babel-types.
+ * @param sourceFilePath - the path to source file.
+ * @param opts - additional options.
+ */
+export declare function programVisitor(types: BabelTypes, inputSourceMapConsumer: SourceMapConsumer | undefined, opts: InstrumentationOptions): {
+    enter(path: NodePath<Program>): void;
+    exit(path: NodePath<Program>): void;
+};
+export {};
+//# sourceMappingURL=visitor.d.ts.map

package/lib/visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.d.ts","sourceRoot":"","sources":["../src/visitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,QAAQ,EAAQ,MAAM,aAAa,CAAC;AAElD,OAAO,EAK8C,OAAO,EAE3D,MAAM,cAAc,CAAC;AAEtB,KAAK,UAAU,GAAG,cAAc,cAAc,CAAC,CAAA;AAE/C,OAAO,EAAC,iBAAiB,EAAC,MAAM,YAAY,CAAC;AAG7C,OAAO,EAAC,sBAAsB,EAAC,MAAM,SAAS,CAAC;AAykB/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EACjB,sBAAsB,EAAE,iBAAiB,GAAG,SAAS,EACrD,IAAI,EAAE,sBAAsB;gBAYvC,SAAS,OAAO,CAAC,GAAG,IAAI;eASzB,SAAS,OAAO,CAAC;EA+BnC"}

package/lib/visitor.js

@@ -0,0 +1,533 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.programVisitor = void 0;
+const core_1 = require("@babel/core");
+const origins_1 = require("./origins");
+// Pattern for istanbul to ignore a section
+const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/;
+// Pattern for istanbul to ignore the whole file
+const COMMENT_FILE_RE = /^\s*istanbul\s+ignore\s+(file)(?=\W|$)/;
+/**
+ * `VisitState` holds the state of the visitor, provides helper functions
+ * and is the `this` for the individual coverage visitors.
+ */
+class VisitState {
+    constructor(types, inputSourceMapConsumer, ignoreClassMethods = [], reportLogic = false, shouldInstrumentCallback) {
+        this.attrs = {};
+        this.nextIgnore = null;
+        this.ignoreClassMethods = ignoreClassMethods;
+        this.types = types;
+        this.reportLogic = reportLogic;
+        this.shouldInstrumentCallback = shouldInstrumentCallback;
+        this.origins = new origins_1.SourceOrigins(inputSourceMapConsumer);
+    }
+    /**
+     * Use the configured callback, if available, to check if the given source
+     * location should be instrumented.
+     */
+    shouldInstrument(path, loc) {
+        if (this.shouldInstrumentCallback) {
+            return this.shouldInstrumentCallback(path, loc);
+        }
+        return true;
+    }
+    /** Should we ignore the node? Yes, if specifically ignoring or if the node is generated. */
+    shouldIgnore(path) {
+        return this.nextIgnore !== null || !path.node.loc;
+    }
+    /** Extract the ignore comment hint (next|if|else) or null. */
+    hintFor(node) {
+        let hint = null;
+        if (node.leadingComments) {
+            node.leadingComments.forEach(c => {
+                const v = (c.value || '').trim();
+                const groups = v.match(COMMENT_RE);
+                if (groups) {
+                    hint = groups[1];
+                }
+            });
+        }
+        return hint;
+    }
+    /**
+     * For these expressions the statement counter needs to be hoisted, so
+     * function name inference can be preserved.
+     */
+    counterNeedsHoisting(path) {
+        return (path.isFunctionExpression() ||
+            path.isArrowFunctionExpression() ||
+            path.isClassExpression());
+    }
+    /** All the generic stuff that needs to be done on enter for every node. */
+    onEnter(path) {
+        const n = path.node;
+        // if already ignoring, nothing more to do
+        if (this.nextIgnore !== null) {
+            return;
+        }
+        // check hint to see if ignore should be turned on
+        const hint = this.hintFor(n);
+        if (hint === 'next') {
+            this.nextIgnore = n;
+            return;
+        }
+        // else check custom node attribute set by a prior visitor
+        if (this.getAttr(path.node, 'skip-all') !== null) {
+            this.nextIgnore = n;
+        }
+        // else check for ignored class methods
+        if (path.isFunctionExpression() &&
+            this.ignoreClassMethods.some(name => path.node.id && name === path.node.id.name)) {
+            this.nextIgnore = n;
+            return;
+        }
+        if (path.isClassMethod() &&
+            this.ignoreClassMethods.some(name => name === path.node.key.name)) {
+            this.nextIgnore = n;
+            return;
+        }
+    }
+    /**
+     * All the generic stuff on exit of a node, including resetting ignores and custom node attrs.
+     */
+    onExit(path) {
+        // restore ignore status, if needed
+        if (path.node === this.nextIgnore) {
+            this.nextIgnore = null;
+        }
+        // nuke all attributes for the node
+        delete path.node.__cov__;
+    }
+    /** Set a node attribute for the supplied node. */
+    setAttr(node, name, value) {
+        node.__cov__ = node.__cov__ || {};
+        node.__cov__[name] = value;
+    }
+    /** Retrieve a node attribute for the supplied node or null. */
+    getAttr(node, name) {
+        const c = node.__cov__;
+        if (!c) {
+            return null;
+        }
+        return c[name];
+    }
+    insertCounter(path, increment) {
+        const T = this.types;
+        if (path.isBlockStatement()) {
+            path.node.body.unshift(T.expressionStatement(increment));
+        }
+        else if (path.isStatement()) {
+            path.insertBefore(T.expressionStatement(increment));
+        }
+        else if (this.counterNeedsHoisting(path) &&
+            T.isVariableDeclarator(path.parent)) {
+            // make an attempt to hoist the statement counter, so that
+            // function names are maintained.
+            const grandParentPath = path.parentPath?.parentPath;
+            if (grandParentPath && T.isExportNamedDeclaration(grandParentPath.parent)) {
+                grandParentPath.parentPath?.insertBefore(T.expressionStatement(increment));
+            }
+            else if (grandParentPath &&
+                (T.isProgram(grandParentPath.parent) ||
+                    T.isBlockStatement(grandParentPath.parent))) {
+                grandParentPath.insertBefore(T.expressionStatement(increment));
+            }
+            else {
+                path.replaceWith(T.sequenceExpression([increment, path.node]));
+            }
+        }
+        else if (path.isExpression()) {
+            path.replaceWith(T.sequenceExpression([increment, path.node]));
+        }
+        else {
+            console.error('Unable to insert counter for node type:', path.node.type);
+        }
+    }
+    insertFunctionCounter(path) {
+        const T = this.types;
+        if (!(path.node?.loc)) {
+            return;
+        }
+        const n = path.node;
+        let declarationLocation;
+        switch (n.type) {
+            case 'FunctionDeclaration':
+            case 'FunctionExpression':
+                if (n.id) {
+                    declarationLocation = n.id.loc ?? undefined;
+                }
+                break;
+        }
+        const body = path.get('body');
+        const loc = path.node.loc ?? declarationLocation;
+        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
+        if (body.isBlockStatement() && this.shouldInstrument(path, originPos)) {
+            // For functions, we only cover the first line of its body.
+            originPos.end = originPos.start;
+            const increment = newLineCoverageExpression(originFileId, originPos);
+            body.node.body.unshift(T.expressionStatement(increment));
+        }
+    }
+    insertStatementCounter(path) {
+        const loc = path.node?.loc;
+        if (!loc) {
+            return;
+        }
+        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
+        if (!this.shouldInstrument(path, originPos)) {
+            return;
+        }
+        const increment = newLineCoverageExpression(originFileId, originPos);
+        this.insertCounter(path, increment);
+    }
+    insertBranchCounter(path, loc) {
+        loc = loc ?? path.node.loc;
+        if (!loc) {
+            return;
+        }
+        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
+        if (this.shouldInstrument(path, originPos)) {
+            const increment = newLineCoverageExpression(originFileId, originPos);
+            this.insertCounter(path, increment);
+        }
+    }
+    findLeaves(node, accumulator, parent, property) {
+        if (!node) {
+            return;
+        }
+        if (node.type === 'LogicalExpression') {
+            const hint = this.hintFor(node);
+            if (hint !== 'next') {
+                this.findLeaves(node.left, accumulator, node, 'left');
+                this.findLeaves(node.right, accumulator, node, 'right');
+            }
+        }
+        else {
+            accumulator.push({
+                node,
+                parent: parent,
+                property: property
+            });
+        }
+    }
+}
+/**
+ * Create a line coverage reporting statement node.
+ */
+function newLineCoverageExpression(originFileId, range) {
+    return {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '_$l' },
+        arguments: [
+            { type: 'Identifier', name: originFileId },
+            { type: 'NumericLiteral', value: range.start.line },
+            { type: 'NumericLiteral', value: range.end.line },
+        ]
+    };
+}
+/**
+ * Creates a new string constant AST node.
+ */
+function newStringConstDeclarationNode(name, value) {
+    return {
+        type: 'VariableDeclaration',
+        kind: 'const',
+        declarations: [
+            {
+                type: 'VariableDeclarator',
+                id: {
+                    type: 'Identifier',
+                    name
+                },
+                init: {
+                    type: 'StringLiteral',
+                    value
+                }
+            }
+        ]
+    };
+}
+/**
+ * Generic function that takes a set of visitor methods and
+ * returns a visitor object with `enter` and `exit` properties,
+ * such that:
+ *
+ * - standard entry processing is done
+ * - the supplied visitors are called only when ignore is not in effect;
+ *   it reliefs them from worrying about ignore states and generated nodes.
+ * - standard exit processing is done
+ */
+function entries(...enter) {
+    // the enter function
+    const wrappedEntry = function (path, node) {
+        this.onEnter(path);
+        if (this.shouldIgnore(path)) {
+            return;
+        }
+        enter.forEach(e => {
+            e.call(this, path, node);
+        });
+    };
+    const exit = function (path) {
+        this.onExit(path);
+    };
+    return {
+        enter: wrappedEntry,
+        exit
+    };
+}
+function coverStatement(path) {
+    this.insertStatementCounter(path);
+}
+function coverAssignmentPattern(path) {
+    this.insertBranchCounter(path.get('right'), undefined);
+}
+function coverFunction(path) {
+    this.insertFunctionCounter(path);
+}
+function coverVariableDeclarator(path) {
+    this.insertStatementCounter(path.get('init'));
+}
+function coverClassPropDeclarator(path) {
+    this.insertStatementCounter(path.get('value'));
+}
+function makeBlock(path) {
+    const T = this.types;
+    if (!path.node) {
+        path.replaceWith(T.blockStatement([]));
+    }
+    if (!path.isBlockStatement()) {
+        path.replaceWith(T.blockStatement([path.node]));
+        const block = path.node;
+        path.node.loc = block.body[0].loc;
+        block.body[0].leadingComments = path.node.leadingComments;
+        path.node.leadingComments = undefined;
+    }
+}
+function blockProp(prop) {
+    return function (path) {
+        makeBlock.call(this, path.get(prop));
+    };
+}
+function makeParenthesizedExpressionForNonIdentifier(path) {
+    const T = this.types;
+    if (path.node && !path.isIdentifier()) {
+        path.replaceWith(T.parenthesizedExpression(path.node));
+    }
+}
+function parenthesizedExpressionProp(prop) {
+    return function (path) {
+        makeParenthesizedExpressionForNonIdentifier.call(this, path.get(prop));
+    };
+}
+function convertArrowExpression(path) {
+    const node = path.node;
+    const T = this.types;
+    if (!T.isBlockStatement(node.body)) {
+        const bloc = node.body.loc;
+        if (node.expression === true) {
+            node.expression = false;
+        }
+        node.body = T.blockStatement([T.returnStatement(node.body)]);
+        // restore body location
+        node.body.loc = bloc;
+        // set up the location for the return statement so it gets
+        // instrumented
+        node.body.body[0].loc = bloc;
+    }
+}
+function coverIfBranches(path) {
+    const n = path.node;
+    const hint = this.hintFor(n);
+    const ignoreIf = hint === 'if';
+    const ignoreElse = hint === 'else';
+    if (ignoreIf) {
+        this.setAttr(n.consequent, 'skip-all', true);
+    }
+    else {
+        this.insertBranchCounter(path.get('consequent'), n.loc);
+    }
+    if (ignoreElse) {
+        this.setAttr(n.alternate, 'skip-all', true);
+    }
+    else {
+        this.insertBranchCounter(path.get('alternate'), undefined);
+    }
+}
+function createSwitchBranch(path) {
+    // Intentionally left blank
+}
+function coverSwitchCase(path) {
+    const T = this.types;
+    const loc = path.node.loc;
+    if (!loc) {
+        return;
+    }
+    const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
+    if (this.shouldInstrument(path, originPos)) {
+        const increment = newLineCoverageExpression(originFileId, originPos);
+        path.node.consequent.unshift(T.expressionStatement(increment));
+    }
+}
+function coverTernary(path) {
+    const n = path.node;
+    const cHint = this.hintFor(n.consequent);
+    const aHint = this.hintFor(n.alternate);
+    if (cHint !== 'next') {
+        this.insertBranchCounter(path.get('consequent'), undefined);
+    }
+    if (aHint !== 'next') {
+        this.insertBranchCounter(path.get('alternate'), undefined);
+    }
+}
+function coverLogicalExpression(path) {
+    const T = this.types;
+    if (path.parentPath.node.type === 'LogicalExpression') {
+        return; // already processed
+    }
+    const leaves = [];
+    this.findLeaves(path.node, leaves, undefined, undefined);
+    for (const leaf of leaves) {
+        const hint = this.hintFor(leaf.node);
+        if (hint === 'next') {
+            continue;
+        }
+        const loc = path.node.loc;
+        if (!loc) {
+            continue;
+        }
+        const [originFileId, originPos] = this.origins.ensureKnownOrigin(loc);
+        if (!this.shouldInstrument(path, originPos)) {
+            continue;
+        }
+        const increment = newLineCoverageExpression(originFileId, originPos);
+        if (!increment) {
+            continue;
+        }
+        leaf.parent[leaf.property] = T.sequenceExpression([
+            increment,
+            leaf.node
+        ]);
+    }
+}
+const codeVisitor = {
+    ArrowFunctionExpression: entries(convertArrowExpression, coverFunction),
+    AssignmentPattern: entries(coverAssignmentPattern),
+    BlockStatement: entries(),
+    ExportDefaultDeclaration: entries(),
+    ExportNamedDeclaration: entries(),
+    ClassMethod: entries(coverFunction),
+    ClassDeclaration: entries(parenthesizedExpressionProp('superClass')),
+    ClassProperty: entries(coverClassPropDeclarator),
+    ClassPrivateProperty: entries(coverClassPropDeclarator),
+    ObjectMethod: entries(coverFunction),
+    ExpressionStatement: entries(coverStatement),
+    BreakStatement: entries(coverStatement),
+    ContinueStatement: entries(coverStatement),
+    DebuggerStatement: entries(coverStatement),
+    ReturnStatement: entries(coverStatement),
+    ThrowStatement: entries(coverStatement),
+    TryStatement: entries(coverStatement),
+    VariableDeclaration: entries(),
+    VariableDeclarator: entries(coverVariableDeclarator),
+    IfStatement: entries(blockProp('consequent'), blockProp('alternate'), coverStatement, coverIfBranches),
+    ForStatement: entries(blockProp('body'), coverStatement),
+    ForInStatement: entries(blockProp('body'), coverStatement),
+    ForOfStatement: entries(blockProp('body'), coverStatement),
+    WhileStatement: entries(blockProp('body'), coverStatement),
+    DoWhileStatement: entries(blockProp('body'), coverStatement),
+    SwitchStatement: entries(createSwitchBranch, coverStatement),
+    SwitchCase: entries(coverSwitchCase),
+    WithStatement: entries(blockProp('body'), coverStatement),
+    FunctionDeclaration: entries(coverFunction),
+    FunctionExpression: entries(coverFunction),
+    LabeledStatement: entries(coverStatement),
+    ConditionalExpression: entries(coverTernary),
+    LogicalExpression: entries(coverLogicalExpression)
+};
+/**
+ * The rewire plugin (and potentially other babel middleware)
+ * may cause files to be instrumented twice, see:
+ * https://github.com/istanbuljs/babel-plugin-istanbul/issues/94
+ * we should only instrument code for coverage the first time
+ * it's run through lib-instrument.
+ */
+function alreadyInstrumented(path, visitState) {
+    return path.scope.hasBinding(visitState.varName);
+}
+function getParentComments(path) {
+    if (!path?.parent) {
+        return [];
+    }
+    if (!('comments' in path.parent)) {
+        return [];
+    }
+    return path.parent.comments;
+}
+function shouldIgnoreFile(programNodePath) {
+    if (!programNodePath) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return getParentComments(programNodePath).some(c => COMMENT_FILE_RE.test(c.value));
+}
+/**
+ * `programVisitor` is a `babel` adaptor for instrumentation.
+ *
+ * It returns an object with two methods `enter` and `exit`.
+ * These should be assigned to or called from `Program` entry and exit functions
+ * in a babel visitor.
+ *
+ * These functions do not make assumptions about the state set by Babel and thus
+ * can be used in a context other than a Babel plugin.
+ *
+ * The exit function returns an object that currently has the following keys:
+ *
+ * `fileCoverage` - the file coverage object created for the source file.
+ * `sourceMappingURL` - any source mapping URL found when processing the file.
+ *
+ * @param types - an instance of babel-types.
+ * @param sourceFilePath - the path to source file.
+ * @param opts - additional options.
+ */
+function programVisitor(types, inputSourceMapConsumer, opts) {
+    opts = { ...opts };
+    const visitState = new VisitState(types, inputSourceMapConsumer, opts.ignoreClassMethods, opts.reportLogic, opts.shouldInstrumentCallback);
+    return {
+        enter(path) {
+            if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
+                return;
+            }
+            if (alreadyInstrumented(path, visitState)) {
+                return;
+            }
+            path.traverse(codeVisitor, visitState);
+        },
+        exit(path) {
+            if (alreadyInstrumented(path, visitState)) {
+                return;
+            }
+            const originData = visitState.origins;
+            if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
+                return;
+            }
+            const body = path.node.body;
+            if (opts.codeToPrepend) {
+                const codeToPrependAst = (0, core_1.parse)(opts.codeToPrepend, { sourceType: 'script' });
+                if (codeToPrependAst !== null) {
+                    body.unshift(...codeToPrependAst.program.body);
+                }
+            }
+            // Add a variable definition for each origin file on top of the file.
+            for (const [originPath, originId] of originData.originToIdMap.entries()) {
+                const declaration = newStringConstDeclarationNode(originId, originPath);
+                body.unshift(declaration);
+            }
+            // Add a token for signaling that the file has been instrumented.
+            if (opts.isInstrumentedToken) {
+                types.addComment(path.node, 'leading', opts.isInstrumentedToken, false);
+            }
+        }
+    };
+}
+exports.programVisitor = programVisitor;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@teamscale/lib-instrument",
+  "version": "0.1.0-beta.2",
+  "description": "Library for adding coverage statements to JS code; forked from istanbul-lib-coverage",
+  "author": "Krishnan Anantheswaran <kananthmail-github@yahoo.com>",
+  "maintainers": [
+    {
+      "name": "CQSE GmbH"
+    }
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.23.2",
+    "@babel/parser": "^7.23.0",
+    "@babel/traverse": "^7.23.2",
+    "@types/node": "^20.8.10",
+    "semver": "^7.5.4",
+    "source-map": "^0.7.4",
+    "typescript": "^5.2.2"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.0",
+    "@babel/types": "^7.23.0",
+    "@types/babel__core": "^7.20.3",
+    "@types/babel__parser": "^7.1.1",
+    "@types/chai": "^4.3.9",
+    "@types/clone": "^2.1.3",
+    "@types/js-yaml": "^4.0.9",
+    "@types/jest": "^29.5.6",
+    "babel-jest": "^29.7.0",
+    "chai": "^4.2.0",
+    "clone": "^2.1.2",
+    "debug": "^4.3.4",
+    "documentation": "^14.0.2",
+    "js-yaml": "^4.1.0",
+    "ts-jest": "^29.1.1",
+    "jest": "^29.7.0",
+    "nopt": "^4.0.1",
+    "nyc": "^15.1.0",
+    "rimraf": "^5.0.5"
+  },
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cqse/teamscale-javascript-profiler.git",
+    "directory": "packages/lib-instrument"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rimraf lib tsconfig.tsbuildinfo",
+    "build": "tsc",
+    "test": "pnpm build && NODE_OPTIONS='--experimental-vm-modules --max-old-space-size=8192' jest --forceExit --coverage --silent=true --detectOpenHandles"
+  }
+}