// b.js
export default B = 'b';

// a.js
import B from './b';
console.log(B);
export const A = 'a';

// index.js
import { A } from './a';
console.log(A);

(function(modules) { // webpackBootstrap
    // ...

    // Load entry module and return exports
    return __webpack_require__(__webpack_require__.s = "./src/index.js");
})(
    {
    "./src/a.js": (function(module, __webpack_exports__, __webpack_require__) {},
    "./src/b.js": (function(module, __webpack_exports__, __webpack_require__) {},
    "./src/index.js": (function(module, __webpack_exports__, __webpack_require__) {}
    }
)

// The require function
function __webpack_require__(moduleId) {

    // Check if module is in cache
    if(installedModules[moduleId]) {
        return installedModules[moduleId].exports;
    }
    // Create a new module (and put it into the cache)
    var module = installedModules[moduleId] = {
        i: moduleId,
        l: false,
        exports: {}
    };

    // Execute the module function
    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

    // Flag the module as loaded
    module.l = true;

    // Return the exports of the module
    return module.exports;
}

/***/ "./src/index.js":
/*!**********************!*\
  !*** ./src/index.js ***!
  \**********************/
/*! no exports provided */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _a__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./a */ \"./src/a.js\");\n\nconsole.log(_a__WEBPACK_IMPORTED_MODULE_0__[\"A\"]);\n\n//# sourceURL=webpack:///./src/index.js?");

/***/ })

"./src/index.js":
(function(module, __webpack_exports__, __webpack_require__) {

    "use strict";
    __webpack_require__.r(__webpack_exports__);
    var _a__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/a.js");
    console.log(_a__WEBPACK_IMPORTED_MODULE_0__["A"]);

})

"./src/a.js":
(function(module, __webpack_exports__, __webpack_require__) {

    "use strict";
    __webpack_require__.r(__webpack_exports__);
    __webpack_require__.d(__webpack_exports__, "A", function() { return A; });
    var _b__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/b.js");
    console.log(_b__WEBPACK_IMPORTED_MODULE_0__["default"]);
    const A = 'a';
}),

"./src/b.js":
(function(module, __webpack_exports__, __webpack_require__) {
    "use strict";
    __webpack_require__.r(__webpack_exports__);
    __webpack_exports__["default"] = (B = 'b');
}),

// define __esModule on exports
__webpack_require__.r = function(exports) {
    if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
        Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
    }
    Object.defineProperty(exports, '__esModule', { value: true });
};
// define getter function for harmony exports
__webpack_require__.d = function(exports, name, getter) {
    if(!__webpack_require__.o(exports, name)) {
        Object.defineProperty(exports, name, { enumerable: true, get: getter });
    }
};
// Object.prototype.hasOwnProperty.call
__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

function objectFactory(...args) {

    // 取出第一个参数（构造器），并从参数中删除。
    const Constructor = args.shift();

    // 创建一个空对象，并将空对象的_proto_属性指向构造函数的 prototype 属性
    // 不建议直接操作_proto_属性（obj.__proto__ = Constructor.prototype）
    const obj = Object.create(constructor.prototype);

    // 执行构造器， 将构造函数内的 this 指向为 obj
    var result = Constructor.apply(obj, args); 

    // 如果构造器返回对象则返回这个对象，否则返回新建的对象。
    return (typeof result === 'object' && result != null) ? result : obj; 
};

// 使用方式
function Person(name) {
  this.name = name
}
const person = new objectFactory(Person, 'season')
console.log(person)

Child.prototype = new Parent()

function Child(name) {
    this.name = name;
}
Child.prototype = new Parent()
function Parent(name) {
    this.name = name;
    this.list = [1, 2, 3];
}
Parent.prototype.getName = function() {
    return this.name
}

var child1 = new Child('child1');
console.log(child1.getName()); // child1
child1.list.push(4);

var child2 = new Child('child2');
console.log(child2.getName()); // child2
console.log(child2.list); // [1, 2, 3, 4]

function Child (args) {
    // ...
    Parent.call(this, args)
}

function Child(name, args) {
    this.name = name;
    Parent.call(this, args)
}

function Parent(name) {
    this.name = name;
    this.list = [1, 2, 3];
}
Parent.prototype.getName = function() {
    return this.name
}

