text: (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
  (function (global){
  "use strict";
  
  require("core-js/shim");
  
  require("regenerator-runtime/runtime");
  
  require("core-js/fn/regexp/escape");
  
  if (global._babelPolyfill) {
    throw new Error("only one instance of babel-polyfill is allowed");
  }
  global._babelPolyfill = true;
  
  var DEFINE_PROPERTY = "defineProperty";
  function define(O, key, value) {
    O[key] || Object[DEFINE_PROPERTY](O, key, {
      writable: true,
      configurable: true,
      value: value
    });
  }
  
  define(String.prototype, "padLeft", "".padStart);
  define(String.prototype, "padRight", "".padEnd);
  
  "pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill".split(",").forEach(function (key) {
    [][key] && define(Array, key, Function.call.bind([][key]));
  });
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"core-js/fn/regexp/escape":3,"core-js/shim":296,"regenerator-runtime/runtime":299}],2:[function(require,module,exports){
  /*
   * base64-arraybuffer
   * https://github.com/niklasvh/base64-arraybuffer
   *
   * Copyright (c) 2012 Niklas von Hertzen
   * Licensed under the MIT license.
   */
  (function(){
    "use strict";
  
    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  
    // Use a lookup table to find the index.
    var lookup = new Uint8Array(256);
    for (var i = 0; i < chars.length; i++) {
      lookup[chars.charCodeAt(i)] = i;
    }
  
    exports.encode = function(arraybuffer, offset, length) {
      var bytes = new Uint8Array(arraybuffer, offset || 0, length !== undefined ? length : arraybuffer.byteLength),
      i, len = bytes.length, base64 = "";
  
      for (i = 0; i < len; i+=3) {
        base64 += chars[bytes[i] >> 2];
        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
        base64 += chars[bytes[i + 2] & 63];
      }
  
      if ((len % 3) === 2) {
        base64 = base64.substring(0, base64.length - 1) + "=";
      } else if (len % 3 === 1) {
        base64 = base64.substring(0, base64.length - 2) + "==";
      }
  
      return base64;
    };
  
    exports.decode =  function(base64) {
      var bufferLength = base64.length * 0.75,
      len = base64.length, i, p = 0,
      encoded1, encoded2, encoded3, encoded4;
  
      if (base64[base64.length - 1] === "=") {
        bufferLength--;
        if (base64[base64.length - 2] === "=") {
          bufferLength--;
        }
      }
  
      var arraybuffer = new ArrayBuffer(bufferLength),
      bytes = new Uint8Array(arraybuffer);
  
      for (i = 0; i < len; i+=4) {
        encoded1 = lookup[base64.charCodeAt(i)];
        encoded2 = lookup[base64.charCodeAt(i+1)];
        encoded3 = lookup[base64.charCodeAt(i+2)];
        encoded4 = lookup[base64.charCodeAt(i+3)];
  
        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
      }
  
      return arraybuffer;
    };
  })();
  
  },{}],3:[function(require,module,exports){
  require('../../modules/core.regexp.escape');
  module.exports = require('../../modules/_core').RegExp.escape;
  },{"../../modules/_core":24,"../../modules/core.regexp.escape":120}],4:[function(require,module,exports){
  module.exports = function(it){
    if(typeof it != 'function')throw TypeError(it + ' is not a function!');
    return it;
  };
  },{}],5:[function(require,module,exports){
  var cof = require('./_cof');
  module.exports = function(it, msg){
    if(typeof it != 'number' && cof(it) != 'Number')throw TypeError(msg);
    return +it;
  };
  },{"./_cof":19}],6:[function(require,module,exports){
  // 22.1.3.31 Array.prototype[@@unscopables]
  var UNSCOPABLES = require('./_wks')('unscopables')
    , ArrayProto  = Array.prototype;
  if(ArrayProto[UNSCOPABLES] == undefined)require('./_hide')(ArrayProto, UNSCOPABLES, {});
  module.exports = function(key){
    ArrayProto[UNSCOPABLES][key] = true;
  };
  },{"./_hide":41,"./_wks":118}],7:[function(require,module,exports){
  module.exports = function(it, Constructor, name, forbiddenField){
    if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){
      throw TypeError(name + ': incorrect invocation!');
    } return it;
  };
  },{}],8:[function(require,module,exports){
  var isObject = require('./_is-object');
  module.exports = function(it){
    if(!isObject(it))throw TypeError(it + ' is not an object!');
    return it;
  };
  },{"./_is-object":50}],9:[function(require,module,exports){
  // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
  'use strict';
  var toObject = require('./_to-object')
    , toIndex  = require('./_to-index')
    , toLength = require('./_to-length');
  
  module.exports = [].copyWithin || function copyWithin(target/*= 0*/, start/*= 0, end = @length*/){
    var O     = toObject(this)
      , len   = toLength(O.length)
      , to    = toIndex(target, len)
      , from  = toIndex(start, len)
      , end   = arguments.length > 2 ? arguments[2] : undefined
      , count = Math.min((end === undefined ? len : toIndex(end, len)) - from, len - to)
      , inc   = 1;
    if(from < to && to < from + count){
      inc  = -1;
      from += count - 1;
      to   += count - 1;
    }
    while(count-- > 0){
      if(from in O)O[to] = O[from];
      else delete O[to];
      to   += inc;
      from += inc;
    } return O;
  };
  },{"./_to-index":106,"./_to-length":109,"./_to-object":110}],10:[function(require,module,exports){
  // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
  'use strict';
  var toObject = require('./_to-object')
    , toIndex  = require('./_to-index')
    , toLength = require('./_to-length');
  module.exports = function fill(value /*, start = 0, end = @length */){
    var O      = toObject(this)
      , length = toLength(O.length)
      , aLen   = arguments.length
      , index  = toIndex(aLen > 1 ? arguments[1] : undefined, length)
      , end    = aLen > 2 ? arguments[2] : undefined
      , endPos = end === undefined ? length : toIndex(end, length);
    while(endPos > index)O[index++] = value;
    return O;
  };
  },{"./_to-index":106,"./_to-length":109,"./_to-object":110}],11:[function(require,module,exports){
  var forOf = require('./_for-of');
  
  module.exports = function(iter, ITERATOR){
    var result = [];
    forOf(iter, false, result.push, result, ITERATOR);
    return result;
  };
  
  },{"./_for-of":38}],12:[function(require,module,exports){
  // false -> Array#indexOf
  // true  -> Array#includes
  var toIObject = require('./_to-iobject')
    , toLength  = require('./_to-length')
    , toIndex   = require('./_to-index');
  module.exports = function(IS_INCLUDES){
    return function($this, el, fromIndex){
      var O      = toIObject($this)
        , length = toLength(O.length)
        , index  = toIndex(fromIndex, length)
        , value;
      // Array#includes uses SameValueZero equality algorithm
      if(IS_INCLUDES && el != el)while(length > index){
        value = O[index++];
        if(value != value)return true;
      // Array#toIndex ignores holes, Array#includes - not
      } else for(;length > index; index++)if(IS_INCLUDES || index in O){
        if(O[index] === el)return IS_INCLUDES || index || 0;
      } return !IS_INCLUDES && -1;
    };
  };
  },{"./_to-index":106,"./_to-iobject":108,"./_to-length":109}],13:[function(require,module,exports){
  // 0 -> Array#forEach
  // 1 -> Array#map
  // 2 -> Array#filter
  // 3 -> Array#some
  // 4 -> Array#every
  // 5 -> Array#find
  // 6 -> Array#findIndex
  var ctx      = require('./_ctx')
    , IObject  = require('./_iobject')
    , toObject = require('./_to-object')
    , toLength = require('./_to-length')
    , asc      = require('./_array-species-create');
  module.exports = function(TYPE, $create){
    var IS_MAP        = TYPE == 1
      , IS_FILTER     = TYPE == 2
      , IS_SOME       = TYPE == 3
      , IS_EVERY      = TYPE == 4
      , IS_FIND_INDEX = TYPE == 6
      , NO_HOLES      = TYPE == 5 || IS_FIND_INDEX
      , create        = $create || asc;
    return function($this, callbackfn, that){
      var O      = toObject($this)
        , self   = IObject(O)
        , f      = ctx(callbackfn, that, 3)
        , length = toLength(self.length)
        , index  = 0
        , result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined
        , val, res;
      for(;length > index; index++)if(NO_HOLES || index in self){
        val = self[index];
        res = f(val, index, O);
        if(TYPE){
          if(IS_MAP)result[index] = res;            // map
          else if(res)switch(TYPE){
            case 3: return true;                    // some
            case 5: return val;                     // find
            case 6: return index;                   // findIndex
            case 2: result.push(val);               // filter
          } else if(IS_EVERY)return false;          // every
        }
      }
      return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
    };
  };
  },{"./_array-species-create":16,"./_ctx":26,"./_iobject":46,"./_to-length":109,"./_to-object":110}],14:[function(require,module,exports){
  var aFunction = require('./_a-function')
    , toObject  = require('./_to-object')
    , IObject   = require('./_iobject')
    , toLength  = require('./_to-length');
  
  module.exports = function(that, callbackfn, aLen, memo, isRight){
    aFunction(callbackfn);
    var O      = toObject(that)
      , self   = IObject(O)
      , length = toLength(O.length)
      , index  = isRight ? length - 1 : 0
      , i      = isRight ? -1 : 1;
    if(aLen < 2)for(;;){
      if(index in self){
        memo = self[index];
        index += i;
        break;
      }
      index += i;
      if(isRight ? index < 0 : length <= index){
        throw TypeError('Reduce of empty array with no initial value');
      }
    }
    for(;isRight ? index >= 0 : length > index; index += i)if(index in self){
      memo = callbackfn(memo, self[index], index, O);
    }
    return memo;
  };
  },{"./_a-function":4,"./_iobject":46,"./_to-length":109,"./_to-object":110}],15:[function(require,module,exports){
  var isObject = require('./_is-object')
    , isArray  = require('./_is-array')
    , SPECIES  = require('./_wks')('species');
  
  module.exports = function(original){
    var C;
    if(isArray(original)){
      C = original.constructor;
      // cross-realm fallback
      if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined;
      if(isObject(C)){
        C = C[SPECIES];
        if(C === null)C = undefined;
      }
    } return C === undefined ? Array : C;
  };
  },{"./_is-array":48,"./_is-object":50,"./_wks":118}],16:[function(require,module,exports){
  // 9.4.2.3 ArraySpeciesCreate(originalArray, length)
  var speciesConstructor = require('./_array-species-constructor');
  
  module.exports = function(original, length){
    return new (speciesConstructor(original))(length);
  };
  },{"./_array-species-constructor":15}],17:[function(require,module,exports){
  'use strict';
  var aFunction  = require('./_a-function')
    , isObject   = require('./_is-object')
    , invoke     = require('./_invoke')
    , arraySlice = [].slice
    , factories  = {};
  
  var construct = function(F, len, args){
    if(!(len in factories)){
      for(var n = [], i = 0; i < len; i++)n[i] = 'a[' + i + ']';
      factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
    } return factories[len](F, args);
  };
  
  module.exports = Function.bind || function bind(that /*, args... */){
    var fn       = aFunction(this)
      , partArgs = arraySlice.call(arguments, 1);
    var bound = function(/* args... */){
      var args = partArgs.concat(arraySlice.call(arguments));
      return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);
    };
    if(isObject(fn.prototype))bound.prototype = fn.prototype;
    return bound;
  };
  },{"./_a-function":4,"./_invoke":45,"./_is-object":50}],18:[function(require,module,exports){
  // getting tag from 19.1.3.6 Object.prototype.toString()
  var cof = require('./_cof')
    , TAG = require('./_wks')('toStringTag')
    // ES3 wrong here
    , ARG = cof(function(){ return arguments; }()) == 'Arguments';
  
  // fallback for IE11 Script Access Denied error
  var tryGet = function(it, key){
    try {
      return it[key];
    } catch(e){ /* empty */ }
  };
  
  module.exports = function(it){
    var O, T, B;
    return it === undefined ? 'Undefined' : it === null ? 'Null'
      // @@toStringTag case
      : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
      // builtinTag case
      : ARG ? cof(O)
      // ES3 arguments fallback
      : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
  };
  },{"./_cof":19,"./_wks":118}],19:[function(require,module,exports){
  var toString = {}.toString;
  
  module.exports = function(it){
    return toString.call(it).slice(8, -1);
  };
  },{}],20:[function(require,module,exports){
  'use strict';
  var dP          = require('./_object-dp').f
    , create      = require('./_object-create')
    , redefineAll = require('./_redefine-all')
    , ctx         = require('./_ctx')
    , anInstance  = require('./_an-instance')
    , defined     = require('./_defined')
    , forOf       = require('./_for-of')
    , $iterDefine = require('./_iter-define')
    , step        = require('./_iter-step')
    , setSpecies  = require('./_set-species')
    , DESCRIPTORS = require('./_descriptors')
    , fastKey     = require('./_meta').fastKey
    , SIZE        = DESCRIPTORS ? '_s' : 'size';
  
  var getEntry = function(that, key){
    // fast case
    var index = fastKey(key), entry;
    if(index !== 'F')return that._i[index];
    // frozen object case
    for(entry = that._f; entry; entry = entry.n){
      if(entry.k == key)return entry;
    }
  };
  
  module.exports = {
    getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
      var C = wrapper(function(that, iterable){
        anInstance(that, C, NAME, '_i');
        that._i = create(null); // index
        that._f = undefined;    // first entry
        that._l = undefined;    // last entry
        that[SIZE] = 0;         // size
        if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
      });
      redefineAll(C.prototype, {
        // 23.1.3.1 Map.prototype.clear()
        // 23.2.3.2 Set.prototype.clear()
        clear: function clear(){
          for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){
            entry.r = true;
            if(entry.p)entry.p = entry.p.n = undefined;
            delete data[entry.i];
          }
          that._f = that._l = undefined;
          that[SIZE] = 0;
        },
        // 23.1.3.3 Map.prototype.delete(key)
        // 23.2.3.4 Set.prototype.delete(value)
        'delete': function(key){
          var that  = this
            , entry = getEntry(that, key);
          if(entry){
            var next = entry.n
              , prev = entry.p;
            delete that._i[entry.i];
            entry.r = true;
            if(prev)prev.n = next;
            if(next)next.p = prev;
            if(that._f == entry)that._f = next;
            if(that._l == entry)that._l = prev;
            that[SIZE]--;
          } return !!entry;
        },
        // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
        // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
        forEach: function forEach(callbackfn /*, that = undefined */){
          anInstance(this, C, 'forEach');
          var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3)
            , entry;
          while(entry = entry ? entry.n : this._f){
            f(entry.v, entry.k, this);
            // revert to the last existing entry
            while(entry && entry.r)entry = entry.p;
          }
        },
        // 23.1.3.7 Map.prototype.has(key)
        // 23.2.3.7 Set.prototype.has(value)
        has: function has(key){
          return !!getEntry(this, key);
        }
      });
      if(DESCRIPTORS)dP(C.prototype, 'size', {
        get: function(){
          return defined(this[SIZE]);
        }
      });
      return C;
    },
    def: function(that, key, value){
      var entry = getEntry(that, key)
        , prev, index;
      // change existing entry
      if(entry){
        entry.v = value;
      // create new entry
      } else {
        that._l = entry = {
          i: index = fastKey(key, true), // <- index
          k: key,                        // <- key
          v: value,                      // <- value
          p: prev = that._l,             // <- previous entry
          n: undefined,                  // <- next entry
          r: false                       // <- removed
        };
        if(!that._f)that._f = entry;
        if(prev)prev.n = entry;
        that[SIZE]++;
        // add to index
        if(index !== 'F')that._i[index] = entry;
      } return that;
    },
    getEntry: getEntry,
    setStrong: function(C, NAME, IS_MAP){
      // add .keys, .values, .entries, [@@iterator]
      // 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
      $iterDefine(C, NAME, function(iterated, kind){
        this._t = iterated;  // target
        this._k = kind;      // kind
        this._l = undefined; // previous
      }, function(){
        var that  = this
          , kind  = that._k
          , entry = that._l;
        // revert to the last existing entry
        while(entry && entry.r)entry = entry.p;
        // get next entry
        if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){
          // or finish the iteration
          that._t = undefined;
          return step(1);
        }
        // return step by kind
        if(kind == 'keys'  )return step(0, entry.k);
        if(kind == 'values')return step(0, entry.v);
        return step(0, [entry.k, entry.v]);
      }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);
  
      // add [@@species], 23.1.2.2, 23.2.2.2
      setSpecies(NAME);
    }
  };
  },{"./_an-instance":7,"./_ctx":26,"./_defined":28,"./_descriptors":29,"./_for-of":38,"./_iter-define":54,"./_iter-step":56,"./_meta":63,"./_object-create":67,"./_object-dp":68,"./_redefine-all":87,"./_set-species":92}],21:[function(require,module,exports){
  // https://github.com/DavidBruant/Map-Set.prototype.toJSON
  var classof = require('./_classof')
    , from    = require('./_array-from-iterable');
  module.exports = function(NAME){
    return function toJSON(){
      if(classof(this) != NAME)throw TypeError(NAME + "#toJSON isn't generic");
      return from(this);
    };
  };
  },{"./_array-from-iterable":11,"./_classof":18}],22:[function(require,module,exports){
  'use strict';
  var redefineAll       = require('./_redefine-all')
    , getWeak           = require('./_meta').getWeak
    , anObject          = require('./_an-object')
    , isObject          = require('./_is-object')
    , anInstance        = require('./_an-instance')
    , forOf             = require('./_for-of')
    , createArrayMethod = require('./_array-methods')
    , $has              = require('./_has')
    , arrayFind         = createArrayMethod(5)
    , arrayFindIndex    = createArrayMethod(6)
    , id                = 0;
  
  // fallback for uncaught frozen keys
  var uncaughtFrozenStore = function(that){
    return that._l || (that._l = new UncaughtFrozenStore);
  };
  var UncaughtFrozenStore = function(){
    this.a = [];
  };
  var findUncaughtFrozen = function(store, key){
    return arrayFind(store.a, function(it){
      return it[0] === key;
    });
  };
  UncaughtFrozenStore.prototype = {
    get: function(key){
      var entry = findUncaughtFrozen(this, key);
      if(entry)return entry[1];
    },
    has: function(key){
      return !!findUncaughtFrozen(this, key);
    },
    set: function(key, value){
      var entry = findUncaughtFrozen(this, key);
      if(entry)entry[1] = value;
      else this.a.push([key, value]);
    },
    'delete': function(key){
      var index = arrayFindIndex(this.a, function(it){
        return it[0] === key;
      });
      if(~index)this.a.splice(index, 1);
      return !!~index;
    }
  };
  
  module.exports = {
    getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
      var C = wrapper(function(that, iterable){
        anInstance(that, C, NAME, '_i');
        that._i = id++;      // collection id
        that._l = undefined; // leak store for uncaught frozen objects
        if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
      });
      redefineAll(C.prototype, {
        // 23.3.3.2 WeakMap.prototype.delete(key)
        // 23.4.3.3 WeakSet.prototype.delete(value)
        'delete': function(key){
          if(!isObject(key))return false;
          var data = getWeak(key);
          if(data === true)return uncaughtFrozenStore(this)['delete'](key);
          return data && $has(data, this._i) && delete data[this._i];
        },
        // 23.3.3.4 WeakMap.prototype.has(key)
        // 23.4.3.4 WeakSet.prototype.has(value)
        has: function has(key){
          if(!isObject(key))return false;
          var data = getWeak(key);
          if(data === true)return uncaughtFrozenStore(this).has(key);
          return data && $has(data, this._i);
        }
      });
      return C;
    },
    def: function(that, key, value){
      var data = getWeak(anObject(key), true);
      if(data === true)uncaughtFrozenStore(that).set(key, value);
      else data[that._i] = value;
      return that;
    },
    ufstore: uncaughtFrozenStore
  };
  },{"./_an-instance":7,"./_an-object":8,"./_array-methods":13,"./_for-of":38,"./_has":40,"./_is-object":50,"./_meta":63,"./_redefine-all":87}],23:[function(require,module,exports){
  'use strict';
  var global            = require('./_global')
    , $export           = require('./_export')
    , redefine          = require('./_redefine')
    , redefineAll       = require('./_redefine-all')
    , meta              = require('./_meta')
    , forOf             = require('./_for-of')
    , anInstance        = require('./_an-instance')
    , isObject          = require('./_is-object')
    , fails             = require('./_fails')
    , $iterDetect       = require('./_iter-detect')
    , setToStringTag    = require('./_set-to-string-tag')
    , inheritIfRequired = require('./_inherit-if-required');
  
  module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
    var Base  = global[NAME]
      , C     = Base
      , ADDER = IS_MAP ? 'set' : 'add'
      , proto = C && C.prototype
      , O     = {};
    var fixMethod = function(KEY){
      var fn = proto[KEY];
      redefine(proto, KEY,
        KEY == 'delete' ? function(a){
          return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'has' ? function has(a){
          return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'get' ? function get(a){
          return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'add' ? function add(a){ fn.call(this, a === 0 ? 0 : a); return this; }
          : function set(a, b){ fn.call(this, a === 0 ? 0 : a, b); return this; }
      );
    };
    if(typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){
      new C().entries().next();
    }))){
      // create collection constructor
      C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
      redefineAll(C.prototype, methods);
      meta.NEED = true;
    } else {
      var instance             = new C
        // early implementations not supports chaining
        , HASNT_CHAINING       = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance
        // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
        , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); })
        // most early implementations doesn't supports iterables, most modern - not close it correctly
        , ACCEPT_ITERABLES     = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new
        // for early implementations -0 and +0 not the same
        , BUGGY_ZERO = !IS_WEAK && fails(function(){
          // V8 ~ Chromium 42- fails only with 5+ elements
          var $instance = new C()
            , index     = 5;
          while(index--)$instance[ADDER](index, index);
          return !$instance.has(-0);
        });
      if(!ACCEPT_ITERABLES){ 
        C = wrapper(function(target, iterable){
          anInstance(target, C, NAME);
          var that = inheritIfRequired(new Base, target, C);
          if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
          return that;
        });
        C.prototype = proto;
        proto.constructor = C;
      }
      if(THROWS_ON_PRIMITIVES || BUGGY_ZERO){
        fixMethod('delete');
        fixMethod('has');
        IS_MAP && fixMethod('get');
      }
      if(BUGGY_ZERO || HASNT_CHAINING)fixMethod(ADDER);
      // weak collections should not contains .clear method
      if(IS_WEAK && proto.clear)delete proto.clear;
    }
  
    setToStringTag(C, NAME);
  
    O[NAME] = C;
    $export($export.G + $export.W + $export.F * (C != Base), O);
  
    if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP);
  
    return C;
  };
  },{"./_an-instance":7,"./_export":33,"./_fails":35,"./_for-of":38,"./_global":39,"./_inherit-if-required":44,"./_is-object":50,"./_iter-detect":55,"./_meta":63,"./_redefine":88,"./_redefine-all":87,"./_set-to-string-tag":93}],24:[function(require,module,exports){
  var core = module.exports = {version: '2.4.0'};
  if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
  },{}],25:[function(require,module,exports){
  'use strict';
  var $defineProperty = require('./_object-dp')
    , createDesc      = require('./_property-desc');
  
  module.exports = function(object, index, value){
    if(index in object)$defineProperty.f(object, index, createDesc(0, value));
    else object[index] = value;
  };
  },{"./_object-dp":68,"./_property-desc":86}],26:[function(require,module,exports){
  // optional / simple context binding
  var aFunction = require('./_a-function');
  module.exports = function(fn, that, length){
    aFunction(fn);
    if(that === undefined)return fn;
    switch(length){
      case 1: return function(a){
        return fn.call(that, a);
      };
      case 2: return function(a, b){
        return fn.call(that, a, b);
      };
      case 3: return function(a, b, c){
        return fn.call(that, a, b, c);
      };
    }
    return function(/* ...args */){
      return fn.apply(that, arguments);
    };
  };
  },{"./_a-function":4}],27:[function(require,module,exports){
  'use strict';
  var anObject    = require('./_an-object')
    , toPrimitive = require('./_to-primitive')
    , NUMBER      = 'number';
  
  module.exports = function(hint){
    if(hint !== 'string' && hint !== NUMBER && hint !== 'default')throw TypeError('Incorrect hint');
    return toPrimitive(anObject(this), hint != NUMBER);
  };
  },{"./_an-object":8,"./_to-primitive":111}],28:[function(require,module,exports){
  // 7.2.1 RequireObjectCoercible(argument)
  module.exports = function(it){
    if(it == undefined)throw TypeError("Can't call method on  " + it);
    return it;
  };
  },{}],29:[function(require,module,exports){
  // Thank's IE8 for his funny defineProperty
  module.exports = !require('./_fails')(function(){
    return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
  });
  },{"./_fails":35}],30:[function(require,module,exports){
  var isObject = require('./_is-object')
    , document = require('./_global').document
    // in old IE typeof document.createElement is 'object'
    , is = isObject(document) && isObject(document.createElement);
  module.exports = function(it){
    return is ? document.createElement(it) : {};
  };
  },{"./_global":39,"./_is-object":50}],31:[function(require,module,exports){
  // IE 8- don't enum bug keys
  module.exports = (
    'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  ).split(',');
  },{}],32:[function(require,module,exports){
  // all enumerable object keys, includes symbols
  var getKeys = require('./_object-keys')
    , gOPS    = require('./_object-gops')
    , pIE     = require('./_object-pie');
  module.exports = function(it){
    var result     = getKeys(it)
      , getSymbols = gOPS.f;
    if(getSymbols){
      var symbols = getSymbols(it)
        , isEnum  = pIE.f
        , i       = 0
        , key;
      while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);
    } return result;
  };
  },{"./_object-gops":74,"./_object-keys":77,"./_object-pie":78}],33:[function(require,module,exports){
  var global    = require('./_global')
    , core      = require('./_core')
    , hide      = require('./_hide')
    , redefine  = require('./_redefine')
    , ctx       = require('./_ctx')
    , PROTOTYPE = 'prototype';
  
  var $export = function(type, name, source){
    var IS_FORCED = type & $export.F
      , IS_GLOBAL = type & $export.G
      , IS_STATIC = type & $export.S
      , IS_PROTO  = type & $export.P
      , IS_BIND   = type & $export.B
      , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
      , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
      , expProto  = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
      , key, own, out, exp;
    if(IS_GLOBAL)source = name;
    for(key in source){
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined;
      // export native or passed
      out = (own ? target : source)[key];
      // bind timers to global for call from export context
      exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
      // extend global
      if(target)redefine(target, key, out, type & $export.U);
      // export
      if(exports[key] != out)hide(exports, key, exp);
      if(IS_PROTO && expProto[key] != out)expProto[key] = out;
    }
  };
  global.core = core;
  // type bitmap
  $export.F = 1;   // forced
  $export.G = 2;   // global
  $export.S = 4;   // static
  $export.P = 8;   // proto
  $export.B = 16;  // bind
  $export.W = 32;  // wrap
  $export.U = 64;  // safe
  $export.R = 128; // real proto method for `library` 
  module.exports = $export;
  },{"./_core":24,"./_ctx":26,"./_global":39,"./_hide":41,"./_redefine":88}],34:[function(require,module,exports){
  var MATCH = require('./_wks')('match');
  module.exports = function(KEY){
    var re = /./;
    try {
      '/./'[KEY](re);
    } catch(e){
      try {
        re[MATCH] = false;
        return !'/./'[KEY](re);
      } catch(f){ /* empty */ }
    } return true;
  };
  },{"./_wks":118}],35:[function(require,module,exports){
  module.exports = function(exec){
    try {
      return !!exec();
    } catch(e){
      return true;
    }
  };
  },{}],36:[function(require,module,exports){
  'use strict';
  var hide     = require('./_hide')
    , redefine = require('./_redefine')
    , fails    = require('./_fails')
    , defined  = require('./_defined')
    , wks      = require('./_wks');
  
  module.exports = function(KEY, length, exec){
    var SYMBOL   = wks(KEY)
      , fns      = exec(defined, SYMBOL, ''[KEY])
      , strfn    = fns[0]
      , rxfn     = fns[1];
    if(fails(function(){
      var O = {};
      O[SYMBOL] = function(){ return 7; };
      return ''[KEY](O) != 7;
    })){
      redefine(String.prototype, KEY, strfn);
      hide(RegExp.prototype, SYMBOL, length == 2
        // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
        // 21.2.5.11 RegExp.prototype[@@split](string, limit)
        ? function(string, arg){ return rxfn.call(string, this, arg); }
        // 21.2.5.6 RegExp.prototype[@@match](string)
        // 21.2.5.9 RegExp.prototype[@@search](string)
        : function(string){ return rxfn.call(string, this); }
      );
    }
  };
  },{"./_defined":28,"./_fails":35,"./_hide":41,"./_redefine":88,"./_wks":118}],37:[function(require,module,exports){
  'use strict';
  // 21.2.5.3 get RegExp.prototype.flags
  var anObject = require('./_an-object');
  module.exports = function(){
    var that   = anObject(this)
      , result = '';
    if(that.global)     result += 'g';
    if(that.ignoreCase) result += 'i';
    if(that.multiline)  result += 'm';
    if(that.unicode)    result += 'u';
    if(that.sticky)     result += 'y';
    return result;
  };
  },{"./_an-object":8}],38:[function(require,module,exports){
  var ctx         = require('./_ctx')
    , call        = require('./_iter-call')
    , isArrayIter = require('./_is-array-iter')
    , anObject    = require('./_an-object')
    , toLength    = require('./_to-length')
    , getIterFn   = require('./core.get-iterator-method')
    , BREAK       = {}
    , RETURN      = {};
  var exports = module.exports = function(iterable, entries, fn, that, ITERATOR){
    var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)
      , f      = ctx(fn, that, entries ? 2 : 1)
      , index  = 0
      , length, step, iterator, result;
    if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
    // fast case for arrays with default iterator
    if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){
      result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
      if(result === BREAK || result === RETURN)return result;
    } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
      result = call(iterator, f, step.value, entries);
      if(result === BREAK || result === RETURN)return result;
    }
  };
  exports.BREAK  = BREAK;
  exports.RETURN = RETURN;
  },{"./_an-object":8,"./_ctx":26,"./_is-array-iter":47,"./_iter-call":52,"./_to-length":109,"./core.get-iterator-method":119}],39:[function(require,module,exports){
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  var global = module.exports = typeof window != 'undefined' && window.Math == Math
    ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
  if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
  },{}],40:[function(require,module,exports){
  var hasOwnProperty = {}.hasOwnProperty;
  module.exports = function(it, key){
    return hasOwnProperty.call(it, key);
  };
  },{}],41:[function(require,module,exports){
  var dP         = require('./_object-dp')
    , createDesc = require('./_property-desc');
  module.exports = require('./_descriptors') ? function(object, key, value){
    return dP.f(object, key, createDesc(1, value));
  } : function(object, key, value){
    object[key] = value;
    return object;
  };
  },{"./_descriptors":29,"./_object-dp":68,"./_property-desc":86}],42:[function(require,module,exports){
  module.exports = require('./_global').document && document.documentElement;
  },{"./_global":39}],43:[function(require,module,exports){
  module.exports = !require('./_descriptors') && !require('./_fails')(function(){
    return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;
  });
  },{"./_descriptors":29,"./_dom-create":30,"./_fails":35}],44:[function(require,module,exports){
  var isObject       = require('./_is-object')
    , setPrototypeOf = require('./_set-proto').set;
  module.exports = function(that, target, C){
    var P, S = target.constructor;
    if(S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf){
      setPrototypeOf(that, P);
    } return that;
  };
  },{"./_is-object":50,"./_set-proto":91}],45:[function(require,module,exports){
  // fast apply, http://jsperf.lnkit.com/fast-apply/5
  module.exports = function(fn, args, that){
    var un = that === undefined;
    switch(args.length){
      case 0: return un ? fn()
                        : fn.call(that);
      case 1: return un ? fn(args[0])
                        : fn.call(that, args[0]);
      case 2: return un ? fn(args[0], args[1])
                        : fn.call(that, args[0], args[1]);
      case 3: return un ? fn(args[0], args[1], args[2])
                        : fn.call(that, args[0], args[1], args[2]);
      case 4: return un ? fn(args[0], args[1], args[2], args[3])
                        : fn.call(that, args[0], args[1], args[2], args[3]);
    } return              fn.apply(that, args);
  };
  },{}],46:[function(require,module,exports){
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
  var cof = require('./_cof');
  module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
    return cof(it) == 'String' ? it.split('') : Object(it);
  };
  },{"./_cof":19}],47:[function(require,module,exports){
  // check on default Array iterator
  var Iterators  = require('./_iterators')
    , ITERATOR   = require('./_wks')('iterator')
    , ArrayProto = Array.prototype;
  
  module.exports = function(it){
    return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
  };
  },{"./_iterators":57,"./_wks":118}],48:[function(require,module,exports){
  // 7.2.2 IsArray(argument)
  var cof = require('./_cof');
  module.exports = Array.isArray || function isArray(arg){
    return cof(arg) == 'Array';
  };
  },{"./_cof":19}],49:[function(require,module,exports){
  // 20.1.2.3 Number.isInteger(number)
  var isObject = require('./_is-object')
    , floor    = Math.floor;
  module.exports = function isInteger(it){
    return !isObject(it) && isFinite(it) && floor(it) === it;
  };
  },{"./_is-object":50}],50:[function(require,module,exports){
  module.exports = function(it){
    return typeof it === 'object' ? it !== null : typeof it === 'function';
  };
  },{}],51:[function(require,module,exports){
  // 7.2.8 IsRegExp(argument)
  var isObject = require('./_is-object')
    , cof      = require('./_cof')
    , MATCH    = require('./_wks')('match');
  module.exports = function(it){
    var isRegExp;
    return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
  };
  },{"./_cof":19,"./_is-object":50,"./_wks":118}],52:[function(require,module,exports){
  // call something on iterator step with safe closing on error
  var anObject = require('./_an-object');
  module.exports = function(iterator, fn, value, entries){
    try {
      return entries ? fn(anObject(value)[0], value[1]) : fn(value);
    // 7.4.6 IteratorClose(iterator, completion)
    } catch(e){
      var ret = iterator['return'];
      if(ret !== undefined)anObject(ret.call(iterator));
      throw e;
    }
  };
  },{"./_an-object":8}],53:[function(require,module,exports){
  'use strict';
  var create         = require('./_object-create')
    , descriptor     = require('./_property-desc')
    , setToStringTag = require('./_set-to-string-tag')
    , IteratorPrototype = {};
  
  // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  require('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });
  
  module.exports = function(Constructor, NAME, next){
    Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
    setToStringTag(Constructor, NAME + ' Iterator');
  };
  },{"./_hide":41,"./_object-create":67,"./_property-desc":86,"./_set-to-string-tag":93,"./_wks":118}],54:[function(require,module,exports){
  'use strict';
  var LIBRARY        = require('./_library')
    , $export        = require('./_export')
    , redefine       = require('./_redefine')
    , hide           = require('./_hide')
    , has            = require('./_has')
    , Iterators      = require('./_iterators')
    , $iterCreate    = require('./_iter-create')
    , setToStringTag = require('./_set-to-string-tag')
    , getPrototypeOf = require('./_object-gpo')
    , ITERATOR       = require('./_wks')('iterator')
    , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
    , FF_ITERATOR    = '@@iterator'
    , KEYS           = 'keys'
    , VALUES         = 'values';
  
  var returnThis = function(){ return this; };
  
  module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
    $iterCreate(Constructor, NAME, next);
    var getMethod = function(kind){
      if(!BUGGY && kind in proto)return proto[kind];
      switch(kind){
        case KEYS: return function keys(){ return new Constructor(this, kind); };
        case VALUES: return function values(){ return new Constructor(this, kind); };
      } return function entries(){ return new Constructor(this, kind); };
    };
    var TAG        = NAME + ' Iterator'
      , DEF_VALUES = DEFAULT == VALUES
      , VALUES_BUG = false
      , proto      = Base.prototype
      , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
      , $default   = $native || getMethod(DEFAULT)
      , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
      , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
      , methods, key, IteratorPrototype;
    // Fix native
    if($anyNative){
      IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
      if(IteratorPrototype !== Object.prototype){
        // Set @@toStringTag to native iterators
        setToStringTag(IteratorPrototype, TAG, true);
        // fix for some old engines
        if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
      }
    }
    // fix Array#{values, @@iterator}.name in V8 / FF
    if(DEF_VALUES && $native && $native.name !== VALUES){
      VALUES_BUG = true;
      $default = function values(){ return $native.call(this); };
    }
    // Define iterator
    if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
      hide(proto, ITERATOR, $default);
    }
    // Plug for library
    Iterators[NAME] = $default;
    Iterators[TAG]  = returnThis;
    if(DEFAULT){
      methods = {
        values:  DEF_VALUES ? $default : getMethod(VALUES),
        keys:    IS_SET     ? $default : getMethod(KEYS),
        entries: $entries
      };
      if(FORCED)for(key in methods){
        if(!(key in proto))redefine(proto, key, methods[key]);
      } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
    }
    return methods;
  };
  },{"./_export":33,"./_has":40,"./_hide":41,"./_iter-create":53,"./_iterators":57,"./_library":59,"./_object-gpo":75,"./_redefine":88,"./_set-to-string-tag":93,"./_wks":118}],55:[function(require,module,exports){
  var ITERATOR     = require('./_wks')('iterator')
    , SAFE_CLOSING = false;
  
  try {
    var riter = [7][ITERATOR]();
    riter['return'] = function(){ SAFE_CLOSING = true; };
    Array.from(riter, function(){ throw 2; });
  } catch(e){ /* empty */ }
  
  module.exports = function(exec, skipClosing){
    if(!skipClosing && !SAFE_CLOSING)return false;
    var safe = false;
    try {
      var arr  = [7]
        , iter = arr[ITERATOR]();
      iter.next = function(){ return {done: safe = true}; };
      arr[ITERATOR] = function(){ return iter; };
      exec(arr);
    } catch(e){ /* empty */ }
    return safe;
  };
  },{"./_wks":118}],56:[function(require,module,exports){
  module.exports = function(done, value){
    return {value: value, done: !!done};
  };
  },{}],57:[function(require,module,exports){
  module.exports = {};
  },{}],58:[function(require,module,exports){
  var getKeys   = require('./_object-keys')
    , toIObject = require('./_to-iobject');
  module.exports = function(object, el){
    var O      = toIObject(object)
      , keys   = getKeys(O)
      , length = keys.length
      , index  = 0
      , key;
    while(length > index)if(O[key = keys[index++]] === el)return key;
  };
  },{"./_object-keys":77,"./_to-iobject":108}],59:[function(require,module,exports){
  module.exports = false;
  },{}],60:[function(require,module,exports){
  // 20.2.2.14 Math.expm1(x)
  var $expm1 = Math.expm1;
  module.exports = (!$expm1
    // Old FF bug
    || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168
    // Tor Browser bug
    || $expm1(-2e-17) != -2e-17
  ) ? function expm1(x){
    return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;
  } : $expm1;
  },{}],61:[function(require,module,exports){
  // 20.2.2.20 Math.log1p(x)
  module.exports = Math.log1p || function log1p(x){
    return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x);
  };
  },{}],62:[function(require,module,exports){
  // 20.2.2.28 Math.sign(x)
  module.exports = Math.sign || function sign(x){
    return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
  };
  },{}],63:[function(require,module,exports){
  var META     = require('./_uid')('meta')
    , isObject = require('./_is-object')
    , has      = require('./_has')
    , setDesc  = require('./_object-dp').f
    , id       = 0;
  var isExtensible = Object.isExtensible || function(){
    return true;
  };
  var FREEZE = !require('./_fails')(function(){
    return isExtensible(Object.preventExtensions({}));
  });
  var setMeta = function(it){
    setDesc(it, META, {value: {
      i: 'O' + ++id, // object ID
      w: {}          // weak collections IDs
    }});
  };
  var fastKey = function(it, create){
    // return primitive with prefix
    if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
    if(!has(it, META)){
      // can't set metadata to uncaught frozen object
      if(!isExtensible(it))return 'F';
      // not necessary to add metadata
      if(!create)return 'E';
      // add missing metadata
      setMeta(it);
    // return object ID
    } return it[META].i;
  };
  var getWeak = function(it, create){
    if(!has(it, META)){
      // can't set metadata to uncaught frozen object
      if(!isExtensible(it))return true;
      // not necessary to add metadata
      if(!create)return false;
      // add missing metadata
      setMeta(it);
    // return hash weak collections IDs
    } return it[META].w;
  };
  // add metadata on freeze-family methods calling
  var onFreeze = function(it){
    if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);
    return it;
  };
  var meta = module.exports = {
    KEY:      META,
    NEED:     false,
    fastKey:  fastKey,
    getWeak:  getWeak,
    onFreeze: onFreeze
  };
  },{"./_fails":35,"./_has":40,"./_is-object":50,"./_object-dp":68,"./_uid":115}],64:[function(require,module,exports){
  var Map     = require('./es6.map')
    , $export = require('./_export')
    , shared  = require('./_shared')('metadata')
    , store   = shared.store || (shared.store = new (require('./es6.weak-map')));
  
  var getOrCreateMetadataMap = function(target, targetKey, create){
    var targetMetadata = store.get(target);
    if(!targetMetadata){
      if(!create)return undefined;
      store.set(target, targetMetadata = new Map);
    }
    var keyMetadata = targetMetadata.get(targetKey);
    if(!keyMetadata){
      if(!create)return undefined;
      targetMetadata.set(targetKey, keyMetadata = new Map);
    } return keyMetadata;
  };
  var ordinaryHasOwnMetadata = function(MetadataKey, O, P){
    var metadataMap = getOrCreateMetadataMap(O, P, false);
    return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
  };
  var ordinaryGetOwnMetadata = function(MetadataKey, O, P){
    var metadataMap = getOrCreateMetadataMap(O, P, false);
    return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
  };
  var ordinaryDefineOwnMetadata = function(MetadataKey, MetadataValue, O, P){
    getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
  };
  var ordinaryOwnMetadataKeys = function(target, targetKey){
    var metadataMap = getOrCreateMetadataMap(target, targetKey, false)
      , keys        = [];
    if(metadataMap)metadataMap.forEach(function(_, key){ keys.push(key); });
    return keys;
  };
  var toMetaKey = function(it){
    return it === undefined || typeof it == 'symbol' ? it : String(it);
  };
  var exp = function(O){
    $export($export.S, 'Reflect', O);
  };
  
  module.exports = {
    store: store,
    map: getOrCreateMetadataMap,
    has: ordinaryHasOwnMetadata,
    get: ordinaryGetOwnMetadata,
    set: ordinaryDefineOwnMetadata,
    keys: ordinaryOwnMetadataKeys,
    key: toMetaKey,
    exp: exp
  };
  },{"./_export":33,"./_shared":95,"./es6.map":150,"./es6.weak-map":256}],65:[function(require,module,exports){
  var global    = require('./_global')
    , macrotask = require('./_task').set
    , Observer  = global.MutationObserver || global.WebKitMutationObserver
    , process   = global.process
    , Promise   = global.Promise
    , isNode    = require('./_cof')(process) == 'process';
  
  module.exports = function(){
    var head, last, notify;
  
    var flush = function(){
      var parent, fn;
      if(isNode && (parent = process.domain))parent.exit();
      while(head){
        fn   = head.fn;
        head = head.next;
        try {
          fn();
        } catch(e){
          if(head)notify();
          else last = undefined;
          throw e;
        }
      } last = undefined;
      if(parent)parent.enter();
    };
  
    // Node.js
    if(isNode){
      notify = function(){
        process.nextTick(flush);
      };
    // browsers with MutationObserver
    } else if(Observer){
      var toggle = true
        , node   = document.createTextNode('');
      new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new
      notify = function(){
        node.data = toggle = !toggle;
      };
    // environments with maybe non-completely correct, but existent Promise
    } else if(Promise && Promise.resolve){
      var promise = Promise.resolve();
      notify = function(){
        promise.then(flush);
      };
    // for other environments - macrotask based on:
    // - setImmediate
    // - MessageChannel
    // - window.postMessag
    // - onreadystatechange
    // - setTimeout
    } else {
      notify = function(){
        // strange IE + webpack dev server bug - use .call(global)
        macrotask.call(global, flush);
      };
    }
  
    return function(fn){
      var task = {fn: fn, next: undefined};
      if(last)last.next = task;
      if(!head){
        head = task;
        notify();
      } last = task;
    };
  };
  },{"./_cof":19,"./_global":39,"./_task":105}],66:[function(require,module,exports){
  'use strict';
  // 19.1.2.1 Object.assign(target, source, ...)
  var getKeys  = require('./_object-keys')
    , gOPS     = require('./_object-gops')
    , pIE      = require('./_object-pie')
    , toObject = require('./_to-object')
    , IObject  = require('./_iobject')
    , $assign  = Object.assign;
  
  // should work with symbols and should have deterministic property order (V8 bug)
  module.exports = !$assign || require('./_fails')(function(){
    var A = {}
      , B = {}
      , S = Symbol()
      , K = 'abcdefghijklmnopqrst';
    A[S] = 7;
    K.split('').forEach(function(k){ B[k] = k; });
    return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
  }) ? function assign(target, source){ // eslint-disable-line no-unused-vars
    var T     = toObject(target)
      , aLen  = arguments.length
      , index = 1
      , getSymbols = gOPS.f
      , isEnum     = pIE.f;
    while(aLen > index){
      var S      = IObject(arguments[index++])
        , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
        , length = keys.length
        , j      = 0
        , key;
      while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
    } return T;
  } : $assign;
  },{"./_fails":35,"./_iobject":46,"./_object-gops":74,"./_object-keys":77,"./_object-pie":78,"./_to-object":110}],67:[function(require,module,exports){
  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  var anObject    = require('./_an-object')
    , dPs         = require('./_object-dps')
    , enumBugKeys = require('./_enum-bug-keys')
    , IE_PROTO    = require('./_shared-key')('IE_PROTO')
    , Empty       = function(){ /* empty */ }
    , PROTOTYPE   = 'prototype';
  
  // Create object with fake `null` prototype: use iframe Object with cleared prototype
  var createDict = function(){
    // Thrash, waste and sodomy: IE GC bug
    var iframe = require('./_dom-create')('iframe')
      , i      = enumBugKeys.length
      , lt     = '<'
      , gt     = '>'
      , iframeDocument;
    iframe.style.display = 'none';
    require('./_html').appendChild(iframe);
    iframe.src = 'javascript:'; // eslint-disable-line no-script-url
    // createDict = iframe.contentWindow.Object;
    // html.removeChild(iframe);
    iframeDocument = iframe.contentWindow.document;
    iframeDocument.open();
    iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
    iframeDocument.close();
    createDict = iframeDocument.F;
    while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
    return createDict();
  };
  
  module.exports = Object.create || function create(O, Properties){
    var result;
    if(O !== null){
      Empty[PROTOTYPE] = anObject(O);
      result = new Empty;
      Empty[PROTOTYPE] = null;
      // add "__proto__" for Object.getPrototypeOf polyfill
      result[IE_PROTO] = O;
    } else result = createDict();
    return Properties === undefined ? result : dPs(result, Properties);
  };
  
  },{"./_an-object":8,"./_dom-create":30,"./_enum-bug-keys":31,"./_html":42,"./_object-dps":69,"./_shared-key":94}],68:[function(require,module,exports){
  var anObject       = require('./_an-object')
    , IE8_DOM_DEFINE = require('./_ie8-dom-define')
    , toPrimitive    = require('./_to-primitive')
    , dP             = Object.defineProperty;
  
  exports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){
    anObject(O);
    P = toPrimitive(P, true);
    anObject(Attributes);
    if(IE8_DOM_DEFINE)try {
      return dP(O, P, Attributes);
    } catch(e){ /* empty */ }
    if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
    if('value' in Attributes)O[P] = Attributes.value;
    return O;
  };
  },{"./_an-object":8,"./_descriptors":29,"./_ie8-dom-define":43,"./_to-primitive":111}],69:[function(require,module,exports){
  var dP       = require('./_object-dp')
    , anObject = require('./_an-object')
    , getKeys  = require('./_object-keys');
  
  module.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){
    anObject(O);
    var keys   = getKeys(Properties)
      , length = keys.length
      , i = 0
      , P;
    while(length > i)dP.f(O, P = keys[i++], Properties[P]);
    return O;
  };
  },{"./_an-object":8,"./_descriptors":29,"./_object-dp":68,"./_object-keys":77}],70:[function(require,module,exports){
  // Forced replacement prototype accessors methods
  module.exports = require('./_library')|| !require('./_fails')(function(){
    var K = Math.random();
    // In FF throws only define methods
    __defineSetter__.call(null, K, function(){ /* empty */});
    delete require('./_global')[K];
  });
  },{"./_fails":35,"./_global":39,"./_library":59}],71:[function(require,module,exports){
  var pIE            = require('./_object-pie')
    , createDesc     = require('./_property-desc')
    , toIObject      = require('./_to-iobject')
    , toPrimitive    = require('./_to-primitive')
    , has            = require('./_has')
    , IE8_DOM_DEFINE = require('./_ie8-dom-define')
    , gOPD           = Object.getOwnPropertyDescriptor;
  
  exports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P){
    O = toIObject(O);
    P = toPrimitive(P, true);
    if(IE8_DOM_DEFINE)try {
      return gOPD(O, P);
    } catch(e){ /* empty */ }
    if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
  };
  },{"./_descriptors":29,"./_has":40,"./_ie8-dom-define":43,"./_object-pie":78,"./_property-desc":86,"./_to-iobject":108,"./_to-primitive":111}],72:[function(require,module,exports){
  // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
  var toIObject = require('./_to-iobject')
    , gOPN      = require('./_object-gopn').f
    , toString  = {}.toString;
  
  var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
    ? Object.getOwnPropertyNames(window) : [];
  
  var getWindowNames = function(it){
    try {
      return gOPN(it);
    } catch(e){
      return windowNames.slice();
    }
  };
  
  module.exports.f = function getOwnPropertyNames(it){
    return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
  };
  
  },{"./_object-gopn":73,"./_to-iobject":108}],73:[function(require,module,exports){
  // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
  var $keys      = require('./_object-keys-internal')
    , hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');
  
  exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){
    return $keys(O, hiddenKeys);
  };
  },{"./_enum-bug-keys":31,"./_object-keys-internal":76}],74:[function(require,module,exports){
  exports.f = Object.getOwnPropertySymbols;
  },{}],75:[function(require,module,exports){
  // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
  var has         = require('./_has')
    , toObject    = require('./_to-object')
    , IE_PROTO    = require('./_shared-key')('IE_PROTO')
    , ObjectProto = Object.prototype;
  
  module.exports = Object.getPrototypeOf || function(O){
    O = toObject(O);
    if(has(O, IE_PROTO))return O[IE_PROTO];
    if(typeof O.constructor == 'function' && O instanceof O.constructor){
      return O.constructor.prototype;
    } return O instanceof Object ? ObjectProto : null;
  };
  },{"./_has":40,"./_shared-key":94,"./_to-object":110}],76:[function(require,module,exports){
  var has          = require('./_has')
    , toIObject    = require('./_to-iobject')
    , arrayIndexOf = require('./_array-includes')(false)
    , IE_PROTO     = require('./_shared-key')('IE_PROTO');
  
  module.exports = function(object, names){
    var O      = toIObject(object)
      , i      = 0
      , result = []
      , key;
    for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
    // Don't enum bug & hidden keys
    while(names.length > i)if(has(O, key = names[i++])){
      ~arrayIndexOf(result, key) || result.push(key);
    }
    return result;
  };
  },{"./_array-includes":12,"./_has":40,"./_shared-key":94,"./_to-iobject":108}],77:[function(require,module,exports){
  // 19.1.2.14 / 15.2.3.14 Object.keys(O)
  var $keys       = require('./_object-keys-internal')
    , enumBugKeys = require('./_enum-bug-keys');
  
  module.exports = Object.keys || function keys(O){
    return $keys(O, enumBugKeys);
  };
  },{"./_enum-bug-keys":31,"./_object-keys-internal":76}],78:[function(require,module,exports){
  exports.f = {}.propertyIsEnumerable;
  },{}],79:[function(require,module,exports){
  // most Object methods by ES6 should accept primitives
  var $export = require('./_export')
    , core    = require('./_core')
    , fails   = require('./_fails');
  module.exports = function(KEY, exec){
    var fn  = (core.Object || {})[KEY] || Object[KEY]
      , exp = {};
    exp[KEY] = exec(fn);
    $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
  };
  },{"./_core":24,"./_export":33,"./_fails":35}],80:[function(require,module,exports){
  var getKeys   = require('./_object-keys')
    , toIObject = require('./_to-iobject')
    , isEnum    = require('./_object-pie').f;
  module.exports = function(isEntries){
    return function(it){
      var O      = toIObject(it)
        , keys   = getKeys(O)
        , length = keys.length
        , i      = 0
        , result = []
        , key;
      while(length > i)if(isEnum.call(O, key = keys[i++])){
        result.push(isEntries ? [key, O[key]] : O[key]);
      } return result;
    };
  };
  },{"./_object-keys":77,"./_object-pie":78,"./_to-iobject":108}],81:[function(require,module,exports){
  // all object keys, includes non-enumerable and symbols
  var gOPN     = require('./_object-gopn')
    , gOPS     = require('./_object-gops')
    , anObject = require('./_an-object')
    , Reflect  = require('./_global').Reflect;
  module.exports = Reflect && Reflect.ownKeys || function ownKeys(it){
    var keys       = gOPN.f(anObject(it))
      , getSymbols = gOPS.f;
    return getSymbols ? keys.concat(getSymbols(it)) : keys;
  };
  },{"./_an-object":8,"./_global":39,"./_object-gopn":73,"./_object-gops":74}],82:[function(require,module,exports){
  var $parseFloat = require('./_global').parseFloat
    , $trim       = require('./_string-trim').trim;
  
  module.exports = 1 / $parseFloat(require('./_string-ws') + '-0') !== -Infinity ? function parseFloat(str){
    var string = $trim(String(str), 3)
      , result = $parseFloat(string);
    return result === 0 && string.charAt(0) == '-' ? -0 : result;
  } : $parseFloat;
  },{"./_global":39,"./_string-trim":103,"./_string-ws":104}],83:[function(require,module,exports){
  var $parseInt = require('./_global').parseInt
    , $trim     = require('./_string-trim').trim
    , ws        = require('./_string-ws')
    , hex       = /^[\-+]?0[xX]/;
  
  module.exports = $parseInt(ws + '08') !== 8 || $parseInt(ws + '0x16') !== 22 ? function parseInt(str, radix){
    var string = $trim(String(str), 3);
    return $parseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10));
  } : $parseInt;
  },{"./_global":39,"./_string-trim":103,"./_string-ws":104}],84:[function(require,module,exports){
  'use strict';
  var path      = require('./_path')
    , invoke    = require('./_invoke')
    , aFunction = require('./_a-function');
  module.exports = function(/* ...pargs */){
    var fn     = aFunction(this)
      , length = arguments.length
      , pargs  = Array(length)
      , i      = 0
      , _      = path._
      , holder = false;
    while(length > i)if((pargs[i] = arguments[i++]) === _)holder = true;
    return function(/* ...args */){
      var that = this
        , aLen = arguments.length
        , j = 0, k = 0, args;
      if(!holder && !aLen)return invoke(fn, pargs, that);
      args = pargs.slice();
      if(holder)for(;length > j; j++)if(args[j] === _)args[j] = arguments[k++];
      while(aLen > k)args.push(arguments[k++]);
      return invoke(fn, args, that);
    };
  };
  },{"./_a-function":4,"./_invoke":45,"./_path":85}],85:[function(require,module,exports){
  module.exports = require('./_global');
  },{"./_global":39}],86:[function(require,module,exports){
  module.exports = function(bitmap, value){
    return {
      enumerable  : !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable    : !(bitmap & 4),
      value       : value
    };
  };
  },{}],87:[function(require,module,exports){
  var redefine = require('./_redefine');
  module.exports = function(target, src, safe){
    for(var key in src)redefine(target, key, src[key], safe);
    return target;
  };
  },{"./_redefine":88}],88:[function(require,module,exports){
  var global    = require('./_global')
    , hide      = require('./_hide')
    , has       = require('./_has')
    , SRC       = require('./_uid')('src')
    , TO_STRING = 'toString'
    , $toString = Function[TO_STRING]
    , TPL       = ('' + $toString).split(TO_STRING);
  
  require('./_core').inspectSource = function(it){
    return $toString.call(it);
  };
  
  (module.exports = function(O, key, val, safe){
    var isFunction = typeof val == 'function';
    if(isFunction)has(val, 'name') || hide(val, 'name', key);
    if(O[key] === val)return;
    if(isFunction)has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
    if(O === global){
      O[key] = val;
    } else {
      if(!safe){
        delete O[key];
        hide(O, key, val);
      } else {
        if(O[key])O[key] = val;
        else hide(O, key, val);
      }
    }
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
  })(Function.prototype, TO_STRING, function toString(){
    return typeof this == 'function' && this[SRC] || $toString.call(this);
  });
  },{"./_core":24,"./_global":39,"./_has":40,"./_hide":41,"./_uid":115}],89:[function(require,module,exports){
  module.exports = function(regExp, replace){
    var replacer = replace === Object(replace) ? function(part){
      return replace[part];
    } : replace;
    return function(it){
      return String(it).replace(regExp, replacer);
    };
  };
  },{}],90:[function(require,module,exports){
  // 7.2.9 SameValue(x, y)
  module.exports = Object.is || function is(x, y){
    return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
  };
  },{}],91:[function(require,module,exports){
  // Works with __proto__ only. Old v8 can't work with null proto objects.
  /* eslint-disable no-proto */
  var isObject = require('./_is-object')
    , anObject = require('./_an-object');
  var check = function(O, proto){
    anObject(O);
    if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
  };
  module.exports = {
    set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
      function(test, buggy, set){
        try {
          set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);
          set(test, []);
          buggy = !(test instanceof Array);
        } catch(e){ buggy = true; }
        return function setPrototypeOf(O, proto){
          check(O, proto);
          if(buggy)O.__proto__ = proto;
          else set(O, proto);
          return O;
        };
      }({}, false) : undefined),
    check: check
  };
  },{"./_an-object":8,"./_ctx":26,"./_is-object":50,"./_object-gopd":71}],92:[function(require,module,exports){
  'use strict';
  var global      = require('./_global')
    , dP          = require('./_object-dp')
    , DESCRIPTORS = require('./_descriptors')
    , SPECIES     = require('./_wks')('species');
  
  module.exports = function(KEY){
    var C = global[KEY];
    if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {
      configurable: true,
      get: function(){ return this; }
    });
  };
  },{"./_descriptors":29,"./_global":39,"./_object-dp":68,"./_wks":118}],93:[function(require,module,exports){
  var def = require('./_object-dp').f
    , has = require('./_has')
    , TAG = require('./_wks')('toStringTag');
  
  module.exports = function(it, tag, stat){
    if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
  };
  },{"./_has":40,"./_object-dp":68,"./_wks":118}],94:[function(require,module,exports){
  var shared = require('./_shared')('keys')
    , uid    = require('./_uid');
  module.exports = function(key){
    return shared[key] || (shared[key] = uid(key));
  };
  },{"./_shared":95,"./_uid":115}],95:[function(require,module,exports){
  var global = require('./_global')
    , SHARED = '__core-js_shared__'
    , store  = global[SHARED] || (global[SHARED] = {});
  module.exports = function(key){
    return store[key] || (store[key] = {});
  };
  },{"./_global":39}],96:[function(require,module,exports){
  // 7.3.20 SpeciesConstructor(O, defaultConstructor)
  var anObject  = require('./_an-object')
    , aFunction = require('./_a-function')
    , SPECIES   = require('./_wks')('species');
  module.exports = function(O, D){
    var C = anObject(O).constructor, S;
    return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
  };
  },{"./_a-function":4,"./_an-object":8,"./_wks":118}],97:[function(require,module,exports){
  var fails = require('./_fails');
  
  module.exports = function(method, arg){
    return !!method && fails(function(){
      arg ? method.call(null, function(){}, 1) : method.call(null);
    });
  };
  },{"./_fails":35}],98:[function(require,module,exports){
  var toInteger = require('./_to-integer')
    , defined   = require('./_defined');
  // true  -> String#at
  // false -> String#codePointAt
  module.exports = function(TO_STRING){
    return function(that, pos){
      var s = String(defined(that))
        , i = toInteger(pos)
        , l = s.length
        , a, b;
      if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
      a = s.charCodeAt(i);
      return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
        ? TO_STRING ? s.charAt(i) : a
        : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
    };
  };
  },{"./_defined":28,"./_to-integer":107}],99:[function(require,module,exports){
  // helper for String#{startsWith, endsWith, includes}
  var isRegExp = require('./_is-regexp')
    , defined  = require('./_defined');
  
  module.exports = function(that, searchString, NAME){
    if(isRegExp(searchString))throw TypeError('String#' + NAME + " doesn't accept regex!");
    return String(defined(that));
  };
  },{"./_defined":28,"./_is-regexp":51}],100:[function(require,module,exports){
  var $export = require('./_export')
    , fails   = require('./_fails')
    , defined = require('./_defined')
    , quot    = /"/g;
  // B.2.3.2.1 CreateHTML(string, tag, attribute, value)
  var createHTML = function(string, tag, attribute, value) {
    var S  = String(defined(string))
      , p1 = '<' + tag;
    if(attribute !== '')p1 += ' ' + attribute + '="' + String(value).replace(quot, '&quot;') + '"';
    return p1 + '>' + S + '</' + tag + '>';
  };
  module.exports = function(NAME, exec){
    var O = {};
    O[NAME] = exec(createHTML);
    $export($export.P + $export.F * fails(function(){
      var test = ''[NAME]('"');
      return test !== test.toLowerCase() || test.split('"').length > 3;
    }), 'String', O);
  };
  },{"./_defined":28,"./_export":33,"./_fails":35}],101:[function(require,module,exports){
  // https://github.com/tc39/proposal-string-pad-start-end
  var toLength = require('./_to-length')
    , repeat   = require('./_string-repeat')
    , defined  = require('./_defined');
  
  module.exports = function(that, maxLength, fillString, left){
    var S            = String(defined(that))
      , stringLength = S.length
      , fillStr      = fillString === undefined ? ' ' : String(fillString)
      , intMaxLength = toLength(maxLength);
    if(intMaxLength <= stringLength || fillStr == '')return S;
    var fillLen = intMaxLength - stringLength
      , stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
    if(stringFiller.length > fillLen)stringFiller = stringFiller.slice(0, fillLen);
    return left ? stringFiller + S : S + stringFiller;
  };
  
  },{"./_defined":28,"./_string-repeat":102,"./_to-length":109}],102:[function(require,module,exports){
  'use strict';
  var toInteger = require('./_to-integer')
    , defined   = require('./_defined');
  
  module.exports = function repeat(count){
    var str = String(defined(this))
      , res = ''
      , n   = toInteger(count);
    if(n < 0 || n == Infinity)throw RangeError("Count can't be negative");
    for(;n > 0; (n >>>= 1) && (str += str))if(n & 1)res += str;
    return res;
  };
  },{"./_defined":28,"./_to-integer":107}],103:[function(require,module,exports){
  var $export = require('./_export')
    , defined = require('./_defined')
    , fails   = require('./_fails')
    , spaces  = require('./_string-ws')
    , space   = '[' + spaces + ']'
    , non     = '\u200b\u0085'
    , ltrim   = RegExp('^' + space + space + '*')
    , rtrim   = RegExp(space + space + '*$');
  
  var exporter = function(KEY, exec, ALIAS){
    var exp   = {};
    var FORCE = fails(function(){
      return !!spaces[KEY]() || non[KEY]() != non;
    });
    var fn = exp[KEY] = FORCE ? exec(trim) : spaces[KEY];
    if(ALIAS)exp[ALIAS] = fn;
    $export($export.P + $export.F * FORCE, 'String', exp);
  };
  
  // 1 -> String#trimLeft
  // 2 -> String#trimRight
  // 3 -> String#trim
  var trim = exporter.trim = function(string, TYPE){
    string = String(defined(string));
    if(TYPE & 1)string = string.replace(ltrim, '');
    if(TYPE & 2)string = string.replace(rtrim, '');
    return string;
  };
  
  module.exports = exporter;
  },{"./_defined":28,"./_export":33,"./_fails":35,"./_string-ws":104}],104:[function(require,module,exports){
  module.exports = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
    '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
  },{}],105:[function(require,module,exports){
  var ctx                = require('./_ctx')
    , invoke             = require('./_invoke')
    , html               = require('./_html')
    , cel                = require('./_dom-create')
    , global             = require('./_global')
    , process            = global.process
    , setTask            = global.setImmediate
    , clearTask          = global.clearImmediate
    , MessageChannel     = global.MessageChannel
    , counter            = 0
    , queue              = {}
    , ONREADYSTATECHANGE = 'onreadystatechange'
    , defer, channel, port;
  var run = function(){
    var id = +this;
    if(queue.hasOwnProperty(id)){
      var fn = queue[id];
      delete queue[id];
      fn();
    }
  };
  var listener = function(event){
    run.call(event.data);
  };
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
  if(!setTask || !clearTask){
    setTask = function setImmediate(fn){
      var args = [], i = 1;
      while(arguments.length > i)args.push(arguments[i++]);
      queue[++counter] = function(){
        invoke(typeof fn == 'function' ? fn : Function(fn), args);
      };
      defer(counter);
      return counter;
    };
    clearTask = function clearImmediate(id){
      delete queue[id];
    };
    // Node.js 0.8-
    if(require('./_cof')(process) == 'process'){
      defer = function(id){
        process.nextTick(ctx(run, id, 1));
      };
    // Browsers with MessageChannel, includes WebWorkers
    } else if(MessageChannel){
      channel = new MessageChannel;
      port    = channel.port2;
      channel.port1.onmessage = listener;
      defer = ctx(port.postMessage, port, 1);
    // Browsers with postMessage, skip WebWorkers
    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
    } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){
      defer = function(id){
        global.postMessage(id + '', '*');
      };
      global.addEventListener('message', listener, false);
    // IE8-
    } else if(ONREADYSTATECHANGE in cel('script')){
      defer = function(id){
        html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
          html.removeChild(this);
          run.call(id);
        };
      };
    // Rest old browsers
    } else {
      defer = function(id){
        setTimeout(ctx(run, id, 1), 0);
      };
    }
  }
  module.exports = {
    set:   setTask,
    clear: clearTask
  };
  },{"./_cof":19,"./_ctx":26,"./_dom-create":30,"./_global":39,"./_html":42,"./_invoke":45}],106:[function(require,module,exports){
  var toInteger = require('./_to-integer')
    , max       = Math.max
    , min       = Math.min;
  module.exports = function(index, length){
    index = toInteger(index);
    return index < 0 ? max(index + length, 0) : min(index, length);
  };
  },{"./_to-integer":107}],107:[function(require,module,exports){
  // 7.1.4 ToInteger
  var ceil  = Math.ceil
    , floor = Math.floor;
  module.exports = function(it){
    return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  };
  },{}],108:[function(require,module,exports){
  // to indexed object, toObject with fallback for non-array-like ES3 strings
  var IObject = require('./_iobject')
    , defined = require('./_defined');
  module.exports = function(it){
    return IObject(defined(it));
  };
  },{"./_defined":28,"./_iobject":46}],109:[function(require,module,exports){
  // 7.1.15 ToLength
  var toInteger = require('./_to-integer')
    , min       = Math.min;
  module.exports = function(it){
    return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  };
  },{"./_to-integer":107}],110:[function(require,module,exports){
  // 7.1.13 ToObject(argument)
  var defined = require('./_defined');
  module.exports = function(it){
    return Object(defined(it));
  };
  },{"./_defined":28}],111:[function(require,module,exports){
  // 7.1.1 ToPrimitive(input [, PreferredType])
  var isObject = require('./_is-object');
  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string
  module.exports = function(it, S){
    if(!isObject(it))return it;
    var fn, val;
    if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
    if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
    if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
    throw TypeError("Can't convert object to primitive value");
  };
  },{"./_is-object":50}],112:[function(require,module,exports){
  'use strict';
  if(require('./_descriptors')){
    var LIBRARY             = require('./_library')
      , global              = require('./_global')
      , fails               = require('./_fails')
      , $export             = require('./_export')
      , $typed              = require('./_typed')
      , $buffer             = require('./_typed-buffer')
      , ctx                 = require('./_ctx')
      , anInstance          = require('./_an-instance')
      , propertyDesc        = require('./_property-desc')
      , hide                = require('./_hide')
      , redefineAll         = require('./_redefine-all')
      , toInteger           = require('./_to-integer')
      , toLength            = require('./_to-length')
      , toIndex             = require('./_to-index')
      , toPrimitive         = require('./_to-primitive')
      , has                 = require('./_has')
      , same                = require('./_same-value')
      , classof             = require('./_classof')
      , isObject            = require('./_is-object')
      , toObject            = require('./_to-object')
      , isArrayIter         = require('./_is-array-iter')
      , create              = require('./_object-create')
      , getPrototypeOf      = require('./_object-gpo')
      , gOPN                = require('./_object-gopn').f
      , getIterFn           = require('./core.get-iterator-method')
      , uid                 = require('./_uid')
      , wks                 = require('./_wks')
      , createArrayMethod   = require('./_array-methods')
      , createArrayIncludes = require('./_array-includes')
      , speciesConstructor  = require('./_species-constructor')
      , ArrayIterators      = require('./es6.array.iterator')
      , Iterators           = require('./_iterators')
      , $iterDetect         = require('./_iter-detect')
      , setSpecies          = require('./_set-species')
      , arrayFill           = require('./_array-fill')
      , arrayCopyWithin     = require('./_array-copy-within')
      , $DP                 = require('./_object-dp')
      , $GOPD               = require('./_object-gopd')
      , dP                  = $DP.f
      , gOPD                = $GOPD.f
      , RangeError          = global.RangeError
      , TypeError           = global.TypeError
      , Uint8Array          = global.Uint8Array
      , ARRAY_BUFFER        = 'ArrayBuffer'
      , SHARED_BUFFER       = 'Shared' + ARRAY_BUFFER
      , BYTES_PER_ELEMENT   = 'BYTES_PER_ELEMENT'
      , PROTOTYPE           = 'prototype'
      , ArrayProto          = Array[PROTOTYPE]
      , $ArrayBuffer        = $buffer.ArrayBuffer
      , $DataView           = $buffer.DataView
      , arrayForEach        = createArrayMethod(0)
      , arrayFilter         = createArrayMethod(2)
      , arraySome           = createArrayMethod(3)
      , arrayEvery          = createArrayMethod(4)
      , arrayFind           = createArrayMethod(5)
      , arrayFindIndex      = createArrayMethod(6)
      , arrayIncludes       = createArrayIncludes(true)
      , arrayIndexOf        = createArrayIncludes(false)
      , arrayValues         = ArrayIterators.values
      , arrayKeys           = ArrayIterators.keys
      , arrayEntries        = ArrayIterators.entries
      , arrayLastIndexOf    = ArrayProto.lastIndexOf
      , arrayReduce         = ArrayProto.reduce
      , arrayReduceRight    = ArrayProto.reduceRight
      , arrayJoin           = ArrayProto.join
      , arraySort           = ArrayProto.sort
      , arraySlice          = ArrayProto.slice
      , arrayToString       = ArrayProto.toString
      , arrayToLocaleString = ArrayProto.toLocaleString
      , ITERATOR            = wks('iterator')
      , TAG                 = wks('toStringTag')
      , TYPED_CONSTRUCTOR   = uid('typed_constructor')
      , DEF_CONSTRUCTOR     = uid('def_constructor')
      , ALL_CONSTRUCTORS    = $typed.CONSTR
      , TYPED_ARRAY         = $typed.TYPED
      , VIEW                = $typed.VIEW
      , WRONG_LENGTH        = 'Wrong length!';
  
    var $map = createArrayMethod(1, function(O, length){
      return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
    });
  
    var LITTLE_ENDIAN = fails(function(){
      return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
    });
  
    var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function(){
      new Uint8Array(1).set({});
    });
  
    var strictToLength = function(it, SAME){
      if(it === undefined)throw TypeError(WRONG_LENGTH);
      var number = +it
        , length = toLength(it);
      if(SAME && !same(number, length))throw RangeError(WRONG_LENGTH);
      return length;
    };
  
    var toOffset = function(it, BYTES){
      var offset = toInteger(it);
      if(offset < 0 || offset % BYTES)throw RangeError('Wrong offset!');
      return offset;
    };
  
    var validate = function(it){
      if(isObject(it) && TYPED_ARRAY in it)return it;
      throw TypeError(it + ' is not a typed array!');
    };
  
    var allocate = function(C, length){
      if(!(isObject(C) && TYPED_CONSTRUCTOR in C)){
        throw TypeError('It is not a typed array constructor!');
      } return new C(length);
    };
  
    var speciesFromList = function(O, list){
      return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
    };
  
    var fromList = function(C, list){
      var index  = 0
        , length = list.length
        , result = allocate(C, length);
      while(length > index)result[index] = list[index++];
      return result;
    };
  
    var addGetter = function(it, key, internal){
      dP(it, key, {get: function(){ return this._d[internal]; }});
    };
  
    var $from = function from(source /*, mapfn, thisArg */){
      var O       = toObject(source)
        , aLen    = arguments.length
        , mapfn   = aLen > 1 ? arguments[1] : undefined
        , mapping = mapfn !== undefined
        , iterFn  = getIterFn(O)
        , i, length, values, result, step, iterator;
      if(iterFn != undefined && !isArrayIter(iterFn)){
        for(iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++){
          values.push(step.value);
        } O = values;
      }
      if(mapping && aLen > 2)mapfn = ctx(mapfn, arguments[2], 2);
      for(i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++){
        result[i] = mapping ? mapfn(O[i], i) : O[i];
      }
      return result;
    };
  
    var $of = function of(/*...items*/){
      var index  = 0
        , length = arguments.length
        , result = allocate(this, length);
      while(length > index)result[index] = arguments[index++];
      return result;
    };
  
    // iOS Safari 6.x fails here
    var TO_LOCALE_BUG = !!Uint8Array && fails(function(){ arrayToLocaleString.call(new Uint8Array(1)); });
  
    var $toLocaleString = function toLocaleString(){
      return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);
    };
  
    var proto = {
      copyWithin: function copyWithin(target, start /*, end */){
        return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
      },
      every: function every(callbackfn /*, thisArg */){
        return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
      },
      fill: function fill(value /*, start, end */){ // eslint-disable-line no-unused-vars
        return arrayFill.apply(validate(this), arguments);
      },
      filter: function filter(callbackfn /*, thisArg */){
        return speciesFromList(this, arrayFilter(validate(this), callbackfn,
          arguments.length > 1 ? arguments[1] : undefined));
      },
      find: function find(predicate /*, thisArg */){
        return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
      },
      findIndex: function findIndex(predicate /*, thisArg */){
        return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
      },
      forEach: function forEach(callbackfn /*, thisArg */){
        arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
      },
      indexOf: function indexOf(searchElement /*, fromIndex */){
        return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
      },
      includes: function includes(searchElement /*, fromIndex */){
        return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
      },
      join: function join(separator){ // eslint-disable-line no-unused-vars
        return arrayJoin.apply(validate(this), arguments);
      },
      lastIndexOf: function lastIndexOf(searchElement /*, fromIndex */){ // eslint-disable-line no-unused-vars
        return arrayLastIndexOf.apply(validate(this), arguments);
      },
      map: function map(mapfn /*, thisArg */){
        return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);
      },
      reduce: function reduce(callbackfn /*, initialValue */){ // eslint-disable-line no-unused-vars
        return arrayReduce.apply(validate(this), arguments);
      },
      reduceRight: function reduceRight(callbackfn /*, initialValue */){ // eslint-disable-line no-unused-vars
        return arrayReduceRight.apply(validate(this), arguments);
      },
      reverse: function reverse(){
        var that   = this
          , length = validate(that).length
          , middle = Math.floor(length / 2)
          , index  = 0
          , value;
        while(index < middle){
          value         = that[index];
          that[index++] = that[--length];
          that[length]  = value;
        } return that;
      },
      some: function some(callbackfn /*, thisArg */){
        return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
      },
      sort: function sort(comparefn){
        return arraySort.call(validate(this), comparefn);
      },
      subarray: function subarray(begin, end){
        var O      = validate(this)
          , length = O.length
          , $begin = toIndex(begin, length);
        return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
          O.buffer,
          O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
          toLength((end === undefined ? length : toIndex(end, length)) - $begin)
        );
      }
    };
  
    var $slice = function slice(start, end){
      return speciesFromList(this, arraySlice.call(validate(this), start, end));
    };
  
    var $set = function set(arrayLike /*, offset */){
      validate(this);
      var offset = toOffset(arguments[1], 1)
        , length = this.length
        , src    = toObject(arrayLike)
        , len    = toLength(src.length)
        , index  = 0;
      if(len + offset > length)throw RangeError(WRONG_LENGTH);
      while(index < len)this[offset + index] = src[index++];
    };
  
    var $iterators = {
      entries: function entries(){
        return arrayEntries.call(validate(this));
      },
      keys: function keys(){
        return arrayKeys.call(validate(this));
      },
      values: function values(){
        return arrayValues.call(validate(this));
      }
    };
  
    var isTAIndex = function(target, key){
      return isObject(target)
        && target[TYPED_ARRAY]
        && typeof key != 'symbol'
        && key in target
        && String(+key) == String(key);
    };
    var $getDesc = function getOwnPropertyDescriptor(target, key){
      return isTAIndex(target, key = toPrimitive(key, true))
        ? propertyDesc(2, target[key])
        : gOPD(target, key);
    };
    var $setDesc = function defineProperty(target, key, desc){
      if(isTAIndex(target, key = toPrimitive(key, true))
        && isObject(desc)
        && has(desc, 'value')
        && !has(desc, 'get')
        && !has(desc, 'set')
        // TODO: add validation descriptor w/o calling accessors
        && !desc.configurable
        && (!has(desc, 'writable') || desc.writable)
        && (!has(desc, 'enumerable') || desc.enumerable)
      ){
        target[key] = desc.value;
        return target;
      } else return dP(target, key, desc);
    };
  
    if(!ALL_CONSTRUCTORS){
      $GOPD.f = $getDesc;
      $DP.f   = $setDesc;
    }
  
    $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {
      getOwnPropertyDescriptor: $getDesc,
      defineProperty:           $setDesc
    });
  
    if(fails(function(){ arrayToString.call({}); })){
      arrayToString = arrayToLocaleString = function toString(){
        return arrayJoin.call(this);
      }
    }
  
    var $TypedArrayPrototype$ = redefineAll({}, proto);
    redefineAll($TypedArrayPrototype$, $iterators);
    hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
    redefineAll($TypedArrayPrototype$, {
      slice:          $slice,
      set:            $set,
      constructor:    function(){ /* noop */ },
      toString:       arrayToString,
      toLocaleString: $toLocaleString
    });
    addGetter($TypedArrayPrototype$, 'buffer', 'b');
    addGetter($TypedArrayPrototype$, 'byteOffset', 'o');
    addGetter($TypedArrayPrototype$, 'byteLength', 'l');
    addGetter($TypedArrayPrototype$, 'length', 'e');
    dP($TypedArrayPrototype$, TAG, {
      get: function(){ return this[TYPED_ARRAY]; }
    });
  
    module.exports = function(KEY, BYTES, wrapper, CLAMPED){
      CLAMPED = !!CLAMPED;
      var NAME       = KEY + (CLAMPED ? 'Clamped' : '') + 'Array'
        , ISNT_UINT8 = NAME != 'Uint8Array'
        , GETTER     = 'get' + KEY
        , SETTER     = 'set' + KEY
        , TypedArray = global[NAME]
        , Base       = TypedArray || {}
        , TAC        = TypedArray && getPrototypeOf(TypedArray)
        , FORCED     = !TypedArray || !$typed.ABV
        , O          = {}
        , TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];
      var getter = function(that, index){
        var data = that._d;
        return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
      };
      var setter = function(that, index, value){
        var data = that._d;
        if(CLAMPED)value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;
        data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
      };
      var addElement = function(that, index){
        dP(that, index, {
          get: function(){
            return getter(this, index);
          },
          set: function(value){
            return setter(this, index, value);
          },
          enumerable: true
        });
      };
      if(FORCED){
        TypedArray = wrapper(function(that, data, $offset, $length){
          anInstance(that, TypedArray, NAME, '_d');
          var index  = 0
            , offset = 0
            , buffer, byteLength, length, klass;
          if(!isObject(data)){
            length     = strictToLength(data, true)
            byteLength = length * BYTES;
            buffer     = new $ArrayBuffer(byteLength);
          } else if(data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER){
            buffer = data;
            offset = toOffset($offset, BYTES);
            var $len = data.byteLength;
            if($length === undefined){
              if($len % BYTES)throw RangeError(WRONG_LENGTH);
              byteLength = $len - offset;
              if(byteLength < 0)throw RangeError(WRONG_LENGTH);
            } else {
              byteLength = toLength($length) * BYTES;
              if(byteLength + offset > $len)throw RangeError(WRONG_LENGTH);
            }
            length = byteLength / BYTES;
          } else if(TYPED_ARRAY in data){
            return fromList(TypedArray, data);
          } else {
            return $from.call(TypedArray, data);
          }
          hide(that, '_d', {
            b: buffer,
            o: offset,
            l: byteLength,
            e: length,
            v: new $DataView(buffer)
          });
          while(index < length)addElement(that, index++);
        });
        TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);
        hide(TypedArrayPrototype, 'constructor', TypedArray);
      } else if(!$iterDetect(function(iter){
        // V8 works with iterators, but fails in many other cases
        // https://code.google.com/p/v8/issues/detail?id=4552
        new TypedArray(null); // eslint-disable-line no-new
        new TypedArray(iter); // eslint-disable-line no-new
      }, true)){
        TypedArray = wrapper(function(that, data, $offset, $length){
          anInstance(that, TypedArray, NAME);
          var klass;
          // `ws` module bug, temporarily remove validation length for Uint8Array
          // https://github.com/websockets/ws/pull/645
          if(!isObject(data))return new Base(strictToLength(data, ISNT_UINT8));
          if(data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER){
            return $length !== undefined
              ? new Base(data, toOffset($offset, BYTES), $length)
              : $offset !== undefined
                ? new Base(data, toOffset($offset, BYTES))
                : new Base(data);
          }
          if(TYPED_ARRAY in data)return fromList(TypedArray, data);
          return $from.call(TypedArray, data);
        });
        arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function(key){
          if(!(key in TypedArray))hide(TypedArray, key, Base[key]);
        });
        TypedArray[PROTOTYPE] = TypedArrayPrototype;
        if(!LIBRARY)TypedArrayPrototype.constructor = TypedArray;
      }
      var $nativeIterator   = TypedArrayPrototype[ITERATOR]
        , CORRECT_ITER_NAME = !!$nativeIterator && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined)
        , $iterator         = $iterators.values;
      hide(TypedArray, TYPED_CONSTRUCTOR, true);
      hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
      hide(TypedArrayPrototype, VIEW, true);
      hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);
  
      if(CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)){
        dP(TypedArrayPrototype, TAG, {
          get: function(){ return NAME; }
        });
      }
  
      O[NAME] = TypedArray;
  
      $export($export.G + $export.W + $export.F * (TypedArray != Base), O);
  
      $export($export.S, NAME, {
        BYTES_PER_ELEMENT: BYTES,
        from: $from,
        of: $of
      });
  
      if(!(BYTES_PER_ELEMENT in TypedArrayPrototype))hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);
  
      $export($export.P, NAME, proto);
  
      setSpecies(NAME);
  
      $export($export.P + $export.F * FORCED_SET, NAME, {set: $set});
  
      $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);
  
      $export($export.P + $export.F * (TypedArrayPrototype.toString != arrayToString), NAME, {toString: arrayToString});
  
      $export($export.P + $export.F * fails(function(){
        new TypedArray(1).slice();
      }), NAME, {slice: $slice});
  
      $export($export.P + $export.F * (fails(function(){
        return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString()
      }) || !fails(function(){
        TypedArrayPrototype.toLocaleString.call([1, 2]);
      })), NAME, {toLocaleString: $toLocaleString});
  
      Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
      if(!LIBRARY && !CORRECT_ITER_NAME)hide(TypedArrayPrototype, ITERATOR, $iterator);
    };
  } else module.exports = function(){ /* empty */ };
  },{"./_an-instance":7,"./_array-copy-within":9,"./_array-fill":10,"./_array-includes":12,"./_array-methods":13,"./_classof":18,"./_ctx":26,"./_descriptors":29,"./_export":33,"./_fails":35,"./_global":39,"./_has":40,"./_hide":41,"./_is-array-iter":47,"./_is-object":50,"./_iter-detect":55,"./_iterators":57,"./_library":59,"./_object-create":67,"./_object-dp":68,"./_object-gopd":71,"./_object-gopn":73,"./_object-gpo":75,"./_property-desc":86,"./_redefine-all":87,"./_same-value":90,"./_set-species":92,"./_species-constructor":96,"./_to-index":106,"./_to-integer":107,"./_to-length":109,"./_to-object":110,"./_to-primitive":111,"./_typed":114,"./_typed-buffer":113,"./_uid":115,"./_wks":118,"./core.get-iterator-method":119,"./es6.array.iterator":131}],113:[function(require,module,exports){
  'use strict';
  var global         = require('./_global')
    , DESCRIPTORS    = require('./_descriptors')
    , LIBRARY        = require('./_library')
    , $typed         = require('./_typed')
    , hide           = require('./_hide')
    , redefineAll    = require('./_redefine-all')
    , fails          = require('./_fails')
    , anInstance     = require('./_an-instance')
    , toInteger      = require('./_to-integer')
    , toLength       = require('./_to-length')
    , gOPN           = require('./_object-gopn').f
    , dP             = require('./_object-dp').f
    , arrayFill      = require('./_array-fill')
    , setToStringTag = require('./_set-to-string-tag')
    , ARRAY_BUFFER   = 'ArrayBuffer'
    , DATA_VIEW      = 'DataView'
    , PROTOTYPE      = 'prototype'
    , WRONG_LENGTH   = 'Wrong length!'
    , WRONG_INDEX    = 'Wrong index!'
    , $ArrayBuffer   = global[ARRAY_BUFFER]
    , $DataView      = global[DATA_VIEW]
    , Math           = global.Math
    , RangeError     = global.RangeError
    , Infinity       = global.Infinity
    , BaseBuffer     = $ArrayBuffer
    , abs            = Math.abs
    , pow            = Math.pow
    , floor          = Math.floor
    , log            = Math.log
    , LN2            = Math.LN2
    , BUFFER         = 'buffer'
    , BYTE_LENGTH    = 'byteLength'
    , BYTE_OFFSET    = 'byteOffset'
    , $BUFFER        = DESCRIPTORS ? '_b' : BUFFER
    , $LENGTH        = DESCRIPTORS ? '_l' : BYTE_LENGTH
    , $OFFSET        = DESCRIPTORS ? '_o' : BYTE_OFFSET;
  
  // IEEE754 conversions based on https://github.com/feross/ieee754
  var packIEEE754 = function(value, mLen, nBytes){
    var buffer = Array(nBytes)
      , eLen   = nBytes * 8 - mLen - 1
      , eMax   = (1 << eLen) - 1
      , eBias  = eMax >> 1
      , rt     = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0
      , i      = 0
      , s      = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0
      , e, m, c;
    value = abs(value)
    if(value != value || value === Infinity){
      m = value != value ? 1 : 0;
      e = eMax;
    } else {
      e = floor(log(value) / LN2);
      if(value * (c = pow(2, -e)) < 1){
        e--;
        c *= 2;
      }
      if(e + eBias >= 1){
        value += rt / c;
      } else {
        value += rt * pow(2, 1 - eBias);
      }
      if(value * c >= 2){
        e++;
        c /= 2;
      }
      if(e + eBias >= eMax){
        m = 0;
        e = eMax;
      } else if(e + eBias >= 1){
        m = (value * c - 1) * pow(2, mLen);
        e = e + eBias;
      } else {
        m = value * pow(2, eBias - 1) * pow(2, mLen);
        e = 0;
      }
    }
    for(; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8);
    e = e << mLen | m;
    eLen += mLen;
    for(; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8);
    buffer[--i] |= s * 128;
    return buffer;
  };
  var unpackIEEE754 = function(buffer, mLen, nBytes){
    var eLen  = nBytes * 8 - mLen - 1
      , eMax  = (1 << eLen) - 1
      , eBias = eMax >> 1
      , nBits = eLen - 7
      , i     = nBytes - 1
      , s     = buffer[i--]
      , e     = s & 127
      , m;
    s >>= 7;
    for(; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8);
    m = e & (1 << -nBits) - 1;
    e >>= -nBits;
    nBits += mLen;
    for(; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8);
    if(e === 0){
      e = 1 - eBias;
    } else if(e === eMax){
      return m ? NaN : s ? -Infinity : Infinity;
    } else {
      m = m + pow(2, mLen);
      e = e - eBias;
    } return (s ? -1 : 1) * m * pow(2, e - mLen);
  };
  
  var unpackI32 = function(bytes){
    return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
  };
  var packI8 = function(it){
    return [it & 0xff];
  };
  var packI16 = function(it){
    return [it & 0xff, it >> 8 & 0xff];
  };
  var packI32 = function(it){
    return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff];
  };
  var packF64 = function(it){
    return packIEEE754(it, 52, 8);
  };
  var packF32 = function(it){
    return packIEEE754(it, 23, 4);
  };
  
  var addGetter = function(C, key, internal){
    dP(C[PROTOTYPE], key, {get: function(){ return this[internal]; }});
  };
  
  var get = function(view, bytes, index, isLittleEndian){
    var numIndex = +index
      , intIndex = toInteger(numIndex);
    if(numIndex != intIndex || intIndex < 0 || intIndex + bytes > view[$LENGTH])throw RangeError(WRONG_INDEX);
    var store = view[$BUFFER]._b
      , start = intIndex + view[$OFFSET]
      , pack  = store.slice(start, start + bytes);
    return isLittleEndian ? pack : pack.reverse();
  };
  var set = function(view, bytes, index, conversion, value, isLittleEndian){
    var numIndex = +index
      , intIndex = toInteger(numIndex);
    if(numIndex != intIndex || intIndex < 0 || intIndex + bytes > view[$LENGTH])throw RangeError(WRONG_INDEX);
    var store = view[$BUFFER]._b
      , start = intIndex + view[$OFFSET]
      , pack  = conversion(+value);
    for(var i = 0; i < bytes; i++)store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];
  };
  
  var validateArrayBufferArguments = function(that, length){
    anInstance(that, $ArrayBuffer, ARRAY_BUFFER);
    var numberLength = +length
      , byteLength   = toLength(numberLength);
    if(numberLength != byteLength)throw RangeError(WRONG_LENGTH);
    return byteLength;
  };
  
  if(!$typed.ABV){
    $ArrayBuffer = function ArrayBuffer(length){
      var byteLength = validateArrayBufferArguments(this, length);
      this._b       = arrayFill.call(Array(byteLength), 0);
      this[$LENGTH] = byteLength;
    };
  
    $DataView = function DataView(buffer, byteOffset, byteLength){
      anInstance(this, $DataView, DATA_VIEW);
      anInstance(buffer, $ArrayBuffer, DATA_VIEW);
      var bufferLength = buffer[$LENGTH]
        , offset       = toInteger(byteOffset);
      if(offset < 0 || offset > bufferLength)throw RangeError('Wrong offset!');
      byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
      if(offset + byteLength > bufferLength)throw RangeError(WRONG_LENGTH);
      this[$BUFFER] = buffer;
      this[$OFFSET] = offset;
      this[$LENGTH] = byteLength;
    };
  
    if(DESCRIPTORS){
      addGetter($ArrayBuffer, BYTE_LENGTH, '_l');
      addGetter($DataView, BUFFER, '_b');
      addGetter($DataView, BYTE_LENGTH, '_l');
      addGetter($DataView, BYTE_OFFSET, '_o');
    }
  
    redefineAll($DataView[PROTOTYPE], {
      getInt8: function getInt8(byteOffset){
        return get(this, 1, byteOffset)[0] << 24 >> 24;
      },
      getUint8: function getUint8(byteOffset){
        return get(this, 1, byteOffset)[0];
      },
      getInt16: function getInt16(byteOffset /*, littleEndian */){
        var bytes = get(this, 2, byteOffset, arguments[1]);
        return (bytes[1] << 8 | bytes[0]) << 16 >> 16;
      },
      getUint16: function getUint16(byteOffset /*, littleEndian */){
        var bytes = get(this, 2, byteOffset, arguments[1]);
        return bytes[1] << 8 | bytes[0];
      },
      getInt32: function getInt32(byteOffset /*, littleEndian */){
        return unpackI32(get(this, 4, byteOffset, arguments[1]));
      },
      getUint32: function getUint32(byteOffset /*, littleEndian */){
        return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;
      },
      getFloat32: function getFloat32(byteOffset /*, littleEndian */){
        return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);
      },
      getFloat64: function getFloat64(byteOffset /*, littleEndian */){
        return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);
      },
      setInt8: function setInt8(byteOffset, value){
        set(this, 1, byteOffset, packI8, value);
      },
      setUint8: function setUint8(byteOffset, value){
        set(this, 1, byteOffset, packI8, value);
      },
      setInt16: function setInt16(byteOffset, value /*, littleEndian */){
        set(this, 2, byteOffset, packI16, value, arguments[2]);
      },
      setUint16: function setUint16(byteOffset, value /*, littleEndian */){
        set(this, 2, byteOffset, packI16, value, arguments[2]);
      },
      setInt32: function setInt32(byteOffset, value /*, littleEndian */){
        set(this, 4, byteOffset, packI32, value, arguments[2]);
      },
      setUint32: function setUint32(byteOffset, value /*, littleEndian */){
        set(this, 4, byteOffset, packI32, value, arguments[2]);
      },
      setFloat32: function setFloat32(byteOffset, value /*, littleEndian */){
        set(this, 4, byteOffset, packF32, value, arguments[2]);
      },
      setFloat64: function setFloat64(byteOffset, value /*, littleEndian */){
        set(this, 8, byteOffset, packF64, value, arguments[2]);
      }
    });
  } else {
    if(!fails(function(){
      new $ArrayBuffer;     // eslint-disable-line no-new
    }) || !fails(function(){
      new $ArrayBuffer(.5); // eslint-disable-line no-new
    })){
      $ArrayBuffer = function ArrayBuffer(length){
        return new BaseBuffer(validateArrayBufferArguments(this, length));
      };
      var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE];
      for(var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j; ){
        if(!((key = keys[j++]) in $ArrayBuffer))hide($ArrayBuffer, key, BaseBuffer[key]);
      };
      if(!LIBRARY)ArrayBufferProto.constructor = $ArrayBuffer;
    }
    // iOS Safari 7.x bug
    var view = new $DataView(new $ArrayBuffer(2))
      , $setInt8 = $DataView[PROTOTYPE].setInt8;
    view.setInt8(0, 2147483648);
    view.setInt8(1, 2147483649);
    if(view.getInt8(0) || !view.getInt8(1))redefineAll($DataView[PROTOTYPE], {
      setInt8: function setInt8(byteOffset, value){
        $setInt8.call(this, byteOffset, value << 24 >> 24);
      },
      setUint8: function setUint8(byteOffset, value){
        $setInt8.call(this, byteOffset, value << 24 >> 24);
      }
    }, true);
  }
  setToStringTag($ArrayBuffer, ARRAY_BUFFER);
  setToStringTag($DataView, DATA_VIEW);
  hide($DataView[PROTOTYPE], $typed.VIEW, true);
  exports[ARRAY_BUFFER] = $ArrayBuffer;
  exports[DATA_VIEW] = $DataView;
  },{"./_an-instance":7,"./_array-fill":10,"./_descriptors":29,"./_fails":35,"./_global":39,"./_hide":41,"./_library":59,"./_object-dp":68,"./_object-gopn":73,"./_redefine-all":87,"./_set-to-string-tag":93,"./_to-integer":107,"./_to-length":109,"./_typed":114}],114:[function(require,module,exports){
  var global = require('./_global')
    , hide   = require('./_hide')
    , uid    = require('./_uid')
    , TYPED  = uid('typed_array')
    , VIEW   = uid('view')
    , ABV    = !!(global.ArrayBuffer && global.DataView)
    , CONSTR = ABV
    , i = 0, l = 9, Typed;
  
  var TypedArrayConstructors = (
    'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'
  ).split(',');
  
  while(i < l){
    if(Typed = global[TypedArrayConstructors[i++]]){
      hide(Typed.prototype, TYPED, true);
      hide(Typed.prototype, VIEW, true);
    } else CONSTR = false;
  }
  
  module.exports = {
    ABV:    ABV,
    CONSTR: CONSTR,
    TYPED:  TYPED,
    VIEW:   VIEW
  };
  },{"./_global":39,"./_hide":41,"./_uid":115}],115:[function(require,module,exports){
  var id = 0
    , px = Math.random();
  module.exports = function(key){
    return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  };
  },{}],116:[function(require,module,exports){
  var global         = require('./_global')
    , core           = require('./_core')
    , LIBRARY        = require('./_library')
    , wksExt         = require('./_wks-ext')
    , defineProperty = require('./_object-dp').f;
  module.exports = function(name){
    var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
    if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});
  };
  },{"./_core":24,"./_global":39,"./_library":59,"./_object-dp":68,"./_wks-ext":117}],117:[function(require,module,exports){
  exports.f = require('./_wks');
  },{"./_wks":118}],118:[function(require,module,exports){
  var store      = require('./_shared')('wks')
    , uid        = require('./_uid')
    , Symbol     = require('./_global').Symbol
    , USE_SYMBOL = typeof Symbol == 'function';
  
  var $exports = module.exports = function(name){
    return store[name] || (store[name] =
      USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
  };
  
  $exports.store = store;
  },{"./_global":39,"./_shared":95,"./_uid":115}],119:[function(require,module,exports){
  var classof   = require('./_classof')
    , ITERATOR  = require('./_wks')('iterator')
    , Iterators = require('./_iterators');
  module.exports = require('./_core').getIteratorMethod = function(it){
    if(it != undefined)return it[ITERATOR]
      || it['@@iterator']
      || Iterators[classof(it)];
  };
  },{"./_classof":18,"./_core":24,"./_iterators":57,"./_wks":118}],120:[function(require,module,exports){
  // https://github.com/benjamingr/RexExp.escape
  var $export = require('./_export')
    , $re     = require('./_replacer')(/[\\^$*+?.()|[\]{}]/g, '\\$&');
  
  $export($export.S, 'RegExp', {escape: function escape(it){ return $re(it); }});
  
  },{"./_export":33,"./_replacer":89}],121:[function(require,module,exports){
  // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
  var $export = require('./_export');
  
  $export($export.P, 'Array', {copyWithin: require('./_array-copy-within')});
  
  require('./_add-to-unscopables')('copyWithin');
  },{"./_add-to-unscopables":6,"./_array-copy-within":9,"./_export":33}],122:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $every  = require('./_array-methods')(4);
  
  $export($export.P + $export.F * !require('./_strict-method')([].every, true), 'Array', {
    // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])
    every: function every(callbackfn /* , thisArg */){
      return $every(this, callbackfn, arguments[1]);
    }
  });
  },{"./_array-methods":13,"./_export":33,"./_strict-method":97}],123:[function(require,module,exports){
  // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
  var $export = require('./_export');
  
  $export($export.P, 'Array', {fill: require('./_array-fill')});
  
  require('./_add-to-unscopables')('fill');
  },{"./_add-to-unscopables":6,"./_array-fill":10,"./_export":33}],124:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $filter = require('./_array-methods')(2);
  
  $export($export.P + $export.F * !require('./_strict-method')([].filter, true), 'Array', {
    // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])
    filter: function filter(callbackfn /* , thisArg */){
      return $filter(this, callbackfn, arguments[1]);
    }
  });
  },{"./_array-methods":13,"./_export":33,"./_strict-method":97}],125:[function(require,module,exports){
  'use strict';
  // 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
  var $export = require('./_export')
    , $find   = require('./_array-methods')(6)
    , KEY     = 'findIndex'
    , forced  = true;
  // Shouldn't skip holes
  if(KEY in [])Array(1)[KEY](function(){ forced = false; });
  $export($export.P + $export.F * forced, 'Array', {
    findIndex: function findIndex(callbackfn/*, that = undefined */){
      return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
    }
  });
  require('./_add-to-unscopables')(KEY);
  },{"./_add-to-unscopables":6,"./_array-methods":13,"./_export":33}],126:[function(require,module,exports){
  'use strict';
  // 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
  var $export = require('./_export')
    , $find   = require('./_array-methods')(5)
    , KEY     = 'find'
    , forced  = true;
  // Shouldn't skip holes
  if(KEY in [])Array(1)[KEY](function(){ forced = false; });
  $export($export.P + $export.F * forced, 'Array', {
    find: function find(callbackfn/*, that = undefined */){
      return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
    }
  });
  require('./_add-to-unscopables')(KEY);
  },{"./_add-to-unscopables":6,"./_array-methods":13,"./_export":33}],127:[function(require,module,exports){
  'use strict';
  var $export  = require('./_export')
    , $forEach = require('./_array-methods')(0)
    , STRICT   = require('./_strict-method')([].forEach, true);
  
  $export($export.P + $export.F * !STRICT, 'Array', {
    // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])
    forEach: function forEach(callbackfn /* , thisArg */){
      return $forEach(this, callbackfn, arguments[1]);
    }
  });
  },{"./_array-methods":13,"./_export":33,"./_strict-method":97}],128:[function(require,module,exports){
  'use strict';
  var ctx            = require('./_ctx')
    , $export        = require('./_export')
    , toObject       = require('./_to-object')
    , call           = require('./_iter-call')
    , isArrayIter    = require('./_is-array-iter')
    , toLength       = require('./_to-length')
    , createProperty = require('./_create-property')
    , getIterFn      = require('./core.get-iterator-method');
  
  $export($export.S + $export.F * !require('./_iter-detect')(function(iter){ Array.from(iter); }), 'Array', {
    // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
    from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
      var O       = toObject(arrayLike)
        , C       = typeof this == 'function' ? this : Array
        , aLen    = arguments.length
        , mapfn   = aLen > 1 ? arguments[1] : undefined
        , mapping = mapfn !== undefined
        , index   = 0
        , iterFn  = getIterFn(O)
        , length, result, step, iterator;
      if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
      // if object isn't iterable or it's array with default iterator - use simple case
      if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){
        for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){
          createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
        }
      } else {
        length = toLength(O.length);
        for(result = new C(length); length > index; index++){
          createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
        }
      }
      result.length = index;
      return result;
    }
  });
  
  },{"./_create-property":25,"./_ctx":26,"./_export":33,"./_is-array-iter":47,"./_iter-call":52,"./_iter-detect":55,"./_to-length":109,"./_to-object":110,"./core.get-iterator-method":119}],129:[function(require,module,exports){
  'use strict';
  var $export       = require('./_export')
    , $indexOf      = require('./_array-includes')(false)
    , $native       = [].indexOf
    , NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;
  
  $export($export.P + $export.F * (NEGATIVE_ZERO || !require('./_strict-method')($native)), 'Array', {
    // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])
    indexOf: function indexOf(searchElement /*, fromIndex = 0 */){
      return NEGATIVE_ZERO
        // convert -0 to +0
        ? $native.apply(this, arguments) || 0
        : $indexOf(this, searchElement, arguments[1]);
    }
  });
  },{"./_array-includes":12,"./_export":33,"./_strict-method":97}],130:[function(require,module,exports){
  // 22.1.2.2 / 15.4.3.2 Array.isArray(arg)
  var $export = require('./_export');
  
  $export($export.S, 'Array', {isArray: require('./_is-array')});
  },{"./_export":33,"./_is-array":48}],131:[function(require,module,exports){
  'use strict';
  var addToUnscopables = require('./_add-to-unscopables')
    , step             = require('./_iter-step')
    , Iterators        = require('./_iterators')
    , toIObject        = require('./_to-iobject');
  
  // 22.1.3.4 Array.prototype.entries()
  // 22.1.3.13 Array.prototype.keys()
  // 22.1.3.29 Array.prototype.values()
  // 22.1.3.30 Array.prototype[@@iterator]()
  module.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){
    this._t = toIObject(iterated); // target
    this._i = 0;                   // next index
    this._k = kind;                // kind
  // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
  }, function(){
    var O     = this._t
      , kind  = this._k
      , index = this._i++;
    if(!O || index >= O.length){
      this._t = undefined;
      return step(1);
    }
    if(kind == 'keys'  )return step(0, index);
    if(kind == 'values')return step(0, O[index]);
    return step(0, [index, O[index]]);
  }, 'values');
  
  // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
  Iterators.Arguments = Iterators.Array;
  
  addToUnscopables('keys');
  addToUnscopables('values');
  addToUnscopables('entries');
  },{"./_add-to-unscopables":6,"./_iter-define":54,"./_iter-step":56,"./_iterators":57,"./_to-iobject":108}],132:[function(require,module,exports){
  'use strict';
  // 22.1.3.13 Array.prototype.join(separator)
  var $export   = require('./_export')
    , toIObject = require('./_to-iobject')
    , arrayJoin = [].join;
  
  // fallback for not array-like strings
  $export($export.P + $export.F * (require('./_iobject') != Object || !require('./_strict-method')(arrayJoin)), 'Array', {
    join: function join(separator){
      return arrayJoin.call(toIObject(this), separator === undefined ? ',' : separator);
    }
  });
  },{"./_export":33,"./_iobject":46,"./_strict-method":97,"./_to-iobject":108}],133:[function(require,module,exports){
  'use strict';
  var $export       = require('./_export')
    , toIObject     = require('./_to-iobject')
    , toInteger     = require('./_to-integer')
    , toLength      = require('./_to-length')
    , $native       = [].lastIndexOf
    , NEGATIVE_ZERO = !!$native && 1 / [1].lastIndexOf(1, -0) < 0;
  
  $export($export.P + $export.F * (NEGATIVE_ZERO || !require('./_strict-method')($native)), 'Array', {
    // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])
    lastIndexOf: function lastIndexOf(searchElement /*, fromIndex = @[*-1] */){
      // convert -0 to +0
      if(NEGATIVE_ZERO)return $native.apply(this, arguments) || 0;
      var O      = toIObject(this)
        , length = toLength(O.length)
        , index  = length - 1;
      if(arguments.length > 1)index = Math.min(index, toInteger(arguments[1]));
      if(index < 0)index = length + index;
      for(;index >= 0; index--)if(index in O)if(O[index] === searchElement)return index || 0;
      return -1;
    }
  });
  },{"./_export":33,"./_strict-method":97,"./_to-integer":107,"./_to-iobject":108,"./_to-length":109}],134:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $map    = require('./_array-methods')(1);
  
  $export($export.P + $export.F * !require('./_strict-method')([].map, true), 'Array', {
    // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])
    map: function map(callbackfn /* , thisArg */){
      return $map(this, callbackfn, arguments[1]);
    }
  });
  },{"./_array-methods":13,"./_export":33,"./_strict-method":97}],135:[function(require,module,exports){
  'use strict';
  var $export        = require('./_export')
    , createProperty = require('./_create-property');
  
  // WebKit Array.of isn't generic
  $export($export.S + $export.F * require('./_fails')(function(){
    function F(){}
    return !(Array.of.call(F) instanceof F);
  }), 'Array', {
    // 22.1.2.3 Array.of( ...items)
    of: function of(/* ...args */){
      var index  = 0
        , aLen   = arguments.length
        , result = new (typeof this == 'function' ? this : Array)(aLen);
      while(aLen > index)createProperty(result, index, arguments[index++]);
      result.length = aLen;
      return result;
    }
  });
  },{"./_create-property":25,"./_export":33,"./_fails":35}],136:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $reduce = require('./_array-reduce');
  
  $export($export.P + $export.F * !require('./_strict-method')([].reduceRight, true), 'Array', {
    // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])
    reduceRight: function reduceRight(callbackfn /* , initialValue */){
      return $reduce(this, callbackfn, arguments.length, arguments[1], true);
    }
  });
  },{"./_array-reduce":14,"./_export":33,"./_strict-method":97}],137:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $reduce = require('./_array-reduce');
  
  $export($export.P + $export.F * !require('./_strict-method')([].reduce, true), 'Array', {
    // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])
    reduce: function reduce(callbackfn /* , initialValue */){
      return $reduce(this, callbackfn, arguments.length, arguments[1], false);
    }
  });
  },{"./_array-reduce":14,"./_export":33,"./_strict-method":97}],138:[function(require,module,exports){
  'use strict';
  var $export    = require('./_export')
    , html       = require('./_html')
    , cof        = require('./_cof')
    , toIndex    = require('./_to-index')
    , toLength   = require('./_to-length')
    , arraySlice = [].slice;
  
  // fallback for not array-like ES3 strings and DOM objects
  $export($export.P + $export.F * require('./_fails')(function(){
    if(html)arraySlice.call(html);
  }), 'Array', {
    slice: function slice(begin, end){
      var len   = toLength(this.length)
        , klass = cof(this);
      end = end === undefined ? len : end;
      if(klass == 'Array')return arraySlice.call(this, begin, end);
      var start  = toIndex(begin, len)
        , upTo   = toIndex(end, len)
        , size   = toLength(upTo - start)
        , cloned = Array(size)
        , i      = 0;
      for(; i < size; i++)cloned[i] = klass == 'String'
        ? this.charAt(start + i)
        : this[start + i];
      return cloned;
    }
  });
  },{"./_cof":19,"./_export":33,"./_fails":35,"./_html":42,"./_to-index":106,"./_to-length":109}],139:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $some   = require('./_array-methods')(3);
  
  $export($export.P + $export.F * !require('./_strict-method')([].some, true), 'Array', {
    // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])
    some: function some(callbackfn /* , thisArg */){
      return $some(this, callbackfn, arguments[1]);
    }
  });
  },{"./_array-methods":13,"./_export":33,"./_strict-method":97}],140:[function(require,module,exports){
  'use strict';
  var $export   = require('./_export')
    , aFunction = require('./_a-function')
    , toObject  = require('./_to-object')
    , fails     = require('./_fails')
    , $sort     = [].sort
    , test      = [1, 2, 3];
  
  $export($export.P + $export.F * (fails(function(){
    // IE8-
    test.sort(undefined);
  }) || !fails(function(){
    // V8 bug
    test.sort(null);
    // Old WebKit
  }) || !require('./_strict-method')($sort)), 'Array', {
    // 22.1.3.25 Array.prototype.sort(comparefn)
    sort: function sort(comparefn){
      return comparefn === undefined
        ? $sort.call(toObject(this))
        : $sort.call(toObject(this), aFunction(comparefn));
    }
  });
  },{"./_a-function":4,"./_export":33,"./_fails":35,"./_strict-method":97,"./_to-object":110}],141:[function(require,module,exports){
  require('./_set-species')('Array');
  },{"./_set-species":92}],142:[function(require,module,exports){
  // 20.3.3.1 / 15.9.4.4 Date.now()
  var $export = require('./_export');
  
  $export($export.S, 'Date', {now: function(){ return new Date().getTime(); }});
  },{"./_export":33}],143:[function(require,module,exports){
  'use strict';
  // 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
  var $export = require('./_export')
    , fails   = require('./_fails')
    , getTime = Date.prototype.getTime;
  
  var lz = function(num){
    return num > 9 ? num : '0' + num;
  };
  
  // PhantomJS / old WebKit has a broken implementations
  $export($export.P + $export.F * (fails(function(){
    return new Date(-5e13 - 1).toISOString() != '0385-07-25T07:06:39.999Z';
  }) || !fails(function(){
    new Date(NaN).toISOString();
  })), 'Date', {
    toISOString: function toISOString(){
      if(!isFinite(getTime.call(this)))throw RangeError('Invalid time value');
      var d = this
        , y = d.getUTCFullYear()
        , m = d.getUTCMilliseconds()
        , s = y < 0 ? '-' : y > 9999 ? '+' : '';
      return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +
        '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +
        'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +
        ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
    }
  });
  },{"./_export":33,"./_fails":35}],144:[function(require,module,exports){
  'use strict';
  var $export     = require('./_export')
    , toObject    = require('./_to-object')
    , toPrimitive = require('./_to-primitive');
  
  $export($export.P + $export.F * require('./_fails')(function(){
    return new Date(NaN).toJSON() !== null || Date.prototype.toJSON.call({toISOString: function(){ return 1; }}) !== 1;
  }), 'Date', {
    toJSON: function toJSON(key){
      var O  = toObject(this)
        , pv = toPrimitive(O);
      return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();
    }
  });
  },{"./_export":33,"./_fails":35,"./_to-object":110,"./_to-primitive":111}],145:[function(require,module,exports){
  var TO_PRIMITIVE = require('./_wks')('toPrimitive')
    , proto        = Date.prototype;
  
  if(!(TO_PRIMITIVE in proto))require('./_hide')(proto, TO_PRIMITIVE, require('./_date-to-primitive'));
  },{"./_date-to-primitive":27,"./_hide":41,"./_wks":118}],146:[function(require,module,exports){
  var DateProto    = Date.prototype
    , INVALID_DATE = 'Invalid Date'
    , TO_STRING    = 'toString'
    , $toString    = DateProto[TO_STRING]
    , getTime      = DateProto.getTime;
  if(new Date(NaN) + '' != INVALID_DATE){
    require('./_redefine')(DateProto, TO_STRING, function toString(){
      var value = getTime.call(this);
      return value === value ? $toString.call(this) : INVALID_DATE;
    });
  }
  },{"./_redefine":88}],147:[function(require,module,exports){
  // 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...)
  var $export = require('./_export');
  
  $export($export.P, 'Function', {bind: require('./_bind')});
  },{"./_bind":17,"./_export":33}],148:[function(require,module,exports){
  'use strict';
  var isObject       = require('./_is-object')
    , getPrototypeOf = require('./_object-gpo')
    , HAS_INSTANCE   = require('./_wks')('hasInstance')
    , FunctionProto  = Function.prototype;
  // 19.2.3.6 Function.prototype[@@hasInstance](V)
  if(!(HAS_INSTANCE in FunctionProto))require('./_object-dp').f(FunctionProto, HAS_INSTANCE, {value: function(O){
    if(typeof this != 'function' || !isObject(O))return false;
    if(!isObject(this.prototype))return O instanceof this;
    // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:
    while(O = getPrototypeOf(O))if(this.prototype === O)return true;
    return false;
  }});
  },{"./_is-object":50,"./_object-dp":68,"./_object-gpo":75,"./_wks":118}],149:[function(require,module,exports){
  var dP         = require('./_object-dp').f
    , createDesc = require('./_property-desc')
    , has        = require('./_has')
    , FProto     = Function.prototype
    , nameRE     = /^\s*function ([^ (]*)/
    , NAME       = 'name';
  
  var isExtensible = Object.isExtensible || function(){
    return true;
  };
  
  // 19.2.4.2 name
  NAME in FProto || require('./_descriptors') && dP(FProto, NAME, {
    configurable: true,
    get: function(){
      try {
        var that = this
          , name = ('' + that).match(nameRE)[1];
        has(that, NAME) || !isExtensible(that) || dP(that, NAME, createDesc(5, name));
        return name;
      } catch(e){
        return '';
      }
    }
  });
  },{"./_descriptors":29,"./_has":40,"./_object-dp":68,"./_property-desc":86}],150:[function(require,module,exports){
  'use strict';
  var strong = require('./_collection-strong');
  
  // 23.1 Map Objects
  module.exports = require('./_collection')('Map', function(get){
    return function Map(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  }, {
    // 23.1.3.6 Map.prototype.get(key)
    get: function get(key){
      var entry = strong.getEntry(this, key);
      return entry && entry.v;
    },
    // 23.1.3.9 Map.prototype.set(key, value)
    set: function set(key, value){
      return strong.def(this, key === 0 ? 0 : key, value);
    }
  }, strong, true);
  },{"./_collection":23,"./_collection-strong":20}],151:[function(require,module,exports){
  // 20.2.2.3 Math.acosh(x)
  var $export = require('./_export')
    , log1p   = require('./_math-log1p')
    , sqrt    = Math.sqrt
    , $acosh  = Math.acosh;
  
  $export($export.S + $export.F * !($acosh
    // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
    && Math.floor($acosh(Number.MAX_VALUE)) == 710
    // Tor Browser bug: Math.acosh(Infinity) -> NaN 
    && $acosh(Infinity) == Infinity
  ), 'Math', {
    acosh: function acosh(x){
      return (x = +x) < 1 ? NaN : x > 94906265.62425156
        ? Math.log(x) + Math.LN2
        : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
    }
  });
  },{"./_export":33,"./_math-log1p":61}],152:[function(require,module,exports){
  // 20.2.2.5 Math.asinh(x)
  var $export = require('./_export')
    , $asinh  = Math.asinh;
  
  function asinh(x){
    return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1));
  }
  
  // Tor Browser bug: Math.asinh(0) -> -0 
  $export($export.S + $export.F * !($asinh && 1 / $asinh(0) > 0), 'Math', {asinh: asinh});
  },{"./_export":33}],153:[function(require,module,exports){
  // 20.2.2.7 Math.atanh(x)
  var $export = require('./_export')
    , $atanh  = Math.atanh;
  
  // Tor Browser bug: Math.atanh(-0) -> 0 
  $export($export.S + $export.F * !($atanh && 1 / $atanh(-0) < 0), 'Math', {
    atanh: function atanh(x){
      return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;
    }
  });
  },{"./_export":33}],154:[function(require,module,exports){
  // 20.2.2.9 Math.cbrt(x)
  var $export = require('./_export')
    , sign    = require('./_math-sign');
  
  $export($export.S, 'Math', {
    cbrt: function cbrt(x){
      return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3);
    }
  });
  },{"./_export":33,"./_math-sign":62}],155:[function(require,module,exports){
  // 20.2.2.11 Math.clz32(x)
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    clz32: function clz32(x){
      return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32;
    }
  });
  },{"./_export":33}],156:[function(require,module,exports){
  // 20.2.2.12 Math.cosh(x)
  var $export = require('./_export')
    , exp     = Math.exp;
  
  $export($export.S, 'Math', {
    cosh: function cosh(x){
      return (exp(x = +x) + exp(-x)) / 2;
    }
  });
  },{"./_export":33}],157:[function(require,module,exports){
  // 20.2.2.14 Math.expm1(x)
  var $export = require('./_export')
    , $expm1  = require('./_math-expm1');
  
  $export($export.S + $export.F * ($expm1 != Math.expm1), 'Math', {expm1: $expm1});
  },{"./_export":33,"./_math-expm1":60}],158:[function(require,module,exports){
  // 20.2.2.16 Math.fround(x)
  var $export   = require('./_export')
    , sign      = require('./_math-sign')
    , pow       = Math.pow
    , EPSILON   = pow(2, -52)
    , EPSILON32 = pow(2, -23)
    , MAX32     = pow(2, 127) * (2 - EPSILON32)
    , MIN32     = pow(2, -126);
  
  var roundTiesToEven = function(n){
    return n + 1 / EPSILON - 1 / EPSILON;
  };
  
  
  $export($export.S, 'Math', {
    fround: function fround(x){
      var $abs  = Math.abs(x)
        , $sign = sign(x)
        , a, result;
      if($abs < MIN32)return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
      a = (1 + EPSILON32 / EPSILON) * $abs;
      result = a - (a - $abs);
      if(result > MAX32 || result != result)return $sign * Infinity;
      return $sign * result;
    }
  });
  },{"./_export":33,"./_math-sign":62}],159:[function(require,module,exports){
  // 20.2.2.17 Math.hypot([value1[, value2[, … ]]])
  var $export = require('./_export')
    , abs     = Math.abs;
  
  $export($export.S, 'Math', {
    hypot: function hypot(value1, value2){ // eslint-disable-line no-unused-vars
      var sum  = 0
        , i    = 0
        , aLen = arguments.length
        , larg = 0
        , arg, div;
      while(i < aLen){
        arg = abs(arguments[i++]);
        if(larg < arg){
          div  = larg / arg;
          sum  = sum * div * div + 1;
          larg = arg;
        } else if(arg > 0){
          div  = arg / larg;
          sum += div * div;
        } else sum += arg;
      }
      return larg === Infinity ? Infinity : larg * Math.sqrt(sum);
    }
  });
  },{"./_export":33}],160:[function(require,module,exports){
  // 20.2.2.18 Math.imul(x, y)
  var $export = require('./_export')
    , $imul   = Math.imul;
  
  // some WebKit versions fails with big numbers, some has wrong arity
  $export($export.S + $export.F * require('./_fails')(function(){
    return $imul(0xffffffff, 5) != -5 || $imul.length != 2;
  }), 'Math', {
    imul: function imul(x, y){
      var UINT16 = 0xffff
        , xn = +x
        , yn = +y
        , xl = UINT16 & xn
        , yl = UINT16 & yn;
      return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);
    }
  });
  },{"./_export":33,"./_fails":35}],161:[function(require,module,exports){
  // 20.2.2.21 Math.log10(x)
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    log10: function log10(x){
      return Math.log(x) / Math.LN10;
    }
  });
  },{"./_export":33}],162:[function(require,module,exports){
  // 20.2.2.20 Math.log1p(x)
  var $export = require('./_export');
  
  $export($export.S, 'Math', {log1p: require('./_math-log1p')});
  },{"./_export":33,"./_math-log1p":61}],163:[function(require,module,exports){
  // 20.2.2.22 Math.log2(x)
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    log2: function log2(x){
      return Math.log(x) / Math.LN2;
    }
  });
  },{"./_export":33}],164:[function(require,module,exports){
  // 20.2.2.28 Math.sign(x)
  var $export = require('./_export');
  
  $export($export.S, 'Math', {sign: require('./_math-sign')});
  },{"./_export":33,"./_math-sign":62}],165:[function(require,module,exports){
  // 20.2.2.30 Math.sinh(x)
  var $export = require('./_export')
    , expm1   = require('./_math-expm1')
    , exp     = Math.exp;
  
  // V8 near Chromium 38 has a problem with very small numbers
  $export($export.S + $export.F * require('./_fails')(function(){
    return !Math.sinh(-2e-17) != -2e-17;
  }), 'Math', {
    sinh: function sinh(x){
      return Math.abs(x = +x) < 1
        ? (expm1(x) - expm1(-x)) / 2
        : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2);
    }
  });
  },{"./_export":33,"./_fails":35,"./_math-expm1":60}],166:[function(require,module,exports){
  // 20.2.2.33 Math.tanh(x)
  var $export = require('./_export')
    , expm1   = require('./_math-expm1')
    , exp     = Math.exp;
  
  $export($export.S, 'Math', {
    tanh: function tanh(x){
      var a = expm1(x = +x)
        , b = expm1(-x);
      return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
    }
  });
  },{"./_export":33,"./_math-expm1":60}],167:[function(require,module,exports){
  // 20.2.2.34 Math.trunc(x)
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    trunc: function trunc(it){
      return (it > 0 ? Math.floor : Math.ceil)(it);
    }
  });
  },{"./_export":33}],168:[function(require,module,exports){
  'use strict';
  var global            = require('./_global')
    , has               = require('./_has')
    , cof               = require('./_cof')
    , inheritIfRequired = require('./_inherit-if-required')
    , toPrimitive       = require('./_to-primitive')
    , fails             = require('./_fails')
    , gOPN              = require('./_object-gopn').f
    , gOPD              = require('./_object-gopd').f
    , dP                = require('./_object-dp').f
    , $trim             = require('./_string-trim').trim
    , NUMBER            = 'Number'
    , $Number           = global[NUMBER]
    , Base              = $Number
    , proto             = $Number.prototype
    // Opera ~12 has broken Object#toString
    , BROKEN_COF        = cof(require('./_object-create')(proto)) == NUMBER
    , TRIM              = 'trim' in String.prototype;
  
  // 7.1.3 ToNumber(argument)
  var toNumber = function(argument){
    var it = toPrimitive(argument, false);
    if(typeof it == 'string' && it.length > 2){
      it = TRIM ? it.trim() : $trim(it, 3);
      var first = it.charCodeAt(0)
        , third, radix, maxCode;
      if(first === 43 || first === 45){
        third = it.charCodeAt(2);
        if(third === 88 || third === 120)return NaN; // Number('+0x1') should be NaN, old V8 fix
      } else if(first === 48){
        switch(it.charCodeAt(1)){
          case 66 : case 98  : radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i
          case 79 : case 111 : radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i
          default : return +it;
        }
        for(var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++){
          code = digits.charCodeAt(i);
          // parseInt parses a string to a first unavailable symbol
          // but ToNumber should return NaN if a string contains unavailable symbols
          if(code < 48 || code > maxCode)return NaN;
        } return parseInt(digits, radix);
      }
    } return +it;
  };
  
  if(!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')){
    $Number = function Number(value){
      var it = arguments.length < 1 ? 0 : value
        , that = this;
      return that instanceof $Number
        // check on 1..constructor(foo) case
        && (BROKEN_COF ? fails(function(){ proto.valueOf.call(that); }) : cof(that) != NUMBER)
          ? inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it);
    };
    for(var keys = require('./_descriptors') ? gOPN(Base) : (
      // ES3:
      'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
      // ES6 (in case, if modules with ES6 Number statics required before):
      'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
      'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
    ).split(','), j = 0, key; keys.length > j; j++){
      if(has(Base, key = keys[j]) && !has($Number, key)){
        dP($Number, key, gOPD(Base, key));
      }
    }
    $Number.prototype = proto;
    proto.constructor = $Number;
    require('./_redefine')(global, NUMBER, $Number);
  }
  },{"./_cof":19,"./_descriptors":29,"./_fails":35,"./_global":39,"./_has":40,"./_inherit-if-required":44,"./_object-create":67,"./_object-dp":68,"./_object-gopd":71,"./_object-gopn":73,"./_redefine":88,"./_string-trim":103,"./_to-primitive":111}],169:[function(require,module,exports){
  // 20.1.2.1 Number.EPSILON
  var $export = require('./_export');
  
  $export($export.S, 'Number', {EPSILON: Math.pow(2, -52)});
  },{"./_export":33}],170:[function(require,module,exports){
  // 20.1.2.2 Number.isFinite(number)
  var $export   = require('./_export')
    , _isFinite = require('./_global').isFinite;
  
  $export($export.S, 'Number', {
    isFinite: function isFinite(it){
      return typeof it == 'number' && _isFinite(it);
    }
  });
  },{"./_export":33,"./_global":39}],171:[function(require,module,exports){
  // 20.1.2.3 Number.isInteger(number)
  var $export = require('./_export');
  
  $export($export.S, 'Number', {isInteger: require('./_is-integer')});
  },{"./_export":33,"./_is-integer":49}],172:[function(require,module,exports){
  // 20.1.2.4 Number.isNaN(number)
  var $export = require('./_export');
  
  $export($export.S, 'Number', {
    isNaN: function isNaN(number){
      return number != number;
    }
  });
  },{"./_export":33}],173:[function(require,module,exports){
  // 20.1.2.5 Number.isSafeInteger(number)
  var $export   = require('./_export')
    , isInteger = require('./_is-integer')
    , abs       = Math.abs;
  
  $export($export.S, 'Number', {
    isSafeInteger: function isSafeInteger(number){
      return isInteger(number) && abs(number) <= 0x1fffffffffffff;
    }
  });
  },{"./_export":33,"./_is-integer":49}],174:[function(require,module,exports){
  // 20.1.2.6 Number.MAX_SAFE_INTEGER
  var $export = require('./_export');
  
  $export($export.S, 'Number', {MAX_SAFE_INTEGER: 0x1fffffffffffff});
  },{"./_export":33}],175:[function(require,module,exports){
  // 20.1.2.10 Number.MIN_SAFE_INTEGER
  var $export = require('./_export');
  
  $export($export.S, 'Number', {MIN_SAFE_INTEGER: -0x1fffffffffffff});
  },{"./_export":33}],176:[function(require,module,exports){
  var $export     = require('./_export')
    , $parseFloat = require('./_parse-float');
  // 20.1.2.12 Number.parseFloat(string)
  $export($export.S + $export.F * (Number.parseFloat != $parseFloat), 'Number', {parseFloat: $parseFloat});
  },{"./_export":33,"./_parse-float":82}],177:[function(require,module,exports){
  var $export   = require('./_export')
    , $parseInt = require('./_parse-int');
  // 20.1.2.13 Number.parseInt(string, radix)
  $export($export.S + $export.F * (Number.parseInt != $parseInt), 'Number', {parseInt: $parseInt});
  },{"./_export":33,"./_parse-int":83}],178:[function(require,module,exports){
  'use strict';
  var $export      = require('./_export')
    , toInteger    = require('./_to-integer')
    , aNumberValue = require('./_a-number-value')
    , repeat       = require('./_string-repeat')
    , $toFixed     = 1..toFixed
    , floor        = Math.floor
    , data         = [0, 0, 0, 0, 0, 0]
    , ERROR        = 'Number.toFixed: incorrect invocation!'
    , ZERO         = '0';
  
  var multiply = function(n, c){
    var i  = -1
      , c2 = c;
    while(++i < 6){
      c2 += n * data[i];
      data[i] = c2 % 1e7;
      c2 = floor(c2 / 1e7);
    }
  };
  var divide = function(n){
    var i = 6
      , c = 0;
    while(--i >= 0){
      c += data[i];
      data[i] = floor(c / n);
      c = (c % n) * 1e7;
    }
  };
  var numToString = function(){
    var i = 6
      , s = '';
    while(--i >= 0){
      if(s !== '' || i === 0 || data[i] !== 0){
        var t = String(data[i]);
        s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t;
      }
    } return s;
  };
  var pow = function(x, n, acc){
    return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);
  };
  var log = function(x){
    var n  = 0
      , x2 = x;
    while(x2 >= 4096){
      n += 12;
      x2 /= 4096;
    }
    while(x2 >= 2){
      n  += 1;
      x2 /= 2;
    } return n;
  };
  
  $export($export.P + $export.F * (!!$toFixed && (
    0.00008.toFixed(3) !== '0.000' ||
    0.9.toFixed(0) !== '1' ||
    1.255.toFixed(2) !== '1.25' ||
    1000000000000000128..toFixed(0) !== '1000000000000000128'
  ) || !require('./_fails')(function(){
    // V8 ~ Android 4.3-
    $toFixed.call({});
  })), 'Number', {
    toFixed: function toFixed(fractionDigits){
      var x = aNumberValue(this, ERROR)
        , f = toInteger(fractionDigits)
        , s = ''
        , m = ZERO
        , e, z, j, k;
      if(f < 0 || f > 20)throw RangeError(ERROR);
      if(x != x)return 'NaN';
      if(x <= -1e21 || x >= 1e21)return String(x);
      if(x < 0){
        s = '-';
        x = -x;
      }
      if(x > 1e-21){
        e = log(x * pow(2, 69, 1)) - 69;
        z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1);
        z *= 0x10000000000000;
        e = 52 - e;
        if(e > 0){
          multiply(0, z);
          j = f;
          while(j >= 7){
            multiply(1e7, 0);
            j -= 7;
          }
          multiply(pow(10, j, 1), 0);
          j = e - 1;
          while(j >= 23){
            divide(1 << 23);
            j -= 23;
          }
          divide(1 << j);
          multiply(1, 1);
          divide(2);
          m = numToString();
        } else {
          multiply(0, z);
          multiply(1 << -e, 0);
          m = numToString() + repeat.call(ZERO, f);
        }
      }
      if(f > 0){
        k = m.length;
        m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f));
      } else {
        m = s + m;
      } return m;
    }
  });
  },{"./_a-number-value":5,"./_export":33,"./_fails":35,"./_string-repeat":102,"./_to-integer":107}],179:[function(require,module,exports){
  'use strict';
  var $export      = require('./_export')
    , $fails       = require('./_fails')
    , aNumberValue = require('./_a-number-value')
    , $toPrecision = 1..toPrecision;
  
  $export($export.P + $export.F * ($fails(function(){
    // IE7-
    return $toPrecision.call(1, undefined) !== '1';
  }) || !$fails(function(){
    // V8 ~ Android 4.3-
    $toPrecision.call({});
  })), 'Number', {
    toPrecision: function toPrecision(precision){
      var that = aNumberValue(this, 'Number#toPrecision: incorrect invocation!');
      return precision === undefined ? $toPrecision.call(that) : $toPrecision.call(that, precision); 
    }
  });
  },{"./_a-number-value":5,"./_export":33,"./_fails":35}],180:[function(require,module,exports){
  // 19.1.3.1 Object.assign(target, source)
  var $export = require('./_export');
  
  $export($export.S + $export.F, 'Object', {assign: require('./_object-assign')});
  },{"./_export":33,"./_object-assign":66}],181:[function(require,module,exports){
  var $export = require('./_export')
  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  $export($export.S, 'Object', {create: require('./_object-create')});
  },{"./_export":33,"./_object-create":67}],182:[function(require,module,exports){
  var $export = require('./_export');
  // 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties)
  $export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperties: require('./_object-dps')});
  },{"./_descriptors":29,"./_export":33,"./_object-dps":69}],183:[function(require,module,exports){
  var $export = require('./_export');
  // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
  $export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperty: require('./_object-dp').f});
  },{"./_descriptors":29,"./_export":33,"./_object-dp":68}],184:[function(require,module,exports){
  // 19.1.2.5 Object.freeze(O)
  var isObject = require('./_is-object')
    , meta     = require('./_meta').onFreeze;
  
  require('./_object-sap')('freeze', function($freeze){
    return function freeze(it){
      return $freeze && isObject(it) ? $freeze(meta(it)) : it;
    };
  });
  },{"./_is-object":50,"./_meta":63,"./_object-sap":79}],185:[function(require,module,exports){
  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  var toIObject                 = require('./_to-iobject')
    , $getOwnPropertyDescriptor = require('./_object-gopd').f;
  
  require('./_object-sap')('getOwnPropertyDescriptor', function(){
    return function getOwnPropertyDescriptor(it, key){
      return $getOwnPropertyDescriptor(toIObject(it), key);
    };
  });
  },{"./_object-gopd":71,"./_object-sap":79,"./_to-iobject":108}],186:[function(require,module,exports){
  // 19.1.2.7 Object.getOwnPropertyNames(O)
  require('./_object-sap')('getOwnPropertyNames', function(){
    return require('./_object-gopn-ext').f;
  });
  },{"./_object-gopn-ext":72,"./_object-sap":79}],187:[function(require,module,exports){
  // 19.1.2.9 Object.getPrototypeOf(O)
  var toObject        = require('./_to-object')
    , $getPrototypeOf = require('./_object-gpo');
  
  require('./_object-sap')('getPrototypeOf', function(){
    return function getPrototypeOf(it){
      return $getPrototypeOf(toObject(it));
    };
  });
  },{"./_object-gpo":75,"./_object-sap":79,"./_to-object":110}],188:[function(require,module,exports){
  // 19.1.2.11 Object.isExtensible(O)
  var isObject = require('./_is-object');
  
  require('./_object-sap')('isExtensible', function($isExtensible){
    return function isExtensible(it){
      return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false;
    };
  });
  },{"./_is-object":50,"./_object-sap":79}],189:[function(require,module,exports){
  // 19.1.2.12 Object.isFrozen(O)
  var isObject = require('./_is-object');
  
  require('./_object-sap')('isFrozen', function($isFrozen){
    return function isFrozen(it){
      return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true;
    };
  });
  },{"./_is-object":50,"./_object-sap":79}],190:[function(require,module,exports){
  // 19.1.2.13 Object.isSealed(O)
  var isObject = require('./_is-object');
  
  require('./_object-sap')('isSealed', function($isSealed){
    return function isSealed(it){
      return isObject(it) ? $isSealed ? $isSealed(it) : false : true;
    };
  });
  },{"./_is-object":50,"./_object-sap":79}],191:[function(require,module,exports){
  // 19.1.3.10 Object.is(value1, value2)
  var $export = require('./_export');
  $export($export.S, 'Object', {is: require('./_same-value')});
  },{"./_export":33,"./_same-value":90}],192:[function(require,module,exports){
  // 19.1.2.14 Object.keys(O)
  var toObject = require('./_to-object')
    , $keys    = require('./_object-keys');
  
  require('./_object-sap')('keys', function(){
    return function keys(it){
      return $keys(toObject(it));
    };
  });
  },{"./_object-keys":77,"./_object-sap":79,"./_to-object":110}],193:[function(require,module,exports){
  // 19.1.2.15 Object.preventExtensions(O)
  var isObject = require('./_is-object')
    , meta     = require('./_meta').onFreeze;
  
  require('./_object-sap')('preventExtensions', function($preventExtensions){
    return function preventExtensions(it){
      return $preventExtensions && isObject(it) ? $preventExtensions(meta(it)) : it;
    };
  });
  },{"./_is-object":50,"./_meta":63,"./_object-sap":79}],194:[function(require,module,exports){
  // 19.1.2.17 Object.seal(O)
  var isObject = require('./_is-object')
    , meta     = require('./_meta').onFreeze;
  
  require('./_object-sap')('seal', function($seal){
    return function seal(it){
      return $seal && isObject(it) ? $seal(meta(it)) : it;
    };
  });
  },{"./_is-object":50,"./_meta":63,"./_object-sap":79}],195:[function(require,module,exports){
  // 19.1.3.19 Object.setPrototypeOf(O, proto)
  var $export = require('./_export');
  $export($export.S, 'Object', {setPrototypeOf: require('./_set-proto').set});
  },{"./_export":33,"./_set-proto":91}],196:[function(require,module,exports){
  'use strict';
  // 19.1.3.6 Object.prototype.toString()
  var classof = require('./_classof')
    , test    = {};
  test[require('./_wks')('toStringTag')] = 'z';
  if(test + '' != '[object z]'){
    require('./_redefine')(Object.prototype, 'toString', function toString(){
      return '[object ' + classof(this) + ']';
    }, true);
  }
  },{"./_classof":18,"./_redefine":88,"./_wks":118}],197:[function(require,module,exports){
  var $export     = require('./_export')
    , $parseFloat = require('./_parse-float');
  // 18.2.4 parseFloat(string)
  $export($export.G + $export.F * (parseFloat != $parseFloat), {parseFloat: $parseFloat});
  },{"./_export":33,"./_parse-float":82}],198:[function(require,module,exports){
  var $export   = require('./_export')
    , $parseInt = require('./_parse-int');
  // 18.2.5 parseInt(string, radix)
  $export($export.G + $export.F * (parseInt != $parseInt), {parseInt: $parseInt});
  },{"./_export":33,"./_parse-int":83}],199:[function(require,module,exports){
  'use strict';
  var LIBRARY            = require('./_library')
    , global             = require('./_global')
    , ctx                = require('./_ctx')
    , classof            = require('./_classof')
    , $export            = require('./_export')
    , isObject           = require('./_is-object')
    , aFunction          = require('./_a-function')
    , anInstance         = require('./_an-instance')
    , forOf              = require('./_for-of')
    , speciesConstructor = require('./_species-constructor')
    , task               = require('./_task').set
    , microtask          = require('./_microtask')()
    , PROMISE            = 'Promise'
    , TypeError          = global.TypeError
    , process            = global.process
    , $Promise           = global[PROMISE]
    , process            = global.process
    , isNode             = classof(process) == 'process'
    , empty              = function(){ /* empty */ }
    , Internal, GenericPromiseCapability, Wrapper;
  
  var USE_NATIVE = !!function(){
    try {
      // correct subclassing with @@species support
      var promise     = $Promise.resolve(1)
        , FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function(exec){ exec(empty, empty); };
      // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
      return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
    } catch(e){ /* empty */ }
  }();
  
  // helpers
  var sameConstructor = function(a, b){
    // with library wrapper special case
    return a === b || a === $Promise && b === Wrapper;
  };
  var isThenable = function(it){
    var then;
    return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
  };
  var newPromiseCapability = function(C){
    return sameConstructor($Promise, C)
      ? new PromiseCapability(C)
      : new GenericPromiseCapability(C);
  };
  var PromiseCapability = GenericPromiseCapability = function(C){
    var resolve, reject;
    this.promise = new C(function($$resolve, $$reject){
      if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');
      resolve = $$resolve;
      reject  = $$reject;
    });
    this.resolve = aFunction(resolve);
    this.reject  = aFunction(reject);
  };
  var perform = function(exec){
    try {
      exec();
    } catch(e){
      return {error: e};
    }
  };
  var notify = function(promise, isReject){
    if(promise._n)return;
    promise._n = true;
    var chain = promise._c;
    microtask(function(){
      var value = promise._v
        , ok    = promise._s == 1
        , i     = 0;
      var run = function(reaction){
        var handler = ok ? reaction.ok : reaction.fail
          , resolve = reaction.resolve
          , reject  = reaction.reject
          , domain  = reaction.domain
          , result, then;
        try {
          if(handler){
            if(!ok){
              if(promise._h == 2)onHandleUnhandled(promise);
              promise._h = 1;
            }
            if(handler === true)result = value;
            else {
              if(domain)domain.enter();
              result = handler(value);
              if(domain)domain.exit();
            }
            if(result === reaction.promise){
              reject(TypeError('Promise-chain cycle'));
            } else if(then = isThenable(result)){
              then.call(result, resolve, reject);
            } else resolve(result);
          } else reject(value);
        } catch(e){
          reject(e);
        }
      };
      while(chain.length > i)run(chain[i++]); // variable length - can't use forEach
      promise._c = [];
      promise._n = false;
      if(isReject && !promise._h)onUnhandled(promise);
    });
  };
  var onUnhandled = function(promise){
    task.call(global, function(){
      var value = promise._v
        , abrupt, handler, console;
      if(isUnhandled(promise)){
        abrupt = perform(function(){
          if(isNode){
            process.emit('unhandledRejection', value, promise);
          } else if(handler = global.onunhandledrejection){
            handler({promise: promise, reason: value});
          } else if((console = global.console) && console.error){
            console.error('Unhandled promise rejection', value);
          }
        });
        // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
        promise._h = isNode || isUnhandled(promise) ? 2 : 1;
      } promise._a = undefined;
      if(abrupt)throw abrupt.error;
    });
  };
  var isUnhandled = function(promise){
    if(promise._h == 1)return false;
    var chain = promise._a || promise._c
      , i     = 0
      , reaction;
    while(chain.length > i){
      reaction = chain[i++];
      if(reaction.fail || !isUnhandled(reaction.promise))return false;
    } return true;
  };
  var onHandleUnhandled = function(promise){
    task.call(global, function(){
      var handler;
      if(isNode){
        process.emit('rejectionHandled', promise);
      } else if(handler = global.onrejectionhandled){
        handler({promise: promise, reason: promise._v});
      }
    });
  };
  var $reject = function(value){
    var promise = this;
    if(promise._d)return;
    promise._d = true;
    promise = promise._w || promise; // unwrap
    promise._v = value;
    promise._s = 2;
    if(!promise._a)promise._a = promise._c.slice();
    notify(promise, true);
  };
  var $resolve = function(value){
    var promise = this
      , then;
    if(promise._d)return;
    promise._d = true;
    promise = promise._w || promise; // unwrap
    try {
      if(promise === value)throw TypeError("Promise can't be resolved itself");
      if(then = isThenable(value)){
        microtask(function(){
          var wrapper = {_w: promise, _d: false}; // wrap
          try {
            then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
          } catch(e){
            $reject.call(wrapper, e);
          }
        });
      } else {
        promise._v = value;
        promise._s = 1;
        notify(promise, false);
      }
    } catch(e){
      $reject.call({_w: promise, _d: false}, e); // wrap
    }
  };
  
  // constructor polyfill
  if(!USE_NATIVE){
    // 25.4.3.1 Promise(executor)
    $Promise = function Promise(executor){
      anInstance(this, $Promise, PROMISE, '_h');
      aFunction(executor);
      Internal.call(this);
      try {
        executor(ctx($resolve, this, 1), ctx($reject, this, 1));
      } catch(err){
        $reject.call(this, err);
      }
    };
    Internal = function Promise(executor){
      this._c = [];             // <- awaiting reactions
      this._a = undefined;      // <- checked in isUnhandled reactions
      this._s = 0;              // <- state
      this._d = false;          // <- done
      this._v = undefined;      // <- value
      this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
      this._n = false;          // <- notify
    };
    Internal.prototype = require('./_redefine-all')($Promise.prototype, {
      // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
      then: function then(onFulfilled, onRejected){
        var reaction    = newPromiseCapability(speciesConstructor(this, $Promise));
        reaction.ok     = typeof onFulfilled == 'function' ? onFulfilled : true;
        reaction.fail   = typeof onRejected == 'function' && onRejected;
        reaction.domain = isNode ? process.domain : undefined;
        this._c.push(reaction);
        if(this._a)this._a.push(reaction);
        if(this._s)notify(this, false);
        return reaction.promise;
      },
      // 25.4.5.1 Promise.prototype.catch(onRejected)
      'catch': function(onRejected){
        return this.then(undefined, onRejected);
      }
    });
    PromiseCapability = function(){
      var promise  = new Internal;
      this.promise = promise;
      this.resolve = ctx($resolve, promise, 1);
      this.reject  = ctx($reject, promise, 1);
    };
  }
  
  $export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});
  require('./_set-to-string-tag')($Promise, PROMISE);
  require('./_set-species')(PROMISE);
  Wrapper = require('./_core')[PROMISE];
  
  // statics
  $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
    // 25.4.4.5 Promise.reject(r)
    reject: function reject(r){
      var capability = newPromiseCapability(this)
        , $$reject   = capability.reject;
      $$reject(r);
      return capability.promise;
    }
  });
  $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
    // 25.4.4.6 Promise.resolve(x)
    resolve: function resolve(x){
      // instanceof instead of internal slot check because we should fix it without replacement native Promise core
      if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;
      var capability = newPromiseCapability(this)
        , $$resolve  = capability.resolve;
      $$resolve(x);
      return capability.promise;
    }
  });
  $export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function(iter){
    $Promise.all(iter)['catch'](empty);
  })), PROMISE, {
    // 25.4.4.1 Promise.all(iterable)
    all: function all(iterable){
      var C          = this
        , capability = newPromiseCapability(C)
        , resolve    = capability.resolve
        , reject     = capability.reject;
      var abrupt = perform(function(){
        var values    = []
          , index     = 0
          , remaining = 1;
        forOf(iterable, false, function(promise){
          var $index        = index++
            , alreadyCalled = false;
          values.push(undefined);
          remaining++;
          C.resolve(promise).then(function(value){
            if(alreadyCalled)return;
            alreadyCalled  = true;
            values[$index] = value;
            --remaining || resolve(values);
          }, reject);
        });
        --remaining || resolve(values);
      });
      if(abrupt)reject(abrupt.error);
      return capability.promise;
    },
    // 25.4.4.4 Promise.race(iterable)
    race: function race(iterable){
      var C          = this
        , capability = newPromiseCapability(C)
        , reject     = capability.reject;
      var abrupt = perform(function(){
        forOf(iterable, false, function(promise){
          C.resolve(promise).then(capability.resolve, reject);
        });
      });
      if(abrupt)reject(abrupt.error);
      return capability.promise;
    }
  });
  },{"./_a-function":4,"./_an-instance":7,"./_classof":18,"./_core":24,"./_ctx":26,"./_export":33,"./_for-of":38,"./_global":39,"./_is-object":50,"./_iter-detect":55,"./_library":59,"./_microtask":65,"./_redefine-all":87,"./_set-species":92,"./_set-to-string-tag":93,"./_species-constructor":96,"./_task":105,"./_wks":118}],200:[function(require,module,exports){
  // 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
  var $export   = require('./_export')
    , aFunction = require('./_a-function')
    , anObject  = require('./_an-object')
    , rApply    = (require('./_global').Reflect || {}).apply
    , fApply    = Function.apply;
  // MS Edge argumentsList argument is optional
  $export($export.S + $export.F * !require('./_fails')(function(){
    rApply(function(){});
  }), 'Reflect', {
    apply: function apply(target, thisArgument, argumentsList){
      var T = aFunction(target)
        , L = anObject(argumentsList);
      return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L);
    }
  });
  },{"./_a-function":4,"./_an-object":8,"./_export":33,"./_fails":35,"./_global":39}],201:[function(require,module,exports){
  // 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
  var $export    = require('./_export')
    , create     = require('./_object-create')
    , aFunction  = require('./_a-function')
    , anObject   = require('./_an-object')
    , isObject   = require('./_is-object')
    , fails      = require('./_fails')
    , bind       = require('./_bind')
    , rConstruct = (require('./_global').Reflect || {}).construct;
  
  // MS Edge supports only 2 arguments and argumentsList argument is optional
  // FF Nightly sets third argument as `new.target`, but does not create `this` from it
  var NEW_TARGET_BUG = fails(function(){
    function F(){}
    return !(rConstruct(function(){}, [], F) instanceof F);
  });
  var ARGS_BUG = !fails(function(){
    rConstruct(function(){});
  });
  
  $export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', {
    construct: function construct(Target, args /*, newTarget*/){
      aFunction(Target);
      anObject(args);
      var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
      if(ARGS_BUG && !NEW_TARGET_BUG)return rConstruct(Target, args, newTarget);
      if(Target == newTarget){
        // w/o altered newTarget, optimization for 0-4 arguments
        switch(args.length){
          case 0: return new Target;
          case 1: return new Target(args[0]);
          case 2: return new Target(args[0], args[1]);
          case 3: return new Target(args[0], args[1], args[2]);
          case 4: return new Target(args[0], args[1], args[2], args[3]);
        }
        // w/o altered newTarget, lot of arguments case
        var $args = [null];
        $args.push.apply($args, args);
        return new (bind.apply(Target, $args));
      }
      // with altered newTarget, not support built-in constructors
      var proto    = newTarget.prototype
        , instance = create(isObject(proto) ? proto : Object.prototype)
        , result   = Function.apply.call(Target, instance, args);
      return isObject(result) ? result : instance;
    }
  });
  },{"./_a-function":4,"./_an-object":8,"./_bind":17,"./_export":33,"./_fails":35,"./_global":39,"./_is-object":50,"./_object-create":67}],202:[function(require,module,exports){
  // 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
  var dP          = require('./_object-dp')
    , $export     = require('./_export')
    , anObject    = require('./_an-object')
    , toPrimitive = require('./_to-primitive');
  
  // MS Edge has broken Reflect.defineProperty - throwing instead of returning false
  $export($export.S + $export.F * require('./_fails')(function(){
    Reflect.defineProperty(dP.f({}, 1, {value: 1}), 1, {value: 2});
  }), 'Reflect', {
    defineProperty: function defineProperty(target, propertyKey, attributes){
      anObject(target);
      propertyKey = toPrimitive(propertyKey, true);
      anObject(attributes);
      try {
        dP.f(target, propertyKey, attributes);
        return true;
      } catch(e){
        return false;
      }
    }
  });
  },{"./_an-object":8,"./_export":33,"./_fails":35,"./_object-dp":68,"./_to-primitive":111}],203:[function(require,module,exports){
  // 26.1.4 Reflect.deleteProperty(target, propertyKey)
  var $export  = require('./_export')
    , gOPD     = require('./_object-gopd').f
    , anObject = require('./_an-object');
  
  $export($export.S, 'Reflect', {
    deleteProperty: function deleteProperty(target, propertyKey){
      var desc = gOPD(anObject(target), propertyKey);
      return desc && !desc.configurable ? false : delete target[propertyKey];
    }
  });
  },{"./_an-object":8,"./_export":33,"./_object-gopd":71}],204:[function(require,module,exports){
  'use strict';
  // 26.1.5 Reflect.enumerate(target)
  var $export  = require('./_export')
    , anObject = require('./_an-object');
  var Enumerate = function(iterated){
    this._t = anObject(iterated); // target
    this._i = 0;                  // next index
    var keys = this._k = []       // keys
      , key;
    for(key in iterated)keys.push(key);
  };
  require('./_iter-create')(Enumerate, 'Object', function(){
    var that = this
      , keys = that._k
      , key;
    do {
      if(that._i >= keys.length)return {value: undefined, done: true};
    } while(!((key = keys[that._i++]) in that._t));
    return {value: key, done: false};
  });
  
  $export($export.S, 'Reflect', {
    enumerate: function enumerate(target){
      return new Enumerate(target);
    }
  });
  },{"./_an-object":8,"./_export":33,"./_iter-create":53}],205:[function(require,module,exports){
  // 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
  var gOPD     = require('./_object-gopd')
    , $export  = require('./_export')
    , anObject = require('./_an-object');
  
  $export($export.S, 'Reflect', {
    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey){
      return gOPD.f(anObject(target), propertyKey);
    }
  });
  },{"./_an-object":8,"./_export":33,"./_object-gopd":71}],206:[function(require,module,exports){
  // 26.1.8 Reflect.getPrototypeOf(target)
  var $export  = require('./_export')
    , getProto = require('./_object-gpo')
    , anObject = require('./_an-object');
  
  $export($export.S, 'Reflect', {
    getPrototypeOf: function getPrototypeOf(target){
      return getProto(anObject(target));
    }
  });
  },{"./_an-object":8,"./_export":33,"./_object-gpo":75}],207:[function(require,module,exports){
  // 26.1.6 Reflect.get(target, propertyKey [, receiver])
  var gOPD           = require('./_object-gopd')
    , getPrototypeOf = require('./_object-gpo')
    , has            = require('./_has')
    , $export        = require('./_export')
    , isObject       = require('./_is-object')
    , anObject       = require('./_an-object');
  
  function get(target, propertyKey/*, receiver*/){
    var receiver = arguments.length < 3 ? target : arguments[2]
      , desc, proto;
    if(anObject(target) === receiver)return target[propertyKey];
    if(desc = gOPD.f(target, propertyKey))return has(desc, 'value')
      ? desc.value
      : desc.get !== undefined
        ? desc.get.call(receiver)
        : undefined;
    if(isObject(proto = getPrototypeOf(target)))return get(proto, propertyKey, receiver);
  }
  
  $export($export.S, 'Reflect', {get: get});
  },{"./_an-object":8,"./_export":33,"./_has":40,"./_is-object":50,"./_object-gopd":71,"./_object-gpo":75}],208:[function(require,module,exports){
  // 26.1.9 Reflect.has(target, propertyKey)
  var $export = require('./_export');
  
  $export($export.S, 'Reflect', {
    has: function has(target, propertyKey){
      return propertyKey in target;
    }
  });
  },{"./_export":33}],209:[function(require,module,exports){
  // 26.1.10 Reflect.isExtensible(target)
  var $export       = require('./_export')
    , anObject      = require('./_an-object')
    , $isExtensible = Object.isExtensible;
  
  $export($export.S, 'Reflect', {
    isExtensible: function isExtensible(target){
      anObject(target);
      return $isExtensible ? $isExtensible(target) : true;
    }
  });
  },{"./_an-object":8,"./_export":33}],210:[function(require,module,exports){
  // 26.1.11 Reflect.ownKeys(target)
  var $export = require('./_export');
  
  $export($export.S, 'Reflect', {ownKeys: require('./_own-keys')});
  },{"./_export":33,"./_own-keys":81}],211:[function(require,module,exports){
  // 26.1.12 Reflect.preventExtensions(target)
  var $export            = require('./_export')
    , anObject           = require('./_an-object')
    , $preventExtensions = Object.preventExtensions;
  
  $export($export.S, 'Reflect', {
    preventExtensions: function preventExtensions(target){
      anObject(target);
      try {
        if($preventExtensions)$preventExtensions(target);
        return true;
      } catch(e){
        return false;
      }
    }
  });
  },{"./_an-object":8,"./_export":33}],212:[function(require,module,exports){
  // 26.1.14 Reflect.setPrototypeOf(target, proto)
  var $export  = require('./_export')
    , setProto = require('./_set-proto');
  
  if(setProto)$export($export.S, 'Reflect', {
    setPrototypeOf: function setPrototypeOf(target, proto){
      setProto.check(target, proto);
      try {
        setProto.set(target, proto);
        return true;
      } catch(e){
        return false;
      }
    }
  });
  },{"./_export":33,"./_set-proto":91}],213:[function(require,module,exports){
  // 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
  var dP             = require('./_object-dp')
    , gOPD           = require('./_object-gopd')
    , getPrototypeOf = require('./_object-gpo')
    , has            = require('./_has')
    , $export        = require('./_export')
    , createDesc     = require('./_property-desc')
    , anObject       = require('./_an-object')
    , isObject       = require('./_is-object');
  
  function set(target, propertyKey, V/*, receiver*/){
    var receiver = arguments.length < 4 ? target : arguments[3]
      , ownDesc  = gOPD.f(anObject(target), propertyKey)
      , existingDescriptor, proto;
    if(!ownDesc){
      if(isObject(proto = getPrototypeOf(target))){
        return set(proto, propertyKey, V, receiver);
      }
      ownDesc = createDesc(0);
    }
    if(has(ownDesc, 'value')){
      if(ownDesc.writable === false || !isObject(receiver))return false;
      existingDescriptor = gOPD.f(receiver, propertyKey) || createDesc(0);
      existingDescriptor.value = V;
      dP.f(receiver, propertyKey, existingDescriptor);
      return true;
    }
    return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
  }
  
  $export($export.S, 'Reflect', {set: set});
  },{"./_an-object":8,"./_export":33,"./_has":40,"./_is-object":50,"./_object-dp":68,"./_object-gopd":71,"./_object-gpo":75,"./_property-desc":86}],214:[function(require,module,exports){
  var global            = require('./_global')
    , inheritIfRequired = require('./_inherit-if-required')
    , dP                = require('./_object-dp').f
    , gOPN              = require('./_object-gopn').f
    , isRegExp          = require('./_is-regexp')
    , $flags            = require('./_flags')
    , $RegExp           = global.RegExp
    , Base              = $RegExp
    , proto             = $RegExp.prototype
    , re1               = /a/g
    , re2               = /a/g
    // "new" creates a new object, old webkit buggy here
    , CORRECT_NEW       = new $RegExp(re1) !== re1;
  
  if(require('./_descriptors') && (!CORRECT_NEW || require('./_fails')(function(){
    re2[require('./_wks')('match')] = false;
    // RegExp constructor can alter flags and IsRegExp works correct with @@match
    return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i';
  }))){
    $RegExp = function RegExp(p, f){
      var tiRE = this instanceof $RegExp
        , piRE = isRegExp(p)
        , fiU  = f === undefined;
      return !tiRE && piRE && p.constructor === $RegExp && fiU ? p
        : inheritIfRequired(CORRECT_NEW
          ? new Base(piRE && !fiU ? p.source : p, f)
          : Base((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? $flags.call(p) : f)
        , tiRE ? this : proto, $RegExp);
    };
    var proxy = function(key){
      key in $RegExp || dP($RegExp, key, {
        configurable: true,
        get: function(){ return Base[key]; },
        set: function(it){ Base[key] = it; }
      });
    };
    for(var keys = gOPN(Base), i = 0; keys.length > i; )proxy(keys[i++]);
    proto.constructor = $RegExp;
    $RegExp.prototype = proto;
    require('./_redefine')(global, 'RegExp', $RegExp);
  }
  
  require('./_set-species')('RegExp');
  },{"./_descriptors":29,"./_fails":35,"./_flags":37,"./_global":39,"./_inherit-if-required":44,"./_is-regexp":51,"./_object-dp":68,"./_object-gopn":73,"./_redefine":88,"./_set-species":92,"./_wks":118}],215:[function(require,module,exports){
  // 21.2.5.3 get RegExp.prototype.flags()
  if(require('./_descriptors') && /./g.flags != 'g')require('./_object-dp').f(RegExp.prototype, 'flags', {
    configurable: true,
    get: require('./_flags')
  });
  },{"./_descriptors":29,"./_flags":37,"./_object-dp":68}],216:[function(require,module,exports){
  // @@match logic
  require('./_fix-re-wks')('match', 1, function(defined, MATCH, $match){
    // 21.1.3.11 String.prototype.match(regexp)
    return [function match(regexp){
      'use strict';
      var O  = defined(this)
        , fn = regexp == undefined ? undefined : regexp[MATCH];
      return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
    }, $match];
  });
  },{"./_fix-re-wks":36}],217:[function(require,module,exports){
  // @@replace logic
  require('./_fix-re-wks')('replace', 2, function(defined, REPLACE, $replace){
    // 21.1.3.14 String.prototype.replace(searchValue, replaceValue)
    return [function replace(searchValue, replaceValue){
      'use strict';
      var O  = defined(this)
        , fn = searchValue == undefined ? undefined : searchValue[REPLACE];
      return fn !== undefined
        ? fn.call(searchValue, O, replaceValue)
        : $replace.call(String(O), searchValue, replaceValue);
    }, $replace];
  });
  },{"./_fix-re-wks":36}],218:[function(require,module,exports){
  // @@search logic
  require('./_fix-re-wks')('search', 1, function(defined, SEARCH, $search){
    // 21.1.3.15 String.prototype.search(regexp)
    return [function search(regexp){
      'use strict';
      var O  = defined(this)
        , fn = regexp == undefined ? undefined : regexp[SEARCH];
      return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
    }, $search];
  });
  },{"./_fix-re-wks":36}],219:[function(require,module,exports){
  // @@split logic
  require('./_fix-re-wks')('split', 2, function(defined, SPLIT, $split){
    'use strict';
    var isRegExp   = require('./_is-regexp')
      , _split     = $split
      , $push      = [].push
      , $SPLIT     = 'split'
      , LENGTH     = 'length'
      , LAST_INDEX = 'lastIndex';
    if(
      'abbc'[$SPLIT](/(b)*/)[1] == 'c' ||
      'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 ||
      'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 ||
      '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 ||
      '.'[$SPLIT](/()()/)[LENGTH] > 1 ||
      ''[$SPLIT](/.?/)[LENGTH]
    ){
      var NPCG = /()??/.exec('')[1] === undefined; // nonparticipating capturing group
      // based on es5-shim implementation, need to rework it
      $split = function(separator, limit){
        var string = String(this);
        if(separator === undefined && limit === 0)return [];
        // If `separator` is not a regex, use native split
        if(!isRegExp(separator))return _split.call(string, separator, limit);
        var output = [];
        var flags = (separator.ignoreCase ? 'i' : '') +
                    (separator.multiline ? 'm' : '') +
                    (separator.unicode ? 'u' : '') +
                    (separator.sticky ? 'y' : '');
        var lastLastIndex = 0;
        var splitLimit = limit === undefined ? 4294967295 : limit >>> 0;
        // Make `global` and avoid `lastIndex` issues by working with a copy
        var separatorCopy = new RegExp(separator.source, flags + 'g');
        var separator2, match, lastIndex, lastLength, i;
        // Doesn't need flags gy, but they don't hurt
        if(!NPCG)separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\s)', flags);
        while(match = separatorCopy.exec(string)){
          // `separatorCopy.lastIndex` is not reliable cross-browser
          lastIndex = match.index + match[0][LENGTH];
          if(lastIndex > lastLastIndex){
            output.push(string.slice(lastLastIndex, match.index));
            // Fix browsers whose `exec` methods don't consistently return `undefined` for NPCG
            if(!NPCG && match[LENGTH] > 1)match[0].replace(separator2, function(){
              for(i = 1; i < arguments[LENGTH] - 2; i++)if(arguments[i] === undefined)match[i] = undefined;
            });
            if(match[LENGTH] > 1 && match.index < string[LENGTH])$push.apply(output, match.slice(1));
            lastLength = match[0][LENGTH];
            lastLastIndex = lastIndex;
            if(output[LENGTH] >= splitLimit)break;
          }
          if(separatorCopy[LAST_INDEX] === match.index)separatorCopy[LAST_INDEX]++; // Avoid an infinite loop
        }
        if(lastLastIndex === string[LENGTH]){
          if(lastLength || !separatorCopy.test(''))output.push('');
        } else output.push(string.slice(lastLastIndex));
        return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;
      };
    // Chakra, V8
    } else if('0'[$SPLIT](undefined, 0)[LENGTH]){
      $split = function(separator, limit){
        return separator === undefined && limit === 0 ? [] : _split.call(this, separator, limit);
      };
    }
    // 21.1.3.17 String.prototype.split(separator, limit)
    return [function split(separator, limit){
      var O  = defined(this)
        , fn = separator == undefined ? undefined : separator[SPLIT];
      return fn !== undefined ? fn.call(separator, O, limit) : $split.call(String(O), separator, limit);
    }, $split];
  });
  },{"./_fix-re-wks":36,"./_is-regexp":51}],220:[function(require,module,exports){
  'use strict';
  require('./es6.regexp.flags');
  var anObject    = require('./_an-object')
    , $flags      = require('./_flags')
    , DESCRIPTORS = require('./_descriptors')
    , TO_STRING   = 'toString'
    , $toString   = /./[TO_STRING];
  
  var define = function(fn){
    require('./_redefine')(RegExp.prototype, TO_STRING, fn, true);
  };
  
  // 21.2.5.14 RegExp.prototype.toString()
  if(require('./_fails')(function(){ return $toString.call({source: 'a', flags: 'b'}) != '/a/b'; })){
    define(function toString(){
      var R = anObject(this);
      return '/'.concat(R.source, '/',
        'flags' in R ? R.flags : !DESCRIPTORS && R instanceof RegExp ? $flags.call(R) : undefined);
    });
  // FF44- RegExp#toString has a wrong name
  } else if($toString.name != TO_STRING){
    define(function toString(){
      return $toString.call(this);
    });
  }
  },{"./_an-object":8,"./_descriptors":29,"./_fails":35,"./_flags":37,"./_redefine":88,"./es6.regexp.flags":215}],221:[function(require,module,exports){
  'use strict';
  var strong = require('./_collection-strong');
  
  // 23.2 Set Objects
  module.exports = require('./_collection')('Set', function(get){
    return function Set(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  }, {
    // 23.2.3.1 Set.prototype.add(value)
    add: function add(value){
      return strong.def(this, value = value === 0 ? 0 : value, value);
    }
  }, strong);
  },{"./_collection":23,"./_collection-strong":20}],222:[function(require,module,exports){
  'use strict';
  // B.2.3.2 String.prototype.anchor(name)
  require('./_string-html')('anchor', function(createHTML){
    return function anchor(name){
      return createHTML(this, 'a', 'name', name);
    }
  });
  },{"./_string-html":100}],223:[function(require,module,exports){
  'use strict';
  // B.2.3.3 String.prototype.big()
  require('./_string-html')('big', function(createHTML){
    return function big(){
      return createHTML(this, 'big', '', '');
    }
  });
  },{"./_string-html":100}],224:[function(require,module,exports){
  'use strict';
  // B.2.3.4 String.prototype.blink()
  require('./_string-html')('blink', function(createHTML){
    return function blink(){
      return createHTML(this, 'blink', '', '');
    }
  });
  },{"./_string-html":100}],225:[function(require,module,exports){
  'use strict';
  // B.2.3.5 String.prototype.bold()
  require('./_string-html')('bold', function(createHTML){
    return function bold(){
      return createHTML(this, 'b', '', '');
    }
  });
  },{"./_string-html":100}],226:[function(require,module,exports){
  'use strict';
  var $export = require('./_export')
    , $at     = require('./_string-at')(false);
  $export($export.P, 'String', {
    // 21.1.3.3 String.prototype.codePointAt(pos)
    codePointAt: function codePointAt(pos){
      return $at(this, pos);
    }
  });
  },{"./_export":33,"./_string-at":98}],227:[function(require,module,exports){
  // 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])
  'use strict';
  var $export   = require('./_export')
    , toLength  = require('./_to-length')
    , context   = require('./_string-context')
    , ENDS_WITH = 'endsWith'
    , $endsWith = ''[ENDS_WITH];
  
  $export($export.P + $export.F * require('./_fails-is-regexp')(ENDS_WITH), 'String', {
    endsWith: function endsWith(searchString /*, endPosition = @length */){
      var that = context(this, searchString, ENDS_WITH)
        , endPosition = arguments.length > 1 ? arguments[1] : undefined
        , len    = toLength(that.length)
        , end    = endPosition === undefined ? len : Math.min(toLength(endPosition), len)
        , search = String(searchString);
      return $endsWith
        ? $endsWith.call(that, search, end)
        : that.slice(end - search.length, end) === search;
    }
  });
  },{"./_export":33,"./_fails-is-regexp":34,"./_string-context":99,"./_to-length":109}],228:[function(require,module,exports){
  'use strict';
  // B.2.3.6 String.prototype.fixed()
  require('./_string-html')('fixed', function(createHTML){
    return function fixed(){
      return createHTML(this, 'tt', '', '');
    }
  });
  },{"./_string-html":100}],229:[function(require,module,exports){
  'use strict';
  // B.2.3.7 String.prototype.fontcolor(color)
  require('./_string-html')('fontcolor', function(createHTML){
    return function fontcolor(color){
      return createHTML(this, 'font', 'color', color);
    }
  });
  },{"./_string-html":100}],230:[function(require,module,exports){
  'use strict';
  // B.2.3.8 String.prototype.fontsize(size)
  require('./_string-html')('fontsize', function(createHTML){
    return function fontsize(size){
      return createHTML(this, 'font', 'size', size);
    }
  });
  },{"./_string-html":100}],231:[function(require,module,exports){
  var $export        = require('./_export')
    , toIndex        = require('./_to-index')
    , fromCharCode   = String.fromCharCode
    , $fromCodePoint = String.fromCodePoint;
  
  // length should be 1, old FF problem
  $export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
    // 21.1.2.2 String.fromCodePoint(...codePoints)
    fromCodePoint: function fromCodePoint(x){ // eslint-disable-line no-unused-vars
      var res  = []
        , aLen = arguments.length
        , i    = 0
        , code;
      while(aLen > i){
        code = +arguments[i++];
        if(toIndex(code, 0x10ffff) !== code)throw RangeError(code + ' is not a valid code point');
        res.push(code < 0x10000
          ? fromCharCode(code)
          : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
        );
      } return res.join('');
    }
  });
  },{"./_export":33,"./_to-index":106}],232:[function(require,module,exports){
  // 21.1.3.7 String.prototype.includes(searchString, position = 0)
  'use strict';
  var $export  = require('./_export')
    , context  = require('./_string-context')
    , INCLUDES = 'includes';
  
  $export($export.P + $export.F * require('./_fails-is-regexp')(INCLUDES), 'String', {
    includes: function includes(searchString /*, position = 0 */){
      return !!~context(this, searchString, INCLUDES)
        .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
    }
  });
  },{"./_export":33,"./_fails-is-regexp":34,"./_string-context":99}],233:[function(require,module,exports){
  'use strict';
  // B.2.3.9 String.prototype.italics()
  require('./_string-html')('italics', function(createHTML){
    return function italics(){
      return createHTML(this, 'i', '', '');
    }
  });
  },{"./_string-html":100}],234:[function(require,module,exports){
  'use strict';
  var $at  = require('./_string-at')(true);
  
  // 21.1.3.27 String.prototype[@@iterator]()
  require('./_iter-define')(String, 'String', function(iterated){
    this._t = String(iterated); // target
    this._i = 0;                // next index
  // 21.1.5.2.1 %StringIteratorPrototype%.next()
  }, function(){
    var O     = this._t
      , index = this._i
      , point;
    if(index >= O.length)return {value: undefined, done: true};
    point = $at(O, index);
    this._i += point.length;
    return {value: point, done: false};
  });
  },{"./_iter-define":54,"./_string-at":98}],235:[function(require,module,exports){
  'use strict';
  // B.2.3.10 String.prototype.link(url)
  require('./_string-html')('link', function(createHTML){
    return function link(url){
      return createHTML(this, 'a', 'href', url);
    }
  });
  },{"./_string-html":100}],236:[function(require,module,exports){
  var $export   = require('./_export')
    , toIObject = require('./_to-iobject')
    , toLength  = require('./_to-length');
  
  $export($export.S, 'String', {
    // 21.1.2.4 String.raw(callSite, ...substitutions)
    raw: function raw(callSite){
      var tpl  = toIObject(callSite.raw)
        , len  = toLength(tpl.length)
        , aLen = arguments.length
        , res  = []
        , i    = 0;
      while(len > i){
        res.push(String(tpl[i++]));
        if(i < aLen)res.push(String(arguments[i]));
      } return res.join('');
    }
  });
  },{"./_export":33,"./_to-iobject":108,"./_to-length":109}],237:[function(require,module,exports){
  var $export = require('./_export');
  
  $export($export.P, 'String', {
    // 21.1.3.13 String.prototype.repeat(count)
    repeat: require('./_string-repeat')
  });
  },{"./_export":33,"./_string-repeat":102}],238:[function(require,module,exports){
  'use strict';
  // B.2.3.11 String.prototype.small()
  require('./_string-html')('small', function(createHTML){
    return function small(){
      return createHTML(this, 'small', '', '');
    }
  });
  },{"./_string-html":100}],239:[function(require,module,exports){
  // 21.1.3.18 String.prototype.startsWith(searchString [, position ])
  'use strict';
  var $export     = require('./_export')
    , toLength    = require('./_to-length')
    , context     = require('./_string-context')
    , STARTS_WITH = 'startsWith'
    , $startsWith = ''[STARTS_WITH];
  
  $export($export.P + $export.F * require('./_fails-is-regexp')(STARTS_WITH), 'String', {
    startsWith: function startsWith(searchString /*, position = 0 */){
      var that   = context(this, searchString, STARTS_WITH)
        , index  = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length))
        , search = String(searchString);
      return $startsWith
        ? $startsWith.call(that, search, index)
        : that.slice(index, index + search.length) === search;
    }
  });
  },{"./_export":33,"./_fails-is-regexp":34,"./_string-context":99,"./_to-length":109}],240:[function(require,module,exports){
  'use strict';
  // B.2.3.12 String.prototype.strike()
  require('./_string-html')('strike', function(createHTML){
    return function strike(){
      return createHTML(this, 'strike', '', '');
    }
  });
  },{"./_string-html":100}],241:[function(require,module,exports){
  'use strict';
  // B.2.3.13 String.prototype.sub()
  require('./_string-html')('sub', function(createHTML){
    return function sub(){
      return createHTML(this, 'sub', '', '');
    }
  });
  },{"./_string-html":100}],242:[function(require,module,exports){
  'use strict';
  // B.2.3.14 String.prototype.sup()
  require('./_string-html')('sup', function(createHTML){
    return function sup(){
      return createHTML(this, 'sup', '', '');
    }
  });
  },{"./_string-html":100}],243:[function(require,module,exports){
  'use strict';
  // 21.1.3.25 String.prototype.trim()
  require('./_string-trim')('trim', function($trim){
    return function trim(){
      return $trim(this, 3);
    };
  });
  },{"./_string-trim":103}],244:[function(require,module,exports){
  'use strict';
  // ECMAScript 6 symbols shim
  var global         = require('./_global')
    , has            = require('./_has')
    , DESCRIPTORS    = require('./_descriptors')
    , $export        = require('./_export')
    , redefine       = require('./_redefine')
    , META           = require('./_meta').KEY
    , $fails         = require('./_fails')
    , shared         = require('./_shared')
    , setToStringTag = require('./_set-to-string-tag')
    , uid            = require('./_uid')
    , wks            = require('./_wks')
    , wksExt         = require('./_wks-ext')
    , wksDefine      = require('./_wks-define')
    , keyOf          = require('./_keyof')
    , enumKeys       = require('./_enum-keys')
    , isArray        = require('./_is-array')
    , anObject       = require('./_an-object')
    , toIObject      = require('./_to-iobject')
    , toPrimitive    = require('./_to-primitive')
    , createDesc     = require('./_property-desc')
    , _create        = require('./_object-create')
    , gOPNExt        = require('./_object-gopn-ext')
    , $GOPD          = require('./_object-gopd')
    , $DP            = require('./_object-dp')
    , $keys          = require('./_object-keys')
    , gOPD           = $GOPD.f
    , dP             = $DP.f
    , gOPN           = gOPNExt.f
    , $Symbol        = global.Symbol
    , $JSON          = global.JSON
    , _stringify     = $JSON && $JSON.stringify
    , PROTOTYPE      = 'prototype'
    , HIDDEN         = wks('_hidden')
    , TO_PRIMITIVE   = wks('toPrimitive')
    , isEnum         = {}.propertyIsEnumerable
    , SymbolRegistry = shared('symbol-registry')
    , AllSymbols     = shared('symbols')
    , OPSymbols      = shared('op-symbols')
    , ObjectProto    = Object[PROTOTYPE]
    , USE_NATIVE     = typeof $Symbol == 'function'
    , QObject        = global.QObject;
  // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
  var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
  
  // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
  var setSymbolDesc = DESCRIPTORS && $fails(function(){
    return _create(dP({}, 'a', {
      get: function(){ return dP(this, 'a', {value: 7}).a; }
    })).a != 7;
  }) ? function(it, key, D){
    var protoDesc = gOPD(ObjectProto, key);
    if(protoDesc)delete ObjectProto[key];
    dP(it, key, D);
    if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);
  } : dP;
  
  var wrap = function(tag){
    var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
    sym._k = tag;
    return sym;
  };
  
  var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){
    return typeof it == 'symbol';
  } : function(it){
    return it instanceof $Symbol;
  };
  
  var $defineProperty = function defineProperty(it, key, D){
    if(it === ObjectProto)$defineProperty(OPSymbols, key, D);
    anObject(it);
    key = toPrimitive(key, true);
    anObject(D);
    if(has(AllSymbols, key)){
      if(!D.enumerable){
        if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));
        it[HIDDEN][key] = true;
      } else {
        if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
        D = _create(D, {enumerable: createDesc(0, false)});
      } return setSymbolDesc(it, key, D);
    } return dP(it, key, D);
  };
  var $defineProperties = function defineProperties(it, P){
    anObject(it);
    var keys = enumKeys(P = toIObject(P))
      , i    = 0
      , l = keys.length
      , key;
    while(l > i)$defineProperty(it, key = keys[i++], P[key]);
    return it;
  };
  var $create = function create(it, P){
    return P === undefined ? _create(it) : $defineProperties(_create(it), P);
  };
  var $propertyIsEnumerable = function propertyIsEnumerable(key){
    var E = isEnum.call(this, key = toPrimitive(key, true));
    if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;
    return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
  };
  var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
    it  = toIObject(it);
    key = toPrimitive(key, true);
    if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;
    var D = gOPD(it, key);
    if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
    return D;
  };
  var $getOwnPropertyNames = function getOwnPropertyNames(it){
    var names  = gOPN(toIObject(it))
      , result = []
      , i      = 0
      , key;
    while(names.length > i){
      if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);
    } return result;
  };
  var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
    var IS_OP  = it === ObjectProto
      , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))
      , result = []
      , i      = 0
      , key;
    while(names.length > i){
      if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);
    } return result;
  };
  
  // 19.4.1.1 Symbol([description])
  if(!USE_NATIVE){
    $Symbol = function Symbol(){
      if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');
      var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
      var $set = function(value){
        if(this === ObjectProto)$set.call(OPSymbols, value);
        if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
        setSymbolDesc(this, tag, createDesc(1, value));
      };
      if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});
      return wrap(tag);
    };
    redefine($Symbol[PROTOTYPE], 'toString', function toString(){
      return this._k;
    });
  
    $GOPD.f = $getOwnPropertyDescriptor;
    $DP.f   = $defineProperty;
    require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;
    require('./_object-pie').f  = $propertyIsEnumerable;
    require('./_object-gops').f = $getOwnPropertySymbols;
  
    if(DESCRIPTORS && !require('./_library')){
      redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
    }
  
    wksExt.f = function(name){
      return wrap(wks(name));
    }
  }
  
  $export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});
  
  for(var symbols = (
    // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
    'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
  ).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);
  
  for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);
  
  $export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
    // 19.4.2.1 Symbol.for(key)
    'for': function(key){
      return has(SymbolRegistry, key += '')
        ? SymbolRegistry[key]
        : SymbolRegistry[key] = $Symbol(key);
    },
    // 19.4.2.5 Symbol.keyFor(sym)
    keyFor: function keyFor(key){
      if(isSymbol(key))return keyOf(SymbolRegistry, key);
      throw TypeError(key + ' is not a symbol!');
    },
    useSetter: function(){ setter = true; },
    useSimple: function(){ setter = false; }
  });
  
  $export($export.S + $export.F * !USE_NATIVE, 'Object', {
    // 19.1.2.2 Object.create(O [, Properties])
    create: $create,
    // 19.1.2.4 Object.defineProperty(O, P, Attributes)
    defineProperty: $defineProperty,
    // 19.1.2.3 Object.defineProperties(O, Properties)
    defineProperties: $defineProperties,
    // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
    getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
    // 19.1.2.7 Object.getOwnPropertyNames(O)
    getOwnPropertyNames: $getOwnPropertyNames,
    // 19.1.2.8 Object.getOwnPropertySymbols(O)
    getOwnPropertySymbols: $getOwnPropertySymbols
  });
  
  // 24.3.2 JSON.stringify(value [, replacer [, space]])
  $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){
    var S = $Symbol();
    // MS Edge converts symbol values to JSON as {}
    // WebKit converts symbol values to JSON as null
    // V8 throws on boxed symbols
    return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
  })), 'JSON', {
    stringify: function stringify(it){
      if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
      var args = [it]
        , i    = 1
        , replacer, $replacer;
      while(arguments.length > i)args.push(arguments[i++]);
      replacer = args[1];
      if(typeof replacer == 'function')$replacer = replacer;
      if($replacer || !isArray(replacer))replacer = function(key, value){
        if($replacer)value = $replacer.call(this, key, value);
        if(!isSymbol(value))return value;
      };
      args[1] = replacer;
      return _stringify.apply($JSON, args);
    }
  });
  
  // 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
  $Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
  // 19.4.3.5 Symbol.prototype[@@toStringTag]
  setToStringTag($Symbol, 'Symbol');
  // 20.2.1.9 Math[@@toStringTag]
  setToStringTag(Math, 'Math', true);
  // 24.3.3 JSON[@@toStringTag]
  setToStringTag(global.JSON, 'JSON', true);
  },{"./_an-object":8,"./_descriptors":29,"./_enum-keys":32,"./_export":33,"./_fails":35,"./_global":39,"./_has":40,"./_hide":41,"./_is-array":48,"./_keyof":58,"./_library":59,"./_meta":63,"./_object-create":67,"./_object-dp":68,"./_object-gopd":71,"./_object-gopn":73,"./_object-gopn-ext":72,"./_object-gops":74,"./_object-keys":77,"./_object-pie":78,"./_property-desc":86,"./_redefine":88,"./_set-to-string-tag":93,"./_shared":95,"./_to-iobject":108,"./_to-primitive":111,"./_uid":115,"./_wks":118,"./_wks-define":116,"./_wks-ext":117}],245:[function(require,module,exports){
  'use strict';
  var $export      = require('./_export')
    , $typed       = require('./_typed')
    , buffer       = require('./_typed-buffer')
    , anObject     = require('./_an-object')
    , toIndex      = require('./_to-index')
    , toLength     = require('./_to-length')
    , isObject     = require('./_is-object')
    , ArrayBuffer  = require('./_global').ArrayBuffer
    , speciesConstructor = require('./_species-constructor')
    , $ArrayBuffer = buffer.ArrayBuffer
    , $DataView    = buffer.DataView
    , $isView      = $typed.ABV && ArrayBuffer.isView
    , $slice       = $ArrayBuffer.prototype.slice
    , VIEW         = $typed.VIEW
    , ARRAY_BUFFER = 'ArrayBuffer';
  
  $export($export.G + $export.W + $export.F * (ArrayBuffer !== $ArrayBuffer), {ArrayBuffer: $ArrayBuffer});
  
  $export($export.S + $export.F * !$typed.CONSTR, ARRAY_BUFFER, {
    // 24.1.3.1 ArrayBuffer.isView(arg)
    isView: function isView(it){
      return $isView && $isView(it) || isObject(it) && VIEW in it;
    }
  });
  
  $export($export.P + $export.U + $export.F * require('./_fails')(function(){
    return !new $ArrayBuffer(2).slice(1, undefined).byteLength;
  }), ARRAY_BUFFER, {
    // 24.1.4.3 ArrayBuffer.prototype.slice(start, end)
    slice: function slice(start, end){
      if($slice !== undefined && end === undefined)return $slice.call(anObject(this), start); // FF fix
      var len    = anObject(this).byteLength
        , first  = toIndex(start, len)
        , final  = toIndex(end === undefined ? len : end, len)
        , result = new (speciesConstructor(this, $ArrayBuffer))(toLength(final - first))
        , viewS  = new $DataView(this)
        , viewT  = new $DataView(result)
        , index  = 0;
      while(first < final){
        viewT.setUint8(index++, viewS.getUint8(first++));
      } return result;
    }
  });
  
  require('./_set-species')(ARRAY_BUFFER);
  },{"./_an-object":8,"./_export":33,"./_fails":35,"./_global":39,"./_is-object":50,"./_set-species":92,"./_species-constructor":96,"./_to-index":106,"./_to-length":109,"./_typed":114,"./_typed-buffer":113}],246:[function(require,module,exports){
  var $export = require('./_export');
  $export($export.G + $export.W + $export.F * !require('./_typed').ABV, {
    DataView: require('./_typed-buffer').DataView
  });
  },{"./_export":33,"./_typed":114,"./_typed-buffer":113}],247:[function(require,module,exports){
  require('./_typed-array')('Float32', 4, function(init){
    return function Float32Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],248:[function(require,module,exports){
  require('./_typed-array')('Float64', 8, function(init){
    return function Float64Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],249:[function(require,module,exports){
  require('./_typed-array')('Int16', 2, function(init){
    return function Int16Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],250:[function(require,module,exports){
  require('./_typed-array')('Int32', 4, function(init){
    return function Int32Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],251:[function(require,module,exports){
  require('./_typed-array')('Int8', 1, function(init){
    return function Int8Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],252:[function(require,module,exports){
  require('./_typed-array')('Uint16', 2, function(init){
    return function Uint16Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],253:[function(require,module,exports){
  require('./_typed-array')('Uint32', 4, function(init){
    return function Uint32Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],254:[function(require,module,exports){
  require('./_typed-array')('Uint8', 1, function(init){
    return function Uint8Array(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  });
  },{"./_typed-array":112}],255:[function(require,module,exports){
  require('./_typed-array')('Uint8', 1, function(init){
    return function Uint8ClampedArray(data, byteOffset, length){
      return init(this, data, byteOffset, length);
    };
  }, true);
  },{"./_typed-array":112}],256:[function(require,module,exports){
  'use strict';
  var each         = require('./_array-methods')(0)
    , redefine     = require('./_redefine')
    , meta         = require('./_meta')
    , assign       = require('./_object-assign')
    , weak         = require('./_collection-weak')
    , isObject     = require('./_is-object')
    , getWeak      = meta.getWeak
    , isExtensible = Object.isExtensible
    , uncaughtFrozenStore = weak.ufstore
    , tmp          = {}
    , InternalMap;
  
  var wrapper = function(get){
    return function WeakMap(){
      return get(this, arguments.length > 0 ? arguments[0] : undefined);
    };
  };
  
  var methods = {
    // 23.3.3.3 WeakMap.prototype.get(key)
    get: function get(key){
      if(isObject(key)){
        var data = getWeak(key);
        if(data === true)return uncaughtFrozenStore(this).get(key);
        return data ? data[this._i] : undefined;
      }
    },
    // 23.3.3.5 WeakMap.prototype.set(key, value)
    set: function set(key, value){
      return weak.def(this, key, value);
    }
  };
  
  // 23.3 WeakMap Objects
  var $WeakMap = module.exports = require('./_collection')('WeakMap', wrapper, methods, weak, true, true);
  
  // IE11 WeakMap frozen keys fix
  if(new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
    InternalMap = weak.getConstructor(wrapper);
    assign(InternalMap.prototype, methods);
    meta.NEED = true;
    each(['delete', 'has', 'get', 'set'], function(key){
      var proto  = $WeakMap.prototype
        , method = proto[key];
      redefine(proto, key, function(a, b){
        // store frozen objects on internal weakmap shim
        if(isObject(a) && !isExtensible(a)){
          if(!this._f)this._f = new InternalMap;
          var result = this._f[key](a, b);
          return key == 'set' ? this : result;
        // store all the rest on native weakmap
        } return method.call(this, a, b);
      });
    });
  }
  },{"./_array-methods":13,"./_collection":23,"./_collection-weak":22,"./_is-object":50,"./_meta":63,"./_object-assign":66,"./_redefine":88}],257:[function(require,module,exports){
  'use strict';
  var weak = require('./_collection-weak');
  
  // 23.4 WeakSet Objects
  require('./_collection')('WeakSet', function(get){
    return function WeakSet(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  }, {
    // 23.4.3.1 WeakSet.prototype.add(value)
    add: function add(value){
      return weak.def(this, value, true);
    }
  }, weak, false, true);
  },{"./_collection":23,"./_collection-weak":22}],258:[function(require,module,exports){
  'use strict';
  // https://github.com/tc39/Array.prototype.includes
  var $export   = require('./_export')
    , $includes = require('./_array-includes')(true);
  
  $export($export.P, 'Array', {
    includes: function includes(el /*, fromIndex = 0 */){
      return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
    }
  });
  
  require('./_add-to-unscopables')('includes');
  },{"./_add-to-unscopables":6,"./_array-includes":12,"./_export":33}],259:[function(require,module,exports){
  // https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask
  var $export   = require('./_export')
    , microtask = require('./_microtask')()
    , process   = require('./_global').process
    , isNode    = require('./_cof')(process) == 'process';
  
  $export($export.G, {
    asap: function asap(fn){
      var domain = isNode && process.domain;
      microtask(domain ? domain.bind(fn) : fn);
    }
  });
  },{"./_cof":19,"./_export":33,"./_global":39,"./_microtask":65}],260:[function(require,module,exports){
  // https://github.com/ljharb/proposal-is-error
  var $export = require('./_export')
    , cof     = require('./_cof');
  
  $export($export.S, 'Error', {
    isError: function isError(it){
      return cof(it) === 'Error';
    }
  });
  },{"./_cof":19,"./_export":33}],261:[function(require,module,exports){
  // https://github.com/DavidBruant/Map-Set.prototype.toJSON
  var $export  = require('./_export');
  
  $export($export.P + $export.R, 'Map', {toJSON: require('./_collection-to-json')('Map')});
  },{"./_collection-to-json":21,"./_export":33}],262:[function(require,module,exports){
  // https://gist.github.com/BrendanEich/4294d5c212a6d2254703
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    iaddh: function iaddh(x0, x1, y0, y1){
      var $x0 = x0 >>> 0
        , $x1 = x1 >>> 0
        , $y0 = y0 >>> 0;
      return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0;
    }
  });
  },{"./_export":33}],263:[function(require,module,exports){
  // https://gist.github.com/BrendanEich/4294d5c212a6d2254703
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    imulh: function imulh(u, v){
      var UINT16 = 0xffff
        , $u = +u
        , $v = +v
        , u0 = $u & UINT16
        , v0 = $v & UINT16
        , u1 = $u >> 16
        , v1 = $v >> 16
        , t  = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
      return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16);
    }
  });
  },{"./_export":33}],264:[function(require,module,exports){
  // https://gist.github.com/BrendanEich/4294d5c212a6d2254703
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    isubh: function isubh(x0, x1, y0, y1){
      var $x0 = x0 >>> 0
        , $x1 = x1 >>> 0
        , $y0 = y0 >>> 0;
      return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0;
    }
  });
  },{"./_export":33}],265:[function(require,module,exports){
  // https://gist.github.com/BrendanEich/4294d5c212a6d2254703
  var $export = require('./_export');
  
  $export($export.S, 'Math', {
    umulh: function umulh(u, v){
      var UINT16 = 0xffff
        , $u = +u
        , $v = +v
        , u0 = $u & UINT16
        , v0 = $v & UINT16
        , u1 = $u >>> 16
        , v1 = $v >>> 16
        , t  = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
      return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16);
    }
  });
  },{"./_export":33}],266:[function(require,module,exports){
  'use strict';
  var $export         = require('./_export')
    , toObject        = require('./_to-object')
    , aFunction       = require('./_a-function')
    , $defineProperty = require('./_object-dp');
  
  // B.2.2.2 Object.prototype.__defineGetter__(P, getter)
  require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {
    __defineGetter__: function __defineGetter__(P, getter){
      $defineProperty.f(toObject(this), P, {get: aFunction(getter), enumerable: true, configurable: true});
    }
  });
  },{"./_a-function":4,"./_descriptors":29,"./_export":33,"./_object-dp":68,"./_object-forced-pam":70,"./_to-object":110}],267:[function(require,module,exports){
  'use strict';
  var $export         = require('./_export')
    , toObject        = require('./_to-object')
    , aFunction       = require('./_a-function')
    , $defineProperty = require('./_object-dp');
  
  // B.2.2.3 Object.prototype.__defineSetter__(P, setter)
  require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {
    __defineSetter__: function __defineSetter__(P, setter){
      $defineProperty.f(toObject(this), P, {set: aFunction(setter), enumerable: true, configurable: true});
    }
  });
  },{"./_a-function":4,"./_descriptors":29,"./_export":33,"./_object-dp":68,"./_object-forced-pam":70,"./_to-object":110}],268:[function(require,module,exports){
  // https://github.com/tc39/proposal-object-values-entries
  var $export  = require('./_export')
    , $entries = require('./_object-to-array')(true);
  
  $export($export.S, 'Object', {
    entries: function entries(it){
      return $entries(it);
    }
  });
  },{"./_export":33,"./_object-to-array":80}],269:[function(require,module,exports){
  // https://github.com/tc39/proposal-object-getownpropertydescriptors
  var $export        = require('./_export')
    , ownKeys        = require('./_own-keys')
    , toIObject      = require('./_to-iobject')
    , gOPD           = require('./_object-gopd')
    , createProperty = require('./_create-property');
  
  $export($export.S, 'Object', {
    getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object){
      var O       = toIObject(object)
        , getDesc = gOPD.f
        , keys    = ownKeys(O)
        , result  = {}
        , i       = 0
        , key;
      while(keys.length > i)createProperty(result, key = keys[i++], getDesc(O, key));
      return result;
    }
  });
  },{"./_create-property":25,"./_export":33,"./_object-gopd":71,"./_own-keys":81,"./_to-iobject":108}],270:[function(require,module,exports){
  'use strict';
  var $export                  = require('./_export')
    , toObject                 = require('./_to-object')
    , toPrimitive              = require('./_to-primitive')
    , getPrototypeOf           = require('./_object-gpo')
    , getOwnPropertyDescriptor = require('./_object-gopd').f;
  
  // B.2.2.4 Object.prototype.__lookupGetter__(P)
  require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {
    __lookupGetter__: function __lookupGetter__(P){
      var O = toObject(this)
        , K = toPrimitive(P, true)
        , D;
      do {
        if(D = getOwnPropertyDescriptor(O, K))return D.get;
      } while(O = getPrototypeOf(O));
    }
  });
  },{"./_descriptors":29,"./_export":33,"./_object-forced-pam":70,"./_object-gopd":71,"./_object-gpo":75,"./_to-object":110,"./_to-primitive":111}],271:[function(require,module,exports){
  'use strict';
  var $export                  = require('./_export')
    , toObject                 = require('./_to-object')
    , toPrimitive              = require('./_to-primitive')
    , getPrototypeOf           = require('./_object-gpo')
    , getOwnPropertyDescriptor = require('./_object-gopd').f;
  
  // B.2.2.5 Object.prototype.__lookupSetter__(P)
  require('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {
    __lookupSetter__: function __lookupSetter__(P){
      var O = toObject(this)
        , K = toPrimitive(P, true)
        , D;
      do {
        if(D = getOwnPropertyDescriptor(O, K))return D.set;
      } while(O = getPrototypeOf(O));
    }
  });
  },{"./_descriptors":29,"./_export":33,"./_object-forced-pam":70,"./_object-gopd":71,"./_object-gpo":75,"./_to-object":110,"./_to-primitive":111}],272:[function(require,module,exports){
  // https://github.com/tc39/proposal-object-values-entries
  var $export = require('./_export')
    , $values = require('./_object-to-array')(false);
  
  $export($export.S, 'Object', {
    values: function values(it){
      return $values(it);
    }
  });
  },{"./_export":33,"./_object-to-array":80}],273:[function(require,module,exports){
  'use strict';
  // https://github.com/zenparsing/es-observable
  var $export     = require('./_export')
    , global      = require('./_global')
    , core        = require('./_core')
    , microtask   = require('./_microtask')()
    , OBSERVABLE  = require('./_wks')('observable')
    , aFunction   = require('./_a-function')
    , anObject    = require('./_an-object')
    , anInstance  = require('./_an-instance')
    , redefineAll = require('./_redefine-all')
    , hide        = require('./_hide')
    , forOf       = require('./_for-of')
    , RETURN      = forOf.RETURN;
  
  var getMethod = function(fn){
    return fn == null ? undefined : aFunction(fn);
  };
  
  var cleanupSubscription = function(subscription){
    var cleanup = subscription._c;
    if(cleanup){
      subscription._c = undefined;
      cleanup();
    }
  };
  
  var subscriptionClosed = function(subscription){
    return subscription._o === undefined;
  };
  
  var closeSubscription = function(subscription){
    if(!subscriptionClosed(subscription)){
      subscription._o = undefined;
      cleanupSubscription(subscription);
    }
  };
  
  var Subscription = function(observer, subscriber){
    anObject(observer);
    this._c = undefined;
    this._o = observer;
    observer = new SubscriptionObserver(this);
    try {
      var cleanup      = subscriber(observer)
        , subscription = cleanup;
      if(cleanup != null){
        if(typeof cleanup.unsubscribe === 'function')cleanup = function(){ subscription.unsubscribe(); };
        else aFunction(cleanup);
        this._c = cleanup;
      }
    } catch(e){
      observer.error(e);
      return;
    } if(subscriptionClosed(this))cleanupSubscription(this);
  };
  
  Subscription.prototype = redefineAll({}, {
    unsubscribe: function unsubscribe(){ closeSubscription(this); }
  });
  
  var SubscriptionObserver = function(subscription){
    this._s = subscription;
  };
  
  SubscriptionObserver.prototype = redefineAll({}, {
    next: function next(value){
      var subscription = this._s;
      if(!subscriptionClosed(subscription)){
        var observer = subscription._o;
        try {
          var m = getMethod(observer.next);
          if(m)return m.call(observer, value);
        } catch(e){
          try {
            closeSubscription(subscription);
          } finally {
            throw e;
          }
        }
      }
    },
    error: function error(value){
      var subscription = this._s;
      if(subscriptionClosed(subscription))throw value;
      var observer = subscription._o;
      subscription._o = undefined;
      try {
        var m = getMethod(observer.error);
        if(!m)throw value;
        value = m.call(observer, value);
      } catch(e){
        try {
          cleanupSubscription(subscription);
        } finally {
          throw e;
        }
      } cleanupSubscription(subscription);
      return value;
    },
    complete: function complete(value){
      var subscription = this._s;
      if(!subscriptionClosed(subscription)){
        var observer = subscription._o;
        subscription._o = undefined;
        try {
          var m = getMethod(observer.complete);
          value = m ? m.call(observer, value) : undefined;
        } catch(e){
          try {
            cleanupSubscription(subscription);
          } finally {
            throw e;
          }
        } cleanupSubscription(subscription);
        return value;
      }
    }
  });
  
  var $Observable = function Observable(subscriber){
    anInstance(this, $Observable, 'Observable', '_f')._f = aFunction(subscriber);
  };
  
  redefineAll($Observable.prototype, {
    subscribe: function subscribe(observer){
      return new Subscription(observer, this._f);
    },
    forEach: function forEach(fn){
      var that = this;
      return new (core.Promise || global.Promise)(function(resolve, reject){
        aFunction(fn);
        var subscription = that.subscribe({
          next : function(value){
            try {
              return fn(value);
            } catch(e){
              reject(e);
              subscription.unsubscribe();
            }
          },
          error: reject,
          complete: resolve
        });
      });
    }
  });
  
  redefineAll($Observable, {
    from: function from(x){
      var C = typeof this === 'function' ? this : $Observable;
      var method = getMethod(anObject(x)[OBSERVABLE]);
      if(method){
        var observable = anObject(method.call(x));
        return observable.constructor === C ? observable : new C(function(observer){
          return observable.subscribe(observer);
        });
      }
      return new C(function(observer){
        var done = false;
        microtask(function(){
          if(!done){
            try {
              if(forOf(x, false, function(it){
                observer.next(it);
                if(done)return RETURN;
              }) === RETURN)return;
            } catch(e){
              if(done)throw e;
              observer.error(e);
              return;
            } observer.complete();
          }
        });
        return function(){ done = true; };
      });
    },
    of: function of(){
      for(var i = 0, l = arguments.length, items = Array(l); i < l;)items[i] = arguments[i++];
      return new (typeof this === 'function' ? this : $Observable)(function(observer){
        var done = false;
        microtask(function(){
          if(!done){
            for(var i = 0; i < items.length; ++i){
              observer.next(items[i]);
              if(done)return;
            } observer.complete();
          }
        });
        return function(){ done = true; };
      });
    }
  });
  
  hide($Observable.prototype, OBSERVABLE, function(){ return this; });
  
  $export($export.G, {Observable: $Observable});
  
  require('./_set-species')('Observable');
  },{"./_a-function":4,"./_an-instance":7,"./_an-object":8,"./_core":24,"./_export":33,"./_for-of":38,"./_global":39,"./_hide":41,"./_microtask":65,"./_redefine-all":87,"./_set-species":92,"./_wks":118}],274:[function(require,module,exports){
  var metadata                  = require('./_metadata')
    , anObject                  = require('./_an-object')
    , toMetaKey                 = metadata.key
    , ordinaryDefineOwnMetadata = metadata.set;
  
  metadata.exp({defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey){
    ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetaKey(targetKey));
  }});
  },{"./_an-object":8,"./_metadata":64}],275:[function(require,module,exports){
  var metadata               = require('./_metadata')
    , anObject               = require('./_an-object')
    , toMetaKey              = metadata.key
    , getOrCreateMetadataMap = metadata.map
    , store                  = metadata.store;
  
  metadata.exp({deleteMetadata: function deleteMetadata(metadataKey, target /*, targetKey */){
    var targetKey   = arguments.length < 3 ? undefined : toMetaKey(arguments[2])
      , metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false);
    if(metadataMap === undefined || !metadataMap['delete'](metadataKey))return false;
    if(metadataMap.size)return true;
    var targetMetadata = store.get(target);
    targetMetadata['delete'](targetKey);
    return !!targetMetadata.size || store['delete'](target);
  }});
  },{"./_an-object":8,"./_metadata":64}],276:[function(require,module,exports){
  var Set                     = require('./es6.set')
    , from                    = require('./_array-from-iterable')
    , metadata                = require('./_metadata')
    , anObject                = require('./_an-object')
    , getPrototypeOf          = require('./_object-gpo')
    , ordinaryOwnMetadataKeys = metadata.keys
    , toMetaKey               = metadata.key;
  
  var ordinaryMetadataKeys = function(O, P){
    var oKeys  = ordinaryOwnMetadataKeys(O, P)
      , parent = getPrototypeOf(O);
    if(parent === null)return oKeys;
    var pKeys  = ordinaryMetadataKeys(parent, P);
    return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys;
  };
  
  metadata.exp({getMetadataKeys: function getMetadataKeys(target /*, targetKey */){
    return ordinaryMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
  }});
  },{"./_an-object":8,"./_array-from-iterable":11,"./_metadata":64,"./_object-gpo":75,"./es6.set":221}],277:[function(require,module,exports){
  var metadata               = require('./_metadata')
    , anObject               = require('./_an-object')
    , getPrototypeOf         = require('./_object-gpo')
    , ordinaryHasOwnMetadata = metadata.has
    , ordinaryGetOwnMetadata = metadata.get
    , toMetaKey              = metadata.key;
  
  var ordinaryGetMetadata = function(MetadataKey, O, P){
    var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
    if(hasOwn)return ordinaryGetOwnMetadata(MetadataKey, O, P);
    var parent = getPrototypeOf(O);
    return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined;
  };
  
  metadata.exp({getMetadata: function getMetadata(metadataKey, target /*, targetKey */){
    return ordinaryGetMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  },{"./_an-object":8,"./_metadata":64,"./_object-gpo":75}],278:[function(require,module,exports){
  var metadata                = require('./_metadata')
    , anObject                = require('./_an-object')
    , ordinaryOwnMetadataKeys = metadata.keys
    , toMetaKey               = metadata.key;
  
  metadata.exp({getOwnMetadataKeys: function getOwnMetadataKeys(target /*, targetKey */){
    return ordinaryOwnMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
  }});
  },{"./_an-object":8,"./_metadata":64}],279:[function(require,module,exports){
  var metadata               = require('./_metadata')
    , anObject               = require('./_an-object')
    , ordinaryGetOwnMetadata = metadata.get
    , toMetaKey              = metadata.key;
  
  metadata.exp({getOwnMetadata: function getOwnMetadata(metadataKey, target /*, targetKey */){
    return ordinaryGetOwnMetadata(metadataKey, anObject(target)
      , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  },{"./_an-object":8,"./_metadata":64}],280:[function(require,module,exports){
  var metadata               = require('./_metadata')
    , anObject               = require('./_an-object')
    , getPrototypeOf         = require('./_object-gpo')
    , ordinaryHasOwnMetadata = metadata.has
    , toMetaKey              = metadata.key;
  
  var ordinaryHasMetadata = function(MetadataKey, O, P){
    var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
    if(hasOwn)return true;
    var parent = getPrototypeOf(O);
    return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false;
  };
  
  metadata.exp({hasMetadata: function hasMetadata(metadataKey, target /*, targetKey */){
    return ordinaryHasMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  },{"./_an-object":8,"./_metadata":64,"./_object-gpo":75}],281:[function(require,module,exports){
  var metadata               = require('./_metadata')
    , anObject               = require('./_an-object')
    , ordinaryHasOwnMetadata = metadata.has
    , toMetaKey              = metadata.key;
  
  metadata.exp({hasOwnMetadata: function hasOwnMetadata(metadataKey, target /*, targetKey */){
    return ordinaryHasOwnMetadata(metadataKey, anObject(target)
      , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  },{"./_an-object":8,"./_metadata":64}],282:[function(require,module,exports){
  var metadata                  = require('./_metadata')
    , anObject                  = require('./_an-object')
    , aFunction                 = require('./_a-function')
    , toMetaKey                 = metadata.key
    , ordinaryDefineOwnMetadata = metadata.set;
  
  metadata.exp({metadata: function metadata(metadataKey, metadataValue){
    return function decorator(target, targetKey){
      ordinaryDefineOwnMetadata(
        metadataKey, metadataValue,
        (targetKey !== undefined ? anObject : aFunction)(target),
        toMetaKey(targetKey)
      );
    };
  }});
  },{"./_a-function":4,"./_an-object":8,"./_metadata":64}],283:[function(require,module,exports){
  // https://github.com/DavidBruant/Map-Set.prototype.toJSON
  var $export  = require('./_export');
  
  $export($export.P + $export.R, 'Set', {toJSON: require('./_collection-to-json')('Set')});
  },{"./_collection-to-json":21,"./_export":33}],284:[function(require,module,exports){
  'use strict';
  // https://github.com/mathiasbynens/String.prototype.at
  var $export = require('./_export')
    , $at     = require('./_string-at')(true);
  
  $export($export.P, 'String', {
    at: function at(pos){
      return $at(this, pos);
    }
  });
  },{"./_export":33,"./_string-at":98}],285:[function(require,module,exports){
  'use strict';
  // https://tc39.github.io/String.prototype.matchAll/
  var $export     = require('./_export')
    , defined     = require('./_defined')
    , toLength    = require('./_to-length')
    , isRegExp    = require('./_is-regexp')
    , getFlags    = require('./_flags')
    , RegExpProto = RegExp.prototype;
  
  var $RegExpStringIterator = function(regexp, string){
    this._r = regexp;
    this._s = string;
  };
  
  require('./_iter-create')($RegExpStringIterator, 'RegExp String', function next(){
    var match = this._r.exec(this._s);
    return {value: match, done: match === null};
  });
  
  $export($export.P, 'String', {
    matchAll: function matchAll(regexp){
      defined(this);
      if(!isRegExp(regexp))throw TypeError(regexp + ' is not a regexp!');
      var S     = String(this)
        , flags = 'flags' in RegExpProto ? String(regexp.flags) : getFlags.call(regexp)
        , rx    = new RegExp(regexp.source, ~flags.indexOf('g') ? flags : 'g' + flags);
      rx.lastIndex = toLength(regexp.lastIndex);
      return new $RegExpStringIterator(rx, S);
    }
  });
  },{"./_defined":28,"./_export":33,"./_flags":37,"./_is-regexp":51,"./_iter-create":53,"./_to-length":109}],286:[function(require,module,exports){
  'use strict';
  // https://github.com/tc39/proposal-string-pad-start-end
  var $export = require('./_export')
    , $pad    = require('./_string-pad');
  
  $export($export.P, 'String', {
    padEnd: function padEnd(maxLength /*, fillString = ' ' */){
      return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
    }
  });
  },{"./_export":33,"./_string-pad":101}],287:[function(require,module,exports){
  'use strict';
  // https://github.com/tc39/proposal-string-pad-start-end
  var $export = require('./_export')
    , $pad    = require('./_string-pad');
  
  $export($export.P, 'String', {
    padStart: function padStart(maxLength /*, fillString = ' ' */){
      return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
    }
  });
  },{"./_export":33,"./_string-pad":101}],288:[function(require,module,exports){
  'use strict';
  // https://github.com/sebmarkbage/ecmascript-string-left-right-trim
  require('./_string-trim')('trimLeft', function($trim){
    return function trimLeft(){
      return $trim(this, 1);
    };
  }, 'trimStart');
  },{"./_string-trim":103}],289:[function(require,module,exports){
  'use strict';
  // https://github.com/sebmarkbage/ecmascript-string-left-right-trim
  require('./_string-trim')('trimRight', function($trim){
    return function trimRight(){
      return $trim(this, 2);
    };
  }, 'trimEnd');
  },{"./_string-trim":103}],290:[function(require,module,exports){
  require('./_wks-define')('asyncIterator');
  },{"./_wks-define":116}],291:[function(require,module,exports){
  require('./_wks-define')('observable');
  },{"./_wks-define":116}],292:[function(require,module,exports){
  // https://github.com/ljharb/proposal-global
  var $export = require('./_export');
  
  $export($export.S, 'System', {global: require('./_global')});
  },{"./_export":33,"./_global":39}],293:[function(require,module,exports){
  var $iterators    = require('./es6.array.iterator')
    , redefine      = require('./_redefine')
    , global        = require('./_global')
    , hide          = require('./_hide')
    , Iterators     = require('./_iterators')
    , wks           = require('./_wks')
    , ITERATOR      = wks('iterator')
    , TO_STRING_TAG = wks('toStringTag')
    , ArrayValues   = Iterators.Array;
  
  for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
    var NAME       = collections[i]
      , Collection = global[NAME]
      , proto      = Collection && Collection.prototype
      , key;
    if(proto){
      if(!proto[ITERATOR])hide(proto, ITERATOR, ArrayValues);
      if(!proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);
      Iterators[NAME] = ArrayValues;
      for(key in $iterators)if(!proto[key])redefine(proto, key, $iterators[key], true);
    }
  }
  },{"./_global":39,"./_hide":41,"./_iterators":57,"./_redefine":88,"./_wks":118,"./es6.array.iterator":131}],294:[function(require,module,exports){
  var $export = require('./_export')
    , $task   = require('./_task');
  $export($export.G + $export.B, {
    setImmediate:   $task.set,
    clearImmediate: $task.clear
  });
  },{"./_export":33,"./_task":105}],295:[function(require,module,exports){
  // ie9- setTimeout & setInterval additional parameters fix
  var global     = require('./_global')
    , $export    = require('./_export')
    , invoke     = require('./_invoke')
    , partial    = require('./_partial')
    , navigator  = global.navigator
    , MSIE       = !!navigator && /MSIE .\./.test(navigator.userAgent); // <- dirty ie9- check
  var wrap = function(set){
    return MSIE ? function(fn, time /*, ...args */){
      return set(invoke(
        partial,
        [].slice.call(arguments, 2),
        typeof fn == 'function' ? fn : Function(fn)
      ), time);
    } : set;
  };
  $export($export.G + $export.B + $export.F * MSIE, {
    setTimeout:  wrap(global.setTimeout),
    setInterval: wrap(global.setInterval)
  });
  },{"./_export":33,"./_global":39,"./_invoke":45,"./_partial":84}],296:[function(require,module,exports){
  require('./modules/es6.symbol');
  require('./modules/es6.object.create');
  require('./modules/es6.object.define-property');
  require('./modules/es6.object.define-properties');
  require('./modules/es6.object.get-own-property-descriptor');
  require('./modules/es6.object.get-prototype-of');
  require('./modules/es6.object.keys');
  require('./modules/es6.object.get-own-property-names');
  require('./modules/es6.object.freeze');
  require('./modules/es6.object.seal');
  require('./modules/es6.object.prevent-extensions');
  require('./modules/es6.object.is-frozen');
  require('./modules/es6.object.is-sealed');
  require('./modules/es6.object.is-extensible');
  require('./modules/es6.object.assign');
  require('./modules/es6.object.is');
  require('./modules/es6.object.set-prototype-of');
  require('./modules/es6.object.to-string');
  require('./modules/es6.function.bind');
  require('./modules/es6.function.name');
  require('./modules/es6.function.has-instance');
  require('./modules/es6.parse-int');
  require('./modules/es6.parse-float');
  require('./modules/es6.number.constructor');
  require('./modules/es6.number.to-fixed');
  require('./modules/es6.number.to-precision');
  require('./modules/es6.number.epsilon');
  require('./modules/es6.number.is-finite');
  require('./modules/es6.number.is-integer');
  require('./modules/es6.number.is-nan');
  require('./modules/es6.number.is-safe-integer');
  require('./modules/es6.number.max-safe-integer');
  require('./modules/es6.number.min-safe-integer');
  require('./modules/es6.number.parse-float');
  require('./modules/es6.number.parse-int');
  require('./modules/es6.math.acosh');
  require('./modules/es6.math.asinh');
  require('./modules/es6.math.atanh');
  require('./modules/es6.math.cbrt');
  require('./modules/es6.math.clz32');
  require('./modules/es6.math.cosh');
  require('./modules/es6.math.expm1');
  require('./modules/es6.math.fround');
  require('./modules/es6.math.hypot');
  require('./modules/es6.math.imul');
  require('./modules/es6.math.log10');
  require('./modules/es6.math.log1p');
  require('./modules/es6.math.log2');
  require('./modules/es6.math.sign');
  require('./modules/es6.math.sinh');
  require('./modules/es6.math.tanh');
  require('./modules/es6.math.trunc');
  require('./modules/es6.string.from-code-point');
  require('./modules/es6.string.raw');
  require('./modules/es6.string.trim');
  require('./modules/es6.string.iterator');
  require('./modules/es6.string.code-point-at');
  require('./modules/es6.string.ends-with');
  require('./modules/es6.string.includes');
  require('./modules/es6.string.repeat');
  require('./modules/es6.string.starts-with');
  require('./modules/es6.string.anchor');
  require('./modules/es6.string.big');
  require('./modules/es6.string.blink');
  require('./modules/es6.string.bold');
  require('./modules/es6.string.fixed');
  require('./modules/es6.string.fontcolor');
  require('./modules/es6.string.fontsize');
  require('./modules/es6.string.italics');
  require('./modules/es6.string.link');
  require('./modules/es6.string.small');
  require('./modules/es6.string.strike');
  require('./modules/es6.string.sub');
  require('./modules/es6.string.sup');
  require('./modules/es6.date.now');
  require('./modules/es6.date.to-json');
  require('./modules/es6.date.to-iso-string');
  require('./modules/es6.date.to-string');
  require('./modules/es6.date.to-primitive');
  require('./modules/es6.array.is-array');
  require('./modules/es6.array.from');
  require('./modules/es6.array.of');
  require('./modules/es6.array.join');
  require('./modules/es6.array.slice');
  require('./modules/es6.array.sort');
  require('./modules/es6.array.for-each');
  require('./modules/es6.array.map');
  require('./modules/es6.array.filter');
  require('./modules/es6.array.some');
  require('./modules/es6.array.every');
  require('./modules/es6.array.reduce');
  require('./modules/es6.array.reduce-right');
  require('./modules/es6.array.index-of');
  require('./modules/es6.array.last-index-of');
  require('./modules/es6.array.copy-within');
  require('./modules/es6.array.fill');
  require('./modules/es6.array.find');
  require('./modules/es6.array.find-index');
  require('./modules/es6.array.species');
  require('./modules/es6.array.iterator');
  require('./modules/es6.regexp.constructor');
  require('./modules/es6.regexp.to-string');
  require('./modules/es6.regexp.flags');
  require('./modules/es6.regexp.match');
  require('./modules/es6.regexp.replace');
  require('./modules/es6.regexp.search');
  require('./modules/es6.regexp.split');
  require('./modules/es6.promise');
  require('./modules/es6.map');
  require('./modules/es6.set');
  require('./modules/es6.weak-map');
  require('./modules/es6.weak-set');
  require('./modules/es6.typed.array-buffer');
  require('./modules/es6.typed.data-view');
  require('./modules/es6.typed.int8-array');
  require('./modules/es6.typed.uint8-array');
  require('./modules/es6.typed.uint8-clamped-array');
  require('./modules/es6.typed.int16-array');
  require('./modules/es6.typed.uint16-array');
  require('./modules/es6.typed.int32-array');
  require('./modules/es6.typed.uint32-array');
  require('./modules/es6.typed.float32-array');
  require('./modules/es6.typed.float64-array');
  require('./modules/es6.reflect.apply');
  require('./modules/es6.reflect.construct');
  require('./modules/es6.reflect.define-property');
  require('./modules/es6.reflect.delete-property');
  require('./modules/es6.reflect.enumerate');
  require('./modules/es6.reflect.get');
  require('./modules/es6.reflect.get-own-property-descriptor');
  require('./modules/es6.reflect.get-prototype-of');
  require('./modules/es6.reflect.has');
  require('./modules/es6.reflect.is-extensible');
  require('./modules/es6.reflect.own-keys');
  require('./modules/es6.reflect.prevent-extensions');
  require('./modules/es6.reflect.set');
  require('./modules/es6.reflect.set-prototype-of');
  require('./modules/es7.array.includes');
  require('./modules/es7.string.at');
  require('./modules/es7.string.pad-start');
  require('./modules/es7.string.pad-end');
  require('./modules/es7.string.trim-left');
  require('./modules/es7.string.trim-right');
  require('./modules/es7.string.match-all');
  require('./modules/es7.symbol.async-iterator');
  require('./modules/es7.symbol.observable');
  require('./modules/es7.object.get-own-property-descriptors');
  require('./modules/es7.object.values');
  require('./modules/es7.object.entries');
  require('./modules/es7.object.define-getter');
  require('./modules/es7.object.define-setter');
  require('./modules/es7.object.lookup-getter');
  require('./modules/es7.object.lookup-setter');
  require('./modules/es7.map.to-json');
  require('./modules/es7.set.to-json');
  require('./modules/es7.system.global');
  require('./modules/es7.error.is-error');
  require('./modules/es7.math.iaddh');
  require('./modules/es7.math.isubh');
  require('./modules/es7.math.imulh');
  require('./modules/es7.math.umulh');
  require('./modules/es7.reflect.define-metadata');
  require('./modules/es7.reflect.delete-metadata');
  require('./modules/es7.reflect.get-metadata');
  require('./modules/es7.reflect.get-metadata-keys');
  require('./modules/es7.reflect.get-own-metadata');
  require('./modules/es7.reflect.get-own-metadata-keys');
  require('./modules/es7.reflect.has-metadata');
  require('./modules/es7.reflect.has-own-metadata');
  require('./modules/es7.reflect.metadata');
  require('./modules/es7.asap');
  require('./modules/es7.observable');
  require('./modules/web.timers');
  require('./modules/web.immediate');
  require('./modules/web.dom.iterable');
  module.exports = require('./modules/_core');
  },{"./modules/_core":24,"./modules/es6.array.copy-within":121,"./modules/es6.array.every":122,"./modules/es6.array.fill":123,"./modules/es6.array.filter":124,"./modules/es6.array.find":126,"./modules/es6.array.find-index":125,"./modules/es6.array.for-each":127,"./modules/es6.array.from":128,"./modules/es6.array.index-of":129,"./modules/es6.array.is-array":130,"./modules/es6.array.iterator":131,"./modules/es6.array.join":132,"./modules/es6.array.last-index-of":133,"./modules/es6.array.map":134,"./modules/es6.array.of":135,"./modules/es6.array.reduce":137,"./modules/es6.array.reduce-right":136,"./modules/es6.array.slice":138,"./modules/es6.array.some":139,"./modules/es6.array.sort":140,"./modules/es6.array.species":141,"./modules/es6.date.now":142,"./modules/es6.date.to-iso-string":143,"./modules/es6.date.to-json":144,"./modules/es6.date.to-primitive":145,"./modules/es6.date.to-string":146,"./modules/es6.function.bind":147,"./modules/es6.function.has-instance":148,"./modules/es6.function.name":149,"./modules/es6.map":150,"./modules/es6.math.acosh":151,"./modules/es6.math.asinh":152,"./modules/es6.math.atanh":153,"./modules/es6.math.cbrt":154,"./modules/es6.math.clz32":155,"./modules/es6.math.cosh":156,"./modules/es6.math.expm1":157,"./modules/es6.math.fround":158,"./modules/es6.math.hypot":159,"./modules/es6.math.imul":160,"./modules/es6.math.log10":161,"./modules/es6.math.log1p":162,"./modules/es6.math.log2":163,"./modules/es6.math.sign":164,"./modules/es6.math.sinh":165,"./modules/es6.math.tanh":166,"./modules/es6.math.trunc":167,"./modules/es6.number.constructor":168,"./modules/es6.number.epsilon":169,"./modules/es6.number.is-finite":170,"./modules/es6.number.is-integer":171,"./modules/es6.number.is-nan":172,"./modules/es6.number.is-safe-integer":173,"./modules/es6.number.max-safe-integer":174,"./modules/es6.number.min-safe-integer":175,"./modules/es6.number.parse-float":176,"./modules/es6.number.parse-int":177,"./modules/es6.number.to-fixed":178,"./modules/es6.number.to-precision":179,"./modules/es6.object.assign":180,"./modules/es6.object.create":181,"./modules/es6.object.define-properties":182,"./modules/es6.object.define-property":183,"./modules/es6.object.freeze":184,"./modules/es6.object.get-own-property-descriptor":185,"./modules/es6.object.get-own-property-names":186,"./modules/es6.object.get-prototype-of":187,"./modules/es6.object.is":191,"./modules/es6.object.is-extensible":188,"./modules/es6.object.is-frozen":189,"./modules/es6.object.is-sealed":190,"./modules/es6.object.keys":192,"./modules/es6.object.prevent-extensions":193,"./modules/es6.object.seal":194,"./modules/es6.object.set-prototype-of":195,"./modules/es6.object.to-string":196,"./modules/es6.parse-float":197,"./modules/es6.parse-int":198,"./modules/es6.promise":199,"./modules/es6.reflect.apply":200,"./modules/es6.reflect.construct":201,"./modules/es6.reflect.define-property":202,"./modules/es6.reflect.delete-property":203,"./modules/es6.reflect.enumerate":204,"./modules/es6.reflect.get":207,"./modules/es6.reflect.get-own-property-descriptor":205,"./modules/es6.reflect.get-prototype-of":206,"./modules/es6.reflect.has":208,"./modules/es6.reflect.is-extensible":209,"./modules/es6.reflect.own-keys":210,"./modules/es6.reflect.prevent-extensions":211,"./modules/es6.reflect.set":213,"./modules/es6.reflect.set-prototype-of":212,"./modules/es6.regexp.constructor":214,"./modules/es6.regexp.flags":215,"./modules/es6.regexp.match":216,"./modules/es6.regexp.replace":217,"./modules/es6.regexp.search":218,"./modules/es6.regexp.split":219,"./modules/es6.regexp.to-string":220,"./modules/es6.set":221,"./modules/es6.string.anchor":222,"./modules/es6.string.big":223,"./modules/es6.string.blink":224,"./modules/es6.string.bold":225,"./modules/es6.string.code-point-at":226,"./modules/es6.string.ends-with":227,"./modules/es6.string.fixed":228,"./modules/es6.string.fontcolor":229,"./modules/es6.string.fontsize":230,"./modules/es6.string.from-code-point":231,"./modules/es6.string.includes":232,"./modules/es6.string.italics":233,"./modules/es6.string.iterator":234,"./modules/es6.string.link":235,"./modules/es6.string.raw":236,"./modules/es6.string.repeat":237,"./modules/es6.string.small":238,"./modules/es6.string.starts-with":239,"./modules/es6.string.strike":240,"./modules/es6.string.sub":241,"./modules/es6.string.sup":242,"./modules/es6.string.trim":243,"./modules/es6.symbol":244,"./modules/es6.typed.array-buffer":245,"./modules/es6.typed.data-view":246,"./modules/es6.typed.float32-array":247,"./modules/es6.typed.float64-array":248,"./modules/es6.typed.int16-array":249,"./modules/es6.typed.int32-array":250,"./modules/es6.typed.int8-array":251,"./modules/es6.typed.uint16-array":252,"./modules/es6.typed.uint32-array":253,"./modules/es6.typed.uint8-array":254,"./modules/es6.typed.uint8-clamped-array":255,"./modules/es6.weak-map":256,"./modules/es6.weak-set":257,"./modules/es7.array.includes":258,"./modules/es7.asap":259,"./modules/es7.error.is-error":260,"./modules/es7.map.to-json":261,"./modules/es7.math.iaddh":262,"./modules/es7.math.imulh":263,"./modules/es7.math.isubh":264,"./modules/es7.math.umulh":265,"./modules/es7.object.define-getter":266,"./modules/es7.object.define-setter":267,"./modules/es7.object.entries":268,"./modules/es7.object.get-own-property-descriptors":269,"./modules/es7.object.lookup-getter":270,"./modules/es7.object.lookup-setter":271,"./modules/es7.object.values":272,"./modules/es7.observable":273,"./modules/es7.reflect.define-metadata":274,"./modules/es7.reflect.delete-metadata":275,"./modules/es7.reflect.get-metadata":277,"./modules/es7.reflect.get-metadata-keys":276,"./modules/es7.reflect.get-own-metadata":279,"./modules/es7.reflect.get-own-metadata-keys":278,"./modules/es7.reflect.has-metadata":280,"./modules/es7.reflect.has-own-metadata":281,"./modules/es7.reflect.metadata":282,"./modules/es7.set.to-json":283,"./modules/es7.string.at":284,"./modules/es7.string.match-all":285,"./modules/es7.string.pad-end":286,"./modules/es7.string.pad-start":287,"./modules/es7.string.trim-left":288,"./modules/es7.string.trim-right":289,"./modules/es7.symbol.async-iterator":290,"./modules/es7.symbol.observable":291,"./modules/es7.system.global":292,"./modules/web.dom.iterable":293,"./modules/web.immediate":294,"./modules/web.timers":295}],297:[function(require,module,exports){
  (function () {
    'use strict';
  
    var ShimDOMException;
    var phases = {
      NONE: 0,
      CAPTURING_PHASE: 1,
      AT_TARGET: 2,
      BUBBLING_PHASE: 3
    };
  
    if (typeof DOMException === 'undefined') {
      // Todo: Better polyfill (if even needed here)
      ShimDOMException = function DOMException (msg, name) { // No need for `toString` as same as for `Error`
        var err = new Error(msg);
        err.name = name;
        return err;
      };
    } else {
      ShimDOMException = DOMException;
    }
  
    var ev = new WeakMap();
    var evCfg = new WeakMap();
  
    // Todo: Set _ev argument outside of this function
    /**
    * We use an adapter class rather than a proxy not only for compatibility but also since we have to clone
    * native event properties anyways in order to properly set `target`, etc.
    * @note The regular DOM method `dispatchEvent` won't work with this polyfill as it expects a native event
    */
    var ShimEvent = function Event (type) { // eslint-disable-line no-native-reassign
      // For WebIDL checks of function's `length`, we check `arguments` for the optional arguments
      this[Symbol.toStringTag] = 'Event';
      this.toString = function () {
        return '[object Event]';
      };
      var evInit = arguments[1];
      var _ev = arguments[2];
      if (!arguments.length) {
        throw new TypeError("Failed to construct 'Event': 1 argument required, but only 0 present.");
      }
      evInit = evInit || {};
      _ev = _ev || {};
  
      var _evCfg = {};
      if ('composed' in evInit) {
        _evCfg.composed = evInit.composed;
      }
  
      // _evCfg.isTrusted = true; // We are not always using this for user-created events
      // _evCfg.timeStamp = new Date().valueOf(); // This is no longer a timestamp, but monotonic (elapsed?)
  
      ev.set(this, _ev);
      evCfg.set(this, _evCfg);
      this.initEvent(type, evInit.bubbles, evInit.cancelable);
      Object.defineProperties(this,
        ['target', 'currentTarget', 'eventPhase', 'defaultPrevented'].reduce(function (obj, prop) {
          obj[prop] = {
            get: function () {
              return (/* prop in _evCfg && */ _evCfg[prop] !== undefined) ? _evCfg[prop] : (
                prop in _ev ? _ev[prop] : (
                  // Defaults
                  prop === 'eventPhase' ? 0 : (prop === 'defaultPrevented' ? false : null)
                )
              );
            }
          };
          return obj;
        }, {})
      );
      var props = [
        // Event
        'type',
        'bubbles', 'cancelable', // Defaults to false
        'isTrusted', 'timeStamp',
        'initEvent',
        // Other event properties (not used by our code)
        'composedPath', 'composed'
      ];
      if (this.toString() === '[object CustomEvent]') {
        props.push('detail', 'initCustomEvent');
      }
  
      Object.defineProperties(this, props.reduce(function (obj, prop) {
        obj[prop] = {
          get: function () {
            return prop in _evCfg ? _evCfg[prop] : (prop in _ev ? _ev[prop] : (
              ['bubbles', 'cancelable', 'composed'].indexOf(prop) > -1 ? false : undefined
            ));
          }
        };
        return obj;
      }, {}));
    };
  
    ShimEvent.prototype.preventDefault = function () {
      if (!(this instanceof ShimEvent)) {
        throw new TypeError('Illegal invocation');
      }
      var _ev = ev.get(this);
      var _evCfg = evCfg.get(this);
      if (this.cancelable && !_evCfg._passive) {
        _evCfg.defaultPrevented = true;
        if (typeof _ev.preventDefault === 'function') { // Prevent any predefined defaults
          _ev.preventDefault();
        }
      };
    };
    ShimEvent.prototype.stopImmediatePropagation = function () {
      var _evCfg = evCfg.get(this);
      _evCfg._stopImmediatePropagation = true;
    };
    ShimEvent.prototype.stopPropagation = function () {
      var _evCfg = evCfg.get(this);
      _evCfg._stopPropagation = true;
    };
    ShimEvent.prototype.initEvent = function (type, bubbles, cancelable) {  // Chrome currently has function length 1 only but WebIDL says 3
      // var bubbles = arguments[1];
      // var cancelable = arguments[2];
      var _evCfg = evCfg.get(this);
  
      if (_evCfg._dispatched) {
        return;
      }
  
      _evCfg.type = type;
      if (bubbles !== undefined) {
        _evCfg.bubbles = bubbles;
      }
      if (cancelable !== undefined) {
        _evCfg.cancelable = cancelable;
      }
    };
    ['type', 'target', 'currentTarget'].forEach(function (prop) {
      Object.defineProperty(ShimEvent.prototype, prop, {
        enumerable: true,
        configurable: true,
        get: function () {
          throw new TypeError('Illegal invocation');
        }
      });
    });
    ['eventPhase', 'defaultPrevented', 'bubbles', 'cancelable', 'timeStamp'].forEach(function (prop) {
      Object.defineProperty(ShimEvent.prototype, prop, {
        enumerable: true,
        configurable: true,
        get: function () {
          throw new TypeError('Illegal invocation');
        }
      });
    });
    ['NONE', 'CAPTURING_PHASE', 'AT_TARGET', 'BUBBLING_PHASE'].forEach(function (prop, i) {
      Object.defineProperty(ShimEvent, prop, {
        enumerable: true,
        writable: false,
        value: i
      });
      Object.defineProperty(ShimEvent.prototype, prop, {
        writable: false,
        value: i
      });
    });
    ShimEvent[Symbol.toStringTag] = 'Function';
    ShimEvent.prototype[Symbol.toStringTag] = 'EventPrototype';
    Object.defineProperty(ShimEvent, 'prototype', {
      writable: false
    });
  
    var ShimCustomEvent = function CustomEvent (type) {
      var eventInitDict = arguments[1];
      var _ev = arguments[2];
      ShimEvent.call(this, type, eventInitDict, _ev);
      this[Symbol.toStringTag] = 'CustomEvent';
      this.toString = function () {
        return '[object CustomEvent]';
      };
      var _evCfg = evCfg.get(this);
      eventInitDict = eventInitDict || {};
      this.initCustomEvent(type, evInit.bubbles, evInit.cancelable, 'detail' in evInit ? evInit.detail : null);
    };
    Object.defineProperty(ShimCustomEvent.prototype, 'constructor', {
        enumerable: false,
        writable: true,
        configurable: true,
        value: ShimCustomEvent
    });
    ShimCustomEvent.prototype.initCustomEvent = function (type, bubbles, cancelable, detail) {
      if (!(this instanceof ShimCustomEvent)) {
          throw new TypeError('Illegal invocation');
      }
      var _evCfg = evCfg.get(this);
      ShimCustomEvent.call(this, type, {bubbles: bubbles, cancelable: cancelable, detail: detail}, arguments[4]);
  
      if (_evCfg._dispatched) {
        return;
      }
  
      if (detail !== undefined) {
        _evCfg.detail = detail;
      }
      Object.defineProperty(this, 'detail', {
          get: function () {
              return _evCfg.detail;
          }
      });
    };
    ShimCustomEvent[Symbol.toStringTag] = 'Function';
    ShimCustomEvent.prototype[Symbol.toStringTag] = 'CustomEventPrototype';
    Object.setPrototypeOf(ShimCustomEvent, ShimEvent); // TODO: IDL needs but reported as slow!
    Object.defineProperty(ShimCustomEvent.prototype, 'detail', {
      enumerable: true,
      configurable: true,
      get: function () {
        throw new TypeError('Illegal invocation');
      }
    });
    Object.setPrototypeOf(ShimCustomEvent.prototype, ShimEvent.prototype); // TODO: IDL needs but reported as slow!
    Object.defineProperty(ShimCustomEvent, 'prototype', {
        writable: false
    });
  
    function copyEvent (ev) {
      if ('detail' in ev) {
        return new ShimCustomEvent(ev.type, {bubbles: ev.bubbles, cancelable: ev.cancelable, detail: ev.detail}, ev);
      }
      return new ShimEvent(ev.type, {bubbles: ev.bubbles, cancelable: ev.cancelable}, ev);
    }
  
    function getListenersOptions (listeners, type, options) {
      var listenersByType = listeners[type];
      if (listenersByType === undefined) listeners[type] = listenersByType = [];
      options = typeof options === 'boolean' ? {capture: options} : (options || {});
      var stringifiedOptions = JSON.stringify(options);
      var listenersByTypeOptions = listenersByType.filter(function (obj) {
        return stringifiedOptions === JSON.stringify(obj.options);
      });
      return {listenersByTypeOptions: listenersByTypeOptions, options: options, listenersByType: listenersByType};
    }
  
    var methods = {
      addListener: function addListener (listeners, listener, type, options) {
        var listenerOptions = getListenersOptions(listeners, type, options);
        var listenersByTypeOptions = listenerOptions.listenersByTypeOptions;
        options = listenerOptions.options;
        var listenersByType = listenerOptions.listenersByType;
  
        if (listenersByTypeOptions.some(function (l) {
          return l.listener === listener;
        })) return;
        listenersByType.push({listener: listener, options: options});
      },
  
      removeListener: function removeListener (listeners, listener, type, options) {
        var listenerOptions = getListenersOptions(listeners, type, options);
        var listenersByType = listenerOptions.listenersByType;
        var stringifiedOptions = JSON.stringify(listenerOptions.options);
  
        listenersByType.some(function (l, i) {
          if (l.listener === listener && stringifiedOptions === JSON.stringify(l.options)) {
            listenersByType.splice(i, 1);
            if (!listenersByType.length) delete listeners[type];
            return true;
          }
        });
      },
  
      hasListener: function hasListener (listeners, listener, type, options) {
        var listenerOptions = getListenersOptions(listeners, type, options);
        var listenersByTypeOptions = listenerOptions.listenersByTypeOptions;
        return listenersByTypeOptions.some(function (l) {
          return l.listener === listener;
        });
      }
    };
  
    function EventTarget () {
      throw new TypeError('Illegal constructor');
    }
  
    Object.assign(EventTarget.prototype, ['Early', '', 'Late', 'Default'].reduce(function (obj, listenerType) {
      ['add', 'remove', 'has'].forEach(function (method) {
        obj[method + listenerType + 'EventListener'] = function (type, listener) {
          var options = arguments[2]; // We keep the listener `length` as per WebIDL
          if (arguments.length < 2) throw new TypeError('2 or more arguments required');
          if (typeof type !== 'string') throw new ShimDOMException('UNSPECIFIED_EVENT_TYPE_ERR', 'UNSPECIFIED_EVENT_TYPE_ERR'); // eslint-disable-line eqeqeq
          if (listener.handleEvent) { listener = listener.handleEvent.bind(listener); }
          var arrStr = '_' + listenerType.toLowerCase() + (listenerType === '' ? 'l' : 'L') + 'isteners';
          if (!this[arrStr]) Object.defineProperty(this, arrStr, {value: {}});
          return methods[method + 'Listener'](this[arrStr], listener, type, options);
        };
      });
      return obj;
    }, {}));
  
    Object.assign(EventTarget.prototype, {
      __setOptions: function (customOptions) {
        customOptions = customOptions || {};
        // Todo: Make into event properties?
        this._defaultSync = customOptions.defaultSync;
        this._extraProperties = customOptions.extraProperties;
      },
      dispatchEvent: function (ev) {
        return this._dispatchEvent(ev, true);
      },
      _dispatchEvent: function (ev, setTarget) {
        var me = this;
        ['early', '', 'late', 'default'].forEach(function (listenerType) {
          var arrStr = '_' + listenerType + (listenerType === '' ? 'l' : 'L') + 'isteners';
          if (!this[arrStr]) Object.defineProperty(this, arrStr, {value: {}});
        }, this);
  
        var _evCfg = evCfg.get(ev);
        if (_evCfg && setTarget && _evCfg._dispatched) throw new ShimDOMException('The object is in an invalid state.', 'InvalidStateError');
  
        var eventCopy;
        if (_evCfg) {
          eventCopy = ev;
        } else {
          eventCopy = copyEvent(ev);
          _evCfg = evCfg.get(eventCopy);
          _evCfg._dispatched = true;
          (this._extraProperties || []).forEach(function (prop) {
            if (prop in ev) {
              eventCopy[prop] = ev[prop]; // Todo: Put internal to `ShimEvent`?
            }
          });
        }
        var type = eventCopy.type;
  
        function finishEventDispatch () {
          _evCfg.eventPhase = phases.NONE;
          _evCfg.currentTarget = null;
          delete _evCfg._children;
        }
        function invokeDefaults () {
          // Ignore stopPropagation from defaults
          _evCfg._stopImmediatePropagation = undefined;
          _evCfg._stopPropagation = undefined;
          // We check here for whether we should invoke since may have changed since timeout (if late listener prevented default)
          if (!eventCopy.defaultPrevented || !_evCfg.cancelable) { // 2nd check should be redundant
            _evCfg.eventPhase = phases.AT_TARGET; // Temporarily set before we invoke default listeners
            eventCopy.target.invokeCurrentListeners(eventCopy.target._defaultListeners, eventCopy, type);
          }
          finishEventDispatch();
        }
        function continueEventDispatch () {
          // Ignore stop propagation of user now
          _evCfg._stopImmediatePropagation = undefined;
          _evCfg._stopPropagation = undefined;
          if (!me._defaultSync) {
            setTimeout(invokeDefaults, 0);
          } else invokeDefaults();
  
          _evCfg.eventPhase = phases.AT_TARGET; // Temporarily set before we invoke late listeners
          // Sync default might have stopped
          if (!_evCfg._stopPropagation) {
            _evCfg._stopImmediatePropagation = undefined;
            _evCfg._stopPropagation = undefined;
            // We could allow stopPropagation by only executing upon (_evCfg._stopPropagation)
            eventCopy.target.invokeCurrentListeners(eventCopy.target._lateListeners, eventCopy, type);
          }
          finishEventDispatch();
  
          return !eventCopy.defaultPrevented;
        }
  
        if (setTarget) _evCfg.target = this;
  
        switch (eventCopy.eventPhase) {
          default: case phases.NONE:
  
            _evCfg.eventPhase = phases.AT_TARGET; // Temporarily set before we invoke early listeners
            this.invokeCurrentListeners(this._earlyListeners, eventCopy, type);
            if (!this.__getParent) {
              _evCfg.eventPhase = phases.AT_TARGET;
              return this._dispatchEvent(eventCopy, false);
            }
  
            var par = this;
            var root = this;
            while (par.__getParent && (par = par.__getParent()) !== null) {
              if (!_evCfg._children) {
                _evCfg._children = [];
              }
              _evCfg._children.push(root);
              root = par;
            }
            root._defaultSync = me._defaultSync;
            _evCfg.eventPhase = phases.CAPTURING_PHASE;
            return root._dispatchEvent(eventCopy, false);
          case phases.CAPTURING_PHASE:
            if (_evCfg._stopPropagation) {
              return continueEventDispatch();
            }
            this.invokeCurrentListeners(this._listeners, eventCopy, type);
            var child = _evCfg._children && _evCfg._children.length && _evCfg._children.pop();
            if (!child || child === eventCopy.target) {
              _evCfg.eventPhase = phases.AT_TARGET;
            }
            if (child) child._defaultSync = me._defaultSync;
            return (child || this)._dispatchEvent(eventCopy, false);
          case phases.AT_TARGET:
            if (_evCfg._stopPropagation) {
              return continueEventDispatch();
            }
            this.invokeCurrentListeners(this._listeners, eventCopy, type, true);
            if (!_evCfg.bubbles) {
              return continueEventDispatch();
            }
            _evCfg.eventPhase = phases.BUBBLING_PHASE;
            return this._dispatchEvent(eventCopy, false);
          case phases.BUBBLING_PHASE:
            if (_evCfg._stopPropagation) {
              return continueEventDispatch();
            }
            var parent = this.__getParent && this.__getParent();
            if (!parent) {
              return continueEventDispatch();
            }
            parent.invokeCurrentListeners(parent._listeners, eventCopy, type, true);
            parent._defaultSync = me._defaultSync;
            return parent._dispatchEvent(eventCopy, false);
        }
      },
      invokeCurrentListeners: function (listeners, eventCopy, type, checkOnListeners) {
        var _evCfg = evCfg.get(eventCopy);
        var me = this;
        _evCfg.currentTarget = this;
  
        var listOpts = getListenersOptions(listeners, type, {});
        var listenersByType = listOpts.listenersByType.concat();
        var dummyIPos = listenersByType.length ? 1 : 0;
  
        listenersByType.some(function (listenerObj, i) {
          var onListener = checkOnListeners ? me['on' + type] : null;
          if (_evCfg._stopImmediatePropagation) return true;
          if (i === dummyIPos && typeof onListener === 'function') {
            // We don't splice this in as could be overwritten; executes here per
            //  https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-attributes:event-handlers-14
            this.tryCatch(function () {
              var ret = onListener.call(eventCopy.currentTarget, eventCopy);
              if (ret === false) {
                eventCopy.preventDefault();
              }
            });
          }
          var options = listenerObj.options;
          var once = options.once; // Remove listener after invoking once
          var passive = options.passive; // Don't allow `preventDefault`
          var capture = options.capture; // Use `_children` and set `eventPhase`
          _evCfg._passive = passive;
  
          if ((capture && eventCopy.target !== eventCopy.currentTarget && eventCopy.eventPhase === phases.CAPTURING_PHASE) ||
            (eventCopy.eventPhase === phases.AT_TARGET ||
            (!capture && eventCopy.target !== eventCopy.currentTarget && eventCopy.eventPhase === phases.BUBBLING_PHASE))
          ) {
            var listener = listenerObj.listener;
            this.tryCatch(function () {
              listener.call(eventCopy.currentTarget, eventCopy);
            });
            if (once) {
              this.removeEventListener(type, listener, options);
            }
          }
        }, this);
        this.tryCatch(function () {
          var onListener = checkOnListeners ? me['on' + type] : null;
          if (typeof onListener === 'function' && listenersByType.length < 2) {
            var ret = onListener.call(eventCopy.currentTarget, eventCopy); // Won't have executed if too short
            if (ret === false) {
              eventCopy.preventDefault();
            }
          }
        });
  
        return !eventCopy.defaultPrevented;
      },
      tryCatch: function (cb) {
        try {
          // Per MDN: Exceptions thrown by event handlers are reported
          //  as uncaught exceptions; the event handlers run on a nested
          //  callstack: they block the caller until they complete, but
          //  exceptions do not propagate to the caller.
          cb();
        } catch (err) {
          this.triggerErrorEvent(err);
        }
      },
      triggerErrorEvent: function (err) {
        var error = err;
        if (typeof err === 'string') {
          error = new Error('Uncaught exception: ' + err);
        }
  
        var triggerGlobalErrorEvent;
        if (typeof window === 'undefined' || typeof ErrorEvent === 'undefined' || (
            window && typeof window === 'object' && !window.dispatchEvent)
        ) {
          triggerGlobalErrorEvent = function () {
            setTimeout(function () { // Node won't be able to catch in this way if we throw in the main thread
              // console.log(err); // Should we auto-log for user?
              throw error; // Let user listen to `process.on('uncaughtException', function(err) {});`
            });
          };
        } else {
          triggerGlobalErrorEvent = function () {
            // See https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror
            //   and https://github.com/w3c/IndexedDB/issues/49
  
            // Note that a regular Event will properly trigger
            //   `window.addEventListener('error')` handlers, but it will not trigger
            //   `window.onerror` as per https://html.spec.whatwg.org/multipage/webappapis.html#handler-onerror
            // Note also that the following line won't handle `window.addEventListener` handlers
            //    if (window.onerror) window.onerror(error.message, err.fileName, err.lineNumber, error.columnNumber, error);
  
            // `ErrorEvent` properly triggers `window.onerror` and `window.addEventListener('error')` handlers
            var ev = new ErrorEvent('error', {
              error: err,
              message: error.message || '',
              // We can't get the actually useful user's values!
              filename: error.fileName || '',
              lineno: error.lineNumber || 0,
              colno: error.columnNumber || 0
            });
            window.dispatchEvent(ev);
            // console.log(err); // Should we auto-log for user?
          };
        }
        if (this.__userErrorEventHandler) {
          this.__userErrorEventHandler(error, triggerGlobalErrorEvent);
        } else {
          triggerGlobalErrorEvent();
        }
      }
    });
    EventTarget.prototype[Symbol.toStringTag] = 'EventTargetPrototype';
  
    Object.defineProperty(EventTarget, 'prototype', {
        writable: false
    });
  
    var ShimEventTarget = EventTarget;
    var EventTargetFactory = {
      createInstance: function (customOptions) {
        function EventTarget () {
          this.__setOptions(customOptions);
        }
        EventTarget.prototype = ShimEventTarget.prototype;
        return new EventTarget();
      }
    };
  
    // Todo: Move to own library (but allowing WeakMaps to be passed in for sharing here)
  
    var exportObj = (typeof module !== 'undefined' && module.exports) ? exports : window;
    exportObj.ShimEvent = ShimEvent;
    exportObj.ShimCustomEvent = ShimCustomEvent;
    exportObj.ShimDOMException = ShimDOMException;
    exportObj.ShimEventTarget = EventTarget;
    exportObj.EventTargetFactory = EventTargetFactory;
  }());
  
  },{}],298:[function(require,module,exports){
  // shim for using process in browser
  var process = module.exports = {};
  
  // cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  
  var cachedSetTimeout;
  var cachedClearTimeout;
  
  function defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      if (!draining || !currentQueue) {
          return;
      }
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;
  
      var len = queue.length;
      while(len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
              if (currentQueue) {
                  currentQueue[queueIndex].run();
              }
          }
          queueIndex = -1;
          len = queue.length;
      }
      currentQueue = null;
      draining = false;
      runClearTimeout(timeout);
  }
  
  process.nextTick = function (fun) {
      var args = new Array(arguments.length - 1);
      if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
          }
      }
      queue.push(new Item(fun, args));
      if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
      }
  };
  
  // v8 likes predictible objects
  function Item(fun, array) {
      this.fun = fun;
      this.array = array;
  }
  Item.prototype.run = function () {
      this.fun.apply(null, this.array);
  };
  process.title = 'browser';
  process.browser = true;
  process.env = {};
  process.argv = [];
  process.version = ''; // empty string to avoid regexp issues
  process.versions = {};
  
  function noop() {}
  
  process.on = noop;
  process.addListener = noop;
  process.once = noop;
  process.off = noop;
  process.removeListener = noop;
  process.removeAllListeners = noop;
  process.emit = noop;
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  },{}],299:[function(require,module,exports){
  (function (process,global){
  /**
   * Copyright (c) 2014, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
   * additional grant of patent rights can be found in the PATENTS file in
   * the same directory.
   */
  
  !(function(global) {
    "use strict";
  
    var Op = Object.prototype;
    var hasOwn = Op.hasOwnProperty;
    var undefined; // More compressible than void 0.
    var $Symbol = typeof Symbol === "function" ? Symbol : {};
    var iteratorSymbol = $Symbol.iterator || "@@iterator";
    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
  
    var inModule = typeof module === "object";
    var runtime = global.regeneratorRuntime;
    if (runtime) {
      if (inModule) {
        // If regeneratorRuntime is defined globally and we're in a module,
        // make the exports object identical to regeneratorRuntime.
        module.exports = runtime;
      }
      // Don't bother evaluating the rest of this file if the runtime was
      // already defined globally.
      return;
    }
  
    // Define the runtime globally (as expected by generated code) as either
    // module.exports (if we're in a module) or a new, empty object.
    runtime = global.regeneratorRuntime = inModule ? module.exports : {};
  
    function wrap(innerFn, outerFn, self, tryLocsList) {
      // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
      var generator = Object.create(protoGenerator.prototype);
      var context = new Context(tryLocsList || []);
  
      // The ._invoke method unifies the implementations of the .next,
      // .throw, and .return methods.
      generator._invoke = makeInvokeMethod(innerFn, self, context);
  
      return generator;
    }
    runtime.wrap = wrap;
  
    // Try/catch helper to minimize deoptimizations. Returns a completion
    // record like context.tryEntries[i].completion. This interface could
    // have been (and was previously) designed to take a closure to be
    // invoked without arguments, but in all the cases we care about we
    // already have an existing method we want to call, so there's no need
    // to create a new function object. We can even get away with assuming
    // the method takes exactly one argument, since that happens to be true
    // in every case, so we don't have to touch the arguments object. The
    // only additional allocation required is the completion record, which
    // has a stable shape and so hopefully should be cheap to allocate.
    function tryCatch(fn, obj, arg) {
      try {
        return { type: "normal", arg: fn.call(obj, arg) };
      } catch (err) {
        return { type: "throw", arg: err };
      }
    }
  
    var GenStateSuspendedStart = "suspendedStart";
    var GenStateSuspendedYield = "suspendedYield";
    var GenStateExecuting = "executing";
    var GenStateCompleted = "completed";
  
    // Returning this object from the innerFn has the same effect as
    // breaking out of the dispatch switch statement.
    var ContinueSentinel = {};
  
    // Dummy constructor functions that we use as the .constructor and
    // .constructor.prototype properties for functions that return Generator
    // objects. For full spec compliance, you may wish to configure your
    // minifier not to mangle the names of these two functions.
    function Generator() {}
    function GeneratorFunction() {}
    function GeneratorFunctionPrototype() {}
  
    // This is a polyfill for %IteratorPrototype% for environments that
    // don't natively support it.
    var IteratorPrototype = {};
    IteratorPrototype[iteratorSymbol] = function () {
      return this;
    };
  
    var getProto = Object.getPrototypeOf;
    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
    if (NativeIteratorPrototype &&
        NativeIteratorPrototype !== Op &&
        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
      // This environment has a native %IteratorPrototype%; use it instead
      // of the polyfill.
      IteratorPrototype = NativeIteratorPrototype;
    }
  
    var Gp = GeneratorFunctionPrototype.prototype =
      Generator.prototype = Object.create(IteratorPrototype);
    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
    GeneratorFunctionPrototype.constructor = GeneratorFunction;
    GeneratorFunctionPrototype[toStringTagSymbol] =
      GeneratorFunction.displayName = "GeneratorFunction";
  
    // Helper for defining the .next, .throw, and .return methods of the
    // Iterator interface in terms of a single ._invoke method.
    function defineIteratorMethods(prototype) {
      ["next", "throw", "return"].forEach(function(method) {
        prototype[method] = function(arg) {
          return this._invoke(method, arg);
        };
      });
    }
  
    runtime.isGeneratorFunction = function(genFun) {
      var ctor = typeof genFun === "function" && genFun.constructor;
      return ctor
        ? ctor === GeneratorFunction ||
          // For the native GeneratorFunction constructor, the best we can
          // do is to check its .name property.
          (ctor.displayName || ctor.name) === "GeneratorFunction"
        : false;
    };
  
    runtime.mark = function(genFun) {
      if (Object.setPrototypeOf) {
        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
      } else {
        genFun.__proto__ = GeneratorFunctionPrototype;
        if (!(toStringTagSymbol in genFun)) {
          genFun[toStringTagSymbol] = "GeneratorFunction";
        }
      }
      genFun.prototype = Object.create(Gp);
      return genFun;
    };
  
    // Within the body of any async function, `await x` is transformed to
    // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
    // `hasOwn.call(value, "__await")` to determine if the yielded value is
    // meant to be awaited.
    runtime.awrap = function(arg) {
      return { __await: arg };
    };
  
    function AsyncIterator(generator) {
      function invoke(method, arg, resolve, reject) {
        var record = tryCatch(generator[method], generator, arg);
        if (record.type === "throw") {
          reject(record.arg);
        } else {
          var result = record.arg;
          var value = result.value;
          if (value &&
              typeof value === "object" &&
              hasOwn.call(value, "__await")) {
            return Promise.resolve(value.__await).then(function(value) {
              invoke("next", value, resolve, reject);
            }, function(err) {
              invoke("throw", err, resolve, reject);
            });
          }
  
          return Promise.resolve(value).then(function(unwrapped) {
            // When a yielded Promise is resolved, its final value becomes
            // the .value of the Promise<{value,done}> result for the
            // current iteration. If the Promise is rejected, however, the
            // result for this iteration will be rejected with the same
            // reason. Note that rejections of yielded Promises are not
            // thrown back into the generator function, as is the case
            // when an awaited Promise is rejected. This difference in
            // behavior between yield and await is important, because it
            // allows the consumer to decide what to do with the yielded
            // rejection (swallow it and continue, manually .throw it back
            // into the generator, abandon iteration, whatever). With
            // await, by contrast, there is no opportunity to examine the
            // rejection reason outside the generator function, so the
            // only option is to throw it from the await expression, and
            // let the generator function handle the exception.
            result.value = unwrapped;
            resolve(result);
          }, reject);
        }
      }
  
      if (typeof process === "object" && process.domain) {
        invoke = process.domain.bind(invoke);
      }
  
      var previousPromise;
  
      function enqueue(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new Promise(function(resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }
  
        return previousPromise =
          // If enqueue has been called before, then we want to wait until
          // all previous Promises have been resolved before calling invoke,
          // so that results are always delivered in the correct order. If
          // enqueue has not been called before, then it is important to
          // call invoke immediately, without waiting on a callback to fire,
          // so that the async generator function has the opportunity to do
          // any necessary setup in a predictable way. This predictability
          // is why the Promise constructor synchronously invokes its
          // executor callback, and why async functions synchronously
          // execute code before the first await. Since we implement simple
          // async functions in terms of async generators, it is especially
          // important to get this right, even though it requires care.
          previousPromise ? previousPromise.then(
            callInvokeWithMethodAndArg,
            // Avoid propagating failures to Promises returned by later
            // invocations of the iterator.
            callInvokeWithMethodAndArg
          ) : callInvokeWithMethodAndArg();
      }
  
      // Define the unified helper method that is used to implement .next,
      // .throw, and .return (see defineIteratorMethods).
      this._invoke = enqueue;
    }
  
    defineIteratorMethods(AsyncIterator.prototype);
    runtime.AsyncIterator = AsyncIterator;
  
    // Note that simple async functions are implemented on top of
    // AsyncIterator objects; they just return a Promise for the value of
    // the final result produced by the iterator.
    runtime.async = function(innerFn, outerFn, self, tryLocsList) {
      var iter = new AsyncIterator(
        wrap(innerFn, outerFn, self, tryLocsList)
      );
  
      return runtime.isGeneratorFunction(outerFn)
        ? iter // If outerFn is a generator, return the full iterator.
        : iter.next().then(function(result) {
            return result.done ? result.value : iter.next();
          });
    };
  
    function makeInvokeMethod(innerFn, self, context) {
      var state = GenStateSuspendedStart;
  
      return function invoke(method, arg) {
        if (state === GenStateExecuting) {
          throw new Error("Generator is already running");
        }
  
        if (state === GenStateCompleted) {
          if (method === "throw") {
            throw arg;
          }
  
          // Be forgiving, per 25.3.3.3.3 of the spec:
          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
          return doneResult();
        }
  
        context.method = method;
        context.arg = arg;
  
        while (true) {
          var delegate = context.delegate;
          if (delegate) {
            var delegateResult = maybeInvokeDelegate(delegate, context);
            if (delegateResult) {
              if (delegateResult === ContinueSentinel) continue;
              return delegateResult;
            }
          }
  
          if (context.method === "next") {
            // Setting context._sent for legacy support of Babel's
            // function.sent implementation.
            context.sent = context._sent = context.arg;
  
          } else if (context.method === "throw") {
            if (state === GenStateSuspendedStart) {
              state = GenStateCompleted;
              throw context.arg;
            }
  
            context.dispatchException(context.arg);
  
          } else if (context.method === "return") {
            context.abrupt("return", context.arg);
          }
  
          state = GenStateExecuting;
  
          var record = tryCatch(innerFn, self, context);
          if (record.type === "normal") {
            // If an exception is thrown from innerFn, we leave state ===
            // GenStateExecuting and loop back for another invocation.
            state = context.done
              ? GenStateCompleted
              : GenStateSuspendedYield;
  
            if (record.arg === ContinueSentinel) {
              continue;
            }
  
            return {
              value: record.arg,
              done: context.done
            };
  
          } else if (record.type === "throw") {
            state = GenStateCompleted;
            // Dispatch the exception by looping back around to the
            // context.dispatchException(context.arg) call above.
            context.method = "throw";
            context.arg = record.arg;
          }
        }
      };
    }
  
    // Call delegate.iterator[context.method](context.arg) and handle the
    // result, either by returning a { value, done } result from the
    // delegate iterator, or by modifying context.method and context.arg,
    // setting context.delegate to null, and returning the ContinueSentinel.
    function maybeInvokeDelegate(delegate, context) {
      var method = delegate.iterator[context.method];
      if (method === undefined) {
        // A .throw or .return when the delegate iterator has no .throw
        // method always terminates the yield* loop.
        context.delegate = null;
  
        if (context.method === "throw") {
          if (delegate.iterator.return) {
            // If the delegate iterator has a return method, give it a
            // chance to clean up.
            context.method = "return";
            context.arg = undefined;
            maybeInvokeDelegate(delegate, context);
  
            if (context.method === "throw") {
              // If maybeInvokeDelegate(context) changed context.method from
              // "return" to "throw", let that override the TypeError below.
              return ContinueSentinel;
            }
          }
  
          context.method = "throw";
          context.arg = new TypeError(
            "The iterator does not provide a 'throw' method");
        }
  
        return ContinueSentinel;
      }
  
      var record = tryCatch(method, delegate.iterator, context.arg);
  
      if (record.type === "throw") {
        context.method = "throw";
        context.arg = record.arg;
        context.delegate = null;
        return ContinueSentinel;
      }
  
      var info = record.arg;
  
      if (! info) {
        context.method = "throw";
        context.arg = new TypeError("iterator result is not an object");
        context.delegate = null;
        return ContinueSentinel;
      }
  
      if (info.done) {
        // Assign the result of the finished delegate to the temporary
        // variable specified by delegate.resultName (see delegateYield).
        context[delegate.resultName] = info.value;
  
        // Resume execution at the desired location (see delegateYield).
        context.next = delegate.nextLoc;
  
        // If context.method was "throw" but the delegate handled the
        // exception, let the outer generator proceed normally. If
        // context.method was "next", forget context.arg since it has been
        // "consumed" by the delegate iterator. If context.method was
        // "return", allow the original .return call to continue in the
        // outer generator.
        if (context.method !== "return") {
          context.method = "next";
          context.arg = undefined;
        }
  
      } else {
        // Re-yield the result returned by the delegate method.
        return info;
      }
  
      // The delegate iterator is finished, so forget it and continue with
      // the outer generator.
      context.delegate = null;
      return ContinueSentinel;
    }
  
    // Define Generator.prototype.{next,throw,return} in terms of the
    // unified ._invoke helper method.
    defineIteratorMethods(Gp);
  
    Gp[toStringTagSymbol] = "Generator";
  
    Gp.toString = function() {
      return "[object Generator]";
    };
  
    function pushTryEntry(locs) {
      var entry = { tryLoc: locs[0] };
  
      if (1 in locs) {
        entry.catchLoc = locs[1];
      }
  
      if (2 in locs) {
        entry.finallyLoc = locs[2];
        entry.afterLoc = locs[3];
      }
  
      this.tryEntries.push(entry);
    }
  
    function resetTryEntry(entry) {
      var record = entry.completion || {};
      record.type = "normal";
      delete record.arg;
      entry.completion = record;
    }
  
    function Context(tryLocsList) {
      // The root entry object (effectively a try statement without a catch
      // or a finally block) gives us a place to store values thrown from
      // locations where there is no enclosing try statement.
      this.tryEntries = [{ tryLoc: "root" }];
      tryLocsList.forEach(pushTryEntry, this);
      this.reset(true);
    }
  
    runtime.keys = function(object) {
      var keys = [];
      for (var key in object) {
        keys.push(key);
      }
      keys.reverse();
  
      // Rather than returning an object with a next method, we keep
      // things simple and return the next function itself.
      return function next() {
        while (keys.length) {
          var key = keys.pop();
          if (key in object) {
            next.value = key;
            next.done = false;
            return next;
          }
        }
  
        // To avoid creating an additional object, we just hang the .value
        // and .done properties off the next function object itself. This
        // also ensures that the minifier will not anonymize the function.
        next.done = true;
        return next;
      };
    };
  
    function values(iterable) {
      if (iterable) {
        var iteratorMethod = iterable[iteratorSymbol];
        if (iteratorMethod) {
          return iteratorMethod.call(iterable);
        }
  
        if (typeof iterable.next === "function") {
          return iterable;
        }
  
        if (!isNaN(iterable.length)) {
          var i = -1, next = function next() {
            while (++i < iterable.length) {
              if (hasOwn.call(iterable, i)) {
                next.value = iterable[i];
                next.done = false;
                return next;
              }
            }
  
            next.value = undefined;
            next.done = true;
  
            return next;
          };
  
          return next.next = next;
        }
      }
  
      // Return an iterator with no values.
      return { next: doneResult };
    }
    runtime.values = values;
  
    function doneResult() {
      return { value: undefined, done: true };
    }
  
    Context.prototype = {
      constructor: Context,
  
      reset: function(skipTempReset) {
        this.prev = 0;
        this.next = 0;
        // Resetting context._sent for legacy support of Babel's
        // function.sent implementation.
        this.sent = this._sent = undefined;
        this.done = false;
        this.delegate = null;
  
        this.method = "next";
        this.arg = undefined;
  
        this.tryEntries.forEach(resetTryEntry);
  
        if (!skipTempReset) {
          for (var name in this) {
            // Not sure about the optimal order of these conditions:
            if (name.charAt(0) === "t" &&
                hasOwn.call(this, name) &&
                !isNaN(+name.slice(1))) {
              this[name] = undefined;
            }
          }
        }
      },
  
      stop: function() {
        this.done = true;
  
        var rootEntry = this.tryEntries[0];
        var rootRecord = rootEntry.completion;
        if (rootRecord.type === "throw") {
          throw rootRecord.arg;
        }
  
        return this.rval;
      },
  
      dispatchException: function(exception) {
        if (this.done) {
          throw exception;
        }
  
        var context = this;
        function handle(loc, caught) {
          record.type = "throw";
          record.arg = exception;
          context.next = loc;
  
          if (caught) {
            // If the dispatched exception was caught by a catch block,
            // then let that catch block handle the exception normally.
            context.method = "next";
            context.arg = undefined;
          }
  
          return !! caught;
        }
  
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          var record = entry.completion;
  
          if (entry.tryLoc === "root") {
            // Exception thrown outside of any try block that could handle
            // it, so set the completion value of the entire function to
            // throw the exception.
            return handle("end");
          }
  
          if (entry.tryLoc <= this.prev) {
            var hasCatch = hasOwn.call(entry, "catchLoc");
            var hasFinally = hasOwn.call(entry, "finallyLoc");
  
            if (hasCatch && hasFinally) {
              if (this.prev < entry.catchLoc) {
                return handle(entry.catchLoc, true);
              } else if (this.prev < entry.finallyLoc) {
                return handle(entry.finallyLoc);
              }
  
            } else if (hasCatch) {
              if (this.prev < entry.catchLoc) {
                return handle(entry.catchLoc, true);
              }
  
            } else if (hasFinally) {
              if (this.prev < entry.finallyLoc) {
                return handle(entry.finallyLoc);
              }
  
            } else {
              throw new Error("try statement without catch or finally");
            }
          }
        }
      },
  
      abrupt: function(type, arg) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc <= this.prev &&
              hasOwn.call(entry, "finallyLoc") &&
              this.prev < entry.finallyLoc) {
            var finallyEntry = entry;
            break;
          }
        }
  
        if (finallyEntry &&
            (type === "break" ||
             type === "continue") &&
            finallyEntry.tryLoc <= arg &&
            arg <= finallyEntry.finallyLoc) {
          // Ignore the finally entry if control is not jumping to a
          // location outside the try/catch block.
          finallyEntry = null;
        }
  
        var record = finallyEntry ? finallyEntry.completion : {};
        record.type = type;
        record.arg = arg;
  
        if (finallyEntry) {
          this.method = "next";
          this.next = finallyEntry.finallyLoc;
          return ContinueSentinel;
        }
  
        return this.complete(record);
      },
  
      complete: function(record, afterLoc) {
        if (record.type === "throw") {
          throw record.arg;
        }
  
        if (record.type === "break" ||
            record.type === "continue") {
          this.next = record.arg;
        } else if (record.type === "return") {
          this.rval = this.arg = record.arg;
          this.method = "return";
          this.next = "end";
        } else if (record.type === "normal" && afterLoc) {
          this.next = afterLoc;
        }
  
        return ContinueSentinel;
      },
  
      finish: function(finallyLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.finallyLoc === finallyLoc) {
            this.complete(entry.completion, entry.afterLoc);
            resetTryEntry(entry);
            return ContinueSentinel;
          }
        }
      },
  
      "catch": function(tryLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc === tryLoc) {
            var record = entry.completion;
            if (record.type === "throw") {
              var thrown = record.arg;
              resetTryEntry(entry);
            }
            return thrown;
          }
        }
  
        // The context.catch method must only be called with a location
        // argument that corresponds to a known catch block.
        throw new Error("illegal catch attempt");
      },
  
      delegateYield: function(iterable, resultName, nextLoc) {
        this.delegate = {
          iterator: values(iterable),
          resultName: resultName,
          nextLoc: nextLoc
        };
  
        if (this.method === "next") {
          // Deliberately forget the last sent value so that we don't
          // accidentally pass it on to the delegate.
          this.arg = undefined;
        }
  
        return ContinueSentinel;
      }
    };
  })(
    // Among the various tricks for obtaining a reference to the global
    // object, this seems to be the most reliable technique that does not
    // use indirect eval (which violates Content Security Policy).
    typeof global === "object" ? global :
    typeof window === "object" ? window :
    typeof self === "object" ? self : this
  );
  
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"_process":298}],300:[function(require,module,exports){
  // Since [immediate](https://github.com/calvinmetcalf/immediate) is
  //   not doing the trick for our WebSQL transactions (at least in Node),
  //   we are forced to make the promises run fully synchronously.
  
  function isPromise(p) {
    return p && typeof p.then === 'function';
  }
  function addReject(prom, reject) {
    prom.then(null, reject) // Use this style for sake of non-Promise thenables (e.g., jQuery Deferred)
  }
  
  // States
  var PENDING = 2,
      FULFILLED = 0, // We later abuse these as array indices
      REJECTED = 1;
  
  function SyncPromise(fn) {
    var self = this;
    self.v = 0; // Value, this will be set to either a resolved value or rejected reason
    self.s = PENDING; // State of the promise
    self.c = [[],[]]; // Callbacks c[0] is fulfillment and c[1] contains rejection callbacks
    function transist(val, state) {
      self.v = val;
      self.s = state;
      self.c[state].forEach(function(fn) { fn(val); });
      // Release memory, but if no handlers have been added, as we
      //   assume that we will resolve/reject (truly) synchronously
      //   and thus we avoid flagging checks about whether we've
      //   already resolved/rejected.
      if (self.c[state].length) self.c = null;
    }
    function resolve(val) {
      if (!self.c) {
        // Already resolved (or will be resolved), do nothing.
      } else if (isPromise(val)) {
        addReject(val.then(resolve), reject);
      } else {
        transist(val, FULFILLED);
      }
    }
    function reject(reason) {
      if (!self.c) {
        // Already resolved (or will be resolved), do nothing.
      } else if (isPromise(reason)) {
        addReject(reason.then(reject), reject);
      } else {
        transist(reason, REJECTED);
      }
    }
    try {
      fn(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  
  var prot = SyncPromise.prototype;
  
  prot.then = function(cb, errBack) {
    var self = this;
    return new SyncPromise(function(resolve, reject) {
      var rej = typeof errBack === 'function' ? errBack : reject;
      function settle() {
        try {
          resolve(cb ? cb(self.v) : self.v);
        } catch(e) {
          rej(e);
        }
      }
      if (self.s === FULFILLED) {
        settle();
      } else if (self.s === REJECTED) {
        rej(self.v);
      } else {
        self.c[FULFILLED].push(settle);
        self.c[REJECTED].push(rej);
      }
    });
  };
  
  prot.catch = function(cb) {
    var self = this;
    return new SyncPromise(function(resolve, reject) {
      function settle() {
        try {
          resolve(cb(self.v));
        } catch(e) {
          reject(e);
        }
      }
      if (self.s === REJECTED) {
        settle();
      } else if (self.s === FULFILLED) {
        resolve(self.v);
      } else {
        self.c[REJECTED].push(settle);
        self.c[FULFILLED].push(resolve);
      }
    });
  };
  
  SyncPromise.all = function(promises) {
    return new SyncPromise(function(resolve, reject, l) {
      l = promises.length;
      var hasPromises = false;
      var newPromises = [];
      if (!l) {
          resolve(newPromises);
          return;
      }
      promises.forEach(function(p, i) {
        if (isPromise(p)) {
          addReject(p.then(function(res) {
            newPromises[i] = res;
            --l || resolve(newPromises);
          }), reject);
        } else {
          newPromises[i] = p;
          --l || resolve(promises);
        }
      });
    });
  };
  
  SyncPromise.race = function(promises) {
    var resolved = false;
    return new SyncPromise(function(resolve, reject) {
      promises.some(function(p, i) {
        if (isPromise(p)) {
          addReject(p.then(function(res) {
            if (resolved) {
              return;
            }
            resolve(res);
            resolved = true;
          }), reject);
        } else {
          resolve(p);
          resolved = true;
          return true;
        }
      });
    });
  };
  
  SyncPromise.resolve = function(val) {
    return new SyncPromise(function(resolve, reject) {
      resolve(val);
    });
  };
  
  SyncPromise.reject = function(val) {
    return new SyncPromise(function(resolve, reject) {
      reject(val);
    });
  };
  module.exports = SyncPromise;
  
  },{}],301:[function(require,module,exports){
  var keys = Object.keys,
      isArray = Array.isArray,
      toString = ({}.toString),
      getProto = Object.getPrototypeOf,
      hasOwn = ({}.hasOwnProperty),
      fnToString = hasOwn.toString;
  
  function toStringTag (val) {
      return toString.call(val).slice(8, -1);
  }
  
  function hasConstructorOf (a, b) {
      if (!a) {
          return false;
      }
      var proto = getProto(a);
      if (!proto) {
          return false;
      }
      var Ctor = hasOwn.call(proto, 'constructor') && proto.constructor;
      if (typeof Ctor !== 'function') {
          return b === null;
      }
      return typeof Ctor === 'function' && b !== null && fnToString.call(Ctor) === fnToString.call(b);
  }
  
  function isPlainObject (val) { // Mirrors jQuery's
      if (!val || toStringTag(val) !== 'Object') {
          return false;
      }
  
      var proto = getProto(val);
      if (!proto) { // `Object.create(null)`
          return true;
      }
  
      return hasConstructorOf(val, Object);
  }
  
  /* Typeson - JSON with types
      * License: The MIT License (MIT)
      * Copyright (c) 2016 David Fahlander
      */
  
  /** An instance of this class can be used to call stringify() and parse().
   * Typeson resolves cyclic references by default. Can also be extended to
   * support custom types using the register() method.
   *
   * @constructor
   * @param {{cyclic: boolean}} [options] - if cyclic (default true), cyclic references will be handled gracefully.
   */
  function Typeson (options) {
      // Replacers signature: replace (value). Returns falsy if not replacing. Otherwise ["Date", value.getTime()]
      var replacers = [];
      // Revivers: map {type => reviver}. Sample: {"Date": value => new Date(value)}
      var revivers = {};
  
      /** Types registered via register() */
      var regTypes = this.types = {};
  
      /** Seraialize given object to Typeson.
       *
       * Arguments works identical to those of JSON.stringify().
       */
      this.stringify = function (obj, replacer, space) { // replacer here has nothing to do with our replacers.
          return JSON.stringify (encapsulate(obj), replacer, space);
      };
  
      /** Parse Typeson back into an obejct.
       *
       * Arguments works identical to those of JSON.parse().
       */
      this.parse = function (text, reviver) {
          return revive (JSON.parse (text, reviver)); // This reviver has nothing to do with our revivers.
      };
  
      /** Encapsulate a complex object into a plain Object by replacing registered types with
       * plain objects representing the types data.
       *
       * This method is used internally by Typeson.stringify().
       * @param {Object} obj - Object to encapsulate.
       */
      var encapsulate = this.encapsulate = function (obj, stateObj) {
          var types = {},
              refObjs=[], // For checking cyclic references
              refKeys=[]; // For checking cyclic references
          // Clone the object deeply while at the same time replacing any special types or cyclic reference:
          var cyclic = options && ('cyclic' in options) ? options.cyclic : true;
          var ret = _encapsulate ('', obj, cyclic, stateObj || {});
          // Add $types to result only if we ever bumped into a special type
          if (keys(types).length) {
              // Special if array (or primitive) was serialized because JSON would ignore custom $types prop on it.
              if (!ret || !isPlainObject(ret) || ret.$types) return {$:ret, $types: {$: types}};
              ret.$types = types;
          }
          return ret;
  
          function _encapsulate (keypath, value, cyclic, stateObj) {
              var $typeof = typeof value;
              if ($typeof in {string:1, boolean:1, number:1, undefined:1 })
                  return value === undefined || ($typeof === 'number' &&
                      (isNaN(value) || value === -Infinity || value === Infinity)) ?
                          replace(keypath, value, stateObj) :
                          value;
              if (value === null) return value;
              if (cyclic) {
                  // Options set to detect cyclic references and be able to rewrite them.
                  var refIndex = refObjs.indexOf(value);
                  if (refIndex < 0) {
                      if (cyclic === true) {
                          refObjs.push(value);
                          refKeys.push(keypath);
                      }
                  } else {
                      types[keypath] = "#";
                      return '#'+refKeys[refIndex];
                  }
              }
              var isPlainObj = isPlainObject(value);
              var replaced = isPlainObj ?
                  value : // Optimization: if plain object, don't try finding a replacer
                  replace(keypath, value, stateObj);
              if (replaced !== value) return replaced;
              var clone;
              var isArr = isArray(value);
              if (isPlainObj)
                  clone = {};
              else if (isArr)
                  clone = new Array(value.length);
              else return value; // Only clone vanilla objects and arrays.
              // Iterate object or array
              keys(value).forEach(function (key) {
                  var val = _encapsulate(keypath + (keypath ? '.':'') + key, value[key], cyclic, {ownKeys: true});
                  if (val !== undefined) clone[key] = val;
              });
              // Iterate array for non-own properties (we can't replace the prior loop though as it iterates non-integer keys)
              if (isArr) {
                  for (var i = 0, vl = value.length; i < vl; i++) {
                      if (!(i in value)) {
                          var val = _encapsulate(keypath + (keypath ? '.':'') + i, value[i], cyclic, {ownKeys: false});
                          if (val !== undefined) clone[i] = val;
                      }
                  }
              }
              return clone;
          }
  
          function replace (key, value, stateObj) {
              // Encapsulate registered types
              var i = replacers.length;
              while (i--) {
                  if (replacers[i].test(value, stateObj)) {
                      var type = replacers[i].type;
                      if (revivers[type]) {
                          // Record the type only if a corresponding reviver exists.
                          // This is to support specs where only replacement is done.
                          // For example ensuring deep cloning of the object, or
                          // replacing a type to its equivalent without the need to revive it.
                          var existing = types[key];
                          // type can comprise an array of types (see test shouldSupportIntermediateTypes)
                          types[key] = existing ? [type].concat(existing) : type;
                      }
                      // Now, also traverse the result in case it contains it own types to replace
                      return _encapsulate(key, replacers[i].replace(value, stateObj), cyclic && "readonly", stateObj);
                  }
              }
              return value;
          }
      };
  
      /** Revive an encapsulated object.
       * This method is used internally by JSON.parse().
       * @param {Object} obj - Object to revive. If it has $types member, the properties that are listed there
       * will be replaced with its true type instead of just plain objects.
       */
      var revive = this.revive = function (obj) {
          var types = obj && obj.$types,
              ignore$Types = true;
          if (!types) return obj; // No type info added. Revival not needed.
          if (types.$ && isPlainObject(types.$)) {
              // Special when root object is not a trivial Object, it will be encapsulated in $.
              obj = obj.$;
              types = types.$;
              ignore$Types = false;
          }
          var ret = _revive ('', obj);
          return hasConstructorOf(ret, Undefined) ? undefined : ret;
  
          function _revive (keypath, value, target) {
              if (ignore$Types && keypath === '$types') return;
              var type = types[keypath];
              if (value && (isPlainObject(value) || isArray(value))) {
                  var clone = isArray(value) ? new Array(value.length) : {};
                  // Iterate object or array
                  keys(value).forEach(function (key) {
                      var val = _revive(keypath + (keypath ? '.':'') + key, value[key], target || clone);
                      if (hasConstructorOf(val, Undefined)) clone[key] = undefined;
                      else if (val !== undefined) clone[key] = val;
                  });
                  value = clone;
              }
              if (!type) return value;
              if (type === '#') return getByKeyPath(target, value.substr(1));
              return [].concat(type).reduce(function(val, type) {
                  var reviver = revivers[type];
                  if (!reviver) throw new Error ("Unregistered type: " + type);
                  return reviver(val);
              }, value);
          }
      };
  
      /** Register types.
       * For examples how to use this method, see https://github.com/dfahlander/typeson-registry/tree/master/types
       * @param {Array.<Object.<string,Function[]>>} typeSpec - Types and their functions [test, encapsulate, revive];
       */
      this.register = function (typeSpecSets) {
          [].concat(typeSpecSets).forEach(function R (typeSpec) {
              if (isArray(typeSpec)) return typeSpec.map(R); // Allow arrays of arrays of arrays...
              typeSpec && keys(typeSpec).forEach(function (typeId) {
                  var spec = typeSpec[typeId],
                      existingReplacer = replacers.filter(function(r){ return r.type === typeId; });
                  if (existingReplacer.length) {
                      // Remove existing spec and replace with this one.
                      replacers.splice(replacers.indexOf(existingReplacer[0]), 1);
                      delete revivers[typeId];
                      delete regTypes[typeId];
                  }
                  if (spec) {
                      if (typeof spec === 'function') {
                          // Support registering just a class without replacer/reviver
                          var Class = spec;
                          spec = [
                              function(x){return x.constructor === Class;},
                              function(x){return assign({}, x)},
                              function(x){return assign(Object.create(Class.prototype), x)}
                          ];
                      }
                      replacers.push({
                          type: typeId,
                          test: spec[0],
                          replace: spec[1]
                      });
                      if (spec[2]) revivers[typeId] = spec[2];
                      regTypes[typeId] = spec; // Record to be retrieved via public types property.
                  }
              });
          });
          return this;
      };
  }
  
  function assign(t,s) {
      keys(s).map(function(k){t[k]=s[k];});
      return t;
  }
  
  /** getByKeyPath() utility */
  function getByKeyPath (obj, keyPath) {
      if (keyPath === '') return obj;
      var period = keyPath.indexOf('.');
      if (period !== -1) {
          var innerObj = obj[keyPath.substr(0, period)];
          return innerObj === undefined ? undefined : getByKeyPath(innerObj, keyPath.substr(period + 1));
      }
      return obj[keyPath];
  }
  
  function Undefined () {}
  Typeson.Undefined = Undefined;
  Typeson.toStringTag = toStringTag;
  Typeson.hasConstructorOf = hasConstructorOf;
  
  module.exports = Typeson;
  
  },{}],302:[function(require,module,exports){
  module.exports = require('./structured-cloning').concat({checkDataCloneException: [function (val) {
      // Should also throw with:
      // 1. `IsDetachedBuffer` (a process not called within the ECMAScript spec)
      // 2. `IsCallable` (covered by `typeof === 'function'` or a function's `toStringTag`)
      // 3. internal slots besides [[Prototype]] or [[Extensible]] (e.g., [[PromiseState]] or [[WeakMapData]])
      // 4. exotic object (e.g., `Proxy`) (which does not have default behavior for one or more of the
      //      essential internal methods that are limited to the following for non-function objects (we auto-exclude functions): 
      //      [[GetPrototypeOf]],[[SetPrototypeOf]],[[IsExtensible]],[[PreventExtensions]],[[GetOwnProperty]],
      //      [[DefineOwnProperty]],[[HasProperty]],[[Get]],[[Set]],[[Delete]],[[OwnPropertyKeys]]);
      //      except for the standard, built-in exotic objects, we'd need to know whether these methods had distinct behaviors
      var stringTag = ({}.toString.call(val).slice(8, -1));
      if ([
              'symbol', // Symbol's `toStringTag` is only "Symbol" for its initial value, so we check `typeof`
              'function' // All functions including bound function exotic objects
          ].includes(typeof val) ||
          [
              'Arguments', // A non-array exotic object
              'Module', // A non-array exotic object
              'Error', // `Error` and other errors have the [[ErrorData]] internal slot and give "Error"
              'Proxy', // Proper `toStringTag` not yet implemented in Chrome/Firefox/Node
              'Promise', // Promise instances have an extra slot ([[PromiseState]]) but not throwing in Chrome `postMessage`
              'WeakMap', // WeakMap instances have an extra slot ([[WeakMapData]]) but not throwing in Chrome `postMessage`
              'WeakSet' // WeakSet instances have an extra slot ([[WeakSetData]]) but not throwing in Chrome `postMessage`
          ].includes(stringTag) ||
          val === Object.prototype || // A non-array exotic object but not throwing in Chrome `postMessage`
          (val && typeof val === 'object' && typeof val.nodeType === 'number' && typeof val.insertBefore === 'function') // Duck-type DOM node objects (non-array exotic? objects which cannot be cloned by the SCA)
      ) {
          throw new DOMException('The object cannot be cloned.', 'DataCloneError');
      }
      return false;
  }]});
  
  },{"./structured-cloning":303}],303:[function(require,module,exports){
  /* This preset includes types for the Structured Cloning Algorithm. */
  module.exports = [
      // Todo: Might also register `ImageBitmap` and synchronous `Blob`/`File`/`FileList`
      // ES5
      require('../types/user-object'), // Processed last
      require('../types/undefined'),
      require('../types/primitive-objects'),
      require('../types/special-numbers'),
      require('../types/date'),
      require('../types/regexp'),
      // ES2015 (ES6)
      typeof Map === 'function' && require('../types/map'),
      typeof Set === 'function' && require('../types/set'),
      typeof ArrayBuffer === 'function' && require('../types/arraybuffer'),
      typeof Uint8Array === 'function' && require('../types/typed-arrays'),
      typeof DataView === 'function' && require('../types/dataview'),
      typeof Intl !== 'undefined' && require('../types/intl-types'),
      // Non-built-ins
      require('../types/imagedata')
  ];
  
  },{"../types/arraybuffer":304,"../types/dataview":305,"../types/date":306,"../types/imagedata":307,"../types/intl-types":308,"../types/map":309,"../types/primitive-objects":310,"../types/regexp":311,"../types/set":312,"../types/special-numbers":313,"../types/typed-arrays":314,"../types/undefined":315,"../types/user-object":316}],304:[function(require,module,exports){
  var Typeson = require('typeson');
  var B64 = require ('base64-arraybuffer');
  
  exports.ArrayBuffer = [
      function test (x) { return Typeson.toStringTag(x) === 'ArrayBuffer';},
      function encapsulate (b) { return B64.encode(b); },
      function revive (b64) { return B64.decode(b64); }
  ];
  // See also typed-arrays!
  
  },{"base64-arraybuffer":2,"typeson":301}],305:[function(require,module,exports){
  var Typeson = require('typeson');
  var B64 = require ('base64-arraybuffer');
  exports.DataView = [
      function (x) { return Typeson.toStringTag(x) === 'DataView'; },
      function (dw) { return { buffer: B64.encode(dw.buffer), byteOffset: dw.byteOffset, byteLength: dw.byteLength }; },
      function (obj) { return new DataView(B64.decode(obj.buffer), obj.byteOffset, obj.byteLength); }
  ];
  
  },{"base64-arraybuffer":2,"typeson":301}],306:[function(require,module,exports){
  var Typeson = require('typeson');
  exports.Date = [
      function (x) { return Typeson.toStringTag(x) === 'Date'; },
      function (date) { return date.getTime(); },
      function (time) { return new Date(time); }
  ];
  
  },{"typeson":301}],307:[function(require,module,exports){
  /** ImageData is browser / DOM specific.
   * Requires arraybuffer.js in order for the returned Uint8ClampedArray to be encapsulated as well,
   * or if use with socket.io, socket.io will take care of that.
  */
  var Typeson = require('typeson');
  exports.ImageData = [
      function (x) { return Typeson.toStringTag(x) === 'ImageData'; },
      function (d) {
          return {
              array: Array.from(d.data), // Ensure `length` gets preserved for revival
              width: d.width,
              height: d.height
          };
      },
      function (o) {return new ImageData(new Uint8ClampedArray(o.array), o.width, o.height);}
  ];
  
  },{"typeson":301}],308:[function(require,module,exports){
  var Typeson = require('typeson');
  exports["Intl.Collator"] = [
      function (x) { return Typeson.hasConstructorOf(x, Intl.Collator); },
      function (c) { return c.resolvedOptions(); },
      function (options) { return new Intl.Collator(options.locale, options); }
  ];
  
  exports["Intl.DateTimeFormat"] = [
      function (x) { return Typeson.hasConstructorOf(x, Intl.DateTimeFormat); },
      function (dtf) { return dtf.resolvedOptions(); },
      function (options) { return new Intl.DateTimeFormat(options.locale, options); }
  ];
  
  exports["Intl.NumberFormat"] = [
      function (x) { return Typeson.hasConstructorOf(x, Intl.NumberFormat); },
      function (nf) { return nf.resolvedOptions(); },
      function (options) { return new Intl.NumberFormat(options.locale, options); }
  ];
  
  },{"typeson":301}],309:[function(require,module,exports){
  var Typeson = require('typeson');
  var makeArray = require('../utils/array-from-iterator');
  exports.Map = [
      function (x) { return Typeson.toStringTag(x) === 'Map'; },
      function (map) { return makeArray(map.entries()); },
      function (entries) { return new Map(entries); }
  ];
  
  },{"../utils/array-from-iterator":317,"typeson":301}],310:[function(require,module,exports){
  // This module is for objectified primitives (such as new Number(3) or
  // new String("foo"))
  var Typeson = require('typeson');
  module.exports = {
      // String Object (not primitive string which need no type spec)
      StringObject: [
          function (x) { return Typeson.toStringTag(x) === 'String' && typeof x === 'object'; },
          function (s) { return String(s); }, // convert to primitive string
          function (s) { return new String(s); } // Revive to an objectified string
      ],
      // Boolean Object (not primitive boolean which need no type spec)
      BooleanObject: [
          function (x) { return Typeson.toStringTag(x) === 'Boolean' && typeof x === 'object'; },
          function (b) { return Boolean(b); }, // convert to primitive boolean
          function (b) { return new Boolean(b); } // Revive to an objectified Boolean
      ],
      // Number Object (not primitive number which need no type spec)
      NumberObject: [
          function (x) { return Typeson.toStringTag(x) === 'Number' && typeof x === 'object'; },
          function (n) { return Number(n); }, // convert to primitive number
          function (n) { return new Number(n); } // Revive to an objectified number
      ]
  };
  
  },{"typeson":301}],311:[function(require,module,exports){
  var Typeson = require('typeson');
  exports.RegExp = [
      function (x) { return Typeson.toStringTag(x) === 'RegExp'; },
      function (rexp) {
          return {
              source: rexp.source,
              flags: (rexp.global?'g':'')+(rexp.ignoreCase?'i':'')+(rexp.multiline?'m':'')
          };
      },
      function (data) { return new RegExp (data.source, data.flags); }
  ];
  
  },{"typeson":301}],312:[function(require,module,exports){
  var Typeson = require('typeson');
  var makeArray = require('../utils/array-from-iterator');
  exports.Set = [
      function (x) { return Typeson.toStringTag(x) === 'Set'; },
      function (set) { return makeArray(set.values()); },
      function (values) { return new Set(values); }
  ];
  
  },{"../utils/array-from-iterator":317,"typeson":301}],313:[function(require,module,exports){
  exports.SpecialNumber = [
      function (x) { return typeof x === 'number' && (isNaN(x) || x === Infinity || x === -Infinity); },
      function (n) { return isNaN(n) ? "NaN" : n > 0 ? "Infinity" : "-Infinity" },
      function (s) { return {NaN: NaN, Infinity: Infinity, "-Infinity": -Infinity}[s];}
  ];
  
  },{}],314:[function(require,module,exports){
  (function (global){
  var Typeson = require('typeson');
  var B64 = require ('base64-arraybuffer');
  
  var _global = typeof self === 'undefined' ? global : self;
  
  [
      "Int8Array",
      "Uint8Array",
      "Uint8ClampedArray",
      "Int16Array",
      "Uint16Array",
      "Int32Array",
      "Uint32Array",
      "Float32Array",
      "Float64Array"
  ].forEach(function (typeName) {
      var TypedArray = _global[typeName];
      if (TypedArray) exports[typeName] = [
          function test (x) { return Typeson.toStringTag(x) === typeName; },
          function encapsulate (a) { return B64.encode (a.buffer, a.byteOffset, a.byteLength); },
          function revive (b64) { return new TypedArray (B64.decode(b64)); }
      ];
  });
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"base64-arraybuffer":2,"typeson":301}],315:[function(require,module,exports){
  var Typeson = require('typeson');
  module.exports = {
      undefined: [
          function (x, stateObj) { return typeof x === 'undefined' && (stateObj.ownKeys || !('ownKeys' in stateObj)); },
          function (n) { return null; },
          function (s) { return new Typeson.Undefined();} // Will add `undefined` (returning `undefined` would instead avoid explicitly setting)
      ],
      sparseUndefined: [
          function (x, stateObj) { return typeof x === 'undefined' && stateObj.ownKeys === false; },
          function (n) { return null; },
          function (s) { return undefined;} // Will avoid adding anything
      ]
  };
  
  },{"typeson":301}],316:[function(require,module,exports){
  var Typeson = require('typeson');
  var getProto = Object.getPrototypeOf;
  
  function isUserObject (val) {
      if (!val || Typeson.toStringTag(val) !== 'Object') {
          return false;
      }
  
      var proto = getProto(val);
      if (!proto) { // `Object.create(null)`
          return true;
      }
      return Typeson.hasConstructorOf(val, Object) || isUserObject(proto);
  }
  
  exports.userObjects = [
      function (x, stateObj) { return isUserObject(x); },
      function (n) { return Object.assign({}, n); },
      function (s) { return s;}
  ];
  
  },{"typeson":301}],317:[function(require,module,exports){
  module.exports = Array.from || function (iterator) {
     var res = [];
     for (var i=iterator.next(); !i.done; i = iterator.next()) {
        res.push(i.value);
     }
     return res;
  }
  
  },{}],318:[function(require,module,exports){
  arguments[4][301][0].apply(exports,arguments)
  },{"dup":301}],319:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  var map = {};
  var CFG = {};
  
  [
  // Boolean for verbose reporting
  'DEBUG', // Effectively defaults to false (ignored unless true)
  
  // Used when setting global shims to determine whether to try to add
  //   other globals shimmed by the library (`ShimDOMException`, `ShimDOMStringList`,
  //   `ShimEvent`, `ShimCustomEvent`, `ShimEventTarget`)
  'addNonIDBGlobals', // Effectively defaults to false (ignored unless true)
  
  // Determines whether the slow-performing `Object.setPrototypeOf` calls required
  //    for full WebIDL compliance will be used. Probably only needed for testing
  //    or environments where full introspection on class relationships is required;
  //    see http://stackoverflow.com/questions/41927589/rationales-consequences-of-webidl-class-inheritance-requirements
  'fullIDLSupport', // Effectively defaults to false (ignored unless true)
  
  // Used by `IDBCursor` continue methods for number of records to cache;
  'cursorPreloadPackSize', //  Defaults to 100
  
  // See optional API (`shimIndexedDB.__setUnicodeIdentifiers`);
  //    or just use the Unicode builds which invoke this method
  //    automatically using the large, fully spec-compliant, regular
  //    expression strings of `src/UnicodeIdentifiers.js`)
  'UnicodeIDStart', // In the non-Unicode builds, defaults to /[$A-Z_a-z]/
  'UnicodeIDContinue', // In the non-Unicode builds, defaults to /[$0-9A-Z_a-z]/
  
  // -----------SQL CONFIG----------
  // Object (`window` in the browser) on which there may be an
  //  `openDatabase` method (if any) for WebSQL. (The browser
  //  throws if attempting to call `openDatabase` without the window
  //  so this is why the config doesn't just allow the function.)
  'win', // Defaults to `window` or `self` in browser builds or
  // a singleton object with the `openDatabase` method set to
  // the "websql" package in Node.
  
  // For internal `openDatabase` calls made by `IDBFactory` methods;
  //  per the WebSQL spec, "User agents are expected to use the display name
  //  and the estimated database size to optimize the user experience.
  //  For example, a user agent could use the estimated size to suggest an
  //  initial quota to the user. This allows a site that is aware that it
  //  will try to use hundreds of megabytes to declare this upfront, instead
  //  of the user agent prompting the user for permission to increase the
  //  quota every five megabytes."
  'DEFAULT_DB_SIZE', // Defaults to (4 * 1024 * 1024) or (25 * 1024 * 1024) in Safari
  
  // Overcoming limitations with node-sqlite3/storing database name on file systems
  // https://en.wikipedia.org/wiki/Filename#Reserved_characters_and_words
  'escapeDatabaseName', // Defaults to prefixing database with `D_`, escaping
  //   `databaseCharacterEscapeList`, escaping NUL, and
  //   escaping upper case letters, as well as enforcing
  //   `databaseNameLengthLimit`
  'unescapeDatabaseName', // Not used internally; usable as a convenience method
  'databaseCharacterEscapeList', // Defaults to global regex representing the following
  // (characters nevertheless commonly reserved in modern, Unicode-supporting
  // systems): 0x00-0x1F 0x7F " * / : < > ? \ |
  'databaseNameLengthLimit', // Defaults to 254 (shortest typical modern file length limit)
  
  // Optional Node WebSQL config
  'sqlBusyTimeout', // Defaults to 1000
  'sqlTrace', // Callback not used by default
  'sqlProfile' // Callback not used by default
  ].forEach(function (prop) {
      Object.defineProperty(CFG, prop, {
          get: function get() {
              return map[prop];
          },
          set: function set(val) {
              map[prop] = val;
          }
      });
  });
  
  exports.default = CFG;
  module.exports = exports['default'];
  
  },{}],320:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.webSQLErrback = exports.createDOMException = exports.ShimDOMException = exports.findError = exports.logError = undefined;
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  /**
   * Creates a native DOMException, for browsers that support it
   * @returns {DOMException}
   */
  function createNativeDOMException(name, message) {
      return new DOMException.prototype.constructor(message, name || 'DOMException');
  }
  
  var codes = { // From web-platform-tests testharness.js name_code_map (though not in new spec)
      IndexSizeError: 1,
      HierarchyRequestError: 3,
      WrongDocumentError: 4,
      InvalidCharacterError: 5,
      NoModificationAllowedError: 7,
      NotFoundError: 8,
      NotSupportedError: 9,
      InUseAttributeError: 10,
      InvalidStateError: 11,
      SyntaxError: 12,
      InvalidModificationError: 13,
      NamespaceError: 14,
      InvalidAccessError: 15,
      TypeMismatchError: 17,
      SecurityError: 18,
      NetworkError: 19,
      AbortError: 20,
      URLMismatchError: 21,
      QuotaExceededError: 22,
      TimeoutError: 23,
      InvalidNodeTypeError: 24,
      DataCloneError: 25,
  
      EncodingError: 0,
      NotReadableError: 0,
      UnknownError: 0,
      ConstraintError: 0,
      DataError: 0,
      TransactionInactiveError: 0,
      ReadOnlyError: 0,
      VersionError: 0,
      OperationError: 0,
      NotAllowedError: 0
  };
  
  var legacyCodes = {
      INDEX_SIZE_ERR: 1,
      DOMSTRING_SIZE_ERR: 2,
      HIERARCHY_REQUEST_ERR: 3,
      WRONG_DOCUMENT_ERR: 4,
      INVALID_CHARACTER_ERR: 5,
      NO_DATA_ALLOWED_ERR: 6,
      NO_MODIFICATION_ALLOWED_ERR: 7,
      NOT_FOUND_ERR: 8,
      NOT_SUPPORTED_ERR: 9,
      INUSE_ATTRIBUTE_ERR: 10,
      INVALID_STATE_ERR: 11,
      SYNTAX_ERR: 12,
      INVALID_MODIFICATION_ERR: 13,
      NAMESPACE_ERR: 14,
      INVALID_ACCESS_ERR: 15,
      VALIDATION_ERR: 16,
      TYPE_MISMATCH_ERR: 17,
      SECURITY_ERR: 18,
      NETWORK_ERR: 19,
      ABORT_ERR: 20,
      URL_MISMATCH_ERR: 21,
      QUOTA_EXCEEDED_ERR: 22,
      TIMEOUT_ERR: 23,
      INVALID_NODE_TYPE_ERR: 24,
      DATA_CLONE_ERR: 25
  };
  
  function createNonNativeDOMExceptionClass() {
      function DOMException(message, name) {
          // const err = Error.prototype.constructor.call(this, message); // Any use to this? Won't set this.message
          this[Symbol.toStringTag] = 'DOMException';
          this._code = name in codes ? codes[name] : legacyCodes[name] || 0;
          this._name = name || 'Error';
          this._message = message === undefined ? '' : '' + message; // Not String() which converts Symbols
          Object.defineProperty(this, 'code', {
              configurable: true,
              enumerable: true,
              writable: true,
              value: this._code
          });
          if (name !== undefined) {
              Object.defineProperty(this, 'name', {
                  configurable: true,
                  enumerable: true,
                  writable: true,
                  value: this._name
              });
          }
          if (message !== undefined) {
              Object.defineProperty(this, 'message', {
                  configurable: true,
                  enumerable: false,
                  writable: true,
                  value: this._message
              });
          }
      }
  
      // Necessary for W3C tests which complains if `DOMException` has properties on its "own" prototype
      var DummyDOMException = function DOMException() {};
      DummyDOMException.prototype = new Error(); // Intended for subclassing
      ['name', 'message'].forEach(function (prop) {
          Object.defineProperty(DummyDOMException.prototype, prop, {
              enumerable: true,
              get: function get() {
                  if (!(this instanceof DOMException || this instanceof DummyDOMException || this instanceof Error)) {
                      throw new TypeError('Illegal invocation');
                  }
                  return this['_' + prop];
              }
          });
      });
      // DOMException uses the same `toString` as `Error`
      Object.defineProperty(DummyDOMException.prototype, 'code', {
          configurable: true,
          enumerable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
      DOMException.prototype = new DummyDOMException();
  
      DOMException.prototype[Symbol.toStringTag] = 'DOMExceptionPrototype';
      Object.defineProperty(DOMException, 'prototype', {
          writable: false
      });
  
      Object.keys(codes).forEach(function (codeName) {
          Object.defineProperty(DOMException.prototype, codeName, {
              enumerable: true,
              configurable: false,
              value: codes[codeName]
          });
          Object.defineProperty(DOMException, codeName, {
              enumerable: true,
              configurable: false,
              value: codes[codeName]
          });
      });
      Object.keys(legacyCodes).forEach(function (codeName) {
          Object.defineProperty(DOMException.prototype, codeName, {
              enumerable: true,
              configurable: false,
              value: legacyCodes[codeName]
          });
          Object.defineProperty(DOMException, codeName, {
              enumerable: true,
              configurable: false,
              value: legacyCodes[codeName]
          });
      });
      Object.defineProperty(DOMException.prototype, 'constructor', {
          writable: true,
          configurable: true,
          enumerable: false,
          value: DOMException
      });
  
      return DOMException;
  }
  
  var ShimNonNativeDOMException = createNonNativeDOMExceptionClass();
  
  /**
   * Creates a generic Error object
   * @returns {Error}
   */
  function createNonNativeDOMException(name, message) {
      return new ShimNonNativeDOMException(message, name);
  }
  
  /**
   * Logs detailed error information to the console.
   * @param {string} name
   * @param {string} message
   * @param {string|Error|null} error
   */
  function logError(name, message, error) {
      if (_CFG2.default.DEBUG) {
          if (error && error.message) {
              error = error.message;
          }
  
          var method = typeof console.error === 'function' ? 'error' : 'log';
          console[method](name + ': ' + message + '. ' + (error || ''));
          console.trace && console.trace();
      }
  }
  
  function isErrorOrDOMErrorOrDOMException(obj) {
      return obj && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && // We don't use util.isObj here as mutual dependency causing problems in Babel with browser
      typeof obj.name === 'string';
  }
  
  /**
   * Finds the error argument.  This is useful because some WebSQL callbacks
   * pass the error as the first argument, and some pass it as the second argument.
   * @param {array} args
   * @returns {Error|DOMException|undefined}
   */
  function findError(args) {
      var err = void 0;
      if (args) {
          if (args.length === 1) {
              return args[0];
          }
          for (var i = 0; i < args.length; i++) {
              var arg = args[i];
              if (isErrorOrDOMErrorOrDOMException(arg)) {
                  return arg;
              }
              if (arg && typeof arg.message === 'string') {
                  err = arg;
              }
          }
      }
      return err;
  }
  
  function webSQLErrback(webSQLErr) {
      var name = void 0,
          message = void 0;
      switch (webSQLErr.code) {
          case 4:
              {
                  // SQLError.QUOTA_ERR
                  name = 'QuotaExceededError';
                  message = 'The operation failed because there was not enough remaining storage space, or the storage quota was reached and the user declined to give more space to the database.';
                  break;
              }
          /*
          // Should a WebSQL timeout treat as IndexedDB `TransactionInactiveError` or `UnknownError`?
          case 7: { // SQLError.TIMEOUT_ERR
              // All transaction errors abort later, so no need to mark inactive
              name = 'TransactionInactiveError';
              message = 'A request was placed against a transaction which is currently not active, or which is finished (Internal SQL Timeout).';
              break;
          }
          */
          default:
              {
                  name = 'UnknownError';
                  message = 'The operation failed for reasons unrelated to the database itself and not covered by any other errors.';
                  break;
              }
      }
      message += ' (' + webSQLErr.message + ')--(' + webSQLErr.code + ')';
      var err = createDOMException(name, message);
      err.sqlError = webSQLErr;
      return err;
  }
  
  var test = void 0,
      useNativeDOMException = false;
  
  // Test whether we can use the browser's native DOMException class
  try {
      test = createNativeDOMException('test name', 'test message');
      if (isErrorOrDOMErrorOrDOMException(test) && test.name === 'test name' && test.message === 'test message') {
          // Native DOMException works as expected
          useNativeDOMException = true;
      }
  } catch (e) {}
  
  var createDOMException = void 0,
      ShimDOMException = void 0;
  if (useNativeDOMException) {
      exports.ShimDOMException = ShimDOMException = DOMException;
      exports.createDOMException = createDOMException = function createDOMException(name, message, error) {
          logError(name, message, error);
          return createNativeDOMException(name, message);
      };
  } else {
      exports.ShimDOMException = ShimDOMException = ShimNonNativeDOMException;
      exports.createDOMException = createDOMException = function createDOMException(name, message, error) {
          logError(name, message, error);
          return createNonNativeDOMException(name, message);
      };
  }
  
  exports.logError = logError;
  exports.findError = findError;
  exports.ShimDOMException = ShimDOMException;
  exports.createDOMException = createDOMException;
  exports.webSQLErrback = webSQLErrback;
  
  },{"./CFG":319}],321:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _DOMStringList$protot;
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  var cleanInterface = false;
  
  var testObject = { test: true };
  // Test whether Object.defineProperty really works.
  if (Object.defineProperty) {
      try {
          Object.defineProperty(testObject, 'test', { enumerable: false });
          if (testObject.test) {
              cleanInterface = true;
          }
      } catch (e) {
          // Object.defineProperty does not work as intended.
      }
  }
  
  /**
   * Shim the DOMStringList object.
   *
   */
  var DOMStringList = function DOMStringList() {
      throw new TypeError('Illegal constructor');
  };
  DOMStringList.prototype = (_DOMStringList$protot = {
      constructor: DOMStringList,
      // Interface.
      contains: function contains(str) {
          if (!arguments.length) {
              throw new TypeError('DOMStringList.contains must be supplied a value');
          }
          return this._items.includes(str);
      },
      item: function item(key) {
          if (!arguments.length) {
              throw new TypeError('DOMStringList.item must be supplied a value');
          }
          if (key < 0 || key >= this.length || !Number.isInteger(key)) {
              return null;
          }
          return this._items[key];
      },
  
      // Helpers. Should only be used internally.
      clone: function clone() {
          var stringList = DOMStringList.__createInstance();
          stringList._items = this._items.slice();
          stringList._length = this.length;
          stringList.addIndexes();
          return stringList;
      },
      addIndexes: function addIndexes() {
          for (var i = 0; i < this._items.length; i++) {
              this[i] = this._items[i];
          }
      },
      sortList: function sortList() {
          // http://w3c.github.io/IndexedDB/#sorted-list
          // https://tc39.github.io/ecma262/#sec-abstract-relational-comparison
          this._items.sort();
          this.addIndexes();
          return this._items;
      },
      forEach: function forEach(cb, thisArg) {
          this._items.forEach(cb, thisArg);
      },
      map: function map(cb, thisArg) {
          return this._items.map(cb, thisArg);
      },
      indexOf: function indexOf(str) {
          return this._items.indexOf(str);
      },
      push: function push(item) {
          this._items.push(item);
          this._length++;
          this.sortList();
      },
      splice: function splice() /* index, howmany, item1, ..., itemX */{
          var _items;
  
          (_items = this._items).splice.apply(_items, arguments);
          this._length = this._items.length;
          for (var i in this) {
              if (i === String(parseInt(i, 10))) {
                  delete this[i];
              }
          }
          this.sortList();
      }
  }, _defineProperty(_DOMStringList$protot, Symbol.toStringTag, 'DOMStringListPrototype'), _defineProperty(_DOMStringList$protot, Symbol.iterator, regeneratorRuntime.mark(function _callee() {
      var i;
      return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
              switch (_context.prev = _context.next) {
                  case 0:
                      i = 0;
  
                  case 1:
                      if (!(i < this._items.length)) {
                          _context.next = 6;
                          break;
                      }
  
                      _context.next = 4;
                      return this._items[i++];
  
                  case 4:
                      _context.next = 1;
                      break;
  
                  case 6:
                  case 'end':
                      return _context.stop();
              }
          }
      }, _callee, this);
  })), _DOMStringList$protot);
  Object.defineProperty(DOMStringList, Symbol.hasInstance, {
      value: function value(obj) {
          return {}.toString.call(obj) === 'DOMStringListPrototype';
      }
  });
  var DOMStringListAlias = DOMStringList;
  Object.defineProperty(DOMStringList, '__createInstance', {
      value: function value() {
          var DOMStringList = function DOMStringList() {
              this.toString = function () {
                  return '[object DOMStringList]';
              };
              // Internal functions on the prototype have been made non-enumerable below.
              Object.defineProperty(this, 'length', {
                  enumerable: true,
                  get: function get() {
                      return this._length;
                  }
              });
              this._items = [];
              this._length = 0;
          };
          DOMStringList.prototype = DOMStringListAlias.prototype;
          return new DOMStringList();
      }
  });
  
  if (cleanInterface) {
      Object.defineProperty(DOMStringList, 'prototype', {
          writable: false
      });
  
      var nonenumerableReadonly = ['addIndexes', 'sortList', 'forEach', 'map', 'indexOf', 'push', 'splice', 'constructor', '__createInstance'];
      nonenumerableReadonly.forEach(function (nonenumerableReadonly) {
          Object.defineProperty(DOMStringList.prototype, nonenumerableReadonly, {
              enumerable: false
          });
      });
  
      // Illegal invocations
      Object.defineProperty(DOMStringList.prototype, 'length', {
          configurable: true,
          enumerable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  
      var nonenumerableWritable = ['_items', '_length'];
      nonenumerableWritable.forEach(function (nonenumerableWritable) {
          Object.defineProperty(DOMStringList.prototype, nonenumerableWritable, {
              enumerable: false,
              writable: true
          });
      });
  }
  
  exports.default = DOMStringList;
  module.exports = exports['default'];
  
  },{}],322:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.ShimEventTarget = exports.ShimCustomEvent = exports.ShimEvent = exports.createEvent = undefined;
  
  var _eventtarget = require('eventtarget');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function createEvent(type, debug, evInit) {
      var ev = new _eventtarget.ShimEvent(type, evInit);
      ev.debug = debug;
      return ev;
  }
  
  // We don't add within polyfill repo as might not always be the desired implementation
  Object.defineProperty(_eventtarget.ShimEvent, Symbol.hasInstance, {
      value: function value(obj) {
          return util.isObj(obj) && 'target' in obj && typeof obj.bubbles === 'boolean';
      }
  });
  
  exports.createEvent = createEvent;
  exports.ShimEvent = _eventtarget.ShimEvent;
  exports.ShimCustomEvent = _eventtarget.ShimCustomEvent;
  exports.ShimEventTarget = _eventtarget.ShimEventTarget;
  
  },{"./util":338,"eventtarget":297}],323:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.IDBCursorWithValue = exports.IDBCursor = undefined;
  
  var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
  
  var _IDBRequest = require('./IDBRequest');
  
  var _IDBObjectStore = require('./IDBObjectStore');
  
  var _IDBObjectStore2 = _interopRequireDefault(_IDBObjectStore);
  
  var _DOMException = require('./DOMException');
  
  var _IDBKeyRange = require('./IDBKeyRange');
  
  var _IDBFactory = require('./IDBFactory');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _IDBTransaction = require('./IDBTransaction');
  
  var _IDBTransaction2 = _interopRequireDefault(_IDBTransaction);
  
  var _Key = require('./Key');
  
  var Key = _interopRequireWildcard(_Key);
  
  var _Sca = require('./Sca');
  
  var Sca = _interopRequireWildcard(_Sca);
  
  var _IDBIndex = require('./IDBIndex');
  
  var _IDBIndex2 = _interopRequireDefault(_IDBIndex);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  /**
   * The IndexedDB Cursor Object
   * http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBCursor
   * @param {IDBKeyRange} range
   * @param {string} direction
   * @param {IDBObjectStore} store
   * @param {IDBObjectStore|IDBIndex} source
   * @param {string} keyColumnName
   * @param {string} valueColumnName
   * @param {boolean} count
   */
  function IDBCursor() {
      throw new TypeError('Illegal constructor');
  }
  var IDBCursorAlias = IDBCursor;
  IDBCursor.__super = function IDBCursor(query, direction, store, source, keyColumnName, valueColumnName, count) {
      this[Symbol.toStringTag] = 'IDBCursor';
      util.defineReadonlyProperties(this, ['key', 'primaryKey']);
      _IDBTransaction2.default.__assertActive(store.transaction);
      var range = (0, _IDBKeyRange.convertValueToKeyRange)(query);
      if (direction !== undefined && !['next', 'prev', 'nextunique', 'prevunique'].includes(direction)) {
          throw new TypeError(direction + 'is not a valid cursor direction');
      }
  
      Object.defineProperties(this, {
          // Babel is not respecting default writable false here, so make explicit
          source: { writable: false, value: source },
          direction: { writable: false, value: direction || 'next' }
      });
      this.__key = undefined;
      this.__primaryKey = undefined;
  
      this.__store = store;
      this.__range = range;
      this.__req = _IDBRequest.IDBRequest.__createInstance();
      this.__req.__source = source;
      this.__req.__transaction = this.__store.transaction;
      this.__keyColumnName = keyColumnName;
      this.__valueColumnName = valueColumnName;
      this.__keyOnly = valueColumnName === 'key';
      this.__valueDecoder = this.__keyOnly ? Key : Sca;
      this.__count = count;
      this.__prefetchedIndex = -1;
      this.__indexSource = util.instanceOf(source, _IDBIndex2.default);
      this.__multiEntryIndex = this.__indexSource ? source.multiEntry : false;
      this.__unique = this.direction.includes('unique');
      this.__sqlDirection = ['prev', 'prevunique'].includes(this.direction) ? 'DESC' : 'ASC';
  
      if (range !== undefined) {
          // Encode the key range and cache the encoded values, so we don't have to re-encode them over and over
          range.__lowerCached = range.lower !== undefined && Key.encode(range.lower, this.__multiEntryIndex);
          range.__upperCached = range.upper !== undefined && Key.encode(range.upper, this.__multiEntryIndex);
      }
      this.__gotValue = true;
      this['continue']();
  };
  
  IDBCursor.__createInstance = function () {
      var IDBCursor = IDBCursorAlias.__super;
      IDBCursor.prototype = IDBCursorAlias.prototype;
  
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
      }
  
      return new (Function.prototype.bind.apply(IDBCursor, [null].concat(args)))();
  };
  
  IDBCursor.prototype.__find = function () /* key, tx, success, error, recordsToLoad */{
      if (this.__multiEntryIndex) {
          this.__findMultiEntry.apply(this, arguments);
      } else {
          this.__findBasic.apply(this, arguments);
      }
  };
  
  IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error, recordsToLoad) {
      var continueCall = recordsToLoad !== undefined;
      recordsToLoad = recordsToLoad || 1;
  
      var me = this;
      var quotedKeyColumnName = util.sqlQuote(me.__keyColumnName);
      var quotedKey = util.sqlQuote('key');
      var sql = ['SELECT * FROM', util.escapeStoreNameForSQL(me.__store.name)];
      var sqlValues = [];
      sql.push('WHERE', quotedKeyColumnName, 'NOT NULL');
      (0, _IDBKeyRange.setSQLForKeyRange)(me.__range, quotedKeyColumnName, sql, sqlValues, true, true);
  
      // Determine the ORDER BY direction based on the cursor.
      var direction = me.__sqlDirection;
      var op = direction === 'ASC' ? '>' : '<';
  
      if (primaryKey !== undefined) {
          sql.push('AND', quotedKey, op + '= ?');
          // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
          sqlValues.push(Key.encode(primaryKey));
      }
      if (key !== undefined) {
          sql.push('AND', quotedKeyColumnName, op + '= ?');
          // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
          sqlValues.push(Key.encode(key));
      } else if (continueCall && me.__key !== undefined) {
          sql.push('AND', quotedKeyColumnName, op + ' ?');
          // Key.convertValueToKey(me.__key); // Already checked when stored
          sqlValues.push(Key.encode(me.__key));
      }
  
      if (!me.__count) {
          // 1. Sort by key
          sql.push('ORDER BY', quotedKeyColumnName, direction);
  
          // 2. Sort by primaryKey (if defined and not unique)
          if (!me.__unique && me.__keyColumnName !== 'key') {
              // Avoid adding 'key' twice
              sql.push(',', quotedKey, direction);
          }
  
          // 3. Sort by position (if defined)
  
          if (!me.__unique && me.__indexSource) {
              // 4. Sort by object store position (if defined and not unique)
              sql.push(',', util.sqlQuote(me.__valueColumnName), direction);
          }
          sql.push('LIMIT', recordsToLoad);
      }
      sql = sql.join(' ');
      _CFG2.default.DEBUG && console.log(sql, sqlValues);
  
      tx.executeSql(sql, sqlValues, function (tx, data) {
          if (me.__count) {
              success(undefined, data.rows.length, undefined);
          } else if (data.rows.length > 1) {
              me.__prefetchedIndex = 0;
              me.__prefetchedData = data.rows;
              _CFG2.default.DEBUG && console.log('Preloaded ' + me.__prefetchedData.length + ' records for cursor');
              me.__decode(data.rows.item(0), success);
          } else if (data.rows.length === 1) {
              me.__decode(data.rows.item(0), success);
          } else {
              _CFG2.default.DEBUG && console.log('Reached end of cursors');
              success(undefined, undefined, undefined);
          }
      }, function (tx, err) {
          _CFG2.default.DEBUG && console.log('Could not execute Cursor.continue', sql, sqlValues);
          error(err);
      });
  };
  
  IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, error) {
      var me = this;
  
      if (me.__prefetchedData && me.__prefetchedData.length === me.__prefetchedIndex) {
          _CFG2.default.DEBUG && console.log('Reached end of multiEntry cursor');
          success(undefined, undefined, undefined);
          return;
      }
  
      var quotedKeyColumnName = util.sqlQuote(me.__keyColumnName);
      var sql = ['SELECT * FROM', util.escapeStoreNameForSQL(me.__store.name)];
      var sqlValues = [];
      sql.push('WHERE', quotedKeyColumnName, 'NOT NULL');
      if (me.__range && me.__range.lower !== undefined && Array.isArray(me.__range.upper)) {
          if (me.__range.upper.indexOf(me.__range.lower) === 0) {
              sql.push('AND', quotedKeyColumnName, "LIKE ? ESCAPE '^'");
              sqlValues.push('%' + util.sqlLIKEEscape(me.__range.__lowerCached.slice(0, -1)) + '%');
          }
      }
  
      // Determine the ORDER BY direction based on the cursor.
      var direction = me.__sqlDirection;
      var op = direction === 'ASC' ? '>' : '<';
      var quotedKey = util.sqlQuote('key');
  
      if (primaryKey !== undefined) {
          sql.push('AND', quotedKey, op + '= ?');
          // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
          sqlValues.push(Key.encode(primaryKey));
      }
      if (key !== undefined) {
          sql.push('AND', quotedKeyColumnName, op + '= ?');
          // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
          sqlValues.push(Key.encode(key));
      } else if (me.__key !== undefined) {
          sql.push('AND', quotedKeyColumnName, op + ' ?');
          // Key.convertValueToKey(me.__key); // Already checked when entered
          sqlValues.push(Key.encode(me.__key));
      }
  
      if (!me.__count) {
          // 1. Sort by key
          sql.push('ORDER BY', quotedKeyColumnName, direction);
  
          // 2. Sort by primaryKey (if defined and not unique)
          if (!me.__unique && me.__keyColumnName !== 'key') {
              // Avoid adding 'key' twice
              sql.push(',', util.sqlQuote('key'), direction);
          }
  
          // 3. Sort by position (if defined)
  
          if (!me.__unique && me.__indexSource) {
              // 4. Sort by object store position (if defined and not unique)
              sql.push(',', util.sqlQuote(me.__valueColumnName), direction);
          }
      }
      sql = sql.join(' ');
      _CFG2.default.DEBUG && console.log(sql, sqlValues);
  
      tx.executeSql(sql, sqlValues, function (tx, data) {
          if (data.rows.length > 0) {
              if (me.__count) {
                  // Avoid caching and other processing below
                  var ct = 0;
                  for (var i = 0; i < data.rows.length; i++) {
                      var rowItem = data.rows.item(i);
                      var rowKey = Key.decode(rowItem[me.__keyColumnName], true);
                      var matches = Key.findMultiEntryMatches(rowKey, me.__range);
                      ct += matches.length;
                  }
                  success(undefined, ct, undefined);
                  return;
              }
              var rows = [];
              for (var _i = 0; _i < data.rows.length; _i++) {
                  var _rowItem = data.rows.item(_i);
                  var _rowKey = Key.decode(_rowItem[me.__keyColumnName], true);
                  var _matches = Key.findMultiEntryMatches(_rowKey, me.__range);
  
                  for (var j = 0; j < _matches.length; j++) {
                      var matchingKey = _matches[j];
                      var clone = {
                          matchingKey: Key.encode(matchingKey, true),
                          key: _rowItem.key
                      };
                      clone[me.__keyColumnName] = _rowItem[me.__keyColumnName];
                      clone[me.__valueColumnName] = _rowItem[me.__valueColumnName];
                      rows.push(clone);
                  }
              }
              var reverse = me.direction.indexOf('prev') === 0;
              rows.sort(function (a, b) {
                  if (a.matchingKey.replace('[', 'z') < b.matchingKey.replace('[', 'z')) {
                      return reverse ? 1 : -1;
                  }
                  if (a.matchingKey.replace('[', 'z') > b.matchingKey.replace('[', 'z')) {
                      return reverse ? -1 : 1;
                  }
                  if (a.key < b.key) {
                      return me.direction === 'prev' ? 1 : -1;
                  }
                  if (a.key > b.key) {
                      return me.direction === 'prev' ? -1 : 1;
                  }
                  return 0;
              });
  
              if (rows.length > 1) {
                  me.__prefetchedIndex = 0;
                  me.__prefetchedData = {
                      data: rows,
                      length: rows.length,
                      item: function item(index) {
                          return this.data[index];
                      }
                  };
                  _CFG2.default.DEBUG && console.log('Preloaded ' + me.__prefetchedData.length + ' records for multiEntry cursor');
                  me.__decode(rows[0], success);
              } else if (rows.length === 1) {
                  _CFG2.default.DEBUG && console.log('Reached end of multiEntry cursor');
                  me.__decode(rows[0], success);
              } else {
                  _CFG2.default.DEBUG && console.log('Reached end of multiEntry cursor');
                  success(undefined, undefined, undefined);
              }
          } else {
              _CFG2.default.DEBUG && console.log('Reached end of multiEntry cursor');
              success(undefined, undefined, undefined);
          }
      }, function (tx, err) {
          _CFG2.default.DEBUG && console.log('Could not execute Cursor.continue', sql, sqlValues);
          error(err);
      });
  };
  
  /**
   * Creates an "onsuccess" callback
   * @private
   */
  IDBCursor.prototype.__onsuccess = function (success) {
      var me = this;
      return function (key, value, primaryKey) {
          if (me.__count) {
              success(value, me.__req);
          } else {
              if (key !== undefined) {
                  me.__gotValue = true;
              }
              me.__key = key === undefined ? null : key;
              me.__primaryKey = primaryKey === undefined ? null : primaryKey;
              me.__value = value === undefined ? null : value;
              var result = key === undefined ? null : me;
              success(result, me.__req);
          }
      };
  };
  
  IDBCursor.prototype.__decode = function (rowItem, callback) {
      var me = this;
      if (me.__multiEntryIndex && me.__unique) {
          if (!me.__matchedKeys) {
              me.__matchedKeys = {};
          }
          if (me.__matchedKeys[rowItem.matchingKey]) {
              callback(undefined, undefined, undefined);
              return;
          }
          me.__matchedKeys[rowItem.matchingKey] = true;
      }
      var encKey = util.unescapeSQLiteResponse(me.__multiEntryIndex ? rowItem.matchingKey : rowItem[me.__keyColumnName]);
      var encVal = util.unescapeSQLiteResponse(rowItem[me.__valueColumnName]);
      var encPrimaryKey = util.unescapeSQLiteResponse(rowItem.key);
  
      var key = Key.decode(encKey, me.__multiEntryIndex);
      var val = me.__valueDecoder.decode(encVal);
      var primaryKey = Key.decode(encPrimaryKey);
      callback(key, val, primaryKey, encKey /*, encVal, encPrimaryKey */);
  };
  
  IDBCursor.prototype.__sourceOrEffectiveObjStoreDeleted = function () {
      if (!this.__store.transaction.db.objectStoreNames.contains(this.__store.name) || this.__indexSource && !this.__store.indexNames.contains(this.source.name)) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'The cursor\'s source or effective object store has been deleted');
      }
  };
  
  IDBCursor.prototype.__invalidateCache = function () {
      this.__prefetchedData = null;
  };
  
  IDBCursor.prototype.__continue = function (key, advanceContinue) {
      var me = this;
      var advanceState = me.__advanceCount !== undefined;
      _IDBTransaction2.default.__assertActive(me.__store.transaction);
      me.__sourceOrEffectiveObjStoreDeleted();
      if (!me.__gotValue && !advanceContinue) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'The cursor is being iterated or has iterated past its end.');
      }
      if (key !== undefined) {
          Key.convertValueToKeyRethrowingAndIfInvalid(key);
          var cmpResult = (0, _IDBFactory.cmp)(key, me.key);
          if (cmpResult === 0 || me.direction.includes('next') && cmpResult === -1 || me.direction.includes('prev') && cmpResult === 1) {
              throw (0, _DOMException.createDOMException)('DataError', 'Cannot ' + (advanceState ? 'advance' : 'continue') + ' the cursor in an unexpected direction');
          }
      }
      this.__continueFinish(key, undefined, advanceState);
  };
  
  IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState) {
      var me = this;
      var recordsToPreloadOnContinue = me.__advanceCount || _CFG2.default.cursorPreloadPackSize || 100;
      me.__gotValue = false;
      me.__req.__readyState = 'pending'; // Unset done flag
  
      me.__store.transaction.__pushToQueue(me.__req, function cursorContinue(tx, args, success, error, executeNextRequest) {
          function triggerSuccess(k, val, primKey) {
              if (advanceState) {
                  if (me.__advanceCount >= 2 && k !== undefined) {
                      me.__advanceCount--;
                      me.__key = k;
                      me.__continue(undefined, true);
                      executeNextRequest(); // We don't call success yet but do need to advance the transaction queue
                      return;
                  }
                  me.__advanceCount = undefined;
              }
              me.__onsuccess(success)(k, val, primKey);
          }
          if (me.__prefetchedData) {
              // We have pre-loaded data for the cursor
              me.__prefetchedIndex++;
              if (me.__prefetchedIndex < me.__prefetchedData.length) {
                  me.__decode(me.__prefetchedData.item(me.__prefetchedIndex), function (k, val, primKey, encKey) {
                      function checkKey() {
                          var cmpResult = key === undefined || (0, _IDBFactory.cmp)(k, key);
                          if (cmpResult > 0 || cmpResult === 0 && (me.__unique || primaryKey === undefined || (0, _IDBFactory.cmp)(primKey, primaryKey) >= 0)) {
                              triggerSuccess(k, val, primKey);
                              return;
                          }
                          cursorContinue(tx, args, success, error);
                      }
                      if (me.__unique && !me.__multiEntryIndex && encKey === Key.encode(me.key, me.__multiEntryIndex)) {
                          cursorContinue(tx, args, success, error);
                          return;
                      }
                      checkKey();
                  });
                  return;
              }
          }
  
          // No (or not enough) pre-fetched data, do query
          me.__find(key, primaryKey, tx, triggerSuccess, function () {
              me.__advanceCount = undefined;
              error.apply(undefined, arguments);
          }, recordsToPreloadOnContinue);
      });
  };
  
  IDBCursor.prototype['continue'] = function () /* key */{
      this.__continue(arguments[0]);
  };
  
  IDBCursor.prototype.continuePrimaryKey = function (key, primaryKey) {
      var me = this;
      _IDBTransaction2.default.__assertActive(me.__store.transaction);
      me.__sourceOrEffectiveObjStoreDeleted();
      if (!me.__indexSource) {
          throw (0, _DOMException.createDOMException)('InvalidAccessError', '`continuePrimaryKey` may only be called on an index source.');
      }
      if (!['next', 'prev'].includes(me.direction)) {
          throw (0, _DOMException.createDOMException)('InvalidAccessError', '`continuePrimaryKey` may not be called with unique cursors.');
      }
      if (!me.__gotValue) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'The cursor is being iterated or has iterated past its end.');
      }
      Key.convertValueToKeyRethrowingAndIfInvalid(key);
      Key.convertValueToKeyRethrowingAndIfInvalid(primaryKey);
  
      var cmpResult = (0, _IDBFactory.cmp)(key, me.key);
      if (me.direction === 'next' && cmpResult === -1 || me.direction === 'prev' && cmpResult === 1) {
          throw (0, _DOMException.createDOMException)('DataError', 'Cannot continue the cursor in an unexpected direction');
      }
      function noErrors() {
          me.__continueFinish(key, primaryKey, false);
      }
      if (cmpResult === 0) {
          Sca.encode(primaryKey, function (encPrimaryKey) {
              Sca.encode(me.primaryKey, function (encObjectStorePos) {
                  if (encPrimaryKey === encObjectStorePos || me.direction === 'next' && encPrimaryKey < encObjectStorePos || me.direction === 'prev' && encPrimaryKey > encObjectStorePos) {
                      throw (0, _DOMException.createDOMException)('DataError', 'Cannot continue the cursor in an unexpected direction');
                  }
                  noErrors();
              });
          });
      } else {
          noErrors();
      }
  };
  
  IDBCursor.prototype.advance = function (count) {
      var me = this;
      count = util.enforceRange(count, 'unsigned long');
      if (count === 0) {
          throw new TypeError('Calling advance() with count argument 0');
      }
      if (me.__gotValue) {
          // Only set the count if not running in error (otherwise will override earlier good advance calls)
          me.__advanceCount = count;
      }
      me.__continue();
  };
  
  IDBCursor.prototype.update = function (valueToUpdate) {
      var me = this;
      if (!arguments.length) throw new TypeError('A value must be passed to update()');
      _IDBTransaction2.default.__assertActive(me.__store.transaction);
      me.__store.transaction.__assertWritable();
      me.__sourceOrEffectiveObjStoreDeleted();
      if (!me.__gotValue) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'The cursor is being iterated or has iterated past its end.');
      }
      if (me.__keyOnly) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This cursor method cannot be called when the key only flag has been set.');
      }
      var request = me.__store.transaction.__createRequest(me);
      var key = me.primaryKey;
      function addToQueue(clonedValue) {
          _IDBObjectStore2.default.__stepsStoringRecordObjectStore(request, me.__store, clonedValue, false, key);
      }
      if (me.__store.keyPath !== null) {
          var _me$__store$__validat = me.__store.__validateKeyAndValueAndCloneValue(valueToUpdate, undefined, true),
              _me$__store$__validat2 = _slicedToArray(_me$__store$__validat, 2),
              evaluatedKey = _me$__store$__validat2[0],
              clonedValue = _me$__store$__validat2[1];
  
          if ((0, _IDBFactory.cmp)(me.primaryKey, evaluatedKey) !== 0) {
              throw (0, _DOMException.createDOMException)('DataError', 'The key of the supplied value to `update` is not equal to the cursor\'s effective key');
          }
          addToQueue(clonedValue);
      } else {
          var _clonedValue = Sca.clone(valueToUpdate);
          addToQueue(_clonedValue);
      }
      return request;
  };
  
  IDBCursor.prototype['delete'] = function () {
      var me = this;
      _IDBTransaction2.default.__assertActive(me.__store.transaction);
      me.__store.transaction.__assertWritable();
      me.__sourceOrEffectiveObjStoreDeleted();
      if (!me.__gotValue) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'The cursor is being iterated or has iterated past its end.');
      }
      if (me.__keyOnly) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This cursor method cannot be called when the key only flag has been set.');
      }
      return this.__store.transaction.__addToTransactionQueue(function cursorDelete(tx, args, success, error) {
          me.__find(undefined, undefined, tx, function (key, value, primaryKey) {
              var sql = 'DELETE FROM  ' + util.escapeStoreNameForSQL(me.__store.name) + ' WHERE "key" = ?';
              _CFG2.default.DEBUG && console.log(sql, key, primaryKey);
              // Key.convertValueToKey(primaryKey); // Already checked when entered
              tx.executeSql(sql, [util.escapeSQLiteStatement(Key.encode(primaryKey))], function (tx, data) {
                  if (data.rowsAffected === 1) {
                      me.__store.__cursors.forEach(function (cursor) {
                          cursor.__invalidateCache(); // Delete
                      });
                      success(undefined);
                  } else {
                      error('No rows with key found' + key);
                  }
              }, function (tx, data) {
                  error(data);
              });
          }, error);
      }, undefined, me);
  };
  
  IDBCursor.prototype[Symbol.toStringTag] = 'IDBCursorPrototype';
  
  ['source', 'direction', 'key', 'primaryKey'].forEach(function (prop) {
      Object.defineProperty(IDBCursor.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  Object.defineProperty(IDBCursor, 'prototype', {
      writable: false
  });
  
  var IDBCursorWithValue = function (_IDBCursor) {
      _inherits(IDBCursorWithValue, _IDBCursor);
  
      function IDBCursorWithValue() {
          _classCallCheck(this, IDBCursorWithValue);
  
          return _possibleConstructorReturn(this, (IDBCursorWithValue.__proto__ || Object.getPrototypeOf(IDBCursorWithValue)).apply(this, arguments));
      }
  
      return IDBCursorWithValue;
  }(IDBCursor);
  
  var IDBCursorWithValueAlias = IDBCursorWithValue;
  IDBCursorWithValue.__createInstance = function () {
      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
      }
  
      function IDBCursorWithValue() {
          var _IDBCursor$__super;
  
          (_IDBCursor$__super = IDBCursor.__super).call.apply(_IDBCursor$__super, [this].concat(args));
          this[Symbol.toStringTag] = 'IDBCursorWithValue';
          util.defineReadonlyProperties(this, 'value');
      }
      IDBCursorWithValue.prototype = IDBCursorWithValueAlias.prototype;
      return new IDBCursorWithValue();
  };
  
  Object.defineProperty(IDBCursorWithValue.prototype, 'value', {
      enumerable: true,
      configurable: true,
      get: function get() {
          throw new TypeError('Illegal invocation');
      }
  });
  
  IDBCursorWithValue.prototype[Symbol.toStringTag] = 'IDBCursorWithValuePrototype';
  
  Object.defineProperty(IDBCursorWithValue, 'prototype', {
      writable: false
  });
  
  exports.IDBCursor = IDBCursor;
  exports.IDBCursorWithValue = IDBCursorWithValue;
  
  },{"./CFG":319,"./DOMException":320,"./IDBFactory":325,"./IDBIndex":326,"./IDBKeyRange":327,"./IDBObjectStore":328,"./IDBRequest":329,"./IDBTransaction":330,"./Key":332,"./Sca":333,"./util":338}],324:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _DOMException = require('./DOMException');
  
  var _Event = require('./Event');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _DOMStringList = require('./DOMStringList');
  
  var _DOMStringList2 = _interopRequireDefault(_DOMStringList);
  
  var _IDBObjectStore = require('./IDBObjectStore');
  
  var _IDBObjectStore2 = _interopRequireDefault(_IDBObjectStore);
  
  var _IDBTransaction = require('./IDBTransaction');
  
  var _IDBTransaction2 = _interopRequireDefault(_IDBTransaction);
  
  var _Sca = require('./Sca');
  
  var Sca = _interopRequireWildcard(_Sca);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  var _eventtarget = require('eventtarget');
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
  
  var listeners = ['onabort', 'onclose', 'onerror', 'onversionchange'];
  var readonlyProperties = ['name', 'version', 'objectStoreNames'];
  
  /**
   * IDB Database Object
   * http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#database-interface
   * @constructor
   */
  function IDBDatabase() {
      throw new TypeError('Illegal constructor');
  }
  var IDBDatabaseAlias = IDBDatabase;
  IDBDatabase.__createInstance = function (db, name, oldVersion, version, storeProperties) {
      function IDBDatabase() {
          var _this = this;
  
          this[Symbol.toStringTag] = 'IDBDatabase';
          util.defineReadonlyProperties(this, readonlyProperties);
          this.__db = db;
          this.__closed = false;
          this.__oldVersion = oldVersion;
          this.__version = version;
          this.__name = name;
          listeners.forEach(function (listener) {
              Object.defineProperty(_this, listener, {
                  enumerable: true,
                  configurable: true,
                  get: function get() {
                      return this['__' + listener];
                  },
                  set: function set(val) {
                      this['__' + listener] = val;
                  }
              });
          });
          listeners.forEach(function (l) {
              _this[l] = null;
          });
  
          this.__transactions = [];
          this.__objectStores = {};
          this.__objectStoreNames = _DOMStringList2.default.__createInstance();
          var itemCopy = {};
  
          var _loop = function _loop(i) {
              var item = storeProperties.rows.item(i);
              // Safari implements `item` getter return object's properties
              //  as readonly, so we copy all its properties (except our
              //  custom `currNum` which we don't need) onto a new object
              itemCopy.name = item.name;
              itemCopy.keyPath = Sca.decode(item.keyPath);
              ['autoInc', 'indexList'].forEach(function (prop) {
                  itemCopy[prop] = JSON.parse(item[prop]);
              });
              itemCopy.idbdb = _this;
              var store = _IDBObjectStore2.default.__createInstance(itemCopy);
              _this.__objectStores[store.name] = store;
              _this.objectStoreNames.push(store.name);
          };
  
          for (var i = 0; i < storeProperties.rows.length; i++) {
              _loop(i);
          }
          this.__oldObjectStoreNames = this.objectStoreNames.clone();
      }
      IDBDatabase.prototype = IDBDatabaseAlias.prototype;
      return new IDBDatabase();
  };
  
  IDBDatabase.prototype = _eventtarget.EventTargetFactory.createInstance();
  IDBDatabase.prototype[Symbol.toStringTag] = 'IDBDatabasePrototype';
  
  /**
   * Creates a new object store.
   * @param {string} storeName
   * @param {object} [createOptions]
   * @returns {IDBObjectStore}
   */
  IDBDatabase.prototype.createObjectStore = function (storeName /* , createOptions */) {
      var createOptions = arguments[1];
      storeName = String(storeName); // W3C test within IDBObjectStore.js seems to accept string conversion
      if (!(this instanceof IDBDatabase)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No object store name was specified');
      }
      _IDBTransaction2.default.__assertVersionChange(this.__versionTransaction); // this.__versionTransaction may not exist if called mistakenly by user in onsuccess
      _IDBTransaction2.default.__assertNotFinished(this.__versionTransaction);
      _IDBTransaction2.default.__assertActive(this.__versionTransaction);
      if (this.__objectStores[storeName]) {
          throw (0, _DOMException.createDOMException)('ConstraintError', 'Object store "' + storeName + '" already exists in ' + this.name);
      }
      createOptions = Object.assign({}, createOptions);
  
      var keyPath = createOptions.keyPath;
      keyPath = keyPath === undefined ? null : keyPath = util.convertToSequenceDOMString(keyPath);
      if (keyPath !== null && !util.isValidKeyPath(keyPath)) {
          throw (0, _DOMException.createDOMException)('SyntaxError', 'The keyPath argument contains an invalid key path.');
      }
  
      var autoIncrement = createOptions.autoIncrement;
      if (autoIncrement && (keyPath === '' || Array.isArray(keyPath))) {
          throw (0, _DOMException.createDOMException)('InvalidAccessError', 'With autoIncrement set, the keyPath argument must not be an array or empty string.');
      }
  
      /** @name IDBObjectStoreProperties **/
      var storeProperties = {
          name: storeName,
          keyPath: keyPath,
          autoInc: autoIncrement,
          indexList: {},
          idbdb: this
      };
      var store = _IDBObjectStore2.default.__createInstance(storeProperties, this.__versionTransaction);
      _IDBObjectStore2.default.__createObjectStore(this, store);
      return store;
  };
  
  /**
   * Deletes an object store.
   * @param {string} storeName
   */
  IDBDatabase.prototype.deleteObjectStore = function (storeName) {
      if (!(this instanceof IDBDatabase)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No object store name was specified');
      }
      _IDBTransaction2.default.__assertVersionChange(this.__versionTransaction);
      _IDBTransaction2.default.__assertNotFinished(this.__versionTransaction);
      _IDBTransaction2.default.__assertActive(this.__versionTransaction);
  
      var store = this.__objectStores[storeName];
      if (!store) {
          throw (0, _DOMException.createDOMException)('NotFoundError', 'Object store "' + storeName + '" does not exist in ' + this.name);
      }
  
      _IDBObjectStore2.default.__deleteObjectStore(this, store);
  };
  
  IDBDatabase.prototype.close = function () {
      if (!(this instanceof IDBDatabase)) {
          throw new TypeError('Illegal invocation');
      }
      this.__closed = true;
  };
  
  /**
   * Starts a new transaction.
   * @param {string|string[]} storeNames
   * @param {string} mode
   * @returns {IDBTransaction}
   */
  IDBDatabase.prototype.transaction = function (storeNames /* , mode */) {
      var _this2 = this;
  
      var mode = arguments[1];
      storeNames = typeof storeNames === 'string' ? [storeNames] : util.isIterable(storeNames) ? [].concat(_toConsumableArray(new Set( // to be unique
      util.convertToSequenceDOMString(storeNames) // iterables have `ToString` applied (and we convert to array for convenience)
      ))).sort() // must be sorted
      : function () {
          throw new TypeError('You must supply a valid `storeNames` to `IDBDatabase.transaction`');
      }();
      if (storeNames.length === 0) {
          throw (0, _DOMException.createDOMException)('InvalidAccessError', 'No valid object store names were specified');
      }
  
      // Since SQLite (at least node-websql and definitely WebSQL) requires
      //   locking of the whole database, to allow simultaneous readwrite
      //   operations on transactions without overlapping stores, we'd probably
      //   need to save the stores in separate databases (we could also consider
      //   prioritizing readonly but not starving readwrite).
      // Even for readonly transactions, due to [issue 17](https://github.com/nolanlawson/node-websql/issues/17),
      //   we're not currently actually running the SQL requests in parallel.
      if (typeof mode === 'number') {
          mode = mode === 1 ? 'readwrite' : 'readonly';
          _CFG2.default.DEBUG && console.log('Mode should be a string, but was specified as ', mode); // Todo Deprecated: Remove this option as no longer in spec
      } else {
          mode = mode || 'readonly';
      }
  
      if (mode !== 'readonly' && mode !== 'readwrite') {
          throw new TypeError('Invalid transaction mode: ' + mode);
      }
  
      _IDBTransaction2.default.__assertNotVersionChange(this.__versionTransaction);
      if (this.__closed) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'An attempt was made to start a new transaction on a database connection that is not open');
      }
  
      storeNames.forEach(function (storeName) {
          if (!_this2.objectStoreNames.contains(storeName)) {
              throw (0, _DOMException.createDOMException)('NotFoundError', 'The "' + storeName + '" object store does not exist');
          }
      });
      // Do not set __active flag to false yet: https://github.com/w3c/IndexedDB/issues/87
      var trans = _IDBTransaction2.default.__createInstance(this, storeNames, mode);
      this.__transactions.push(trans);
      return trans;
  };
  
  // Todo __forceClose: Add tests for `__forceClose`
  IDBDatabase.prototype.__forceClose = function (msg) {
      var me = this;
      me.close();
      var ct = 0;
      me.__transactions.forEach(function (trans) {
          trans.on__abort = function () {
              ct++;
              if (ct === me.__transactions.length) {
                  // Todo __forceClose: unblock any pending `upgradeneeded` or `deleteDatabase` calls
                  var evt = (0, _Event.createEvent)('close');
                  setTimeout(function () {
                      me.dispatchEvent(evt);
                  });
              }
          };
          trans.__abortTransaction((0, _DOMException.createDOMException)('AbortError', 'The connection was force-closed: ' + (msg || '')));
      });
  };
  
  listeners.forEach(function (listener) {
      Object.defineProperty(IDBDatabase.prototype, listener, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          },
          set: function set(val) {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBDatabase.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  Object.defineProperty(IDBDatabase.prototype, 'constructor', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: IDBDatabase
  });
  
  Object.defineProperty(IDBDatabase, 'prototype', {
      writable: false
  });
  
  exports.default = IDBDatabase;
  module.exports = exports['default'];
  
  },{"./CFG":319,"./DOMException":320,"./DOMStringList":321,"./Event":322,"./IDBObjectStore":328,"./IDBTransaction":330,"./Sca":333,"./util":338,"eventtarget":297}],325:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.shimIndexedDB = exports.cmp = exports.IDBFactory = undefined;
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var _Event = require('./Event');
  
  var _IDBVersionChangeEvent = require('./IDBVersionChangeEvent');
  
  var _IDBVersionChangeEvent2 = _interopRequireDefault(_IDBVersionChangeEvent);
  
  var _DOMException = require('./DOMException');
  
  var _IDBRequest = require('./IDBRequest');
  
  var _DOMStringList = require('./DOMStringList');
  
  var _DOMStringList2 = _interopRequireDefault(_DOMStringList);
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _Key = require('./Key');
  
  var Key = _interopRequireWildcard(_Key);
  
  var _IDBTransaction = require('./IDBTransaction');
  
  var _IDBTransaction2 = _interopRequireDefault(_IDBTransaction);
  
  var _IDBDatabase = require('./IDBDatabase');
  
  var _IDBDatabase2 = _interopRequireDefault(_IDBDatabase);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  var sysdb = void 0;
  
  /**
   * Craetes the sysDB to keep track of version numbers for databases
   **/
  function createSysDB(success, failure) {
      function sysDbCreateError(tx, err) {
          err = (0, _DOMException.webSQLErrback)(err);
          _CFG2.default.DEBUG && console.log('Error in sysdb transaction - when creating dbVersions', err);
          failure(err);
      }
  
      if (sysdb) {
          success();
      } else {
          sysdb = _CFG2.default.win.openDatabase('__sysdb__.sqlite', 1, 'System Database', _CFG2.default.DEFAULT_DB_SIZE);
          sysdb.transaction(function (systx) {
              systx.executeSql('CREATE TABLE IF NOT EXISTS dbVersions (name VARCHAR(255), version INT);', [], success, sysDbCreateError);
          }, sysDbCreateError);
      }
  }
  
  /**
   * IDBFactory Class
   * https://w3c.github.io/IndexedDB/#idl-def-IDBFactory
   * @constructor
   */
  function IDBFactory() {
      throw new TypeError('Illegal constructor');
  }
  var IDBFactoryAlias = IDBFactory;
  IDBFactory.__createInstance = function () {
      function IDBFactory() {
          this[Symbol.toStringTag] = 'IDBFactory';
          this.modules = { // Export other shims (especially for testing)
              Event: typeof Event !== 'undefined' ? Event : _Event.ShimEvent,
              Error: Error, // For test comparisons
              ShimEvent: _Event.ShimEvent,
              ShimCustomEvent: _Event.ShimCustomEvent,
              ShimEventTarget: _Event.ShimEventTarget,
              ShimDOMException: _DOMException.ShimDOMException,
              ShimDOMStringList: _DOMStringList2.default,
              IDBFactory: IDBFactoryAlias
          };
          this.utils = { createDOMException: _DOMException.createDOMException }; // Expose for ease in simulating such exceptions during testing
          this.__connections = [];
      }
      IDBFactory.prototype = IDBFactoryAlias.prototype;
      return new IDBFactory();
  };
  
  /**
   * The IndexedDB Method to create a new database and return the DB
   * @param {string} name
   * @param {number} version
   */
  IDBFactory.prototype.open = function (name /* , version */) {
      var me = this;
      if (!(me instanceof IDBFactory)) {
          throw new TypeError('Illegal invocation');
      }
      var version = arguments[1];
      var req = _IDBRequest.IDBOpenDBRequest.__createInstance();
      var calledDbCreateError = false;
  
      if (arguments.length === 0) {
          throw new TypeError('Database name is required');
      }
      if (version !== undefined) {
          version = util.enforceRange(version, 'unsigned long long');
          if (version === 0) {
              throw new TypeError('Version cannot be 0');
          }
      }
      name = String(name); // cast to a string
      var sqlSafeName = util.escapeSQLiteStatement(name);
      var escapedDatabaseName = void 0;
      try {
          escapedDatabaseName = util.escapeDatabaseNameForSQLAndFiles(name);
      } catch (err) {
          throw err; // new TypeError('You have supplied a database name which does not match the currently supported configuration, possibly due to a length limit enforced for Node compatibility.');
      }
  
      function dbCreateError(tx, err) {
          if (calledDbCreateError) {
              return;
          }
          err = err ? (0, _DOMException.webSQLErrback)(err) : tx;
          calledDbCreateError = true;
          var evt = (0, _Event.createEvent)('error', err, { bubbles: true });
          req.__readyState = 'done';
          req.__error = err;
          req.__result = undefined;
          req.dispatchEvent(evt);
      }
  
      function openDB(oldVersion) {
          var db = _CFG2.default.win.openDatabase(escapedDatabaseName, 1, name, _CFG2.default.DEFAULT_DB_SIZE);
          req.__readyState = 'done';
          if (version === undefined) {
              version = oldVersion || 1;
          }
          if (oldVersion > version) {
              var err = (0, _DOMException.createDOMException)('VersionError', 'An attempt was made to open a database using a lower version than the existing version.', version);
              dbCreateError(err);
              return;
          }
  
          db.transaction(function (tx) {
              tx.executeSql('CREATE TABLE IF NOT EXISTS __sys__ (name VARCHAR(255), keyPath VARCHAR(255), autoInc BOOLEAN, indexList BLOB, currNum INTEGER)', [], function () {
                  tx.executeSql('SELECT "name", "keyPath", "autoInc", "indexList", "currNum" FROM __sys__', [], function (tx, data) {
                      req.__result = _IDBDatabase2.default.__createInstance(db, name, oldVersion, version, data);
                      me.__connections.push(req.result);
                      if (oldVersion < version) {
                          // DB Upgrade in progress
                          var sysdbFinishedCb = function sysdbFinishedCb(systx, err, cb) {
                              if (err) {
                                  try {
                                      systx.executeSql('ROLLBACK', [], cb, cb);
                                      return;
                                  } catch (er) {
                                      // Browser may fail with expired transaction above so
                                      // no choice but to manually revert
                                      sysdb.transaction(function (systx) {
                                          function reportError() {
                                              throw new Error('Unable to roll back upgrade transaction!');
                                          }
                                          // Attempt to revert
                                          if (oldVersion === 0) {
                                              systx.executeSql('DELETE FROM dbVersions WHERE "name" = ?', [sqlSafeName], cb, reportError);
                                          } else {
                                              systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [oldVersion, sqlSafeName], cb, reportError);
                                          }
                                      });
                                      return;
                                  }
                              }
                              cb(); // In browser, should auto-commit
                          };
                          sysdb.transaction(function (systx) {
                              function versionSet() {
                                  var e = new _IDBVersionChangeEvent2.default('upgradeneeded', { oldVersion: oldVersion, newVersion: version });
                                  req.__transaction = req.result.__versionTransaction = _IDBTransaction2.default.__createInstance(req.result, req.result.objectStoreNames, 'versionchange');
                                  req.transaction.__addNonRequestToTransactionQueue(function onupgradeneeded(tx, args, finished, error) {
                                      req.dispatchEvent(e);
                                      finished();
                                  });
                                  req.transaction.on__beforecomplete = function (ev) {
                                      req.result.__versionTransaction = null;
                                      sysdbFinishedCb(systx, false, function () {
                                          req.transaction.__transFinishedCb(false, function () {
                                              ev.complete();
                                              req.__transaction = null;
                                          });
                                      });
                                  };
                                  req.transaction.on__abort = function () {
                                      req.__transaction = null;
                                      setTimeout(function () {
                                          var err = (0, _DOMException.createDOMException)('AbortError', 'The upgrade transaction was aborted.');
                                          sysdbFinishedCb(systx, err, function () {
                                              dbCreateError(err);
                                          });
                                      });
                                  };
                                  req.transaction.on__complete = function () {
                                      if (req.result.__closed) {
                                          req.__transaction = null;
                                          var _err = (0, _DOMException.createDOMException)('AbortError', 'The connection has been closed.');
                                          dbCreateError(_err);
                                          return;
                                      }
                                      // Since this is running directly after `IDBTransaction.complete`,
                                      //   there should be a new task. However, while increasing the
                                      //   timeout 1ms in `IDBTransaction.__executeRequests` can allow
                                      //   `IDBOpenDBRequest.onsuccess` to trigger faster than a new
                                      //   transaction as required by "transaction-create_in_versionchange" in
                                      //   w3c/Transaction.js (though still on a timeout separate from this
                                      //   preceding `IDBTransaction.oncomplete`), this causes a race condition
                                      //   somehow with old transactions (e.g., for the Mocha test,
                                      //   in `IDBObjectStore.deleteIndex`, "should delete an index that was
                                      //   created in a previous transaction").
                                      // setTimeout(() => {
                                      req.__transaction = null;
                                      var e = (0, _Event.createEvent)('success');
                                      req.dispatchEvent(e);
                                      // });
                                  };
                              }
                              if (oldVersion === 0) {
                                  systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
                              } else {
                                  systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [version, sqlSafeName], versionSet, dbCreateError);
                              }
                          }, dbCreateError, null, function (currentTask, err, done, rollback, commit) {
                              if (currentTask.readOnly || err) {
                                  return true;
                              }
                              sysdbFinishedCb = function sysdbFinishedCb(systx, err, cb) {
                                  if (err) {
                                      rollback(err, cb);
                                  } else {
                                      commit(cb);
                                  }
                              };
                              return false;
                          });
                      } else {
                          var e = (0, _Event.createEvent)('success');
                          req.dispatchEvent(e);
                      }
                  }, dbCreateError);
              }, dbCreateError);
          }, dbCreateError);
      }
  
      createSysDB(function () {
          sysdb.readTransaction(function (sysReadTx) {
              sysReadTx.executeSql('SELECT "version" FROM dbVersions WHERE "name" = ?', [sqlSafeName], function (sysReadTx, data) {
                  if (data.rows.length === 0) {
                      // Database with this name does not exist
                      openDB(0);
                  } else {
                      openDB(data.rows.item(0).version);
                  }
              }, dbCreateError);
          }, dbCreateError);
      }, dbCreateError);
  
      return req;
  };
  
  /**
   * Deletes a database
   * @param {string} name
   * @returns {IDBOpenDBRequest}
   */
  IDBFactory.prototype.deleteDatabase = function (name) {
      if (!(this instanceof IDBFactory)) {
          throw new TypeError('Illegal invocation');
      }
      var req = _IDBRequest.IDBOpenDBRequest.__createInstance();
      var calledDBError = false;
      var version = 0;
  
      if (arguments.length === 0) {
          throw new TypeError('Database name is required');
      }
      name = String(name); // cast to a string
      var sqlSafeName = util.escapeSQLiteStatement(name);
  
      var escapedDatabaseName = void 0;
      try {
          escapedDatabaseName = util.escapeDatabaseNameForSQLAndFiles(name);
      } catch (err) {
          throw err; // throw new TypeError('You have supplied a database name which does not match the currently supported configuration, possibly due to a length limit enforced for Node compatibility.');
      }
  
      var sysdbFinishedCbDelete = function sysdbFinishedCbDelete(err, cb) {
          cb(err);
      };
  
      // Although the spec has no specific conditions where an error
      //  may occur in `deleteDatabase`, it does provide for
      //  `UnknownError` as we may require upon a SQL deletion error
      function dbError(tx, err) {
          if (calledDBError || err === true) {
              return;
          }
          err = (0, _DOMException.webSQLErrback)(err || tx);
          sysdbFinishedCbDelete(true, function () {
              req.__readyState = 'done';
              req.__error = err;
              req.__result = undefined;
              var e = (0, _Event.createEvent)('error', err, { bubbles: true });
              req.dispatchEvent(e);
              calledDBError = true;
          });
      }
  
      createSysDB(function () {
          function databaseDeleted() {
              sysdbFinishedCbDelete(false, function () {
                  req.__result = undefined;
                  req.__readyState = 'done';
                  var e = new _IDBVersionChangeEvent2.default('success', { oldVersion: version, newVersion: null });
                  req.dispatchEvent(e);
              });
          }
          sysdb.readTransaction(function (sysReadTx) {
              sysReadTx.executeSql('SELECT "version" FROM dbVersions WHERE "name" = ?', [sqlSafeName], function (sysReadTx, data) {
                  if (data.rows.length === 0) {
                      req.__result = undefined;
                      var e = new _IDBVersionChangeEvent2.default('success', { oldVersion: version, newVersion: null });
                      req.dispatchEvent(e);
                      return;
                  }
                  version = data.rows.item(0).version;
  
                  // Since we need two databases which can't be in a single transaction, we
                  //  do this deleting from `dbVersions` first since the `__sys__` deleting
                  //  only impacts file memory whereas this one is critical for avoiding it
                  //  being found via `open` or `webkitGetDatabaseNames`; however, we will
                  //  avoid committing anyways until all deletions are made and rollback the
                  //  `dbVersions` change if they fail
                  sysdb.transaction(function (systx) {
                      systx.executeSql('DELETE FROM dbVersions WHERE "name" = ? ', [sqlSafeName], function () {
                          // Todo Node Config: Give config option to Node to delete the entire database file
                          var db = _CFG2.default.win.openDatabase(escapedDatabaseName, 1, name, _CFG2.default.DEFAULT_DB_SIZE);
                          db.transaction(function (tx) {
                              tx.executeSql('SELECT "name" FROM __sys__', [], function (tx, data) {
                                  var tables = data.rows;
                                  (function deleteTables(i) {
                                      if (i >= tables.length) {
                                          // If all tables are deleted, delete the housekeeping tables
                                          tx.executeSql('DROP TABLE IF EXISTS __sys__', [], function () {
                                              databaseDeleted();
                                          }, dbError);
                                      } else {
                                          // Delete all tables in this database, maintained in the sys table
                                          tx.executeSql('DROP TABLE ' + util.escapeStoreNameForSQL(util.unescapeSQLiteResponse( // Avoid double-escaping
                                          tables.item(i).name)), [], function () {
                                              deleteTables(i + 1);
                                          }, function () {
                                              deleteTables(i + 1);
                                          });
                                      }
                                  })(0);
                              }, function (e) {
                                  // __sys__ table does not exist, but that does not mean delete did not happen
                                  databaseDeleted();
                              });
                          });
                      }, dbError);
                  }, dbError, null, function (currentTask, err, done, rollback, commit) {
                      if (currentTask.readOnly || err) {
                          return true;
                      }
                      sysdbFinishedCbDelete = function sysdbFinishedCbDelete(err, cb) {
                          if (err) {
                              rollback(err, cb);
                          } else {
                              commit(cb);
                          }
                      };
                      return false;
                  });
              }, dbError);
          }, dbError);
      }, dbError);
  
      return req;
  };
  
  /**
   * Compares two keys
   * @param key1
   * @param key2
   * @returns {number}
   */
  function cmp(first, second) {
      var encodedKey1 = Key.encode(first);
      var encodedKey2 = Key.encode(second);
      var result = encodedKey1 > encodedKey2 ? 1 : encodedKey1 === encodedKey2 ? 0 : -1;
  
      if (_CFG2.default.DEBUG) {
          // verify that the keys encoded correctly
          var decodedKey1 = Key.decode(encodedKey1);
          var decodedKey2 = Key.decode(encodedKey2);
          if ((typeof first === 'undefined' ? 'undefined' : _typeof(first)) === 'object') {
              first = JSON.stringify(first);
              decodedKey1 = JSON.stringify(decodedKey1);
          }
          if ((typeof second === 'undefined' ? 'undefined' : _typeof(second)) === 'object') {
              second = JSON.stringify(second);
              decodedKey2 = JSON.stringify(decodedKey2);
          }
  
          // encoding/decoding mismatches are usually due to a loss of floating-point precision
          if (decodedKey1 !== first) {
              console.warn(first + ' was incorrectly encoded as ' + decodedKey1);
          }
          if (decodedKey2 !== second) {
              console.warn(second + ' was incorrectly encoded as ' + decodedKey2);
          }
      }
  
      return result;
  }
  
  IDBFactory.prototype.cmp = function (key1, key2) {
      if (!(this instanceof IDBFactory)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length < 2) {
          throw new TypeError('You must provide two keys to be compared');
      }
      // We use encoding facilities already built for proper sorting;
      //   the following "conversions" are for validation only
      Key.convertValueToKeyRethrowingAndIfInvalid(key1);
      Key.convertValueToKeyRethrowingAndIfInvalid(key2);
      return cmp(key1, key2);
  };
  
  /**
  * NON-STANDARD!! (Also may return outdated information if a database has since been deleted)
  * @link https://www.w3.org/Bugs/Public/show_bug.cgi?id=16137
  * @link http://lists.w3.org/Archives/Public/public-webapps/2011JulSep/1537.html
  */
  IDBFactory.prototype.webkitGetDatabaseNames = function () {
      if (!(this instanceof IDBFactory)) {
          throw new TypeError('Illegal invocation');
      }
      var calledDbCreateError = false;
      function dbGetDatabaseNamesError(tx, err) {
          if (calledDbCreateError) {
              return;
          }
          err = err ? (0, _DOMException.webSQLErrback)(err) : tx;
          calledDbCreateError = true;
          var evt = (0, _Event.createEvent)('error', err, { bubbles: true, cancelable: true }); // http://stackoverflow.com/questions/40165909/to-where-do-idbopendbrequest-error-events-bubble-up/40181108#40181108
          req.__readyState = 'done';
          req.__error = err;
          req.__result = undefined;
          req.dispatchEvent(evt);
      }
      var req = _IDBRequest.IDBRequest.__createInstance();
      createSysDB(function () {
          sysdb.readTransaction(function (sysReadTx) {
              sysReadTx.executeSql('SELECT "name" FROM dbVersions', [], function (sysReadTx, data) {
                  var dbNames = _DOMStringList2.default.__createInstance();
                  for (var i = 0; i < data.rows.length; i++) {
                      dbNames.push(util.unescapeSQLiteResponse(data.rows.item(i).name));
                  }
                  req.__result = dbNames;
                  req.__readyState = 'done';
                  var e = (0, _Event.createEvent)('success'); // http://stackoverflow.com/questions/40165909/to-where-do-idbopendbrequest-error-events-bubble-up/40181108#40181108
                  req.dispatchEvent(e);
              }, dbGetDatabaseNamesError);
          }, dbGetDatabaseNamesError);
      }, dbGetDatabaseNamesError);
      return req;
  };
  
  /**
  * @Todo __forceClose: Test
  * This is provided to facilitate unit-testing of the
  *  closing of a database connection with a forced flag:
  * <http://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>
  */
  IDBFactory.prototype.__forceClose = function (connIdx, msg) {
      var me = this;
      function forceClose(conn) {
          conn.__forceClose(msg);
      }
      if (connIdx == null) {
          me.__connections.forEach(forceClose);
      } else if (!Number.isInteger(connIdx) || connIdx < 0 || connIdx > me.__connections.length - 1) {
          throw new TypeError('If providing an argument, __forceClose must be called with a ' + 'numeric index to indicate a specific connection to lose');
      } else {
          forceClose(me.__connections[connIdx]);
      }
  };
  
  IDBFactory.prototype[Symbol.toStringTag] = 'IDBFactoryPrototype';
  
  Object.defineProperty(IDBFactory, 'prototype', {
      writable: false
  });
  
  var shimIndexedDB = IDBFactory.__createInstance();
  exports.IDBFactory = IDBFactory;
  exports.cmp = cmp;
  exports.shimIndexedDB = shimIndexedDB;
  
  },{"./CFG":319,"./DOMException":320,"./DOMStringList":321,"./Event":322,"./IDBDatabase":324,"./IDBRequest":329,"./IDBTransaction":330,"./IDBVersionChangeEvent":331,"./Key":332,"./util":338}],326:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.default = exports.IDBIndex = exports.executeFetchIndexData = exports.buildFetchIndexDataSQL = undefined;
  
  var _DOMException = require('./DOMException');
  
  var _IDBCursor = require('./IDBCursor');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _Key = require('./Key');
  
  var Key = _interopRequireWildcard(_Key);
  
  var _IDBKeyRange = require('./IDBKeyRange');
  
  var _IDBTransaction = require('./IDBTransaction');
  
  var _IDBTransaction2 = _interopRequireDefault(_IDBTransaction);
  
  var _Sca = require('./Sca');
  
  var Sca = _interopRequireWildcard(_Sca);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
  
  var readonlyProperties = ['objectStore', 'keyPath', 'multiEntry', 'unique'];
  
  /**
   * IDB Index
   * http://www.w3.org/TR/IndexedDB/#idl-def-IDBIndex
   * @param {IDBObjectStore} store
   * @param {IDBIndexProperties} indexProperties
   * @constructor
   */
  function IDBIndex() {
      throw new TypeError('Illegal constructor');
  }
  var IDBIndexAlias = IDBIndex;
  IDBIndex.__createInstance = function (store, indexProperties) {
      function IDBIndex() {
          var me = this;
          me[Symbol.toStringTag] = 'IDBIndex';
          util.defineReadonlyProperties(me, readonlyProperties);
          me.__objectStore = store;
          me.__name = me.__originalName = indexProperties.columnName;
          me.__keyPath = Array.isArray(indexProperties.keyPath) ? indexProperties.keyPath.slice() : indexProperties.keyPath;
          var optionalParams = indexProperties.optionalParams;
          me.__multiEntry = !!(optionalParams && optionalParams.multiEntry);
          me.__unique = !!(optionalParams && optionalParams.unique);
          me.__deleted = !!indexProperties.__deleted;
          me.__objectStore.__cursors = indexProperties.cursors || [];
          Object.defineProperty(me, 'name', {
              enumerable: false,
              configurable: false,
              get: function get() {
                  return this.__name;
              },
              set: function set(newName) {
                  var me = this;
                  var oldName = me.name;
                  _IDBTransaction2.default.__assertVersionChange(me.objectStore.transaction);
                  _IDBTransaction2.default.__assertActive(me.objectStore.transaction);
                  if (me.__deleted) {
                      throw (0, _DOMException.createDOMException)('InvalidStateError', 'This index has been deleted');
                  }
                  if (me.objectStore.__deleted) {
                      throw (0, _DOMException.createDOMException)('InvalidStateError', "This index's object store has been deleted");
                  }
                  if (newName === oldName) {
                      return;
                  }
                  if (me.objectStore.__indexes[newName] && !me.objectStore.__indexes[newName].__deleted) {
                      throw (0, _DOMException.createDOMException)('ConstraintError', 'Index "' + newName + '" already exists on ' + me.objectStore.name);
                  }
  
                  delete me.objectStore.__indexes[me.name];
                  me.objectStore.indexNames.splice(me.objectStore.indexNames.indexOf(me.name), 1);
                  me.objectStore.__indexes[newName] = me;
                  me.objectStore.indexNames.push(newName);
  
                  me.__name = newName;
                  // Todo: Add pending flag to delay queries against this index until renamed in SQLite?
                  var colInfoToPreserveArr = [['key', 'BLOB ' + (me.objectStore.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY')], ['value', 'BLOB']];
                  me.__renameIndex(me.objectStore, oldName, newName, colInfoToPreserveArr);
              }
          });
      }
      IDBIndex.prototype = IDBIndexAlias.prototype;
      return new IDBIndex();
  };
  
  /**
   * Clones an IDBIndex instance for a different IDBObjectStore instance.
   * @param {IDBIndex} index
   * @param {IDBObjectStore} store
   * @protected
   */
  IDBIndex.__clone = function (index, store) {
      var idx = IDBIndex.__createInstance(store, {
          columnName: index.name,
          keyPath: index.keyPath,
          optionalParams: {
              multiEntry: index.multiEntry,
              unique: index.unique
          }
      });
      // idx.__deleted = index.__deleted;
      return idx;
  };
  
  /**
   * Creates a new index on an object store.
   * @param {IDBObjectStore} store
   * @param {IDBIndex} index
   * @returns {IDBIndex}
   * @protected
   */
  IDBIndex.__createIndex = function (store, index) {
      var idx = store.__indexes[index.name];
      var columnExists = idx && idx.__deleted;
  
      // Add the index to the IDBObjectStore
      index.__pending = true;
      store.__indexes[index.name] = index;
      store.indexNames.push(index.name);
  
      // Create the index in WebSQL
      var transaction = store.transaction;
      transaction.__addNonRequestToTransactionQueue(function createIndex(tx, args, success, failure) {
          var indexValues = {};
  
          function error(tx, err) {
              failure((0, _DOMException.createDOMException)('UnknownError', 'Could not create index "' + index.name + '"', err));
          }
  
          function applyIndex(tx) {
              // Update the object store's index list
              IDBIndex.__updateIndexList(store, tx, function () {
                  // Add index entries for all existing records
                  tx.executeSql('SELECT "key", "value" FROM ' + util.escapeStoreNameForSQL(store.name), [], function (tx, data) {
                      _CFG2.default.DEBUG && console.log('Adding existing ' + store.name + ' records to the ' + index.name + ' index');
                      addIndexEntry(0);
  
                      function addIndexEntry(i) {
                          if (i < data.rows.length) {
                              try {
                                  var value = Sca.decode(util.unescapeSQLiteResponse(data.rows.item(i).value));
                                  var indexKey = Key.extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry); // Todo: Do we need this stricter error checking?
                                  if (indexKey.invalid || indexKey.failure) {
                                      // Todo: Do we need invalid checks and should we instead treat these as being duplicates?
                                      throw new Error('Go to catch; ignore bad indexKey');
                                  }
                                  indexKey = Key.encode(indexKey.value, index.multiEntry);
                                  if (index.unique) {
                                      if (indexValues[indexKey]) {
                                          indexValues = {};
                                          failure((0, _DOMException.createDOMException)('ConstraintError', 'Duplicate values already exist within the store'));
                                          return;
                                      }
                                      indexValues[indexKey] = true;
                                  }
  
                                  tx.executeSql('UPDATE ' + util.escapeStoreNameForSQL(store.name) + ' SET ' + util.escapeIndexNameForSQL(index.name) + ' = ? WHERE "key" = ?', [util.escapeSQLiteStatement(indexKey), data.rows.item(i).key], function (tx, data) {
                                      addIndexEntry(i + 1);
                                  }, error);
                              } catch (e) {
                                  // Not a valid value to insert into index, so just continue
                                  addIndexEntry(i + 1);
                              }
                          } else {
                              delete index.__pending;
                              indexValues = {};
                              success(store);
                          }
                      }
                  }, error);
              }, error);
          }
  
          if (columnExists) {
              // For a previously existing index, just update the index entries in the existing column
              applyIndex(tx);
          } else {
              // For a new index, add a new column to the object store, then apply the index
              var sql = ['ALTER TABLE', util.escapeStoreNameForSQL(store.name), 'ADD', util.escapeIndexNameForSQL(index.name), 'BLOB'].join(' ');
              _CFG2.default.DEBUG && console.log(sql);
              tx.executeSql(sql, [], applyIndex, error);
          }
      }, undefined, store);
  };
  
  /**
   * Deletes an index from an object store.
   * @param {IDBObjectStore} store
   * @param {IDBIndex} index
   * @protected
   */
  IDBIndex.__deleteIndex = function (store, index) {
      // Remove the index from the IDBObjectStore
      store.__indexes[index.name].__deleted = true;
      store.indexNames.splice(store.indexNames.indexOf(index.name), 1);
  
      // Remove the index in WebSQL
      var transaction = store.transaction;
      transaction.__addNonRequestToTransactionQueue(function deleteIndex(tx, args, success, failure) {
          function error(tx, err) {
              failure((0, _DOMException.createDOMException)('UnknownError', 'Could not delete index "' + index.name + '"', err));
          }
  
          // Update the object store's index list
          IDBIndex.__updateIndexList(store, tx, success, error);
      }, undefined, store);
  };
  
  /**
   * Updates index list for the given object store.
   * @param {IDBObjectStore} store
   * @param {object} tx
   * @param {function} success
   * @param {function} failure
   */
  IDBIndex.__updateIndexList = function (store, tx, success, failure) {
      var indexList = {};
      for (var i = 0; i < store.indexNames.length; i++) {
          var idx = store.__indexes[store.indexNames[i]];
          /** @type {IDBIndexProperties} **/
          indexList[idx.name] = {
              columnName: idx.name,
              keyPath: idx.keyPath,
              optionalParams: {
                  unique: idx.unique,
                  multiEntry: idx.multiEntry
              },
              deleted: !!idx.deleted
          };
      }
  
      _CFG2.default.DEBUG && console.log('Updating the index list for ' + store.name, indexList);
      tx.executeSql('UPDATE __sys__ SET "indexList" = ? WHERE "name" = ?', [JSON.stringify(indexList), util.escapeSQLiteStatement(store.name)], function () {
          success(store);
      }, failure);
  };
  
  /**
   * Retrieves index data for the given key
   * @param {*|IDBKeyRange} range
   * @param {string} opType
   * @param {boolean} nullDisallowed
   * @param {number} count
   * @returns {IDBRequest}
   * @private
   */
  IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed, count) {
      var me = this;
      if (count !== undefined) {
          count = util.enforceRange(count, 'unsigned long');
      }
  
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This index has been deleted');
      }
      if (me.objectStore.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', "This index's object store has been deleted");
      }
      _IDBTransaction2.default.__assertActive(me.objectStore.transaction);
  
      if (nullDisallowed && range == null) {
          throw (0, _DOMException.createDOMException)('DataError', 'No key or range was specified');
      }
  
      var fetchArgs = buildFetchIndexDataSQL(nullDisallowed, me, range, opType, false);
      return me.objectStore.transaction.__addToTransactionQueue(function () {
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
              args[_key] = arguments[_key];
          }
  
          executeFetchIndexData.apply(undefined, [count].concat(_toConsumableArray(fetchArgs), args));
      }, undefined, me);
  };
  
  /**
   * Opens a cursor over the given key range.
   * @param {*|IDBKeyRange} query
   * @param {string} direction
   * @returns {IDBRequest}
   */
  IDBIndex.prototype.openCursor = function () /* query, direction */{
      var me = this;
  
      var _arguments = Array.prototype.slice.call(arguments),
          query = _arguments[0],
          direction = _arguments[1];
  
      var cursor = _IDBCursor.IDBCursorWithValue.__createInstance(query, direction, me.objectStore, me, util.escapeIndexNameForSQLKeyColumn(me.name), 'value');
      me.__objectStore.__cursors.push(cursor);
      return cursor.__req;
  };
  
  /**
   * Opens a cursor over the given key range.  The cursor only includes key values, not data.
   * @param {*|IDBKeyRange} query
   * @param {string} direction
   * @returns {IDBRequest}
   */
  IDBIndex.prototype.openKeyCursor = function () /* query, direction */{
      var me = this;
  
      var _arguments2 = Array.prototype.slice.call(arguments),
          query = _arguments2[0],
          direction = _arguments2[1];
  
      var cursor = _IDBCursor.IDBCursor.__createInstance(query, direction, me.objectStore, me, util.escapeIndexNameForSQLKeyColumn(me.name), 'key');
      me.__objectStore.__cursors.push(cursor);
      return cursor.__req;
  };
  
  IDBIndex.prototype.get = function (query) {
      if (!arguments.length) {
          // Per https://heycam.github.io/webidl/
          throw new TypeError('A parameter was missing for `IDBIndex.get`.');
      }
      return this.__fetchIndexData(query, 'value', true);
  };
  
  IDBIndex.prototype.getKey = function (query) {
      if (!arguments.length) {
          // Per https://heycam.github.io/webidl/
          throw new TypeError('A parameter was missing for `IDBIndex.getKey`.');
      }
      return this.__fetchIndexData(query, 'key', true);
  };
  
  IDBIndex.prototype.getAll = function () /* query, count */{
      var _arguments3 = Array.prototype.slice.call(arguments),
          query = _arguments3[0],
          count = _arguments3[1];
  
      return this.__fetchIndexData(query, 'value', false, count);
  };
  
  IDBIndex.prototype.getAllKeys = function () /* query, count */{
      var _arguments4 = Array.prototype.slice.call(arguments),
          query = _arguments4[0],
          count = _arguments4[1];
  
      return this.__fetchIndexData(query, 'key', false, count);
  };
  
  IDBIndex.prototype.count = function () /* query */{
      var me = this;
      var query = arguments[0];
      // With the exception of needing to check whether the index has been
      //  deleted, we could, for greater spec parity (if not accuracy),
      //  just call:
      //  `return me.__objectStore.count(query);`
  
      if (util.instanceOf(query, _IDBKeyRange.IDBKeyRange)) {
          // Todo: Do we need this block?
          // We don't need to add to cursors array since has the count parameter which won't cache
          return _IDBCursor.IDBCursorWithValue.__createInstance(query, 'next', me.objectStore, me, util.escapeIndexNameForSQLKeyColumn(me.name), 'value', true).__req;
      }
      return me.__fetchIndexData(query, 'count', false);
  };
  
  IDBIndex.prototype.__renameIndex = function (store, oldName, newName) {
      var colInfoToPreserveArr = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
  
      var newNameType = 'BLOB';
      var storeName = store.name;
      var escapedStoreNameSQL = util.escapeStoreNameForSQL(storeName);
      var colNamesToPreserve = colInfoToPreserveArr.map(function (colInfo) {
          return colInfo[0];
      });
      var colInfoToPreserve = colInfoToPreserveArr.map(function (colInfo) {
          return colInfo.join(' ');
      });
      var listColInfoToPreserve = colInfoToPreserve.length ? colInfoToPreserve.join(', ') + ', ' : '';
      var listColsToPreserve = colNamesToPreserve.length ? colNamesToPreserve.join(', ') + ', ' : '';
  
      // We could adapt the approach at http://stackoverflow.com/a/8430746/271577
      //    to make the approach reusable without passing column names, but it is a bit fragile
      store.transaction.__addNonRequestToTransactionQueue(function renameIndex(tx, args, success, error) {
          var sql = 'ALTER TABLE ' + escapedStoreNameSQL + ' RENAME TO tmp_' + escapedStoreNameSQL;
          tx.executeSql(sql, [], function (tx, data) {
              var sql = 'CREATE TABLE ' + escapedStoreNameSQL + '(' + listColInfoToPreserve + util.escapeIndexNameForSQL(newName) + ' ' + newNameType + ')';
              tx.executeSql(sql, [], function (tx, data) {
                  var sql = 'INSERT INTO ' + escapedStoreNameSQL + '(' + listColsToPreserve + util.escapeIndexNameForSQL(newName) + ') SELECT ' + listColsToPreserve + util.escapeIndexNameForSQL(oldName) + ' FROM tmp_' + escapedStoreNameSQL;
                  tx.executeSql(sql, [], function (tx, data) {
                      var sql = 'DROP TABLE tmp_' + escapedStoreNameSQL;
                      tx.executeSql(sql, [], function (tx, data) {
                          success();
                      }, function (tx, err) {
                          error(err);
                      });
                  }, function (tx, err) {
                      error(err);
                  });
              });
          }, function (tx, err) {
              error(err);
          });
      });
  };
  
  Object.defineProperty(IDBIndex, Symbol.hasInstance, {
      value: function value(obj) {
          return util.isObj(obj) && typeof obj.openCursor === 'function' && typeof obj.multiEntry === 'boolean';
      }
  });
  
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBIndex.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  Object.defineProperty(IDBIndex.prototype, 'name', {
      enumerable: true,
      configurable: true,
      get: function get() {
          throw new TypeError('Illegal invocation');
      },
      set: function set(val) {
          throw new TypeError('Illegal invocation');
      }
  });
  IDBIndex.prototype[Symbol.toStringTag] = 'IDBIndexPrototype';
  
  Object.defineProperty(IDBIndex, 'prototype', {
      writable: false
  });
  
  function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range, opType, multiChecks, sql, sqlValues, tx, args, success, error) {
      if (unboundedDisallowed) {
          count = 1;
      }
      if (count) {
          sql.push('LIMIT', count);
      }
      var isCount = opType === 'count';
      _CFG2.default.DEBUG && console.log('Trying to fetch data for Index', sql.join(' '), sqlValues);
      tx.executeSql(sql.join(' '), sqlValues, function (tx, data) {
          var records = [];
          var recordCount = 0;
          var decode = isCount ? function () {} : opType === 'key' ? function (record) {
              // Key.convertValueToKey(record.key); // Already validated before storage
              return Key.decode(util.unescapeSQLiteResponse(record.key));
          } : function (record) {
              // when opType is value
              return Sca.decode(util.unescapeSQLiteResponse(record.value));
          };
          if (index.multiEntry) {
              var escapedIndexNameForKeyCol = util.escapeIndexNameForSQLKeyColumn(index.name);
              var encodedKey = Key.encode(range, index.multiEntry);
  
              var _loop = function _loop(i) {
                  var row = data.rows.item(i);
                  var rowKey = Key.decode(row[escapedIndexNameForKeyCol]);
                  var record = void 0;
                  if (hasKey && (multiChecks && range.some(function (check) {
                      return rowKey.includes(check);
                  }) || // More precise than our SQL
                  Key.isMultiEntryMatch(encodedKey, row[escapedIndexNameForKeyCol]))) {
                      recordCount++;
                      record = row;
                  } else if (!hasKey && !multiChecks) {
                      if (rowKey !== undefined) {
                          recordCount += Array.isArray(rowKey) ? rowKey.length : 1;
                          record = row;
                      }
                  }
                  if (record) {
                      records.push(decode(record));
                      if (unboundedDisallowed) {
                          return 'break';
                      }
                  }
              };
  
              for (var i = 0; i < data.rows.length; i++) {
                  var _ret = _loop(i);
  
                  if (_ret === 'break') break;
              }
          } else {
              for (var i = 0; i < data.rows.length; i++) {
                  var _record = data.rows.item(i);
                  if (_record) {
                      records.push(decode(_record));
                  }
              }
              recordCount = records.length;
          }
          if (isCount) {
              success(recordCount);
          } else if (recordCount === 0) {
              success(unboundedDisallowed ? undefined : []);
          } else {
              success(unboundedDisallowed ? records[0] : records);
          }
      }, error);
  }
  
  function buildFetchIndexDataSQL(nullDisallowed, index, range, opType, multiChecks) {
      var hasRange = nullDisallowed || range != null;
      var col = opType === 'count' ? 'key' : opType; // It doesn't matter which column we use for 'count' as long as it is valid
      var sql = ['SELECT', util.sqlQuote(col) + (index.multiEntry ? ', ' + util.escapeIndexNameForSQL(index.name) : ''), 'FROM', util.escapeStoreNameForSQL(index.objectStore.name), 'WHERE', util.escapeIndexNameForSQL(index.name), 'NOT NULL'];
      var sqlValues = [];
      if (hasRange) {
          if (multiChecks) {
              sql.push('AND (');
              range.forEach(function (innerKey, i) {
                  if (i > 0) sql.push('OR');
                  sql.push(util.escapeIndexNameForSQL(index.name), "LIKE ? ESCAPE '^' ");
                  sqlValues.push('%' + util.sqlLIKEEscape(Key.encode(innerKey, index.multiEntry)) + '%');
              });
              sql.push(')');
          } else if (index.multiEntry) {
              sql.push('AND', util.escapeIndexNameForSQL(index.name), "LIKE ? ESCAPE '^'");
              sqlValues.push('%' + util.sqlLIKEEscape(Key.encode(range, index.multiEntry)) + '%');
          } else {
              var convertedRange = (0, _IDBKeyRange.convertValueToKeyRange)(range, nullDisallowed);
              (0, _IDBKeyRange.setSQLForKeyRange)(convertedRange, util.escapeIndexNameForSQL(index.name), sql, sqlValues, true, false);
          }
      }
      return [nullDisallowed, index, hasRange, range, opType, multiChecks, sql, sqlValues];
  }
  
  exports.buildFetchIndexDataSQL = buildFetchIndexDataSQL;
  exports.executeFetchIndexData = executeFetchIndexData;
  exports.IDBIndex = IDBIndex;
  exports.default = IDBIndex;
  
  },{"./CFG":319,"./DOMException":320,"./IDBCursor":323,"./IDBKeyRange":327,"./IDBTransaction":330,"./Key":332,"./Sca":333,"./util":338}],327:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.default = exports.convertValueToKeyRange = exports.IDBKeyRange = exports.setSQLForKeyRange = undefined;
  
  var _DOMException = require('./DOMException');
  
  var _Key = require('./Key');
  
  var Key = _interopRequireWildcard(_Key);
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  var readonlyProperties = ['lower', 'upper', 'lowerOpen', 'upperOpen'];
  
  /**
   * The IndexedDB KeyRange object
   * http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#dfn-key-range
   * @param {Object} lower
   * @param {Object} upper
   * @param {Object} lowerOpen
   * @param {Object} upperOpen
   */
  function IDBKeyRange() {
      throw new TypeError('Illegal constructor');
  }
  var IDBKeyRangeAlias = IDBKeyRange;
  IDBKeyRange.__createInstance = function (lower, upper, lowerOpen, upperOpen) {
      function IDBKeyRange() {
          this[Symbol.toStringTag] = 'IDBKeyRange';
          if (lower === undefined && upper === undefined) {
              throw (0, _DOMException.createDOMException)('DataError', 'Both arguments to the key range method cannot be undefined');
          }
          var lowerConverted = void 0,
              upperConverted = void 0;
          if (lower !== undefined) {
              lowerConverted = Key.roundTrip(lower); // Todo: does this make the "conversions" redundant
              Key.convertValueToKeyRethrowingAndIfInvalid(lower);
          }
          if (upper !== undefined) {
              upperConverted = Key.roundTrip(upper); // Todo: does this make the "conversions" redundant
              Key.convertValueToKeyRethrowingAndIfInvalid(upper);
          }
          if (lower !== undefined && upper !== undefined && lower !== upper) {
              if (Key.encode(lower) > Key.encode(upper)) {
                  throw (0, _DOMException.createDOMException)('DataError', '`lower` must not be greater than `upper` argument in `bound()` call.');
              }
          }
  
          this.__lower = lowerConverted;
          this.__upper = upperConverted;
          this.__lowerOpen = !!lowerOpen;
          this.__upperOpen = !!upperOpen;
      }
      IDBKeyRange.prototype = IDBKeyRangeAlias.prototype;
      return new IDBKeyRange();
  };
  IDBKeyRange.prototype.includes = function (key) {
      // We can't do a regular instanceof check as it will create a loop given our hasInstance implementation
      if (!util.isObj(this) || typeof this.__lowerOpen !== 'boolean') {
          throw new TypeError('Illegal invocation');
      }
      if (!arguments.length) {
          throw new TypeError('IDBKeyRange.includes requires a key argument');
      }
      Key.convertValueToKeyRethrowingAndIfInvalid(key);
      return Key.isKeyInRange(key, this);
  };
  
  IDBKeyRange.only = function (value) {
      if (!arguments.length) {
          throw new TypeError('IDBKeyRange.only requires a value argument');
      }
      return IDBKeyRange.__createInstance(value, value, false, false);
  };
  
  IDBKeyRange.lowerBound = function (value /*, open */) {
      if (!arguments.length) {
          throw new TypeError('IDBKeyRange.lowerBound requires a value argument');
      }
      return IDBKeyRange.__createInstance(value, undefined, arguments[1], true);
  };
  IDBKeyRange.upperBound = function (value /*, open */) {
      if (!arguments.length) {
          throw new TypeError('IDBKeyRange.upperBound requires a value argument');
      }
      return IDBKeyRange.__createInstance(undefined, value, true, arguments[1]);
  };
  IDBKeyRange.bound = function (lower, upper /* , lowerOpen, upperOpen */) {
      if (arguments.length <= 1) {
          throw new TypeError('IDBKeyRange.bound requires lower and upper arguments');
      }
      return IDBKeyRange.__createInstance(lower, upper, arguments[2], arguments[3]);
  };
  IDBKeyRange.prototype[Symbol.toStringTag] = 'IDBKeyRangePrototype';
  
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBKeyRange.prototype, '__' + prop, {
          enumerable: false,
          configurable: false,
          writable: true
      });
      Object.defineProperty(IDBKeyRange.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              // We can't do a regular instanceof check as it will create a loop given our hasInstance implementation
              if (!util.isObj(this) || typeof this.__lowerOpen !== 'boolean') {
                  throw new TypeError('Illegal invocation');
              }
              return this['__' + prop];
          }
      });
  });
  
  Object.defineProperty(IDBKeyRange, Symbol.hasInstance, {
      value: function value(obj) {
          return util.isObj(obj) && 'upper' in obj && typeof obj.lowerOpen === 'boolean';
      }
  });
  
  Object.defineProperty(IDBKeyRange, 'prototype', {
      writable: false
  });
  
  function setSQLForKeyRange(range, quotedKeyColumnName, sql, sqlValues, addAnd, checkCached) {
      if (range && (range.lower !== undefined || range.upper !== undefined)) {
          if (addAnd) sql.push('AND');
          var encodedLowerKey = void 0,
              encodedUpperKey = void 0;
          var hasLower = range.lower !== undefined;
          var hasUpper = range.upper !== undefined;
          if (hasLower) {
              encodedLowerKey = checkCached ? range.__lowerCached : Key.encode(range.lower);
          }
          if (hasUpper) {
              encodedUpperKey = checkCached ? range.__upperCached : Key.encode(range.upper);
          }
          if (hasLower) {
              sqlValues.push(util.escapeSQLiteStatement(encodedLowerKey));
              if (hasUpper && encodedLowerKey === encodedUpperKey && !range.lowerOpen && !range.upperOpen) {
                  sql.push(quotedKeyColumnName, '=', '?');
                  return;
              }
              sql.push(quotedKeyColumnName, range.lowerOpen ? '>' : '>=', '?');
          }
          hasLower && hasUpper && sql.push('AND');
          if (hasUpper) {
              sql.push(quotedKeyColumnName, range.upperOpen ? '<' : '<=', '?');
              sqlValues.push(util.escapeSQLiteStatement(encodedUpperKey));
          }
      }
  }
  
  function convertValueToKeyRange(value, nullDisallowed) {
      if (util.instanceOf(value, IDBKeyRange)) {
          // We still need to validate IDBKeyRange-like objects (the above check is based on loose duck-typing)
          if (!value.toString() !== '[object IDBKeyRange]') {
              return IDBKeyRange.__createInstance(value.lower, value.upper, value.lowerOpen, value.upperOpen);
          }
          return value;
      }
      if (value == null) {
          if (nullDisallowed) {
              throw (0, _DOMException.createDOMException)('DataError', 'No key or range was specified');
          }
          return undefined; // Represents unbounded
      }
      Key.convertValueToKeyRethrowingAndIfInvalid(value);
      return IDBKeyRange.only(value);
  }
  
  exports.setSQLForKeyRange = setSQLForKeyRange;
  exports.IDBKeyRange = IDBKeyRange;
  exports.convertValueToKeyRange = convertValueToKeyRange;
  exports.default = IDBKeyRange;
  
  },{"./DOMException":320,"./Key":332,"./util":338}],328:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
  
  var _DOMException = require('./DOMException');
  
  var _IDBCursor = require('./IDBCursor');
  
  var _IDBKeyRange = require('./IDBKeyRange');
  
  var _DOMStringList = require('./DOMStringList');
  
  var _DOMStringList2 = _interopRequireDefault(_DOMStringList);
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _Key = require('./Key');
  
  var Key = _interopRequireWildcard(_Key);
  
  var _IDBIndex = require('./IDBIndex');
  
  var _IDBTransaction = require('./IDBTransaction');
  
  var _IDBTransaction2 = _interopRequireDefault(_IDBTransaction);
  
  var _Sca = require('./Sca');
  
  var Sca = _interopRequireWildcard(_Sca);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  var _syncPromise = require('sync-promise');
  
  var _syncPromise2 = _interopRequireDefault(_syncPromise);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
  
  var readonlyProperties = ['keyPath', 'indexNames', 'transaction', 'autoIncrement'];
  
  /**
   * IndexedDB Object Store
   * http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBObjectStore
   * @param {IDBObjectStoreProperties} storeProperties
   * @param {IDBTransaction} transaction
   * @constructor
   */
  function IDBObjectStore() {
      throw new TypeError('Illegal constructor');
  }
  var IDBObjectStoreAlias = IDBObjectStore;
  IDBObjectStore.__createInstance = function (storeProperties, transaction) {
      function IDBObjectStore() {
          var me = this;
          me[Symbol.toStringTag] = 'IDBObjectStore';
          util.defineReadonlyProperties(this, readonlyProperties);
          me.__name = me.__originalName = storeProperties.name;
          me.__keyPath = Array.isArray(storeProperties.keyPath) ? storeProperties.keyPath.slice() : storeProperties.keyPath;
          me.__transaction = transaction;
          me.__idbdb = storeProperties.idbdb;
          me.__cursors = storeProperties.cursors || [];
  
          // autoInc is numeric (0/1) on WinPhone
          me.__autoIncrement = !!storeProperties.autoInc;
  
          me.__indexes = {};
          me.__indexNames = _DOMStringList2.default.__createInstance();
          var indexList = storeProperties.indexList;
          for (var indexName in indexList) {
              if (indexList.hasOwnProperty(indexName)) {
                  var index = _IDBIndex.IDBIndex.__createInstance(me, indexList[indexName]);
                  me.__indexes[index.name] = index;
                  if (!index.__deleted) {
                      me.indexNames.push(index.name);
                  }
              }
          }
          me.__oldIndexNames = me.indexNames.clone();
          Object.defineProperty(this, 'name', {
              enumerable: false,
              configurable: false,
              get: function get() {
                  return this.__name;
              },
              set: function set(name) {
                  var me = this;
                  if (me.__deleted) {
                      throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
                  }
                  _IDBTransaction2.default.__assertVersionChange(me.transaction);
                  _IDBTransaction2.default.__assertActive(me.transaction);
                  if (me.name === name) {
                      return;
                  }
                  if (me.__idbdb.__objectStores[name]) {
                      throw (0, _DOMException.createDOMException)('ConstraintError', 'Object store "' + name + '" already exists in ' + me.__idbdb.name);
                  }
  
                  delete me.__idbdb.__objectStores[me.name];
                  me.__idbdb.objectStoreNames.splice(me.__idbdb.objectStoreNames.indexOf(me.name), 1);
                  me.__idbdb.__objectStores[name] = me;
                  me.__idbdb.objectStoreNames.push(name);
                  me.__name = name;
                  // Todo: Add pending flag to delay queries against this store until renamed in SQLite
  
                  var sql = 'ALTER TABLE ' + util.escapeStoreNameForSQL(me.name) + ' RENAME TO ' + util.escapeStoreNameForSQL(name);
                  me.transaction.__addNonRequestToTransactionQueue(function objectStoreClear(tx, args, success, error) {
                      tx.executeSql(sql, [], function (tx, data) {
                          success();
                      }, function (tx, err) {
                          error(err);
                      });
                  });
              }
          });
      }
      IDBObjectStore.prototype = IDBObjectStoreAlias.prototype;
      return new IDBObjectStore();
  };
  
  /**
   * Clones an IDBObjectStore instance for a different IDBTransaction instance.
   * @param {IDBObjectStore} store
   * @param {IDBTransaction} transaction
   * @protected
   */
  IDBObjectStore.__clone = function (store, transaction) {
      var newStore = IDBObjectStore.__createInstance({
          name: store.name,
          keyPath: Array.isArray(store.keyPath) ? store.keyPath.slice() : store.keyPath,
          autoInc: store.autoIncrement,
          indexList: {},
          idbdb: store.__idbdb,
          cursors: store.__cursors
      }, transaction);
  
      newStore.__indexes = store.__indexes;
      newStore.__indexNames = store.indexNames;
      newStore.__oldIndexNames = store.__oldIndexNames;
      return newStore;
  };
  
  /**
   * Creates a new object store in the database.
   * @param {IDBDatabase} db
   * @param {IDBObjectStore} store
   * @protected
   */
  IDBObjectStore.__createObjectStore = function (db, store) {
      // Add the object store to the IDBDatabase
      db.__objectStores[store.name] = store;
      db.objectStoreNames.push(store.name);
  
      // Add the object store to WebSQL
      var transaction = db.__versionTransaction;
      _IDBTransaction2.default.__assertVersionChange(transaction);
  
      transaction.__addNonRequestToTransactionQueue(function createObjectStore(tx, args, success, failure) {
          function error(tx, err) {
              _CFG2.default.DEBUG && console.log(err);
              failure((0, _DOMException.createDOMException)('UnknownError', 'Could not create object store "' + store.name + '"', err));
          }
  
          // key INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE
          var sql = ['CREATE TABLE', util.escapeStoreNameForSQL(store.name), '(key BLOB', store.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY', ', value BLOB)'].join(' ');
          _CFG2.default.DEBUG && console.log(sql);
          tx.executeSql(sql, [], function (tx, data) {
              Sca.encode(store.keyPath, function (encodedKeyPath) {
                  tx.executeSql('INSERT INTO __sys__ VALUES (?,?,?,?,?)', [util.escapeSQLiteStatement(store.name), encodedKeyPath, store.autoIncrement, '{}', 1], function () {
                      success(store);
                  }, error);
              });
          }, error);
      });
  };
  
  /**
   * Deletes an object store from the database.
   * @param {IDBDatabase} db
   * @param {IDBObjectStore} store
   * @protected
   */
  IDBObjectStore.__deleteObjectStore = function (db, store) {
      // Remove the object store from the IDBDatabase
      store.__deleted = true;
      db.__objectStores[store.name] = undefined;
      db.objectStoreNames.splice(db.objectStoreNames.indexOf(store.name), 1);
  
      var storeClone = db.__versionTransaction.__storeClones[store.name];
      if (storeClone) {
          storeClone.__indexNames = _DOMStringList2.default.__createInstance();
          storeClone.__indexes = {};
          storeClone.__deleted = true;
      }
  
      // Remove the object store from WebSQL
      var transaction = db.__versionTransaction;
      _IDBTransaction2.default.__assertVersionChange(transaction);
  
      transaction.__addNonRequestToTransactionQueue(function deleteObjectStore(tx, args, success, failure) {
          function error(tx, err) {
              _CFG2.default.DEBUG && console.log(err);
              failure((0, _DOMException.createDOMException)('UnknownError', 'Could not delete ObjectStore', err));
          }
  
          tx.executeSql('SELECT "name", "keyPath", "autoInc", "indexList", "currNum" FROM __sys__ WHERE "name" = ?', [util.escapeSQLiteStatement(store.name)], function (tx, data) {
              if (data.rows.length > 0) {
                  tx.executeSql('DROP TABLE ' + util.escapeStoreNameForSQL(store.name), [], function () {
                      tx.executeSql('DELETE FROM __sys__ WHERE "name" = ?', [util.escapeSQLiteStatement(store.name)], function () {
                          success();
                      }, error);
                  }, error);
              }
          });
      });
  };
  
  // Todo: Although we may end up needing to do cloning genuinely asynchronously (for Blobs and FileLists),
  //   and we'll want to ensure the queue starts up synchronously, we nevertheless do the cloning
  //   before entering the queue and its callback since the encoding we do is preceded by validation
  //   which we must do synchronously anyways. If we reimplement Blobs and FileLists asynchronously,
  //   we can detect these types (though validating synchronously as possible) and once entering the
  //   queue callback, ensure they load before triggering success or failure (perhaps by returning and
  //   a `SyncPromise` from the `Sca.clone` operation and later detecting and ensuring it is resolved
  //   before continuing).
  /**
   * Determines whether the given inline or out-of-line key is valid, according to the object store's schema.
   * @param {*} value     Used for inline keys
   * @param {*} key       Used for out-of-line keys
   * @private
   */
  IDBObjectStore.prototype.__validateKeyAndValueAndCloneValue = function (value, key, cursorUpdate) {
      var me = this;
      if (me.keyPath !== null) {
          if (key !== undefined) {
              throw (0, _DOMException.createDOMException)('DataError', 'The object store uses in-line keys and the key parameter was provided', me);
          }
          // Todo Binary: Avoid blobs loading async to ensure cloning (and errors therein)
          //   occurs sync; then can make cloning and this method without callbacks (except where ok
          //   to be async)
          var _clonedValue = Sca.clone(value);
          key = Key.extractKeyValueDecodedFromValueUsingKeyPath(_clonedValue, me.keyPath); // May throw so "rethrow"
          if (key.invalid) {
              throw (0, _DOMException.createDOMException)('DataError', 'KeyPath was specified, but key was invalid.');
          }
          if (key.failure) {
              if (!cursorUpdate) {
                  if (!me.autoIncrement) {
                      throw (0, _DOMException.createDOMException)('DataError', 'Could not evaluate a key from keyPath and there is no key generator');
                  }
                  if (!Key.checkKeyCouldBeInjectedIntoValue(_clonedValue, me.keyPath)) {
                      throw (0, _DOMException.createDOMException)('DataError', 'A key could not be injected into a value');
                  }
                  // A key will be generated
                  return [undefined, _clonedValue];
              }
              throw (0, _DOMException.createDOMException)('DataError', 'Could not evaluate a key from keyPath');
          }
          // An `IDBCursor.update` call will also throw if not equal to the cursor’s effective key
          return [key.value, _clonedValue];
      }
      if (key === undefined) {
          if (!me.autoIncrement) {
              throw (0, _DOMException.createDOMException)('DataError', 'The object store uses out-of-line keys and has no key generator and the key parameter was not provided.', me);
          }
          // A key will be generated
          key = undefined;
      } else {
          Key.convertValueToKeyRethrowingAndIfInvalid(key);
      }
      var clonedValue = Sca.clone(value);
      return [key, clonedValue];
  };
  
  /**
   * From the store properties and object, extracts the value for the key in the object store
   * If the table has auto increment, get the current number (unless it has a keyPath leading to a
   *  valid but non-numeric or < 1 key)
   * @param {Object} tx
   * @param {Object} value
   * @param {Object} key
   * @param {function} success
   * @param {function} failure
   */
  IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failure) {
      var me = this;
  
      // Only run if cloning is needed
      function keyCloneThenSuccess() {
          Sca.encode(key, function (key) {
              key = Sca.decode(key);
              success(key);
          });
      }
  
      function getCurrentNumber(callback) {
          tx.executeSql('SELECT "currNum" FROM __sys__ WHERE "name" = ?', [util.escapeSQLiteStatement(me.name)], function (tx, data) {
              if (data.rows.length !== 1) {
                  callback(1);
              } else {
                  callback(data.rows.item(0).currNum);
              }
          }, function (tx, error) {
              failure((0, _DOMException.createDOMException)('DataError', 'Could not get the auto increment value for key', error));
          });
      }
  
      // Bump up the auto-inc counter if the key path-resolved value is valid (greater than old value and >=1) OR
      //  if a manually passed in key is valid (numeric and >= 1) and >= any primaryKey
      function setCurrentNumber() {
          var sql = 'UPDATE __sys__ SET "currNum" = ? WHERE "name" = ?';
          var sqlValues = [Math.floor(key) + 1, util.escapeSQLiteStatement(me.name)];
          _CFG2.default.DEBUG && console.log(sql, sqlValues);
          tx.executeSql(sql, sqlValues, function (tx, data) {
              keyCloneThenSuccess();
          }, function (tx, err) {
              failure((0, _DOMException.createDOMException)('UnknownError', 'Could not set the auto increment value for key', err));
          });
      }
      // Increment current number by 1 (we cannot leverage SQLite's
      //  autoincrement (and decrement when not needed), as decrementing
      //  will be overwritten/ignored upon the next insert)
      function incrementCurrentNumber(cn, cb) {
          var sql = 'UPDATE __sys__ SET "currNum" = "currNum" + 1 WHERE "name" = ?';
          var sqlValues = [util.escapeSQLiteStatement(me.name)];
          _CFG2.default.DEBUG && console.log(sql, sqlValues);
          tx.executeSql(sql, sqlValues, function (tx, data) {
              cb();
              success(cn);
          }, function (tx, err) {
              failure((0, _DOMException.createDOMException)('UnknownError', 'Could not set the auto increment value for key', err));
          });
      }
  
      // We don't begin with in-line steps to "extract a key from a value using a key path"
      //   as already run and already treating any (acceptable) failures as `undefined`
  
      if (me.autoIncrement) {
          // If auto-increment and no valid primaryKey found on the keyPath, get and set the new value, and use
          if (key === undefined) {
              getCurrentNumber(function (cn) {
                  if (cn > 9007199254740992) {
                      // 2 ^ 53 (See <https://github.com/w3c/IndexedDB/issues/147>)
                      failure((0, _DOMException.createDOMException)('ConstraintError', 'The key generator\'s current number has reached the maximum safe integer limit'));
                      return;
                  }
                  incrementCurrentNumber(cn, function () {
                      if (me.keyPath !== null) {
                          try {
                              Key.injectKeyIntoValueUsingKeyPath(value, cn, me.keyPath);
                          } catch (e) {
                              failure((0, _DOMException.createDOMException)('DataError', 'Could not assign a generated value to the keyPath', e));
                          }
                      }
                  });
              });
          } else if (!Number.isFinite(key) || key < 1) {
              // Optimize with no need to get the current number
              // Auto-increment attempted with a bad (non-numeric/non-finite or < 1) key;
              //   the steps don't mention failure but we are not to change the current number
              keyCloneThenSuccess();
          } else {
              // If auto-increment and the keyPath item is a valid numeric key, get the old auto-increment to compare if the new is higher
              //  to determine which to use and whether to update the current number
              getCurrentNumber(function (cn) {
                  var useNewKeyForAutoInc = key >= cn;
                  if (useNewKeyForAutoInc) {
                      setCurrentNumber();
                  } else {
                      keyCloneThenSuccess();
                  }
              });
          }
          // Not auto-increment
      } else {
          keyCloneThenSuccess();
      }
  };
  
  IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyOrCurrentNumber, success, error) {
      var me = this;
      // The `ConstraintError` to occur for `add` upon a duplicate will occur naturally in attempting an insert
      // We process the index information first as it will stored in the same table as the store
      var paramMap = {};
      var indexPromises = me.indexNames.map(function (indexName) {
          // While this may sometimes resolve sync and sometimes async, the
          //   idea is to avoid, where possible, unnecessary delays (and
          //   consuming code ought to only see a difference in the browser
          //   where we can't control the transaction timeout anyways).
          return new _syncPromise2.default(function (resolve, reject) {
              var index = me.__indexes[indexName];
              if (index.__pending) {
                  resolve();
                  return;
              }
              var indexKey = void 0;
              try {
                  indexKey = Key.extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry); // Add as necessary to this and skip past this index if exceptions here)
                  if (indexKey.invalid || indexKey.failure) {
                      throw new Error('Go to catch');
                  }
              } catch (err) {
                  resolve();
                  return;
              }
              indexKey = indexKey.value;
              function setIndexInfo(index) {
                  if (indexKey === undefined) {
                      return;
                  }
                  paramMap[index.name] = Key.encode(indexKey, index.multiEntry);
              }
              if (index.unique) {
                  var multiCheck = index.multiEntry && Array.isArray(indexKey);
                  var fetchArgs = (0, _IDBIndex.buildFetchIndexDataSQL)(true, index, indexKey, 'key', multiCheck);
                  _IDBIndex.executeFetchIndexData.apply(undefined, [null].concat(_toConsumableArray(fetchArgs), [tx, null, function success(key) {
                      if (key === undefined) {
                          setIndexInfo(index);
                          resolve();
                          return;
                      }
                      reject((0, _DOMException.createDOMException)('ConstraintError', 'Index already contains a record equal to ' + (multiCheck ? 'one of the subkeys of' : '') + '`indexKey`'));
                  }, reject]));
              } else {
                  setIndexInfo(index);
                  resolve();
              }
          });
      });
      _syncPromise2.default.all(indexPromises).then(function () {
          var sqlStart = ['INSERT INTO', util.escapeStoreNameForSQL(me.name), '('];
          var sqlEnd = [' VALUES ('];
          var insertSqlValues = [];
          if (clonedKeyOrCurrentNumber !== undefined) {
              // Key.convertValueToKey(primaryKey); // Already run
              sqlStart.push(util.sqlQuote('key'), ',');
              sqlEnd.push('?,');
              insertSqlValues.push(util.escapeSQLiteStatement(Key.encode(clonedKeyOrCurrentNumber)));
          }
          for (var key in paramMap) {
              sqlStart.push(util.escapeIndexNameForSQL(key) + ',');
              sqlEnd.push('?,');
              insertSqlValues.push(util.escapeSQLiteStatement(paramMap[key]));
          }
          // removing the trailing comma
          sqlStart.push(util.sqlQuote('value') + ' )');
          sqlEnd.push('?)');
          insertSqlValues.push(util.escapeSQLiteStatement(encoded));
  
          var insertSql = sqlStart.join(' ') + sqlEnd.join(' ');
          _CFG2.default.DEBUG && console.log('SQL for adding', insertSql, insertSqlValues);
  
          tx.executeSql(insertSql, insertSqlValues, function (tx, data) {
              success(clonedKeyOrCurrentNumber);
          }, function (tx, err) {
              // Should occur for `add` operation
              error((0, _DOMException.createDOMException)('ConstraintError', err.message, err));
          });
      }).catch(function (err) {
          error(err);
      });
  };
  
  IDBObjectStore.prototype.add = function (value /* , key */) {
      var me = this;
      var key = arguments[1];
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No value was specified');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
      me.transaction.__assertWritable();
  
      var request = me.transaction.__createRequest(me);
  
      var _me$__validateKeyAndV = me.__validateKeyAndValueAndCloneValue(value, key, false),
          _me$__validateKeyAndV2 = _slicedToArray(_me$__validateKeyAndV, 2),
          ky = _me$__validateKeyAndV2[0],
          clonedValue = _me$__validateKeyAndV2[1];
  
      IDBObjectStore.__stepsStoringRecordObjectStore(request, me, clonedValue, true, ky);
      return request;
  };
  
  IDBObjectStore.prototype.put = function (value /*, key */) {
      var me = this;
      var key = arguments[1];
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No value was specified');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
      me.transaction.__assertWritable();
  
      var request = me.transaction.__createRequest(me);
  
      var _me$__validateKeyAndV3 = me.__validateKeyAndValueAndCloneValue(value, key, false),
          _me$__validateKeyAndV4 = _slicedToArray(_me$__validateKeyAndV3, 2),
          ky = _me$__validateKeyAndV4[0],
          clonedValue = _me$__validateKeyAndV4[1];
  
      IDBObjectStore.__stepsStoringRecordObjectStore(request, me, clonedValue, false, ky);
      return request;
  };
  
  IDBObjectStore.prototype.__overwrite = function (tx, key, cb, error) {
      var me = this;
      // First try to delete if the record exists
      // Key.convertValueToKey(key); // Already run
      var sql = 'DELETE FROM ' + util.escapeStoreNameForSQL(me.name) + ' WHERE "key" = ?';
      var encodedKey = Key.encode(key);
      tx.executeSql(sql, [util.escapeSQLiteStatement(encodedKey)], function (tx, data) {
          _CFG2.default.DEBUG && console.log('Did the row with the', key, 'exist? ', data.rowsAffected);
          cb(tx);
      }, function (tx, err) {
          error(err);
      });
  };
  
  IDBObjectStore.__stepsStoringRecordObjectStore = function (request, store, value, noOverwrite /* , key */) {
      var key = arguments[4];
      store.transaction.__pushToQueue(request, function (tx, args, success, error) {
          store.__deriveKey(tx, value, key, function (clonedKeyOrCurrentNumber) {
              Sca.encode(value, function (encoded) {
                  function insert(tx) {
                      store.__insertData(tx, encoded, value, clonedKeyOrCurrentNumber, function () {
                          store.__cursors.forEach(function (cursor) {
                              cursor.__invalidateCache();
                          });
                          success.apply(undefined, arguments);
                      }, error);
                  }
                  if (!noOverwrite) {
                      store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
                      return;
                  }
                  insert(tx);
              });
          }, error);
      });
  };
  
  IDBObjectStore.prototype.__get = function (query, getKey, getAll, count) {
      var me = this;
      if (count !== undefined) {
          count = util.enforceRange(count, 'unsigned long');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
  
      var range = (0, _IDBKeyRange.convertValueToKeyRange)(query, !getAll);
  
      var col = getKey ? 'key' : 'value';
      var sql = ['SELECT', util.sqlQuote(col), 'FROM', util.escapeStoreNameForSQL(me.name)];
      var sqlValues = [];
      if (range !== undefined) {
          sql.push('WHERE');
          (0, _IDBKeyRange.setSQLForKeyRange)(range, util.sqlQuote('key'), sql, sqlValues);
      }
      if (!getAll) {
          count = 1;
      }
      if (count) {
          if (typeof count !== 'number' || isNaN(count) || !isFinite(count)) {
              throw new TypeError('The count parameter must be a finite number');
          }
          sql.push('LIMIT', count);
      }
      sql = sql.join(' ');
      return me.transaction.__addToTransactionQueue(function objectStoreGet(tx, args, success, error) {
          _CFG2.default.DEBUG && console.log('Fetching', me.name, sqlValues);
          tx.executeSql(sql, sqlValues, function (tx, data) {
              _CFG2.default.DEBUG && console.log('Fetched data', data);
              var ret = void 0;
              try {
                  // Opera can't deal with the try-catch here.
                  if (data.rows.length === 0) {
                      return getAll ? success([]) : success();
                  }
                  ret = [];
                  if (getKey) {
                      for (var i = 0; i < data.rows.length; i++) {
                          // Key.convertValueToKey(data.rows.item(i).key); // Already validated before storage
                          ret.push(Key.decode(util.unescapeSQLiteResponse(data.rows.item(i).key), false));
                      }
                  } else {
                      for (var _i = 0; _i < data.rows.length; _i++) {
                          ret.push(Sca.decode(util.unescapeSQLiteResponse(data.rows.item(_i).value)));
                      }
                  }
                  if (!getAll) {
                      ret = ret[0];
                  }
              } catch (e) {
                  // If no result is returned, or error occurs when parsing JSON
                  _CFG2.default.DEBUG && console.log(e);
              }
              success(ret);
          }, function (tx, err) {
              error(err);
          });
      }, undefined, me);
  };
  
  IDBObjectStore.prototype.get = function (query) {
      if (!arguments.length) {
          throw new TypeError('A parameter was missing for `IDBObjectStore.get`.');
      }
      return this.__get(query);
  };
  
  IDBObjectStore.prototype.getKey = function (query) {
      if (!arguments.length) {
          throw new TypeError('A parameter was missing for `IDBObjectStore.getKey`.');
      }
      return this.__get(query, true);
  };
  
  IDBObjectStore.prototype.getAll = function () /* query, count */{
      if (!arguments.length) {
          throw new TypeError('A parameter was missing for `IDBObjectStore.getAll`.');
      }
  
      var _arguments = Array.prototype.slice.call(arguments),
          query = _arguments[0],
          count = _arguments[1];
  
      return this.__get(query, false, true, count);
  };
  
  IDBObjectStore.prototype.getAllKeys = function () /* query, count */{
      if (!arguments.length) {
          throw new TypeError('A parameter was missing for `IDBObjectStore.getAllKeys`.');
      }
  
      var _arguments2 = Array.prototype.slice.call(arguments),
          query = _arguments2[0],
          count = _arguments2[1];
  
      return this.__get(query, true, true, count);
  };
  
  IDBObjectStore.prototype['delete'] = function (query) {
      var me = this;
      if (!(this instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (!arguments.length) {
          throw new TypeError('A parameter was missing for `IDBObjectStore.delete`.');
      }
  
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
      me.transaction.__assertWritable();
  
      var range = (0, _IDBKeyRange.convertValueToKeyRange)(query, true);
  
      var sqlArr = ['DELETE FROM', util.escapeStoreNameForSQL(me.name), 'WHERE'];
      var sqlValues = [];
      (0, _IDBKeyRange.setSQLForKeyRange)(range, util.sqlQuote('key'), sqlArr, sqlValues);
      var sql = sqlArr.join(' ');
  
      return me.transaction.__addToTransactionQueue(function objectStoreDelete(tx, args, success, error) {
          _CFG2.default.DEBUG && console.log('Deleting', me.name, sqlValues);
          tx.executeSql(sql, sqlValues, function (tx, data) {
              _CFG2.default.DEBUG && console.log('Deleted from database', data.rowsAffected);
              me.__cursors.forEach(function (cursor) {
                  cursor.__invalidateCache(); // Delete
              });
              success();
          }, function (tx, err) {
              error(err);
          });
      }, undefined, me);
  };
  
  IDBObjectStore.prototype.clear = function () {
      var me = this;
      if (!(this instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
      me.transaction.__assertWritable();
  
      return me.transaction.__addToTransactionQueue(function objectStoreClear(tx, args, success, error) {
          tx.executeSql('DELETE FROM ' + util.escapeStoreNameForSQL(me.name), [], function (tx, data) {
              _CFG2.default.DEBUG && console.log('Cleared all records from database', data.rowsAffected);
              me.__cursors.forEach(function (cursor) {
                  cursor.__invalidateCache(); // Clear
              });
              success();
          }, function (tx, err) {
              error(err);
          });
      }, undefined, me);
  };
  
  IDBObjectStore.prototype.count = function () /* query */{
      var me = this;
      var query = arguments[0];
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
  
      // We don't need to add to cursors array since has the count parameter which won't cache
      return _IDBCursor.IDBCursorWithValue.__createInstance(query, 'next', me, me, 'key', 'value', true).__req;
  };
  
  IDBObjectStore.prototype.openCursor = function () /* query, direction */{
      var me = this;
  
      var _arguments3 = Array.prototype.slice.call(arguments),
          query = _arguments3[0],
          direction = _arguments3[1];
  
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      var cursor = _IDBCursor.IDBCursorWithValue.__createInstance(query, direction, me, me, 'key', 'value');
      me.__cursors.push(cursor);
      return cursor.__req;
  };
  
  IDBObjectStore.prototype.openKeyCursor = function () /* query, direction */{
      var me = this;
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
  
      var _arguments4 = Array.prototype.slice.call(arguments),
          query = _arguments4[0],
          direction = _arguments4[1];
  
      var cursor = _IDBCursor.IDBCursor.__createInstance(query, direction, me, me, 'key', 'key');
      me.__cursors.push(cursor);
      return cursor.__req;
  };
  
  IDBObjectStore.prototype.index = function (indexName) {
      var me = this;
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No index name was specified');
      }
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertNotFinished(me.transaction);
      var index = me.__indexes[indexName];
      if (!index || index.__deleted) {
          throw (0, _DOMException.createDOMException)('NotFoundError', 'Index "' + indexName + '" does not exist on ' + me.name);
      }
      /*
      // const storeClone = me.transaction.objectStore(me.name); // Ensure clone is made if not present
      // const indexes = storeClone.__indexes;
      const storeClones = me.transaction.__storeClones;
      if (!storeClones[me.name] || storeClones[me.name].__deleted) { // The latter condition is to allow store
                                                           //   recreation to create new clone object
          storeClones[me.name] = IDBObjectStore.__clone(me, me.transaction);
      }
       const indexes = storeClones[me.name].__indexes;
      if (!indexes[indexName]) {
          indexes[indexName] = IDBIndex.__clone(index, me);
      }
      return indexes[indexName];
      */
      return _IDBIndex.IDBIndex.__clone(index, me);
  };
  
  /**
   * Creates a new index on the object store.
   * @param {string} indexName
   * @param {string} keyPath
   * @param {object} optionalParameters
   * @returns {IDBIndex}
   */
  IDBObjectStore.prototype.createIndex = function (indexName, keyPath /* , optionalParameters */) {
      var me = this;
      var optionalParameters = arguments[2];
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      indexName = String(indexName); // W3C test within IDBObjectStore.js seems to accept string conversion
      if (arguments.length === 0) {
          throw new TypeError('No index name was specified');
      }
      if (arguments.length === 1) {
          throw new TypeError('No key path was specified');
      }
      _IDBTransaction2.default.__assertVersionChange(me.transaction);
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
      if (me.__indexes[indexName] && !me.__indexes[indexName].__deleted) {
          throw (0, _DOMException.createDOMException)('ConstraintError', 'Index "' + indexName + '" already exists on ' + me.name);
      }
  
      keyPath = util.convertToSequenceDOMString(keyPath);
      if (!util.isValidKeyPath(keyPath)) {
          throw (0, _DOMException.createDOMException)('SyntaxError', 'A valid keyPath must be supplied');
      }
      if (Array.isArray(keyPath) && optionalParameters && optionalParameters.multiEntry) {
          throw (0, _DOMException.createDOMException)('InvalidAccessError', 'The keyPath argument was an array and the multiEntry option is true.');
      }
  
      optionalParameters = optionalParameters || {};
      /** @name IDBIndexProperties **/
      var indexProperties = {
          columnName: indexName,
          keyPath: keyPath,
          optionalParams: {
              unique: !!optionalParameters.unique,
              multiEntry: !!optionalParameters.multiEntry
          }
      };
      var index = _IDBIndex.IDBIndex.__createInstance(me, indexProperties);
      _IDBIndex.IDBIndex.__createIndex(me, index);
      return index;
  };
  
  IDBObjectStore.prototype.deleteIndex = function (indexName) {
      var me = this;
      if (!(me instanceof IDBObjectStore)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No index name was specified');
      }
      _IDBTransaction2.default.__assertVersionChange(me.transaction);
      if (me.__deleted) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'This store has been deleted');
      }
      _IDBTransaction2.default.__assertActive(me.transaction);
      var index = me.__indexes[indexName];
      if (!index) {
          throw (0, _DOMException.createDOMException)('NotFoundError', 'Index "' + indexName + '" does not exist on ' + me.name);
      }
  
      _IDBIndex.IDBIndex.__deleteIndex(me, index);
  };
  
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBObjectStore.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  Object.defineProperty(IDBObjectStore.prototype, 'name', {
      enumerable: true,
      configurable: true,
      get: function get() {
          throw new TypeError('Illegal invocation');
      },
      set: function set(val) {
          throw new TypeError('Illegal invocation');
      }
  });
  
  IDBObjectStore.prototype[Symbol.toStringTag] = 'IDBObjectStorePrototype';
  
  Object.defineProperty(IDBObjectStore, 'prototype', {
      writable: false
  });
  
  exports.default = IDBObjectStore;
  module.exports = exports['default'];
  
  },{"./CFG":319,"./DOMException":320,"./DOMStringList":321,"./IDBCursor":323,"./IDBIndex":326,"./IDBKeyRange":327,"./IDBTransaction":330,"./Key":332,"./Sca":333,"./util":338,"sync-promise":300}],329:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.IDBOpenDBRequest = exports.IDBRequest = undefined;
  
  var _DOMException = require('./DOMException');
  
  var _eventtarget = require('eventtarget');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var listeners = ['onsuccess', 'onerror'];
  var readonlyProperties = ['source', 'transaction', 'readyState'];
  var doneFlagGetters = ['result', 'error'];
  
  /**
   * The IDBRequest Object that is returns for all async calls
   * http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#request-api
   */
  
  var IDBRequest = function IDBRequest() {
      _classCallCheck(this, IDBRequest);
  
      throw new TypeError('Illegal constructor');
  };
  
  IDBRequest.__super = function IDBRequest() {
      var _this = this;
  
      this[Symbol.toStringTag] = 'IDBRequest';
      doneFlagGetters.forEach(function (prop) {
          Object.defineProperty(this, '__' + prop, {
              enumerable: false,
              configurable: false,
              writable: true
          });
          Object.defineProperty(this, prop, {
              enumerable: true,
              configurable: true,
              get: function get() {
                  if (this.__readyState !== 'done') {
                      throw (0, _DOMException.createDOMException)('InvalidStateError', 'The request is still pending.');
                  }
                  return this['__' + prop];
              }
          });
      }, this);
      util.defineReadonlyProperties(this, readonlyProperties);
      listeners.forEach(function (listener) {
          Object.defineProperty(_this, listener, {
              configurable: true, // Needed by support.js in W3C IndexedDB tests
              get: function get() {
                  return this['__' + listener];
              },
              set: function set(val) {
                  this['__' + listener] = val;
              }
          });
      }, this);
      listeners.forEach(function (l) {
          _this[l] = null;
      });
      this.__result = undefined;
      this.__error = this.__source = this.__transaction = null;
      this.__readyState = 'pending';
  };
  
  IDBRequest.__createInstance = function () {
      return new IDBRequest.__super();
  };
  
  IDBRequest.prototype = _eventtarget.EventTargetFactory.createInstance({ extraProperties: ['debug'] });
  IDBRequest.prototype[Symbol.toStringTag] = 'IDBRequestPrototype';
  
  IDBRequest.prototype.__getParent = function () {
      if (this.toString() === '[object IDBOpenDBRequest]') {
          return null;
      }
      return this.__transaction;
  };
  
  // Illegal invocations
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBRequest.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  doneFlagGetters.forEach(function (prop) {
      Object.defineProperty(IDBRequest.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  listeners.forEach(function (listener) {
      Object.defineProperty(IDBRequest.prototype, listener, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          },
          set: function set(val) {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  Object.defineProperty(IDBRequest.prototype, 'constructor', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: IDBRequest
  });
  IDBRequest.__super.prototype = IDBRequest.prototype;
  
  Object.defineProperty(IDBRequest, 'prototype', {
      writable: false
  });
  
  var openListeners = ['onblocked', 'onupgradeneeded'];
  
  /**
   * The IDBOpenDBRequest called when a database is opened
   */
  
  var IDBOpenDBRequest = function (_IDBRequest) {
      _inherits(IDBOpenDBRequest, _IDBRequest);
  
      function IDBOpenDBRequest() {
          _classCallCheck(this, IDBOpenDBRequest);
  
          return _possibleConstructorReturn(this, (IDBOpenDBRequest.__proto__ || Object.getPrototypeOf(IDBOpenDBRequest)).apply(this, arguments));
      }
  
      return IDBOpenDBRequest;
  }(IDBRequest);
  
  IDBOpenDBRequest.prototype = Object.create(IDBRequest.prototype);
  
  Object.defineProperty(IDBOpenDBRequest.prototype, 'constructor', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: IDBOpenDBRequest
  });
  
  var IDBOpenDBRequestAlias = IDBOpenDBRequest;
  IDBOpenDBRequest.__createInstance = function () {
      function IDBOpenDBRequest() {
          var _this3 = this;
  
          IDBRequest.__super.call(this);
  
          this[Symbol.toStringTag] = 'IDBOpenDBRequest';
          this.__setOptions({ extraProperties: ['oldVersion', 'newVersion', 'debug'] }); // Ensure EventTarget preserves our properties
          openListeners.forEach(function (listener) {
              Object.defineProperty(_this3, listener, {
                  configurable: true, // Needed by support.js in W3C IndexedDB tests
                  get: function get() {
                      return this['__' + listener];
                  },
                  set: function set(val) {
                      this['__' + listener] = val;
                  }
              });
          }, this);
          openListeners.forEach(function (l) {
              _this3[l] = null;
          });
      }
      IDBOpenDBRequest.prototype = IDBOpenDBRequestAlias.prototype;
      return new IDBOpenDBRequest();
  };
  
  openListeners.forEach(function (listener) {
      Object.defineProperty(IDBOpenDBRequest.prototype, listener, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          },
          set: function set(val) {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  IDBOpenDBRequest.prototype[Symbol.toStringTag] = 'IDBOpenDBRequestPrototype';
  
  Object.defineProperty(IDBOpenDBRequest, 'prototype', {
      writable: false
  });
  
  exports.IDBRequest = IDBRequest;
  exports.IDBOpenDBRequest = IDBOpenDBRequest;
  
  },{"./DOMException":320,"./util":338,"eventtarget":297}],330:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _Event = require('./Event');
  
  var _DOMException = require('./DOMException');
  
  var _IDBRequest = require('./IDBRequest');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _IDBObjectStore = require('./IDBObjectStore');
  
  var _IDBObjectStore2 = _interopRequireDefault(_IDBObjectStore);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  var _eventtarget = require('eventtarget');
  
  var _syncPromise = require('sync-promise');
  
  var _syncPromise2 = _interopRequireDefault(_syncPromise);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  var uniqueID = 0;
  var listeners = ['onabort', 'oncomplete', 'onerror'];
  var readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
  
  /**
   * The IndexedDB Transaction
   * http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBTransaction
   * @param {IDBDatabase} db
   * @param {string[]} storeNames
   * @param {string} mode
   * @constructor
   */
  function IDBTransaction() {
      throw new TypeError('Illegal constructor');
  }
  var IDBTransactionAlias = IDBTransaction;
  IDBTransaction.__createInstance = function (db, storeNames, mode) {
      function IDBTransaction() {
          var _this = this;
  
          var me = this;
          me[Symbol.toStringTag] = 'IDBTransaction';
          util.defineReadonlyProperties(me, readonlyProperties);
          me.__id = ++uniqueID; // for debugging simultaneous transactions
          me.__active = true;
          me.__running = false;
          me.__errored = false;
          me.__requests = [];
          me.__objectStoreNames = storeNames;
          me.__mode = mode;
          me.__db = db;
          me.__error = null;
          me.__internal = false;
  
          readonlyProperties.forEach(function (readonlyProp) {
              Object.defineProperty(_this, readonlyProp, {
                  configurable: true
              });
          });
          listeners.forEach(function (listener) {
              Object.defineProperty(_this, listener, {
                  enumerable: true,
                  configurable: true,
                  get: function get() {
                      return this['__' + listener];
                  },
                  set: function set(val) {
                      this['__' + listener] = val;
                  }
              });
          });
          listeners.forEach(function (l) {
              _this[l] = null;
          });
          me.__storeClones = {};
  
          // Kick off the transaction as soon as all synchronous code is done
          setTimeout(function () {
              me.__executeRequests();
          }, 0);
      }
      IDBTransaction.prototype = IDBTransactionAlias.prototype;
      return new IDBTransaction();
  };
  
  IDBTransaction.prototype = _eventtarget.EventTargetFactory.createInstance({ defaultSync: true, extraProperties: ['complete'] }); // Ensure EventTarget preserves our properties
  IDBTransaction.prototype.__transFinishedCb = function (err, cb) {
      if (err) {
          cb(true);
          return;
      }
      cb();
  };
  IDBTransaction.prototype.__executeRequests = function () {
      var me = this;
      if (me.__running) {
          _CFG2.default.DEBUG && console.log('Looks like the request set is already running', me.mode);
          return;
      }
  
      me.__running = true;
  
      me.db.__db[me.mode === 'readonly' ? 'readTransaction' : 'transaction']( // `readTransaction` is optimized, at least in `node-websql`
      function executeRequests(tx) {
          me.__tx = tx;
          var q = null,
              i = -1;
  
          function success(result, req) {
              if (me.__errored || me.__requestsFinished) {
                  // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
                  return;
              }
              if (req) {
                  q.req = req; // Need to do this in case of cursors
              }
              if (q.req.__readyState === 'done') {
                  // Avoid continuing with aborted requests
                  return;
              }
              q.req.__readyState = 'done';
              q.req.__result = result;
              q.req.__error = null;
              var e = (0, _Event.createEvent)('success');
              try {
                  // Catching a `dispatchEvent` call is normally not possible for a standard `EventTarget`,
                  // but we are using the `EventTarget` library's `__userErrorEventHandler` to override this
                  // behavior for convenience in our internal calls
                  me.__internal = true;
                  me.__active = true;
                  q.req.dispatchEvent(e);
                  me.__internal = false;
                  // Do not set __active flag to false yet: https://github.com/w3c/IndexedDB/issues/87
              } catch (err) {
                  me.__internal = false;
                  me.__abortTransaction((0, _DOMException.createDOMException)('AbortError', 'A request was aborted.'));
                  return;
              }
              executeNextRequest();
          }
  
          function error() /* tx, err */{
              if (me.__errored || me.__requestsFinished) {
                  // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
                  return;
              }
              if (q.req && q.req.__readyState === 'done') {
                  // Avoid continuing with aborted requests
                  return;
              }
  
              for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                  args[_key] = arguments[_key];
              }
  
              var err = (0, _DOMException.findError)(args);
              if (!q.req) {
                  me.__abortTransaction(err);
                  return;
              }
              // Fire an error event for the current IDBRequest
              q.req.__readyState = 'done';
              q.req.__error = err;
              q.req.__result = undefined;
              q.req.addLateEventListener('error', function (e) {
                  if (e.cancelable && e.defaultPrevented) {
                      executeNextRequest();
                  }
              });
              q.req.addDefaultEventListener('error', function () {
                  me.__abortTransaction(q.req.__error);
              });
              var e = void 0;
              try {
                  // Catching a `dispatchEvent` call is normally not possible for a standard `EventTarget`,
                  // but we are using the `EventTarget` library's `__userErrorEventHandler` to override this
                  // behavior for convenience in our internal calls
                  me.__internal = true;
                  me.__active = true;
                  e = (0, _Event.createEvent)('error', err, { bubbles: true, cancelable: true });
                  q.req.dispatchEvent(e);
                  me.__internal = false;
                  // Do not set __active flag to false yet: https://github.com/w3c/IndexedDB/issues/87
              } catch (handlerErr) {
                  me.__internal = false;
                  (0, _DOMException.logError)('Error', 'An error occurred in a handler attached to request chain', handlerErr); // We do nothing else with this `handlerErr` per spec
                  e.preventDefault(); // Prevent 'error' default as steps indicate we should abort with `AbortError` even without cancellation
                  me.__abortTransaction((0, _DOMException.createDOMException)('AbortError', 'A request was aborted.'));
              }
          }
  
          function executeNextRequest() {
              if (me.__errored || me.__requestsFinished) {
                  // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
                  return;
              }
              i++;
              if (i >= me.__requests.length) {
                  // All requests in the transaction are done
                  me.__requests = [];
                  if (me.__active) {
                      requestsFinished();
                  }
              } else {
                  try {
                      q = me.__requests[i];
                      if (!q.req) {
                          q.op(tx, q.args, executeNextRequest, error);
                          return;
                      }
                      if (q.req.__readyState === 'done') {
                          // Avoid continuing with aborted requests
                          return;
                      }
                      q.op(tx, q.args, success, error, executeNextRequest);
                  } catch (e) {
                      error(e);
                  }
              }
          }
  
          executeNextRequest();
      }, function webSQLError(webSQLErr) {
          if (webSQLErr === true) {
              // Not a genuine SQL error
              return;
          }
          var err = (0, _DOMException.webSQLErrback)(webSQLErr);
          me.__abortTransaction(err);
      }, function () {
          // For Node, we don't need to try running here as we can keep
          //   the transaction running long enough to rollback (in the
          //   next (non-standard) callback for this transaction call)
          if (me.__transFinishedCb !== IDBTransaction.prototype.__transFinishedCb) {
              // Node
              return;
          }
          if (!me.__transactionEndCallback && !me.__requestsFinished) {
              me.__transactionFinished = true;
              return;
          }
          if (me.__transactionEndCallback && !me.__completed) {
              me.__transFinishedCb(me.__errored, me.__transactionEndCallback);
          }
      }, function (currentTask, err, done, rollback, commit) {
          if (currentTask.readOnly || err) {
              return true;
          }
          me.__transFinishedCb = function (err, cb) {
              if (err) {
                  rollback(err, cb);
              } else {
                  commit(cb);
              }
          };
          if (me.__transactionEndCallback && !me.__completed) {
              me.__transFinishedCb(me.__errored, me.__transactionEndCallback);
          }
          return false;
      });
  
      function requestsFinished() {
          me.__active = false;
          me.__requestsFinished = true;
  
          function complete() {
              me.__completed = true;
              _CFG2.default.DEBUG && console.log('Transaction completed');
              var evt = (0, _Event.createEvent)('complete');
              try {
                  me.__internal = true;
                  me.dispatchEvent(evt);
                  me.__internal = false;
                  me.dispatchEvent((0, _Event.createEvent)('__complete'));
              } catch (e) {
                  me.__internal = false;
                  // An error occurred in the "oncomplete" handler.
                  // It's too late to call "onerror" or "onabort". Throw a global error instead.
                  // (this may seem odd/bad, but it's how all native IndexedDB implementations work)
                  me.__errored = true;
                  throw e;
              } finally {
                  me.__storeClones = {};
              }
          }
          if (me.mode === 'readwrite') {
              if (me.__transactionFinished) {
                  complete();
                  return;
              }
              me.__transactionEndCallback = complete;
              return;
          }
          if (me.mode === 'readonly') {
              complete();
              return;
          }
          var ev = (0, _Event.createEvent)('__beforecomplete');
          ev.complete = complete;
          me.dispatchEvent(ev);
      }
  };
  
  /**
   * Creates a new IDBRequest for the transaction.
   * NOTE: The transaction is not queued until you call {@link IDBTransaction#__pushToQueue}
   * @returns {IDBRequest}
   * @protected
   */
  IDBTransaction.prototype.__createRequest = function (source) {
      var me = this;
      var request = _IDBRequest.IDBRequest.__createInstance();
      request.__source = source !== undefined ? source : me.db;
      request.__transaction = me;
      return request;
  };
  
  /**
   * Adds a callback function to the transaction queue
   * @param {function} callback
   * @param {*} args
   * @returns {IDBRequest}
   * @protected
   */
  IDBTransaction.prototype.__addToTransactionQueue = function (callback, args, source) {
      var request = this.__createRequest(source);
      this.__pushToQueue(request, callback, args);
      return request;
  };
  
  /**
   * Adds a callback function to the transaction queue without generating a request
   * @param {function} callback
   * @param {*} args
   * @returns {IDBRequest}
   * @protected
   */
  IDBTransaction.prototype.__addNonRequestToTransactionQueue = function (callback, args, source) {
      this.__pushToQueue(null, callback, args);
  };
  
  /**
   * Adds an IDBRequest to the transaction queue
   * @param {IDBRequest} request
   * @param {function} callback
   * @param {*} args
   * @protected
   */
  IDBTransaction.prototype.__pushToQueue = function (request, callback, args) {
      this.__assertActive();
      this.__requests.push({
          'op': callback,
          'args': args,
          'req': request
      });
  };
  
  IDBTransaction.prototype.__assertActive = function () {
      if (!this.__active) {
          throw (0, _DOMException.createDOMException)('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
      }
  };
  
  IDBTransaction.prototype.__assertWritable = function () {
      if (this.mode === 'readonly') {
          throw (0, _DOMException.createDOMException)('ReadOnlyError', 'The transaction is read only');
      }
  };
  
  IDBTransaction.prototype.__assertVersionChange = function () {
      IDBTransaction.__assertVersionChange(this);
  };
  
  /**
   * Returns the specified object store.
   * @param {string} objectStoreName
   * @returns {IDBObjectStore}
   */
  IDBTransaction.prototype.objectStore = function (objectStoreName) {
      var me = this;
      if (!(me instanceof IDBTransaction)) {
          throw new TypeError('Illegal invocation');
      }
      if (arguments.length === 0) {
          throw new TypeError('No object store name was specified');
      }
      IDBTransaction.__assertNotFinished(me);
      if (me.__objectStoreNames.indexOf(objectStoreName) === -1) {
          throw (0, _DOMException.createDOMException)('NotFoundError', objectStoreName + ' is not participating in this transaction');
      }
      var store = me.db.__objectStores[objectStoreName];
      if (!store) {
          throw (0, _DOMException.createDOMException)('NotFoundError', objectStoreName + ' does not exist in ' + me.db.name);
      }
  
      if (!me.__storeClones[objectStoreName] || me.__storeClones[objectStoreName].__deleted) {
          // The latter condition is to allow store
          //   recreation to create new clone object
          me.__storeClones[objectStoreName] = _IDBObjectStore2.default.__clone(store, me);
      }
      return me.__storeClones[objectStoreName];
  };
  
  IDBTransaction.prototype.__abortTransaction = function (err) {
      var me = this;
      (0, _DOMException.logError)('Error', 'An error occurred in a transaction', err);
      if (me.__errored) {
          // We've already called "onerror", "onabort", or thrown, so don't do it again.
          return;
      }
      me.__errored = true;
  
      if (me.mode === 'versionchange') {
          // Steps for aborting an upgrade transaction
          me.db.__version = me.db.__oldVersion;
          me.db.__objectStoreNames = me.db.__oldObjectStoreNames;
          Object.values(me.__storeClones).forEach(function (store) {
              store.__name = store.__originalName;
              store.__indexNames = store.__oldIndexNames;
              Object.values(store.__indexes).forEach(function (index) {
                  index.__name = index.__originalName;
              });
          });
      }
      me.__active = false; // Setting here and in requestsFinished for https://github.com/w3c/IndexedDB/issues/87
  
      if (err !== null) {
          me.__error = err;
      }
  
      if (me.__requestsFinished) {
          // The transaction has already completed, so we can't call "onerror" or "onabort".
          // So throw the error instead.
          setTimeout(function () {
              throw err;
          }, 0);
      }
  
      function abort(tx, errOrResult) {
          if (!tx) {
              _CFG2.default.DEBUG && console.log('Rollback not possible due to missing transaction', me);
          } else if (errOrResult && typeof errOrResult.code === 'number') {
              _CFG2.default.DEBUG && console.log('Rollback erred; feature is probably not supported as per WebSQL', me);
          } else {
              _CFG2.default.DEBUG && console.log('Rollback succeeded', me);
          }
  
          me.__requests.filter(function (q) {
              return q.req && q.req.__readyState !== 'done';
          }).reduce(function (promises, q) {
              // We reduce to a chain of promises to be queued in order, so we cannot use `Promise.all`,
              //  and I'm unsure whether `setTimeout` currently behaves first-in-first-out with the same timeout
              //  so we could just use a `forEach`.
              return promises.then(function () {
                  q.req.__readyState = 'done';
                  q.req.__result = undefined;
                  q.req.__error = (0, _DOMException.createDOMException)('AbortError', 'A request was aborted.');
                  var reqEvt = (0, _Event.createEvent)('error', q.req.__error, { bubbles: true, cancelable: true });
                  return new _syncPromise2.default(function (resolve) {
                      setTimeout(function () {
                          q.req.dispatchEvent(reqEvt); // No need to catch errors
                          resolve();
                      });
                  });
              });
          }, _syncPromise2.default.resolve()).then(function () {
              // Also works when there are no pending requests
              var evt = (0, _Event.createEvent)('abort', err, { bubbles: true, cancelable: false });
              setTimeout(function () {
                  me.dispatchEvent(evt);
                  me.__storeClones = {};
                  me.dispatchEvent((0, _Event.createEvent)('__abort'));
              });
          });
      }
  
      me.__transFinishedCb(true, function (rollback) {
          if (rollback && me.__tx) {
              // Not supported in standard SQL (and WebSQL errors should
              //   rollback automatically), but for Node.js, etc., we give chance for
              //   manual aborts which would otherwise not work.
              if (me.mode === 'readwrite') {
                  if (me.__transactionFinished) {
                      abort();
                      return;
                  }
                  me.__transactionEndCallback = abort;
                  return;
              }
              try {
                  me.__tx.executeSql('ROLLBACK', [], abort, abort); // Not working in some circumstances, even in Node
              } catch (err) {
                  // Browser errs when transaction has ended and since it most likely already erred here,
                  //   we call to abort
                  abort();
              }
          } else {
              abort(null, { code: 0 });
          }
      });
  };
  
  IDBTransaction.prototype.abort = function () {
      var me = this;
      if (!(me instanceof IDBTransaction)) {
          throw new TypeError('Illegal invocation');
      }
      _CFG2.default.DEBUG && console.log('The transaction was aborted', me);
      IDBTransaction.__assertNotFinished(me);
      me.__abortTransaction(null);
  };
  IDBTransaction.prototype[Symbol.toStringTag] = 'IDBTransactionPrototype';
  
  IDBTransaction.__assertVersionChange = function (tx) {
      if (!tx || tx.mode !== 'versionchange') {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'Not a version transaction');
      }
  };
  IDBTransaction.__assertNotVersionChange = function (tx) {
      if (tx && tx.mode === 'versionchange') {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'Cannot be called during a version transaction');
      }
  };
  
  IDBTransaction.__assertNotFinished = function (tx) {
      if (!tx || tx.__completed || tx.__errored) {
          throw (0, _DOMException.createDOMException)('InvalidStateError', 'Transaction is completed or errored');
      }
  };
  
  IDBTransaction.__assertActive = function (tx) {
      if (!tx || !tx.__active) {
          throw (0, _DOMException.createDOMException)('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
      }
  };
  
  /**
  * Used by our EventTarget.prototype library to implement bubbling/capturing
  */
  IDBTransaction.prototype.__getParent = function () {
      return this.db;
  };
  /**
  * Used by our EventTarget.prototype library to detect errors in user handlers
  */
  IDBTransaction.prototype.__userErrorEventHandler = function (error, triggerGlobalErrorEvent) {
      if (this.__internal) {
          this.__internal = false;
          throw error;
      }
      triggerGlobalErrorEvent();
  };
  
  listeners.forEach(function (listener) {
      Object.defineProperty(IDBTransaction.prototype, listener, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          },
          set: function set(val) {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  // Illegal invocations
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBTransaction.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              throw new TypeError('Illegal invocation');
          }
      });
  });
  
  Object.defineProperty(IDBTransaction.prototype, 'constructor', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: IDBTransaction
  });
  
  Object.defineProperty(IDBTransaction, 'prototype', {
      writable: false
  });
  
  exports.default = IDBTransaction;
  module.exports = exports['default'];
  
  },{"./CFG":319,"./DOMException":320,"./Event":322,"./IDBObjectStore":328,"./IDBRequest":329,"./util":338,"eventtarget":297,"sync-promise":300}],331:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _Event = require('./Event');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  var readonlyProperties = ['oldVersion', 'newVersion'];
  
  // Babel apparently having a problem adding `hasInstance` to a class, so we are redefining as a function
  function IDBVersionChangeEvent(type /* , eventInitDict */) {
      // eventInitDict is a IDBVersionChangeEventInit (but is not defined as a global)
      _Event.ShimEvent.call(this, type);
      this[Symbol.toStringTag] = 'IDBVersionChangeEvent';
      this.toString = function () {
          return '[object IDBVersionChangeEvent]';
      };
      this.__eventInitDict = arguments[1] || {};
  }
  
  IDBVersionChangeEvent.prototype = Object.create(_Event.ShimEvent.prototype);
  
  IDBVersionChangeEvent.prototype[Symbol.toStringTag] = 'IDBVersionChangeEventPrototype';
  
  readonlyProperties.forEach(function (prop) {
      Object.defineProperty(IDBVersionChangeEvent.prototype, prop, {
          enumerable: true,
          configurable: true,
          get: function get() {
              if (!(this instanceof IDBVersionChangeEvent)) {
                  throw new TypeError('Illegal invocation');
              }
              return this.__eventInitDict && this.__eventInitDict[prop] || (prop === 'oldVersion' ? 0 : null);
          }
      });
  });
  
  Object.defineProperty(IDBVersionChangeEvent, Symbol.hasInstance, {
      value: function value(obj) {
          return util.isObj(obj) && 'oldVersion' in obj && typeof obj.defaultPrevented === 'boolean';
      }
  });
  
  Object.defineProperty(IDBVersionChangeEvent.prototype, 'constructor', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: IDBVersionChangeEvent
  });
  
  Object.defineProperty(IDBVersionChangeEvent, 'prototype', {
      writable: false
  });
  
  exports.default = IDBVersionChangeEvent;
  module.exports = exports['default'];
  
  },{"./Event":322,"./util":338}],332:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.findMultiEntryMatches = exports.isKeyInRange = exports.isMultiEntryMatch = exports.checkKeyCouldBeInjectedIntoValue = exports.injectKeyIntoValueUsingKeyPath = exports.extractKeyValueDecodedFromValueUsingKeyPath = exports.evaluateKeyPathOnValue = exports.extractKeyFromValueUsingKeyPath = exports.convertValueToKeyRethrowingAndIfInvalid = exports.convertValueToMultiEntryKey = exports.convertValueToKey = exports.convertValueToMultiEntryKeyDecoded = exports.convertValueToKeyValueDecoded = exports.convertKeyToValue = exports.roundTrip = exports.decode = exports.encode = undefined;
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var _DOMException = require('./DOMException');
  
  var _util = require('./util');
  
  var util = _interopRequireWildcard(_util);
  
  var _IDBFactory = require('./IDBFactory');
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  /**
   * Encodes the keys based on their types. This is required to maintain collations
   */
  var collations = ['invalid', 'number', 'date', 'string', 'binary', 'array'];
  
  /**
   * The sign values for numbers, ordered from least to greatest.
   *  - "negativeInfinity": Sorts below all other values.
   *  - "bigNegative": Negative values less than or equal to negative one.
   *  - "smallNegative": Negative values between negative one and zero, noninclusive.
   *  - "smallPositive": Positive values between zero and one, including zero but not one.
   *  - "largePositive": Positive values greater than or equal to one.
   *  - "positiveInfinity": Sorts above all other values.
   */
  var signValues = ['negativeInfinity', 'bigNegative', 'smallNegative', 'smallPositive', 'bigPositive', 'positiveInfinity'];
  
  var types = {
      invalid: {
          encode: function encode(key) {
              return collations.indexOf('invalid') + '-';
          },
          decode: function decode(key) {
              return undefined;
          }
      },
  
      // Numbers are represented in a lexically sortable base-32 sign-exponent-mantissa
      // notation.
      //
      // sign: takes a value between zero and five, inclusive. Represents infinite cases
      //     and the signs of both the exponent and the fractional part of the number.
      // exponent: padded to two base-32 digits, represented by the 32's compliment in the
      //     "smallPositive" and "bigNegative" cases to ensure proper lexical sorting.
      // mantissa: also called the fractional part. Normed 11-digit base-32 representation.
      //     Represented by the 32's compliment in the "smallNegative" and "bigNegative"
      //     cases to ensure proper lexical sorting.
      number: {
          // The encode step checks for six numeric cases and generates 14-digit encoded
          // sign-exponent-mantissa strings.
          encode: function encode(key) {
              var key32 = Math.abs(key).toString(32);
              // Get the index of the decimal.
              var decimalIndex = key32.indexOf('.');
              // Remove the decimal.
              key32 = decimalIndex !== -1 ? key32.replace('.', '') : key32;
              // Get the index of the first significant digit.
              var significantDigitIndex = key32.search(/[^0]/);
              // Truncate leading zeros.
              key32 = key32.slice(significantDigitIndex);
              var sign = void 0,
                  exponent = void 0,
                  mantissa = void 0;
  
              // Finite cases:
              if (isFinite(key)) {
                  // Negative cases:
                  if (key < 0) {
                      // Negative exponent case:
                      if (key > -1) {
                          sign = signValues.indexOf('smallNegative');
                          exponent = padBase32Exponent(significantDigitIndex);
                          mantissa = flipBase32(padBase32Mantissa(key32));
                          // Non-negative exponent case:
                      } else {
                          sign = signValues.indexOf('bigNegative');
                          exponent = flipBase32(padBase32Exponent(decimalIndex !== -1 ? decimalIndex : key32.length));
                          mantissa = flipBase32(padBase32Mantissa(key32));
                      }
                      // Non-negative cases:
                  } else {
                      // Negative exponent case:
                      if (key < 1) {
                          sign = signValues.indexOf('smallPositive');
                          exponent = flipBase32(padBase32Exponent(significantDigitIndex));
                          mantissa = padBase32Mantissa(key32);
                          // Non-negative exponent case:
                      } else {
                          sign = signValues.indexOf('bigPositive');
                          exponent = padBase32Exponent(decimalIndex !== -1 ? decimalIndex : key32.length);
                          mantissa = padBase32Mantissa(key32);
                      }
                  }
                  // Infinite cases:
              } else {
                  exponent = zeros(2);
                  mantissa = zeros(11);
                  sign = signValues.indexOf(key > 0 ? 'positiveInfinity' : 'negativeInfinity');
              }
  
              return collations.indexOf('number') + '-' + sign + exponent + mantissa;
          },
          // The decode step must interpret the sign, reflip values encoded as the 32's complements,
          // apply signs to the exponent and mantissa, do the base-32 power operation, and return
          // the original JavaScript number values.
          decode: function decode(key) {
              var sign = +key.substr(2, 1);
              var exponent = key.substr(3, 2);
              var mantissa = key.substr(5, 11);
  
              switch (signValues[sign]) {
                  case 'negativeInfinity':
                      return -Infinity;
                  case 'positiveInfinity':
                      return Infinity;
                  case 'bigPositive':
                      return pow32(mantissa, exponent);
                  case 'smallPositive':
                      exponent = negate(flipBase32(exponent));
                      return pow32(mantissa, exponent);
                  case 'smallNegative':
                      exponent = negate(exponent);
                      mantissa = flipBase32(mantissa);
                      return -pow32(mantissa, exponent);
                  case 'bigNegative':
                      exponent = flipBase32(exponent);
                      mantissa = flipBase32(mantissa);
                      return -pow32(mantissa, exponent);
                  default:
                      throw new Error('Invalid number.');
              }
          }
      },
  
      // Strings are encoded as JSON strings (with quotes and unicode characters escaped).
      //
      // If the strings are in an array, then some extra encoding is done to make sorting work correctly:
      // Since we can't force all strings to be the same length, we need to ensure that characters line-up properly
      // for sorting, while also accounting for the extra characters that are added when the array itself is encoded as JSON.
      // To do this, each character of the string is prepended with a dash ("-"), and a space is added to the end of the string.
      // This effectively doubles the size of every string, but it ensures that when two arrays of strings are compared,
      // the indexes of each string's characters line up with each other.
      string: {
          encode: function encode(key, inArray) {
              if (inArray) {
                  // prepend each character with a dash, and append a space to the end
                  key = key.replace(/(.)/g, '-$1') + ' ';
              }
              return collations.indexOf('string') + '-' + key;
          },
          decode: function decode(key, inArray) {
              key = key.slice(2);
              if (inArray) {
                  // remove the space at the end, and the dash before each character
                  key = key.substr(0, key.length - 1).replace(/-(.)/g, '$1');
              }
              return key;
          }
      },
  
      // Arrays are encoded as JSON strings.
      // An extra, value is added to each array during encoding to make empty arrays sort correctly.
      array: {
          encode: function encode(key) {
              var encoded = [];
              for (var i = 0; i < key.length; i++) {
                  var item = key[i];
                  var encodedItem = _encode(item, true); // encode the array item
                  encoded[i] = encodedItem;
              }
              encoded.push(collations.indexOf('invalid') + '-'); // append an extra item, so empty arrays sort correctly
              return collations.indexOf('array') + '-' + JSON.stringify(encoded);
          },
          decode: function decode(key) {
              var decoded = JSON.parse(key.slice(2));
              decoded.pop(); // remove the extra item
              for (var i = 0; i < decoded.length; i++) {
                  var item = decoded[i];
                  var decodedItem = _decode(item, true); // decode the item
                  decoded[i] = decodedItem;
              }
              return decoded;
          }
      },
  
      // Dates are encoded as ISO 8601 strings, in UTC time zone.
      date: {
          encode: function encode(key) {
              return collations.indexOf('date') + '-' + key.toJSON();
          },
          decode: function decode(key) {
              return new Date(key.slice(2));
          }
      },
      binary: { // `ArrayBuffer`/Views on buffers (`TypedArray` or `DataView`)
          encode: function encode(key) {
              return collations.indexOf('binary') + '-' + (key.byteLength ? Array.from(getCopyBytesHeldByBufferSource(key)).map(function (b) {
                  return padStart(b, 3, '0');
              }) // e.g., '255,005,254,000,001,033'
              : '');
          },
          decode: function decode(key) {
              // Set the entries in buffer's [[ArrayBufferData]] to those in `value`
              var k = key.slice(2);
              var arr = k.length ? k.split(',').map(function (s) {
                  return parseInt(s, 10);
              }) : [];
              var buffer = new ArrayBuffer(arr.length);
              var uint8 = new Uint8Array(buffer);
              uint8.set(arr);
              return buffer;
          }
      }
  };
  
  function padStart(str, ct, fill) {
      return new Array(ct - String(str).length + 1).join(fill) + str;
  }
  
  /**
   * Return a padded base-32 exponent value.
   * @param {number}
   * @return {string}
   */
  function padBase32Exponent(n) {
      n = n.toString(32);
      return n.length === 1 ? '0' + n : n;
  }
  
  /**
   * Return a padded base-32 mantissa.
   * @param {string}
   * @return {string}
   */
  function padBase32Mantissa(s) {
      return (s + zeros(11)).slice(0, 11);
  }
  
  /**
   * Flips each digit of a base-32 encoded string.
   * @param {string} encoded
   */
  function flipBase32(encoded) {
      var flipped = '';
      for (var i = 0; i < encoded.length; i++) {
          flipped += (31 - parseInt(encoded[i], 32)).toString(32);
      }
      return flipped;
  }
  
  /**
   * Base-32 power function.
   * RESEARCH: This function does not precisely decode floats because it performs
   * floating point arithmetic to recover values. But can the original values be
   * recovered exactly?
   * Someone may have already figured out a good way to store JavaScript floats as
   * binary strings and convert back. Barring a better method, however, one route
   * may be to generate decimal strings that `parseFloat` decodes predictably.
   * @param {string}
   * @param {string}
   * @return {number}
   */
  function pow32(mantissa, exponent) {
      exponent = parseInt(exponent, 32);
      if (exponent < 0) {
          return roundToPrecision(parseInt(mantissa, 32) * Math.pow(32, exponent - 10));
      } else {
          if (exponent < 11) {
              var whole = mantissa.slice(0, exponent);
              whole = parseInt(whole, 32);
              var fraction = mantissa.slice(exponent);
              fraction = parseInt(fraction, 32) * Math.pow(32, exponent - 11);
              return roundToPrecision(whole + fraction);
          } else {
              var expansion = mantissa + zeros(exponent - 11);
              return parseInt(expansion, 32);
          }
      }
  }
  
  /**
   *
   */
  function roundToPrecision(num, precision) {
      precision = precision || 16;
      return parseFloat(num.toPrecision(precision));
  }
  
  /**
   * Returns a string of n zeros.
   * @param {number}
   * @return {string}
   */
  function zeros(n) {
      return '0'.repeat(n);
  }
  
  /**
   * Negates numeric strings.
   * @param {string}
   * @return {string}
   */
  function negate(s) {
      return '-' + s;
  }
  
  /**
   * Returns the string "number", "date", "string", "binary", or "array"
   */
  function getKeyType(key) {
      if (Array.isArray(key)) return 'array';
      if (util.isDate(key)) return 'date';
      if (util.isBinary(key)) return 'binary';
      var keyType = typeof key === 'undefined' ? 'undefined' : _typeof(key);
      return ['string', 'number'].includes(keyType) ? keyType : 'invalid';
  }
  
  /**
   * Keys must be strings, numbers (besides NaN), Dates (if value is not NaN),
   *   binary objects or Arrays
   * @param input The key input
   * @param seen An array of already seen keys
   */
  function convertValueToKey(input, seen) {
      return convertValueToKeyValueDecoded(input, seen, false, true);
  }
  
  /**
  * Currently not in use
  */
  function convertValueToMultiEntryKey(input) {
      return convertValueToKeyValueDecoded(input, null, true, true);
  }
  
  // https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-copy-2
  function getCopyBytesHeldByBufferSource(O) {
      var offset = 0;
      var length = 0;
      if (ArrayBuffer.isView(O)) {
          // Has [[ViewedArrayBuffer]] internal slot
          var arrayBuffer = O.buffer;
          if (arrayBuffer === undefined) {
              throw new TypeError('Could not copy the bytes held by a buffer source as the buffer was undefined.');
          }
          offset = O.byteOffset; // [[ByteOffset]] (will also throw as desired if detached)
          length = O.byteLength; // [[ByteLength]] (will also throw as desired if detached)
      } else {
          length = O.byteLength; // [[ArrayBufferByteLength]] on ArrayBuffer (will also throw as desired if detached)
      }
      // const octets = new Uint8Array(input);
      // const octets = types.binary.decode(types.binary.encode(input));
      return new Uint8Array(O.buffer || O, offset, length);
  }
  
  /**
  * Shortcut utility to avoid returning full keys from `convertValueToKey`
  *   and subsequent need to process in calling code unless `fullKeys` is
  *   set; may throw
  */
  function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
      seen = seen || [];
      if (seen.includes(input)) return { type: 'array', invalid: true, message: 'An array key cannot be circular' };
      var type = getKeyType(input);
      var ret = { type: type, value: input };
      switch (type) {
          case 'number':
              {
                  if (Number.isNaN(input)) {
                      return { type: 'NaN', invalid: true }; // List as 'NaN' type for convenience of consumers in reporting errors
                  }
                  return ret;
              }case 'string':
              {
                  return ret;
              }case 'binary':
              {
                  // May throw (if detached)
                  // Get a copy of the bytes held by the buffer source
                  // https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-copy-2
                  var octets = getCopyBytesHeldByBufferSource(input);
                  return { type: 'binary', value: octets };
              }case 'array':
              {
                  // May throw (from binary)
                  var len = input.length;
                  seen.push(input);
                  var keys = [];
                  for (var i = 0; i < len; i++) {
                      // We cannot iterate here with array extras as we must ensure sparse arrays are invalidated
                      if (!multiEntry && !Object.prototype.hasOwnProperty.call(input, i)) {
                          return { type: type, invalid: true, message: 'Does not have own index property' };
                      }
                      try {
                          var _ret = function () {
                              var entry = input[i];
                              var key = convertValueToKeyValueDecoded(entry, seen, false, fullKeys); // Though steps do not list rethrowing, the next is returnifabrupt when not multiEntry
                              if (key.invalid) {
                                  if (multiEntry) {
                                      return 'continue';
                                  }
                                  return {
                                      v: { type: type, invalid: true, message: 'Bad array entry value-to-key conversion' }
                                  };
                              }
                              if (!multiEntry || !fullKeys && keys.every(function (k) {
                                  return (0, _IDBFactory.cmp)(k, key.value) !== 0;
                              }) || fullKeys && keys.every(function (k) {
                                  return (0, _IDBFactory.cmp)(k, key) !== 0;
                              })) {
                                  keys.push(fullKeys ? key : key.value);
                              }
                          }();
  
                          switch (_ret) {
                              case 'continue':
                                  continue;
  
                              default:
                                  if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
                          }
                      } catch (err) {
                          if (!multiEntry) {
                              throw err;
                          }
                      }
                  }
                  return { type: type, value: keys };
              }case 'date':
              {
                  if (!Number.isNaN(input.getTime())) {
                      return fullKeys ? { type: type, value: input.getTime() } : { type: type, value: new Date(input.getTime()) };
                  }
                  return { type: type, invalid: true, message: 'Not a valid date' };
                  // Falls through
              }case 'invalid':default:
              {
                  // Other `typeof` types which are not valid keys:
                  //    'undefined', 'boolean', 'object' (including `null`), 'symbol', 'function
                  var _type = input === null ? 'null' : typeof input === 'undefined' ? 'undefined' : _typeof(input); // Convert `null` for convenience of consumers in reporting errors
                  return { type: _type, invalid: true, message: 'Not a valid key; type ' + _type };
              }
      }
  }
  function convertValueToMultiEntryKeyDecoded(key, fullKeys) {
      return convertValueToKeyValueDecoded(key, null, true, fullKeys);
  }
  
  /**
  * An internal utility
  */
  function convertValueToKeyRethrowingAndIfInvalid(input, seen) {
      var key = convertValueToKey(input, seen);
      if (key.invalid) {
          throw (0, _DOMException.createDOMException)('DataError', key.message || 'Not a valid key; type: ' + key.type);
      }
      return key;
  }
  
  function extractKeyFromValueUsingKeyPath(value, keyPath, multiEntry) {
      return extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry, true);
  }
  /**
  * Not currently in use
  */
  function evaluateKeyPathOnValue(value, keyPath, multiEntry) {
      return evaluateKeyPathOnValueToDecodedValue(value, keyPath, multiEntry, true);
  }
  
  /**
  * May throw, return `{failure: true}` (e.g., non-object on keyPath resolution)
  *    or `{invalid: true}` (e.g., `NaN`)
  */
  function extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry, fullKeys) {
      var r = evaluateKeyPathOnValueToDecodedValue(value, keyPath, multiEntry, fullKeys);
      if (r.failure) {
          return r;
      }
      if (!multiEntry) {
          return convertValueToKeyValueDecoded(r.value, null, false, fullKeys);
      }
      return convertValueToMultiEntryKeyDecoded(r.value, fullKeys);
  }
  
  /**
   * Returns the value of an inline key based on a key path (wrapped in an object with key `value`)
   *   or `{failure: true}`
   * @param {object} value
   * @param {string|array} keyPath
   * @param {boolean} multiEntry
   * @returns {undefined|array|string}
   */
  function evaluateKeyPathOnValueToDecodedValue(value, keyPath, multiEntry, fullKeys) {
      if (Array.isArray(keyPath)) {
          var result = [];
          return keyPath.some(function (item) {
              var key = evaluateKeyPathOnValueToDecodedValue(value, item, multiEntry, fullKeys);
              if (key.failure) {
                  return true;
              }
              result.push(key.value);
          }, []) ? { failure: true } : { value: result };
      }
      if (keyPath === '') {
          return { value: value };
      }
      var identifiers = keyPath.split('.');
      return identifiers.some(function (idntfr, i) {
          if (idntfr === 'length' && (typeof value === 'string' || Array.isArray(value))) {
              value = value.length;
          } else if (util.isBlob(value)) {
              switch (idntfr) {
                  case 'size':case 'type':
                      value = value[idntfr];
                      return;
              }
          } else if (util.isFile(value)) {
              switch (idntfr) {
                  case 'name':case 'lastModified':
                      value = value[idntfr];
                      return;
                  case 'lastModifiedDate':
                      value = new Date(value.lastModified);
                      return;
              }
          } else if (!util.isObj(value) || !Object.prototype.hasOwnProperty.call(value, idntfr)) {
              return true;
          } else {
              value = value[idntfr];
              return value === undefined;
          }
      }) ? { failure: true } : { value: value };
  }
  
  /**
   * Sets the inline key value
   * @param {object} value
   * @param {*} key
   * @param {string} keyPath
   */
  function injectKeyIntoValueUsingKeyPath(value, key, keyPath) {
      var identifiers = keyPath.split('.');
      var last = identifiers.pop();
      for (var i = 0; i < identifiers.length; i++) {
          var identifier = identifiers[i];
          var hop = Object.prototype.hasOwnProperty.call(value, identifier);
          if (!hop) {
              value[identifier] = {};
          }
          value = value[identifier];
      }
      value[last] = key; // key is already a `keyValue` in our processing so no need to convert
  }
  
  // See https://github.com/w3c/IndexedDB/pull/146
  function checkKeyCouldBeInjectedIntoValue(value, keyPath) {
      var identifiers = keyPath.split('.');
      identifiers.pop();
      for (var i = 0; i < identifiers.length; i++) {
          if (!util.isObj(value)) {
              return false;
          }
          var identifier = identifiers[i];
          var hop = Object.prototype.hasOwnProperty.call(value, identifier);
          if (!hop) {
              return true;
          }
          value = value[identifier];
      }
      return util.isObj(value);
  }
  
  function isKeyInRange(key, range, checkCached) {
      var lowerMatch = range.lower === undefined;
      var upperMatch = range.upper === undefined;
      var encodedKey = _encode(key, true);
      var lower = checkCached ? range.__lowerCached : _encode(range.lower, true);
      var upper = checkCached ? range.__upperCached : _encode(range.upper, true);
  
      if (range.lower !== undefined) {
          if (range.lowerOpen && encodedKey > lower) {
              lowerMatch = true;
          }
          if (!range.lowerOpen && encodedKey >= lower) {
              lowerMatch = true;
          }
      }
      if (range.upper !== undefined) {
          if (range.upperOpen && encodedKey < upper) {
              upperMatch = true;
          }
          if (!range.upperOpen && encodedKey <= upper) {
              upperMatch = true;
          }
      }
  
      return lowerMatch && upperMatch;
  }
  
  /**
   * Determines whether an index entry matches a multi-entry key value.
   * @param {string} encodedEntry     The entry value (already encoded)
   * @param {string} encodedKey       The full index key (already encoded)
   * @returns {boolean}
   */
  function isMultiEntryMatch(encodedEntry, encodedKey) {
      var keyType = collations[encodedKey.slice(0, 1)];
  
      if (keyType === 'array') {
          return encodedKey.indexOf(encodedEntry) > 1;
      } else {
          return encodedKey === encodedEntry;
      }
  }
  
  function findMultiEntryMatches(keyEntry, range) {
      var matches = [];
  
      if (Array.isArray(keyEntry)) {
          for (var i = 0; i < keyEntry.length; i++) {
              var key = keyEntry[i];
  
              if (Array.isArray(key)) {
                  if (range && range.lower === range.upper) {
                      continue;
                  }
                  if (key.length === 1) {
                      key = key[0];
                  } else {
                      var nested = findMultiEntryMatches(key, range);
                      if (nested.length > 0) {
                          matches.push(key);
                      }
                      continue;
                  }
              }
  
              if (range == null || isKeyInRange(key, range, true)) {
                  matches.push(key);
              }
          }
      } else {
          if (range == null || isKeyInRange(keyEntry, range, true)) {
              matches.push(keyEntry);
          }
      }
      return matches;
  }
  
  /**
  * Not currently in use but keeping for spec parity
  */
  function convertKeyToValue(key) {
      var type = key.type;
      var value = key.value;
      switch (type) {
          case 'number':case 'string':
              {
                  return value;
              }case 'array':
              {
                  var array = [];
                  var len = value.length;
                  var index = 0;
                  while (index < len) {
                      var entry = convertKeyToValue(value[index]);
                      array[index] = entry;
                      index++;
                  }
                  return array;
              }case 'date':
              {
                  return new Date(value);
              }case 'binary':
              {
                  var _len = value.length;
                  var buffer = new ArrayBuffer(_len);
                  // Set the entries in buffer's [[ArrayBufferData]] to those in `value`
                  var uint8 = new Uint8Array(buffer, value.byteOffset || 0, value.byteLength);
                  uint8.set(value);
                  return buffer;
              }case 'invalid':default:
              throw new Error('Bad key');
      }
  }
  
  function _encode(key, inArray) {
      // Bad keys like `null`, `object`, `boolean`, 'function', 'symbol' should not be passed here due to prior validation
      if (key === undefined) {
          return null;
      }
      // array, date, number, string, binary (should already have detected "invalid")
      return types[getKeyType(key)].encode(key, inArray);
  }
  function _decode(key, inArray) {
      if (typeof key !== 'string') {
          return undefined;
      }
      return types[collations[key.slice(0, 1)]].decode(key, inArray);
  }
  
  function roundTrip(key, inArray) {
      return _decode(_encode(key, inArray), inArray);
  }
  
  /* eslint-disable object-property-newline */
  exports.encode = _encode;
  exports.decode = _decode;
  exports.roundTrip = roundTrip;
  exports.convertKeyToValue = convertKeyToValue;
  exports.convertValueToKeyValueDecoded = convertValueToKeyValueDecoded;
  exports.convertValueToMultiEntryKeyDecoded = convertValueToMultiEntryKeyDecoded;
  exports.convertValueToKey = convertValueToKey;
  exports.convertValueToMultiEntryKey = convertValueToMultiEntryKey;
  exports.convertValueToKeyRethrowingAndIfInvalid = convertValueToKeyRethrowingAndIfInvalid;
  exports.extractKeyFromValueUsingKeyPath = extractKeyFromValueUsingKeyPath;
  exports.evaluateKeyPathOnValue = evaluateKeyPathOnValue;
  exports.extractKeyValueDecodedFromValueUsingKeyPath = extractKeyValueDecodedFromValueUsingKeyPath;
  exports.injectKeyIntoValueUsingKeyPath = injectKeyIntoValueUsingKeyPath;
  exports.checkKeyCouldBeInjectedIntoValue = checkKeyCouldBeInjectedIntoValue;
  exports.isMultiEntryMatch = isMultiEntryMatch;
  exports.isKeyInRange = isKeyInRange;
  exports.findMultiEntryMatches = findMultiEntryMatches;
  
  },{"./DOMException":320,"./IDBFactory":325,"./util":338}],333:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.clone = exports.decode = exports.encode = undefined;
  
  var _typeson = require('typeson');
  
  var _typeson2 = _interopRequireDefault(_typeson);
  
  var _structuredCloningThrowing = require('typeson-registry/presets/structured-cloning-throwing');
  
  var _structuredCloningThrowing2 = _interopRequireDefault(_structuredCloningThrowing);
  
  var _DOMException = require('./DOMException');
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Todo: Register `ImageBitmap` and add `Blob`/`File`/`FileList`
  // Todo: add a proper polyfill for `ImageData` using node-canvas
  // See also: http://stackoverflow.com/questions/42170826/categories-for-rejection-by-the-structured-cloning-algorithm
  
  var typeson = new _typeson2.default().register(_structuredCloningThrowing2.default);
  
  // We are keeping the callback approach for now in case we wish to reexpose Blob, File, FileList
  
  // import Blob from 'w3c-blob'; // Needed by Node; uses native if available (browser)
  
  function encode(obj, cb) {
      var ret = void 0;
      try {
          ret = typeson.stringify(obj);
      } catch (err) {
          // SCA in typeson-registry using `DOMException` which is not defined (e.g., in Node)
          if (_typeson2.default.hasConstructorOf(err, ReferenceError) ||
          // SCA in typeson-registry threw a cloning error and we are in a
          //   supporting environment (e.g., the browser) where `ShimDOMException` is
          //   an alias for `DOMException`; if typeson-registry ever uses our shim
          //   to throw, we can use this condition alone.
          _typeson2.default.hasConstructorOf(err, _DOMException.ShimDOMException)) {
              throw (0, _DOMException.createDOMException)('DataCloneError', 'The object cannot be cloned.');
          }
          throw err; // We should rethrow non-cloning exceptions like from
          //  throwing getters (as in the W3C test, key-conversion-exceptions.htm)
      }
      if (cb) cb(ret);
      return ret;
  }
  
  function decode(obj) {
      return typeson.parse(obj);
  }
  
  function clone(val) {
      // We don't return the intermediate `encode` as we'll need to reencode the clone as it may differ
      return decode(encode(val));
  }
  
  exports.encode = encode;
  exports.decode = decode;
  exports.clone = clone;
  
  },{"./DOMException":320,"typeson":318,"typeson-registry/presets/structured-cloning-throwing":302}],334:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  // ID_Start (includes Other_ID_Start)
  var UnicodeIDStart = '(?:[$A-Z_a-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4\\uDD00-\\uDD43]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D])';
  
  // ID_Continue (includes Other_ID_Continue)
  var UnicodeIDContinue = '(?:[$0-9A-Z_a-z\\xAA\\xB5\\xB7\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0-\\u08B4\\u08B6-\\u08BD\\u08D4-\\u08E1\\u08E3-\\u0963\\u0966-\\u096F\\u0971-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AF9\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58-\\u0C5A\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C80-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D01-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-\\u0D57\\u0D5F-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1369-\\u1371\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19DA\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1AB0-\\u1ABD\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1C80-\\u1C88\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1CF8\\u1CF9\\u1D00-\\u1DF5\\u1DFB-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200C\\u200D\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA827\\uA840-\\uA873\\uA880-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA8FD\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uA9E0-\\uA9FE\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDDFD\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDEE0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF7A\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCA0-\\uDCA9\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE38-\\uDE3A\\uDE3F\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE6\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC00-\\uDC46\\uDC66-\\uDC6F\\uDC7F-\\uDCBA\\uDCD0-\\uDCE8\\uDCF0-\\uDCF9\\uDD00-\\uDD34\\uDD36-\\uDD3F\\uDD50-\\uDD73\\uDD76\\uDD80-\\uDDC4\\uDDCA-\\uDDCC\\uDDD0-\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE37\\uDE3E\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEEA\\uDEF0-\\uDEF9\\uDF00-\\uDF03\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3C-\\uDF44\\uDF47\\uDF48\\uDF4B-\\uDF4D\\uDF50\\uDF57\\uDF5D-\\uDF63\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC00-\\uDC4A\\uDC50-\\uDC59\\uDC80-\\uDCC5\\uDCC7\\uDCD0-\\uDCD9\\uDD80-\\uDDB5\\uDDB8-\\uDDC0\\uDDD8-\\uDDDD\\uDE00-\\uDE40\\uDE44\\uDE50-\\uDE59\\uDE80-\\uDEB7\\uDEC0-\\uDEC9\\uDF00-\\uDF19\\uDF1D-\\uDF2B\\uDF30-\\uDF39]|\\uD806[\\uDCA0-\\uDCE9\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC36\\uDC38-\\uDC40\\uDC50-\\uDC59\\uDC72-\\uDC8F\\uDC92-\\uDCA7\\uDCA9-\\uDCB6]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDE60-\\uDE69\\uDED0-\\uDEED\\uDEF0-\\uDEF4\\uDF00-\\uDF36\\uDF40-\\uDF43\\uDF50-\\uDF59\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50-\\uDF7E\\uDF8F-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99\\uDC9D\\uDC9E]|\\uD834[\\uDD65-\\uDD69\\uDD6D-\\uDD72\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB\\uDFCE-\\uDFFF]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD838[\\uDC00-\\uDC06\\uDC08-\\uDC18\\uDC1B-\\uDC21\\uDC23\\uDC24\\uDC26-\\uDC2A]|\\uD83A[\\uDC00-\\uDCC4\\uDCD0-\\uDCD6\\uDD00-\\uDD4A\\uDD50-\\uDD59]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]|\\uDB40[\\uDD00-\\uDDEF])';
  
  exports.UnicodeIDStart = UnicodeIDStart;
  exports.UnicodeIDContinue = UnicodeIDContinue;
  
  },{}],335:[function(require,module,exports){
  'use strict';
  
  var _UnicodeIdentifiers = require('./UnicodeIdentifiers');
  
  var UnicodeIdentifiers = _interopRequireWildcard(_UnicodeIdentifiers);
  
  var _setGlobalVars = require('./setGlobalVars');
  
  var _setGlobalVars2 = _interopRequireDefault(_setGlobalVars);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  // BEGIN: Same code as in browser.js
  _CFG2.default.win = typeof window !== 'undefined' ? window : self; // For Web Workers
  
  /* global shimIndexedDB */
  (0, _setGlobalVars2.default)();
  // END: Same code as in browser.js
  
  var __setUnicodeIdentifiers = shimIndexedDB.__setUnicodeIdentifiers.bind(shimIndexedDB);
  shimIndexedDB.__setUnicodeIdentifiers = function () {
      __setUnicodeIdentifiers(UnicodeIdentifiers);
  };
  
  shimIndexedDB.__setUnicodeIdentifiers();
  
  },{"./CFG":319,"./UnicodeIdentifiers":334,"./setGlobalVars":337}],336:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var _DOMException = require('./DOMException');
  
  var _Key = require('./Key');
  
  var Key = _interopRequireWildcard(_Key);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  // Todo Browser: polyfill IDBVersionChangeEvent, IDBOpenDBRequest?
  
  /**
   * Polyfills missing features in the browser's native IndexedDB implementation.
   * This is used for browsers that DON'T support WebSQL but DO support IndexedDB
   */
  function polyfill() {
      if (navigator.userAgent.match(/MSIE/) || navigator.userAgent.match(/Trident/) || navigator.userAgent.match(/Edge/)) {
          // Internet Explorer's native IndexedDB does not support compound keys
          compoundKeyPolyfill();
      }
  }
  
  /**
   * Polyfills support for compound keys
   */
  function compoundKeyPolyfill(IDBCursor, IDBCursorWithValue, IDBDatabase, IDBFactory, IDBIndex, IDBKeyRange, IDBObjectStore, IDBRequest, IDBTransaction) {
      var cmp = IDBFactory.prototype.cmp;
      var createObjectStore = IDBDatabase.prototype.createObjectStore;
      var createIndex = IDBObjectStore.prototype.createIndex;
      var add = IDBObjectStore.prototype.add;
      var put = IDBObjectStore.prototype.put;
      var indexGet = IDBIndex.prototype.get;
      var indexGetKey = IDBIndex.prototype.getKey;
      var indexCursor = IDBIndex.prototype.openCursor;
      var indexKeyCursor = IDBIndex.prototype.openKeyCursor;
      var storeGet = IDBObjectStore.prototype.get;
      var storeDelete = IDBObjectStore.prototype.delete;
      var storeCursor = IDBObjectStore.prototype.openCursor;
      var storeKeyCursor = IDBObjectStore.prototype.openKeyCursor;
      var bound = IDBKeyRange.bound;
      var upperBound = IDBKeyRange.upperBound;
      var lowerBound = IDBKeyRange.lowerBound;
      var only = IDBKeyRange.only;
      var requestResult = Object.getOwnPropertyDescriptor(IDBRequest.prototype, 'result');
      var cursorPrimaryKey = Object.getOwnPropertyDescriptor(IDBCursor.prototype, 'primaryKey');
      var cursorKey = Object.getOwnPropertyDescriptor(IDBCursor.prototype, 'key');
      var cursorValue = Object.getOwnPropertyDescriptor(IDBCursorWithValue.prototype, 'value');
  
      IDBFactory.prototype.cmp = function (key1, key2) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key1)) {
              args[0] = encodeCompoundKey(key1);
          }
          if (Array.isArray(key2)) {
              args[1] = encodeCompoundKey(key2);
          }
          return cmp.apply(this, args);
      };
  
      IDBDatabase.prototype.createObjectStore = function (name, opts) {
          if (opts && Array.isArray(opts.keyPath)) {
              opts.keyPath = encodeCompoundKeyPath(opts.keyPath);
          }
          return createObjectStore.apply(this, arguments);
      };
  
      IDBObjectStore.prototype.createIndex = function (name, keyPath, opts) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(keyPath)) {
              args[1] = encodeCompoundKeyPath(keyPath);
          }
          return createIndex.apply(this, args);
      };
  
      IDBObjectStore.prototype.add = function () /* value, key */{
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
              args[_key] = arguments[_key];
          }
  
          return this.__insertData(add, args);
      };
  
      IDBObjectStore.prototype.put = function () /* value, key */{
          for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
              args[_key2] = arguments[_key2];
          }
  
          return this.__insertData(put, args);
      };
  
      IDBObjectStore.prototype.__insertData = function (method, args) {
          args = Array.prototype.slice.call(args);
          var value = args[0];
          var key = args[1];
  
          // out-of-line key
          if (Array.isArray(key)) {
              args[1] = encodeCompoundKey(key);
          }
  
          if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
              // inline key
              if (isCompoundKey(this.keyPath)) {
                  var erred = setInlineCompoundKey(value, this.keyPath);
                  if (erred) {
                      throw (0, _DOMException.createDOMException)('DataError', 'keyPath error');
                  }
              }
  
              // inline indexes
              for (var i = 0; i < this.indexNames.length; i++) {
                  var index = this.index(this.indexNames[i]);
                  if (isCompoundKey(index.keyPath)) {
                      try {
                          setInlineCompoundKey(value, index.keyPath, index.multiEntry);
                      } catch (e) {
                          // The value doesn't have a valid key for this index.
                      }
                  }
              }
          }
          return method.apply(this, args);
      };
  
      IDBIndex.prototype.get = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return indexGet.apply(this, args);
      };
  
      IDBIndex.prototype.getKey = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return indexGetKey.apply(this, args);
      };
  
      IDBIndex.prototype.openCursor = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return indexCursor.apply(this, args);
      };
  
      IDBIndex.prototype.openKeyCursor = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return indexKeyCursor.apply(this, args);
      };
  
      IDBObjectStore.prototype.get = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return storeGet.apply(this, args);
      };
  
      IDBObjectStore.prototype.delete = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return storeDelete.apply(this, args);
      };
  
      IDBObjectStore.prototype.openCursor = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return storeCursor.apply(this, args);
      };
  
      IDBObjectStore.prototype.openKeyCursor = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return storeKeyCursor.apply(this, args);
      };
  
      IDBKeyRange.bound = function (lower, upper, lowerOpen, upperOpen) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(lower)) {
              args[0] = encodeCompoundKey(lower);
          }
          if (Array.isArray(upper)) {
              args[1] = encodeCompoundKey(upper);
          }
          return bound.apply(IDBKeyRange, args);
      };
  
      IDBKeyRange.upperBound = function (key, open) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return upperBound.apply(IDBKeyRange, args);
      };
  
      IDBKeyRange.lowerBound = function (key, open) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return lowerBound.apply(IDBKeyRange, args);
      };
  
      IDBKeyRange.only = function (key) {
          var args = Array.prototype.slice.call(arguments);
          if (Array.isArray(key)) {
              args[0] = encodeCompoundKey(key);
          }
          return only.apply(IDBKeyRange, args);
      };
  
      Object.defineProperty(IDBRequest.prototype, 'result', {
          enumerable: requestResult.enumerable,
          configurable: requestResult.configurable,
          get: function get() {
              var result = requestResult.get.call(this);
              return removeInlineCompoundKey(result);
          }
      });
  
      Object.defineProperty(IDBCursor.prototype, 'primaryKey', {
          enumerable: cursorPrimaryKey.enumerable,
          configurable: cursorPrimaryKey.configurable,
          get: function get() {
              var result = cursorPrimaryKey.get.call(this);
              return removeInlineCompoundKey(result);
          }
      });
  
      Object.defineProperty(IDBCursor.prototype, 'key', {
          enumerable: cursorKey.enumerable,
          configurable: cursorKey.configurable,
          get: function get() {
              var result = cursorKey.get.call(this);
              return removeInlineCompoundKey(result);
          }
      });
  
      Object.defineProperty(IDBCursorWithValue.prototype, 'value', {
          enumerable: cursorValue.enumerable,
          configurable: cursorValue.configurable,
          get: function get() {
              var result = cursorValue.get.call(this);
              return removeInlineCompoundKey(result);
          }
      });
  }
  
  var compoundKeysPropertyName = '__$$compoundKey';
  var propertySeparatorRegExp = /\$\$/g;
  var propertySeparator = '$$$$'; // "$$" after RegExp escaping
  var keySeparator = '$_$';
  
  function isCompoundKey(keyPath) {
      return keyPath && keyPath.indexOf(compoundKeysPropertyName + '.') === 0;
  }
  
  function encodeCompoundKeyPath(keyPath) {
      // Encoded dotted properties
      // ["name.first", "name.last"] ==> ["name$$first", "name$$last"]
      for (var i = 0; i < keyPath.length; i++) {
          keyPath[i] = keyPath[i].replace(/\./g, propertySeparator);
      }
  
      // Encode the array as a single property
      // ["name$$first", "name$$last"] => "__$$compoundKey.name$$first$_$name$$last"
      return compoundKeysPropertyName + '.' + keyPath.join(keySeparator);
  }
  
  function decodeCompoundKeyPath(keyPath) {
      // Remove the "__$$compoundKey." prefix
      keyPath = keyPath.substr(compoundKeysPropertyName.length + 1);
  
      // Split the properties into an array
      // "name$$first$_$name$$last" ==> ["name$$first", "name$$last"]
      keyPath = keyPath.split(keySeparator);
  
      // Decode dotted properties
      // ["name$$first", "name$$last"] ==> ["name.first", "name.last"]
      for (var i = 0; i < keyPath.length; i++) {
          keyPath[i] = keyPath[i].replace(propertySeparatorRegExp, '.');
      }
      return keyPath;
  }
  
  function setInlineCompoundKey(value, encodedKeyPath, multiEntry) {
      // Encode the key
      var keyPath = decodeCompoundKeyPath(encodedKeyPath);
      var key = Key.extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry);
      if (key.failure || key.invalid) {
          return true;
      }
      var encodedKey = encodeCompoundKey(key.value);
  
      // Store the encoded key inline
      encodedKeyPath = encodedKeyPath.substr(compoundKeysPropertyName.length + 1);
      value[compoundKeysPropertyName] = value[compoundKeysPropertyName] || {};
      value[compoundKeysPropertyName][encodedKeyPath] = encodedKey;
  }
  
  function removeInlineCompoundKey(value) {
      if (typeof value === 'string' && isCompoundKey(value)) {
          return decodeCompoundKey(value);
      } else if (value && _typeof(value[compoundKeysPropertyName]) === 'object') {
          delete value[compoundKeysPropertyName];
      }
      return value;
  }
  
  function encodeCompoundKey(key) {
      // Validate and encode the key
      Key.convertValueToKeyRethrowingAndIfInvalid(key);
      key = Key.encode(key);
  
      // Prepend the "__$$compoundKey." prefix
      key = compoundKeysPropertyName + '.' + key;
  
      validateKeyLength(key);
      return key;
  }
  
  function decodeCompoundKey(key) {
      validateKeyLength(key);
  
      // Remove the "__$$compoundKey." prefix
      key = key.substr(compoundKeysPropertyName.length + 1);
  
      // Decode the key
      key = Key.decode(key);
      return key;
  }
  
  function validateKeyLength(key) {
      // BUG: Internet Explorer truncates string keys at 889 characters
      if (key.length > 889) {
          throw (0, _DOMException.createDOMException)('DataError', 'The encoded key is ' + key.length + ' characters long, but IE only allows 889 characters. Consider replacing numeric keys with strings to reduce the encoded length.');
      }
  }
  
  exports.default = polyfill;
  module.exports = exports['default'];
  
  },{"./DOMException":320,"./Key":332}],337:[function(require,module,exports){
  (function (global){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; // `Object.assign` including within `EventTarget`, generator functions, `Array.from`, etc.; see https://babeljs.io/docs/usage/polyfill/
  
  
  require('babel-polyfill');
  
  var _IDBVersionChangeEvent = require('./IDBVersionChangeEvent');
  
  var _IDBVersionChangeEvent2 = _interopRequireDefault(_IDBVersionChangeEvent);
  
  var _IDBCursor = require('./IDBCursor');
  
  var _IDBRequest = require('./IDBRequest');
  
  var _DOMException = require('./DOMException');
  
  var _IDBFactory = require('./IDBFactory');
  
  var _IDBKeyRange = require('./IDBKeyRange');
  
  var _IDBKeyRange2 = _interopRequireDefault(_IDBKeyRange);
  
  var _IDBObjectStore = require('./IDBObjectStore');
  
  var _IDBObjectStore2 = _interopRequireDefault(_IDBObjectStore);
  
  var _IDBIndex = require('./IDBIndex');
  
  var _IDBIndex2 = _interopRequireDefault(_IDBIndex);
  
  var _IDBTransaction = require('./IDBTransaction');
  
  var _IDBTransaction2 = _interopRequireDefault(_IDBTransaction);
  
  var _IDBDatabase = require('./IDBDatabase');
  
  var _IDBDatabase2 = _interopRequireDefault(_IDBDatabase);
  
  var _polyfill = require('./polyfill');
  
  var _polyfill2 = _interopRequireDefault(_polyfill);
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  var glob = typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : self;
  glob._babelPolyfill = false; // http://stackoverflow.com/questions/31282702/conflicting-use-of-babel-register
  
  function setConfig(prop, val) {
      if (prop && (typeof prop === 'undefined' ? 'undefined' : _typeof(prop)) === 'object') {
          for (var p in prop) {
              setConfig(p, prop[p]);
          }
          return;
      }
      if (!(prop in _CFG2.default)) {
          throw new Error(prop + ' is not a valid configuration property');
      }
      _CFG2.default[prop] = val;
  }
  
  function setGlobalVars(idb, initialConfig) {
      if (initialConfig) {
          setConfig(initialConfig);
      }
      var IDB = idb || (typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {});
      function shim(name, value, propDesc) {
          if (!propDesc || !Object.defineProperty) {
              try {
                  // Try setting the property. This will fail if the property is read-only.
                  IDB[name] = value;
              } catch (e) {
                  console.log(e);
              }
          }
          if (IDB[name] !== value && Object.defineProperty) {
              // Setting a read-only property failed, so try re-defining the property
              try {
                  var desc = propDesc || {};
                  desc.get = function () {
                      return value;
                  };
                  Object.defineProperty(IDB, name, desc);
                  /*
                  // Due to <https://github.com/axemclion/IndexedDBShim/issues/280>,
                  //   there are problems for us to retain the descriptor
                  //   and thus the fact that indexedDB is to be implemented
                  //   as a getter (as expected in interface tests).
                  if (name === 'indexedDB') {
                      console.log(Object.getOwnPropertyDescriptor(IDB, name));
                  }
                  */
              } catch (e) {
                  // With `indexedDB`, PhantomJS fails here and below but
                  //  not above, while Chrome is reverse (and Firefox doesn't
                  //  get here since no WebSQL to use for shimming)
              }
          }
          if (IDB[name] !== value) {
              typeof console !== 'undefined' && console.warn && console.warn('Unable to shim ' + name);
          }
      }
      shim('shimIndexedDB', _IDBFactory.shimIndexedDB, {
          enumerable: false,
          configurable: true
      });
      if (IDB.shimIndexedDB) {
          IDB.shimIndexedDB.__useShim = function () {
              // Todo: Accept argument to set DOMException, DOMStringList, Event
              var shimIDBFactory = IDB.shimIndexedDB.modules.IDBFactory;
              if (_CFG2.default.win.openDatabase !== undefined) {
                  // Polyfill ALL of IndexedDB, using WebSQL
                  if (_CFG2.default.fullIDLSupport) {
                      // Slow per MDN so off by default! Though apparently needed for WebIDL: http://stackoverflow.com/questions/41927589/rationales-consequences-of-webidl-class-inheritance-requirements
                      var ShimEvent = IDB.shimIndexedDB.modules.ShimEvent;
                      var ShimEventTarget = IDB.shimIndexedDB.modules.ShimEventTarget;
                      Object.setPrototypeOf(_IDBDatabase2.default, ShimEventTarget);
                      Object.setPrototypeOf(_IDBRequest.IDBRequest, ShimEventTarget);
                      Object.setPrototypeOf(_IDBTransaction2.default, ShimEventTarget);
                      Object.setPrototypeOf(_IDBVersionChangeEvent2.default, ShimEvent);
                      Object.setPrototypeOf(_DOMException.ShimDOMException, Error);
                      Object.setPrototypeOf(_DOMException.ShimDOMException.prototype, Error.prototype);
                  }
                  [['indexedDB', _IDBFactory.shimIndexedDB], ['IDBFactory', shimIDBFactory], ['IDBDatabase', _IDBDatabase2.default], ['IDBObjectStore', _IDBObjectStore2.default], ['IDBIndex', _IDBIndex2.default], ['IDBTransaction', _IDBTransaction2.default], ['IDBCursor', _IDBCursor.IDBCursor], ['IDBCursorWithValue', _IDBCursor.IDBCursorWithValue], ['IDBKeyRange', _IDBKeyRange2.default], ['IDBRequest', _IDBRequest.IDBRequest], ['IDBOpenDBRequest', _IDBRequest.IDBOpenDBRequest], ['IDBVersionChangeEvent', _IDBVersionChangeEvent2.default]].forEach(function (_ref) {
                      var _ref2 = _slicedToArray(_ref, 2),
                          prop = _ref2[0],
                          obj = _ref2[1];
  
                      shim(prop, obj, {
                          enumerable: false,
                          configurable: true
                      });
                  });
                  if (_CFG2.default.addNonIDBGlobals && IDB.indexedDB && IDB.indexedDB.modules) {
                      // As `DOMStringList` exists per IDL (and Chrome) in the global
                      //   thread (but not in workers), we prefix the name to avoid
                      //   shadowing or conflicts
                      // Todo: We could provide an option to shim directly as
                      //   `DOMStringList` and thereby get the `enumerable` and readonly
                      //   settings out of the box
                      shim('ShimDOMStringList', IDB.indexedDB.modules.ShimDOMStringList, {
                          enumerable: false,
                          configurable: true
                      });
                      shim('ShimEvent', IDB.indexedDB.modules.ShimEvent);
                      shim('ShimCustomEvent', IDB.indexedDB.modules.ShimCustomEvent);
                      shim('ShimEventTarget', IDB.indexedDB.modules.ShimEventTarget);
                      shim('ShimDOMException', IDB.indexedDB.modules.ShimDOMException);
                  }
              } else if (_typeof(IDB.indexedDB) === 'object') {
                  // Polyfill the missing IndexedDB features (no need for IDBEnvironment, the window containing indexedDB itself))
                  (0, _polyfill2.default)(_IDBCursor.IDBCursor, _IDBCursor.IDBCursorWithValue, _IDBDatabase2.default, shimIDBFactory, _IDBIndex2.default, _IDBKeyRange2.default, _IDBObjectStore2.default, _IDBRequest.IDBRequest, _IDBTransaction2.default);
              }
          };
  
          IDB.shimIndexedDB.__debug = function (val) {
              _CFG2.default.DEBUG = val;
          };
          IDB.shimIndexedDB.__setConfig = setConfig;
          IDB.shimIndexedDB.__getConfig = function (prop) {
              if (!(prop in _CFG2.default)) {
                  throw new Error(prop + ' is not a valid configuration property');
              }
              return _CFG2.default[prop];
          };
          IDB.shimIndexedDB.__setUnicodeIdentifiers = function (ui) {
              setConfig({
                  UnicodeIDStart: ui.UnicodeIDStart,
                  UnicodeIDContinue: ui.UnicodeIDContinue
              });
          };
      }
  
      // Workaround to prevent an error in Firefox
      if (!('indexedDB' in IDB) && typeof window !== 'undefined') {
          // 2nd condition avoids problems in Node
          IDB.indexedDB = IDB.indexedDB || IDB.webkitIndexedDB || IDB.mozIndexedDB || IDB.oIndexedDB || IDB.msIndexedDB;
      }
  
      // Detect browsers with known IndexedDb issues (e.g. Android pre-4.4)
      var poorIndexedDbSupport = false;
      if (typeof navigator !== 'undefined' && ( // Ignore Node or other environments
  
      // Bad non-Chrome Android support
      navigator.userAgent.match(/Android (?:2|3|4\.[0-3])/) && !navigator.userAgent.match(/Chrome/) ||
      // Bad non-Safari iOS9 support (see <https://github.com/axemclion/IndexedDBShim/issues/252>)
      (navigator.userAgent.indexOf('Safari') === -1 || navigator.userAgent.indexOf('Chrome') > -1) && // Exclude genuine Safari: http://stackoverflow.com/a/7768006/271577
      // Detect iOS: http://stackoverflow.com/questions/9038625/detect-if-device-is-ios/9039885#9039885
      // and detect version 9: http://stackoverflow.com/a/26363560/271577
      /(iPad|iPhone|iPod).* os 9_/i.test(navigator.userAgent) && !window.MSStream // But avoid IE11
      )) {
          poorIndexedDbSupport = true;
      }
      if (!_CFG2.default.DEFAULT_DB_SIZE) {
          _CFG2.default.DEFAULT_DB_SIZE = ( // Safari currently requires larger size: (We don't need a larger size for Node as node-websql doesn't use this info)
          // https://github.com/axemclion/IndexedDBShim/issues/41
          // https://github.com/axemclion/IndexedDBShim/issues/115
          typeof navigator !== 'undefined' && navigator.userAgent.indexOf('Safari') > -1 && navigator.userAgent.indexOf('Chrome') === -1 ? 25 : 4) * 1024 * 1024;
      }
      if ((!IDB.indexedDB || poorIndexedDbSupport) && _CFG2.default.win.openDatabase !== undefined) {
          IDB.shimIndexedDB.__useShim();
      } else {
          IDB.IDBDatabase = IDB.IDBDatabase || IDB.webkitIDBDatabase;
          IDB.IDBTransaction = IDB.IDBTransaction || IDB.webkitIDBTransaction || {};
          IDB.IDBCursor = IDB.IDBCursor || IDB.webkitIDBCursor;
          IDB.IDBKeyRange = IDB.IDBKeyRange || IDB.webkitIDBKeyRange;
      }
      return IDB;
  }
  
  exports.default = setGlobalVars;
  module.exports = exports['default'];
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./CFG":319,"./DOMException":320,"./IDBCursor":323,"./IDBDatabase":324,"./IDBFactory":325,"./IDBIndex":326,"./IDBKeyRange":327,"./IDBObjectStore":328,"./IDBRequest":329,"./IDBTransaction":330,"./IDBVersionChangeEvent":331,"./polyfill":336,"babel-polyfill":1}],338:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.convertToSequenceDOMString = exports.enforceRange = exports.isValidKeyPath = exports.defineReadonlyProperties = exports.isIterable = exports.isBinary = exports.isFile = exports.isRegExp = exports.isBlob = exports.isDate = exports.isObj = exports.instanceOf = exports.sqlQuote = exports.sqlLIKEEscape = exports.escapeIndexNameForSQLKeyColumn = exports.escapeIndexNameForSQL = exports.escapeStoreNameForSQL = exports.unescapeDatabaseNameForSQLAndFiles = exports.escapeDatabaseNameForSQLAndFiles = exports.unescapeSQLiteResponse = exports.escapeSQLiteStatement = undefined;
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var _CFG = require('./CFG');
  
  var _CFG2 = _interopRequireDefault(_CFG);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function escapeNameForSQLiteIdentifier(arg) {
      // http://stackoverflow.com/a/6701665/271577
      return '_' + // Prevent empty string
      arg.replace(/\^/g, '^^') // Escape our escape
      // http://www.sqlite.org/src/tktview?name=57c971fc74
      .replace(/\0/g, '^0')
      // We need to avoid identifiers being treated as duplicates based on SQLite's ASCII-only case-insensitive table and column names
      // (For SQL in general, however, see http://stackoverflow.com/a/17215009/271577
      // See also https://www.sqlite.org/faq.html#q18 re: Unicode (non-ASCII) case-insensitive not working
      .replace(/([A-Z])/g, '^$1')
      // http://stackoverflow.com/a/6701665/271577
      .replace(/([\uD800-\uDBFF])(?![\uDC00-\uDFFF])|(^|[^\uD800-\uDBFF])([\uDC00-\uDFFF])/g, function (_, unmatchedHighSurrogate, unmatchedLowSurrogate) {
          if (unmatchedHighSurrogate) {
              return '^2' + unmatchedHighSurrogate + '\uDC00'; // Add a low surrogate for compatibility with `node-sqlite3`: http://bugs.python.org/issue12569 and http://stackoverflow.com/a/6701665/271577
          }
          return '^3\uD800' + unmatchedLowSurrogate;
      });
  }
  
  function escapeSQLiteStatement(arg) {
      return arg.replace(/\^/g, '^^').replace(/\0/g, '^0');
  }
  function unescapeSQLiteResponse(arg) {
      return arg.replace(/\^0/g, '\0').replace(/\^\^/g, '^');
  }
  
  function sqlEscape(arg) {
      // https://www.sqlite.org/lang_keywords.html
      // http://stackoverflow.com/a/6701665/271577
      // There is no need to escape ', `, or [], as
      //   we should always be within double quotes
      // NUL should have already been stripped
      return arg.replace(/"/g, '""');
  }
  
  function sqlQuote(arg) {
      return '"' + sqlEscape(arg) + '"';
  }
  
  function escapeDatabaseNameForSQLAndFiles(db) {
      if (_CFG2.default.escapeDatabaseName) {
          // We at least ensure NUL is escaped by default, but we need to still
          //   handle empty string and possibly also length (potentially
          //   throwing if too long), escaping casing (including Unicode?),
          //   and escaping special characters depending on file system
          return _CFG2.default.escapeDatabaseName(escapeSQLiteStatement(db));
      }
      db = 'D' + escapeNameForSQLiteIdentifier(db);
      if (_CFG2.default.databaseCharacterEscapeList !== false) {
          db = db.replace(_CFG2.default.databaseCharacterEscapeList ? new RegExp(_CFG2.default.databaseCharacterEscapeList, 'g') : /[\u0000-\u001F\u007F"*/:<>?\\|]/g, function (n0) {
              return '^1' + n0.charCodeAt().toString(16).padStart(2, '0');
          });
      }
      if (_CFG2.default.databaseNameLengthLimit !== false && db.length >= (_CFG2.default.databaseNameLengthLimit || 254)) {
          throw new Error('Unexpectedly long database name supplied; length limit required for Node compatibility; passed length: ' + db.length + '; length limit setting: ' + (_CFG2.default.databaseNameLengthLimit || 254) + '.');
      }
      return db; // Shouldn't have quoting (do we even need NUL/case escaping here?)
  }
  
  // Not in use internally but supplied for convenience
  function unescapeDatabaseNameForSQLAndFiles(db) {
      if (_CFG2.default.unescapeDatabaseName) {
          // We at least ensure NUL is unescaped by default, but we need to still
          //   handle empty string and possibly also length (potentially
          //   throwing if too long), unescaping casing (including Unicode?),
          //   and unescaping special characters depending on file system
          return _CFG2.default.unescapeDatabaseName(unescapeSQLiteResponse(db));
      }
  
      return db.slice(2) // D_
      .replace(/(\^+)1([0-9a-f]{2})/g, function (_, esc, hex) {
          return esc % 2 ? String.fromCharCode(parseInt(hex, 16)) : _;
      }) // databaseCharacterEscapeList
      .replace(/(\^+)3\uD800([\uDC00-\uDFFF])/g, function (_, esc, lowSurr) {
          return esc % 2 ? lowSurr : _;
      }).replace(/(\^+)2([\uD800-\uDBFF])\uDC00/g, function (_, esc, highSurr) {
          return esc % 2 ? highSurr : _;
      }).replace(/(\^+)([A-Z])/g, function (_, esc, upperCase) {
          return esc % 2 ? upperCase : _;
      }).replace(/(\^+)0/g, function (_, esc) {
          return esc % 2 ? '\0' : _;
      }).replace(/\^\^/g, '^');
  }
  
  function escapeStoreNameForSQL(store) {
      return sqlQuote('S' + escapeNameForSQLiteIdentifier(store));
  }
  
  function escapeIndexNameForSQL(index) {
      return sqlQuote('I' + escapeNameForSQLiteIdentifier(index));
  }
  
  function escapeIndexNameForSQLKeyColumn(index) {
      return 'I' + escapeNameForSQLiteIdentifier(index);
  }
  
  function sqlLIKEEscape(str) {
      // https://www.sqlite.org/lang_expr.html#like
      return sqlEscape(str).replace(/\^/g, '^^');
  }
  
  // Babel doesn't seem to provide a means of using the `instanceof` operator with Symbol.hasInstance (yet?)
  function instanceOf(obj, Clss) {
      return Clss[Symbol.hasInstance](obj);
  }
  
  function isObj(obj) {
      return obj && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
  }
  
  function isDate(obj) {
      return isObj(obj) && typeof obj.getDate === 'function';
  }
  
  function isBlob(obj) {
      return isObj(obj) && typeof obj.size === 'number' && typeof obj.slice === 'function' && !('lastModified' in obj);
  }
  
  function isRegExp(obj) {
      return isObj(obj) && typeof obj.flags === 'string' && typeof obj.exec === 'function';
  }
  
  function isFile(obj) {
      return isObj(obj) && typeof obj.name === 'string' && typeof obj.slice === 'function' && 'lastModified' in obj;
  }
  
  function isBinary(obj) {
      return isObj(obj) && typeof obj.byteLength === 'number' && (typeof obj.slice === 'function' || // `TypedArray` (view on buffer) or `ArrayBuffer`
      typeof obj.getFloat64 === 'function' // `DataView` (view on buffer)
      );
  }
  
  function isIterable(obj) {
      return isObj(obj) && typeof obj[Symbol.iterator] === 'function';
  }
  
  function defineReadonlyProperties(obj, props) {
      props = typeof props === 'string' ? [props] : props;
      props.forEach(function (prop) {
          Object.defineProperty(obj, '__' + prop, {
              enumerable: false,
              configurable: false,
              writable: true
          });
          Object.defineProperty(obj, prop, {
              enumerable: true,
              configurable: true,
              get: function get() {
                  return this['__' + prop];
              }
          });
      });
  }
  
  var HexDigit = '[0-9a-fA-F]';
  // The commented out line below is technically the grammar, with a SyntaxError
  //   to occur if larger than U+10FFFF, but we will prevent the error by
  //   establishing the limit in regular expressions
  // const HexDigits = HexDigit + HexDigit + '*';
  var HexDigits = '0*(?:' + HexDigit + '{1,5}|10' + HexDigit + '{4})*';
  var UnicodeEscapeSequence = '(?:u' + HexDigit + '{4}|u{' + HexDigits + '})';
  
  function isIdentifier(item) {
      // For load-time and run-time performance, we don't provide the complete regular
      //   expression for identifiers, but these can be passed in, using the expressions
      //   found at https://gist.github.com/brettz9/b4cd6821d990daa023b2e604de371407
      // ID_Start (includes Other_ID_Start)
      var UnicodeIDStart = _CFG2.default.UnicodeIDStart || '[$A-Z_a-z]';
      // ID_Continue (includes Other_ID_Continue)
      var UnicodeIDContinue = _CFG2.default.UnicodeIDContinue || '[$0-9A-Z_a-z]';
      var IdentifierStart = '(?:' + UnicodeIDStart + '|[$_]|\\\\' + UnicodeEscapeSequence + ')';
      var IdentifierPart = '(?:' + UnicodeIDContinue + '|[$_]|\\\\' + UnicodeEscapeSequence + '|\\u200C|\\u200D)';
      return new RegExp('^' + IdentifierStart + IdentifierPart + '*$').test(item);
  }
  
  function isValidKeyPathString(keyPathString) {
      return typeof keyPathString === 'string' && (keyPathString === '' || isIdentifier(keyPathString) || keyPathString.split('.').every(isIdentifier));
  }
  
  function isValidKeyPath(keyPath) {
      return isValidKeyPathString(keyPath) || Array.isArray(keyPath) && keyPath.length &&
      // Convert array from sparse to dense http://www.2ality.com/2012/06/dense-arrays.html
      Array.apply(null, keyPath).every(function (kpp) {
          // See also https://heycam.github.io/webidl/#idl-DOMString
          return isValidKeyPathString(kpp); // Should already be converted to string by here
      });
  }
  
  function enforceRange(number, type) {
      number = Math.floor(Number(number));
      var max = void 0,
          min = void 0;
      switch (type) {
          case 'unsigned long long':
              {
                  max = 0x1FFFFFFFFFFFFF; // 2^53 - 1
                  min = 0;
                  break;
              }
          case 'unsigned long':
              {
                  max = 0xFFFFFFFF; // 2^32 - 1
                  min = 0;
                  break;
              }
          default:
              throw new Error('Unrecognized type supplied to enforceRange');
      }
      if (isNaN(number) || !isFinite(number) || number > max || number < min) {
          throw new TypeError('Invalid range: ' + number);
      }
      return number;
  }
  
  function ToString(o) {
      // Todo: See `es-abstract/es7`
      return '' + o; // `String()` will not throw with Symbols
  }
  
  function convertToSequenceDOMString(val) {
      // Per <https://heycam.github.io/webidl/#idl-sequence>, converting to a sequence works with iterables
      if (isIterable(val)) {
          // We don't want `Array.from` to convert primitives
          // Per <https://heycam.github.io/webidl/#es-DOMString>, converting to a `DOMString` to be via `ToString`: https://tc39.github.io/ecma262/#sec-tostring
          return Array.from(val).map(ToString);
      }
      return val;
  }
  
  exports.escapeSQLiteStatement = escapeSQLiteStatement;
  exports.unescapeSQLiteResponse = unescapeSQLiteResponse;
  exports.escapeDatabaseNameForSQLAndFiles = escapeDatabaseNameForSQLAndFiles;
  exports.unescapeDatabaseNameForSQLAndFiles = unescapeDatabaseNameForSQLAndFiles;
  exports.escapeStoreNameForSQL = escapeStoreNameForSQL;
  exports.escapeIndexNameForSQL = escapeIndexNameForSQL;
  exports.escapeIndexNameForSQLKeyColumn = escapeIndexNameForSQLKeyColumn;
  exports.sqlLIKEEscape = sqlLIKEEscape;
  exports.sqlQuote = sqlQuote;
  exports.instanceOf = instanceOf;
  exports.isObj = isObj;
  exports.isDate = isDate;
  exports.isBlob = isBlob;
  exports.isRegExp = isRegExp;
  exports.isFile = isFile;
  exports.isBinary = isBinary;
  exports.isIterable = isIterable;
  exports.defineReadonlyProperties = defineReadonlyProperties;
  exports.isValidKeyPath = isValidKeyPath;
  exports.enforceRange = enforceRange;
  exports.convertToSequenceDOMString = convertToSequenceDOMString;
  
  },{"./CFG":319}]},{},[335]);
  