render: function (createElement) {
  // `<div><slot></slot></div>`
  return createElement('div', this.$slots.default)
}

props: ['message'],
render: function (createElement) {
  // `<div><slot :text="message"></slot></div>`
  return createElement('div', [
    this.$scopedSlots.default({
      text: this.message
    })
  ])
}

render: function (createElement) {
  // `<div><child v-slot="props"><span>{{ props.text }}</span></child></div>`
  return createElement('div', [
    createElement('child', {
      // 在数据对象中传递 `scopedSlots`
      // 格式为 { name: props => VNode | Array<VNode> }
      scopedSlots: {
        default: function (props) {
          return createElement('span', props.text)
        }
      }
    })
  ])
}

render(h) {
  return h('ul', [
    ...this.filteredTodos(i => {
      return h('li', {
        key: i.id,
      }, [
        this.$scopedSlots.todo ? this.$scopedSlots.todo({
          todo: i
        }) : i.text
      ])
    })
  ])
}

render(h) {
  return h('todo-list', {
    props: {
      todos: this.todos,
    },
    scopedSlots: {
      todo: ({todo}) => {
        return [
          todo.isComplete ? h('span', '✓') : '',
          todo.text
        ]
      }
    }
  })
}

render() {
  return (
    <ul>
        {
        this.filteredTodos.map(todo => {
         return <li key={todo.id}>
          {this.$scopedSlots.todo ? this.$scopedSlots.todo({todo}) : todo.text }
          </li>})
            }
      </ul>
)}

render() {
    return (
      <todo-list todos={this.todos} scopedSlots={{
        todo: ({todo}) => {
          return <div>
            {todo.isComplete ? <span>✓</span> : ''}
            {todo.text}
          </div>   
        }
      }}></todo-list>
    )
  }

"editor.codeActionsOnSave": {
    "source.fixAll.eslint": true
  }

module.exports = {
  ...
  extends: [
    'plugin:vue/essential',
    'airbnb-base',
    'plugin:prettier/recommended' // 添加 prettier 插件
  ],
  ...
}

require.context(directory, useSudirectories = false, regExp =  /^\.\//) {}

// 注册
Vue.directive('my-directive', {
  bind: function () {}, // 只调用一次，指令第一次绑定到元素时调用。在这里可以进行一次性的初始化设置
  inserted: function () {}, // 被绑定元素插入父节点时调用 (仅保证父节点存在，但不一定已被插入文档中)
  update: function () {}, // 所在组件的 VNode 更新时调用
  componentUpdated: function () {}, // 指令所在组件的 VNode 及其子 VNode 全部更新后调用
  unbind: function () {} // 只调用一次，指令与元素解绑时调用
})

// 注册 (指令函数)
Vue.directive('my-directive', function () {
  // 这里将会被 `bind` 和 `update` 调用
}

// permission
const Auth = ['admin']

const checkAuth = function(authList) {
  return Auth.some(item => authList.includes(item))
}

function install(Vue) {
     Vue.directive('permission', {
    inserted(el, binding) {
      if(!checkAuth(binding.value)) {
        el.parentNode && el.parentNode.removeChild(el)
      }
    }
  }) 
}

export default {install}

//main.js
import Permission form './permission.js'
Vue.use(Permission)

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    // for(let i = 0; i < nums.length; i++) {
    //     for(let j = 0; j<nums.length; j++) {
    //         if(nums[i] + nums[j] === target && i !== j) return [i,j]
    //     }
    // }
    let obj = {}
    for(let i =0; i<nums.length; i++) {
        let num = nums[i];
        if(num in obj) {
            return [obj[num], i]
        } else {
            obj[target - num] = i
        }
    }
};

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    const stack = []
    const map = {
        '(': ')',
        '{': '}',
        '[': ']'
    }
    for(let i=0;i<s.length;i++) {
        if(s[i] in map) {
            stack.push(s[i])
        } else {
            if(map[stack.pop()] !== s[i]) {
                return false
            }
        }
    }
    return !stack.length
};

/**
 * @param {string} path
 * @return {string}
 */
var simplifyPath = function(path) {
    const stack = []
    const paths = path.split('/')
    for(let i =0;i<paths.length;i++) {
        const p = paths[i]
        if(p === '..') {
            stack.pop()
        } else if(p && p !== '.') {
            stack.push(p)
        }
    }
    return '/' + stack.join('/')
};

// 手动实现链表结构
class Node {
  constructor(element) {
    this.element = element
    this.next =null
  }
}

class LinkNodeList {
  constructor() {
    this.head = null
    this.length = 0
  }

  append(element) {
    let node = new Node(element)
    let cur
    if(!this.head) {
      this.head = node
    } else {
      cur = this.head
      while(cur.next) {
        cur = cur.next 
      }
      cur.next =node
    }
    this.length += 1
  }

  print() {
    let cur = this.head
    let ret = []
    while(cur) {
      ret.push(cur.element)
      cur = cur.next
    }
    return ret.join('==>')
  }

  removeAt(index) {
    let prev
    let cur = this.head
    let i = 0
    if(index === 0) {
      this.head = cur.next
    } else {
      while(i < index) {
        prev = cur
        cur = cur.next
        i++
      }
      prev.next = cur.next
      cur.next = null
    }
    this.length -= 1;
    return cur.element;
  }
}