var child1 = new Child('child1', 'parent1');
console.log(child1.getName()); // Uncaught TypeError: child1.getName is not a function
child1.list.push(4);
console.log(child1.list) // [1, 2, 3, 4]

var child2 = new Child('child2', 'parent2');
console.log(child2.list); // [1, 2, 3]

function Child (args1, args2) {
    // ...
    this.args1 = args1
    Parent.call(this, args2)
}
Child.prototype = new Parent()
Child.prototype.constrcutor = Child

function Child(name, args) {
    this.name = name;
    Parent.call(this, args)
}
Child.prototype = new Parent();
Child.prototype.constrcutor = Child;
function Parent(name) {
    this.name = name;
    this.list = [1, 2, 3];
}
Parent.prototype.getName = function() {
    return this.name
}

var child1 = new Child('child1', 'parent1');
console.log(child1.getName()); // parent1
child1.list.push(4);
console.log(child1.list) // [1, 2, 3, 4]

var child2 = new Child('child2', 'parent2');
console.log(child2.list); // [1, 2, 3]

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}
var parent = {
    name: 'parent',
    list: [1, 2, 3]
}

var child1 = object(parent);
child1.name = "child1";
console.log(child1.name); // 'child1'
child1.list.push(4);
console.log(child1.list); //  [1, 2, 3, 4]

var child2 = object(parent);
console.log(child2.list); // [1, 2, 3, 4]

function createAnother(original){
    var clone = object(original);
    clone.sayHi = function(){  // 以某种方式来增强这个对象，给该对象增加一个 sayHi 方法
        alert("hi");
    };
    return clone;
}

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}
function inheritPrototype(subType, superType){
    var prototype = object(superType.prototype);
    prototype.constructor = subType;
    subType.prototype = prototype;
}
function Parent(name) {
    this.name = name;
    this.list = [1, 2, 3];
}
Parent.prototype.getName = function() {
    return this.name
}

function Child(name, args) {
    this.name = name;
    Parent.call(this, args);  // 通过构造函数来继承属性
}
inheritPrototype(Child, Parent); // 通过寄生式继承来继承父类的原型


var child1 = new Child('child1', 'parent1');
console.log(child1.getName()); // parent1
child1.list.push(4);
console.log(child1.list) // [1, 2, 3, 4]

var child2 = new Child('child2', 'parent2');
console.log(child2.list); // [1, 2, 3]

Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;

class Parent {
    constructor(){
        this.name = 'parent';
        this.list = [1, 2, 3];
    }
    getName() {
        return this.name
    }
}
class Child extends Parent {
    constructor(){
        super()
    }
}
var child1 = new Child();
console.log(child1.name); // parent
console.log(child1.getName())  // parent
child1.list.push(4)  // parent
console.log(child1.list)  // [1, 2, 3, 4]

var child2 = new Child();
console.log(child2.name); // parent
console.log(child2.getName())  // parent
console.log(child2.list)  // [1, 2, 3]

// ... 省略一些方法定义
function _inherits(subClass, superClass) {
    // 父类必须是函数并且不能为null
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function"); 
    } 
    // 通过Object.create实现继承，第二个参数用来修复子类的 constructor
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true 
        } 
    });
    // 设置子类的 __proto__ 属性指向父类
    if (superClass) 
        _setPrototypeOf(subClass, superClass);
}
function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
        o.__proto__ = p; return o;
    };
    return _setPrototypeOf(o, p);
}
// 两个参数，一个参数是指向子类实例的this，另一个参数是 调用父类构造函数的返回值
function _possibleConstructorReturn(self, call) {
    // 如果父类返回的是对象或者函数，则返回 父类构造函数生成的this（Parent.call(this)），否则返回子类的this
    if (call && (_typeof(call) === "object" || typeof call === "function")) {
        return call; 
    } 
    return _assertThisInitialized(self);
}

function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o); 
        };
    return _getPrototypeOf(o);
}


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

    this.name = 'parent';
    this.list = [1, 2, 3];
  }

  _createClass(Parent, [{
    key: "getName",
    value: function getName() {
      return this.name;
    }
  }]);

  return Parent;
}();

var Child =
/*#__PURE__*/
function (_Parent) {
    // 通过 Object.create 实现继承
  _inherits(Child, _Parent);

  function Child() {
      // 确保类是通过 new 作为构造函数调用而不是直接调用
    _classCallCheck(this, Child);
    // _getPrototypeOf(Child) 返回 子类的原型（父类构造函数），通过子类 this 执行父类构造函数的方法
    return _possibleConstructorReturn(this, _getPrototypeOf(Child).call(this));
  }

  return Child;
}(Parent);

