@teamscale/lib-instrument 1.0.0-beta.6 → 1.0.4

package/lib/index.cjs

@@ -0,0 +1,613 @@
+let _babel_core = require("@babel/core");
+let source_map = require("source-map");
+
+//#region src/origins.ts
+/**
+* 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.
+*/
+const fileIdSeqGenerator = (() => {
+	const instrumenterRunId = process.pid;
+	let fileIdSeq = 0;
+	return { next: () => {
+		fileIdSeq++;
+		let num;
+		if (fileIdSeq < 1e4) num = instrumenterRunId * 1e4 + fileIdSeq;
+		else if (fileIdSeq < 1e5) num = instrumenterRunId * 1e5 + 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.
+*/
+var SourceOrigins = class {
+	sourceMap;
+	/**
+	* The mapping of file ids to the file names in the transpiler origin,
+	* that is, the file names found in the source map.
+	*/
+	originToIdMap;
+	constructor(sourceMap) {
+		this.originToIdMap = /* @__PURE__ */ 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 = void 0;
+		let endPos = void 0;
+		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${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
+		}];
+	}
+};
+
+//#endregion
+//#region src/visitor.ts
+const COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/;
+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.
+*/
+var VisitState = class {
+	types;
+	attrs;
+	nextIgnore;
+	ignoreClassMethods;
+	reportLogic;
+	/** Callback to determine if the given source location should be instrumented. */
+	shouldInstrumentCallback;
+	/** Object that manages the mapping to the original code, using source maps. */
+	origins;
+	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 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 = COMMENT_RE.exec(v);
+			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 (this.nextIgnore !== null) return;
+		if (this.hintFor(n) === "next") {
+			this.nextIgnore = n;
+			return;
+		}
+		if (this.getAttr(path.node, "skip-all") !== null) this.nextIgnore = n;
+		if (path.isFunctionExpression() && this.ignoreClassMethods.some((name) => 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) {
+		if (path.node === this.nextIgnore) this.nextIgnore = null;
+		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)) {
+			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 ?? void 0;
+				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)) {
+			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") {
+			if (this.hintFor(node) !== "next") {
+				this.findLeaves(node.left, accumulator, node, "left");
+				this.findLeaves(node.right, accumulator, node, "right");
+			}
+		} else accumulator.push({
+			node,
+			parent,
+			property
+		});
+	}
+};
+/**
+* Create a line coverage reporting statement node.
+*/
+function newLineCoverageExpression(originFileId, range) {
+	const argumentList = [{
+		type: "Identifier",
+		name: originFileId
+	}, {
+		type: "NumericLiteral",
+		value: range.start.line
+	}];
+	if (range.start.line !== range.end.line) argumentList.push({
+		type: "NumericLiteral",
+		value: range.end.line
+	});
+	return {
+		type: "CallExpression",
+		callee: {
+			type: "Identifier",
+			name: "_$l"
+		},
+		arguments: argumentList
+	};
+}
+/**
+* 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 relieves them from worrying about ignore states and generated nodes.
+* - standard exit processing is done
+*/
+function entries(...enter) {
+	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"), void 0);
+}
+function coverFunction(path) {
+	this.insertFunctionCounter(path);
+}
+function coverVariableDeclarator(path) {
+	this.insertStatementCounter(path.get("init"));
+}
+function coverClassPropDeclarator(path) {
+	this.insertStatementCounter(path.get("value"));
+}
+function coverSequenceExpression(path) {
+	const T = this.types;
+	if (!path.isSequenceExpression()) return;
+	const newExpressions = [];
+	for (const expression of path.node.expressions) {
+		const [originFileId, originPos] = this.origins.ensureKnownOrigin(expression.loc);
+		if (this.shouldInstrument(path, originPos)) {
+			const increment = newLineCoverageExpression(originFileId, originPos);
+			newExpressions.push(increment);
+		}
+		newExpressions.push(expression);
+	}
+	path.replaceWith(T.sequenceExpression(newExpressions));
+}
+function makeBlock(path) {
+	const T = this.types;
+	if (!path.node) path.replaceWith(T.blockStatement([]));
+	if (path.isSequenceExpression()) coverSequenceExpression.call(this, path);
+	else 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 = void 0;
+	}
+}
+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) node.expression = false;
+		node.body = T.blockStatement([T.returnStatement(node.body)]);
+		node.body.loc = bloc;
+		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"), void 0);
+}
+function createSwitchBranch() {}
+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"), void 0);
+	if (aHint !== "next") this.insertBranchCounter(path.get("alternate"), void 0);
+}
+function coverLogicalExpression(path) {
+	const T = this.types;
+	if (path.parentPath.node.type === "LogicalExpression") return;
+	const leaves = [];
+	this.findLeaves(path.node, leaves, void 0, void 0);
+	for (const leaf of leaves) {
+		if (this.hintFor(leaf.node) === "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),
+	SequenceExpression: entries(coverSequenceExpression)
+};
+/**
+* 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;
+	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 inputSourceMapConsumer - access object for the source map of the input.
+* @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, _babel_core.parse)(opts.codeToPrepend, { sourceType: "script" });
+				if (codeToPrependAst !== null) body.unshift(...codeToPrependAst.program.body);
+			}
+			for (const [originPath, originId] of originData.originToIdMap.entries()) {
+				const declaration = newStringConstDeclarationNode(originId, originPath);
+				body.unshift(declaration);
+			}
+			if (opts.isInstrumentedToken) types.addComment(path.node, "leading", opts.isInstrumentedToken, false);
+		}
+	};
+}
+
+//#endregion
+//#region src/instrumenter.ts
+function mapSourceMapsOption(produceSourceMap) {
+	if (produceSourceMap === "none") return false;
+	if (produceSourceMap === "external") return "both";
+	return produceSourceMap;
+}
+/**
+* The main class of the instrumenter.
+*/
+var Instrumenter = class {
+	opts;
+	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((/* @__PURE__ */ new Date()).getTime()) + ".js";
+		const { opts } = this;
+		const sourceMapToUse = inputSourceMap ?? opts.inputSourceMap;
+		let inputSourceMapConsumer = void 0;
+		if (sourceMapToUse) inputSourceMapConsumer = await new source_map.SourceMapConsumer(sourceMapToUse);
+		return (0, _babel_core.transformSync)(code, {
+			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 = 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);
+					}
+				} } };
+			}]]
+		}).code;
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Creates a new coverage instrumenter.
+*
+* @param opts - instrumenter options
+*/
+function createInstrumenter(opts) {
+	return new Instrumenter(opts);
+}
+
+//#endregion
+exports.createInstrumenter = createInstrumenter;
+exports.programVisitor = programVisitor;