const linkList = new LinkNodeList()
linkList.append('hah')
linkList.append('yy')
linkList.removeAt(1)
linkList.print()

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var middleNode = function(head) {
    // 初学时的暴力解法
    // let n = 0
    // let p = {}
    // p.next = head
    // let node = p
    // let arr = []
    // while(node) {
    //     if(node.val) {
    //         arr.push(node)
    //         n++
    //     }
    //     node = node.next
    // }
    // if(n%2 === 0) {
    //     return arr[n/2]
    // } else {
    //     return arr[Math.floor(n/2)]
    // }
    // 快慢指针法
    let slow = head
    let fast = head
    while(fast && fast.next) {
        slow = slow.next
        fast = fast.next.next
    }
    return slow
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var removeElements = function(head, val) {
    // 添加一个哨兵元素
    let prev = {
        next: head
    }
    let cur = prev

    while(cur.next) {
        if(cur.next.val === val) {
            cur.next = cur.next.next
        } else {
            cur = cur.next
        }
    }
    return prev.next
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    let cur = head
    let prev = null
    while(cur !== null) {
        let next = cur.next
        cur.next = prev
        prev = cur
        cur = next    
    }
    return prev
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    // 解法一
    // const cache = new Set()
    // while(head) {
    //     if(cache.has(head)) {
    //         return head
    //     } else {
    //         cache.add(head)
    //         head = head.next
    //     }
    // }
    // return null
    // 解法二 快慢指针
    let fast = head
    let slow = head
    let start = head
    
    while(fast && fast.next) {
        fast = fast.next.next
        slow = slow.next
        if(slow == fast) {
            while(slow && start) {
                if(slow == start) {
                    return slow
                }
                slow = slow.next
                start = start.next         
            }
        }
    }
    return null
};

/*
 * @lc app=leetcode.cn id=226 lang=javascript
 *
 * [226] 翻转二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var invertTree = function(root) {
  if(root == null) {
    return root
  }
  [root.left, root.right] = [invertTree(root.right), invertTree(root.left)]

  return root
};

// @lc code=start
/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root, arr = []) {
  // 递归
  // if(root) {
  //   arr.push(root.val)
  //   preorderTraversal(root.left, arr)
  //   preorderTraversal(root.right, arr)
  // }
  // return arr
  // 迭代
  let result = []
  let stack = [] // 用来得到right
  let cur = root

  while(cur || stack.length > 0) {
    while(cur) {
      result.push(cur.val)
      stack.push(cur)
      cur = cur.left
    }
    cur = stack.pop()
    cur = cur.right
  }

  return result
};

var inorderTraversal = function(root) {
    // 递归
    // if(root == null) {
    //     return arr
    // }
    // inorderTraversal(root.left, arr)
    // if(root.val) arr.push(root.val)
    // inorderTraversal(root.right, arr)
    // return arr
    // 迭代
    let result = []
    let stack = []
    let cur = root
    while(cur || stack.length > 0) {
        while(cur) {
            stack.push(cur)
            cur = cur.left
        }
        cur = stack.pop()
        result.push(cur.val)
        cur = cur.right
    }
    return result
};

/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    // 递归
    if(root == null) {
        return 0
    }
    
    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1
};

var lowestCommonAncestor = function(root, p, q) {
    // 递归
    // if(p.val > root.val && q.val > root.val) {
    //     return lowestCommonAncestor(root.right, p, q)
    // } else if(p.val < root.val && q.val < root.val) {
    //     return lowestCommonAncestor(root.left, p, q)
    // } else {
    //     return root
    // }
    // 迭代
    while(root) {
        if(p.val > root.val && q.val > root.val) {
            root = root.right
        } else if(q.val < root.val && p.val < root.val) {
            root = root.left
        } else {
            return root
        }
    }
};

/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    // 递归
    if(root == null || root == p || root == q) {
        return root
    }

    let left = lowestCommonAncestor(root.left, p, q)
    let right = lowestCommonAncestor(root.right, p, q)

    if(left == null) {
        return right
    }
    if(right == null) {
        return left
    }
    return root
};

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)
}

Vue.prototype._init = function (options?: Object) {
  const vm: Component = this
  // a uid
  vm._uid = uid++

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

  // a flag to avoid this being observed
  vm._isVue = 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)
  } else {
    vm.$options = mergeOptions(
      resolveConstructorOptions(vm.constructor),
      options || {},
      vm
    )
  }
  /* istanbul ignore else */
  if (process.env.NODE_ENV !== 'production') {
    initProxy(vm)
  } else {
    vm._renderProxy = vm
  }
  // expose real self
  vm._self = vm
  initLifecycle(vm) // init Lifecycle
  initEvents(vm) // initEvents
  initRender(vm)
  callHook(vm, 'beforeCreate')
  initInjections(vm) // resolve injections before data/props
  initState(vm) // 初始化响应式
  initProvide(vm) // resolve provide after data/props
  callHook(vm, 'created')

  /* istanbul ignore if */
  if (process.env.NODE_ENV !== 'production' && 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)
  }
}

initLifecycle(vm) // init Lifecycle
initEvents(vm) // initEvents
initRender(vm)
callHook(vm, 'beforeCreate')
initInjections(vm) // resolve injections before data/props
initState(vm) // 初始化响应式
initProvide(vm) // resolve provide after data/props
callHook(vm, 'created')