first commit

node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js

+export default function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js

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

node_modules/@babel/runtime/helpers/esm/slicedToArray.js

+import arrayWithHoles from "@babel/runtime/helpers/esm/arrayWithHoles";
+import iterableToArrayLimit from "@babel/runtime/helpers/esm/iterableToArrayLimit";
+import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
+import nonIterableRest from "@babel/runtime/helpers/esm/nonIterableRest";
+export default function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/slicedToArrayLoose.js

+import arrayWithHoles from "@babel/runtime/helpers/esm/arrayWithHoles";
+import iterableToArrayLimitLoose from "@babel/runtime/helpers/esm/iterableToArrayLimitLoose";
+import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
+import nonIterableRest from "@babel/runtime/helpers/esm/nonIterableRest";
+export default function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/superPropBase.js

+import getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+export default function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js

+export default function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js

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

node_modules/@babel/runtime/helpers/esm/tdz.js

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

node_modules/@babel/runtime/helpers/esm/temporalRef.js

+import undef from "@babel/runtime/helpers/esm/temporalUndefined";
+import err from "@babel/runtime/helpers/esm/tdz";
+export default function _temporalRef(val, name) {
+  return val === undef ? err(name) : val;
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/temporalUndefined.js

+export default function _temporalUndefined() {}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/toArray.js

+import arrayWithHoles from "@babel/runtime/helpers/esm/arrayWithHoles";
+import iterableToArray from "@babel/runtime/helpers/esm/iterableToArray";
+import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
+import nonIterableRest from "@babel/runtime/helpers/esm/nonIterableRest";
+export default function _toArray(arr) {
+  return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/toConsumableArray.js

+import arrayWithoutHoles from "@babel/runtime/helpers/esm/arrayWithoutHoles";
+import iterableToArray from "@babel/runtime/helpers/esm/iterableToArray";
+import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
+import nonIterableSpread from "@babel/runtime/helpers/esm/nonIterableSpread";
+export default function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/toPrimitive.js

+import _typeof from "@babel/runtime/helpers/esm/typeof";
+export default 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);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/toPropertyKey.js

+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import toPrimitive from "@babel/runtime/helpers/esm/toPrimitive";
+export default function _toPropertyKey(arg) {
+  var key = toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/typeof.js

+export default function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js

+import arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
+export default function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js

+import AsyncGenerator from "@babel/runtime/helpers/esm/AsyncGenerator";
+export default function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js

+import getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import setPrototypeOf from "@babel/runtime/helpers/esm/setPrototypeOf";
+import isNativeFunction from "@babel/runtime/helpers/esm/isNativeFunction";
+import construct from "@babel/runtime/helpers/esm/construct";
+export default function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _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);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/esm/wrapRegExp.js

+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
+import getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import inherits from "@babel/runtime/helpers/esm/inherits";
+export default function _wrapRegExp(re, groups) {
+  _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);
+}
\ No newline at end of file

node_modules/@babel/runtime/helpers/extends.js

+function _extends() {
+  module.exports = _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+module.exports = _extends;
\ No newline at end of file