// commonjs、amd等模块化方案中，导入导出是动态的，难以预测
if (flag) {
   require('foo.js');
   exports.foo = 'foo';
}

// es module 下面代码非法，因为导入导出是静态的，不允许放到if等判断条件内
if (flag) {
   import foo from 'foo.js';
   exports const bar = 'bar';
}

export class V6Engine {
  toString() {
    return 'V6';
  }
}

export class V8Engine {
  toString() {
    return 'V8';
  }
}

export function getVersion() {
  return '1.0';
}

import { V8Engine } from './engine';

class SportsCar {
  constructor(engine) {
    this.engine = engine;
  }

  toString() {
    return this.engine.toString() + ' Sports Car';
  }
}

console.log(new SportsCar(new V8Engine()).toString());

(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export getVersion */
class V6Engine {
  toString() {
    return 'V6';
  }
}
/* unused harmony export V6Engine */

class V8Engine {
  toString() {
    return 'V8';
  }
}
/* harmony export (immutable) */ __webpack_exports__["a"] = V8Engine;

function getVersion() {
  return '1.0';
}

/***/ }),
/* 1 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__engine__ = __webpack_require__(0);

class SportsCar {
  constructor(engine) {
    this.engine = engine;
  }

  toString() {
    return this.engine.toString() + ' Sports Car';
  }
}

console.log(new SportsCar(new __WEBPACK_IMPORTED_MODULE_0__engine__["a" /* V8Engine */]()).toString());

/***/ })

- ["es2015", { "modules": 'cjs' }]
+ ["es2015", { "modules": false }]

module: {
  rules: [
    { test: /\.js$/, loader: 'babel-loader' }
  ]
},

plugins: [
  new webpack.LoaderOptionsPlugin({
    minimize: true,
    debug: false
  }),
  new webpack.optimize.UglifyJsPlugin({
    compress: {
      warnings: true
    },
    output: {
      comments: false
    },
    sourceMap: false
  })
]

! function (n) {
  function t(e) {
    if (r[e]) return r[e].exports;
    var o = r[e] = {
      i: e,
      l: !1,
      exports: {}
    };
    return n[e].call(o.exports, o, o.exports, t), o.l = !0, o.exports
  }
  var r = {};
  t.m = n, t.c = r, t.i = function (n) {
    return n
  }, t.d = function (n, r, e) {
    t.o(n, r) || Object.defineProperty(n, r, {
      configurable: !1,
      enumerable: !0,
      get: e
    })
  }, t.n = function (n) {
    var r = n && n.__esModule ? function () {
      return n.default
    } : function () {
      return n
    };
    return t.d(r, "a", r), r
  }, t.o = function (n, t) {
    return Object.prototype.hasOwnProperty.call(n, t)
  }, t.p = "", t(t.s = 2)
}([function (n, t, r) {
  "use strict";
  t.__esModule = !0, t.default = function (n, t) {
    if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function")
  }
}, function (n, t, r) {
  "use strict";
  r.d(t, "a", function () {
    return u
  });
  var e = r(0),
    o = r.n(e),
    u = (function () {
      function n() {
        o()(this, n)
      }
      n.prototype.toString = function () {
        return "V6"
      }
    }(), function () {
      function n() {
        o()(this, n)
      }
      return n.prototype.toString = function () {
        return "V8"
      }, n
    }())
}, function (n, t, r) {
  "use strict";
  Object.defineProperty(t, "__esModule", {
    value: !0
  });
  var e = r(0),
    o = r.n(e),
    u = r(1),
    i = function () {
      function n(t) {
        o()(this, n), this.engine = t
      }
      return n.prototype.toString = function () {
        return this.engine.toString() + " Sports Car"
      }, n
    }();
  console.log(new i(new u.a).toString())
}]);

var V6Engine = function () {
  function V6Engine() {
    _classCallCheck(this, V6Engine);
  }

  V6Engine.prototype.toString = function toString() {
    return 'V6';
  };

  return V6Engine;
}();

