claude-autopm 3.1.2 → 3.2.1

package/packages/plugin-devops/node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument/src/visitor.js

@@ -1,843 +0,0 @@
-const { createHash } = require('crypto');
-const { template } = require('@babel/core');
-const { defaults } = require('@istanbuljs/schema');
-const { SourceCoverage } = require('./source-coverage');
-const { SHA, MAGIC_KEY, MAGIC_VALUE } = require('./constants');
-
-// 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|$)/;
-// source map URL pattern
-const SOURCE_MAP_RE = /[#@]\s*sourceMappingURL=(.*)\s*$/m;
-
-// generate a variable name from hashing the supplied file path
-function genVar(filename) {
-    const hash = createHash(SHA);
-    hash.update(filename);
-    return 'cov_' + parseInt(hash.digest('hex').substr(0, 12), 16).toString(36);
-}
-
-// VisitState holds the state of the visitor, provides helper functions
-// and is the `this` for the individual coverage visitors.
-class VisitState {
-    constructor(
-        types,
-        sourceFilePath,
-        inputSourceMap,
-        ignoreClassMethods = [],
-        reportLogic = false
-    ) {
-        this.varName = genVar(sourceFilePath);
-        this.attrs = {};
-        this.nextIgnore = null;
-        this.cov = new SourceCoverage(sourceFilePath);
-
-        if (typeof inputSourceMap !== 'undefined') {
-            this.cov.inputSourceMap(inputSourceMap);
-        }
-        this.ignoreClassMethods = ignoreClassMethods;
-        this.types = types;
-        this.sourceMappingURL = null;
-        this.reportLogic = reportLogic;
-    }
-
-    // should we ignore the node? Yes, if specifically ignoring
-    // or if the node is generated.
-    shouldIgnore(path) {
-        return this.nextIgnore || !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 || /* istanbul ignore next: paranoid check */ ''
-                ).trim();
-                const groups = v.match(COMMENT_RE);
-                if (groups) {
-                    hint = groups[1];
-                }
-            });
-        }
-        return hint;
-    }
-
-    // extract a source map URL from comments and keep track of it
-    maybeAssignSourceMapURL(node) {
-        const extractURL = comments => {
-            if (!comments) {
-                return;
-            }
-            comments.forEach(c => {
-                const v = (
-                    c.value || /* istanbul ignore next: paranoid check */ ''
-                ).trim();
-                const groups = v.match(SOURCE_MAP_RE);
-                if (groups) {
-                    this.sourceMappingURL = groups[1];
-                }
-            });
-        };
-        extractURL(node.leadingComments);
-        extractURL(node.trailingComments);
-    }
-
-    // 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;
-
-        this.maybeAssignSourceMapURL(n);
-
-        // 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 reseting 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];
-    }
-
-    //
-    increase(type, id, index) {
-        const T = this.types;
-        const wrap =
-            index !== null
-                ? // If `index` present, turn `x` into `x[index]`.
-                  x => T.memberExpression(x, T.numericLiteral(index), true)
-                : x => x;
-        return T.updateExpression(
-            '++',
-            wrap(
-                T.memberExpression(
-                    T.memberExpression(
-                        T.callExpression(T.identifier(this.varName), []),
-                        T.identifier(type)
-                    ),
-                    T.numericLiteral(id),
-                    true
-                )
-            )
-        );
-    }
-
-    // Reads the logic expression conditions and conditionally increments truthy counter.
-    increaseTrue(type, id, index, node) {
-        const T = this.types;
-        const tempName = `${this.varName}_temp`;
-
-        return T.sequenceExpression([
-            T.assignmentExpression(
-                '=',
-                T.memberExpression(
-                    T.callExpression(T.identifier(this.varName), []),
-                    T.identifier(tempName)
-                ),
-                node // Only evaluates once.
-            ),
-            T.parenthesizedExpression(
-                T.conditionalExpression(
-                    this.validateTrueNonTrivial(T, tempName),
-                    this.increase(type, id, index),
-                    T.nullLiteral()
-                )
-            ),
-            T.memberExpression(
-                T.callExpression(T.identifier(this.varName), []),
-                T.identifier(tempName)
-            )
-        ]);
-    }
-
-    validateTrueNonTrivial(T, tempName) {
-        return T.logicalExpression(
-            '&&',
-            T.memberExpression(
-                T.callExpression(T.identifier(this.varName), []),
-                T.identifier(tempName)
-            ),
-            T.logicalExpression(
-                '&&',
-                T.parenthesizedExpression(
-                    T.logicalExpression(
-                        '||',
-                        T.unaryExpression(
-                            '!',
-                            T.callExpression(
-                                T.memberExpression(
-                                    T.identifier('Array'),
-                                    T.identifier('isArray')
-                                ),
-                                [
-                                    T.memberExpression(
-                                        T.callExpression(
-                                            T.identifier(this.varName),
-                                            []
-                                        ),
-                                        T.identifier(tempName)
-                                    )
-                                ]
-                            )
-                        ),
-                        T.memberExpression(
-                            T.memberExpression(
-                                T.callExpression(
-                                    T.identifier(this.varName),
-                                    []
-                                ),
-                                T.identifier(tempName)
-                            ),
-                            T.identifier('length')
-                        )
-                    )
-                ),
-                T.parenthesizedExpression(
-                    T.logicalExpression(
-                        '||',
-                        T.binaryExpression(
-                            '!==',
-                            T.callExpression(
-                                T.memberExpression(
-                                    T.identifier('Object'),
-                                    T.identifier('getPrototypeOf')
-                                ),
-                                [
-                                    T.memberExpression(
-                                        T.callExpression(
-                                            T.identifier(this.varName),
-                                            []
-                                        ),
-                                        T.identifier(tempName)
-                                    )
-                                ]
-                            ),
-                            T.memberExpression(
-                                T.identifier('Object'),
-                                T.identifier('prototype')
-                            )
-                        ),
-                        T.memberExpression(
-                            T.callExpression(
-                                T.memberExpression(
-                                    T.identifier('Object'),
-                                    T.identifier('values')
-                                ),
-                                [
-                                    T.memberExpression(
-                                        T.callExpression(
-                                            T.identifier(this.varName),
-                                            []
-                                        ),
-                                        T.identifier(tempName)
-                                    )
-                                ]
-                            ),
-                            T.identifier('length')
-                        )
-                    )
-                )
-            )
-        );
-    }
-
-    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.parentPath)
-        ) {
-            // make an attempt to hoist the statement counter, so that
-            // function names are maintained.
-            const parent = path.parentPath.parentPath;
-            if (parent && T.isExportNamedDeclaration(parent.parentPath)) {
-                parent.parentPath.insertBefore(
-                    T.expressionStatement(increment)
-                );
-            } else if (
-                parent &&
-                (T.isProgram(parent.parentPath) ||
-                    T.isBlockStatement(parent.parentPath))
-            ) {
-                parent.insertBefore(T.expressionStatement(increment));
-            } else {
-                path.replaceWith(T.sequenceExpression([increment, path.node]));
-            }
-        } /* istanbul ignore else: not expected */ else if (
-            path.isExpression()
-        ) {
-            path.replaceWith(T.sequenceExpression([increment, path.node]));
-        } else {
-            console.error(
-                'Unable to insert counter for node type:',
-                path.node.type
-            );
-        }
-    }
-
-    insertStatementCounter(path) {
-        /* istanbul ignore if: paranoid check */
-        if (!(path.node && path.node.loc)) {
-            return;
-        }
-        const index = this.cov.newStatement(path.node.loc);
-        const increment = this.increase('s', index, null);
-        this.insertCounter(path, increment);
-    }
-
-    insertFunctionCounter(path) {
-        const T = this.types;
-        /* istanbul ignore if: paranoid check */
-        if (!(path.node && path.node.loc)) {
-            return;
-        }
-        const n = path.node;
-
-        let dloc = null;
-        // get location for declaration
-        switch (n.type) {
-            case 'FunctionDeclaration':
-            case 'FunctionExpression':
-                /* istanbul ignore else: paranoid check */
-                if (n.id) {
-                    dloc = n.id.loc;
-                }
-                break;
-        }
-        if (!dloc) {
-            dloc = {
-                start: n.loc.start,
-                end: { line: n.loc.start.line, column: n.loc.start.column + 1 }
-            };
-        }
-
-        const name = path.node.id ? path.node.id.name : path.node.name;
-        const index = this.cov.newFunction(name, dloc, path.node.body.loc);
-        const increment = this.increase('f', index, null);
-        const body = path.get('body');
-        /* istanbul ignore else: not expected */
-        if (body.isBlockStatement()) {
-            body.node.body.unshift(T.expressionStatement(increment));
-        } else {
-            console.error(
-                'Unable to process function body node type:',
-                path.node.type
-            );
-        }
-    }
-
-    getBranchIncrement(branchName, loc) {
-        const index = this.cov.addBranchPath(branchName, loc);
-        return this.increase('b', branchName, index);
-    }
-
-    getBranchLogicIncrement(path, branchName, loc) {
-        const index = this.cov.addBranchPath(branchName, loc);
-        return [
-            this.increase('b', branchName, index),
-            this.increaseTrue('bT', branchName, index, path.node)
-        ];
-    }
-
-    insertBranchCounter(path, branchName, loc) {
-        const increment = this.getBranchIncrement(
-            branchName,
-            loc || path.node.loc
-        );
-        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,
-                property
-            });
-        }
-    }
-}
-
-// 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
-//   This relieves 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, node) {
-        this.onExit(path, node);
-    };
-    return {
-        enter: wrappedEntry,
-        exit
-    };
-}
-
-function coverStatement(path) {
-    this.insertStatementCounter(path);
-}
-
-/* istanbul ignore next: no node.js support */
-function coverAssignmentPattern(path) {
-    const n = path.node;
-    const b = this.cov.newBranch('default-arg', n.loc);
-    this.insertBranchCounter(path.get('right'), b);
-}
-
-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]));
-        path.node.loc = path.node.body[0].loc;
-        path.node.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 n = path.node;
-    const T = this.types;
-    if (!T.isBlockStatement(n.body)) {
-        const bloc = n.body.loc;
-        if (n.expression === true) {
-            n.expression = false;
-        }
-        n.body = T.blockStatement([T.returnStatement(n.body)]);
-        // restore body location
-        n.body.loc = bloc;
-        // set up the location for the return statement so it gets
-        // instrumented
-        n.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';
-    const branch = this.cov.newBranch('if', n.loc);
-
-    if (ignoreIf) {
-        this.setAttr(n.consequent, 'skip-all', true);
-    } else {
-        this.insertBranchCounter(path.get('consequent'), branch, n.loc);
-    }
-    if (ignoreElse) {
-        this.setAttr(n.alternate, 'skip-all', true);
-    } else {
-        this.insertBranchCounter(path.get('alternate'), branch);
-    }
-}
-
-function createSwitchBranch(path) {
-    const b = this.cov.newBranch('switch', path.node.loc);
-    this.setAttr(path.node, 'branchName', b);
-}
-
-function coverSwitchCase(path) {
-    const T = this.types;
-    const b = this.getAttr(path.parentPath.node, 'branchName');
-    /* istanbul ignore if: paranoid check */
-    if (b === null) {
-        throw new Error('Unable to get switch branch name');
-    }
-    const increment = this.getBranchIncrement(b, path.node.loc);
-    path.node.consequent.unshift(T.expressionStatement(increment));
-}
-
-function coverTernary(path) {
-    const n = path.node;
-    const branch = this.cov.newBranch('cond-expr', path.node.loc);
-    const cHint = this.hintFor(n.consequent);
-    const aHint = this.hintFor(n.alternate);
-
-    if (cHint !== 'next') {
-        this.insertBranchCounter(path.get('consequent'), branch);
-    }
-    if (aHint !== 'next') {
-        this.insertBranchCounter(path.get('alternate'), branch);
-    }
-}
-
-function coverLogicalExpression(path) {
-    const T = this.types;
-    if (path.parentPath.node.type === 'LogicalExpression') {
-        return; // already processed
-    }
-    const leaves = [];
-    this.findLeaves(path.node, leaves);
-    const b = this.cov.newBranch(
-        'binary-expr',
-        path.node.loc,
-        this.reportLogic
-    );
-    for (let i = 0; i < leaves.length; i += 1) {
-        const leaf = leaves[i];
-        const hint = this.hintFor(leaf.node);
-        if (hint === 'next') {
-            continue;
-        }
-
-        if (this.reportLogic) {
-            const increment = this.getBranchLogicIncrement(
-                leaf,
-                b,
-                leaf.node.loc
-            );
-            if (!increment[0]) {
-                continue;
-            }
-            leaf.parent[leaf.property] = T.sequenceExpression([
-                increment[0],
-                increment[1]
-            ]);
-            continue;
-        }
-
-        const increment = this.getBranchIncrement(b, leaf.node.loc);
-        if (!increment) {
-            continue;
-        }
-        leaf.parent[leaf.property] = T.sequenceExpression([
-            increment,
-            leaf.node
-        ]);
-    }
-}
-
-const codeVisitor = {
-    ArrowFunctionExpression: entries(convertArrowExpression, coverFunction),
-    AssignmentPattern: entries(coverAssignmentPattern),
-    BlockStatement: entries(), // ignore processing only
-    ExportDefaultDeclaration: entries(), // ignore processing only
-    ExportNamedDeclaration: entries(), // ignore processing only
-    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(), // ignore processing only
-    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)
-};
-const globalTemplateAlteredFunction = template(`
-        var Function = (function(){}).constructor;
-        var global = (new Function(GLOBAL_COVERAGE_SCOPE))();
-`);
-const globalTemplateFunction = template(`
-        var global = (new Function(GLOBAL_COVERAGE_SCOPE))();
-`);
-const globalTemplateVariable = template(`
-        var global = GLOBAL_COVERAGE_SCOPE;
-`);
-// the template to insert at the top of the program.
-const coverageTemplate = template(
-    `
-    function COVERAGE_FUNCTION () {
-        var path = PATH;
-        var hash = HASH;
-        GLOBAL_COVERAGE_TEMPLATE
-        var gcv = GLOBAL_COVERAGE_VAR;
-        var coverageData = INITIAL;
-        var coverage = global[gcv] || (global[gcv] = {});
-        if (!coverage[path] || coverage[path].hash !== hash) {
-            coverage[path] = coverageData;
-        }
-
-        var actualCoverage = coverage[path];
-        {
-            // @ts-ignore
-            COVERAGE_FUNCTION = function () {
-                return actualCoverage;
-            }
-        }
-
-        return actualCoverage;
-    }
-`,
-    { preserveComments: true }
-);
-// 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 istanbul-lib-instrument.
-function alreadyInstrumented(path, visitState) {
-    return path.scope.hasBinding(visitState.varName);
-}
-function shouldIgnoreFile(programNode) {
-    return (
-        programNode.parent &&
-        programNode.parent.comments.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 {Object} types - an instance of babel-types.
- * @param {string} sourceFilePath - the path to source file.
- * @param {Object} opts - additional options.
- * @param {string} [opts.coverageVariable=__coverage__] the global coverage variable name.
- * @param {boolean} [opts.reportLogic=false] report boolean value of logical expressions.
- * @param {string} [opts.coverageGlobalScope=this] the global coverage variable scope.
- * @param {boolean} [opts.coverageGlobalScopeFunc=true] use an evaluated function to find coverageGlobalScope.
- * @param {Array} [opts.ignoreClassMethods=[]] names of methods to ignore by default on classes.
- * @param {object} [opts.inputSourceMap=undefined] the input source map, that maps the uninstrumented code back to the
- * original code.
- */
-function programVisitor(types, sourceFilePath = 'unknown.js', opts = {}) {
-    const T = types;
-    opts = {
-        ...defaults.instrumentVisitor,
-        ...opts
-    };
-    const visitState = new VisitState(
-        types,
-        sourceFilePath,
-        opts.inputSourceMap,
-        opts.ignoreClassMethods,
-        opts.reportLogic
-    );
-    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;
-            }
-            visitState.cov.freeze();
-            const coverageData = visitState.cov.toJSON();
-            if (shouldIgnoreFile(path.find(p => p.isProgram()))) {
-                return {
-                    fileCoverage: coverageData,
-                    sourceMappingURL: visitState.sourceMappingURL
-                };
-            }
-            coverageData[MAGIC_KEY] = MAGIC_VALUE;
-            const hash = createHash(SHA)
-                .update(JSON.stringify(coverageData))
-                .digest('hex');
-            coverageData.hash = hash;
-            if (
-                coverageData.inputSourceMap &&
-                Object.getPrototypeOf(coverageData.inputSourceMap) !==
-                    Object.prototype
-            ) {
-                coverageData.inputSourceMap = {
-                    ...coverageData.inputSourceMap
-                };
-            }
-            const coverageNode = T.valueToNode(coverageData);
-            delete coverageData[MAGIC_KEY];
-            delete coverageData.hash;
-            let gvTemplate;
-            if (opts.coverageGlobalScopeFunc) {
-                if (path.scope.getBinding('Function')) {
-                    gvTemplate = globalTemplateAlteredFunction({
-                        GLOBAL_COVERAGE_SCOPE: T.stringLiteral(
-                            'return ' + opts.coverageGlobalScope
-                        )
-                    });
-                } else {
-                    gvTemplate = globalTemplateFunction({
-                        GLOBAL_COVERAGE_SCOPE: T.stringLiteral(
-                            'return ' + opts.coverageGlobalScope
-                        )
-                    });
-                }
-            } else {
-                gvTemplate = globalTemplateVariable({
-                    GLOBAL_COVERAGE_SCOPE: opts.coverageGlobalScope
-                });
-            }
-            const cv = coverageTemplate({
-                GLOBAL_COVERAGE_VAR: T.stringLiteral(opts.coverageVariable),
-                GLOBAL_COVERAGE_TEMPLATE: gvTemplate,
-                COVERAGE_FUNCTION: T.identifier(visitState.varName),
-                PATH: T.stringLiteral(sourceFilePath),
-                INITIAL: coverageNode,
-                HASH: T.stringLiteral(hash)
-            });
-            // explicitly call this.varName to ensure coverage is always initialized
-            path.node.body.unshift(
-                T.expressionStatement(
-                    T.callExpression(T.identifier(visitState.varName), [])
-                )
-            );
-            path.node.body.unshift(cv);
-            return {
-                fileCoverage: coverageData,
-                sourceMappingURL: visitState.sourceMappingURL
-            };
-        }
-    };
-}
-
-module.exports = programVisitor;