xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/commonjs/CommonJsExportRequireDependency.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const Template_1 = require("@/template/Template");
+const ArrayHelpers_1 = require("@/base/ArrayHelpers");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+const processExportInfo_1 = __importDefault(require("@/dependencies/processExportInfo"));
+const CommonJsDependencyHelpers_1 = require("./CommonJsDependencyHelpers");
+const idsSymbol = Symbol('CommonJsExportRequireDependency.ids');
+const EMPTY_OBJECT = {};
+class CommonJsExportRequireDependency extends ModuleDependency_1.default {
+    constructor(range, valueRange, base, names, request, ids, resultUsed) {
+        super(request);
+        this.range = range;
+        this.valueRange = valueRange;
+        this.base = base;
+        this.names = names;
+        this.ids = ids;
+        this.resultUsed = resultUsed;
+        this.asiSafe = undefined;
+    }
+    get type() {
+        return 'cjs export require';
+    }
+    couldAffectReferencingModule() {
+        return Dependency_1.default.TRANSITIVE;
+    }
+    getIds(moduleGraph) {
+        return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+    }
+    setIds(moduleGraph, ids) {
+        moduleGraph.getMeta(this)[idsSymbol] = ids;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        const ids = this.getIds(moduleGraph);
+        const getFullResult = () => {
+            if (ids.length === 0) {
+                return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+            }
+            return [
+                {
+                    name: ids,
+                    canMangle: false,
+                },
+            ];
+        };
+        if (this.resultUsed)
+            return getFullResult();
+        let exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this));
+        for (const name of this.names) {
+            const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+            const used = exportInfo.getUsed(runtime);
+            if (used === ExportsInfo_1.UsageState.Unused)
+                return Dependency_1.default.NO_EXPORTS_REFERENCED;
+            if (used !== ExportsInfo_1.UsageState.OnlyPropertiesUsed)
+                return getFullResult();
+            exportsInfo = exportInfo.exportsInfo;
+            if (!exportsInfo)
+                return getFullResult();
+        }
+        if (exportsInfo.otherExportsInfo.getUsed(runtime) !== ExportsInfo_1.UsageState.Unused) {
+            return getFullResult();
+        }
+        const referencedExports = [];
+        for (const exportInfo of exportsInfo.orderedExports) {
+            (0, processExportInfo_1.default)(runtime, referencedExports, ids.concat(exportInfo.name), exportInfo, false);
+        }
+        return referencedExports.map(name => ({
+            name,
+            canMangle: false,
+        }));
+    }
+    getExports(moduleGraph) {
+        const ids = this.getIds(moduleGraph);
+        if (this.names.length === 1) {
+            const name = this.names[0];
+            const from = moduleGraph.getConnection(this);
+            if (!from)
+                return;
+            return {
+                exports: [
+                    {
+                        name,
+                        from,
+                        export: ids.length === 0 ? null : ids,
+                        // we can't mangle names that are in an empty object
+                        // because one could access the prototype property
+                        // when export isn't set yet
+                        canMangle: !(name in EMPTY_OBJECT) && false,
+                    },
+                ],
+                dependencies: [from.module],
+            };
+        }
+        if (this.names.length > 0) {
+            const name = this.names[0];
+            return {
+                exports: [
+                    {
+                        name,
+                        // we can't mangle names that are in an empty object
+                        // because one could access the prototype property
+                        // when export isn't set yet
+                        canMangle: !(name in EMPTY_OBJECT) && false,
+                    },
+                ],
+                dependencies: undefined,
+            };
+        }
+        const from = moduleGraph.getConnection(this);
+        if (!from)
+            return;
+        const reexportInfo = this.getStarReexports(moduleGraph, undefined, from.module);
+        if (reexportInfo) {
+            return {
+                exports: Array.from(reexportInfo.exports, (name) => ({
+                    name,
+                    from,
+                    export: ids.concat(name),
+                    canMangle: !(name in EMPTY_OBJECT) && false,
+                })),
+                // TODO handle deep reexports
+                dependencies: [from.module],
+            };
+        }
+        return {
+            exports: true,
+            from: ids.length === 0 ? from : undefined,
+            canMangle: false,
+            dependencies: [from.module],
+        };
+    }
+    getStarReexports(moduleGraph, runtime, importedModule = moduleGraph.getModule(this)) {
+        let importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+        const ids = this.getIds(moduleGraph);
+        if (ids.length > 0)
+            importedExportsInfo = importedExportsInfo.getNestedExportsInfo(ids);
+        let exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this));
+        if (this.names.length > 0)
+            exportsInfo = exportsInfo.getNestedExportsInfo(this.names);
+        const noExtraExports = importedExportsInfo && importedExportsInfo.otherExportsInfo.provided === false;
+        const noExtraImports = exportsInfo && exportsInfo.otherExportsInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused;
+        if (!noExtraExports && !noExtraImports) {
+            return;
+        }
+        const isNamespaceImport = importedModule.getExportsType(moduleGraph, false) === 'namespace';
+        const exports = new Set();
+        const checked = new Set();
+        if (noExtraImports) {
+            for (const exportInfo of exportsInfo.orderedExports) {
+                const name = exportInfo.name;
+                if (exportInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused)
+                    continue;
+                if (name === '__esModule' && isNamespaceImport) {
+                    exports.add(name);
+                }
+                else if (importedExportsInfo) {
+                    const importedExportInfo = importedExportsInfo.getReadOnlyExportInfo(name);
+                    if (importedExportInfo.provided === false)
+                        continue;
+                    exports.add(name);
+                    if (importedExportInfo.provided === true)
+                        continue;
+                    checked.add(name);
+                }
+                else {
+                    exports.add(name);
+                    checked.add(name);
+                }
+            }
+        }
+        else if (noExtraExports) {
+            for (const importedExportInfo of importedExportsInfo.orderedExports) {
+                const name = importedExportInfo.name;
+                if (importedExportInfo.provided === false)
+                    continue;
+                if (exportsInfo) {
+                    const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+                    if (exportInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused)
+                        continue;
+                }
+                exports.add(name);
+                if (importedExportInfo.provided === true)
+                    continue;
+                checked.add(name);
+            }
+            if (isNamespaceImport) {
+                exports.add('__esModule');
+                checked.delete('__esModule');
+            }
+        }
+        return { exports, checked };
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.asiSafe);
+        write(this.range);
+        write(this.valueRange);
+        write(this.base);
+        write(this.names);
+        write(this.ids);
+        write(this.resultUsed);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.asiSafe = read();
+        this.range = read();
+        this.valueRange = read();
+        this.base = read();
+        this.names = read();
+        this.ids = read();
+        this.resultUsed = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(CommonJsExportRequireDependency, 'mp-compiler/core/dependencies/CommonJsExportRequireDependency');
+CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependencyTemplate extends (ModuleDependency_1.default.Template) {
+    apply(dependency, source, { module, runtimeTemplate, chunkGraph, moduleGraph, runtimeRequirements, runtime }) {
+        const dep = dependency;
+        const used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+        const [type, base] = (0, CommonJsDependencyHelpers_1.handleDependencyBase)(dep.base, module, runtimeRequirements);
+        const importedModule = moduleGraph.getModule(dep);
+        let requireExpr = runtimeTemplate.moduleExports({
+            module: importedModule,
+            chunkGraph,
+            request: dep.request,
+            weak: dep.weak,
+            runtimeRequirements,
+        });
+        if (importedModule) {
+            const ids = dep.getIds(moduleGraph);
+            const usedImported = moduleGraph.getExportsInfo(importedModule).getUsedName(ids, runtime);
+            if (usedImported) {
+                const comment = (0, ArrayHelpers_1.equals)(usedImported, ids)
+                    ? ''
+                    : `${Template_1.Template.toNormalComment((0, propertyAccess_1.default)(ids))} `;
+                requireExpr += `${comment}${(0, propertyAccess_1.default)(usedImported)}`;
+            }
+        }
+        switch (type) {
+            case 'expression':
+                source.replace(dep.range[0], dep.range[1] - 1, used
+                    ? `${base}${(0, propertyAccess_1.default)(used)} = ${requireExpr}`
+                    : `/* unused reexport */ ${requireExpr}`);
+                return;
+            case 'Object.defineProperty':
+                throw new Error('TODO');
+            default:
+                throw new Error('Unexpected type');
+        }
+    }
+};
+exports.default = CommonJsExportRequireDependency;

