first commit

node_modules/@babel/runtime-corejs2/helpers/readOnlyError.js

+function _readOnlyError(name) {
+  throw new Error("\"" + name + "\" is read-only");
+}
+
+module.exports = _readOnlyError;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/set.js

+var _Object$defineProperty = require("../core-js/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor");
+
+var _Reflect$set = require("../core-js/reflect/set");
+
+var superPropBase = require("./superPropBase");
+
+var defineProperty = require("./defineProperty");
+
+function set(target, property, value, receiver) {
+  if (typeof Reflect !== "undefined" && _Reflect$set) {
+    set = _Reflect$set;
+  } else {
+    set = function set(target, property, value, receiver) {
+      var base = superPropBase(target, property);
+      var desc;
+
+      if (base) {
+        desc = _Object$getOwnPropertyDescriptor(base, property);
+
+        if (desc.set) {
+          desc.set.call(receiver, value);
+          return true;
+        } else if (!desc.writable) {
+          return false;
+        }
+      }
+
+      desc = _Object$getOwnPropertyDescriptor(receiver, property);
+
+      if (desc) {
+        if (!desc.writable) {
+          return false;
+        }
+
+        desc.value = value;
+
+        _Object$defineProperty(receiver, property, desc);
+      } else {
+        defineProperty(receiver, property, value);
+      }
+
+      return true;
+    };
+  }
+
+  return set(target, property, value, receiver);
+}
+
+function _set(target, property, value, receiver, isStrict) {
+  var s = set(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error('failed to set property');
+  }
+
+  return value;
+}
+
+module.exports = _set;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/setPrototypeOf.js

+var _Object$setPrototypeOf = require("../core-js/object/set-prototype-of");
+
+function _setPrototypeOf(o, p) {
+  module.exports = _setPrototypeOf = _Object$setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+module.exports = _setPrototypeOf;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/skipFirstGeneratorNext.js

+function _skipFirstGeneratorNext(fn) {
+  return function () {
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}
+
+module.exports = _skipFirstGeneratorNext;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/slicedToArray.js

+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArrayLimit = require("./iterableToArrayLimit");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArray;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/slicedToArrayLoose.js

+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArrayLimitLoose = require("./iterableToArrayLimitLoose");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArrayLoose;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/superPropBase.js

+var getPrototypeOf = require("./getPrototypeOf");
+
+function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
+
+module.exports = _superPropBase;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/taggedTemplateLiteral.js

+var _Object$defineProperties = require("../core-js/object/define-properties");
+
+var _Object$freeze = require("../core-js/object/freeze");
+
+function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return _Object$freeze(_Object$defineProperties(strings, {
+    raw: {
+      value: _Object$freeze(raw)
+    }
+  }));
+}
+
+module.exports = _taggedTemplateLiteral;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/taggedTemplateLiteralLoose.js

+function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}
+
+module.exports = _taggedTemplateLiteralLoose;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/tdz.js

+function _tdzError(name) {
+  throw new ReferenceError(name + " is not defined - temporal dead zone");
+}
+
+module.exports = _tdzError;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/temporalRef.js

+var temporalUndefined = require("./temporalUndefined");
+
+var tdz = require("./tdz");
+
+function _temporalRef(val, name) {
+  return val === temporalUndefined ? tdz(name) : val;
+}
+
+module.exports = _temporalRef;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/temporalUndefined.js

+function _temporalUndefined() {}
+
+module.exports = _temporalUndefined;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/toArray.js

+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArray = require("./iterableToArray");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _toArray(arr) {
+  return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+}
+
+module.exports = _toArray;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/toConsumableArray.js

+var arrayWithoutHoles = require("./arrayWithoutHoles");
+
+var iterableToArray = require("./iterableToArray");
+
+var nonIterableSpread = require("./nonIterableSpread");
+
+function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
+
+module.exports = _toConsumableArray;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/toPrimitive.js

+var _Symbol$toPrimitive = require("../core-js/symbol/to-primitive");
+
+var _typeof = require("../helpers/typeof");
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[_Symbol$toPrimitive];
+
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+
+  return (hint === "string" ? String : Number)(input);
+}
+
+module.exports = _toPrimitive;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/toPropertyKey.js

