text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  function _template() {
    const data = _interopRequireDefault(require("@babel/template"));
  
    _template = function () {
      return data;
    };
  
    return data;
  }
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  const helpers = {};
  var _default = helpers;
  exports.default = _default;
  
  helpers.typeof = () => _template().default.program.ast`
    export default function _typeof(obj) {
      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function (obj) { return typeof obj; };
      } else {
        _typeof = function (obj) {
          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype
            ? "symbol"
            : typeof obj;
        };
      }
  
      return _typeof(obj);
    }
  `;
  
  helpers.jsx = () => _template().default.program.ast`
    var REACT_ELEMENT_TYPE;
  
    export default function _createRawReactElement(type, props, key, children) {
      if (!REACT_ELEMENT_TYPE) {
        REACT_ELEMENT_TYPE = (
          typeof Symbol === "function" && Symbol.for && Symbol.for("react.element")
        ) || 0xeac7;
      }
  
      var defaultProps = type && type.defaultProps;
      var childrenLength = arguments.length - 3;
  
      if (!props && childrenLength !== 0) {
        // If we're going to assign props.children, we create a new object now
        // to avoid mutating defaultProps.
        props = {
          children: void 0,
        };
      }
      if (props && defaultProps) {
        for (var propName in defaultProps) {
          if (props[propName] === void 0) {
            props[propName] = defaultProps[propName];
          }
        }
      } else if (!props) {
        props = defaultProps || {};
      }
  
      if (childrenLength === 1) {
        props.children = children;
      } else if (childrenLength > 1) {
        var childArray = new Array(childrenLength);
        for (var i = 0; i < childrenLength; i++) {
          childArray[i] = arguments[i + 3];
        }
        props.children = childArray;
      }
  
      return {
        $$typeof: REACT_ELEMENT_TYPE,
        type: type,
        key: key === undefined ? null : '' + key,
        ref: null,
        props: props,
        _owner: null,
      };
    }
  `;
  
  helpers.asyncIterator = () => _template().default.program.ast`
    export default function _asyncIterator(iterable) {
      var method
      if (typeof Symbol === "function") {
        if (Symbol.asyncIterator) {
          method = iterable[Symbol.asyncIterator]
          if (method != null) return method.call(iterable);
        }
        if (Symbol.iterator) {
          method = iterable[Symbol.iterator]
          if (method != null) return method.call(iterable);
        }
      }
      throw new TypeError("Object is not async iterable");
    }
  `;
  
  helpers.AwaitValue = () => _template().default.program.ast`
    export default function _AwaitValue(value) {
      this.wrapped = value;
    }
  `;
  
  helpers.AsyncGenerator = () => _template().default.program.ast`
    import AwaitValue from "AwaitValue";
  
    export default function AsyncGenerator(gen) {
      var front, back;
  
      function send(key, arg) {
        return new Promise(function (resolve, reject) {
          var request = {
            key: key,
            arg: arg,
            resolve: resolve,
            reject: reject,
            next: null,
          };
  
          if (back) {
            back = back.next = request;
          } else {
            front = back = request;
            resume(key, arg);
          }
        });
      }
  
      function resume(key, arg) {
        try {
          var result = gen[key](arg)
          var value = result.value;
          var wrappedAwait = value instanceof AwaitValue;
  
          Promise.resolve(wrappedAwait ? value.wrapped : value).then(
            function (arg) {
              if (wrappedAwait) {
                resume("next", arg);
                return
              }
  
              settle(result.done ? "return" : "normal", arg);
            },
            function (err) { resume("throw", err); });
        } catch (err) {
          settle("throw", err);
        }
      }
  
      function settle(type, value) {
        switch (type) {
          case "return":
            front.resolve({ value: value, done: true });
            break;
          case "throw":
            front.reject(value);
            break;
          default:
            front.resolve({ value: value, done: false });
            break;
        }
  
        front = front.next;
        if (front) {
          resume(front.key, front.arg);
        } else {
          back = null;
        }
      }
  
      this._invoke = send;
  
      // Hide "return" method if generator return is not supported
      if (typeof gen.return !== "function") {
        this.return = undefined;
      }
    }
  
    if (typeof Symbol === "function" && Symbol.asyncIterator) {
      AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; };
    }
  
    AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
    AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };
    AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
  `;
  
  helpers.wrapAsyncGenerator = () => _template().default.program.ast`
    import AsyncGenerator from "AsyncGenerator";
  
    export default function _wrapAsyncGenerator(fn) {
      return function () {
        return new AsyncGenerator(fn.apply(this, arguments));
      };
    }
  `;
  
  helpers.awaitAsyncGenerator = () => _template().default.program.ast`
    import AwaitValue from "AwaitValue";
  
    export default function _awaitAsyncGenerator(value) {
      return new AwaitValue(value);
    }
  `;
  
  helpers.asyncGeneratorDelegate = () => _template().default.program.ast`
    export default function _asyncGeneratorDelegate(inner, awaitWrap) {
      var iter = {}, waiting = false;
  
      function pump(key, value) {
        waiting = true;
        value = new Promise(function (resolve) { resolve(inner[key](value)); });
        return { done: false, value: awaitWrap(value) };
      };
  
      if (typeof Symbol === "function" && Symbol.iterator) {
        iter[Symbol.iterator] = function () { return this; };
      }
  
      iter.next = function (value) {
        if (waiting) {
          waiting = false;
          return value;
        }
        return pump("next", value);
      };
  
      if (typeof inner.throw === "function") {
        iter.throw = function (value) {
          if (waiting) {
            waiting = false;
            throw value;
          }
          return pump("throw", value);
        };
      }
  
      if (typeof inner.return === "function") {
        iter.return = function (value) {
          return pump("return", value);
        };
      }
  
      return iter;
    }
  `;
  
  helpers.asyncToGenerator = () => _template().default.program.ast`
    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error) {
        reject(error);
        return;
      }
  
      if (info.done) {
        resolve(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
  
    export default function _asyncToGenerator(fn) {
      return function () {
        var self = this, args = arguments;
        return new Promise(function (resolve, reject) {
          var gen = fn.apply(self, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
          }
  
          _next(undefined);
        });
      };
    }
  `;
  
  helpers.classCallCheck = () => _template().default.program.ast`
    export default function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
  `;
  
  helpers.createClass = () => _template().default.program.ast`
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i ++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    export default function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      return Constructor;
    }
  `;
  
  helpers.defineEnumerableProperties = () => _template().default.program.ast`
    export default function _defineEnumerableProperties(obj, descs) {
      for (var key in descs) {
        var desc = descs[key];
        desc.configurable = desc.enumerable = true;
        if ("value" in desc) desc.writable = true;
        Object.defineProperty(obj, key, desc);
      }
  
      // Symbols are not enumerated over by for-in loops. If native
      // Symbols are available, fetch all of the descs object's own
      // symbol properties and define them on our target object too.
      if (Object.getOwnPropertySymbols) {
        var objectSymbols = Object.getOwnPropertySymbols(descs);
        for (var i = 0; i < objectSymbols.length; i++) {
          var sym = objectSymbols[i];
          var desc = descs[sym];
          desc.configurable = desc.enumerable = true;
          if ("value" in desc) desc.writable = true;
          Object.defineProperty(obj, sym, desc);
        }
      }
      return obj;
    }
  `;
  
  helpers.defaults = () => _template().default.program.ast`
    export default function _defaults(obj, defaults) {
      var keys = Object.getOwnPropertyNames(defaults);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        var value = Object.getOwnPropertyDescriptor(defaults, key);
        if (value && value.configurable && obj[key] === undefined) {
          Object.defineProperty(obj, key, value);
        }
      }
      return obj;
    }
  `;
  
  helpers.defineProperty = () => _template().default.program.ast`
    export default function _defineProperty(obj, key, value) {
      // Shortcircuit the slow defineProperty path when possible.
      // We are trying to avoid issues where setters defined on the
      // prototype cause side effects under the fast path of simple
      // assignment. By checking for existence of the property with
      // the in operator, we can optimize most of this overhead away.
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value: value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }
  `;
  
  helpers.extends = () => _template().default.program.ast`
    export default function _extends() {
      _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);
    }
  `;
  
  helpers.objectSpread = () => _template().default.program.ast`
    import defineProperty from "defineProperty";
  
    export default function _objectSpread(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = (arguments[i] != null) ? arguments[i] : {};
        var ownKeys = Object.keys(source);
        if (typeof Object.getOwnPropertySymbols === 'function') {
          ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
          }));
        }
        ownKeys.forEach(function(key) {
          defineProperty(target, key, source[key]);
        });
      }
      return target;
    }
  `;
  
  helpers.inherits = () => _template().default.program.ast`
    import setPrototypeOf from "setPrototypeOf";
  
    export default function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          writable: true,
          configurable: true
        }
      });
      if (superClass) setPrototypeOf(subClass, superClass);
    }
  `;
  
  helpers.inheritsLoose = () => _template().default.program.ast`
    export default function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      subClass.__proto__ = superClass;
    }
  `;
  
  helpers.getPrototypeOf = () => _template().default.program.ast`
    export default function _getPrototypeOf(o) {
      _getPrototypeOf = Object.setPrototypeOf
        ? Object.getPrototypeOf
        : function _getPrototypeOf(o) {
            return o.__proto__ || Object.getPrototypeOf(o);
          };
      return _getPrototypeOf(o);
    }
  `;
  
  helpers.setPrototypeOf = () => _template().default.program.ast`
    export default function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
      };
      return _setPrototypeOf(o, p);
    }
  `;
  
  helpers.construct = () => _template().default.program.ast`
    import setPrototypeOf from "setPrototypeOf";
  
    function isNativeReflectConstruct() {
      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  
      // core-js@3
      if (Reflect.construct.sham) return false;
  
      // Proxy can't be polyfilled. Every browser implemented
      // proxies before or at the same time as Reflect.construct,
      // so if they support Proxy they also support Reflect.construct.
      if (typeof Proxy === "function") return true;
  
      // Since Reflect.construct can't be properly polyfilled, some
      // implementations (e.g. core-js@2) don't set the correct internal slots.
      // Those polyfills don't allow us to subclass built-ins, so we need to
      // use our fallback implementation.
      try {
        // If the internal slots aren't set, this throws an error similar to
        //   TypeError: this is not a Date object.
        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
        return true;
      } catch (e) {
        return false;
      }
    }
  
    export default function _construct(Parent, args, Class) {
      if (isNativeReflectConstruct()) {
        _construct = Reflect.construct;
      } else {
        _construct = function _construct(Parent, args, Class) {
          var a = [null];
          a.push.apply(a, args);
          var Constructor = Function.bind.apply(Parent, a);
          var instance = new Constructor();
          if (Class) setPrototypeOf(instance, Class.prototype);
          return instance;
        };
      }
      // Avoid issues with Class being present but undefined when it wasn't
      // present in the original call.
      return _construct.apply(null, arguments);
    }
  `;
  
  helpers.wrapNativeSuper = () => _template().default.program.ast`
    import getPrototypeOf from "getPrototypeOf";
    import setPrototypeOf from "setPrototypeOf";
    import construct from "construct";
  
    export default function _wrapNativeSuper(Class) {
      var _cache = typeof Map === "function" ? new Map() : undefined;
  
      _wrapNativeSuper = function _wrapNativeSuper(Class) {
        if (Class === null) return null;
        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)
    }
  `;
  
  helpers.instanceof = () => _template().default.program.ast`
    export default function _instanceof(left, right) {
      if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return right[Symbol.hasInstance](left);
      } else {
        return left instanceof right;
      }
    }
  `;
  
  helpers.interopRequireDefault = () => _template().default.program.ast`
    export default function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
  `;
  
  helpers.interopRequireWildcard = () => _template().default.program.ast`
    export default 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)) {
              var desc = Object.defineProperty && Object.getOwnPropertyDescriptor
                ? Object.getOwnPropertyDescriptor(obj, key)
                : {};
              if (desc.get || desc.set) {
                Object.defineProperty(newObj, key, desc);
              } else {
                newObj[key] = obj[key];
              }
            }
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }
  `;
  
  helpers.newArrowCheck = () => _template().default.program.ast`
    export default function _newArrowCheck(innerThis, boundThis) {
      if (innerThis !== boundThis) {
        throw new TypeError("Cannot instantiate an arrow function");
      }
    }
  `;
  
  helpers.objectDestructuringEmpty = () => _template().default.program.ast`
    export default function _objectDestructuringEmpty(obj) {
      if (obj == null) throw new TypeError("Cannot destructure undefined");
    }
  `;
  
  helpers.objectWithoutPropertiesLoose = () => _template().default.program.ast`
    export default function _objectWithoutPropertiesLoose(source, excluded) {
      if (source == null) return {};
  
      var target = {};
      var sourceKeys = Object.keys(source);
      var key, i;
  
      for (i = 0; i < sourceKeys.length; i++) {
        key = sourceKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        target[key] = source[key];
      }
  
      return target;
    }
  `;
  
  helpers.objectWithoutProperties = () => _template().default.program.ast`
    import objectWithoutPropertiesLoose from "objectWithoutPropertiesLoose";
  
    export default function _objectWithoutProperties(source, excluded) {
      if (source == null) return {};
  
      var target = objectWithoutPropertiesLoose(source, excluded);
      var key, i;
  
      if (Object.getOwnPropertySymbols) {
        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
        for (i = 0; i < sourceSymbolKeys.length; i++) {
          key = sourceSymbolKeys[i];
          if (excluded.indexOf(key) >= 0) continue;
          if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
          target[key] = source[key];
        }
      }
  
      return target;
    }
  `;
  
  helpers.assertThisInitialized = () => _template().default.program.ast`
    export default function _assertThisInitialized(self) {
      if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return self;
    }
  `;
  
  helpers.possibleConstructorReturn = () => _template().default.program.ast`
    import assertThisInitialized from "assertThisInitialized";
  
    export default function _possibleConstructorReturn(self, call) {
      if (call && (typeof call === "object" || typeof call === "function")) {
        return call;
      }
      return assertThisInitialized(self);
    }
  `;
  
  helpers.superPropBase = () => _template().default.program.ast`
    import getPrototypeOf from "getPrototypeOf";
  
    export default function _superPropBase(object, property) {
      // Yes, this throws if object is null to being with, that's on purpose.
      while (!Object.prototype.hasOwnProperty.call(object, property)) {
        object = getPrototypeOf(object);
        if (object === null) break;
      }
      return object;
    }
  `;
  
  helpers.get = () => _template().default.program.ast`
    import getPrototypeOf from "getPrototypeOf";
    import superPropBase from "superPropBase";
  
    export default function _get(target, property, receiver) {
      if (typeof Reflect !== "undefined" && Reflect.get) {
        _get = Reflect.get;
      } else {
        _get = function _get(target, property, receiver) {
          var base = superPropBase(target, property);
  
          if (!base) return;
  
          var desc = Object.getOwnPropertyDescriptor(base, property);
          if (desc.get) {
            return desc.get.call(receiver);
          }
  
          return desc.value;
        };
      }
      return _get(target, property, receiver || target);
    }
  `;
  
  helpers.set = () => _template().default.program.ast`
    import getPrototypeOf from "getPrototypeOf";
    import superPropBase from "superPropBase";
    import defineProperty from "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) {
              // Both getter and non-writable fall into this.
              return false;
            }
          }
  
          // Without a super that defines the property, spec boils down to
          // "define on receiver" for some reason.
          desc = Object.getOwnPropertyDescriptor(receiver, property);
          if (desc) {
            if (!desc.writable) {
              // Setter, getter, and non-writable fall into this.
              return false;
            }
  
            desc.value = value;
            Object.defineProperty(receiver, property, desc);
          } else {
            // Avoid setters that may be defined on Sub's prototype, but not on
            // the instance.
            defineProperty(receiver, property, value);
          }
  
          return true;
        };
      }
  
      return set(target, property, value, receiver);
    }
  
    export default 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;
    }
  `;
  
  helpers.taggedTemplateLiteral = () => _template().default.program.ast`
    export default function _taggedTemplateLiteral(strings, raw) {
      if (!raw) { raw = strings.slice(0); }
      return Object.freeze(Object.defineProperties(strings, {
          raw: { value: Object.freeze(raw) }
      }));
    }
  `;
  
  helpers.taggedTemplateLiteralLoose = () => _template().default.program.ast`
    export default function _taggedTemplateLiteralLoose(strings, raw) {
      if (!raw) { raw = strings.slice(0); }
      strings.raw = raw;
      return strings;
    }
  `;
  
  helpers.temporalRef = () => _template().default.program.ast`
    import undef from "temporalUndefined";
  
    export default function _temporalRef(val, name) {
      if (val === undef) {
        throw new ReferenceError(name + " is not defined - temporal dead zone");
      } else {
        return val;
      }
    }
  `;
  
  helpers.readOnlyError = () => _template().default.program.ast`
    export default function _readOnlyError(name) {
      throw new Error("\\"" + name + "\\" is read-only");
    }
  `;
  
  helpers.classNameTDZError = () => _template().default.program.ast`
    export default function _classNameTDZError(name) {
      throw new Error("Class \\"" + name + "\\" cannot be referenced in computed property keys.");
    }
  `;
  
  helpers.temporalUndefined = () => _template().default.program.ast`
    export default {};
  `;
  
  helpers.slicedToArray = () => _template().default.program.ast`
    import arrayWithHoles from "arrayWithHoles";
    import iterableToArrayLimit from "iterableToArrayLimit";
    import nonIterableRest from "nonIterableRest";
  
    export default function _slicedToArray(arr, i) {
      return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
    }
  `;
  
  helpers.slicedToArrayLoose = () => _template().default.program.ast`
    import arrayWithHoles from "arrayWithHoles";
    import iterableToArrayLimitLoose from "iterableToArrayLimitLoose";
    import nonIterableRest from "nonIterableRest";
  
    export default function _slicedToArrayLoose(arr, i) {
      return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
    }
  `;
  
  helpers.toArray = () => _template().default.program.ast`
    import arrayWithHoles from "arrayWithHoles";
    import iterableToArray from "iterableToArray";
    import nonIterableRest from "nonIterableRest";
  
    export default function _toArray(arr) {
      return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
    }
  `;
  
  helpers.toConsumableArray = () => _template().default.program.ast`
    import arrayWithoutHoles from "arrayWithoutHoles";
    import iterableToArray from "iterableToArray";
    import nonIterableSpread from "nonIterableSpread";
  
    export default function _toConsumableArray(arr) {
      return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
    }
  `;
  
  helpers.arrayWithoutHoles = () => _template().default.program.ast`
    export default function _arrayWithoutHoles(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
        return arr2;
      }
    }
  `;
  
  helpers.arrayWithHoles = () => _template().default.program.ast`
    export default function _arrayWithHoles(arr) {
      if (Array.isArray(arr)) return arr;
    }
  `;
  
  helpers.iterableToArray = () => _template().default.program.ast`
    export default function _iterableToArray(iter) {
      if (
        Symbol.iterator in Object(iter) ||
        Object.prototype.toString.call(iter) === "[object Arguments]"
      ) return Array.from(iter);
    }
  `;
  
  helpers.iterableToArrayLimit = () => _template().default.program.ast`
    export default function _iterableToArrayLimit(arr, i) {
      // this is an expanded form of \`for...of\` that properly supports abrupt completions of
      // iterators etc. variable names have been minimised to reduce the size of this massive
      // helper. sometimes spec compliancy is annoying :(
      //
      // _n = _iteratorNormalCompletion
      // _d = _didIteratorError
      // _e = _iteratorError
      // _i = _iterator
      // _s = _step
  
      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"] != null) _i["return"]();
        } finally {
          if (_d) throw _e;
        }
      }
      return _arr;
    }
  `;
  
  helpers.iterableToArrayLimitLoose = () => _template().default.program.ast`
    export default function _iterableToArrayLimitLoose(arr, i) {
      var _arr = [];
      for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
        _arr.push(_step.value);
        if (i && _arr.length === i) break;
      }
      return _arr;
    }
  `;
  
  helpers.nonIterableSpread = () => _template().default.program.ast`
    export default function _nonIterableSpread() {
      throw new TypeError("Invalid attempt to spread non-iterable instance");
    }
  `;
  
  helpers.nonIterableRest = () => _template().default.program.ast`
    export default function _nonIterableRest() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  `;
  
  helpers.skipFirstGeneratorNext = () => _template().default.program.ast`
    export default function _skipFirstGeneratorNext(fn) {
      return function () {
        var it = fn.apply(this, arguments);
        it.next();
        return it;
      }
    }
  `;
  
  helpers.toPropertyKey = () => _template().default.program.ast`
    export default function _toPropertyKey(key) {
      if (typeof key === "symbol") {
        return key;
      } else {
        return String(key);
      }
    }
  `;
  
  helpers.initializerWarningHelper = () => _template().default.program.ast`
      export default function _initializerWarningHelper(descriptor, context){
          throw new Error(
            'Decorating class property failed. Please ensure that ' +
            'proposal-class-properties is enabled and set to use loose mode. ' +
            'To use proposal-class-properties in spec mode with decorators, wait for ' +
            'the next major version of decorators in stage 2.'
          );
      }
  `;
  
  helpers.initializerDefineProperty = () => _template().default.program.ast`
      export default function _initializerDefineProperty(target, property, descriptor, context){
          if (!descriptor) return;
  
          Object.defineProperty(target, property, {
              enumerable: descriptor.enumerable,
              configurable: descriptor.configurable,
              writable: descriptor.writable,
              value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,
          });
      }
  `;
  
  helpers.applyDecoratedDescriptor = () => _template().default.program.ast`
      export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){
          var desc = {};
          Object['ke' + 'ys'](descriptor).forEach(function(key){
              desc[key] = descriptor[key];
          });
          desc.enumerable = !!desc.enumerable;
          desc.configurable = !!desc.configurable;
          if ('value' in desc || desc.initializer){
              desc.writable = true;
          }
  
          desc = decorators.slice().reverse().reduce(function(desc, decorator){
              return decorator(target, property, desc) || desc;
          }, desc);
  
          if (context && desc.initializer !== void 0){
              desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
              desc.initializer = undefined;
          }
  
          if (desc.initializer === void 0){
              // This is a hack to avoid this being processed by 'transform-runtime'.
              // See issue #9.
              Object['define' + 'Property'](target, property, desc);
              desc = null;
          }
  
          return desc;
      }
  `;
  
  helpers.classPrivateFieldLooseKey = () => _template().default.program.ast`
    var id = 0;
    export default function _classPrivateFieldKey(name) {
      return "__private_" + (id++) + "_" + name;
    }
  `;
  
  helpers.classPrivateFieldLooseBase = () => _template().default.program.ast`
    export default function _classPrivateFieldBase(receiver, privateKey) {
      if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
        throw new TypeError("attempted to use private field on non-instance");
      }
      return receiver;
    }
  `;
  
  helpers.classPrivateFieldGet = () => _template().default.program.ast`
    export default function _classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
    }
  `;
  
  helpers.classPrivateFieldSet = () => _template().default.program.ast`
    export default function _classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
    }
  `;