var V6Engine = /*#__PURE__*/function () {
  function V6Engine() {
    _classCallCheck(this, V6Engine);
  }

  V6Engine.prototype.toString = function toString() {
    return 'V6';
  };

  return V6Engine;
}();

// a.js
export const a = 'a'

window.abc = 'abc'

Arrary.prototype.sum = function () {
  return a + b;
}

// index.js
import a from './a'

sum(1, 2)

// index.js
export { a } from "./a";
export { b } from "./b";
console.log();

// a.js
export const a = 'a'

// b.js
export const b = 'b'
console.log('side effect');

// 项目app.js
import { a } from 'big-module'

console.log(a);

if (options.optimization.providedExports) {
  const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
  new FlagDependencyExportsPlugin().apply(compiler);
}
if (options.optimization.usedExports) {
  const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin");
  new FlagDependencyUsagePlugin(
    options.optimization.usedExports === "global"
  ).apply(compiler);
}

// 在finishModules 钩子内处理，此时所有的模块已经全部转化成module实例
compilation.hooks.finishModules.tapAsync

let exportsInfo;
while (modules.length > 0) {
  // 通过module获取moduleGraphModule.exports对象
  exportsInfo = moduleGraph.getExportsInfo(module);
  
  // 获取module下原始的dependcy
  processDependenciesBlock(module);
  for (const [
    dep,
    exportsSpec
  ] of exportsSpecsFromDependencies) {
    // 将原始的dependcy转化成exportInfo,并将exportInfo设置到exportsInfo，便于后续usedExport的时候用到
    processExportsSpec(dep, exportsSpec);
  }
}

const processDependenciesBlock = depBlock => {
  // 遍历所有module的依赖项，比如index.js 引入 import {V8Engine} from './engine' 如下所示
  // [
  //   {
  //     request: "./engine",
  //     ids: [
  //       "V8Engine",
  //     ],
  //     name: "V8Engine",
  //   }
  // ]
  for (const dep of depBlock.dependencies) {
    processDependency(dep);   
  }
};

const processDependency = dep => {
  // 获取模块export的值
  const exportDesc = dep.getExports(moduleGraph);
  if (!exportDesc) return;
  exportsSpecsFromDependencies.set(dep, exportDesc);
};

const processExportsSpec = (dep, exportDesc) {
  // 如果name对应的exportInfo在exportsInfo上没有，则new ExportInfo，并设置到exportsInfo上
  const exportInfo = exportsInfo.getExportInfo(name);

}

compilation.hooks.optimizeDependencies.tap

const queue = new TupleQueue();

// 从entry模块开始遍历，然后将entryModule推到queue队列
for of compilation.entries

// 将entrymodule推到queue队列
queue.enqueue(entrymodule, runtime);

// 从入口模块开始 遍历
while (queue.length) {
  const [module, runtime] = queue.dequeue();
  processModule(module, runtime, false);
}

// 获取模块的依赖项，即模块impport的依赖模块，然后进行遍历
for of block.dependencies

// 根据依赖然后从moduleGraph的_depenciesMap内获取到ModuleGraphConnection
// ModuleGraphConnection.module 获取当前模块信息，ModuleGraphConnection.originModule获取父模块信息
const connection = moduleGraph.getConnection(dep);

// HarmonyImportSideEffectDependency => false
// HarmonyImportSpecifierDependency => true
const activeState = connection.getActiveState(runtime);
if (activeState === false) continue;

// 根据depency实例获取对应的导出名称
const referencedExports = compilation.getDependencyReferencedExports(dep, runtime);

// 存储module与导出的exportInfo信息,这里的referencedExports就是当前模块内被使用的依赖模块的exportName
// {
  module => {
    exportName: [exportName]
  }
}
// 比如index.js import A from './a'; import B from './b'; console.log(A)
// 那么 module 则是a.js 对应的referencedExports{"A" => [A]}
map.set(module, referencedExports);


