.config/coc/extensions/node_modules/coc-prettier/node_modules/core-js/internals/collection-strong.js

   1 'use strict';
   2 var defineProperty = require('../internals/object-define-property').f;
   3 var create = require('../internals/object-create');
   4 var redefineAll = require('../internals/redefine-all');
   5 var bind = require('../internals/function-bind-context');
   6 var anInstance = require('../internals/an-instance');
   7 var iterate = require('../internals/iterate');
   8 var defineIterator = require('../internals/define-iterator');
   9 var setSpecies = require('../internals/set-species');
  10 var DESCRIPTORS = require('../internals/descriptors');
  11 var fastKey = require('../internals/internal-metadata').fastKey;
  12 var InternalStateModule = require('../internals/internal-state');
  13
  14 var setInternalState = InternalStateModule.set;
  15 var internalStateGetterFor = InternalStateModule.getterFor;
  16
  17 module.exports = {
  18   getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
  19     var C = wrapper(function (that, iterable) {
  20       anInstance(that, C, CONSTRUCTOR_NAME);
  21       setInternalState(that, {
  22         type: CONSTRUCTOR_NAME,
  23         index: create(null),
  24         first: undefined,
  25         last: undefined,
  26         size: 0
  27       });
  28       if (!DESCRIPTORS) that.size = 0;
  29       if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });
  30     });
  31
  32     var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
  33
  34     var define = function (that, key, value) {
  35       var state = getInternalState(that);
  36       var entry = getEntry(that, key);
  37       var previous, index;
  38       // change existing entry
  39       if (entry) {
  40         entry.value = value;
  41       // create new entry
  42       } else {
  43         state.last = entry = {
  44           index: index = fastKey(key, true),
  45           key: key,
  46           value: value,
  47           previous: previous = state.last,
  48           next: undefined,
  49           removed: false
  50         };
  51         if (!state.first) state.first = entry;
  52         if (previous) previous.next = entry;
  53         if (DESCRIPTORS) state.size++;
  54         else that.size++;
  55         // add to index
  56         if (index !== 'F') state.index[index] = entry;
  57       } return that;
  58     };
  59
  60     var getEntry = function (that, key) {
  61       var state = getInternalState(that);
  62       // fast case
  63       var index = fastKey(key);
  64       var entry;
  65       if (index !== 'F') return state.index[index];
  66       // frozen object case
  67       for (entry = state.first; entry; entry = entry.next) {
  68         if (entry.key == key) return entry;
  69       }
  70     };
  71
  72     redefineAll(C.prototype, {
  73       // 23.1.3.1 Map.prototype.clear()
  74       // 23.2.3.2 Set.prototype.clear()
  75       clear: function clear() {
  76         var that = this;
  77         var state = getInternalState(that);
  78         var data = state.index;
  79         var entry = state.first;
  80         while (entry) {
  81           entry.removed = true;
  82           if (entry.previous) entry.previous = entry.previous.next = undefined;
  83           delete data[entry.index];
  84           entry = entry.next;
  85         }
  86         state.first = state.last = undefined;
  87         if (DESCRIPTORS) state.size = 0;
  88         else that.size = 0;
  89       },
  90       // 23.1.3.3 Map.prototype.delete(key)
  91       // 23.2.3.4 Set.prototype.delete(value)
  92       'delete': function (key) {
  93         var that = this;
  94         var state = getInternalState(that);
  95         var entry = getEntry(that, key);
  96         if (entry) {
  97           var next = entry.next;
  98           var prev = entry.previous;
  99           delete state.index[entry.index];
 100           entry.removed = true;
 101           if (prev) prev.next = next;
 102           if (next) next.previous = prev;
 103           if (state.first == entry) state.first = next;
 104           if (state.last == entry) state.last = prev;
 105           if (DESCRIPTORS) state.size--;
 106           else that.size--;
 107         } return !!entry;
 108       },
 109       // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
 110       // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
 111       forEach: function forEach(callbackfn /* , that = undefined */) {
 112         var state = getInternalState(this);
 113         var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
 114         var entry;
 115         while (entry = entry ? entry.next : state.first) {
 116           boundFunction(entry.value, entry.key, this);
 117           // revert to the last existing entry
 118           while (entry && entry.removed) entry = entry.previous;
 119         }
 120       },
 121       // 23.1.3.7 Map.prototype.has(key)
 122       // 23.2.3.7 Set.prototype.has(value)
 123       has: function has(key) {
 124         return !!getEntry(this, key);
 125       }
 126     });
 127
 128     redefineAll(C.prototype, IS_MAP ? {
 129       // 23.1.3.6 Map.prototype.get(key)
 130       get: function get(key) {
 131         var entry = getEntry(this, key);
 132         return entry && entry.value;
 133       },
 134       // 23.1.3.9 Map.prototype.set(key, value)
 135       set: function set(key, value) {
 136         return define(this, key === 0 ? 0 : key, value);
 137       }
 138     } : {
 139       // 23.2.3.1 Set.prototype.add(value)
 140       add: function add(value) {
 141         return define(this, value = value === 0 ? 0 : value, value);
 142       }
 143     });
 144     if (DESCRIPTORS) defineProperty(C.prototype, 'size', {
 145       get: function () {
 146         return getInternalState(this).size;
 147       }
 148     });
 149     return C;
 150   },
 151   setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {
 152     var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';
 153     var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);
 154     var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);
 155     // add .keys, .values, .entries, [@@iterator]
 156     // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
 157     defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {
 158       setInternalState(this, {
 159         type: ITERATOR_NAME,
 160         target: iterated,
 161         state: getInternalCollectionState(iterated),
 162         kind: kind,
 163         last: undefined
 164       });
 165     }, function () {
 166       var state = getInternalIteratorState(this);
 167       var kind = state.kind;
 168       var entry = state.last;
 169       // revert to the last existing entry
 170       while (entry && entry.removed) entry = entry.previous;
 171       // get next entry
 172       if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {
 173         // or finish the iteration
 174         state.target = undefined;
 175         return { value: undefined, done: true };
 176       }
 177       // return step by kind
 178       if (kind == 'keys') return { value: entry.key, done: false };
 179       if (kind == 'values') return { value: entry.value, done: false };
 180       return { value: [entry.key, entry.value], done: false };
 181     }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
 182
 183     // add [@@species], 23.1.2.2, 23.2.2.2
 184     setSpecies(CONSTRUCTOR_NAME);
 185   }
 186 };