var funcs = [];
for(let i = 0; i < 5; i++) {
    funcs.push(function() {
        console.log(i);
    })
}
funcs[3](); // 3

// spread
var a = [2,3,4];
var b = [1, ...a, 5];
console.log(b);   // [1,2,3,4,5]

// rest
function foo(x, y, ...z) {
    console.log(x, y, z)
}
foo(1,2,3,4,5) // 1 2 [3, 4, 5]
// 如果没有明明参数的话，会收集所有的参数
function foo(...args) {
    console.log(args);
}
foo(1,2,3,4,5); // [1,2,3,4,5]

var controller = {
    makeRequest: function() {
        var self = this;
        btn.addEventListner('click', function(){
            // 
            self.makeRequest(...);
        }, false)
    }
}

function foo() {
    // ...
}
export default foo;

function foo() {
    // ...
}
export { foo as default };

typeof null === 'object'
typeof function a() {} === 'function'
var a
typeof a // 'undefined'
typeof b // 'undefined'  // 即使b未声明，也会返回undefined

var a = [];
a['13'] = 42;
a,length; //14

null：指空值；曾经赋过值，但目前没有值；是一个特殊的关键字，不是标识符
undefined：指没有值，从未赋值；是一个标识符，可以被当做变量来使用和赋值

var a = new Boolean(false);
if(!a) {
    console.log('Oops'); // 执行不到这里
}

var vm = new Vue({
    el: '#app',
    data: {
        test: 1
    }
})

// src/core/instance/index.js
function Vue (options) {
  if (process.env.NODE_ENV !== 'production' &&
    !(this instanceof Vue)
  ) {
    warn('Vue is a constructor and should be called with the `new` keyword')
  }
  this._init(options)
}

// src/core/instance/init.js
Vue.prototype._init = function (options?: Object) {
  const vm: Component = this

  // ...

  // merge options
  vm._self = vm
  initLifecycle(vm)
  initEvents(vm)
  initRender(vm)
  callHook(vm, 'beforeCreate')
  initInjections(vm) // resolve injections before data/props
  initState(vm)
  initProvide(vm) // resolve provide after data/props
  callHook(vm, 'created')

  // ...

  if (vm.$options.el) {
    vm.$mount(vm.$options.el)
  }
}

export function initState (vm: Component) {
  vm._watchers = []
  const opts = vm.$options
  if (opts.props) initProps(vm, opts.props)
  if (opts.methods) initMethods(vm, opts.methods)
  if (opts.data) {
    initData(vm)
  } else {
    observe(vm._data = {}, true /* asRootData */)
  }
  if (opts.computed) initComputed(vm, opts.computed)
  if (opts.watch && opts.watch !== nativeWatch) {
    initWatch(vm, opts.watch)
  }
}

// src/platforms/web/runtime/index.js
// public mount method
Vue.prototype.$mount = function (
  el?: string | Element,
  hydrating?: boolean
): Component {
  el = el && inBrowser ? query(el) : undefined
  return mountComponent(this, el, hydrating)
}

// src/platforms/web/entry-runtime-with-compiler.js
const mount = Vue.prototype.$mount
Vue.prototype.$mount = function (
  el?: string | Element,
  hydrating?: boolean
): Component {
  // ...
  return mount.call(this, el, hydrating)
}

// 运行时+编译器
// 需要编译器
new Vue({
  template: '<div>{{ hi }}</div>'
})

// 运行时版本
// 不需要编译器
new Vue({
  render (h) {
    return h('div', this.hi)
  }
})

  el = el && query(el)
