add some packages

node_modules/core-js/modules/core.dict.js

@@ -0,0 +1,157 @@
+'use strict';
+var ctx = require('./_ctx');
+var $export = require('./_export');
+var createDesc = require('./_property-desc');
+var assign = require('./_object-assign');
+var create = require('./_object-create');
+var getPrototypeOf = require('./_object-gpo');
+var getKeys = require('./_object-keys');
+var dP = require('./_object-dp');
+var keyOf = require('./_keyof');
+var aFunction = require('./_a-function');
+var forOf = require('./_for-of');
+var isIterable = require('./core.is-iterable');
+var $iterCreate = require('./_iter-create');
+var step = require('./_iter-step');
+var isObject = require('./_is-object');
+var toIObject = require('./_to-iobject');
+var DESCRIPTORS = require('./_descriptors');
+var has = require('./_has');
+
+// 0 -> Dict.forEach
+// 1 -> Dict.map
+// 2 -> Dict.filter
+// 3 -> Dict.some
+// 4 -> Dict.every
+// 5 -> Dict.find
+// 6 -> Dict.findKey
+// 7 -> Dict.mapPairs
+var createDictMethod = function (TYPE) {
+  var IS_MAP = TYPE == 1;
+  var IS_EVERY = TYPE == 4;
+  return function (object, callbackfn, that /* = undefined */) {
+    var f = ctx(callbackfn, that, 3);
+    var O = toIObject(object);
+    var result = IS_MAP || TYPE == 7 || TYPE == 2
+          ? new (typeof this == 'function' ? this : Dict)() : undefined;
+    var key, val, res;
+    for (key in O) if (has(O, key)) {
+      val = O[key];
+      res = f(val, key, object);
+      if (TYPE) {
+        if (IS_MAP) result[key] = res;          // map
+        else if (res) switch (TYPE) {
+          case 2: result[key] = val; break;     // filter
+          case 3: return true;                  // some
+          case 5: return val;                   // find
+          case 6: return key;                   // findKey
+          case 7: result[res[0]] = res[1];      // mapPairs
+        } else if (IS_EVERY) return false;      // every
+      }
+    }
+    return TYPE == 3 || IS_EVERY ? IS_EVERY : result;
+  };
+};
+var findKey = createDictMethod(6);
+
+var createDictIter = function (kind) {
+  return function (it) {
+    return new DictIterator(it, kind);
+  };
+};
+var DictIterator = function (iterated, kind) {
+  this._t = toIObject(iterated); // target
+  this._a = getKeys(iterated);   // keys
+  this._i = 0;                   // next index
+  this._k = kind;                // kind
+};
+$iterCreate(DictIterator, 'Dict', function () {
+  var that = this;
+  var O = that._t;
+  var keys = that._a;
+  var kind = that._k;
+  var key;
+  do {
+    if (that._i >= keys.length) {
+      that._t = undefined;
+      return step(1);
+    }
+  } while (!has(O, key = keys[that._i++]));
+  if (kind == 'keys') return step(0, key);
+  if (kind == 'values') return step(0, O[key]);
+  return step(0, [key, O[key]]);
+});
+
+function Dict(iterable) {
+  var dict = create(null);
+  if (iterable != undefined) {
+    if (isIterable(iterable)) {
+      forOf(iterable, true, function (key, value) {
+        dict[key] = value;
+      });
+    } else assign(dict, iterable);
+  }
+  return dict;
+}
+Dict.prototype = null;
+
+function reduce(object, mapfn, init) {
+  aFunction(mapfn);
+  var O = toIObject(object);
+  var keys = getKeys(O);
+  var length = keys.length;
+  var i = 0;
+  var memo, key;
+  if (arguments.length < 3) {
+    if (!length) throw TypeError('Reduce of empty object with no initial value');
+    memo = O[keys[i++]];
+  } else memo = Object(init);
+  while (length > i) if (has(O, key = keys[i++])) {
+    memo = mapfn(memo, O[key], key, object);
+  }
+  return memo;
+}
+
+function includes(object, el) {
+  // eslint-disable-next-line no-self-compare
+  return (el == el ? keyOf(object, el) : findKey(object, function (it) {
+    // eslint-disable-next-line no-self-compare
+    return it != it;
+  })) !== undefined;
+}
+
+function get(object, key) {
+  if (has(object, key)) return object[key];
+}
+function set(object, key, value) {
+  if (DESCRIPTORS && key in Object) dP.f(object, key, createDesc(0, value));
+  else object[key] = value;
+  return object;
+}
+
+function isDict(it) {
+  return isObject(it) && getPrototypeOf(it) === Dict.prototype;
+}
+
+$export($export.G + $export.F, { Dict: Dict });
+
+$export($export.S, 'Dict', {
+  keys: createDictIter('keys'),
+  values: createDictIter('values'),
+  entries: createDictIter('entries'),
+  forEach: createDictMethod(0),
+  map: createDictMethod(1),
+  filter: createDictMethod(2),
+  some: createDictMethod(3),
+  every: createDictMethod(4),
+  find: createDictMethod(5),
+  findKey: findKey,
+  mapPairs: createDictMethod(7),
+  reduce: reduce,
+  keyOf: keyOf,
+  includes: includes,
+  has: has,
+  get: get,
+  set: set,
+  isDict: isDict
+});