{"version":3,"sources":["webpack:///./node_modules/core-js/modules/es.set.symmetric-difference.v2.js","webpack:///./node_modules/core-js/modules/es.set.difference.v2.js","webpack:///./node_modules/core-js/internals/iterator-close.js","webpack:///./node_modules/core-js/internals/set-iterate.js","webpack:///./node_modules/core-js/internals/set-is-superset-of.js","webpack:///./node_modules/core-js/internals/get-iterator-direct.js","webpack:///./node_modules/core-js/internals/iterate-simple.js","webpack:///./node_modules/core-js/internals/set-is-subset-of.js","webpack:///./node_modules/core-js/modules/es.set.union.v2.js","webpack:///./node_modules/core-js/modules/es.set.intersection.v2.js","webpack:///./node_modules/core-js/internals/get-set-record.js","webpack:///./node_modules/core-js/internals/set-clone.js","webpack:///./node_modules/core-js/modules/es.set.is-subset-of.v2.js","webpack:///./node_modules/core-js/internals/set-size.js","webpack:///./node_modules/core-js/internals/set-intersection.js","webpack:///./node_modules/core-js/internals/set-symmetric-difference.js","webpack:///./node_modules/core-js/modules/es.set.is-superset-of.v2.js","webpack:///./node_modules/core-js/internals/set-difference.js","webpack:///./node_modules/core-js/internals/set-is-disjoint-from.js","webpack:///./node_modules/core-js/modules/es.set.is-disjoint-from.v2.js","webpack:///./node_modules/core-js/internals/set-helpers.js","webpack:///./node_modules/core-js/internals/set-method-accept-set-like.js","webpack:///./node_modules/core-js/internals/a-set.js","webpack:///./node_modules/core-js/internals/set-union.js","webpack:///../../../src/components/VTreeview/VTreeviewNode.ts","webpack:///../../../../src/components/VTreeview/util/filterTreeItems.ts","webpack:///../../../src/components/VTreeview/VTreeview.ts"],"names":["$","symmetricDifference","setMethodAcceptSetLike","target","proto","real","forced","difference","call","anObject","getMethod","module","exports","iterator","kind","value","innerResult","innerError","error","uncurryThis","iterateSimple","SetHelpers","Set","SetPrototype","forEach","keys","next","set","fn","interruptible","aSet","has","size","getSetRecord","iteratorClose","other","O","this","otherRec","getIterator","e","obj","done","record","ITERATOR_INSTEAD_OF_RECORD","step","result","undefined","iterate","includes","union","fails","intersection","INCORRECT","String","Array","from","aCallable","toIntegerOrInfinity","getIteratorDirect","INVALID_SIZE","$RangeError","RangeError","$TypeError","TypeError","max","Math","SetRecord","intSize","prototype","it","numSize","add","isSubsetOf","uncurryThisAccessor","iterateSet","clone","remove","keysIter","isSupersetOf","isDisjointFrom","getBuiltIn","createSetLike","name","error2","baseMixins","mixins","Colorable","RegistrableInject","VTreeviewNodeProps","activatable","Boolean","activeClass","type","default","color","disablePerNode","expandIcon","indeterminateIcon","itemChildren","itemDisabled","itemKey","itemText","loadChildren","Function","loadingIcon","offIcon","onIcon","openOnClick","rounded","selectable","selectedColor","shaped","transition","selectionType","validator","v","VTreeviewNode","extend","inject","treeview","props","level","Number","item","Object","parentIsDisabled","data","hasLoaded","isActive","isIndeterminate","isLoading","isOpen","isSelected","computed","disabled","getObjectValueByPath","key","children","filter","child","isExcluded","text","scopedProps","leaf","selected","indeterminate","active","open","computedIcon","hasChildren","length","created","register","beforeDestroy","unregister","methods","checkChildren","Promise","resolve","then","updateOpen","emitOpen","genLabel","$scopedSlots","label","push","$createElement","slot","staticClass","genPrependSlot","prepend","genAppendSlot","append","genContent","genToggle","VIcon","class","on","click","stopPropagation","genCheckbox","$nextTick","updateSelected","emitSelected","genLevel","createRange","map","genNode","unshift","setTextColor","updateActive","emitActive","genChild","scopedSlots","genChildrenWrapper","c","genTransition","VExpandTransition","render","h","attrs","filterTreeItem","search","textKey","toLocaleLowerCase","indexOf","filterTreeItems","idKey","childrenKey","excluded","match","i","RegistrableProvide","Themeable","provide","dense","hoverable","items","multipleActive","openAll","returnObject","activeCache","nodes","openCache","selectedCache","excludedItems","watch","handler","oldKeys","k","newKeys","getKeys","diff","arrayDiff","oldSelectedCache","buildTree","deepEqual","deep","handleNodeCacheWatcher","getValue","mounted","$slots","consoleWarn","updateAll","parent","_a","oldNode","hasOwnProperty","vnode","node","calculateState","updateVnodeState","state","counts","reduce","emitNodeCache","event","cache","$emit","updateFn","emitFn","old","getDescendants","descendants","getParents","parents","isParent","delete","isForced","changed","Map","descendant","calculated","entries","options","bind","themeClasses"],"mappings":"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","file":"js/CreateExternalSSOUser~CreateExternalUser~Crm~Economy~Employee~Incident~IncidentCreate~Insurance~Loca~d71dc856.37e470b8.js","sourcesContent":["'use strict';\nvar $ = require('../internals/export');\nvar symmetricDifference = require('../internals/set-symmetric-difference');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\n// `Set.prototype.symmetricDifference` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('symmetricDifference') }, {\n  symmetricDifference: symmetricDifference\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar difference = require('../internals/set-difference');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\n// `Set.prototype.difference` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('difference') }, {\n  difference: difference\n});\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n  var innerResult, innerError;\n  anObject(iterator);\n  try {\n    innerResult = getMethod(iterator, 'return');\n    if (!innerResult) {\n      if (kind === 'throw') throw value;\n      return value;\n    }\n    innerResult = call(innerResult, iterator);\n  } catch (error) {\n    innerError = true;\n    innerResult = error;\n  }\n  if (kind === 'throw') throw value;\n  if (innerError) throw innerResult;\n  anObject(innerResult);\n  return value;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar iterateSimple = require('../internals/iterate-simple');\nvar SetHelpers = require('../internals/set-helpers');\n\nvar Set = SetHelpers.Set;\nvar SetPrototype = SetHelpers.proto;\nvar forEach = uncurryThis(SetPrototype.forEach);\nvar keys = uncurryThis(SetPrototype.keys);\nvar next = keys(new Set()).next;\n\nmodule.exports = function (set, fn, interruptible) {\n  return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn);\n};\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar has = require('../internals/set-helpers').has;\nvar size = require('../internals/set-size');\nvar getSetRecord = require('../internals/get-set-record');\nvar iterateSimple = require('../internals/iterate-simple');\nvar iteratorClose = require('../internals/iterator-close');\n\n// `Set.prototype.isSupersetOf` method\n// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSupersetOf\nmodule.exports = function isSupersetOf(other) {\n  var O = aSet(this);\n  var otherRec = getSetRecord(other);\n  if (size(O) < otherRec.size) return false;\n  var iterator = otherRec.getIterator();\n  return iterateSimple(iterator, function (e) {\n    if (!has(O, e)) return iteratorClose(iterator, 'normal', false);\n  }) !== false;\n};\n","'use strict';\n// `GetIteratorDirect(obj)` abstract operation\n// https://tc39.es/proposal-iterator-helpers/#sec-getiteratordirect\nmodule.exports = function (obj) {\n  return {\n    iterator: obj,\n    next: obj.next,\n    done: false\n  };\n};\n","'use strict';\nvar call = require('../internals/function-call');\n\nmodule.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {\n  var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;\n  var next = record.next;\n  var step, result;\n  while (!(step = call(next, iterator)).done) {\n    result = fn(step.value);\n    if (result !== undefined) return result;\n  }\n};\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar size = require('../internals/set-size');\nvar iterate = require('../internals/set-iterate');\nvar getSetRecord = require('../internals/get-set-record');\n\n// `Set.prototype.isSubsetOf` method\n// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSubsetOf\nmodule.exports = function isSubsetOf(other) {\n  var O = aSet(this);\n  var otherRec = getSetRecord(other);\n  if (size(O) > otherRec.size) return false;\n  return iterate(O, function (e) {\n    if (!otherRec.includes(e)) return false;\n  }, true) !== false;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar union = require('../internals/set-union');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\n// `Set.prototype.union` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('union') }, {\n  union: union\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar intersection = require('../internals/set-intersection');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\nvar INCORRECT = !setMethodAcceptSetLike('intersection') || fails(function () {\n  // eslint-disable-next-line es/no-array-from, es/no-set -- testing\n  return String(Array.from(new Set([1, 2, 3]).intersection(new Set([3, 2])))) !== '3,2';\n});\n\n// `Set.prototype.intersection` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {\n  intersection: intersection\n});\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar call = require('../internals/function-call');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar getIteratorDirect = require('../internals/get-iterator-direct');\n\nvar INVALID_SIZE = 'Invalid size';\nvar $RangeError = RangeError;\nvar $TypeError = TypeError;\nvar max = Math.max;\n\nvar SetRecord = function (set, intSize) {\n  this.set = set;\n  this.size = max(intSize, 0);\n  this.has = aCallable(set.has);\n  this.keys = aCallable(set.keys);\n};\n\nSetRecord.prototype = {\n  getIterator: function () {\n    return getIteratorDirect(anObject(call(this.keys, this.set)));\n  },\n  includes: function (it) {\n    return call(this.has, this.set, it);\n  }\n};\n\n// `GetSetRecord` abstract operation\n// https://tc39.es/proposal-set-methods/#sec-getsetrecord\nmodule.exports = function (obj) {\n  anObject(obj);\n  var numSize = +obj.size;\n  // NOTE: If size is undefined, then numSize will be NaN\n  // eslint-disable-next-line no-self-compare -- NaN check\n  if (numSize !== numSize) throw new $TypeError(INVALID_SIZE);\n  var intSize = toIntegerOrInfinity(numSize);\n  if (intSize < 0) throw new $RangeError(INVALID_SIZE);\n  return new SetRecord(obj, intSize);\n};\n","'use strict';\nvar SetHelpers = require('../internals/set-helpers');\nvar iterate = require('../internals/set-iterate');\n\nvar Set = SetHelpers.Set;\nvar add = SetHelpers.add;\n\nmodule.exports = function (set) {\n  var result = new Set();\n  iterate(set, function (it) {\n    add(result, it);\n  });\n  return result;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isSubsetOf = require('../internals/set-is-subset-of');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\n// `Set.prototype.isSubsetOf` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('isSubsetOf') }, {\n  isSubsetOf: isSubsetOf\n});\n","'use strict';\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar SetHelpers = require('../internals/set-helpers');\n\nmodule.exports = uncurryThisAccessor(SetHelpers.proto, 'size', 'get') || function (set) {\n  return set.size;\n};\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar SetHelpers = require('../internals/set-helpers');\nvar size = require('../internals/set-size');\nvar getSetRecord = require('../internals/get-set-record');\nvar iterateSet = require('../internals/set-iterate');\nvar iterateSimple = require('../internals/iterate-simple');\n\nvar Set = SetHelpers.Set;\nvar add = SetHelpers.add;\nvar has = SetHelpers.has;\n\n// `Set.prototype.intersection` method\n// https://github.com/tc39/proposal-set-methods\nmodule.exports = function intersection(other) {\n  var O = aSet(this);\n  var otherRec = getSetRecord(other);\n  var result = new Set();\n\n  if (size(O) > otherRec.size) {\n    iterateSimple(otherRec.getIterator(), function (e) {\n      if (has(O, e)) add(result, e);\n    });\n  } else {\n    iterateSet(O, function (e) {\n      if (otherRec.includes(e)) add(result, e);\n    });\n  }\n\n  return result;\n};\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar SetHelpers = require('../internals/set-helpers');\nvar clone = require('../internals/set-clone');\nvar getSetRecord = require('../internals/get-set-record');\nvar iterateSimple = require('../internals/iterate-simple');\n\nvar add = SetHelpers.add;\nvar has = SetHelpers.has;\nvar remove = SetHelpers.remove;\n\n// `Set.prototype.symmetricDifference` method\n// https://github.com/tc39/proposal-set-methods\nmodule.exports = function symmetricDifference(other) {\n  var O = aSet(this);\n  var keysIter = getSetRecord(other).getIterator();\n  var result = clone(O);\n  iterateSimple(keysIter, function (e) {\n    if (has(O, e)) remove(result, e);\n    else add(result, e);\n  });\n  return result;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isSupersetOf = require('../internals/set-is-superset-of');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\n// `Set.prototype.isSupersetOf` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('isSupersetOf') }, {\n  isSupersetOf: isSupersetOf\n});\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar SetHelpers = require('../internals/set-helpers');\nvar clone = require('../internals/set-clone');\nvar size = require('../internals/set-size');\nvar getSetRecord = require('../internals/get-set-record');\nvar iterateSet = require('../internals/set-iterate');\nvar iterateSimple = require('../internals/iterate-simple');\n\nvar has = SetHelpers.has;\nvar remove = SetHelpers.remove;\n\n// `Set.prototype.difference` method\n// https://github.com/tc39/proposal-set-methods\nmodule.exports = function difference(other) {\n  var O = aSet(this);\n  var otherRec = getSetRecord(other);\n  var result = clone(O);\n  if (size(O) <= otherRec.size) iterateSet(O, function (e) {\n    if (otherRec.includes(e)) remove(result, e);\n  });\n  else iterateSimple(otherRec.getIterator(), function (e) {\n    if (has(O, e)) remove(result, e);\n  });\n  return result;\n};\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar has = require('../internals/set-helpers').has;\nvar size = require('../internals/set-size');\nvar getSetRecord = require('../internals/get-set-record');\nvar iterateSet = require('../internals/set-iterate');\nvar iterateSimple = require('../internals/iterate-simple');\nvar iteratorClose = require('../internals/iterator-close');\n\n// `Set.prototype.isDisjointFrom` method\n// https://tc39.github.io/proposal-set-methods/#Set.prototype.isDisjointFrom\nmodule.exports = function isDisjointFrom(other) {\n  var O = aSet(this);\n  var otherRec = getSetRecord(other);\n  if (size(O) <= otherRec.size) return iterateSet(O, function (e) {\n    if (otherRec.includes(e)) return false;\n  }, true) !== false;\n  var iterator = otherRec.getIterator();\n  return iterateSimple(iterator, function (e) {\n    if (has(O, e)) return iteratorClose(iterator, 'normal', false);\n  }) !== false;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isDisjointFrom = require('../internals/set-is-disjoint-from');\nvar setMethodAcceptSetLike = require('../internals/set-method-accept-set-like');\n\n// `Set.prototype.isDisjointFrom` method\n// https://github.com/tc39/proposal-set-methods\n$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('isDisjointFrom') }, {\n  isDisjointFrom: isDisjointFrom\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\n// eslint-disable-next-line es/no-set -- safe\nvar SetPrototype = Set.prototype;\n\nmodule.exports = {\n  // eslint-disable-next-line es/no-set -- safe\n  Set: Set,\n  add: uncurryThis(SetPrototype.add),\n  has: uncurryThis(SetPrototype.has),\n  remove: uncurryThis(SetPrototype['delete']),\n  proto: SetPrototype\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nvar createSetLike = function (size) {\n  return {\n    size: size,\n    has: function () {\n      return false;\n    },\n    keys: function () {\n      return {\n        next: function () {\n          return { done: true };\n        }\n      };\n    }\n  };\n};\n\nmodule.exports = function (name) {\n  var Set = getBuiltIn('Set');\n  try {\n    new Set()[name](createSetLike(0));\n    try {\n      // late spec change, early WebKit ~ Safari 17.0 beta implementation does not pass it\n      // https://github.com/tc39/proposal-set-methods/pull/88\n      new Set()[name](createSetLike(-1));\n      return false;\n    } catch (error2) {\n      return true;\n    }\n  } catch (error) {\n    return false;\n  }\n};\n","'use strict';\nvar has = require('../internals/set-helpers').has;\n\n// Perform ? RequireInternalSlot(M, [[SetData]])\nmodule.exports = function (it) {\n  has(it);\n  return it;\n};\n","'use strict';\nvar aSet = require('../internals/a-set');\nvar add = require('../internals/set-helpers').add;\nvar clone = require('../internals/set-clone');\nvar getSetRecord = require('../internals/get-set-record');\nvar iterateSimple = require('../internals/iterate-simple');\n\n// `Set.prototype.union` method\n// https://github.com/tc39/proposal-set-methods\nmodule.exports = function union(other) {\n  var O = aSet(this);\n  var keysIter = getSetRecord(other).getIterator();\n  var result = clone(O);\n  iterateSimple(keysIter, function (it) {\n    add(result, it);\n  });\n  return result;\n};\n","// Components\nimport { VExpandTransition } from '../transitions'\nimport { VIcon } from '../VIcon'\nimport VTreeview from './VTreeview'\n\n// Mixins\nimport { inject as RegistrableInject } from '../../mixins/registrable'\nimport Colorable from '../../mixins/colorable'\n\n// Utils\nimport mixins, { ExtractVue } from '../../util/mixins'\nimport { getObjectValueByPath, createRange } from '../../util/helpers'\n\n// Types\nimport { VNode, VNodeChildren, PropType } from 'vue'\nimport { PropValidator } from 'vue/types/options'\n\ntype VTreeViewInstance = InstanceType<typeof VTreeview>\n\nconst baseMixins = mixins(\n  Colorable,\n  RegistrableInject('treeview')\n)\n\ninterface options extends ExtractVue<typeof baseMixins> {\n  treeview: VTreeViewInstance\n}\n\nexport const VTreeviewNodeProps = {\n  activatable: Boolean,\n  activeClass: {\n    type: String,\n    default: 'v-treeview-node--active',\n  },\n  color: {\n    type: String,\n    default: 'primary',\n  },\n  disablePerNode: Boolean,\n  expandIcon: {\n    type: String,\n    default: '$subgroup',\n  },\n  indeterminateIcon: {\n    type: String,\n    default: '$checkboxIndeterminate',\n  },\n  itemChildren: {\n    type: String,\n    default: 'children',\n  },\n  itemDisabled: {\n    type: String,\n    default: 'disabled',\n  },\n  itemKey: {\n    type: String,\n    default: 'id',\n  },\n  itemText: {\n    type: String,\n    default: 'name',\n  },\n  loadChildren: Function as PropType<(item: any) => Promise<void>>,\n  loadingIcon: {\n    type: String,\n    default: '$loading',\n  },\n  offIcon: {\n    type: String,\n    default: '$checkboxOff',\n  },\n  onIcon: {\n    type: String,\n    default: '$checkboxOn',\n  },\n  openOnClick: Boolean,\n  rounded: Boolean,\n  selectable: Boolean,\n  selectedColor: {\n    type: String,\n    default: 'accent',\n  },\n  shaped: Boolean,\n  transition: Boolean,\n  selectionType: {\n    type: String as PropType<'leaf' | 'independent'>,\n    default: 'leaf',\n    validator: (v: string) => ['leaf', 'independent'].includes(v),\n  },\n}\n\n/* @vue/component */\nconst VTreeviewNode = baseMixins.extend<options>().extend({\n  name: 'v-treeview-node',\n\n  inject: {\n    treeview: {\n      default: null,\n    },\n  },\n\n  props: {\n    level: Number,\n    item: {\n      type: Object,\n      default: () => null,\n    } as PropValidator<Record<string, unknown> | null>,\n    parentIsDisabled: Boolean,\n    ...VTreeviewNodeProps,\n  },\n\n  data: () => ({\n    hasLoaded: false,\n    isActive: false, // Node is selected (row)\n    isIndeterminate: false, // Node has at least one selected child\n    isLoading: false,\n    isOpen: false, // Node is open/expanded\n    isSelected: false, // Node is selected (checkbox)\n  }),\n\n  computed: {\n    disabled (): boolean {\n      return (\n        getObjectValueByPath(this.item, this.itemDisabled) ||\n        (!this.disablePerNode && (this.parentIsDisabled && this.selectionType === 'leaf'))\n      )\n    },\n    key (): string {\n      return getObjectValueByPath(this.item, this.itemKey)\n    },\n    children (): any[] | null {\n      const children = getObjectValueByPath(this.item, this.itemChildren)\n      return children && children.filter((child: any) => !this.treeview.isExcluded(getObjectValueByPath(child, this.itemKey)))\n    },\n    text (): string {\n      return getObjectValueByPath(this.item, this.itemText)\n    },\n    scopedProps (): object {\n      return {\n        item: this.item,\n        leaf: !this.children,\n        selected: this.isSelected,\n        indeterminate: this.isIndeterminate,\n        active: this.isActive,\n        open: this.isOpen,\n      }\n    },\n    computedIcon (): string {\n      if (this.isIndeterminate) return this.indeterminateIcon\n      else if (this.isSelected) return this.onIcon\n      else return this.offIcon\n    },\n    hasChildren (): boolean {\n      return !!this.children && (!!this.children.length || !!this.loadChildren)\n    },\n  },\n\n  created () {\n    this.treeview.register(this)\n  },\n\n  beforeDestroy () {\n    this.treeview.unregister(this)\n  },\n\n  methods: {\n    checkChildren (): Promise<void> {\n      return new Promise<void>(resolve => {\n        // TODO: Potential issue with always trying\n        // to load children if response is empty?\n        if (!this.children || this.children.length || !this.loadChildren || this.hasLoaded) return resolve()\n\n        this.isLoading = true\n        resolve(this.loadChildren(this.item))\n      }).then(() => {\n        this.isLoading = false\n        this.hasLoaded = true\n      })\n    },\n    open () {\n      this.isOpen = !this.isOpen\n      this.treeview.updateOpen(this.key, this.isOpen)\n      this.treeview.emitOpen()\n    },\n    genLabel () {\n      const children = []\n\n      if (this.$scopedSlots.label) children.push(this.$scopedSlots.label(this.scopedProps))\n      else children.push(this.text)\n\n      return this.$createElement('div', {\n        slot: 'label',\n        staticClass: 'v-treeview-node__label',\n      }, children)\n    },\n    genPrependSlot () {\n      if (!this.$scopedSlots.prepend) return null\n\n      return this.$createElement('div', {\n        staticClass: 'v-treeview-node__prepend',\n      }, this.$scopedSlots.prepend(this.scopedProps))\n    },\n    genAppendSlot () {\n      if (!this.$scopedSlots.append) return null\n\n      return this.$createElement('div', {\n        staticClass: 'v-treeview-node__append',\n      }, this.$scopedSlots.append(this.scopedProps))\n    },\n    genContent () {\n      const children = [\n        this.genPrependSlot(),\n        this.genLabel(),\n        this.genAppendSlot(),\n      ]\n\n      return this.$createElement('div', {\n        staticClass: 'v-treeview-node__content',\n      }, children)\n    },\n    genToggle () {\n      return this.$createElement(VIcon, {\n        staticClass: 'v-treeview-node__toggle',\n        class: {\n          'v-treeview-node__toggle--open': this.isOpen,\n          'v-treeview-node__toggle--loading': this.isLoading,\n        },\n        slot: 'prepend',\n        on: {\n          click: (e: MouseEvent) => {\n            e.stopPropagation()\n\n            if (this.isLoading) return\n\n            this.checkChildren().then(() => this.open())\n          },\n        },\n      }, [this.isLoading ? this.loadingIcon : this.expandIcon])\n    },\n    genCheckbox () {\n      return this.$createElement(VIcon, {\n        staticClass: 'v-treeview-node__checkbox',\n        props: {\n          color: this.isSelected || this.isIndeterminate ? this.selectedColor : undefined,\n          disabled: this.disabled,\n        },\n        on: {\n          click: (e: MouseEvent) => {\n            e.stopPropagation()\n\n            if (this.isLoading) return\n\n            this.checkChildren().then(() => {\n              // We nextTick here so that items watch in VTreeview has a chance to run first\n              this.$nextTick(() => {\n                this.isSelected = !this.isSelected\n                this.isIndeterminate = false\n\n                this.treeview.updateSelected(this.key, this.isSelected)\n                this.treeview.emitSelected()\n              })\n            })\n          },\n        },\n      }, [this.computedIcon])\n    },\n    genLevel (level: number) {\n      return createRange(level).map(() => this.$createElement('div', {\n        staticClass: 'v-treeview-node__level',\n      }))\n    },\n    genNode () {\n      const children = [this.genContent()]\n\n      if (this.selectable) children.unshift(this.genCheckbox())\n\n      if (this.hasChildren) {\n        children.unshift(this.genToggle())\n      } else {\n        children.unshift(...this.genLevel(1))\n      }\n\n      children.unshift(...this.genLevel(this.level))\n\n      return this.$createElement('div', this.setTextColor(this.isActive && this.color, {\n        staticClass: 'v-treeview-node__root',\n        class: {\n          [this.activeClass]: this.isActive,\n        },\n        on: {\n          click: () => {\n            if (this.openOnClick && this.hasChildren) {\n              this.checkChildren().then(this.open)\n            } else if (this.activatable && !this.disabled) {\n              this.isActive = !this.isActive\n              this.treeview.updateActive(this.key, this.isActive)\n              this.treeview.emitActive()\n            }\n          },\n        },\n      }), children)\n    },\n    genChild (item: any, parentIsDisabled: boolean) {\n      return this.$createElement(VTreeviewNode, {\n        key: getObjectValueByPath(item, this.itemKey),\n        props: {\n          activatable: this.activatable,\n          activeClass: this.activeClass,\n          item,\n          selectable: this.selectable,\n          selectedColor: this.selectedColor,\n          color: this.color,\n          disablePerNode: this.disablePerNode,\n          expandIcon: this.expandIcon,\n          indeterminateIcon: this.indeterminateIcon,\n          offIcon: this.offIcon,\n          onIcon: this.onIcon,\n          loadingIcon: this.loadingIcon,\n          itemKey: this.itemKey,\n          itemText: this.itemText,\n          itemDisabled: this.itemDisabled,\n          itemChildren: this.itemChildren,\n          loadChildren: this.loadChildren,\n          transition: this.transition,\n          openOnClick: this.openOnClick,\n          rounded: this.rounded,\n          shaped: this.shaped,\n          level: this.level + 1,\n          selectionType: this.selectionType,\n          parentIsDisabled,\n        },\n        scopedSlots: this.$scopedSlots,\n      })\n    },\n    genChildrenWrapper () {\n      if (!this.isOpen || !this.children) return null\n\n      const children = [this.children.map(c => this.genChild(c, this.disabled))]\n\n      return this.$createElement('div', {\n        staticClass: 'v-treeview-node__children',\n      }, children)\n    },\n    genTransition () {\n      return this.$createElement(VExpandTransition, [this.genChildrenWrapper()])\n    },\n  },\n\n  render (h): VNode {\n    const children: VNodeChildren = [this.genNode()]\n\n    if (this.transition) children.push(this.genTransition())\n    else children.push(this.genChildrenWrapper())\n\n    return h('div', {\n      staticClass: 'v-treeview-node',\n      class: {\n        'v-treeview-node--leaf': !this.hasChildren,\n        'v-treeview-node--click': this.openOnClick,\n        'v-treeview-node--disabled': this.disabled,\n        'v-treeview-node--rounded': this.rounded,\n        'v-treeview-node--shaped': this.shaped,\n        'v-treeview-node--selected': this.isSelected,\n      },\n      attrs: {\n        'aria-expanded': String(this.isOpen),\n      },\n    }, children)\n  },\n})\n\nexport default VTreeviewNode\n","import { getObjectValueByPath } from '../../../util/helpers'\nimport { TreeviewItemFunction } from 'vuetify/types'\n\nexport function filterTreeItem (item: object, search: string, textKey: string): boolean {\n  const text = getObjectValueByPath(item, textKey)\n\n  return text.toLocaleLowerCase().indexOf(search.toLocaleLowerCase()) > -1\n}\n\nexport function filterTreeItems (\n  filter: TreeviewItemFunction,\n  item: any,\n  search: string,\n  idKey: string,\n  textKey: string,\n  childrenKey: string,\n  excluded: Set<string | number>\n): boolean {\n  if (filter(item, search, textKey)) {\n    return true\n  }\n\n  const children = getObjectValueByPath(item, childrenKey)\n\n  if (children) {\n    let match = false\n    for (let i = 0; i < children.length; i++) {\n      if (filterTreeItems(filter, children[i], search, idKey, textKey, childrenKey, excluded)) {\n        match = true\n      }\n    }\n\n    if (match) return true\n  }\n\n  excluded.add(getObjectValueByPath(item, idKey))\n\n  return false\n}\n","// Styles\nimport './VTreeview.sass'\n\n// Types\nimport { VNode, VNodeChildrenArrayContents, PropType } from 'vue'\nimport { PropValidator } from 'vue/types/options'\nimport { TreeviewItemFunction } from 'vuetify/types'\n\n// Components\nimport VTreeviewNode, { VTreeviewNodeProps } from './VTreeviewNode'\n\n// Mixins\nimport Themeable from '../../mixins/themeable'\nimport { provide as RegistrableProvide } from '../../mixins/registrable'\n\n// Utils\nimport {\n  arrayDiff,\n  deepEqual,\n  getObjectValueByPath,\n} from '../../util/helpers'\nimport mixins from '../../util/mixins'\nimport { consoleWarn } from '../../util/console'\nimport {\n  filterTreeItems,\n  filterTreeItem,\n} from './util/filterTreeItems'\n\ntype VTreeviewNodeInstance = InstanceType<typeof VTreeviewNode>\n\ntype NodeCache = Set<string | number>\ntype NodeArray = (string | number)[]\n\ntype NodeState = {\n  parent: number | string | null\n  children: (number | string)[]\n  vnode: VTreeviewNodeInstance | null\n  isActive: boolean\n  isSelected: boolean\n  isIndeterminate: boolean\n  isOpen: boolean\n  item: any\n}\n\nexport default mixins(\n  RegistrableProvide('treeview'),\n  Themeable\n  /* @vue/component */\n).extend({\n  name: 'v-treeview',\n\n  provide (): object {\n    return { treeview: this }\n  },\n\n  props: {\n    active: {\n      type: Array,\n      default: () => ([]),\n    } as PropValidator<NodeArray>,\n    dense: Boolean,\n    disabled: Boolean,\n    filter: Function as PropType<TreeviewItemFunction>,\n    hoverable: Boolean,\n    items: {\n      type: Array,\n      default: () => ([]),\n    } as PropValidator<any[]>,\n    multipleActive: Boolean,\n    open: {\n      type: Array,\n      default: () => ([]),\n    } as PropValidator<NodeArray>,\n    openAll: Boolean,\n    returnObject: {\n      type: Boolean,\n      default: false, // TODO: Should be true in next major\n    },\n    search: String,\n    value: {\n      type: Array,\n      default: () => ([]),\n    } as PropValidator<NodeArray>,\n    ...VTreeviewNodeProps,\n  },\n\n  data: () => ({\n    level: -1,\n    activeCache: new Set() as NodeCache,\n    nodes: {} as Record<string | number, NodeState>,\n    openCache: new Set() as NodeCache,\n    selectedCache: new Set() as NodeCache,\n  }),\n\n  computed: {\n    excludedItems (): Set<string | number> {\n      const excluded = new Set<string|number>()\n\n      if (!this.search) return excluded\n\n      for (let i = 0; i < this.items.length; i++) {\n        filterTreeItems(\n          this.filter || filterTreeItem,\n          this.items[i],\n          this.search,\n          this.itemKey,\n          this.itemText,\n          this.itemChildren,\n          excluded\n        )\n      }\n\n      return excluded\n    },\n  },\n\n  watch: {\n    items: {\n      handler () {\n        const oldKeys = Object.keys(this.nodes).map(k => getObjectValueByPath(this.nodes[k].item, this.itemKey))\n        const newKeys = this.getKeys(this.items)\n        const diff = arrayDiff(newKeys, oldKeys)\n\n        // We only want to do stuff if items have changed\n        if (!diff.length && newKeys.length < oldKeys.length) return\n\n        // If nodes are removed we need to clear them from this.nodes\n        diff.forEach(k => delete this.nodes[k])\n\n        const oldSelectedCache = [...this.selectedCache]\n        this.selectedCache = new Set()\n        this.activeCache = new Set()\n        this.openCache = new Set()\n        this.buildTree(this.items)\n\n        // Only emit selected if selection has changed\n        // as a result of items changing. This fixes a\n        // potential double emit when selecting a node\n        // with dynamic children\n        if (!deepEqual(oldSelectedCache, [...this.selectedCache])) this.emitSelected()\n      },\n      deep: true,\n    },\n    active (value: (string | number | any)[]) {\n      this.handleNodeCacheWatcher(value, this.activeCache, this.updateActive, this.emitActive)\n    },\n    value (value: (string | number | any)[]) {\n      this.handleNodeCacheWatcher(value, this.selectedCache, this.updateSelected, this.emitSelected)\n    },\n    open (value: (string | number | any)[]) {\n      this.handleNodeCacheWatcher(value, this.openCache, this.updateOpen, this.emitOpen)\n    },\n  },\n\n  created () {\n    const getValue = (key: string | number) => this.returnObject ? getObjectValueByPath(key, this.itemKey) : key\n\n    this.buildTree(this.items)\n\n    for (const value of this.value.map(getValue)) {\n      this.updateSelected(value, true, true)\n    }\n\n    for (const active of this.active.map(getValue)) {\n      this.updateActive(active, true)\n    }\n  },\n\n  mounted () {\n    // Save the developer from themselves\n    if (this.$slots.prepend || this.$slots.append) {\n      consoleWarn('The prepend and append slots require a slot-scope attribute', this)\n    }\n\n    if (this.openAll) {\n      this.updateAll(true)\n    } else {\n      this.open.forEach(key => this.updateOpen(this.returnObject ? getObjectValueByPath(key, this.itemKey) : key, true))\n      this.emitOpen()\n    }\n  },\n\n  methods: {\n    /** @public */\n    updateAll (value: boolean) {\n      Object.keys(this.nodes).forEach(key => this.updateOpen(getObjectValueByPath(this.nodes[key].item, this.itemKey), value))\n      this.emitOpen()\n    },\n    getKeys (items: any[], keys: any[] = []) {\n      for (let i = 0; i < items.length; i++) {\n        const key = getObjectValueByPath(items[i], this.itemKey)\n        keys.push(key)\n        const children = getObjectValueByPath(items[i], this.itemChildren)\n        if (children) {\n          keys.push(...this.getKeys(children))\n        }\n      }\n\n      return keys\n    },\n    buildTree (items: any[], parent: (string | number | null) = null) {\n      for (let i = 0; i < items.length; i++) {\n        const item = items[i]\n        const key = getObjectValueByPath(item, this.itemKey)\n        const children = getObjectValueByPath(item, this.itemChildren) ?? []\n        const oldNode = this.nodes.hasOwnProperty(key) ? this.nodes[key] : {\n          isSelected: false, isIndeterminate: false, isActive: false, isOpen: false, vnode: null,\n        } as NodeState\n\n        const node: any = {\n          vnode: oldNode.vnode,\n          parent,\n          children: children.map((c: any) => getObjectValueByPath(c, this.itemKey)),\n          item,\n        }\n\n        this.buildTree(children, key)\n\n        // This fixed bug with dynamic children resetting selected parent state\n        if (\n          this.selectionType !== 'independent' &&\n          parent !== null &&\n          !this.nodes.hasOwnProperty(key) &&\n          this.nodes.hasOwnProperty(parent)\n        ) {\n          node.isSelected = this.nodes[parent].isSelected\n        } else {\n          node.isSelected = oldNode.isSelected\n          node.isIndeterminate = oldNode.isIndeterminate\n        }\n\n        node.isActive = oldNode.isActive\n        node.isOpen = oldNode.isOpen\n\n        this.nodes[key] = node\n\n        if (children.length && this.selectionType !== 'independent') {\n          const { isSelected, isIndeterminate } = this.calculateState(key, this.nodes)\n\n          node.isSelected = isSelected\n          node.isIndeterminate = isIndeterminate\n        }\n\n        // Don't forget to rebuild cache\n        if (this.nodes[key].isSelected && (this.selectionType === 'independent' || node.children.length === 0)) this.selectedCache.add(key)\n        if (this.nodes[key].isActive) this.activeCache.add(key)\n        if (this.nodes[key].isOpen) this.openCache.add(key)\n\n        this.updateVnodeState(key)\n      }\n    },\n    calculateState (node: string | number, state: Record<string | number, NodeState>) {\n      const children = state[node].children\n      const counts = children.reduce((counts: number[], child: string | number) => {\n        counts[0] += +Boolean(state[child].isSelected)\n        counts[1] += +Boolean(state[child].isIndeterminate)\n\n        return counts\n      }, [0, 0])\n\n      const isSelected = !!children.length && counts[0] === children.length\n      const isIndeterminate = !isSelected && (counts[0] > 0 || counts[1] > 0)\n\n      return {\n        isSelected,\n        isIndeterminate,\n      }\n    },\n    emitOpen () {\n      this.emitNodeCache('update:open', this.openCache)\n    },\n    emitSelected () {\n      this.emitNodeCache('input', this.selectedCache)\n    },\n    emitActive () {\n      this.emitNodeCache('update:active', this.activeCache)\n    },\n    emitNodeCache (event: string, cache: NodeCache) {\n      this.$emit(event, this.returnObject ? [...cache].map(key => this.nodes[key].item) : [...cache])\n    },\n    handleNodeCacheWatcher (value: any[], cache: NodeCache, updateFn: Function, emitFn: Function) {\n      value = this.returnObject ? value.map(v => getObjectValueByPath(v, this.itemKey)) : value\n      const old = [...cache]\n      if (deepEqual(old, value)) return\n\n      old.forEach(key => updateFn(key, false))\n      value.forEach(key => updateFn(key, true))\n\n      emitFn()\n    },\n    getDescendants (key: string | number, descendants: NodeArray = []) {\n      const children = this.nodes[key].children\n\n      descendants.push(...children)\n\n      for (let i = 0; i < children.length; i++) {\n        descendants = this.getDescendants(children[i], descendants)\n      }\n\n      return descendants\n    },\n    getParents (key: string | number) {\n      let parent = this.nodes[key].parent\n\n      const parents = []\n      while (parent !== null) {\n        parents.push(parent)\n        parent = this.nodes[parent].parent\n      }\n\n      return parents\n    },\n    register (node: VTreeviewNodeInstance) {\n      const key = getObjectValueByPath(node.item, this.itemKey)\n      this.nodes[key].vnode = node\n\n      this.updateVnodeState(key)\n    },\n    unregister (node: VTreeviewNodeInstance) {\n      const key = getObjectValueByPath(node.item, this.itemKey)\n      if (this.nodes[key]) this.nodes[key].vnode = null\n    },\n    isParent (key: string | number) {\n      return this.nodes[key].children && this.nodes[key].children.length\n    },\n    updateActive (key: string | number, isActive: boolean) {\n      if (!this.nodes.hasOwnProperty(key)) return\n\n      if (!this.multipleActive) {\n        this.activeCache.forEach(active => {\n          this.nodes[active].isActive = false\n          this.updateVnodeState(active)\n          this.activeCache.delete(active)\n        })\n      }\n\n      const node = this.nodes[key]\n      if (!node) return\n\n      if (isActive) this.activeCache.add(key)\n      else this.activeCache.delete(key)\n\n      node.isActive = isActive\n\n      this.updateVnodeState(key)\n    },\n    updateSelected (key: string | number, isSelected: boolean, isForced = false) {\n      if (!this.nodes.hasOwnProperty(key)) return\n\n      const changed = new Map()\n\n      if (this.selectionType !== 'independent') {\n        for (const descendant of this.getDescendants(key)) {\n          if (!getObjectValueByPath(this.nodes[descendant].item, this.itemDisabled) || isForced) {\n            this.nodes[descendant].isSelected = isSelected\n            this.nodes[descendant].isIndeterminate = false\n            changed.set(descendant, isSelected)\n          }\n        }\n\n        const calculated = this.calculateState(key, this.nodes)\n        this.nodes[key].isSelected = isSelected\n        this.nodes[key].isIndeterminate = calculated.isIndeterminate\n        changed.set(key, isSelected)\n\n        for (const parent of this.getParents(key)) {\n          const calculated = this.calculateState(parent, this.nodes)\n          this.nodes[parent].isSelected = calculated.isSelected\n          this.nodes[parent].isIndeterminate = calculated.isIndeterminate\n          changed.set(parent, calculated.isSelected)\n        }\n      } else {\n        this.nodes[key].isSelected = isSelected\n        this.nodes[key].isIndeterminate = false\n        changed.set(key, isSelected)\n      }\n\n      for (const [key, value] of changed.entries()) {\n        this.updateVnodeState(key)\n\n        if (this.selectionType === 'leaf' && this.isParent(key)) continue\n\n        value === true ? this.selectedCache.add(key) : this.selectedCache.delete(key)\n      }\n    },\n    updateOpen (key: string | number, isOpen: boolean) {\n      if (!this.nodes.hasOwnProperty(key)) return\n\n      const node = this.nodes[key]\n      const children = getObjectValueByPath(node.item, this.itemChildren)\n\n      if (children && !children.length && node.vnode && !node.vnode.hasLoaded) {\n        node.vnode.checkChildren().then(() => this.updateOpen(key, isOpen))\n      } else if (children && children.length) {\n        node.isOpen = isOpen\n\n        node.isOpen ? this.openCache.add(key) : this.openCache.delete(key)\n\n        this.updateVnodeState(key)\n      }\n    },\n    updateVnodeState (key: string | number) {\n      const node = this.nodes[key]\n\n      if (node && node.vnode) {\n        node.vnode.isSelected = node.isSelected\n        node.vnode.isIndeterminate = node.isIndeterminate\n        node.vnode.isActive = node.isActive\n        node.vnode.isOpen = node.isOpen\n      }\n    },\n    isExcluded (key: string | number) {\n      return !!this.search && this.excludedItems.has(key)\n    },\n  },\n\n  render (h): VNode {\n    const children: VNodeChildrenArrayContents = this.items.length\n      ? this.items.filter(item => {\n        return !this.isExcluded(getObjectValueByPath(item, this.itemKey))\n      }).map(item => {\n        const genChild = VTreeviewNode.options.methods.genChild.bind(this)\n\n        return genChild(item, this.disabled || getObjectValueByPath(item, this.itemDisabled))\n      })\n      /* istanbul ignore next */\n      : this.$slots.default! // TODO: remove type annotation with TS 3.2\n\n    return h('div', {\n      staticClass: 'v-treeview',\n      class: {\n        'v-treeview--hoverable': this.hoverable,\n        'v-treeview--dense': this.dense,\n        ...this.themeClasses,\n      },\n    }, children)\n  },\n})\n"],"sourceRoot":""}