+var _typeof = require("../helpers/typeof");
+
+var toPrimitive = require("./toPrimitive");
+
+function _toPropertyKey(arg) {
+  var key = toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+module.exports = _toPropertyKey;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/typeof.js

+var _Symbol$iterator = require("../core-js/symbol/iterator");
+
+var _Symbol = require("../core-js/symbol");
+
+function _typeof2(obj) { if (typeof _Symbol === "function" && typeof _Symbol$iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof _Symbol === "function" && obj.constructor === _Symbol && obj !== _Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
+
+function _typeof(obj) {
+  if (typeof _Symbol === "function" && _typeof2(_Symbol$iterator) === "symbol") {
+    module.exports = _typeof = function _typeof(obj) {
+      return _typeof2(obj);
+    };
+  } else {
+    module.exports = _typeof = function _typeof(obj) {
+      return obj && typeof _Symbol === "function" && obj.constructor === _Symbol && obj !== _Symbol.prototype ? "symbol" : _typeof2(obj);
+    };
+  }
+
+  return _typeof(obj);
+}
+
+module.exports = _typeof;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/wrapAsyncGenerator.js

+var AsyncGenerator = require("./AsyncGenerator");
+
+function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}
+
+module.exports = _wrapAsyncGenerator;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/wrapNativeSuper.js

+var _Object$create = require("../core-js/object/create");
+
+var _Map = require("../core-js/map");
+
+var getPrototypeOf = require("./getPrototypeOf");
+
+var setPrototypeOf = require("./setPrototypeOf");
+
+var isNativeFunction = require("./isNativeFunction");
+
+var construct = require("./construct");
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof _Map === "function" ? new _Map() : undefined;
+
+  module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return construct(Class, arguments, getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = _Object$create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+module.exports = _wrapNativeSuper;
\ No newline at end of file

node_modules/@babel/runtime-corejs2/helpers/wrapRegExp.js

+var _Object$create = require("../core-js/object/create");
+
+var _Object$keys = require("../core-js/object/keys");
+
+var _typeof = require("../helpers/typeof");
+
+var _Symbol$replace = require("../core-js/symbol/replace");
+
+var _WeakMap = require("../core-js/weak-map");
+
+var wrapNativeSuper = require("./wrapNativeSuper");
+
+var getPrototypeOf = require("./getPrototypeOf");
+
+var possibleConstructorReturn = require("./possibleConstructorReturn");
+
+var inherits = require("./inherits");
+
+function _wrapRegExp(re, groups) {
+  module.exports = _wrapRegExp = function _wrapRegExp(re, groups) {
+    return new BabelRegExp(re, undefined, groups);
+  };
+
+  var _RegExp = wrapNativeSuper(RegExp);
+
+  var _super = RegExp.prototype;
+
+  var _groups = new _WeakMap();
+
+  function BabelRegExp(re, flags, groups) {
+    var _this = _RegExp.call(this, re, flags);
+
+    _groups.set(_this, groups || _groups.get(re));
+
+    return _this;
+  }
+
+  inherits(BabelRegExp, _RegExp);
+
+  BabelRegExp.prototype.exec = function (str) {
+    var result = _super.exec.call(this, str);
+
+    if (result) result.groups = buildGroups(result, this);
+    return result;
+  };
+
+  BabelRegExp.prototype[_Symbol$replace] = function (str, substitution) {
+    if (typeof substitution === "string") {
+      var groups = _groups.get(this);
+
+      return _super[_Symbol$replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
+        return "$" + groups[name];
+      }));
+    } else if (typeof substitution === "function") {
+      var _this = this;
+
+      return _super[_Symbol$replace].call(this, str, function () {
+        var args = [];
+        args.push.apply(args, arguments);
+
+        if (_typeof(args[args.length - 1]) !== "object") {
+          args.push(buildGroups(args, _this));
+        }
+
+        return substitution.apply(this, args);
+      });
+    } else {
+      return _super[_Symbol$replace].call(this, str, substitution);
+    }
+  };
+
+  function buildGroups(result, re) {
+    var g = _groups.get(re);
+
+    return _Object$keys(g).reduce(function (groups, name) {
+      groups[name] = result[g[name]];
+      return groups;
+    }, _Object$create(null));
+  }
+
+  return _wrapRegExp.apply(this, arguments);
+}
+
+module.exports = _wrapRegExp;
\ No newline at end of file