text: (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
  }(this, (function () { 'use strict';
  
    function _typeof(obj) {
      "@babel/helpers - typeof";
  
      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function (obj) {
          return typeof obj;
        };
      } else {
        _typeof = function (obj) {
          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
        };
      }
  
      return _typeof(obj);
    }
  
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
  
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      return Constructor;
    }
  
    // 重写数组的方法 7个 push shift unshift pop reverse sort splice 会导致数组本身发生变化
    var oldArrayMethods = Array.prototype; // value.__proto__ = arrayMethods 通过原型链向上查找
    // arrayMethods.__proto__ = oldArrayMethods
  
    var arrayMethods = Object.create(oldArrayMethods);
    var methods = ['push', 'shift', 'unshift', 'pop', 'sort', 'splice', 'reverse'];
    methods.forEach(function (method) {
      arrayMethods[method] = function () {
        console.log('调用了push方法'); // AOP 切片编程
  
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
  
        var result = oldArrayMethods[method].apply(this, args); // 调用原生的数组方法
        // push unshift 添加的元素可能还是一个对象
  
        var inserted; // 当前用户插入的元素
  
        var ob = this.__ob__; // __ob__ 是当前Observer的实例
  
        switch (method) {
          case 'push':
          case 'unshift':
            inserted = args;
            break;
  
          case 'splice':
            // 3个 新增的属性 splice 有删除 新增的功能 arr.splice(0,1,{name: 1})
            inserted = args.slice(2);
        }
  
        if (inserted) ob.observerArray(inserted); // 将新增属性继续观测
  
        return result;
      };
    });
  
    /**
     * 
     * @param {*} data 当前数据是不是对象
     */
    function isObject(data) {
      return _typeof(data) === 'object' && data !== null;
    }
    function def(data, key, value) {
      Object.defineProperty(data, key, {
        enumerable: false,
        configurable: false,
        value: value
      });
    }
  
    var Observer = /*#__PURE__*/function () {
      function Observer(value) {
        _classCallCheck(this, Observer);
  
        // vue 如果数据的层次过多 需要递归的解析对象中的属性，依次增加set和get方法
        // value.__ob__ = this // 给每一个监控过的对象都增加一个__ob__属性
        def(value, '__ob__', this);
  
        if (Array.isArray(value)) {
          // 对数组监控
          // 如果是数组的话，并不会对索引进行观测 因为会导致性能问题
          // 前端开发中很少 去操作索引，一般会使用 push、pop、shift、unshift...
          value.__proto__ = arrayMethods; // 如果数组里放的是对象再监控
  
          this.observerArray(value);
        } else {
          this.walk(value);
        }
      }
  
      _createClass(Observer, [{
        key: "observerArray",
        value: function observerArray(value) {
          for (var i = 0; i < value.length; i++) {
            observe(value[i]);
          }
        }
      }, {
        key: "walk",
        value: function walk(data) {
          var keys = Object.keys(data);
          keys.forEach(function (key) {
            defineReactive(data, key, data[key]); // 定义响应式数据
          });
        }
      }]);
  
      return Observer;
    }();
  
    function defineReactive(data, key, value) {
      observe(value); // 递归实现深度监测（数据越深，递归越多，从而导致性能浪费，所以写代码时，层级不要太多）
  
      Object.defineProperty(data, key, {
        get: function get() {
          // 获取值的时候做一些操作
          return value;
        },
        set: function set(newValue) {
          // 设置值时也可以做一些操作
          console.log('更新数据');
          if (newValue === value) return;
          observe(newValue); // 继续劫持用户设置的值，因为有可能用户设置的值是一个对象
  
          value = newValue;
        }
      });
    }
  
    function observe(data) {
      var isObj = isObject(data);
      console.log(isObj);
  
      if (!isObj) {
        return;
      }
  
      return new Observer(data); // 用来观测数据
    }
  
    function initState(vm) {
      var opts = vm.$options; // vue的数据来源 属性 方法 数据 计算属性 watch
  
      if (opts.props) ;
  
      if (opts.methods) ;
  
      if (opts.data) {
        initData(vm);
      }
  
      if (opts.computed) ;
  
      if (opts.watch) ;
    }
  
    function initData(vm) {
      // 数据初始化工作
      var data = vm.$options.data; // 用户传递的data
  
      data = vm._data = typeof data === 'function' ? data.call(vm) : data; // 对象劫持 用户改变了数据 通知 => 刷新页面
      // MVVM模式 数据变化可以驱动视图变化
      // Object.defineProperty() 给属性增加get方法和set方法
  
      observe(data); // 响应式原理
    }
  
    function initMixin(Vue) {
      Vue.prototype._init = function (options) {
        // 数据劫持
        var vm = this; // vue中使用 this.$options 指代的就是用户传递的属性
  
        vm.$options = options; // 初始化状态
  
        initState(vm); // 分割代码
      };
    }
  
    // Vue的核心代码 只是Vue的一个声明
  
    function Vue(options) {
      // 进行Vue的初始化操作
      this._init(options);
    } // 通过引入文件的方式 给Vue原型上添加方法
  
  
    initMixin(Vue); // 给Vue原型上添加一个_init方法
  
    return Vue;
  
  })));
  //# sourceMappingURL=vue.js.map
  