package/dist/dependencies/commonjs/CommonJsExportsDependency.d.ts

@@ -0,0 +1,19 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class CommonJsExportsDependency extends NullDependency {
+    range: any;
+    valueRange: any;
+    base: any;
+    names: any;
+    constructor(range: any, valueRange: any, base: any, names: any);
+    get type(): string;
+    getExports(moduleGraph: any): {
+        exports: {
+            name: any;
+            canMangle: boolean;
+        }[];
+        dependencies: undefined;
+    };
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CommonJsExportsDependency;

package/dist/dependencies/commonjs/CommonJsExportsDependency.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const CommonJsDependencyHelpers_1 = require("./CommonJsDependencyHelpers");
+const EMPTY_OBJECT = {};
+class CommonJsExportsDependency extends NullDependency_1.default {
+    constructor(range, valueRange, base, names) {
+        super();
+        this.range = range;
+        this.valueRange = valueRange;
+        this.base = base;
+        this.names = names;
+    }
+    get type() {
+        return 'cjs exports';
+    }
+    getExports(moduleGraph) {
+        const name = this.names[0];
+        return {
+            exports: [
+                {
+                    name,
+                    // we can't mangle names that are in an empty object
+                    // because one could access the prototype property
+                    // when export isn't set yet
+                    canMangle: !(name in EMPTY_OBJECT),
+                },
+            ],
+            dependencies: undefined,
+        };
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.valueRange);
+        write(this.base);
+        write(this.names);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.valueRange = read();
+        this.base = read();
+        this.names = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(CommonJsExportsDependency, 'mp-compiler/core/dependencies/CommonJsExportsDependency');
+CommonJsExportsDependency.Template = class CommonJsExportsDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, moduleGraph, initFragments, runtimeRequirements, runtime }) {
+        const dep = dependency;
+        const used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+        const [type, base] = (0, CommonJsDependencyHelpers_1.handleDependencyBase)(dep.base, module, runtimeRequirements);
+        switch (type) {
+            case 'expression':
+                if (!used) {
+                    initFragments.push(new InitFragment_1.default('var __webpack_unused_export__;\n', InitFragment_1.default.STAGE_CONSTANTS, 0, '__webpack_unused_export__'));
+                    source.replace(dep.range[0], dep.range[1] - 1, '__webpack_unused_export__');
+                    return;
+                }
+                source.replace(dep.range[0], dep.range[1] - 1, `${base}${(0, propertyAccess_1.default)(used)}`);
+                return;
+            case 'Object.defineProperty':
+                if (!used) {
+                    initFragments.push(new InitFragment_1.default('var __webpack_unused_export__;\n', InitFragment_1.default.STAGE_CONSTANTS, 0, '__webpack_unused_export__'));
+                    source.replace(dep.range[0], dep.valueRange[0] - 1, '__webpack_unused_export__ = (');
+                    source.replace(dep.valueRange[1], dep.range[1] - 1, ')');
+                    return;
+                }
+                source.replace(dep.range[0], dep.valueRange[0] - 1, `Object.defineProperty(${base}${(0, propertyAccess_1.default)(used.slice(0, -1))}, ${JSON.stringify(used[used.length - 1])}, (`);
+                source.replace(dep.valueRange[1], dep.range[1] - 1, '))');
+        }
+    }
+};
+exports.default = CommonJsExportsDependency;