// 然后遍历map对象
for (const [module, referencedExports] of map) {
  processReferencedModule(
      module,
      Array.from(referencedExports.values()),
      runtime,
      forceSideEffects
  );
}

// 在processReferencedModule方法内，通过moduleGraph与module获取当前module的所有exportsInfo
const exportsInfo = moduleGraph.getExportsInfo(module);

// 遍历在父模块内使用的export
for of usedExports

const UsageState: Readonly<{
    Unused: 0;
    OnlyPropertiesUsed: 1;
    NoInfo: 2;
    Unknown: 3;
    Used: 4;
}>

// 然后将当前模块的exportInfo设置成Used
exportInfo.setUsedConditionally(
  v => v !== UsageState.Used,
  UsageState.Used,
  runtime
)

// 设置成功之后会在_useInRuntime添加状态
exportInfo._useInRuntime = new Map({0: {app => 4}})

// 让后再将当前子模块推到queue，继续根据当前子模块内使用的dependy转化成包含子子模块的模块与，子模块使用了的referencedExports map对象
queue.enqueue(currentModule, runtime);

generate

// 生成代码的时候，会调用每个模块的sourceModule方法生成模块代码
this.sourceModule(module, initFragments, source, generateContext);

// 遍历模块依赖，生成依赖项代码
for (const dependency of module.dependencies) {
  this.sourceDependency(
    module,
    dependency,
    initFragments,
    source,
    generateContext
  );
}

const template = generateContext.dependencyTemplates.get(constructor);

template.apply(dependency, source, templateContext);

const used = moduleGraph
  .getExportsInfo(module) // 获取ModuleGraphModule.exports
  .getUsedName(dep.name, runtime); // 回去ExportsInfo._exports._usedInRuntime 在FlagDependencyUsagePlugin插件内如果有使用则有值

if (!used) {
  const set = new Set();
  set.add(dep.name || "namespace");
  initFragments.push(
    new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
  );
  return;
}

const map = new Map();
map.set(used, `/* binding */ ${dep.id}`);
initFragments.push(
  new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
);

InitFragment.addToSource(source, initFragments, generateContext);

concatSource.add(fragment.getContent(context));

const unusedPart =
      this.unusedExports.size > 1
      ? `/* unused harmony exports ${joinIterableWithComma(
        this.unusedExports
      )} */\n`
      : this.unusedExports.size > 0
      ? `/* unused harmony export ${first(this.unusedExports)} */\n`
      : "";
const definitions = [];
const orderedExportMap = Array.from(this.exportMap).sort(([a], [b]) =>
                                                         a < b ? -1 : 1
                                                        );
for (const [key, value] of orderedExportMap) {
  definitions.push(
    `\n/* harmony export */   ${JSON.stringify(
      key
    )}: ${runtimeTemplate.returningFunction(value)}`
  );
}
const definePart =
      this.exportMap.size > 0
? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
this.exportsArgument
}, {${definitions.join(",")}\n/* harmony export */ });\n`
: "";
return `${definePart}${unusedPart}`;

if (options.optimization.sideEffects) {
  const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin");
  new SideEffectsFlagPlugin(
    options.optimization.sideEffects === true
  ).apply(compiler);
}

compiler.hooks.compilation.tap
  normalModuleFactory.hooks.module.tap
    const sideEffects = resolveData.descriptionFileData.sideEffects;
    module.factoryMeta.sideEffectFree = !sideEffects;

  normalModuleFactory.hooks.parser.for('javascript/auto').tap
    parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
      sideEffectsStatement = undefined;
    });
    parser.hooks.statement.tap(
      { name: "SideEffectsFlagPlugin", stage: -100 },
      statement => {
        if (sideEffectsStatement) return;
        if (parser.scope.topLevelScope !== true) return;
        switch (statement.type) {
          case "ExpressionStatement":
            if (
              !parser.isPure(statement.expression, statement.range[0])
            ) {
              sideEffectsStatement = statement;
            }
            break;
          case "VariableDeclaration":
          case "ClassDeclaration":
          case "FunctionDeclaration":
            if (!parser.isPure(statement, statement.range[0])) {
              sideEffectsStatement = statement;
            }
            break;
          default:
            sideEffectsStatement = statement;
            break;
        }
      }
    );
    parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
      if (sideEffectsStatement === undefined) {
        parser.state.module.buildMeta.sideEffectFree = true;
      } else {
        const { loc, type } = sideEffectsStatement;
        moduleGraph
          .getOptimizationBailout(parser.state.module)
          .push(
          () =>
          `Statement (${type}) with side effects in source code at ${formatLocation(
            loc
          )}`
        );
      }
    });

// 构建chunkGraph
buildChunkGraph

// 根据entry module提取依赖module
extractBlockModules

// 根据当前模块的outgoingConnections获取到当前模块的依赖，并遍历这些依赖
for of moduleGraph.getOutgoingConnections(module)

// 获取当前module的状态
const state = connection.getActiveState(runtime);

// 调用当前模块的getSideEffectsConnectionState获取当前模块状态
refModule.getSideEffectsConnectionState(moduleGraph);

getSideEffectsConnectionState(moduleGraph) {
  // 如果设置了sideEffects: false 这里的this.factoryMeta.sideEffectFree=true
  if (this.factoryMeta !== undefined) {
    if (this.factoryMeta.sideEffectFree) return false;
    if (this.factoryMeta.sideEffectFree === false) return true;
  }
  
  // 如果没有设置sideEffects,则通过sideEffects插件在webpack解析ast的过程，如果判定模块没有副作用this.buildMeta.sideEffectFree=true
  if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
    if (this._isEvaluatingSideEffects)
      return ModuleGraphConnection.CIRCULAR_CONNECTION;
    this._isEvaluatingSideEffects = true;
    /** @type {ConnectionState} */
    let current = false;
    for (const dep of this.dependencies) {
      const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
      if (state === true) {
        this._isEvaluatingSideEffects = false;
        return true;
      } else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
        current = ModuleGraphConnection.addConnectionStates(current, state);
      }
    }
    this._isEvaluatingSideEffects = false;
    // When caching is implemented here, make sure to not cache when
    // at least one circular connection was in the loop above
    return current;
  } else {
    // 其它情况，需要包含当前module
    return true;
  }
}


// 如果模块状态为false，则该模块不会被包含进当前chunk
if (state === false) continue;

const buildTerserOptions = (terserOptions = {}) => {
    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
    return {
      ...terserOptions,
      compress:
        typeof terserOptions.compress === "boolean"
          ? terserOptions.compress
          : { ...terserOptions.compress },
      // ecma: terserOptions.ecma,
      // ie8: terserOptions.ie8,
      // keep_classnames: terserOptions.keep_classnames,
      // keep_fnames: terserOptions.keep_fnames,
      mangle:
        terserOptions.mangle == null
          ? true
          : typeof terserOptions.mangle === "boolean"
          ? terserOptions.mangle
          : { ...terserOptions.mangle },
      // module: terserOptions.module,
      // nameCache: { ...terserOptions.toplevel },
      // the `output` option is deprecated
      ...(terserOptions.format
        ? { format: { beautify: false, ...terserOptions.format } }
        : { output: { beautify: false, ...terserOptions.output } }),
      parse: { ...terserOptions.parse },
      // safari10: terserOptions.safari10,
      // Ignoring sourceMap from options
      // eslint-disable-next-line no-undefined
      sourceMap: undefined,
      // toplevel: terserOptions.toplevel
    };
  };

const { minify } = require("terser");
// Copy `terser` options
const terserOptions = buildTerserOptions(minimizerOptions);
const result = await minify({ [filename]: code }, terserOptions);

 const buildUglifyJsOptions = (uglifyJsOptions = {}) => {
    // eslint-disable-next-line no-param-reassign
    delete minimizerOptions.ecma;
    // eslint-disable-next-line no-param-reassign
    delete minimizerOptions.module;

    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
    return {
      ...uglifyJsOptions,
      // warnings: uglifyJsOptions.warnings,
      parse: { ...uglifyJsOptions.parse },
      compress:
        typeof uglifyJsOptions.compress === "boolean"
          ? uglifyJsOptions.compress
          : { ...uglifyJsOptions.compress },
      mangle:
        uglifyJsOptions.mangle == null
          ? true
          : typeof uglifyJsOptions.mangle === "boolean"
          ? uglifyJsOptions.mangle
          : { ...uglifyJsOptions.mangle },
      output: { beautify: false, ...uglifyJsOptions.output },
      // Ignoring sourceMap from options
      // eslint-disable-next-line no-undefined
      sourceMap: undefined,
      // toplevel: uglifyJsOptions.toplevel
      // nameCache: { ...uglifyJsOptions.toplevel },
      // ie8: uglifyJsOptions.ie8,
      // keep_fnames: uglifyJsOptions.keep_fnames,
    };
  };
const { minify } = require("uglify-js");

// Copy `uglify-js` options
const uglifyJsOptions = buildUglifyJsOptions(minimizerOptions);
const result = await minify({ [filename]: code }, uglifyJsOptions);

function fn() {
  return 1;
  const a = 'a'; // dead_code
  for () {}
}

function f(x, y) {
  function g() { // unused
    something();
  }
  return x + y;
}

module.exports = {
  //...
  resolve: {
    // module推荐放到main前面，因为大部分npm包提供了es module模块，而es module入口约定通过module字段暴露
    mainFields: ['browser', 'module', 'main'],
  },
};

// babel.config.js

module.exports = {
  "presets": [
    ["@babel/preset-env", {
      "loose": true,
      "modules": false // 配置成false or auto，避免babel将模块转化成commonjs模块
    }]
  ]
}

import { getVersion } from './used-no-sideEffect';

const newGetversion = getVersion

export default {
    bar: 'bar',
    foo: 'foo'
}

const bar = 'bar'
const foo = 'foo'

export {
    bar,
    foo
}

{
  "name": "awesome npm module",
  "version": "1.0.0",
  "sideEffects": false
}

{
  "name": "@abc/yked",
  "version": "2.5.6",
  "description": "租户后台公用组件库",
  "main": "lib/index.js",
  "module": "es/index.js",
  "types": "lib/index.d.ts",
  "sideEffects": [
    "lib/index.js",
    "es/index.js",
    "*.less"
  ]
}

// index.js
import { initHotIconfont } from '@abc/yk-hot-iconfont';
import { setDomainUrl } from './utils/set-domain-url';

// 设置使用方a标签跳转带有token和mini_app_id
setDomainUrl();

// 初始化热更新iconfont
initHotIconfont({
  pid: [48757, 83033, 84450], // 项目pid
  fileType: 'css', // 'js' | 'css' 引入的文件类型
});

export * from './components';
export * from './decorator';

{
  "name": "app",
  "version": "1.0.0",
  "sideEffects": [
    '*.css',
    'run.js' // 添加需要保留副作用的模块
  ]
}

module.exports = class AddSideEffectsPlugin {
  constructor({
    includePackages = [], // 传入需要处理的npm package name
  } = {}) {
    this.includePackages = includePackages;
  }
  apply(compiler /*: any */) {
    const name = this.constructor.name;
    const { context } = compiler;
    compiler.hooks.normalModuleFactory.tap(name, normalModuleFactory => {
      normalModuleFactory.hooks.module.tap(name, (module, data) => {
        const resolveData = data.resourceResolveData;
        
        // 如果npm包没有设置sideEffects，且满足includePackages，就设置sideEffectFree: true,表示该模块是纯的
        if (
          this.includePackages.some((item) => data.resource.include(item)),
          resolveData &&
          resolveData.descriptionFileData &&
          resolveData.descriptionFileData.sideEffects === void 0
        ) {
          module.factoryMeta.sideEffectFree = true;
        }
      });
    });
  }
};