package/lib/index.d.cts

@@ -0,0 +1,45 @@
+import { NodePath } from "@babel/core";
+import * as _babel_types0 from "@babel/types";
+import { Program, SourceLocation } from "@babel/types";
+import { ParserPlugin } from "@babel/parser";
+import { RawSourceMap, SourceMapConsumer } from "source-map";
+
+//#region src/utils.d.ts
+type InstrumentationOptions = Partial<{
+  reportLogic: boolean;
+  coverageGlobalScopeFunc: boolean;
+  ignoreClassMethods: string[];
+  inputSourceMap?: RawSourceMap;
+  isInstrumentedToken?: string;
+  codeToPrepend?: string;
+  shouldInstrumentCallback?: (path: NodePath, loc: SourceLocation) => boolean;
+}>;
+//#endregion
+//#region src/instrumenter.d.ts
+type InstrumenterOptions = InstrumentationOptions & Partial<{
+  preserveComments: boolean;
+  compact: boolean;
+  esModules: boolean;
+  autoWrap: boolean;
+  produceSourceMap: 'none' | 'inline' | 'external';
+  debug: boolean;
+  parserPlugins: ParserPlugin[];
+}>;
+declare class Instrumenter {
+  private readonly opts;
+  constructor(opts?: Partial<InstrumenterOptions>);
+  instrument(code: string, filename: string | undefined, inputSourceMap: RawSourceMap | undefined, shouldInstrumentCallback?: (path: NodePath, location: SourceLocation) => boolean): Promise<string>;
+}
+//#endregion
+//#region src/visitor.d.ts
+type BabelTypes = typeof _babel_types0;
+declare function programVisitor(types: BabelTypes, inputSourceMapConsumer: SourceMapConsumer | undefined, opts: InstrumentationOptions): {
+  enter(path: NodePath<Program>): void;
+  exit(path: NodePath<Program>): void;
+};
+//#endregion
+//#region src/index.d.ts
+declare function createInstrumenter(opts: InstrumenterOptions): Instrumenter;
+//#endregion
+export { type InstrumenterOptions, createInstrumenter, programVisitor };
+//# sourceMappingURL=index.d.cts.map