package/dist/dependencies/commonjs/CommonJsExportsParserPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class CommonJsExportsParserPlugin {
+    moduleGraph: any;
+    constructor(moduleGraph: any);
+    apply(parser: any): void;
+}
+export default CommonJsExportsParserPlugin;

package/dist/dependencies/commonjs/CommonJsExportsParserPlugin.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const formatLocation_1 = __importDefault(require("@/base/formatLocation"));
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const DynamicExports = __importStar(require("@/dependencies/DynamicExports"));
+const HarmonyExports = __importStar(require("@/dependencies/harmony/HarmonyExports"));
+const ModuleDecoratorDependency_1 = __importDefault(require("@/dependencies/ModuleDecoratorDependency"));
+const CommonJsExportRequireDependency_1 = __importDefault(require("./CommonJsExportRequireDependency"));
+const CommonJsExportsDependency_1 = __importDefault(require("./CommonJsExportsDependency"));
+const CommonJsSelfReferenceDependency_1 = __importDefault(require("./CommonJsSelfReferenceDependency"));
+/**
+ * This function takes a generic expression and detects whether it is an ObjectExpression.
+ * This is used in the context of parsing CommonJS exports to get the value of the property descriptor
+ * when the `exports` object is assigned to `Object.defineProperty`.
+ *
+ * In CommonJS modules, the `exports` object can be assigned to `Object.defineProperty` and therefore
+ * webpack has to detect this case and get the value key of the property descriptor. See the following example
+ * for more information: https://astexplorer.net/#/gist/83ce51a4e96e59d777df315a6d111da6/8058ead48a1bb53c097738225db0967ef7f70e57
+ *
+ * This would be an example of a CommonJS module that exports an object with a property descriptor:
+ * ```js
+ * Object.defineProperty(exports, "__esModule", { value: true });
+ * exports.foo = void 0;
+ * exports.foo = "bar";
+ * ```
+ */
+const getValueOfPropertyDescription = expr => {
+    if (expr.type !== 'ObjectExpression')
+        return;
+    for (const property of expr.properties) {
+        if (property.computed)
+            continue;
+        const key = property.key;
+        if (key.type !== 'Identifier' || key.name !== 'value')
+            continue;
+        return property.value;
+    }
+};
+/**
+ * The purpose of this function is to check whether an expression is a truthy literal or not. This is
+ * useful when parsing CommonJS exports, because CommonJS modules can export any value, including falsy
+ * values like `null` and `false`. However, exports should only be created if the exported value is truthy.
+ *
+ */
+const isTruthyLiteral = expr => {
+    switch (expr.type) {
+        case 'Literal':
+            return !!expr.value;
+        case 'UnaryExpression':
+            if (expr.operator === '!')
+                return isFalsyLiteral(expr.argument);
+    }
+    return false;
+};
+/**
+ * The purpose of this function is to check whether an expression is a falsy literal or not. This is
+ * useful when parsing CommonJS exports, because CommonJS modules can export any value, including falsy
+ * values like `null` and `false`. However, exports should only be created if the exported value is truthy.
+ */
+const isFalsyLiteral = expr => {
+    switch (expr.type) {
+        case 'Literal':
+            return !expr.value;
+        case 'UnaryExpression':
+            if (expr.operator === '!')
+                return isTruthyLiteral(expr.argument);
+    }
+    return false;
+};
+const parseRequireCall = (parser, expr) => {
+    const ids = [];
+    while (expr.type === 'MemberExpression') {
+        if (expr.object.type === 'Super')
+            return;
+        if (!expr.property)
+            return;
+        const prop = expr.property;
+        if (expr.computed) {
+            if (prop.type !== 'Literal')
+                return;
+            ids.push(`${prop.value}`);
+        }
+        else {
+            if (prop.type !== 'Identifier')
+                return;
+            ids.push(prop.name);
+        }
+        expr = expr.object;
+    }
+    if (expr.type !== 'CallExpression' || expr.arguments.length !== 1)
+        return;
+    const callee = expr.callee;
+    if (callee.type !== 'Identifier' || parser.getVariableInfo(callee.name) !== 'require') {
+        return;
+    }
+    const arg = expr.arguments[0];
+    if (arg.type === 'SpreadElement')
+        return;
+    const argValue = parser.evaluateExpression(arg);
+    return { argument: argValue, ids: ids.reverse() };
+};
+class CommonJsExportsParserPlugin {
+    constructor(moduleGraph) {
+        this.moduleGraph = moduleGraph;
+    }
+    apply(parser) {
+        const enableStructuredExports = () => {
+            DynamicExports.enable(parser.state);
+        };
+        const checkNamespace = (topLevel, members, valueExpr) => {
+            if (!DynamicExports.isEnabled(parser.state))
+                return;
+            if (members.length > 0 && members[0] === '__esModule') {
+                if (valueExpr && isTruthyLiteral(valueExpr) && topLevel) {
+                    DynamicExports.setFlagged(parser.state);
+                }
+                else {
+                    DynamicExports.setDynamic(parser.state);
+                }
+            }
+        };
+        const bailout = (reason) => {
+            DynamicExports.bailout(parser.state);
+            if (reason)
+                bailoutHint(reason);
+        };
+        const bailoutHint = reason => {
+            this.moduleGraph
+                .getOptimizationBailout(parser.state.module)
+                .push(`CommonJS bailout: ${reason}`);
+        };
+        // metadata //
+        parser.hooks.evaluateTypeof
+            .for('module')
+            .tap('CommonJsExportsParserPlugin', (0, JavascriptParserHelpers_1.evaluateToString)('object'));
+        parser.hooks.evaluateTypeof.for('exports').tap('CommonJsPlugin', (0, JavascriptParserHelpers_1.evaluateToString)('object'));
+        // exporting //
+        const handleAssignExport = (expr, base, members) => {
+            if (HarmonyExports.isEnabled(parser.state))
+                return;
+            // Handle reexporting
+            const requireCall = parseRequireCall(parser, expr.right);
+            if ((requireCall === null || requireCall === void 0 ? void 0 : requireCall.argument.isString()) &&
+                (members.length === 0 || members[0] !== '__esModule')) {
+                enableStructuredExports();
+                // It's possible to reexport __esModule, so we must convert to a dynamic module
+                if (members.length === 0)
+                    DynamicExports.setDynamic(parser.state);
+                const dep = new CommonJsExportRequireDependency_1.default(expr.range, null, base, members, requireCall.argument.string, requireCall.ids, !parser.isStatementLevelExpression(expr));
+                dep.loc = expr.loc;
+                dep.optional = !!parser.scope.inTry;
+                parser.state.module.addDependency(dep);
+                return true;
+            }
+            if (members.length === 0)
+                return;
+            enableStructuredExports();
+            const remainingMembers = members;
+            checkNamespace(parser.statementPath.length === 1 && parser.isStatementLevelExpression(expr), remainingMembers, expr.right);
+            const dep = new CommonJsExportsDependency_1.default(expr.left.range, null, base, remainingMembers);
+            dep.loc = expr.loc;
+            parser.state.module.addDependency(dep);
+            parser.walkExpression(expr.right);
+            return true;
+        };
+        parser.hooks.assignMemberChain
+            .for('exports')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => handleAssignExport(expr, 'exports', members));
+        parser.hooks.assignMemberChain
+            .for('this')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => {
+            if (!parser.scope.topLevelScope)
+                return;
+            return handleAssignExport(expr, 'this', members);
+        });
+        parser.hooks.assignMemberChain
+            .for('module')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => {
+            if (members[0] !== 'exports')
+                return;
+            return handleAssignExport(expr, 'module.exports', members.slice(1));
+        });
+        parser.hooks.call
+            .for('Object.defineProperty')
+            .tap('CommonJsExportsParserPlugin', expression => {
+            const expr = expression;
+            if (!parser.isStatementLevelExpression(expr))
+                return;
+            if (expr.arguments.length !== 3)
+                return;
+            if (expr.arguments[0].type === 'SpreadElement')
+                return;
+            if (expr.arguments[1].type === 'SpreadElement')
+                return;
+            if (expr.arguments[2].type === 'SpreadElement')
+                return;
+            const exportsArg = parser.evaluateExpression(expr.arguments[0]);
+            if (!exportsArg.isIdentifier())
+                return;
+            if (exportsArg.identifier !== 'exports' &&
+                exportsArg.identifier !== 'module.exports' &&
+                (exportsArg.identifier !== 'this' || !parser.scope.topLevelScope)) {
+                return;
+            }
+            const propertyArg = parser.evaluateExpression(expr.arguments[1]);
+            const property = propertyArg.asString();
+            if (typeof property !== 'string')
+                return;
+            enableStructuredExports();
+            const descArg = expr.arguments[2];
+            checkNamespace(parser.statementPath.length === 1, [property], getValueOfPropertyDescription(descArg));
+            const dep = new CommonJsExportsDependency_1.default(expr.range, expr.arguments[2].range, `Object.defineProperty(${exportsArg.identifier})`, [property]);
+            dep.loc = expr.loc;
+            parser.state.module.addDependency(dep);
+            parser.walkExpression(expr.arguments[2]);
+            return true;
+        });
+        // Self reference //
+        const handleAccessExport = (expr, base, members, call = undefined) => {
+            if (HarmonyExports.isEnabled(parser.state))
+                return;
+            if (members.length === 0) {
+                bailout(`${base} is used directly at ${(0, formatLocation_1.default)(expr.loc)}`);
+            }
+            if (call && members.length === 1) {
+                bailoutHint(`${base}${(0, propertyAccess_1.default)(members)}(...) prevents optimization as ${base} is passed as call context at ${(0, formatLocation_1.default)(expr.loc)}`);
+            }
+            const dep = new CommonJsSelfReferenceDependency_1.default(expr.range, base, members, !!call);
+            dep.loc = expr.loc;
+            parser.state.module.addDependency(dep);
+            if (call) {
+                parser.walkExpressions(call.arguments);
+            }
+            return true;
+        };
+        parser.hooks.callMemberChain
+            .for('exports')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => handleAccessExport(expr.callee, 'exports', members, expr));
+        parser.hooks.expressionMemberChain
+            .for('exports')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => handleAccessExport(expr, 'exports', members));
+        parser.hooks.expression.for('exports').tap('CommonJsExportsParserPlugin', expr => handleAccessExport(expr, 'exports', []));
+        parser.hooks.callMemberChain
+            .for('module')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => {
+            if (members[0] !== 'exports')
+                return;
+            return handleAccessExport(expr.callee, 'module.exports', members.slice(1), expr);
+        });
+        parser.hooks.expressionMemberChain
+            .for('module')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => {
+            if (members[0] !== 'exports')
+                return;
+            return handleAccessExport(expr, 'module.exports', members.slice(1));
+        });
+        parser.hooks.expression.for('module.exports').tap('CommonJsExportsParserPlugin', expr => handleAccessExport(expr, 'module.exports', []));
+        parser.hooks.callMemberChain.for('this').tap('CommonJsExportsParserPlugin', (expr, members) => {
+            if (!parser.scope.topLevelScope)
+                return;
+            return handleAccessExport(expr.callee, 'this', members, expr);
+        });
+        parser.hooks.expressionMemberChain
+            .for('this')
+            .tap('CommonJsExportsParserPlugin', (expr, members) => {
+            if (!parser.scope.topLevelScope)
+                return;
+            return handleAccessExport(expr, 'this', members);
+        });
+        parser.hooks.expression.for('this').tap('CommonJsExportsParserPlugin', expr => {
+            if (!parser.scope.topLevelScope)
+                return;
+            return handleAccessExport(expr, 'this', []);
+        });
+        // Bailouts //
+        parser.hooks.expression.for('module').tap('CommonJsPlugin', expr => {
+            bailout();
+            const isHarmony = HarmonyExports.isEnabled(parser.state);
+            const dep = new ModuleDecoratorDependency_1.default(isHarmony ? RuntimeGlobals.harmonyModuleDecorator : RuntimeGlobals.nodeModuleDecorator, !isHarmony);
+            dep.loc = expr.loc;
+            parser.state.module.addDependency(dep);
+            return true;
+        });
+    }
+}
+exports.default = CommonJsExportsParserPlugin;