function Vue(){
    if(!this instanceof Vue){
        return warn("必须使用 new 关键字来实例化")
    }
    this._init();
}

let uid = 0;
export function initMixin(Vue){
    Vue.prototype._init = function (options?: Record<string, any>) {
        const vm: Component = this
        // a uid
        vm._uid = uid++

        let startTag, endTag
        /* istanbul ignore if */
        if (__DEV__ && config.performance && mark) {
            startTag = `vue-perf-start:${vm._uid}`
            endTag = `vue-perf-end:${vm._uid}`
            mark(startTag)
        }

        // a flag to mark this as a Vue instance without having to do instanceof
        // check
        vm._isVue = true
        // avoid instances from being observed
        vm.__v_skip = true
        // effect scope
        vm._scope = new EffectScope(true /* detached */)
        // #13134 edge case where a child component is manually created during the
        // render of a parent component
        vm._scope.parent = undefined
        vm._scope._vm = true
        // merge options
        if (options && options._isComponent) {
            // optimize internal component instantiation
            // since dynamic options merging is pretty slow, and none of the
            // internal component options needs special treatment.
            initInternalComponent(vm, options as any)
        } else {
            vm.$options = mergeOptions(
                resolveConstructorOptions(vm.constructor as any),
                options || {},
                vm
            )
        }
        /* istanbul ignore else */
        if (__DEV__) {
            initProxy(vm)
        } else {
            vm._renderProxy = vm
        }
        // expose real self
        vm._self = vm
        initLifecycle(vm)
        initEvents(vm)
        initRender(vm)
        callHook(vm, 'beforeCreate', undefined, false /* setContext */)
        initInjections(vm) // resolve injections before data/props
        initState(vm)
        initProvide(vm) // resolve provide after data/props
        callHook(vm, 'created')

        /* istanbul ignore if */
        if (__DEV__ && config.performance && mark) {
            vm._name = formatComponentName(vm, false)
            mark(endTag)
            measure(`vue ${vm._name} init`, startTag, endTag)
        }

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

let uid = 0;

Vue.prototype.init=function(){
  vm._uid = uid++
}

// _init 函数刚执行时
let startTag, endTag
if (__DEV__ && config.performance && mark) {
  startTag = `vue-perf-start:${vm._uid}`
  endTag = `vue-perf-end:${vm._uid}`
  mark(startTag)
}
// _init 函数初始化逻辑完成
if (__DEV__ && config.performance && mark) {
  mark(endTag)
  measure(`vue ${vm._uid} init`, startTag, endTag)
}

// 开启 vue性能配置
Vue.config.performance = true;

// core/config.js
export default {
  // 默认不开启perf
  performance: false
}

import config from '../config'
export function initGlobalAPI(Vue){
    // 省略部分代码
    const configDef = {};
    configDef.get = () => config;

    if (__DEV__) {
        configDef.set = () => {
          warn(
            '不要替换Vue.配置对象，而是设置单独的字段'
          )
        }
    }

    Object.defineProperty(Vue,'config',configDef);
}

export default {
  /**
   * Option merge strategies (used in core/util/options)
   */
  // $flow-disable-line
  optionMergeStrategies: Object.create(null),

  /**
   * Whether to suppress warnings.
   */
  silent: false,

  /**
   * Show production mode tip message on boot?
   */
  productionTip: __DEV__,

  /**
   * Whether to enable devtools
   */
  devtools: __DEV__,

  /**
   * Whether to record perf
   */
  performance: false,

  /**
   * Error handler for watcher errors
   */
  errorHandler: null,

  /**
   * Warn handler for watcher warns
   */
  warnHandler: null,

  /**
   * Ignore certain custom elements
   */
  ignoredElements: [],

  /**
   * Custom user key aliases for v-on
   */
  // $flow-disable-line
  keyCodes: Object.create(null),

  /**
   * Check if a tag is reserved so that it cannot be registered as a
   * component. This is platform-dependent and may be overwritten.
   */
  isReservedTag: no,

  /**
   * Check if an attribute is reserved so that it cannot be used as a component
   * prop. This is platform-dependent and may be overwritten.
   */
  isReservedAttr: no,

  /**
   * Check if a tag is an unknown element.
   * Platform-dependent.
   */
  isUnknownElement: no,

  /**
   * Get the namespace of an element
   */
  getTagNamespace: noop,

  /**
   * Parse the real tag name for the specific platform.
   */
  parsePlatformTagName: identity,

  /**
   * Check if an attribute must be bound using property, e.g. value
   * Platform-dependent.
   */
  mustUseProp: no,

  /**
   * Perform updates asynchronously. Intended to be used by Vue Test Utils
   * This will significantly reduce performance if set to false.
   */
  async: true,

  /**
   * Exposed for legacy reasons
   */
  _lifecycleHooks: LIFECYCLE_HOOKS
} as unknown as Config

// 判断是否在浏览器中
import { inBrowser } from './env'

export let mark
export let measure

// 只有在开发环境中才会设置 mark 和 measure
if (__DEV__) {
  const perf = inBrowser && window.performance 
  if (
    perf && 
    perf.mark && 
    perf.measure && 
    perf.clearMarks && 
    perf.clearMeasures
  ) {
    mark = tag => perf.mark(tag)
    measure = (name, startTag, endTag) => {
      perf.measure(name, startTag, endTag)
      perf.clearMarks(startTag)
      perf.clearMarks(endTag) 
    }
  }
}

window.performance.mark("_start")
for(let i=0;i<10000;i++){
  console.log();
}
window.performance.mark("_end")
window.performance.measure("timestamp","_start","_end")

// 可以获取直接间隔
window.performance.getEntriesByName("timestamp")[0]

Vue.prototype.init=function(){
  vm._isVue = true
}

Vue.prototype.init=function(){
  vm.__v_skip = true
}

if (options && options._isComponent) {
    // optimize internal component instantiation
    // since dynamic options merging is pretty slow, and none of the
    // internal component options needs special treatment.
    initInternalComponent(vm, options as any)
} else {
    vm.$options = mergeOptions(
        resolveConstructorOptions(vm.constructor as any),
        options || {},
        vm
    )
}

if (__DEV__) {
    initProxy(vm)
}else {
    vm._renderProxy = vm
}

Vue.prototype.init=function(){
  vm._self = vm
}

// 初始化生命周期
initLifeCycle(vm);
// 初始化事件中心
initEvents(vm)
// 初始化渲染
initRender(vm)
// 初始化 inject
initInjections(vm)
// 初始化 props、data、computed 等
initState(vm)
// 初始化 provider
initProvide(vm)

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