package/lib/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/utils.ts","../src/instrumenter.ts","../src/visitor.ts","../src/index.ts"],"mappings":";;;;;;;KAOY,sBAAA,GAAyB,OAAA;EAAA,WAAA;EAAA,uBAAA;EAAA,kBAAA;EAAA,cAAA,GAWhB,YAAA;EAAA,mBAAA;EAAA,aAAA;EAAA,wBAAA,IAAA,IAAA,EASiB,QAAA,EAAA,GAAA,EAAe,cAAA;AAAA;;;KCZzC,mBAAA,GAAsB,sBAAA,GAAyB,OAAA;EAAA,gBAAA;EAAA,OAAA;EAAA,SAAA;EAAA,QAAA;EAAA,gBAAA;EAAA,KAAA;EAAA,aAAA,EAoBxC,YAAA;AAAA;AAAA,cAgBN,YAAA;EAAA,iBAAA,IAAA;EAAA,YAAA,IAAA,GAIU,OAAA,CAAQ,mBAAA;EAAA,WAAA,IAAA,UAAA,QAAA,sBAAA,cAAA,EAgBkD,YAAA,cAAA,wBAAA,IAAA,IAAA,EAC1B,QAAA,EAAA,QAAA,EAAoB,cAAA,eAA6B,OAAA;AAAA;;;KC7DnG,UAAA,UAAU,aAAA;AAAA,iBA6nBC,cAAA,CAAA,KAAA,EAAsB,UAAA,EAAA,sBAAA,EACiB,iBAAA,cAAA,IAAA,EAClB,sBAAA;EAAA,KAAA,CAAA,IAAA,EAYjB,QAAA,CAAS,OAAA;EAAA,IAAA,CAAA,IAAA,EASV,QAAA,CAAS,OAAA;AAAA;;;iBCrpBZ,kBAAA,CAAA,IAAA,EAAyB,mBAAA,GAAsB,YAAA"}

package/lib/index.d.mts

@@ -0,0 +1,45 @@
+import { NodePath } from "@babel/core";
+import { RawSourceMap, SourceMapConsumer } from "source-map";
+import * as _babel_types0 from "@babel/types";
+import { Program, SourceLocation } from "@babel/types";
+import { ParserPlugin } from "@babel/parser";
+
+//#region src/utils.d.ts
+type InstrumentationOptions = Partial<{
+  reportLogic: boolean;
+  coverageGlobalScopeFunc: boolean;
+  ignoreClassMethods: string[];
+  inputSourceMap?: RawSourceMap;
+  isInstrumentedToken?: string;
+  codeToPrepend?: string;
+  shouldInstrumentCallback?: (path: NodePath, loc: SourceLocation) => boolean;
+}>;
+//#endregion
+//#region src/instrumenter.d.ts
+type InstrumenterOptions = InstrumentationOptions & Partial<{
+  preserveComments: boolean;
+  compact: boolean;
+  esModules: boolean;
+  autoWrap: boolean;
+  produceSourceMap: 'none' | 'inline' | 'external';
+  debug: boolean;
+  parserPlugins: ParserPlugin[];
+}>;
+declare class Instrumenter {
+  private readonly opts;
+  constructor(opts?: Partial<InstrumenterOptions>);
+  instrument(code: string, filename: string | undefined, inputSourceMap: RawSourceMap | undefined, shouldInstrumentCallback?: (path: NodePath, location: SourceLocation) => boolean): Promise<string>;
+}
+//#endregion
+//#region src/visitor.d.ts
+type BabelTypes = typeof _babel_types0;
+declare function programVisitor(types: BabelTypes, inputSourceMapConsumer: SourceMapConsumer | undefined, opts: InstrumentationOptions): {
+  enter(path: NodePath<Program>): void;
+  exit(path: NodePath<Program>): void;
+};
+//#endregion
+//#region src/index.d.ts
+declare function createInstrumenter(opts: InstrumenterOptions): Instrumenter;
+//#endregion
+export { type InstrumenterOptions, createInstrumenter, programVisitor };
+//# sourceMappingURL=index.d.mts.map