/* istanbul ignore if */
if (el === document.body || el === document.documentElement) {
  process.env.NODE_ENV !== 'production' && warn(
    `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
  )
  return this
}

const options = this.$options
// resolve template/el and convert to render function
if (!options.render) {
  let template = options.template
  // 处理 template
  if (template) {
    if (typeof template === 'string') {
      if (template.charAt(0) === '#') {
        template = idToTemplate(template)
        /* istanbul ignore if */
        if (process.env.NODE_ENV !== 'production' && !template) {
          warn(
            `Template element not found or is empty: ${options.template}`,
            this
          )
        }
      }
    } else if (template.nodeType) {
      template = template.innerHTML
    } else {
      if (process.env.NODE_ENV !== 'production') {
        warn('invalid template option:' + template, this)
      }
      return this
    }
  } else if (el) {
    template = getOuterHTML(el)
  }
  if (template) {
    /* istanbul ignore if */
    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
      mark('compile')
    }

    const { render, staticRenderFns } = compileToFunctions(template, {
      outputSourceRange: process.env.NODE_ENV !== 'production',
      shouldDecodeNewlines,
      shouldDecodeNewlinesForHref,
      delimiters: options.delimiters,
      comments: options.comments
    }, this)
    options.render = render
    options.staticRenderFns = staticRenderFns

    /* istanbul ignore if */
    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
      mark('compile end')
      measure(`vue ${this._name} compile`, 'compile', 'compile end')
    }
  }

// src/core/instance/lifecycle.js
export function mountComponent (
  vm: Component,
  el: ?Element,
  hydrating?: boolean
): Component {
  vm.$el = el
  if (!vm.$options.render) {
    vm.$options.render = createEmptyVNode
    // ...
  }
  callHook(vm, 'beforeMount')

  let updateComponent
  /* istanbul ignore if */
  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
    updateComponent = () => {
      // ...
    }
  } else {
    updateComponent = () => {
      vm._update(vm._render(), hydrating)
    }
  }

  new Watcher(vm, updateComponent, noop, {
    before () {
      if (vm._isMounted && !vm._isDestroyed) {
        callHook(vm, 'beforeUpdate')
      }
    }
  }, true /* isRenderWatcher */)

  // manually mounted instance, call mounted on self
  // mounted is called for render-created child components in its inserted hook
  if (vm.$vnode == null) {
    vm._isMounted = true
    callHook(vm, 'mounted')
  }
  return vm
}

updateComponent = () => {
  vm._update(vm._render(), hydrating)
}

// src/core/observer/watcher.js
export default class Watcher {
  // ...
  constructor (
    vm: Component,
    expOrFn: string | Function,
    cb: Function,
    options?: ?Object,
    isRenderWatcher?: boolean
  ) {
    // ...
    if (typeof expOrFn === 'function') {
        this.getter = expOrFn
    } else {
        this.getter = parsePath(expOrFn)
        if (!this.getter) {
            this.getter = function () {}
            process.env.NODE_ENV !== 'production' && warn(
            `Failed watching path: "${expOrFn}" ` +
            'Watcher only accepts simple dot-delimited paths. ' +
            'For full control, use a function instead.',
            vm
            )
        }
    }
    this.value = this.lazy
      ? undefined
      : this.get() // 注意这里

  }
  get () {
    // ...
  }

  // ...
}

get () {
   pushTarget(this)
   let value
   const vm = this.vm
   try {
     value = this.getter.call(vm, vm)
   } catch (e) {
     // ...
   } finally {
     // ...
   }
   return value    
}

export default class Dep {
  // ...
}

Dep.target = null
const targetStack = []

export function pushTarget (_target: ?Watcher) {
  if (Dep.target) targetStack.push(Dep.target)
  Dep.target = _target
}

export function popTarget () {
  Dep.target = targetStack.pop()
}

// src/core/observer/dep.js
class Dep {
  addDep (dep: Dep) {
    const id = dep.id
    if (!this.newDepIds.has(id)) {
        this.newDepIds.add(id)
        this.newDeps.push(dep)
        if (!this.depIds.has(id)) {
        dep.addSub(this)
        }
    }
  }
  depend () {
    if (Dep.target) {
        Dep.target.addDep(this)
    }
  }
}

new Watcher(vm, updateComponent, noop, {
    before () {
      if (vm._isMounted) {
        callHook(vm, 'beforeUpdate')
      }
    }
  }, true /* isRenderWatcher */)

// src/core/observer/dep.js
class Dep {
  // ...
  notify () {
  // stabilize the subscriber list first
    const subs = this.subs.slice()
    for (let i = 0, l = subs.length; i < l; i++) {
      subs[i].update()
    }
  }
}

// src/core/observer/watcher.js
class Watcher {
  // ...
  update () {
    /* istanbul ignore else */
    if (this.lazy) {
      this.dirty = true
    } else if (this.sync) {
      this.run()
    } else {
      queueWatcher(this)
    }
  }
}

// src/core/observer/scheduler.js
const queue: Array<Watcher> = []
let has: { [key: number]: ?true } = {}
let waiting = false
let flushing = false
/**
 * Push a watcher into the watcher queue.
 * Jobs with duplicate IDs will be skipped unless it's
 * pushed when the queue is being flushed.
 */
export function queueWatcher (watcher: Watcher) {
  const id = watcher.id
  if (has[id] == null) {
    has[id] = true
    if (!flushing) {
      queue.push(watcher)
    } else {
      // if already flushing, splice the watcher based on its id
      // if already past its id, it will be run next immediately.
      let i = queue.length - 1
      while (i > index && queue[i].id > watcher.id) {
        i--
      }
      queue.splice(i + 1, 0, watcher)
    }
    // queue the flush
    if (!waiting) {
      waiting = true

      if (process.env.NODE_ENV !== 'production' && !config.async) {
        flushSchedulerQueue()
        return
      }
      nextTick(flushSchedulerQueue)
    }
  }
}

function flushSchedulerQueue () {
  // ...
  // 获取到 updatedQueue
  callUpdatedHooks(updatedQueue)
}

function callUpdatedHooks (queue) {
  let i = queue.length
  while (i--) {
    const watcher = queue[i]
    const vm = watcher.vm
    if (vm._watcher === watcher && vm._isMounted) {
      callHook(vm, 'updated')
    }
  }
}

Vue.prototype.$destroy = function () {
    const vm: Component = this
    if (vm._isBeingDestroyed) {
      return
    }
    callHook(vm, 'beforeDestroy')
    vm._isBeingDestroyed = true
    // remove self from parent
    const parent = vm.$parent
    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
      remove(parent.$children, vm)
    }
    // teardown watchers
    if (vm._watcher) {
      vm._watcher.teardown()
    }
    let i = vm._watchers.length
    while (i--) {
      vm._watchers[i].teardown()
    }
    // remove reference from data ob
    // frozen object may not have observer.
    if (vm._data.__ob__) {
      vm._data.__ob__.vmCount--
    }
    // call the last hook...
    vm._isDestroyed = true
    // invoke destroy hooks on current rendered tree
    vm.__patch__(vm._vnode, null)
    // fire destroyed hook
    callHook(vm, 'destroyed')
    // turn off all instance listeners.
    vm.$off()
    // remove __vue__ reference
    if (vm.$el) {
      vm.$el.__vue__ = null
    }
    // release circular reference (#6759)
    if (vm.$vnode) {
      vm.$vnode.parent = null
    }
  }
}

<script type ="module" src=""></script>

module.exports = value
exports.a = value

require(xxx)

//定义没有依赖的模块
define(function(){
    return xxx
})
//定义有依赖的模块
define(['module1', 'module2'], function(m1, m2){
    return xxx
})

//定义没有依赖的模块
define(function(require, exports, module){
  exports.xxx = value
  module.exports = value
})
//定义有依赖的模块
define(function(require, exports, module){
  //引入依赖模块(同步)
  var module2 = require('./module2')
  //引入依赖模块(异步)
    require.async('./module3', function (m3) {
    })
  //暴露模块
  exports.xxx = value
})

// 使用模块
define(function (require) {
  var m1 = require('./module1')
  var m2 = require('./module2')
  m1.show()
  m2.show()
})

// 独立使用export声明。
export {a, b, c};
// 声明型语句前加export。
export var a = 1;

export default function add() { // 输出
  // ...
}

import add from 'add'; // 输入

// 正确
export var a = 1;

// 正确
var a = 1;
export default a;

// 错误
export default var a = 1;

// 报错
export 1;

// 报错
var m = 1;
export m;

// 正确
// 写法一
export var m = 1;

// 写法二
var m = 1;
export {m};

// 写法三
var n = 1;
export {n as m};

import x from "./a.js"; // 导入默认值
import {a as x, modify} from './a.js'; // 引入模块中的变量
import * from "./a.js"; // 把模块中的所有变量以类似对象的方式引入

// CommonJS模块
let { stat, exists, readFile } = require('fs');
// 等同于
let _fs = require('fs');
let stat = _fs.stat;
let exists = _fs.exists;
let readfile = _fs.readfile;

// ES6模块
import { stat, exists, readFile } from 'fs';