@burst/cli/lib/index.js

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var commander = _interopDefault(require('commander'));
var chalk = _interopDefault(require('chalk'));
var React = require('react');
var React__default = _interopDefault(React);
var ink = require('ink');
var semver = require('semver');
var semver__default = _interopDefault(semver);
var execa = _interopDefault(require('execa'));
var axios = _interopDefault(require('axios'));
var path$1 = require('path');
var path$1__default = _interopDefault(path$1);
var lodash = require('lodash');
var codeFrame = require('@babel/code-frame');
var resolve = _interopDefault(require('resolve-from'));
var Worker = _interopDefault(require('jest-worker'));
var PQueue = _interopDefault(require('p-queue'));
var fs = require('fs');
var fs__default = _interopDefault(fs);
require('core-js/modules/es.array.iterator');
var yaml = require('js-yaml');
var yaml__default = _interopDefault(yaml);
var ora = _interopDefault(require('ora'));
var slugify = _interopDefault(require('slugify'));
var inquirer = require('inquirer');
var util = require('util');
var prettierConfig$1 = _interopDefault(require('@burst/prettier-config'));
var stylelint = _interopDefault(require('stylelint'));
var client = require('@slack/client');
var xml2js = _interopDefault(require('xml2js'));
var rimrafWithCallback = _interopDefault(require('rimraf'));
var stagedFilesWithCallback = _interopDefault(require('staged-git-files'));

var fails = function (exec) {
  try {
    return !!exec();
  } catch (error) {
    return true;
  }
};

// Thank's IE8 for his funny defineProperty
var descriptors = !fails(function () {
  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
});

var hasOwnProperty = {}.hasOwnProperty;

var has = function (it, key) {
  return hasOwnProperty.call(it, key);
};

var isObject = function (it) {
  return typeof it === 'object' ? it !== null : typeof it === 'function';
};

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global$1 = typeof window == 'object' && window && window.Math == Math ? window
  : typeof self == 'object' && self && self.Math == Math ? self
  // eslint-disable-next-line no-new-func
  : Function('return this')();

var document$1 = global$1.document;
// typeof document.createElement is 'object' in old IE
var exist = isObject(document$1) && isObject(document$1.createElement);

var documentCreateElement = function (it) {
  return exist ? document$1.createElement(it) : {};
};

// Thank's IE8 for his funny defineProperty
var ie8DomDefine = !descriptors && !fails(function () {
  return Object.defineProperty(documentCreateElement('div'), 'a', {
    get: function () { return 7; }
  }).a != 7;
});

var anObject = function (it) {
  if (!isObject(it)) {
    throw TypeError(String(it) + ' is not an object');
  } return it;
};

// 7.1.1 ToPrimitive(input [, PreferredType])

// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
var toPrimitive = 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");
};

var nativeDefineProperty = Object.defineProperty;

var f = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPrimitive(P, true);
  anObject(Attributes);
  if (ie8DomDefine) try {
    return nativeDefineProperty(O, P, Attributes);
  } catch (error) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};

var objectDefineProperty = {
	f: f
};

var toString = {}.toString;

var classofRaw = function (it) {
  return toString.call(it).slice(8, -1);
};

// fallback for non-array-like ES3 and non-enumerable old V8 strings


var split = ''.split;

var indexedObject = fails(function () {
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
  // eslint-disable-next-line no-prototype-builtins
  return !Object('z').propertyIsEnumerable(0);
}) ? function (it) {
  return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);
} : Object;

// `RequireObjectCoercible` abstract operation
// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
var requireObjectCoercible = function (it) {
  if (it == undefined) throw TypeError("Can't call method on " + it);
  return it;
};

// toObject with fallback for non-array-like ES3 strings



var toIndexedObject = function (it) {
  return indexedObject(requireObjectCoercible(it));
};

var ceil = Math.ceil;
var floor = Math.floor;

// `ToInteger` abstract operation
// https://tc39.github.io/ecma262/#sec-tointeger
var toInteger = function (argument) {
  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
};

var min = Math.min;

// `ToLength` abstract operation
// https://tc39.github.io/ecma262/#sec-tolength
var toLength = function (argument) {
  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
};

var max = Math.max;
var min$1 = Math.min;

// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(length, length).
var toAbsoluteIndex = function (index, length) {
  var integer = toInteger(index);
  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
};

// `Array.prototype.{ indexOf, includes }` methods implementation
// false -> Array#indexOf
// https://tc39.github.io/ecma262/#sec-array.prototype.indexof
// true  -> Array#includes
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
var arrayIncludes = function (IS_INCLUDES) {
  return function ($this, el, fromIndex) {
    var O = toIndexedObject($this);
    var length = toLength(O.length);
    var index = toAbsoluteIndex(fromIndex, length);
    var value;
    // Array#includes uses SameValueZero equality algorithm
    // eslint-disable-next-line no-self-compare
    if (IS_INCLUDES && el != el) while (length > index) {
      value = O[index++];
      // eslint-disable-next-line no-self-compare
      if (value != value) return true;
    // Array#indexOf 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;
  };
};

var hiddenKeys = {};

var arrayIndexOf = arrayIncludes(false);


var objectKeysInternal = function (object, names) {
  var O = toIndexedObject(object);
  var i = 0;
  var result = [];
  var key;
  for (key in O) !has(hiddenKeys, key) && 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;
};

// IE8- don't enum bug keys
var enumBugKeys = [
  'constructor',
  'hasOwnProperty',
  'isPrototypeOf',
  'propertyIsEnumerable',
  'toLocaleString',
  'toString',
  'valueOf'
];

// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)

var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');

var f$1 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return objectKeysInternal(O, hiddenKeys$1);
};

var objectGetOwnPropertyNames = {
	f: f$1
};

var f$2 = Object.getOwnPropertySymbols;

var objectGetOwnPropertySymbols = {
	f: f$2
};

var Reflect = global$1.Reflect;

// all object keys, includes non-enumerable and symbols
var ownKeys = Reflect && Reflect.ownKeys || function ownKeys(it) {
  var keys = objectGetOwnPropertyNames.f(anObject(it));
  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
};

var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

// Nashorn ~ JDK8 bug
var NASHORN_BUG = nativeGetOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);

var f$3 = NASHORN_BUG ? function propertyIsEnumerable(V) {
  var descriptor = nativeGetOwnPropertyDescriptor(this, V);
  return !!descriptor && descriptor.enumerable;
} : nativePropertyIsEnumerable;

var objectPropertyIsEnumerable = {
	f: f$3
};

var createPropertyDescriptor = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};

var nativeGetOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;

var f$4 = descriptors ? nativeGetOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
  O = toIndexedObject(O);
  P = toPrimitive(P, true);
  if (ie8DomDefine) try {
    return nativeGetOwnPropertyDescriptor$1(O, P);
  } catch (error) { /* empty */ }
  if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);
};

var objectGetOwnPropertyDescriptor = {
	f: f$4
};

var copyConstructorProperties = function (target, source) {
  var keys = ownKeys(source);
  var defineProperty = objectDefineProperty.f;
  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
  }
};

var hide = descriptors ? function (object, key, value) {
  return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var setGlobal = function (key, value) {
  try {
    hide(global$1, key, value);
  } catch (error) {
    global$1[key] = value;
  } return value;
};

var isPure = false;

var shared = createCommonjsModule(function (module) {
var SHARED = '__core-js_shared__';
var store = global$1[SHARED] || setGlobal(SHARED, {});

(module.exports = function (key, value) {
  return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
  version: '3.0.1',
  mode: 'global',
  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
});
});

var functionToString = shared('native-function-to-string', Function.toString);

var WeakMap = global$1.WeakMap;

var nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(functionToString.call(WeakMap));

var id = 0;
var postfix = Math.random();

var uid = function (key) {
  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + postfix).toString(36));
};

var shared$1 = shared('keys');


var sharedKey = function (key) {
  return shared$1[key] || (shared$1[key] = uid(key));
};

var WeakMap$1 = global$1.WeakMap;
var set, get, has$1;

var enforce = function (it) {
  return has$1(it) ? get(it) : set(it, {});
};

var getterFor = function (TYPE) {
  return function (it) {
    var state;
    if (!isObject(it) || (state = get(it)).type !== TYPE) {
      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
    } return state;
  };
};

if (nativeWeakMap) {
  var store = new WeakMap$1();
  var wmget = store.get;
  var wmhas = store.has;
  var wmset = store.set;
  set = function (it, metadata) {
    wmset.call(store, it, metadata);
    return metadata;
  };
  get = function (it) {
    return wmget.call(store, it) || {};
  };
  has$1 = function (it) {
    return wmhas.call(store, it);
  };
} else {
  var STATE = sharedKey('state');
  hiddenKeys[STATE] = true;
  set = function (it, metadata) {
    hide(it, STATE, metadata);
    return metadata;
  };
  get = function (it) {
    return has(it, STATE) ? it[STATE] : {};
  };
  has$1 = function (it) {
    return has(it, STATE);
  };
}

var internalState = {
  set: set,
  get: get,
  has: has$1,
  enforce: enforce,
  getterFor: getterFor
};

var redefine = createCommonjsModule(function (module) {
var getInternalState = internalState.get;
var enforceInternalState = internalState.enforce;
var TEMPLATE = String(functionToString).split('toString');

shared('inspectSource', function (it) {
  return functionToString.call(it);
});

(module.exports = function (O, key, value, options) {
  var unsafe = options ? !!options.unsafe : false;
  var simple = options ? !!options.enumerable : false;
  var noTargetGet = options ? !!options.noTargetGet : false;
  if (typeof value == 'function') {
    if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key);
    enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
  }
  if (O === global$1) {
    if (simple) O[key] = value;
    else setGlobal(key, value);
    return;
  } else if (!unsafe) {
    delete O[key];
  } else if (!noTargetGet && O[key]) {
    simple = true;
  }
  if (simple) O[key] = value;
  else hide(O, key, value);
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, 'toString', function toString() {
  return typeof this == 'function' && getInternalState(this).source || functionToString.call(this);
});
});

var replacement = /#|\.prototype\./;

var isForced = function (feature, detection) {
  var value = data[normalize(feature)];
  return value == POLYFILL ? true
    : value == NATIVE ? false
    : typeof detection == 'function' ? fails(detection)
    : !!detection;
};

var normalize = isForced.normalize = function (string) {
  return String(string).replace(replacement, '.').toLowerCase();
};

var data = isForced.data = {};
var NATIVE = isForced.NATIVE = 'N';
var POLYFILL = isForced.POLYFILL = 'P';

var isForced_1 = isForced;

var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;






/*
  options.target      - name of the target object
  options.global      - target is the global object
  options.stat        - export as static methods of target
  options.proto       - export as prototype methods of target
  options.real        - real prototype method for the `pure` version
  options.forced      - export even if the native feature is available
  options.bind        - bind methods to the target, required for the `pure` version
  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
  options.sham        - add a flag to not completely full polyfills
  options.enumerable  - export as enumerable property
  options.noTargetGet - prevent calling a getter on target
*/
var _export = function (options, source) {
  var TARGET = options.target;
  var GLOBAL = options.global;
  var STATIC = options.stat;
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
  if (GLOBAL) {
    target = global$1;
  } else if (STATIC) {
    target = global$1[TARGET] || setGlobal(TARGET, {});
  } else {
    target = (global$1[TARGET] || {}).prototype;
  }
  if (target) for (key in source) {
    sourceProperty = source[key];
    if (options.noTargetGet) {
      descriptor = getOwnPropertyDescriptor(target, key);
      targetProperty = descriptor && descriptor.value;
    } else targetProperty = target[key];
    FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
    // contained in target
    if (!FORCED && targetProperty !== undefined) {
      if (typeof sourceProperty === typeof targetProperty) continue;
      copyConstructorProperties(sourceProperty, targetProperty);
    }
    // add a flag to not completely full polyfills
    if (options.sham || (targetProperty && targetProperty.sham)) {
      hide(sourceProperty, 'sham', true);
    }
    // extend global
    redefine(target, key, sourceProperty, options);
  }
};

var defineProperty = objectDefineProperty.f;

var NativeSymbol = global$1.Symbol;

if (descriptors && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||
  // Safari 12 bug
  NativeSymbol().description !== undefined
)) {
  var EmptyStringDescriptionStore = {};
  // wrap Symbol constructor for correct work with undefined description
  var SymbolWrapper = function Symbol() {
    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
    var result = this instanceof SymbolWrapper
      ? new NativeSymbol(description)
      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
      : description === undefined ? NativeSymbol() : NativeSymbol(description);
    if (description === '') EmptyStringDescriptionStore[result] = true;
    return result;
  };
  copyConstructorProperties(SymbolWrapper, NativeSymbol);
  var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
  symbolPrototype.constructor = SymbolWrapper;

  var symbolToString = symbolPrototype.toString;
  var native = String(NativeSymbol('test')) == 'Symbol(test)';
  var regexp = /^Symbol\((.*)\)[^)]+$/;
  defineProperty(symbolPrototype, 'description', {
    configurable: true,
    get: function description() {
      var symbol = isObject(this) ? this.valueOf() : this;
      var string = symbolToString.call(symbol);
      if (has(EmptyStringDescriptionStore, symbol)) return '';
      var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
      return desc === '' ? undefined : desc;
    }
  });

  _export({ global: true, forced: true }, { Symbol: SymbolWrapper });
}

// Chrome 38 Symbol has incorrect toString conversion
var nativeSymbol = !fails(function () {
  // eslint-disable-next-line no-undef
  return !String(Symbol());
});

var store$1 = shared('wks');

var Symbol$1 = global$1.Symbol;


var wellKnownSymbol = function (name) {
  return store$1[name] || (store$1[name] = nativeSymbol && Symbol$1[name]
    || (nativeSymbol ? Symbol$1 : uid)('Symbol.' + name));
};

// 19.1.2.14 / 15.2.3.14 Object.keys(O)



var objectKeys = Object.keys || function keys(O) {
  return objectKeysInternal(O, enumBugKeys);
};

var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
  anObject(O);
  var keys = objectKeys(Properties);
  var length = keys.length;
  var i = 0;
  var key;
  while (length > i) objectDefineProperty.f(O, key = keys[i++], Properties[key]);
  return O;
};

var document$2 = global$1.document;

var html = document$2 && document$2.documentElement;

// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])





var IE_PROTO = sharedKey('IE_PROTO');
var PROTOTYPE = 'prototype';
var Empty = function () { /* empty */ };

// Create object with fake `null` prototype: use iframe Object with cleared prototype
var createDict = function () {
  // Thrash, waste and sodomy: IE GC bug
  var iframe = documentCreateElement('iframe');
  var length = enumBugKeys.length;
  var lt = '<';
  var script = 'script';
  var gt = '>';
  var js = 'java' + script + ':';
  var iframeDocument;
  iframe.style.display = 'none';
  html.appendChild(iframe);
  iframe.src = String(js);
  iframeDocument = iframe.contentWindow.document;
  iframeDocument.open();
  iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt);
  iframeDocument.close();
  createDict = iframeDocument.F;
  while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]];
  return createDict();
};

var objectCreate = 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 : objectDefineProperties(result, Properties);
};

hiddenKeys[IE_PROTO] = true;

var UNSCOPABLES = wellKnownSymbol('unscopables');


var ArrayPrototype = Array.prototype;

// Array.prototype[@@unscopables]
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
if (ArrayPrototype[UNSCOPABLES] == undefined) {
  hide(ArrayPrototype, UNSCOPABLES, objectCreate(null));
}

// add a key to Array.prototype[@@unscopables]
var addToUnscopables = function (key) {
  ArrayPrototype[UNSCOPABLES][key] = true;
};

var iterators = {};

// `ToObject` abstract operation
// https://tc39.github.io/ecma262/#sec-toobject
var toObject = function (argument) {
  return Object(requireObjectCoercible(argument));
};

var correctPrototypeGetter = !fails(function () {
  function F() { /* empty */ }
  F.prototype.constructor = null;
  return Object.getPrototypeOf(new F()) !== F.prototype;
});

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)


var IE_PROTO$1 = sharedKey('IE_PROTO');

var ObjectPrototype = Object.prototype;

var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) {
  O = toObject(O);
  if (has(O, IE_PROTO$1)) return O[IE_PROTO$1];
  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
    return O.constructor.prototype;
  } return O instanceof Object ? ObjectPrototype : null;
};

var ITERATOR = wellKnownSymbol('iterator');
var BUGGY_SAFARI_ITERATORS = false;

var returnThis = function () { return this; };

// `%IteratorPrototype%` object
// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;

if ([].keys) {
  arrayIterator = [].keys();
  // Safari 8 has buggy iterators w/o `next`
  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
  else {
    PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator));
    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
  }
}

if (IteratorPrototype == undefined) IteratorPrototype = {};

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
if (!has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);

var iteratorsCore = {
  IteratorPrototype: IteratorPrototype,
  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
};

var defineProperty$1 = objectDefineProperty.f;

var TO_STRING_TAG = wellKnownSymbol('toStringTag');

var setToStringTag = function (it, TAG, STATIC) {
  if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
    defineProperty$1(it, TO_STRING_TAG, { configurable: true, value: TAG });
  }
};

var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;





var returnThis$1 = function () { return this; };

var createIteratorConstructor = function (IteratorConstructor, NAME, next) {
  var TO_STRING_TAG = NAME + ' Iterator';
  IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) });
  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
  iterators[TO_STRING_TAG] = returnThis$1;
  return IteratorConstructor;
};

var validateSetPrototypeOfArguments = function (O, proto) {
  anObject(O);
  if (!isObject(proto) && proto !== null) {
    throw TypeError("Can't set " + String(proto) + ' as a prototype');
  }
};

// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */


var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
  var correctSetter = false;
  var test = {};
  var setter;
  try {
    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
    setter.call(test, []);
    correctSetter = test instanceof Array;
  } catch (error) { /* empty */ }
  return function setPrototypeOf(O, proto) {
    validateSetPrototypeOfArguments(O, proto);
    if (correctSetter) setter.call(O, proto);
    else O.__proto__ = proto;
    return O;
  };
}() : undefined);

var ITERATOR$1 = wellKnownSymbol('iterator');


var IteratorPrototype$2 = iteratorsCore.IteratorPrototype;
var BUGGY_SAFARI_ITERATORS$1 = iteratorsCore.BUGGY_SAFARI_ITERATORS;
var KEYS = 'keys';
var VALUES = 'values';
var ENTRIES = 'entries';

var returnThis$2 = function () { return this; };

var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
  createIteratorConstructor(IteratorConstructor, NAME, next);

  var getIterationMethod = function (KIND) {
    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
    if (!BUGGY_SAFARI_ITERATORS$1 && KIND in IterablePrototype) return IterablePrototype[KIND];
    switch (KIND) {
      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
    } return function () { return new IteratorConstructor(this); };
  };

  var TO_STRING_TAG = NAME + ' Iterator';
  var INCORRECT_VALUES_NAME = false;
  var IterablePrototype = Iterable.prototype;
  var nativeIterator = IterablePrototype[ITERATOR$1]
    || IterablePrototype['@@iterator']
    || DEFAULT && IterablePrototype[DEFAULT];
  var defaultIterator = !BUGGY_SAFARI_ITERATORS$1 && nativeIterator || getIterationMethod(DEFAULT);
  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
  var CurrentIteratorPrototype, methods, KEY;

  // fix native
  if (anyNativeIterator) {
    CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable()));
    if (IteratorPrototype$2 !== Object.prototype && CurrentIteratorPrototype.next) {
      if (objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype$2) {
        if (objectSetPrototypeOf) {
          objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2);
        } else if (typeof CurrentIteratorPrototype[ITERATOR$1] != 'function') {
          hide(CurrentIteratorPrototype, ITERATOR$1, returnThis$2);
        }
      }
      // Set @@toStringTag to native iterators
      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
    }
  }

  // fix Array#{values, @@iterator}.name in V8 / FF
  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
    INCORRECT_VALUES_NAME = true;
    defaultIterator = function values() { return nativeIterator.call(this); };
  }

  // define iterator
  if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
    hide(IterablePrototype, ITERATOR$1, defaultIterator);
  }
  iterators[NAME] = defaultIterator;

  // export additional methods
  if (DEFAULT) {
    methods = {
      values: getIterationMethod(VALUES),
      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
      entries: getIterationMethod(ENTRIES)
    };
    if (FORCED) for (KEY in methods) {
      if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
        redefine(IterablePrototype, KEY, methods[KEY]);
      }
    } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME }, methods);
  }

  return methods;
};

var ARRAY_ITERATOR = 'Array Iterator';
var setInternalState = internalState.set;
var getInternalState = internalState.getterFor(ARRAY_ITERATOR);

// `Array.prototype.entries` method
// https://tc39.github.io/ecma262/#sec-array.prototype.entries
// `Array.prototype.keys` method
// https://tc39.github.io/ecma262/#sec-array.prototype.keys
// `Array.prototype.values` method
// https://tc39.github.io/ecma262/#sec-array.prototype.values
// `Array.prototype[@@iterator]` method
// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
// `CreateArrayIterator` internal method
// https://tc39.github.io/ecma262/#sec-createarrayiterator
var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
  setInternalState(this, {
    type: ARRAY_ITERATOR,
    target: toIndexedObject(iterated), // target
    index: 0,                          // next index
    kind: kind                         // kind
  });
// `%ArrayIteratorPrototype%.next` method
// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
}, function () {
  var state = getInternalState(this);
  var target = state.target;
  var kind = state.kind;
  var index = state.index++;
  if (!target || index >= target.length) {
    state.target = undefined;
    return { value: undefined, done: true };
  }
  if (kind == 'keys') return { value: index, done: false };
  if (kind == 'values') return { value: target[index], done: false };
  return { value: [index, target[index]], done: false };
}, 'values');

// argumentsList[@@iterator] is %ArrayProto_values%
// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject
// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject
iterators.Arguments = iterators.Array;

// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');

var aFunction = function (it) {
  if (typeof it != 'function') {
    throw TypeError(String(it) + ' is not a function');
  } return it;
};

var anInstance = function (it, Constructor, name) {
  if (!(it instanceof Constructor)) {
    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
  } return it;
};

// check on default Array iterator

var ITERATOR$2 = wellKnownSymbol('iterator');
var ArrayPrototype$1 = Array.prototype;

var isArrayIteratorMethod = function (it) {
  return it !== undefined && (iterators.Array === it || ArrayPrototype$1[ITERATOR$2] === it);
};

// optional / simple context binding
var bindContext = function (fn, that, length) {
  aFunction(fn);
  if (that === undefined) return fn;
  switch (length) {
    case 0: return function () {
      return fn.call(that);
    };
    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);
  };
};

var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
// ES3 wrong here
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';

// fallback for IE11 Script Access Denied error
var tryGet = function (it, key) {
  try {
    return it[key];
  } catch (error) { /* empty */ }
};

// getting tag from ES6+ `Object.prototype.toString`
var classof = function (it) {
  var O, tag, result;
  return it === undefined ? 'Undefined' : it === null ? 'Null'
    // @@toStringTag case
    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag
    // builtinTag case
    : CORRECT_ARGUMENTS ? classofRaw(O)
    // ES3 arguments fallback
    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
};

var ITERATOR$3 = wellKnownSymbol('iterator');


var getIteratorMethod = function (it) {
  if (it != undefined) return it[ITERATOR$3]
    || it['@@iterator']
    || iterators[classof(it)];
};

// call something on iterator step with safe closing on error
var callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
  try {
    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
  // 7.4.6 IteratorClose(iterator, completion)
  } catch (error) {
    var returnMethod = iterator['return'];
    if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
    throw error;
  }
};

var iterate = createCommonjsModule(function (module) {
var BREAK = {};

var exports = module.exports = function (iterable, fn, that, ENTRIES, ITERATOR) {
  var boundFunction = bindContext(fn, that, ENTRIES ? 2 : 1);
  var iterator, iterFn, index, length, result, step;

  if (ITERATOR) {
    iterator = iterable;
  } else {
    iterFn = getIteratorMethod(iterable);
    if (typeof iterFn != 'function') throw TypeError('Target is not iterable');
    // optimisation for array iterators
    if (isArrayIteratorMethod(iterFn)) {
      for (index = 0, length = toLength(iterable.length); length > index; index++) {
        result = ENTRIES ? boundFunction(anObject(step = iterable[index])[0], step[1]) : boundFunction(iterable[index]);
        if (result === BREAK) return BREAK;
      } return;
    }
    iterator = iterFn.call(iterable);
  }

  while (!(step = iterator.next()).done) {
    if (callWithSafeIterationClosing(iterator, boundFunction, step.value, ENTRIES) === BREAK) return BREAK;
  }
};

exports.BREAK = BREAK;
});

var ITERATOR$4 = wellKnownSymbol('iterator');
var SAFE_CLOSING = false;

try {
  var called = 0;
  var iteratorWithReturn = {
    next: function () {
      return { done: !!called++ };
    },
    'return': function () {
      SAFE_CLOSING = true;
    }
  };
  iteratorWithReturn[ITERATOR$4] = function () {
    return this;
  };
} catch (error) { /* empty */ }

var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
  var ITERATION_SUPPORT = false;
  try {
    var object = {};
    object[ITERATOR$4] = function () {
      return {
        next: function () {
          return { done: ITERATION_SUPPORT = true };
        }
      };
    };
    exec(object);
  } catch (error) { /* empty */ }
  return ITERATION_SUPPORT;
};

var SPECIES = wellKnownSymbol('species');

// `SpeciesConstructor` abstract operation
// https://tc39.github.io/ecma262/#sec-speciesconstructor
var speciesConstructor = function (O, defaultConstructor) {
  var C = anObject(O).constructor;
  var S;
  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);
};

var set$1 = global$1.setImmediate;
var clear = global$1.clearImmediate;
var process$1 = global$1.process;
var MessageChannel = global$1.MessageChannel;
var Dispatch = global$1.Dispatch;
var counter = 0;
var queue = {};
var ONREADYSTATECHANGE = 'onreadystatechange';
var defer, channel, port;

var run = function () {
  var id = +this;
  // eslint-disable-next-line no-prototype-builtins
  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 (!set$1 || !clear) {
  set$1 = function setImmediate(fn) {
    var args = [];
    var i = 1;
    while (arguments.length > i) args.push(arguments[i++]);
    queue[++counter] = function () {
      // eslint-disable-next-line no-new-func
      (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
    };
    defer(counter);
    return counter;
  };
  clear = function clearImmediate(id) {
    delete queue[id];
  };
  // Node.js 0.8-
  if (classofRaw(process$1) == 'process') {
    defer = function (id) {
      process$1.nextTick(bindContext(run, id, 1));
    };
  // Sphere (JS game engine) Dispatch API
  } else if (Dispatch && Dispatch.now) {
    defer = function (id) {
      Dispatch.now(bindContext(run, id, 1));
    };
  // Browsers with MessageChannel, includes WebWorkers
  } else if (MessageChannel) {
    channel = new MessageChannel();
    port = channel.port2;
    channel.port1.onmessage = listener;
    defer = bindContext(port.postMessage, port, 1);
  // Browsers with postMessage, skip WebWorkers
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
  } else if (global$1.addEventListener && typeof postMessage == 'function' && !global$1.importScripts) {
    defer = function (id) {
      global$1.postMessage(id + '', '*');
    };
    global$1.addEventListener('message', listener, false);
  // IE8-
  } else if (ONREADYSTATECHANGE in documentCreateElement('script')) {
    defer = function (id) {
      html.appendChild(documentCreateElement('script'))[ONREADYSTATECHANGE] = function () {
        html.removeChild(this);
        run.call(id);
      };
    };
  // Rest old browsers
  } else {
    defer = function (id) {
      setTimeout(bindContext(run, id, 1), 0);
    };
  }
}

var task = {
  set: set$1,
  clear: clear
};

var navigator = global$1.navigator;

var userAgent = navigator && navigator.userAgent || '';

var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;

var macrotask = task.set;

var MutationObserver = global$1.MutationObserver || global$1.WebKitMutationObserver;
var process$2 = global$1.process;
var Promise$1 = global$1.Promise;
var IS_NODE = classofRaw(process$2) == 'process';
// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$1, 'queueMicrotask');
var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;

var flush, head, last, notify, toggle, node, promise;

// modern engines have queueMicrotask method
if (!queueMicrotask) {
  flush = function () {
    var parent, fn;
    if (IS_NODE && (parent = process$2.domain)) parent.exit();
    while (head) {
      fn = head.fn;
      head = head.next;
      try {
        fn();
      } catch (error) {
        if (head) notify();
        else last = undefined;
        throw error;
      }
    } last = undefined;
    if (parent) parent.enter();
  };

  // Node.js
  if (IS_NODE) {
    notify = function () {
      process$2.nextTick(flush);
    };
  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
  } else if (MutationObserver && !/(iPhone|iPod|iPad).*AppleWebKit/i.test(userAgent)) {
    toggle = true;
    node = document.createTextNode('');
    new MutationObserver(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$1 && Promise$1.resolve) {
    // Promise.resolve without an argument throws an error in LG WebOS 2
    promise = Promise$1.resolve(undefined);
    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$1, flush);
    };
  }
}

var microtask = queueMicrotask || function (fn) {
  var task = { fn: fn, next: undefined };
  if (last) last.next = task;
  if (!head) {
    head = task;
    notify();
  } last = task;
};

// 25.4.1.5 NewPromiseCapability(C)


var PromiseCapability = 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 f$5 = function (C) {
  return new PromiseCapability(C);
};

var newPromiseCapability = {
	f: f$5
};

var promiseResolve = function (C, x) {
  anObject(C);
  if (isObject(x) && x.constructor === C) return x;
  var promiseCapability = newPromiseCapability.f(C);
  var resolve = promiseCapability.resolve;
  resolve(x);
  return promiseCapability.promise;
};

var hostReportErrors = function (a, b) {
  var console = global$1.console;
  if (console && console.error) {
    arguments.length === 1 ? console.error(a) : console.error(a, b);
  }
};

var perform = function (exec) {
  try {
    return { error: false, value: exec() };
  } catch (error) {
    return { error: true, value: error };
  }
};

var redefineAll = function (target, src, options) {
  for (var key in src) redefine(target, key, src[key], options);
  return target;
};

var path = global$1;

var aFunction$1 = function (variable) {
  return typeof variable == 'function' ? variable : undefined;
};

var getBuiltIn = function (namespace, method) {
  return arguments.length < 2 ? aFunction$1(path[namespace]) || aFunction$1(global$1[namespace])
    : path[namespace] && path[namespace][method] || global$1[namespace] && global$1[namespace][method];
};

var SPECIES$1 = wellKnownSymbol('species');

var setSpecies = function (CONSTRUCTOR_NAME) {
  var C = getBuiltIn(CONSTRUCTOR_NAME);
  var defineProperty = objectDefineProperty.f;
  if (descriptors && C && !C[SPECIES$1]) defineProperty(C, SPECIES$1, {
    configurable: true,
    get: function () { return this; }
  });
};

var PROMISE = 'Promise';










var task$1 = task.set;






var SPECIES$2 = wellKnownSymbol('species');


var getInternalState$1 = internalState.get;
var setInternalState$1 = internalState.set;
var getInternalPromiseState = internalState.getterFor(PROMISE);
var PromiseConstructor = global$1[PROMISE];
var TypeError$1 = global$1.TypeError;
var document$3 = global$1.document;
var process$3 = global$1.process;
var $fetch = global$1.fetch;
var versions = process$3 && process$3.versions;
var v8 = versions && versions.v8 || '';
var newPromiseCapability$1 = newPromiseCapability.f;
var newGenericPromiseCapability = newPromiseCapability$1;
var IS_NODE$1 = classofRaw(process$3) == 'process';
var DISPATCH_EVENT = !!(document$3 && document$3.createEvent && global$1.dispatchEvent);
var UNHANDLED_REJECTION = 'unhandledrejection';
var REJECTION_HANDLED = 'rejectionhandled';
var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;
var HANDLED = 1;
var UNHANDLED = 2;
var Internal, OwnPromiseCapability, PromiseWrapper;

var FORCED = isForced_1(PROMISE, function () {
  // correct subclassing with @@species support
  var promise = PromiseConstructor.resolve(1);
  var empty = function () { /* empty */ };
  var FakePromise = (promise.constructor = {})[SPECIES$2] = function (exec) {
    exec(empty, empty);
  };
  // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
  return !((IS_NODE$1 || typeof PromiseRejectionEvent == 'function')
    && (!isPure || promise['finally'])
    && promise.then(empty) instanceof FakePromise
    // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
    // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
    // we can't detect it synchronously, so just check versions
    && v8.indexOf('6.6') !== 0
    && userAgent.indexOf('Chrome/66') === -1);
});

var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
});

// helpers
var isThenable = function (it) {
  var then;
  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
};

var notify$1 = function (promise, state, isReject) {
  if (state.notified) return;
  state.notified = true;
  var chain = state.reactions;
  microtask(function () {
    var value = state.value;
    var ok = state.state == FULFILLED;
    var i = 0;
    var run = function (reaction) {
      var handler = ok ? reaction.ok : reaction.fail;
      var resolve = reaction.resolve;
      var reject = reaction.reject;
      var domain = reaction.domain;
      var result, then, exited;
      try {
        if (handler) {
          if (!ok) {
            if (state.rejection === UNHANDLED) onHandleUnhandled(promise, state);
            state.rejection = HANDLED;
          }
          if (handler === true) result = value;
          else {
            if (domain) domain.enter();
            result = handler(value); // may throw
            if (domain) {
              domain.exit();
              exited = true;
            }
          }
          if (result === reaction.promise) {
            reject(TypeError$1('Promise-chain cycle'));
          } else if (then = isThenable(result)) {
            then.call(result, resolve, reject);
          } else resolve(result);
        } else reject(value);
      } catch (error) {
        if (domain && !exited) domain.exit();
        reject(error);
      }
    };
    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
    state.reactions = [];
    state.notified = false;
    if (isReject && !state.rejection) onUnhandled(promise, state);
  });
};

var dispatchEvent = function (name, promise, reason) {
  var event, handler;
  if (DISPATCH_EVENT) {
    event = document$3.createEvent('Event');
    event.promise = promise;
    event.reason = reason;
    event.initEvent(name, false, true);
    global$1.dispatchEvent(event);
  } else event = { promise: promise, reason: reason };
  if (handler = global$1['on' + name]) handler(event);
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
};

var onUnhandled = function (promise, state) {
  task$1.call(global$1, function () {
    var value = state.value;
    var IS_UNHANDLED = isUnhandled(state);
    var result;
    if (IS_UNHANDLED) {
      result = perform(function () {
        if (IS_NODE$1) {
          process$3.emit('unhandledRejection', value, promise);
        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
      });
      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
      state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED;
      if (result.error) throw result.value;
    }
  });
};

var isUnhandled = function (state) {
  return state.rejection !== HANDLED && !state.parent;
};

var onHandleUnhandled = function (promise, state) {
  task$1.call(global$1, function () {
    if (IS_NODE$1) {
      process$3.emit('rejectionHandled', promise);
    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
  });
};

var bind = function (fn, promise, state, unwrap) {
  return function (value) {
    fn(promise, state, value, unwrap);
  };
};

var internalReject = function (promise, state, value, unwrap) {
  if (state.done) return;
  state.done = true;
  if (unwrap) state = unwrap;
  state.value = value;
  state.state = REJECTED;
  notify$1(promise, state, true);
};

var internalResolve = function (promise, state, value, unwrap) {
  if (state.done) return;
  state.done = true;
  if (unwrap) state = unwrap;
  try {
    if (promise === value) throw TypeError$1("Promise can't be resolved itself");
    var then = isThenable(value);
    if (then) {
      microtask(function () {
        var wrapper = { done: false };
        try {
          then.call(value,
            bind(internalResolve, promise, wrapper, state),
            bind(internalReject, promise, wrapper, state)
          );
        } catch (error) {
          internalReject(promise, wrapper, error, state);
        }
      });
    } else {
      state.value = value;
      state.state = FULFILLED;
      notify$1(promise, state, false);
    }
  } catch (error) {
    internalReject(promise, { done: false }, error, state);
  }
};

// constructor polyfill
if (FORCED) {
  // 25.4.3.1 Promise(executor)
  PromiseConstructor = function Promise(executor) {
    anInstance(this, PromiseConstructor, PROMISE);
    aFunction(executor);
    Internal.call(this);
    var state = getInternalState$1(this);
    try {
      executor(bind(internalResolve, this, state), bind(internalReject, this, state));
    } catch (error) {
      internalReject(this, state, error);
    }
  };
  // eslint-disable-next-line no-unused-vars
  Internal = function Promise(executor) {
    setInternalState$1(this, {
      type: PROMISE,
      done: false,
      notified: false,
      parent: false,
      reactions: [],
      rejection: false,
      state: PENDING,
      value: undefined
    });
  };
  Internal.prototype = redefineAll(PromiseConstructor.prototype, {
    // `Promise.prototype.then` method
    // https://tc39.github.io/ecma262/#sec-promise.prototype.then
    then: function then(onFulfilled, onRejected) {
      var state = getInternalPromiseState(this);
      var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor));
      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
      reaction.fail = typeof onRejected == 'function' && onRejected;
      reaction.domain = IS_NODE$1 ? process$3.domain : undefined;
      state.parent = true;
      state.reactions.push(reaction);
      if (state.state != PENDING) notify$1(this, state, false);
      return reaction.promise;
    },
    // `Promise.prototype.catch` method
    // https://tc39.github.io/ecma262/#sec-promise.prototype.catch
    'catch': function (onRejected) {
      return this.then(undefined, onRejected);
    }
  });
  OwnPromiseCapability = function () {
    var promise = new Internal();
    var state = getInternalState$1(promise);
    this.promise = promise;
    this.resolve = bind(internalResolve, promise, state);
    this.reject = bind(internalReject, promise, state);
  };
  newPromiseCapability.f = newPromiseCapability$1 = function (C) {
    return C === PromiseConstructor || C === PromiseWrapper
      ? new OwnPromiseCapability(C)
      : newGenericPromiseCapability(C);
  };

  // wrap fetch result
  if (typeof $fetch == 'function') _export({ global: true, enumerable: true, forced: true }, {
    // eslint-disable-next-line no-unused-vars
    fetch: function fetch(input) {
      return promiseResolve(PromiseConstructor, $fetch.apply(global$1, arguments));
    }
  });
}

_export({ global: true, wrap: true, forced: FORCED }, { Promise: PromiseConstructor });

setToStringTag(PromiseConstructor, PROMISE, false, true);
setSpecies(PROMISE);

PromiseWrapper = path[PROMISE];

// statics
_export({ target: PROMISE, stat: true, forced: FORCED }, {
  // `Promise.reject` method
  // https://tc39.github.io/ecma262/#sec-promise.reject
  reject: function reject(r) {
    var capability = newPromiseCapability$1(this);
    capability.reject.call(undefined, r);
    return capability.promise;
  }
});

_export({ target: PROMISE, stat: true, forced: FORCED }, {
  // `Promise.resolve` method
  // https://tc39.github.io/ecma262/#sec-promise.resolve
  resolve: function resolve(x) {
    return promiseResolve(this, x);
  }
});

_export({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
  // `Promise.all` method
  // https://tc39.github.io/ecma262/#sec-promise.all
  all: function all(iterable) {
    var C = this;
    var capability = newPromiseCapability$1(C);
    var resolve = capability.resolve;
    var reject = capability.reject;
    var result = perform(function () {
      var values = [];
      var counter = 0;
      var remaining = 1;
      iterate(iterable, function (promise) {
        var index = counter++;
        var 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 (result.error) reject(result.value);
    return capability.promise;
  },
  // `Promise.race` method
  // https://tc39.github.io/ecma262/#sec-promise.race
  race: function race(iterable) {
    var C = this;
    var capability = newPromiseCapability$1(C);
    var reject = capability.reject;
    var result = perform(function () {
      iterate(iterable, function (promise) {
        C.resolve(promise).then(capability.resolve, reject);
      });
    });
    if (result.error) reject(result.value);
    return capability.promise;
  }
});

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;
}

function _objectSpread(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? Object(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;
}

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;
}

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;
}

/**
 * This abstract class should be implemented by all commands.
 */
class Command {
  constructor() {
    _defineProperty(this, "command", void 0);

    _defineProperty(this, "description", void 0);

    _defineProperty(this, "options", []);
  }

}

// a string of all valid unicode whitespaces
// eslint-disable-next-line max-len
var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';

var whitespace = '[' + whitespaces + ']';
var ltrim = RegExp('^' + whitespace + whitespace + '*');
var rtrim = RegExp(whitespace + whitespace + '*$');

// 1 -> String#trimStart
// 2 -> String#trimEnd
// 3 -> String#trim
var stringTrim = function (string, TYPE) {
  string = String(requireObjectCoercible(string));
  if (TYPE & 1) string = string.replace(ltrim, '');
  if (TYPE & 2) string = string.replace(rtrim, '');
  return string;
};

var non = '\u200B\u0085\u180E';

// check that a method works with the correct list
// of whitespaces and has a correct name
var forcedStringTrimMethod = function (METHOD_NAME) {
  return fails(function () {
    return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;
  });
};

var FORCED$1 = forcedStringTrimMethod('trim');

// `String.prototype.trim` method
// https://tc39.github.io/ecma262/#sec-string.prototype.trim
_export({ target: 'String', proto: true, forced: FORCED$1 }, {
  trim: function trim() {
    return stringTrim(this, 3);
  }
});

const semverRegex = require('semver-regex');

const getLatestVersion = require('latest-version');

function parseVersion(v) {
  if (v === null) throw new Error('Version is null.');

  if (typeof v === 'string') {
    const parsedV = semver__default.parse(semverRegex().exec(v)[0]);

    if (parsedV === null) {
      throw new Error(`Version ${v.trim()} cannot be parsed.`);
    }

    return parsedV;
  }

  return v;
}
async function latestVersion(npmPackageName) {
  return parseVersion((await getLatestVersion(npmPackageName)));
}

function useExeca(cmd, options) {
  const [execaResult, setExecaResult] = React__default.useState();
  React__default.useEffect(() => {
    const p = execa.command(cmd, _objectSpread({
      reject: false
    }, options));
    p.then(r => {
      if (r.killed) return;
      setExecaResult(r);
    });
    return () => p.kill();
  }, [cmd, options]);
  return execaResult;
}
function useLatestNpmVersion(pkg) {
  const [latest, setLatest] = React__default.useState(null);
  const [error, setError] = React__default.useState();
  React__default.useEffect(() => {
    let mounted = true;
    latestVersion(pkg).then(v => {
      if (mounted) setLatest(v);
    }).catch(e => {
      if (mounted) setError(e);
    });
    return () => {
      mounted = false;
    };
  }, [pkg]);
  return {
    latest,
    error
  };
}
function latestVersionResult(version) {
  return {
    type: CheckStatusType.Ok,
    message: React__default.createElement(React__default.Fragment, null, "Version ", React__default.createElement(Version, {
      version: version
    }), " is the latest.")
  };
}
function outdatedVersionResult(current, latest, type = CheckStatusType.Warning) {
  return {
    type,
    message: React__default.createElement(React__default.Fragment, null, "You have version ", React__default.createElement(Version, {
      version: current
    }), " while the latest is", ' ', React__default.createElement(Version, {
      version: latest
    }), ".")
  };
}
function Version({
  version
}) {
  return React__default.createElement(ink.Text, {
    color: "cyan"
  }, typeof version === 'string' ? version : version.format());
}

function usePHPCheck() {
  const phpV = useExeca('php -v');
  const version = phpV && !phpV.failed ? parseVersion(phpV.stdout) : undefined;

  if (!phpV) {
    return {
      type: CheckStatusType.Loading,
      message: 'Checking your PHP version...'
    };
  }

  if (!version) {
    return {
      type: CheckStatusType.Error,
      message: "Looks like you don't have PHP correctly installed."
    };
  }

  if (version.major >= 7 && version.minor >= 4) {
    return {
      type: CheckStatusType.Ok,
      message: React__default.createElement(React__default.Fragment, null, "You have PHP ", React__default.createElement(Version, {
        version: version
      }), " installed.")
    };
  }

  return {
    type: CheckStatusType.Warning,
    message: React__default.createElement(React__default.Fragment, null, "You have PHP ", React__default.createElement(Version, {
      version: version
    }), " installed, but you need at least ", React__default.createElement(Version, {
      version: "7.4"
    }), ".")
  };
}

function useExit(shouldExit, error) {
  const {
    exit
  } = ink.useApp();
  React__default.useEffect(() => {
    if (shouldExit) exit(error);
  }, [error, exit, shouldExit]);
}

function useAxios(url, config) {
  const [res, setRes] = React__default.useState({
    loading: true
  });
  React__default.useEffect(() => {
    const source = axios.CancelToken.source();
    axios(_objectSpread({
      url,
      cancelToken: source.token
    }, config)).then(response => {
      setRes({
        response,
        loading: false
      });
    }).catch(error => {
      if (!axios.isCancel(error)) {
        setRes({
          error,
          loading: false
        });
      }
    });
    return () => {
      source.cancel();
    };
  }, [config, url]);
  return res;
}

const axiosConfig = {
  timeout: 3000
};
function useNodeJsCheck() {
  const nodeVersions = useAxios('https://nodejs.org/dist/index.json', axiosConfig);
  const nodeVersion = parseVersion(process.version);
  const versionSupported = nodeVersion.major === 8 || nodeVersion.major === 10;

  if (!versionSupported) {
    return {
      type: CheckStatusType.Error,
      message: 'You should use Node.js 8 or 10.'
    };
  }

  if (nodeVersions.error) {
    return {
      type: CheckStatusType.LoadingError,
      message: `Error fetching latest version: ${nodeVersions.error.message}`
    };
  }

  if (nodeVersions.loading) {
    return {
      type: CheckStatusType.Loading,
      message: 'Fetching latest version...'
    };
  }

  const latestInMajor = nodeVersions.response.data.map(v => parseVersion(v.version)).find(s => !!s && s.major === nodeVersion.major);

  if (!latestInMajor) {
    return {
      type: CheckStatusType.LoadingError,
      message: "Can't find latest Node.js version."
    };
  }

  if (latestInMajor.compare(nodeVersion) === 0) {
    return latestVersionResult(nodeVersion);
  }

  return outdatedVersionResult(nodeVersion, latestInMajor);
}

function useNPMCheck() {
  const npmV = useExeca('npm -v');
  const version = npmV ? parseVersion(npmV.stdout) : undefined;
  const {
    latest,
    error
  } = useLatestNpmVersion('npm');

  if (!npmV) {
    return {
      type: CheckStatusType.Loading,
      message: 'Getting your NPM version...'
    };
  }

  if (!version) {
    return {
      type: CheckStatusType.Error,
      message: 'Something is wrong with your NPM installation.'
    };
  }

  if (error) {
    return {
      type: CheckStatusType.LoadingError,
      message: `Error fetching latest version: ${error.message}`
    };
  }

  if (!latest) {
    return {
      type: CheckStatusType.Loading,
      message: 'Getting latest version from NPM...'
    };
  }

  if (latest.compare(version.version) === 0) {
    return latestVersionResult(version);
  }

  return outdatedVersionResult(version, latest);
}

var version = "0.0.151";

const updatedError = new Error('Burst CLI was updated!');
function UpdateBurstCli() {
  const updateCommand = useExeca('npm i -g @burst/cli');
  useExit(!!updateCommand, updatedError);

  if (!updateCommand) {
    return React__default.createElement(ink.Box, {
      marginTop: 1,
      marginBottom: 1
    }, React__default.createElement(ink.Text, null, "Updating the Burst CLI to the latest version..."));
  }

  return React__default.createElement(ink.Box, {
    marginTop: 1,
    marginBottom: 1
  }, updateCommand.failed ? React__default.createElement(ink.Text, null, "Burst CLI ", React__default.createElement(ink.Text, {
    bold: true
  }, "failed to update"), ", please run", ' ', React__default.createElement(ink.Text, {
    color: "cyan"
  }, "npm i -g @burst/cli"), " yourself.") : React__default.createElement(ink.Text, null, "Burst CLI updated, please re-run your command."));
}
function useBurstCliCheck() {
  const {
    latest,
    error
  } = useLatestNpmVersion('@burst/cli');

  if (error) {
    return {
      type: CheckStatusType.LoadingError,
      message: `Error fetching latest version: ${error.message}`
    };
  }

  if (latest) {
    if (latest.compare(version) !== 0) {
      return outdatedVersionResult(version, latest, CheckStatusType.Error);
    }

    return latestVersionResult(latest);
  }

  return {
    type: CheckStatusType.Loading,
    message: 'Getting latest version from NPM...'
  };
}

const minVersion = '3.0.0-rc.12';
const maxVersion = '3.0.0-rc.15';
function useLandoCheck() {
  const lando = useExeca('lando version');
  const version = lando && lando.exitCode === 0 ? parseVersion(lando.stdout) : undefined;

  if (!lando) {
    return {
      type: CheckStatusType.Loading,
      message: 'Checking your Lando version...'
    };
  }

  if (!version) {
    return {
      type: CheckStatusType.Ok,
      message: "You don't have Lando installed, which is fine."
    };
  }

  const downloadLink = React__default.createElement(React__default.Fragment, null, "Download the latest supported version here:", ' ', `https://github.com/lando/lando/releases/tag/v${maxVersion}`);

  if (version.compare(minVersion) === -1) {
    return {
      type: CheckStatusType.Error,
      message: React__default.createElement(React__default.Fragment, null, "You have Lando ", React__default.createElement(Version, {
        version: version
      }), " installed, but you need at least ", React__default.createElement(Version, {
        version: minVersion
      }), ". Please update to", ' ', React__default.createElement(Version, {
        version: maxVersion
      }), " if possible. ", downloadLink)
    };
  }

  if (version.compare(maxVersion) === 1) {
    return {
      type: CheckStatusType.Error,
      message: React__default.createElement(React__default.Fragment, null, "You have Lando ", React__default.createElement(Version, {
        version: version
      }), " installed, but the latest supported version is ", React__default.createElement(Version, {
        version: maxVersion
      }), ". Please downgrade to to that version. ", downloadLink)
    };
  }

  if (version.compare(maxVersion) === -1) {
    return {
      type: CheckStatusType.Warning,
      message: React__default.createElement(React__default.Fragment, null, "You have Lando ", React__default.createElement(Version, {
        version: version
      }), " installed, but the latest supported version is ", React__default.createElement(Version, {
        version: maxVersion
      }), ". ", downloadLink)
    };
  }

  return {
    type: CheckStatusType.Ok,
    message: React__default.createElement(React__default.Fragment, null, "You have Lando ", React__default.createElement(Version, {
      version: version
    }), " installed.")
  };
}

const isCI = require('is-ci');

class CheckCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'check');

    _defineProperty(this, "description", 'Check your local environment.');
  }

  async action() {
    const a = ink.render(React__default.createElement(Check, null));
    await a.waitUntilExit();
  }

}
function checkFirst(funcToWrap) {
  return async (...args) => {
    // We don't want to check first on the CI.
    if (!isCI) {
      try {
        const a = ink.render(React__default.createElement(Check, {
          onlyDisplayErrors: true
        }));
        await a.waitUntilExit();
        a.cleanup();
      } catch (error) {
        if (error !== updatedError) {
          throw error;
        } // The Burst CLI was just updated, so we need to stop.


        process.exit(1);
      }
    }

    return funcToWrap(...args);
  };
}
let CheckStatusType;

(function (CheckStatusType) {
  CheckStatusType[CheckStatusType["Loading"] = 0] = "Loading";
  CheckStatusType[CheckStatusType["Warning"] = 1] = "Warning";
  CheckStatusType[CheckStatusType["Error"] = 2] = "Error";
  CheckStatusType[CheckStatusType["LoadingError"] = 3] = "LoadingError";
  CheckStatusType[CheckStatusType["Ok"] = 4] = "Ok";
})(CheckStatusType || (CheckStatusType = {}));

function Check({
  onlyDisplayErrors = false
}) {
  const checks = [['Burst CLI', useBurstCliCheck()], ['Node.js', useNodeJsCheck()], ['PHP', usePHPCheck()], ['NPM', useNPMCheck()], ['Lando', useLandoCheck()]];
  const burstCliNeedsUpdate = checks[0][1].type === CheckStatusType.Error;
  const checksLoaded = checks.every(([, c]) => c.type !== CheckStatusType.Loading);
  useExit(checksLoaded && !burstCliNeedsUpdate);
  return React__default.createElement(ink.Box, {
    marginBottom: 1,
    flexDirection: "column"
  }, (onlyDisplayErrors ? checks.filter(([, c]) => c.type !== CheckStatusType.Loading && c.type !== CheckStatusType.Ok) : checks).map(([n, c]) => React__default.createElement(ink.Box, {
    key: n
  }, React__default.createElement(ink.Box, {
    width: 4
  }, React__default.createElement(ink.Text, null, c.type === CheckStatusType.Loading ? '⌚' : c.type === CheckStatusType.Warning ? '🚧' : c.type === CheckStatusType.Error ? '❌' : c.type === CheckStatusType.LoadingError ? '❌' : '👍')), React__default.createElement(ink.Box, {
    width: 12
  }, React__default.createElement(ink.Text, null, n)), React__default.createElement(ink.Box, {
    flexGrow: 1
  }, React__default.createElement(ink.Text, null, c.message)))), !checksLoaded && React__default.createElement(ink.Box, {
    marginTop: 1,
    marginBottom: 1
  }, React__default.createElement(ink.Text, null, "Checking your local development environment...")), burstCliNeedsUpdate && React__default.createElement(UpdateBurstCli, null));
}

const isCI$1 = require('is-ci');

class PrepareCICommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'prepare-ci');

    _defineProperty(this, "description", 'This adds various environment varibles.');

    _defineProperty(this, "action", async () => {
      if (!isCI$1) {
        console.log('You can only run this command in the CI.');
        process.exit(1);
      }

      console.log((await prepareCI()));
    });
  }

}
async function prepareCI() {
  if (!isCI$1) return [];
  const toEval = []; // Start ssh agent

  if (!process.env.SSH_AUTH_SOCK || !process.env.SSH_AGENT_PID) {
    const {
      stdout: agent
    } = await execa('ssh-agent');
    toEval.push(agent);
    const [, authSock] = /SSH_AUTH_SOCK=(.*); export/.exec(agent) || ['', ''];
    const [, agentPid] = /SSH_AGENT_PID=(.*); export/.exec(agent) || ['', ''];
    process.env.SSH_AUTH_SOCK = authSock;
    process.env.SSH_AGENT_PID = agentPid;
  } // Add ssh key


  if (process.env.PLATFORMSH_SSH_KEY) {
    await execa.command(`echo "$PLATFORMSH_SSH_KEY" | tr -d '\\r' | ssh-add - > /dev/null`, {
      shell: true
    });
  }

  return toEval.join('\n');
}

const isCI$2 = require('is-ci');

const repoRootGitCmd = process.env.CI_PROJECT_DIR ? {
  stdout: process.env.CI_PROJECT_DIR,
  failed: false
} : execa.sync('git', ['rev-parse', '--show-toplevel'], {
  reject: false
});

if (repoRootGitCmd.failed) {
  throw new Error('Please use the Burst CLI in a git repository.');
}

const repoRoot = repoRootGitCmd.stdout;
/** @deprecated */

function getRepoRoot() {
  return repoRoot;
}
async function push(url, branch, {
  dir
} = {}) {
  // Remove any possible old remote we could still have.
  // We catch everything, because it fails if there isn't one.
  // That's no problem.
  await execa('git', ['remote', 'remove', '_burst_tmp_']).catch(() => undefined); // Add a new remote with the push url.

  await execa('git', ['remote', 'add', '_burst_tmp_', url]); // Push current head to the new remote on the branch provided.

  try {
    let src = 'HEAD';

    if (dir) {
      console.log(`Creating git subtree of the ${chalk.cyan(dir)} directory.`);
      ({
        stdout: src
      } = await execa('git', ['subtree', 'split', '--prefix', dir], {
        stderr: !isCI$2 ? 'inherit' : undefined,
        // We always need to run the subtree command from the root of the
        // project, see #44.
        cwd: repoRoot
      }));
      console.log('Done with creating subtree.');
    } // Make sure we can push with SSH if on the Gitlab CI


    await prepareCI(); // We push the src (which is HEAD or a commit id) to the remote repository. We prefix
    // the remote repository with refs/heads/ so the branch is created if it doesn't
    // exist on the remote already.

    await execa('git', ['push', '_burst_tmp_', `${src}:refs/heads/${branch}`, '--force', '--verbose'], {
      stdio: 'inherit'
    });
  } finally {
    // Remove the remote (even if pushing failed).
    await execa('git', ['remote', 'remove', '_burst_tmp_']).catch(() => {// do nothing
    });
  }
}
async function getCurrentBranch() {
  // In Gitlab CI, we can use this environment variable.
  if (process.env.CI_COMMIT_REF_NAME) return process.env.CI_COMMIT_REF_NAME; // Otherwise, we use the Git CLI to get the current branch.

  return (await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout;
}
async function getListOfRepoFiles(search = [], fromRoot = false) {
  const cwd = fromRoot || !search.length ? repoRoot : undefined; // To get a complete list of all files that are on disk and not excluded by a
  // gitignore rule, we need to do multple 'git ls-files' calls.
  //
  // CACHED:
  // This are all the files that are currently staged.
  // If a file is deleted but that change isn't staged yet, it will still be
  // returned.
  //
  // DELETED:
  // This returns all files that are staged at this moment, but aren't
  // available on the disk anymore. If a deletion is staged, it isn't returned
  // anymore.
  //
  // UNTRACKED:
  // This are all the new files that exist on disk, but aren't tracked / staged
  // yet.

  const [cached, deleted, untracked] = await Promise.all([gitLsFiles(search, cwd), gitLsFiles(['--deleted', ...search], cwd), gitLsFiles([...search, '--others', '--exclude-standard'], cwd)]);
  return [...untracked, ...cached.filter(file => !deleted.includes(file))];
}

async function gitLsFiles(opts, cwd) {
  const {
    stdout: command
  } = await execa('git', ['ls-files', ...opts, '--full-name'], {
    cwd
  });
  return command.split('\n').filter(f => f.length);
}

function useTsWorker() {
  return useWorker('./workers/ts', React.useMemo(() => ['doTsCheck'], []), React.useMemo(() => ({
    numWorkers: 1
  }), []));
}
function usePrettierWorker() {
  return useWorker('./workers/prettier', React.useMemo(() => ['getFileInfo', 'format'], []), React.useMemo(() => ({
    numWorkers: 1
  }), []));
}
function useEslintWorker() {
  return useWorker('./workers/eslint', React.useMemo(() => ['lintFile', 'writeToDisk'], []), React.useMemo(() => ({
    numWorkers: 2
  }), []));
}

function useWorker(path, exposedMethods, options) {
  const worker = React.useMemo(() => new Worker(require.resolve(path), _objectSpread({}, options, {
    exposedMethods: exposedMethods
  })), [exposedMethods, path, options]);
  React.useEffect(() => () => {
    worker.end();
  }, [worker]);
  return worker;
}

function useTsChecker(allFiles) {
  const files = React.useMemo(() => allFiles.filter(f => f.path.endsWith('.ts') || f.path.endsWith('.tsx')), [allFiles]);
  const [filesWithTs, filesWithoutTs] = React.useMemo(() => {
    const resolved = lodash.groupBy(files, file => resolve.silent(file.absolutePath, 'typescript'));

    const {
      undefined: withoutTs = []
    } = resolved,
          withTs = _objectWithoutProperties(resolved, ["undefined"]);

    return [withTs, withoutTs];
  }, [files]);
  const worker = useTsWorker();
  const [workerResults, setWorkerResults] = React.useState([]);
  React.useEffect(() => {
    Object.entries(filesWithTs).forEach(async ([tsPath, tsFiles]) => {
      const workerResult = await worker.doTsCheck(tsPath, tsFiles.map(f => f.absolutePath));
      setWorkerResults(r => [...r, workerResult]);
    });
  }, [filesWithTs, worker]);
  const filesWithoutProject = lodash.flatten(workerResults.map(r => r.filesWithoutProject));
  const filesNotIncludedInProject = lodash.flatten(workerResults.map(r => r.filesNotIncludedInProject));
  const errors = [...filesWithoutTs.map(f => ({
    filename: f.absolutePath,
    message: 'No TypeScript module can be found for this file. \nAre you sure TypeScript is installed?'
  })), ...filesWithoutProject.map(f => ({
    filename: f,
    message: 'Found no tsconfig.json file. \nAre you sure there is a tsconfig.json file in the root of the app?'
  })), ...filesNotIncludedInProject.map(f => ({
    filename: f,
    message: 'There is a tsconfig.json file, but it looks like this file is excluded. \nPlease check the include / exclude part of the tsconfig.json file.'
  })), ...lodash.flatten(workerResults.map(r => r.errors))].map(f => _objectSpread({}, f, {
    linter: 'TypeScript',
    autoFixable: false
  }));
  return {
    files,
    done: workerResults.length === Object.keys(filesWithTs).length,
    errors
  };
}

function useEslint(allFiles, fix) {
  const files = React.useMemo(() => allFiles.filter(f => f.path.endsWith('.js') || f.path.endsWith('.jsx') || f.path.endsWith('.ts') || f.path.endsWith('.tsx')), [allFiles]);
  const eslint = useEslintWorker();
  const [reports, setReports] = React.useState([]);
  const [execErrors, setExecErrors] = React.useState({});
  React.useEffect(() => {
    files.forEach(async file => {
      try {
        const report = await eslint.lintFile(file.absolutePath, fix);

        if (report.results.length === 0) {
          throw new Error('The file could not be linted by ESLint.');
        }

        if (fix) {
          await eslint.writeToDisk(report);
        }

        setReports(r => [...r, ...report.results]);
      } catch (e) {
        setExecErrors(exe => _objectSpread({}, exe, {
          [file.absolutePath]: e.message || e.toString()
        }));
      }
    });
  }, [eslint, files, fix]);
  const [longTimeAgoSinceLastReport, setLTASLR] = React.useState(false);
  const allFilesLinted = reports.length + Object.keys(execErrors).length === files.length;
  React.useEffect(() => {
    if (allFilesLinted || longTimeAgoSinceLastReport) return; // When not a single file has been linted in the last minute - it is probabily
    // stuck on one file. We add an error for these files.

    const timeoutId = setTimeout(() => {
      setLTASLR(true);
    }, 5 * 60 * 1000);
    return () => clearTimeout(timeoutId);
  }, [reports, execErrors, allFilesLinted, longTimeAgoSinceLastReport]);
  const filesAutoFixed = fix ? reports.reduce((c, r) => c + (r.output ? 1 : 0), 0) : 0;
  const errors = [];
  const prettierErrors = [];
  reports.forEach(r => {
    r.messages.forEach(m => {
      // We only want to show the Prettier error once per file.
      if (m.ruleId === 'prettier/prettier') {
        if (prettierErrors.includes(r.filePath)) return;
        errors.push({
          linter: 'ESLint',
          filename: r.filePath,
          autoFixable: true,
          message: 'Not according to Prettier styling.',
          rule: 'prettier/prettier'
        });
        prettierErrors.push(r.filePath);
        return;
      }

      errors.push({
        linter: 'ESLint',
        filename: r.filePath,
        autoFixable: !!m.fix,
        message: m.message,
        rule: m.ruleId || undefined,
        sourceLocation: _objectSpread({
          start: {
            line: m.line,
            column: m.column
          }
        }, m.endLine ? {
          end: {
            line: m.endLine,
            column: m.endColumn
          }
        } : {})
      });
    });
  });
  Object.entries(execErrors).forEach(([filename, error]) => {
    errors.push({
      linter: 'ESLint',
      filename,
      autoFixable: false,
      message: error
    });
  });
  const filesReported = reports.map(r => r.filePath);
  const filesWithErrors = Object.keys(execErrors);

  if (longTimeAgoSinceLastReport) {
    files.filter(f => !filesReported.includes(f.absolutePath) && !filesWithErrors.includes(f.absolutePath)).forEach(file => {
      errors.push({
        linter: 'ESLint',
        filename: file.absolutePath,
        autoFixable: false,
        message: 'ESLint has probabily timeout while linting this file.'
      });
    });
  }

  return {
    files,
    reports,
    filesAutoFixed,
    errors,
    done: allFilesLinted || longTimeAgoSinceLastReport
  };
}

var sloppyArrayMethod = function (METHOD_NAME, argument) {
  var method = [][METHOD_NAME];
  return !method || !fails(function () {
    // eslint-disable-next-line no-useless-call,no-throw-literal
    method.call(null, argument || function () { throw 1; }, 1);
  });
};

var nativeSort = [].sort;
var test = [1, 2, 3];

// IE8-
var FAILS_ON_UNDEFINED = fails(function () {
  test.sort(undefined);
});
// V8 bug
var FAILS_ON_NULL = fails(function () {
  test.sort(null);
});
// Old WebKit
var SLOPPY_METHOD = sloppyArrayMethod('sort');

var FORCED$2 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || SLOPPY_METHOD;

// `Array.prototype.sort` method
// https://tc39.github.io/ecma262/#sec-array.prototype.sort
_export({ target: 'Array', proto: true, forced: FORCED$2 }, {
  sort: function sort(comparefn) {
    return comparefn === undefined
      ? nativeSort.call(toObject(this))
      : nativeSort.call(toObject(this), aFunction(comparefn));
  }
});

function isObject$1(something) {
  return typeof something === 'object' && something !== null;
}

const appTypes = ['drupal', 'wordpress', 'magento', 'other'];
function getProjectConfiguration(burstYaml, gitlabYaml, getPathFromDir) {
  const burstConfig = yaml.safeLoad(burstYaml || '{}');
  const gitlabConfig = yaml.safeLoad(gitlabYaml || '{}');

  if (!isObject$1(burstConfig)) {
    throw new Error('The burst.yaml is invalid. Please export an object.');
  }

  if (!isObject$1(gitlabConfig)) {
    throw new Error('The .gitlab-ci.yml file is invalid. The contents should be an object.');
  }

  const apps = isObject$1(burstConfig.apps) ? Object.entries(burstConfig.apps).map(([name, app]) => {
    if (!isObject$1(app)) {
      throw new Error(`App "${name}" should be an object.`);
    }

    let type = 'other';

    if (typeof app.type !== 'undefined') {
      if (!isAppType(app.type)) {
        throw new Error(`The type of "${name}" should be any of: ${appTypes.join(', ')}.`);
      }

      ({
        type
      } = app);
    } else if (isAppType(name)) {
      type = name;
    }

    let dir = name;

    if (typeof app.dir === 'string') {
      ({
        dir
      } = app);

      if (app.dir === '__legacy__project_root__') {
        dir = undefined;
      }
    }

    const hosting = (typeof app.hosting === 'undefined' ? [] : Array.isArray(app.hosting) ? app.hosting : [app.hosting]).map(h => {
      if (!isObject$1(h)) {
        throw new Error(`The hosting of ${name} should be an object or an array of objects.`);
      }

      if (h.type !== 'platform' && h.type !== 'heroku') {
        throw new Error(`Hosting of "${name}" has an unknown type. Only "platform" and "heroku" are currently allowed.`);
      }

      if (typeof h.id !== 'string') {
        throw new Error(`Hosting "${h.type}" of "${name}" does not have an id provided.`);
      }

      return {
        type: h.type,
        id: h.id
      };
    });
    const path = getPathFromDir(dir);
    return {
      name,
      type,
      dir,
      path,
      disableLinting: !!app.disableLinting,
      hosting
    };
  }) : [];

  if (typeof burstConfig.apps !== 'undefined' && !apps.length) {
    throw new Error("The 'apps' property in the burst.yaml should be an object with one or more keys.");
  }

  const usesProjectCiTemplate = Array.isArray(gitlabConfig.include) && gitlabConfig.include.some(i => isObject$1(i) && i.project === 'burstdigital/utils/burst-devtools' && i.file === '/ci-templates/project.yml');
  const vars = isObject$1(gitlabConfig.variables) ? gitlabConfig.variables : {};
  return {
    apps,
    usesProjectCiTemplate,
    deployEnabled: variableFlag(vars, 'BURST_DEPLOY', true),
    lintEnabled: variableFlag(vars, 'BURST_LINT', usesProjectCiTemplate),
    lintStylesEnabled: variableFlag(vars, 'BURST_LINT_STYLES', usesProjectCiTemplate),
    lintPhpEnabled: variableFlag(vars, 'BURST_LINT_PHP', usesProjectCiTemplate)
  };
}

function variableFlag(variables, variableName, fallback) {
  const variable = variables[variableName];

  if (typeof process.env[variableName] !== 'undefined' && process.env[variableName] !== variable) {
    throw new Error(`It looks like there exists an environment variable with the name of ${variableName}. You should not set this environment variable yourself. It should only be present in the 'variables' section in the .gitlab-ci.yml file. This way, the configuration is consistent for everyone. The .gitlab-ci.yml file is also read when using the Burst CLI locally.`);
  }

  if (typeof variable === 'undefined') return fallback;
  if (variable === 'disable') return false;
  if (variable === 'enable') return true;
  throw new Error(`The variable ${variableName} defined in .gitlab-ci.yml should be 'enable' or 'disable'. ` + `If you remove the variable, it will default to '${fallback ? 'enable' : 'disable'}'.`);
}

function isAppType(something) {
  return typeof something === 'string' && appTypes.includes(something);
}

// CONVERT_TO_STRING: true  -> String#at
// CONVERT_TO_STRING: false -> String#codePointAt
var stringAt = function (that, pos, CONVERT_TO_STRING) {
  var S = String(requireObjectCoercible(that));
  var position = toInteger(pos);
  var size = S.length;
  var first, second;
  if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
  first = S.charCodeAt(position);
  return first < 0xD800 || first > 0xDBFF || position + 1 === size
    || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
      ? CONVERT_TO_STRING ? S.charAt(position) : first
      : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
};

// `AdvanceStringIndex` abstract operation
// https://tc39.github.io/ecma262/#sec-advancestringindex
var advanceStringIndex = function (S, index, unicode) {
  return index + (unicode ? stringAt(S, index, true).length : 1);
};

// `RegExp.prototype.flags` getter implementation
// https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags
var regexpFlags = function () {
  var that = anObject(this);
  var 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;
};

var nativeExec = RegExp.prototype.exec;
// This always refers to the native implementation, because the
// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
// which loads this file before patching the method.
var nativeReplace = String.prototype.replace;

var patchedExec = nativeExec;

var UPDATES_LAST_INDEX_WRONG = (function () {
  var re1 = /a/;
  var re2 = /b*/g;
  nativeExec.call(re1, 'a');
  nativeExec.call(re2, 'a');
  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
})();

// nonparticipating capturing group, copied from es5-shim's String#split patch.
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;

var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;

if (PATCH) {
  patchedExec = function exec(str) {
    var re = this;
    var lastIndex, reCopy, match, i;

    if (NPCG_INCLUDED) {
      reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re));
    }
    if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;

    match = nativeExec.call(re, str);

    if (UPDATES_LAST_INDEX_WRONG && match) {
      re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
    }
    if (NPCG_INCLUDED && match && match.length > 1) {
      // Fix browsers whose `exec` methods don't consistently return `undefined`
      // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
      nativeReplace.call(match[0], reCopy, function () {
        for (i = 1; i < arguments.length - 2; i++) {
          if (arguments[i] === undefined) match[i] = undefined;
        }
      });
    }

    return match;
  };
}

var regexpExec = patchedExec;

// `RegExpExec` abstract operation
// https://tc39.github.io/ecma262/#sec-regexpexec
var regexpExecAbstract = function (R, S) {
  var exec = R.exec;
  if (typeof exec === 'function') {
    var result = exec.call(R, S);
    if (typeof result !== 'object') {
      throw TypeError('RegExp exec method returned something other than an Object or null');
    }
    return result;
  }

  if (classofRaw(R) !== 'RegExp') {
    throw TypeError('RegExp#exec called on incompatible receiver');
  }

  return regexpExec.call(R, S);
};

var SPECIES$3 = wellKnownSymbol('species');

var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
  // #replace needs built-in support for named groups.
  // #match works fine because it just return the exec results, even if it has
  // a "grops" property.
  var re = /./;
  re.exec = function () {
    var result = [];
    result.groups = { a: '7' };
    return result;
  };
  return ''.replace(re, '$<a>') !== '7';
});

// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
// Weex JS has frozen built-in prototypes, so use try / catch wrapper
var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
  var re = /(?:)/;
  var originalExec = re.exec;
  re.exec = function () { return originalExec.apply(this, arguments); };
  var result = 'ab'.split(re);
  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
});

var fixRegexpWellKnownSymbolLogic = function (KEY, length, exec, sham) {
  var SYMBOL = wellKnownSymbol(KEY);

  var DELEGATES_TO_SYMBOL = !fails(function () {
    // String methods call symbol-named RegEp methods
    var O = {};
    O[SYMBOL] = function () { return 7; };
    return ''[KEY](O) != 7;
  });

  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
    // Symbol-named RegExp methods call .exec
    var execCalled = false;
    var re = /a/;
    re.exec = function () { execCalled = true; return null; };

    if (KEY === 'split') {
      // RegExp[@@split] doesn't call the regex's exec method, but first creates
      // a new one. We need to return the patched regex when creating the new one.
      re.constructor = {};
      re.constructor[SPECIES$3] = function () { return re; };
    }

    re[SYMBOL]('');
    return !execCalled;
  });

  if (
    !DELEGATES_TO_SYMBOL ||
    !DELEGATES_TO_EXEC ||
    (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
    (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
  ) {
    var nativeRegExpMethod = /./[SYMBOL];
    var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
      if (regexp.exec === regexpExec) {
        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
          // The native String method already delegates to @@method (this
          // polyfilled function), leasing to infinite recursion.
          // We avoid it by directly calling the native @@method method.
          return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
        }
        return { done: true, value: nativeMethod.call(str, regexp, arg2) };
      }
      return { done: false };
    });
    var stringMethod = methods[0];
    var regexMethod = methods[1];

    redefine(String.prototype, KEY, stringMethod);
    redefine(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 regexMethod.call(string, this, arg); }
      // 21.2.5.6 RegExp.prototype[@@match](string)
      // 21.2.5.9 RegExp.prototype[@@search](string)
      : function (string) { return regexMethod.call(string, this); }
    );
    if (sham) hide(RegExp.prototype[SYMBOL], 'sham', true);
  }
};

var max$1 = Math.max;
var min$2 = Math.min;
var floor$1 = Math.floor;
var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g;
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g;

var maybeToString = function (it) {
  return it === undefined ? it : String(it);
};

// @@replace logic
fixRegexpWellKnownSymbolLogic(
  'replace',
  2,
  function (REPLACE, nativeReplace, maybeCallNative) {
    return [
      // `String.prototype.replace` method
      // https://tc39.github.io/ecma262/#sec-string.prototype.replace
      function replace(searchValue, replaceValue) {
        var O = requireObjectCoercible(this);
        var replacer = searchValue == undefined ? undefined : searchValue[REPLACE];
        return replacer !== undefined
          ? replacer.call(searchValue, O, replaceValue)
          : nativeReplace.call(String(O), searchValue, replaceValue);
      },
      // `RegExp.prototype[@@replace]` method
      // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace
      function (regexp, replaceValue) {
        var res = maybeCallNative(nativeReplace, regexp, this, replaceValue);
        if (res.done) return res.value;

        var rx = anObject(regexp);
        var S = String(this);

        var functionalReplace = typeof replaceValue === 'function';
        if (!functionalReplace) replaceValue = String(replaceValue);

        var global = rx.global;
        if (global) {
          var fullUnicode = rx.unicode;
          rx.lastIndex = 0;
        }
        var results = [];
        while (true) {
          var result = regexpExecAbstract(rx, S);
          if (result === null) break;

          results.push(result);
          if (!global) break;

          var matchStr = String(result[0]);
          if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
        }

        var accumulatedResult = '';
        var nextSourcePosition = 0;
        for (var i = 0; i < results.length; i++) {
          result = results[i];

          var matched = String(result[0]);
          var position = max$1(min$2(toInteger(result.index), S.length), 0);
          var captures = [];
          // NOTE: This is equivalent to
          //   captures = result.slice(1).map(maybeToString)
          // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
          // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
          // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
          for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));
          var namedCaptures = result.groups;
          if (functionalReplace) {
            var replacerArgs = [matched].concat(captures, position, S);
            if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
            var replacement = String(replaceValue.apply(undefined, replacerArgs));
          } else {
            replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
          }
          if (position >= nextSourcePosition) {
            accumulatedResult += S.slice(nextSourcePosition, position) + replacement;
            nextSourcePosition = position + matched.length;
          }
        }
        return accumulatedResult + S.slice(nextSourcePosition);
      }
    ];

    // https://tc39.github.io/ecma262/#sec-getsubstitution
    function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
      var tailPos = position + matched.length;
      var m = captures.length;
      var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
      if (namedCaptures !== undefined) {
        namedCaptures = toObject(namedCaptures);
        symbols = SUBSTITUTION_SYMBOLS;
      }
      return nativeReplace.call(replacement, symbols, function (match, ch) {
        var capture;
        switch (ch.charAt(0)) {
          case '$': return '$';
          case '&': return matched;
          case '`': return str.slice(0, position);
          case "'": return str.slice(tailPos);
          case '<':
            capture = namedCaptures[ch.slice(1, -1)];
            break;
          default: // \d\d?
            var n = +ch;
            if (n === 0) return match;
            if (n > m) {
              var f = floor$1(n / 10);
              if (f === 0) return match;
              if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
              return match;
            }
            capture = captures[n - 1];
        }
        return capture === undefined ? '' : capture;
      });
    }
  }
);

class HostingProvider {
  constructor(config) {
    this.config = config;
  }

  /**
   * The number of deploy target levels this hosting provider supports. For example,
   * Platform.sh supports 2 special ones: 'Production', 'Staging'.
   *
   * Heroku only has one environment per app, so there it's only 1.
   */
  static getAvailableDeployTargetLevels() {
    return 1;
  }

}
class HostingProviderEnvironment {
  /**
   * The deploy target level for this application. Should be set using the
   * 'deployTargetLevels' option. This should never be the same or higher then the passed
   * option.
   *
   * The lower the number, the more important the deploy target is.
   */
  getDeployTarget() {
    return DeployTarget.Other;
  }

  isSuggested() {
    return false;
  }

  isActive() {
    return false;
  }

}

const PlatformClient = require('platformsh-client').default;

class Platform extends HostingProvider {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "name", 'platform');

    _defineProperty(this, "isEnterpriseProject", false);

    _defineProperty(this, "platformProject", null);
  }

  isSameAs(config) {
    return config.id === this.config.id;
  }

  getDisplayName() {
    if (this.platformProject) return this.platformProject.title;
    return this.config.id;
  }

  getLink() {
    return `https://console.platform.sh/burst/${encodeURIComponent(this.config.id)}`;
  }

  static getAvailableDeployTargetLevels() {
    return 3;
  }

  static async getClient() {
    if (this.client) return this.client;

    if (process.env.PLATFORMSH_CLI_TOKEN) {
      this.client = new PlatformClient({
        api_token: process.env.PLATFORMSH_CLI_TOKEN
      });
    } else {
      this.client = new PlatformClient({
        access_token: await getPlatformToken()
      });
    }

    return this.client;
  }

  async getPlatformProject() {
    if (this.platformProject) return this.platformProject;
    const platformClient = await Platform.getClient();
    this.platformProject = await platformClient.getProject(this.config.id);
    return this.platformProject;
  }

  async getPossibleEnvs(config) {
    const spinner = ora().start(`Getting platform environments for project ${this.config.id}.`);
    const platformProject = await this.getPlatformProject();
    const platformEnvs = await platformProject.getEnvironments();
    this.isEnterpriseProject = platformEnvs.some(e => e.id === 'production' && e.deployment_target === 'enterprise');
    spinner.stop();
    const instances = [];
    instances.push(...platformEnvs.map( // eslint-disable-next-line no-use-before-define
    e => new PlatformEnvironment(this, e, config, instances)));

    if (!instances.find(i => i.isSuggested())) {
      instances.push( // eslint-disable-next-line no-use-before-define
      new PlatformEnvironment(this, {
        new: true
      }, config, instances));
    }

    return instances;
  }

  async getGitUrl() {
    return (await this.getPlatformProject()).getGitUrl();
  }

}

_defineProperty(Platform, "client", void 0);

class PlatformEnvironment extends HostingProviderEnvironment {
  constructor(project, model, config, environments) {
    super();
    this.project = project;
    this.config = config;
    this.environments = environments;

    _defineProperty(this, "model", void 0);

    if (model.new) {
      const target = Object.entries(this.branchNamesWithTargets()).find(([, t]) => t === config.suggestedTarget);
      const id = target ? target[0] : config.suggestedName;

      if (!id) {
        throw new Error(`Not a valid config was passed. Either pass a 'suggestedTarget' or ` + `'suggestedName'.\n Passed now: \n${JSON.stringify(config)}`);
      }

      this.model = _objectSpread({}, model, {
        id
      });
    } else {
      this.model = model;
    }
  }

  getDisplayName() {
    const {
      id
    } = this.model;

    if (this.project.isEnterpriseProject) {
      if (id === 'production') return 'Production (enterprise)';
      if (id === 'staging') return 'Staging (enterprise)';
      if (id === 'master') return 'Mirror';
    }

    if (id === 'master') return 'Production';
    if (id === 'staging') return 'Staging (will be deleted in the future)';
    if (id === 'mirror') return 'Mirror';
    if (this.hasOptedOutResync()) return `${id} [keep data]`;
    if (this.hasOptedOutDeactvation()) return `${id} [keep]`;
    return id;
  }

  branchNamesWithTargets() {
    if (this.project.isEnterpriseProject) {
      return {
        production: DeployTarget.Production,
        staging: DeployTarget.Staging,
        master: DeployTarget.Staging
      };
    }

    return {
      master: DeployTarget.Production,
      staging: DeployTarget.Staging,
      mirror: DeployTarget.Staging
    };
  }

  getDeployTarget() {
    const {
      id
    } = this.model;

    if (this.branchNamesWithTargets()[id]) {
      return this.branchNamesWithTargets()[id];
    }

    return DeployTarget.Dynamic;
  }

  isSuggested() {
    return this.config.suggestedTarget === this.getDeployTarget() || this.config.suggestedName === this.model.id || // We also check if there is a slugified version, because previously we
    // used the branch slug from the Gitlab CI env variables instead of the
    // real branch name. This way we can still deploy to the 'old' name.
    !!this.config.suggestedName && slugify(this.config.suggestedName).replace(/-+/g, '') === slugify(this.model.id).replace(/-+/g, '');
  }

  isActive() {
    if (this.model.new) return false; // There is a bug in the Platform.sh client, that marks 'dirty' environments
    // as inactive. An environment is dirty when someting is happening on that
    // env (deploy, backup, activation, deactivation). Most of the time when an
    // env is dirty, it's active. Only if there is an #activate _link available,
    // it's not.

    if (this.model.is_dirty) {
      return !this.model.hasLink('#activate');
    }

    return this.model.isActive();
  }

  hasOptedOutDeactvation() {
    return this.hasOptedOutResync() || !this.model.new && this.model.title.endsWith('[keep]');
  }

  hasOptedOutResync() {
    return !this.model.new && this.model.title.endsWith('[keep data]');
  }

  canBeResyncedOrDeactivated() {
    return !this.model.new && !['master', 'production', 'mirror'].includes(this.model.id) && !(this.project.isEnterpriseProject && this.model.id === 'staging') && this.isActive();
  }

  async deploy({
    deployOnlySubdirectory
  }) {
    if (!this.project.platformProject) {
      throw Error('Not possible.');
    }

    const newParent = this.project.isEnterpriseProject || this.getDeployTarget() !== DeployTarget.Dynamic ? 'master' : 'mirror';
    let resync = false;

    if (this.canBeResyncedOrDeactivated() && !this.hasOptedOutResync() && !process.env.CI) {
      ({
        resync
      } = await inquirer.prompt([{
        type: 'confirm',
        name: 'resync',
        message: `💣  Do you want to use fresh data (and remove the database on this environment)?`
      }]));
    }

    if (this.canBeResyncedOrDeactivated() && !this.hasOptedOutResync() && !resync) {
      console.log('\n\n💣');
      console.log('💣  WARNING');
      console.log('💣');
      console.log('💣  In the future, a deploy will automatically use fresh data.');
      console.log('💣  This means that the database will be removed.');
      console.log('💣');
      console.log(`💣  If you want to opt out, add ${chalk.cyan('[keep data]')} to the name of the environment.`);
      console.log('💣\n\n');
    }

    console.log(`\n\n${chalk.bgYellow.black('  DEPLOY START  ')}  Deploying to Platform.sh project ${this.project.getDisplayName()} branch ${this.model.id}\n\n`);

    try {
      // If we want to resync, we first deactivate the environment.
      if (resync && !this.model.new) {
        console.log('Creating a backup (just to be sure)...');

        try {
          await this.model.backup();
        } catch (e) {
          ({
            resync
          } = await inquirer.prompt([{
            type: 'confirm',
            name: 'resync',
            message: `💣  Creating a backup isn't possible at the moment. Continue?`
          }]));
        }
      }

      if (resync && !this.model.new) {
        console.log('De-activating environment...');
        await this.model.runLongOperation('deactivate', 'POST', undefined);
        await this.model.refresh();
      } // If the environment doesn't exist yet, we first need to push. This creates an inactive environment.


      let isPushed = false;

      if (this.model.new) {
        console.log('Creating new environment by pushing...');
        await this.push(deployOnlySubdirectory);
        isPushed = true;
        this.model = await this.project.platformProject.getEnvironment(encodeURIComponent(this.model.id));
      } // We make sure the title and parent are as expected.
      // If they aren't currently, we set them before deploying.


      let needsSave = false;
      const {
        title
      } = this.model;
      const newTitle = this.getDisplayName();

      if (title !== newTitle) {
        console.log(`The environment title is currently ${chalk.red(title)}. That will be changed to ${chalk.cyan(newTitle)}.`);
        this.model.title = newTitle;
        needsSave = true;
      }

      if (this.getDeployTarget() === DeployTarget.Dynamic) {
        if (this.model.parent !== newParent) {
          console.log(`The parent of the environment was ${chalk.red(this.model.parent)}. That will be changed to ${chalk.cyan(newParent)}.`);
          this.model.parent = newParent;
          needsSave = true;
        } // Check if the needed parent actually exists. If not, we should create it.
        // We do this by branching from the master. If it does exist but it's
        // inactive, we activate it.


        const p = this.environments.find(e => e.model.id === newParent);

        if (!p) {
          const m = this.environments.find(e => e.model.id === 'master');
          if (!m || m.model.new) throw new Error("The master envronment doesn't exist.");
          console.log('Creating parent environment...');
          await this.catchTooManyEnvironments(() => {
            if (m.model.new) throw new Error('Not possible.');
            return m.model.branch('Mirror', newParent);
          });
        } else if (!p.isActive()) {
          console.log('Activating parent environment...');
          if (p.model.new) throw new Error('Not possible.');
          await this.activateSafely(p.model);
        }
      }

      if (needsSave) {
        await this.model.update(this.model.data);
        console.log('Updated environment information.');
      } // We push the code to Platform now. Except when we did that to create an inactive
      // environment.


      if (!isPushed) {
        await this.push(deployOnlySubdirectory);
      } // We use our own isActive instead of Platform.sh's one, because the
      // Platform.sh one is buggy.


      if (!this.isActive()) {
        await this.activateSafely(this.model);
        console.log('\n\nThe environment is being activated.');
        console.log('Follow the progress here: ');
        console.log(`${this.project.getLink()}/${encodeURIComponent(this.model.id)}`);
      }

      console.log(`\n\n${chalk.bgGreen.black('  DEPLOY DONE  ')}  Deploy successfully completed.\n\n`);
    } catch (e) {
      console.error(chalk.bgRed('  DEPLOY FAILED  '));
      throw e;
    }
  }

  async push(dir) {
    return push((await this.project.getGitUrl()), this.model.id, {
      dir
    });
  }

  getUrls() {
    if (this.model.new) return [];
    const urls = this.model.getRouteUrls();
    return urls.filter(u => !u.startsWith('http://'));
  }

  async activateSafely(model, retry = 0) {
    await this.catchTooManyEnvironments(async () => {
      try {
        await model.runLongOperation('activate', 'POST', undefined);
      } catch (error) {
        // Sometimes, Platform.sh introduces a bug where the environment will appear
        // activated while it's not. This happens when you try to activate an
        // environment, but an error returns. The environment is then not really
        // activated, but it does show up in Platform.sh as activated. In this case, it
        // needs to be de-activated and activated again. See also issue #65.
        if (error.message !== 'Access was denied to this resource.' && retry < 5) {
          throw error;
        }

        console.log("Platform.sh acts like this environment was already activated, but it isn't. This is a bug in Platform.sh.");
        console.log('De-activating to recover from bug...');
        await model.refresh();
        await model.runLongOperation('deactivate', 'POST', undefined);
        console.log('Activating again...');
        await model.refresh();
        await this.activateSafely(model, retry + 1);
      }
    });
  }

  async catchTooManyEnvironments(action) {
    try {
      return await action();
    } catch (error) {
      if (error.message !== 'This action would raise the count of environments over its limit.') {
        throw error;
      }

      console.log(chalk.red('\n\nThere are not enough environments available.\n\n'));
      const envsThatCanBeDeleted = this.environments.filter(env => env.canBeResyncedOrDeactivated() && !env.hasOptedOutDeactvation());

      if (!envsThatCanBeDeleted.length) {
        throw new Error('There are no environments that can be deactivated. Please upgrade the number of available environments.');
      }

      if (process.env.CI) {
        throw new Error('Use the Burst CLI locally to choose an environment to remove.');
      }

      const {
        envToDeactivate
      } = await inquirer.prompt([{
        type: 'list',
        name: 'envToDeactivate',
        message: '💣  What environment do you want to deactivate? (we will create a backup before deactivation, just to be sure)',
        choices: envsThatCanBeDeleted.map(env => ({
          name: env.getDisplayName(),
          value: env
        }))
      }]);
      if (envToDeactivate.model.new) throw new Error('Not possible');
      await envToDeactivate.model.backup();
      await envToDeactivate.model.deactivate(); // Make sure that if there is a next round of deactivations, that it can't be
      // selected again.

      await envToDeactivate.model.refresh();
      return this.catchTooManyEnvironments(() => action());
    }
  }

}

async function getPlatformToken() {
  const {
    stdout: res
  } = await execa('platform', ['auth:token'], {
    preferLocal: false
  });

  if (res.length === 0) {
    throw new Error("The Platform access_token token can't be fetched from the Platform CLI.");
  }

  return res;
}

class Heroku extends HostingProvider {
  constructor(config) {
    super(config);

    if (typeof config.id !== 'string') {
      throw new Error('Hosting config not okay.');
    }
  }

  getDisplayName() {
    return this.config.id;
  }

  getLink() {
    return '';
  }

  isSameAs(config) {
    return config.id === this.config.id;
  }

  async getPossibleEnvs() {
    // eslint-disable-next-line no-use-before-define
    return [new HerokuApp(this)];
  }

}
class HerokuApp extends HostingProviderEnvironment {
  constructor(hostingProvider) {
    super();
    this.hostingProvider = hostingProvider;
  }

  getDisplayName() {
    return this.hostingProvider.getDisplayName();
  }

  async deploy() {
    throw new Error('Not possible to deploy a Heroku application yet.');
  }

  getUrls() {
    return [];
  }

}

const hostingProviders = {
  platform: Platform,
  heroku: Heroku
};

let DeployTarget;

(function (DeployTarget) {
  DeployTarget["Production"] = "production";
  DeployTarget["Staging"] = "staging";
  DeployTarget["Dynamic"] = "dynamic";
  DeployTarget["Other"] = "other";
})(DeployTarget || (DeployTarget = {}));

function isFile(path) {
  try {
    return fs.statSync(path).isFile();
  } catch (_unused) {
    return false;
  }
}

const burstYamlPath = `${repoRoot}/burst.yaml`;
const gitlabYamlPath = `${repoRoot}/.gitlab-ci.yml`;
const projectConfig = getProjectConfiguration(isFile(burstYamlPath) ? fs.readFileSync(burstYamlPath, 'utf8') : null, isFile(gitlabYamlPath) ? fs.readFileSync(gitlabYamlPath, 'utf8') : null, dir => {
  const path = dir ? `${repoRoot}/${dir}` : repoRoot;

  try {
    const isDir = fs.statSync(path).isDirectory();

    if (!isDir) {
      throw new Error(`The location ${path} was found, but it's not a directory.`);
    }

    return path;
  } catch (e) {
    console.log();
    console.log();
    console.log(chalk.red("Your burst.yaml file references a path that doesn't exist:"));
    console.log(chalk.yellow(path));
    console.log();
    console.log();
    console.log(chalk.red('Please fix the burst.yaml file in the root.'));
    console.log();
    console.log();
    throw e;
  }
});

class ProjectInfo {
  /**
   * This gets all different hosting options there are.
   *
   * Every hosting option can deploy one or more apps.
   * Every hosting option can have multiple deploy targets (production for
   * example). These deploy targets can be different per app.
   */
  async getHostingProvidersWithApps() {
    const hostingProvidersWithApps = [];
    projectConfig.apps.forEach(app => {
      app.hosting.forEach(hc => {
        const {
          type
        } = hc,
              hostingConfig = _objectWithoutProperties(hc, ["type"]); // Verify that there is a class for this hosting type.


        const ThisHostingProvider = hostingProviders[type];

        if (!ThisHostingProvider) {
          throw new Error(`There is no hosting provider with the name '${type}' supported.`);
        } // Check if there is a hosting with the same type and id.
        // If there is, we just need to add the app.


        const existingHosting = hostingProvidersWithApps.find(h => h.hostingProvider instanceof ThisHostingProvider && h.hostingProvider.isSameAs(hostingConfig));

        if (existingHosting) {
          existingHosting.apps.push(app);
        } else {
          hostingProvidersWithApps.push({
            hostingProvider: new ThisHostingProvider(hostingConfig),
            apps: [app]
          });
        }
      });
    });
    return hostingProvidersWithApps;
  }
  /**
   * This gets all hosting options, and groups them on the combination of apps.
   *
   * The apps will be the same for all hostings in a collection, but the deploy
   * type can be different per app.
   */


  async getHostingProvidersByAppCominations() {
    const hostings = await this.getHostingProvidersWithApps();
    const hostingsGrouped = lodash.groupBy(hostings, hosting => hosting.apps.map(a => a.name).sort().join('__'));
    return Object.values(hostingsGrouped).map(hostingsGroup => ({
      apps: hostingsGroup[0].apps,
      hostingProviders: hostingsGroup.map(hosting => hosting.hostingProvider)
    }));
  }

}

let projectInfo;
function getProjectInfo() {
  if (projectInfo) return projectInfo;
  projectInfo = new ProjectInfo();
  return projectInfo;
}

const composerHelperDir = path$1__default.join(__dirname, '../composer-helper');
function usePHPCS(allFiles, fix) {
  const files = React.useMemo(() => allFiles.filter(f => // Keep this in sync with drupal_ruleset.xml.
  f.path.endsWith('.php') || f.path.endsWith('.module') || f.path.endsWith('.theme') || f.path.endsWith('.inc') || f.path.endsWith('.install')), [allFiles]);
  const composerInstalled = useComposerHelper(files.length > 0 && projectConfig.lintPhpEnabled);
  const fileChunksPerStandard = React.useMemo(() => {
    const filesPerStandard = lodash.groupBy(files, file => {
      if (file.app) {
        if (file.app.type === 'drupal') {
          return `${composerHelperDir}/drupal_ruleset.xml`;
        }

        if (file.app.type === 'magento') {
          return `${composerHelperDir}/magento_ruleset.xml`;
        }

        if (file.app.type === 'wordpress') {
          return `${composerHelperDir}/wordpress_ruleset.xml`;
        }
      }

      return `${composerHelperDir}/other_ruleset.xml`;
    });
    return lodash.flatten(Object.entries(filesPerStandard).map(([standard, fs]) => lodash.chunk(fs, 20).map(fc => ({
      chunkFiles: fc,
      standard
    }))));
  }, [files]);
  const [results, setResults] = React.useState({});
  const [filesFixed, setFilesFixed] = React.useState(0);
  const [filesWithoutFixes, setFilesWithoutFixes] = React.useState(0);
  React.useEffect(() => {
    if (!composerInstalled) return;
    const queue = new PQueue({
      concurrency: 20
    });
    queue.addAll(fileChunksPerStandard.map(({
      chunkFiles,
      standard
    }) => async () => {
      const absolutePaths = chunkFiles.map(f => f.absolutePath); // The arguments we need to pass to the phpcs and phpcbf commands.

      const args = [...chunkFiles.map(f => f.absolutePath), '-q', `--standard=${standard}`, ...(standard === `${composerHelperDir}/wordpress_ruleset.xml` ? ['--runtime-set', 'installed_paths', `${composerHelperDir}/vendor/wp-coding-standards/wpcs`] : [])]; // We first execute phpcs. This way we know how many errors there are.

      const result = parsePhpcsResult((await execa(`${composerHelperDir}/vendor/bin/phpcs`, [...args, '--report=json'], {
        reject: false,
        preferLocal: false
      })).stdout, absolutePaths); // Sometimes, files aren't linted. We should still add them to the
      // result, so we won't wait forever for these files to be linted.

      absolutePaths.forEach(f => {
        if (!result.files[f]) result.files[f] = {
          errors: 0,
          warnings: 0,
          messages: []
        };
      });
      setResults(r => _objectSpread({}, r, result.files)); // If there are auto-fixable errors or warnings, we can fix them.

      if (fix) {
        if (result.totals.fixable > 0) {
          await execa(`${composerHelperDir}/vendor/bin/phpcbf`, args, {
            reject: false,
            preferLocal: false
          });
          setFilesFixed(f => f + chunkFiles.length);
        } else {
          setFilesWithoutFixes(f => f + chunkFiles.length);
        }
      }
    }));
    return () => queue.clear();
  }, [composerInstalled, fileChunksPerStandard, fix]); // If there are, create nice error objects.

  const errors = lodash.flatten(Object.entries(results).map(([filename, r]) => r.messages.filter(message => fix ? message.type === 'ERROR' && !message.fixable : message.type === 'ERROR' || message.fixable).map(message => ({
    linter: 'PHPCS',
    filename,
    autoFixable: message.fixable,
    message: message.message,
    rule: message.source,
    sourceLocation: {
      start: {
        line: message.line,
        column: message.column
      }
    }
  }))));

  if (composerInstalled === false) {
    errors.push({
      linter: 'PHPCS',
      filename: 'Composer dependencies',
      autoFixable: false,
      message: "The composer dependencies couldn't be installed. PHP files can't be linted."
    });
  }

  const filesLinted = Object.keys(results).length;
  const done = !projectConfig.lintPhpEnabled || composerInstalled === false || filesLinted === files.length && (!fix || files.length - filesFixed - filesWithoutFixes === 0);
  return {
    errors,
    files,
    filesLinted,
    filesFixed,
    filesWithFixes: fix ? files.length - filesWithoutFixes : 0,
    done
  };
}

function parsePhpcsResult(result, pathsLinted) {
  try {
    return JSON.parse(result);
  } catch (error) {
    const resultJson = {
      files: {},
      totals: {
        errors: pathsLinted.length,
        warnings: 0,
        fixable: 0
      }
    };
    pathsLinted.forEach(p => {
      resultJson.files[p] = {
        errors: 1,
        warnings: 0,
        messages: [{
          message: result,
          source: '',
          severity: 9999,
          fixable: false,
          type: 'ERROR',
          line: 0,
          column: 0
        }]
      };
    });
    return resultJson;
  }
}

function useComposerHelper(install) {
  const [installCompleted, setInstallCompleted] = React.useState();
  React.useEffect(() => {
    if (!install) return;
    const composerInstall = execa('composer', ['install', '--no-interaction'], {
      cwd: composerHelperDir,
      reject: false,
      preferLocal: false
    });
    composerInstall.then(a => {
      if (a.killed) return;
      if (a.failed) setInstallCompleted(false);
      setInstallCompleted(true);
    });
    return () => composerInstall.kill();
  }, [install]);
  return installCompleted;
}

const readFileAsync = util.promisify(fs.readFile);
const writeFileAsync = util.promisify(fs.writeFile);
function usePrettier(allFiles, fix) {
  const prettier = usePrettierWorker();
  const [filesInfo, setFilesInfo] = React.useState({});
  React.useEffect(() => {
    const queue = new PQueue({
      concurrency: 10
    });
    queue.addAll(allFiles.map(file => async () => {
      // We don't want to test Drupal configuration exports.
      if (/\/config\/[\w/]+\/[\w.-]+\.yml$/.test(file.absolutePath)) {
        setFilesInfo(i => _objectSpread({}, i, {
          [file.absolutePath]: {
            ignored: true,
            inferredParser: null
          }
        }));
        return;
      }

      const fileInfo = await prettier.getFileInfo(file.absolutePath);
      setFilesInfo(i => _objectSpread({}, i, {
        [file.absolutePath]: fileInfo
      }));
    }));
    return () => queue.clear();
  }, [allFiles, prettier]);
  const filesChecked = Object.keys(filesInfo).length;
  const files = React.useMemo(() => Object.entries(filesInfo).filter(([, result]) => result.inferredParser).map(([filename, result]) => ({
    filename,
    inferredParser: result.inferredParser
  })), [filesInfo]);
  const [results, setResults] = React.useState({});
  const [errorResults, setErrorResults] = React.useState({});
  React.useEffect(() => {
    if (filesChecked < allFiles.length) return;
    const queue = new PQueue({
      concurrency: 10
    });
    queue.addAll(files.map(({
      filename,
      inferredParser
    }) => async () => {
      // Create the default prettier config.
      const filePrettierConfig = _objectSpread({}, prettierConfig$1, {
        parser: inferredParser
      }); // Some files have a special prettier config.


      if (filename.endsWith('composer.lock') || filename.endsWith('composer.json')) {
        filePrettierConfig.parser = 'json-stringify';
        filePrettierConfig.tabWidth = 4;
      }

      try {
        // Get the contents of the file.
        const fileContents = await readFileAsync(filename, {
          encoding: 'utf8'
        }); // Format the files, so we can check if they are different.

        const newFileContents = await prettier.format(fileContents, filePrettierConfig); // If the file contents didn't change, nothing was fixed.

        const correct = fileContents === newFileContents; // If something was fixed, write the results back to disk.

        if (fix && !correct) {
          await writeFileAsync(filename, newFileContents, {
            encoding: 'utf8'
          });
        }

        setResults(r => _objectSpread({}, r, {
          [filename]: correct
        }));
      } catch (e) {
        setErrorResults(r => _objectSpread({}, r, {
          [filename]: e.message || e.toString()
        }));
      }
    }));
    return () => queue.clear();
  }, [allFiles.length, files, filesChecked, fix, prettier]);
  const filesToLint = Object.keys(files).length;
  const linted = Object.keys(results).length + Object.keys(errorResults).length;
  const filesNotCorrect = Object.entries(results).filter(([, correct]) => !correct).map(([file]) => file);
  const errors = [...(fix ? [] : filesNotCorrect.map(f => ({
    linter: 'Prettier',
    filename: f,
    autoFixable: true,
    message: 'Not according to Prettier styling.'
  }))), ...Object.entries(errorResults).map(([filename, error]) => ({
    linter: 'Prettier',
    filename,
    autoFixable: false,
    message: `Error while linting with Prettier: ${error}`
  }))];
  return {
    filesChecked,
    filesToLint,
    linted,
    done: allFiles.length === filesChecked && linted === filesToLint,
    errors,
    fixed: fix ? filesNotCorrect : [],
    filesNotCorrect
  };
}

function useStylelint(allFiles, fix) {
  const [lintResults, setLintResults] = React.useState();
  const [fixResults, setFixResults] = React.useState();
  const filesLintable = React.useMemo(() => projectConfig.lintStylesEnabled ? allFiles.filter(({
    filename: f
  }) => !f.endsWith('.d.ts') && (f.endsWith('.js') || f.endsWith('.jsx') || f.endsWith('.ts') || f.endsWith('.tsx'))) : [], [allFiles]);
  const filesFixable = React.useMemo(() => projectConfig.lintStylesEnabled ? allFiles.filter(({
    filename: f
  }) => f.endsWith('.css') || f.endsWith('.sass') || f.endsWith('.scss') || f.endsWith('.less')) : [], [allFiles]);
  const filesForLintRun = React.useMemo(() => fix ? filesLintable : [...filesLintable, ...filesFixable], [filesFixable, filesLintable, fix]);
  const filesForFixRun = React.useMemo(() => fix ? filesFixable : [], [filesFixable, fix]);
  React.useEffect(() => {
    if (!filesForLintRun.length) return;
    stylelint.lint({
      configFile: require.resolve('@burst/stylelint-config'),
      files: filesForLintRun.map(f => f.absolutePath)
    }).then(r => setLintResults(r));
  }, [filesForLintRun]);
  React.useEffect(() => {
    if (!filesForFixRun.length) return;
    stylelint.lint({
      configFile: require.resolve('@burst/stylelint-config/pure'),
      files: filesForFixRun.map(f => f.absolutePath),
      fix: true
    }).then(() => // We need to lint a second time, because the autofixer disables
    // stylelint-disable comments. We only get the correct results if we
    // lint without fix: true.
    stylelint.lint({
      configFile: require.resolve('@burst/stylelint-config/pure'),
      files: filesForFixRun.map(f => f.absolutePath)
    })).then(r => setFixResults(r));
  }, [filesForFixRun]);
  const errors = [];
  [...(lintResults ? lintResults.results : []), ...(fixResults ? fixResults.results : [])].forEach(r => {
    errors.push(...[...r.parseErrors, ...r.warnings].map(e => ({
      linter: 'Stylelint',
      filename: r.source,
      autoFixable: false,
      message: e.text.replace(` (${e.line}:${e.column})`, '').replace(` (${e.rule})`, ''),
      rule: e.rule,
      sourceLocation: {
        start: {
          line: e.line,
          column: e.column
        }
      }
    })));
  });
  return {
    filesFixable,
    filesToLint: filesForFixRun.length + filesForLintRun.length,
    done: (!filesForLintRun.length || !!lintResults) && (!filesForFixRun.length || !!fixResults),
    errors
  };
}

const lintingFailed = new Error('ERRORS');
class LintCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'lint [files...]');

    _defineProperty(this, "description", 'Lint files in the current git repository.');

    _defineProperty(this, "options", [{
      flags: '-f, --fix',
      description: 'Fix linting errors automatically if possible.'
    }, {
      flags: '-v, --verbose',
      description: 'Show the source of every linting error.'
    }, {
      flags: '--summary',
      description: 'Show a list of errors and how many times they occur.'
    }, {
      flags: '--staged',
      description: 'Only lint staged files.'
    }]);
  }

  async action(filesToSearch, {
    fix,
    verbose,
    summary,
    staged
  }) {
    if (!projectConfig.lintEnabled) {
      console.log(chalk.underline('\n\n\nThe Burst linter is not enabled for this project.\n'));
      console.log('Is this a new project, or are you trying to add the linter');
      console.log('to a project that is not yet lint-compatible? Then you can');
      console.log("use the Gitlab CI Template to enable the linter. If that's");
      console.log('not possible, you can add to the .gitlab-ci.yml:\n');
      console.log(chalk.grey('variables:'));
      console.log(chalk.grey('  BURST_LINT: enable\n'));
      console.log('But using the Gitlab CI Template is preferred.\n\n');
      console.log(chalk.bold.yellow(`If this is a project where linting was enabled before, you\nprobabily only have to ${chalk.underline('merge from master')}!`));
      console.log('\n\nIf you have any questions, please ask Bart.\n\n');
      process.exit(1);
    }

    if (staged) {
      // eslint-disable-next-line global-require
      const lintStaged = require('lint-staged/src');

      if (!filesToSearch.length) {
        process.chdir(repoRoot);
      }

      lintStaged(console, `${__dirname}../../config/lint-staged.js`);
      return;
    }

    const a = ink.render(React__default.createElement(Lint, {
      paths: filesToSearch,
      fix: !!fix,
      verbose: !!verbose,
      summary: !!summary,
      staged: !!staged
    }));

    try {
      await a.waitUntilExit();
    } catch (e) {
      if (e.message !== 'ERRORS') throw e;
      process.exitCode = 1;
    } // @ts-ignore


    a.cleanup();
  }

}

function Lint(props) {
  const filePaths = useFilePaths(props.paths); // We want to exit with exit code 1 if there were no files found.

  useExit(!!filePaths && filePaths.length === 0, lintingFailed);

  if (!filePaths || !projectConfig.apps || !repoRoot) {
    return React__default.createElement(ink.Text, null, "Listing all files in this repository...");
  }

  if (filePaths.length === 0) {
    return React__default.createElement(ink.Text, null, "We found no files.");
  }

  const files = filePaths.map(path => ({
    path,
    absolutePath: `${repoRoot}/${path}`,
    filename: path$1.basename(path),
    app: projectConfig.apps.find(a => !!a.dir && path.startsWith(`${a.dir}/`)) || projectConfig.apps.find(a => !a.dir)
  })).filter(f => !f.app || !f.app.disableLinting);
  return React__default.createElement(Lint2, {
    files: files,
    verbose: props.verbose,
    fix: props.fix,
    repoRoot: repoRoot,
    summary: props.summary
  });
}

function Lint2(props) {
  const startTime = React.useMemo(() => new Date(), []);
  const eslint = useEslint(props.files, props.fix);
  const phpcs = usePHPCS(props.files, props.fix);
  const stylelint = useStylelint(props.files, props.fix);
  const prettierFiles = React.useMemo(() => props.files.filter(f => !eslint.files.includes(f) && !phpcs.files.includes(f) && !stylelint.filesFixable.includes(f)), [eslint.files, phpcs.files, props.files, stylelint.filesFixable]);
  const prettier = usePrettier(prettierFiles, props.fix);
  const tsChecker = useTsChecker(props.files); // Build the complete array of found errors.

  const allErrors = [...prettier.errors, ...eslint.errors, ...tsChecker.errors, ...phpcs.errors, ...stylelint.errors];
  const done = eslint.done && tsChecker.done && phpcs.done && prettier.done && stylelint.done;
  const numErrors = allErrors.length;
  const numAutofixed = prettier.fixed.length + eslint.filesAutoFixed + phpcs.filesFixed;
  const errorsAutofixable = allErrors.filter(e => e.autoFixable).length;
  useExit(done, allErrors.length ? lintingFailed : undefined);
  useTick();
  return React__default.createElement(React__default.Fragment, null, React__default.createElement(ink.Box, {
    marginTop: 1,
    flexDirection: "column"
  }, props.summary ? React__default.createElement(ErrorSummaryList, {
    allErrors: allErrors
  }) : React__default.createElement(FileErrorList, {
    allErrors: allErrors,
    repoRoot: props.repoRoot,
    verbose: props.verbose
  })), React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "Git")), React__default.createElement(ink.Text, null, "Found ", React__default.createElement(ink.Text, {
    color: "cyan"
  }, props.files.length), " files.")), !!eslint.files.length && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "ESLint")), React__default.createElement(ink.Text, null, "Linted", ' ', React__default.createElement(NumberOfTotal, {
    number: eslint.reports.length,
    total: eslint.files.length
  }), ' ', "files, found ", React__default.createElement(ErrorCount, {
    errors: eslint.errors.length
  }), ".")), !!prettierFiles.length && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "Prettier")), React__default.createElement(ink.Text, null, "Linted", ' ', React__default.createElement(NumberOfTotal, {
    number: prettier.linted,
    total: prettier.filesToLint
  }), ' ', "files, found ", React__default.createElement(ErrorCount, {
    errors: prettier.filesNotCorrect.length
  }), ".")), !!tsChecker.files.length && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "Typescript")), tsChecker.done ? React__default.createElement(ink.Text, null, "Typechecked projects, found", ' ', React__default.createElement(ErrorCount, {
    errors: tsChecker.errors.length
  }), ".") : React__default.createElement(ink.Text, null, "Typechecking projects...", !!tsChecker.errors.length && React__default.createElement(React__default.Fragment, null, ' ', "found ", React__default.createElement(ErrorCount, {
    errors: tsChecker.errors.length
  }), " so far."))), !!phpcs.files.length && projectConfig.lintPhpEnabled && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "PHPCS")), React__default.createElement(ink.Text, null, "Linted", ' ', React__default.createElement(NumberOfTotal, {
    number: phpcs.filesLinted,
    total: phpcs.files.length
  }), ' ', "files", props.fix && React__default.createElement(React__default.Fragment, null, ", fixed", ' ', React__default.createElement(NumberOfTotal, {
    number: phpcs.filesFixed,
    total: phpcs.filesWithFixes
  }), ' ', "files"), ". Found ", React__default.createElement(ErrorCount, {
    errors: phpcs.errors.length
  }), ".")), projectConfig.lintPhpEnabled || React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "PHPCS")), React__default.createElement(ink.Text, {
    italic: true
  }, "Disabled.")), !!stylelint.filesToLint && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "Stylelint")), React__default.createElement(ink.Text, null, stylelint.done ? 'Linted' : 'Linting', ' ', React__default.createElement(ink.Text, {
    color: "cyan"
  }, stylelint.filesToLint), " files", stylelint.done ? '.' : '...', " Found", ' ', React__default.createElement(ErrorCount, {
    errors: stylelint.errors.length
  }), ".")), projectConfig.lintStylesEnabled || React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "Stylelint")), React__default.createElement(ink.Text, {
    italic: true
  }, "Disabled.")), React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, React__default.createElement(ink.Text, null, "Time")), React__default.createElement(ink.Text, null, Math.round((new Date().getTime() - startTime.getTime()) / 1000), "s")), React__default.createElement(ink.Box, {
    marginY: 1,
    flexDirection: "column"
  }, numErrors === 0 && numAutofixed === 0 && done ? React__default.createElement(ink.Text, {
    underline: true
  }, "No errors found. Perfect!") : numErrors === 0 && numAutofixed === 0 ? React__default.createElement(ink.Text, {
    underline: true
  }, "No errors found so far...") : numErrors === 0 && numAutofixed > 0 ? React__default.createElement(ink.Text, {
    underline: true
  }, "Autofixed ", numAutofixed, " file", numAutofixed === 1 ? '' : 's', done ? '' : ' so far', ", found no unfixable errors", done ? '.' : ' yet...') : numErrors > 0 && numAutofixed > 0 ? React__default.createElement(ink.Text, {
    underline: true
  }, "Autofixed ", numAutofixed, " file", numAutofixed === 1 ? '' : 's', done ? '' : ' so far', ", but also found ", allErrors.length, " error", allErrors.length === 1 ? ' ' : 's ', "that you need to fix manually.") : numErrors > 0 && numAutofixed === 0 ? React__default.createElement(ink.Text, {
    underline: true
  }, "Found ", allErrors.length, " error", allErrors.length === 1 ? '' : 's', done ? '.' : ' so far...') : null, !props.fix && errorsAutofixable > 0 && React__default.createElement(ink.Box, {
    marginTop: 1
  }, React__default.createElement(ink.Text, {
    color: "grey"
  }, "If you run ", React__default.createElement(ink.Text, {
    color: "red"
  }, "burst lint --fix"), ' ', errorsAutofixable, " error", errorsAutofixable !== 1 && 's', " will be automatically fixed."))));
}

function useTick() {
  const [, setS] = React.useState(0);
  React.useEffect(() => {
    const t = setTimeout(() => setS(se => se + 1), 1000);
    return () => clearTimeout(t);
  });
}

function FileErrorList(props) {
  const errorsPerFile = lodash.groupBy(props.allErrors, 'filename');
  return React__default.createElement(React__default.Fragment, null, Object.entries(errorsPerFile).map(([file, errors], i1) => React__default.createElement(ink.Box, {
    marginBottom: 1,
    flexDirection: "column",
    key: file
  }, React__default.createElement(ink.Text, {
    italic: true
  }, file.startsWith(props.repoRoot) ? file.substr(props.repoRoot.length + 1) : file), errors.map((e, i2) => React__default.createElement(LintErrorMessage // eslint-disable-next-line react/no-array-index-key
  , {
    key: `${i1}_${i2}`,
    error: e,
    verbose: props.verbose
  })))));
}

function ErrorSummaryList(props) {
  const errorsPerError = lodash.countBy(props.allErrors, e => e.rule ? `${e.linter} - ${e.rule}` : `${e.linter} - ${e.message}`);
  return React__default.createElement(ink.Box, {
    marginBottom: 2,
    flexDirection: "column"
  }, React__default.createElement(ink.Text, {
    italic: true
  }, "There are ", Object.keys(errorsPerError).length, " different types of errors."), lodash.sortBy(Object.entries(errorsPerError), ['1', '0']).map(([error, errors]) => React__default.createElement(ink.Box, {
    key: error
  }, React__default.createElement(ink.Box, {
    width: 6,
    alignItems: "flex-end"
  }, React__default.createElement(ink.Text, null, errors)), React__default.createElement(ink.Text, null, error))));
}

function useFilePaths(paths) {
  const [filePaths, setFilePaths] = React.useState(null);
  React.useEffect(() => {
    getListOfRepoFiles(paths).then(f => setFilePaths(f));
  }, [paths]);
  return filePaths;
}

function LintErrorMessage({
  error,
  verbose
}) {
  return React__default.createElement(React__default.Fragment, null, React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 3
  }, React__default.createElement(ink.Text, null, error.autoFixable ? '✨' : '')), React__default.createElement(ink.Box, {
    width: 10
  }, React__default.createElement(ink.Text, null, error.linter)), React__default.createElement(ink.Box, {
    width: 10
  }, error.sourceLocation ? React__default.createElement(ink.Text, {
    color: "gray"
  }, error.sourceLocation.start.line, ":", error.sourceLocation.start.column) : null), React__default.createElement(ink.Box, null, React__default.createElement(ink.Text, null, error.message, ' ', !!error.rule && React__default.createElement(ink.Text, {
    color: "grey"
  }, error.rule)))), verbose && error.rawlines && error.sourceLocation && React__default.createElement(ink.Text, null, codeFrame.codeFrameColumns(error.rawlines, error.sourceLocation)));
}

function ErrorCount(props) {
  return React__default.createElement(ink.Text, null, React__default.createElement(ink.Text, {
    color: props.errors ? 'red' : 'cyan'
  }, props.errors), " error", props.errors !== 1 ? 's' : '');
}

function NumberOfTotal(props) {
  return React__default.createElement(React__default.Fragment, null, React__default.createElement(ink.Text, {
    color: "cyan"
  }, props.number), props.number !== props.total && React__default.createElement(React__default.Fragment, null, ' ', "/ ", React__default.createElement(ink.Text, {
    color: "cyan"
  }, props.total)));
}

const {
  SLACK_TOKEN,
  GITLAB_USER_NAME
} = process.env;
const token = SLACK_TOKEN;
const web = new client.WebClient(token);
async function sendStartDeploymentMessage(project, environment) {
  if (!token) return;
  const attachment = {
    color: '#ffff00',
    fallback: `Deploy ${project.getDisplayName()}`,
    title: `Deploy ${project.getDisplayName()}`,
    title_link: project.getLink(),
    text: GITLAB_USER_NAME ? `The Gitlab user ${GITLAB_USER_NAME} triggered a deploy.\n` : 'A deploy was triggered.\n',
    fields: [{
      title: 'Deploy start',
      value: new Date().toTimeString(),
      short: true
    }, {
      title: 'Deploy done',
      value: 'Not yet...',
      short: true
    }, {
      title: 'URLs',
      value: environment.getUrls().join('\n'),
      short: false
    }]
  };
  const message = await web.chat.postMessage({
    channel: '#deploys',
    text: '',
    attachments: [attachment]
  });
  return async (successful, text) => {
    attachment.color = successful ? '#00ff00' : '#ff0000';
    attachment.fields[1].value = new Date().toTimeString();
    if (text) attachment.text += `${text}\n`;
    await web.chat.update({
      channel: message.channel,
      text: '',
      attachments: [attachment],
      ts: message.ts
    });
  };
}
async function sendTestFailedMessage(error) {
  await web.chat.postMessage({
    channel: '#test-reports',
    text: `A test failed to run successfully. \n\nError: \n\n${typeof error.message === 'string' ? error : error}\n\nGitlab CI job: ${process.env.CI_JOB_URL}`
  });
}

const isCI$3 = require('is-ci');

class DeployCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'deploy');

    _defineProperty(this, "description", 'Deploy one or more applications.');

    _defineProperty(this, "options", [{
      flags: '--all',
      description: "Deprecated. Doesn't do anything."
    }, {
      flags: '--production',
      description: 'Deploy to the production environment.'
    }, {
      flags: '--same-branch',
      description: "Deprecated. Doesn't do anything."
    }]);
  }

  async action(command) {
    /**
     * First, we need to know which apps we need to deploy.
     */
    const allHostingProvidersPerAppCombination = await getProjectInfo().getHostingProvidersByAppCominations();

    if (allHostingProvidersPerAppCombination.length === 0) {
      console.error('There are no apps configured for deployment.');
      return process.exit(1);
    }

    let hostingProvidersPerAppCombination = allHostingProvidersPerAppCombination;
    /**
     * If there is more then one app, we need to ask the user which app they want to
     * deploy. If this is in the CI, we always want to deploy all the apps.
     */

    if (!isCI$3 && allHostingProvidersPerAppCombination.length >= 2) {
      const answers = await inquirer.prompt([{
        type: 'list',
        name: 'h',
        message: 'What apps do you want to deploy?',
        choices: [...allHostingProvidersPerAppCombination.map(h => ({
          name: `Deploy ${h.apps.map(a => a.name).join(' + ')}`,
          value: [h]
        })), new inquirer.Separator(), {
          name: 'All of the above',
          value: hostingProvidersPerAppCombination
        }]
      }]);
      hostingProvidersPerAppCombination = answers.h;
    }
    /**
     * Now that we know which apps to deploy, we need to know what environments we
     * need to deploy to.
     */


    const environmentsToDeploy = [];
    const branch = await getCurrentBranch(); // If the --production arg was passed, we prefer to deploy to production.
    // If the branch is 'master', we prefer to deploy to staging.

    const suggestedTarget = command.production ? DeployTarget.Production : branch === 'master' ? DeployTarget.Staging : undefined; // If neither --production or 'master', we prefer to deploy to an environment with
    // the same name as the current branch.

    const suggestedName = suggestedTarget ? undefined : branch; // Now, we get the environments for all hosting providers.

    for (const appCombi of hostingProvidersPerAppCombination) {
      const environments = lodash.flatten((await Promise.all(appCombi.hostingProviders.map(async provider => (await provider.getPossibleEnvs({
        suggestedTarget,
        suggestedName
      })).map(environment => ({
        provider,
        environment,
        apps: appCombi.apps
      })))))); // When running in the CI, we just always deploy to the suggested environments.
      // When interaction is possible, we ask the user what environments to deploy to.

      if (isCI$3) {
        environmentsToDeploy.push(...environments.filter(e => e.environment.isSuggested()));
      } else {
        const {
          e
        } = await inquirer.prompt([{
          type: 'list',
          name: 'e',
          message: `Where do you want to deploy ${appCombi.apps.map(awdt => awdt.name).join(' + ')} to?`,
          choices: [// We first want to show suggested environments, then normal environments
          // and as last the inactive environments
          ...lodash.sortBy(environments, ewa => ewa.environment.isSuggested() ? 0 : ewa.environment.isActive() ? 1 : 2).map(ewa => ({
            // If it's a suggested environment, we show a rocket emoji.
            name: (ewa.environment.isSuggested() ? '🚀 ' : '  ') + getEnvironmentDisplayName(ewa),
            value: ewa
          }))],
          pageSize: 30
        }]);
        environmentsToDeploy.push(e);
      }
    } // If there are no suggestions, die.


    if (environmentsToDeploy.length === 0) {
      console.error('There are no environments to deploy to.');
      return process.exit(1);
    }
    /**
     * Ask for confirmation before deploying. Only ask for real confirmation when
     * interaction is possible. On the CI, we still show what we're about to do.
     */


    console.log("You're about to perform the following actions:");
    environmentsToDeploy.forEach(e => console.log(` -  ${getEnvironmentDisplayName(e)}`));

    if (!isCI$3) {
      const {
        sure
      } = await inquirer.prompt([{
        type: 'confirm',
        name: 'sure',
        message: `Are you sure?`
      }]);
      if (!sure) return process.exit(1);
    }
    /**
     * Now, deploy!
     */


    for (const env of environmentsToDeploy) {
      // If there are multiple, different hosting provider configurations of the same
      // hosting provider we need to only deploy a subfolder.
      const hostingProvidersOfSameType = allHostingProvidersPerAppCombination.filter(hppac => hppac.hostingProviders.find(hp => hp.constructor === env.provider.constructor));

      if (hostingProvidersOfSameType.length > 1 && env.apps.length !== 1) {
        console.error('Impossible to have multiple apps deployed when more then 1 hosting provider config of that type available.');
        process.exit(1);
      }

      const deployOnlySubdirectory = hostingProvidersOfSameType.length > 1 ? env.apps[0].dir : undefined; // Send a message to Slack when deploying to production.

      const done = env.environment.getDeployTarget() === DeployTarget.Production ? await sendStartDeploymentMessage(env.provider, env.environment).catch(e => console.error('Slack fail!', e)) : null;

      try {
        await env.environment.deploy({
          deployOnlySubdirectory
        });
      } catch (e) {
        // Notify Slack that the deployment failed.
        if (done) {
          await done(false, e.message).catch(console.error);
        }

        throw e;
      } // Notify Slack that the deployment is completed.


      if (done) {
        await done(true).catch(e => console.error('Slack fail!', e));
      }
    }
  }

}

function getEnvironmentDisplayName(e) {
  const displayName = e.apps.map(a => `Deploy ${chalk.magenta(a.name)} to ${chalk.cyan(e.environment.getDisplayName())}`).join(' and ') + chalk.grey(` - ${e.provider.getDisplayName()}`);
  if (e.environment.isActive()) return displayName;
  return chalk.dim(displayName) + chalk.grey(' (inactive)');
}

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;

var _freeGlobal = freeGlobal;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = _freeGlobal || freeSelf || Function('return this')();

var _root = root;

/** Built-in value references. */
var Symbol$2 = _root.Symbol;

var _Symbol = Symbol$2;

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty$1 = objectProto.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto.toString;

/** Built-in value references. */
var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */
function getRawTag(value) {
  var isOwn = hasOwnProperty$1.call(value, symToStringTag),
      tag = value[symToStringTag];

  try {
    value[symToStringTag] = undefined;
    var unmasked = true;
  } catch (e) {}

  var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag] = tag;
    } else {
      delete value[symToStringTag];
    }
  }
  return result;
}

var _getRawTag = getRawTag;

/** Used for built-in method references. */
var objectProto$1 = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString$1 = objectProto$1.toString;

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */
function objectToString(value) {
  return nativeObjectToString$1.call(value);
}

var _objectToString = objectToString;

/** `Object#toString` result references. */
var nullTag = '[object Null]',
    undefinedTag = '[object Undefined]';

/** Built-in value references. */
var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return (symToStringTag$1 && symToStringTag$1 in Object(value))
    ? _getRawTag(value)
    : _objectToString(value);
}

var _baseGetTag = baseGetTag;

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject$2(value) {
  var type = typeof value;
  return value != null && (type == 'object' || type == 'function');
}

var isObject_1 = isObject$2;

/** `Object#toString` result references. */
var asyncTag = '[object AsyncFunction]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    proxyTag = '[object Proxy]';

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */
function isFunction(value) {
  if (!isObject_1(value)) {
    return false;
  }
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in Safari 9 which returns 'object' for typed arrays and other constructors.
  var tag = _baseGetTag(value);
  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}

var isFunction_1 = isFunction;

/** Used to detect overreaching core-js shims. */
var coreJsData = _root['__core-js_shared__'];

var _coreJsData = coreJsData;

/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() {
  var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
  return uid ? ('Symbol(src)_1.' + uid) : '';
}());

/**
 * Checks if `func` has its source masked.
 *
 * @private
 * @param {Function} func The function to check.
 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
 */
function isMasked(func) {
  return !!maskSrcKey && (maskSrcKey in func);
}

var _isMasked = isMasked;

/** Used for built-in method references. */
var funcProto = Function.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/**
 * Converts `func` to its source code.
 *
 * @private
 * @param {Function} func The function to convert.
 * @returns {string} Returns the source code.
 */
function toSource(func) {
  if (func != null) {
    try {
      return funcToString.call(func);
    } catch (e) {}
    try {
      return (func + '');
    } catch (e) {}
  }
  return '';
}

var _toSource = toSource;

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used for built-in method references. */
var funcProto$1 = Function.prototype,
    objectProto$2 = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString$1 = funcProto$1.toString;

/** Used to check objects for own properties. */
var hasOwnProperty$2 = objectProto$2.hasOwnProperty;

/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
  funcToString$1.call(hasOwnProperty$2).replace(reRegExpChar, '\\$&')
  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);

/**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */
function baseIsNative(value) {
  if (!isObject_1(value) || _isMasked(value)) {
    return false;
  }
  var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor;
  return pattern.test(_toSource(value));
}

var _baseIsNative = baseIsNative;

/**
 * Gets the value at `key` of `object`.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {string} key The key of the property to get.
 * @returns {*} Returns the property value.
 */
function getValue(object, key) {
  return object == null ? undefined : object[key];
}

var _getValue = getValue;

/**
 * Gets the native function at `key` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the method to get.
 * @returns {*} Returns the function if it's native, else `undefined`.
 */
function getNative(object, key) {
  var value = _getValue(object, key);
  return _baseIsNative(value) ? value : undefined;
}

var _getNative = getNative;

/* Built-in method references that are verified to be native. */
var nativeCreate = _getNative(Object, 'create');

var _nativeCreate = nativeCreate;

/**
 * Removes all key-value entries from the hash.
 *
 * @private
 * @name clear
 * @memberOf Hash
 */
function hashClear() {
  this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
  this.size = 0;
}

var _hashClear = hashClear;

/**
 * Removes `key` and its value from the hash.
 *
 * @private
 * @name delete
 * @memberOf Hash
 * @param {Object} hash The hash to modify.
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function hashDelete(key) {
  var result = this.has(key) && delete this.__data__[key];
  this.size -= result ? 1 : 0;
  return result;
}

var _hashDelete = hashDelete;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used for built-in method references. */
var objectProto$3 = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty$3 = objectProto$3.hasOwnProperty;

/**
 * Gets the hash value for `key`.
 *
 * @private
 * @name get
 * @memberOf Hash
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function hashGet(key) {
  var data = this.__data__;
  if (_nativeCreate) {
    var result = data[key];
    return result === HASH_UNDEFINED ? undefined : result;
  }
  return hasOwnProperty$3.call(data, key) ? data[key] : undefined;
}

var _hashGet = hashGet;

/** Used for built-in method references. */
var objectProto$4 = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty$4 = objectProto$4.hasOwnProperty;

/**
 * Checks if a hash value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Hash
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function hashHas(key) {
  var data = this.__data__;
  return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$4.call(data, key);
}

var _hashHas = hashHas;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';

/**
 * Sets the hash `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Hash
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the hash instance.
 */
function hashSet(key, value) {
  var data = this.__data__;
  this.size += this.has(key) ? 0 : 1;
  data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;
  return this;
}

var _hashSet = hashSet;

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Hash(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

// Add methods to `Hash`.
Hash.prototype.clear = _hashClear;
Hash.prototype['delete'] = _hashDelete;
Hash.prototype.get = _hashGet;
Hash.prototype.has = _hashHas;
Hash.prototype.set = _hashSet;

var _Hash = Hash;

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */
function listCacheClear() {
  this.__data__ = [];
  this.size = 0;
}

var _listCacheClear = listCacheClear;

/**
 * Performs a
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * comparison between two values to determine if they are equivalent.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.eq(object, object);
 * // => true
 *
 * _.eq(object, other);
 * // => false
 *
 * _.eq('a', 'a');
 * // => true
 *
 * _.eq('a', Object('a'));
 * // => false
 *
 * _.eq(NaN, NaN);
 * // => true
 */
function eq(value, other) {
  return value === other || (value !== value && other !== other);
}

var eq_1 = eq;

/**
 * Gets the index at which the `key` is found in `array` of key-value pairs.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} key The key to search for.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function assocIndexOf(array, key) {
  var length = array.length;
  while (length--) {
    if (eq_1(array[length][0], key)) {
      return length;
    }
  }
  return -1;
}

var _assocIndexOf = assocIndexOf;

/** Used for built-in method references. */
var arrayProto = Array.prototype;

/** Built-in value references. */
var splice = arrayProto.splice;

/**
 * Removes `key` and its value from the list cache.
 *
 * @private
 * @name delete
 * @memberOf ListCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function listCacheDelete(key) {
  var data = this.__data__,
      index = _assocIndexOf(data, key);

  if (index < 0) {
    return false;
  }
  var lastIndex = data.length - 1;
  if (index == lastIndex) {
    data.pop();
  } else {
    splice.call(data, index, 1);
  }
  --this.size;
  return true;
}

var _listCacheDelete = listCacheDelete;

/**
 * Gets the list cache value for `key`.
 *
 * @private
 * @name get
 * @memberOf ListCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function listCacheGet(key) {
  var data = this.__data__,
      index = _assocIndexOf(data, key);

  return index < 0 ? undefined : data[index][1];
}

var _listCacheGet = listCacheGet;

/**
 * Checks if a list cache value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf ListCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function listCacheHas(key) {
  return _assocIndexOf(this.__data__, key) > -1;
}

var _listCacheHas = listCacheHas;

/**
 * Sets the list cache `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf ListCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the list cache instance.
 */
function listCacheSet(key, value) {
  var data = this.__data__,
      index = _assocIndexOf(data, key);

  if (index < 0) {
    ++this.size;
    data.push([key, value]);
  } else {
    data[index][1] = value;
  }
  return this;
}

var _listCacheSet = listCacheSet;

/**
 * Creates an list cache object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function ListCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

// Add methods to `ListCache`.
ListCache.prototype.clear = _listCacheClear;
ListCache.prototype['delete'] = _listCacheDelete;
ListCache.prototype.get = _listCacheGet;
ListCache.prototype.has = _listCacheHas;
ListCache.prototype.set = _listCacheSet;

var _ListCache = ListCache;

/* Built-in method references that are verified to be native. */
var Map = _getNative(_root, 'Map');

var _Map = Map;

/**
 * Removes all key-value entries from the map.
 *
 * @private
 * @name clear
 * @memberOf MapCache
 */
function mapCacheClear() {
  this.size = 0;
  this.__data__ = {
    'hash': new _Hash,
    'map': new (_Map || _ListCache),
    'string': new _Hash
  };
}

var _mapCacheClear = mapCacheClear;

/**
 * Checks if `value` is suitable for use as unique object key.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
 */
function isKeyable(value) {
  var type = typeof value;
  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
    ? (value !== '__proto__')
    : (value === null);
}

var _isKeyable = isKeyable;

/**
 * Gets the data for `map`.
 *
 * @private
 * @param {Object} map The map to query.
 * @param {string} key The reference key.
 * @returns {*} Returns the map data.
 */
function getMapData(map, key) {
  var data = map.__data__;
  return _isKeyable(key)
    ? data[typeof key == 'string' ? 'string' : 'hash']
    : data.map;
}

var _getMapData = getMapData;

/**
 * Removes `key` and its value from the map.
 *
 * @private
 * @name delete
 * @memberOf MapCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function mapCacheDelete(key) {
  var result = _getMapData(this, key)['delete'](key);
  this.size -= result ? 1 : 0;
  return result;
}

var _mapCacheDelete = mapCacheDelete;

/**
 * Gets the map value for `key`.
 *
 * @private
 * @name get
 * @memberOf MapCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function mapCacheGet(key) {
  return _getMapData(this, key).get(key);
}

var _mapCacheGet = mapCacheGet;

/**
 * Checks if a map value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf MapCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function mapCacheHas(key) {
  return _getMapData(this, key).has(key);
}

var _mapCacheHas = mapCacheHas;

/**
 * Sets the map `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf MapCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the map cache instance.
 */
function mapCacheSet(key, value) {
  var data = _getMapData(this, key),
      size = data.size;

  data.set(key, value);
  this.size += data.size == size ? 0 : 1;
  return this;
}

var _mapCacheSet = mapCacheSet;

/**
 * Creates a map cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function MapCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

// Add methods to `MapCache`.
MapCache.prototype.clear = _mapCacheClear;
MapCache.prototype['delete'] = _mapCacheDelete;
MapCache.prototype.get = _mapCacheGet;
MapCache.prototype.has = _mapCacheHas;
MapCache.prototype.set = _mapCacheSet;

var _MapCache = MapCache;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';

/**
 * Adds `value` to the array cache.
 *
 * @private
 * @name add
 * @memberOf SetCache
 * @alias push
 * @param {*} value The value to cache.
 * @returns {Object} Returns the cache instance.
 */
function setCacheAdd(value) {
  this.__data__.set(value, HASH_UNDEFINED$2);
  return this;
}

var _setCacheAdd = setCacheAdd;

/**
 * Checks if `value` is in the array cache.
 *
 * @private
 * @name has
 * @memberOf SetCache
 * @param {*} value The value to search for.
 * @returns {number} Returns `true` if `value` is found, else `false`.
 */
function setCacheHas(value) {
  return this.__data__.has(value);
}

var _setCacheHas = setCacheHas;

/**
 *
 * Creates an array cache object to store unique values.
 *
 * @private
 * @constructor
 * @param {Array} [values] The values to cache.
 */
function SetCache(values) {
  var index = -1,
      length = values == null ? 0 : values.length;

  this.__data__ = new _MapCache;
  while (++index < length) {
    this.add(values[index]);
  }
}

// Add methods to `SetCache`.
SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd;
SetCache.prototype.has = _setCacheHas;

var _SetCache = SetCache;

/**
 * The base implementation of `_.findIndex` and `_.findLastIndex` without
 * support for iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {number} fromIndex The index to search from.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseFindIndex(array, predicate, fromIndex, fromRight) {
  var length = array.length,
      index = fromIndex + (fromRight ? 1 : -1);

  while ((fromRight ? index-- : ++index < length)) {
    if (predicate(array[index], index, array)) {
      return index;
    }
  }
  return -1;
}

var _baseFindIndex = baseFindIndex;

/**
 * The base implementation of `_.isNaN` without support for number objects.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 */
function baseIsNaN(value) {
  return value !== value;
}

var _baseIsNaN = baseIsNaN;

/**
 * A specialized version of `_.indexOf` which performs strict equality
 * comparisons of values, i.e. `===`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function strictIndexOf(array, value, fromIndex) {
  var index = fromIndex - 1,
      length = array.length;

  while (++index < length) {
    if (array[index] === value) {
      return index;
    }
  }
  return -1;
}

var _strictIndexOf = strictIndexOf;

/**
 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseIndexOf(array, value, fromIndex) {
  return value === value
    ? _strictIndexOf(array, value, fromIndex)
    : _baseFindIndex(array, _baseIsNaN, fromIndex);
}

var _baseIndexOf = baseIndexOf;

/**
 * A specialized version of `_.includes` for arrays without support for
 * specifying an index to search from.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludes$1(array, value) {
  var length = array == null ? 0 : array.length;
  return !!length && _baseIndexOf(array, value, 0) > -1;
}

var _arrayIncludes = arrayIncludes$1;

/**
 * This function is like `arrayIncludes` except that it accepts a comparator.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @param {Function} comparator The comparator invoked per element.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludesWith(array, value, comparator) {
  var index = -1,
      length = array == null ? 0 : array.length;

  while (++index < length) {
    if (comparator(value, array[index])) {
      return true;
    }
  }
  return false;
}

var _arrayIncludesWith = arrayIncludesWith;

/**
 * Checks if a `cache` value for `key` exists.
 *
 * @private
 * @param {Object} cache The cache to query.
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function cacheHas(cache, key) {
  return cache.has(key);
}

var _cacheHas = cacheHas;

/* Built-in method references that are verified to be native. */
var Set = _getNative(_root, 'Set');

var _Set = Set;

/**
 * This method returns `undefined`.
 *
 * @static
 * @memberOf _
 * @since 2.3.0
 * @category Util
 * @example
 *
 * _.times(2, _.noop);
 * // => [undefined, undefined]
 */
function noop() {
  // No operation performed.
}

var noop_1 = noop;

/**
 * Converts `set` to an array of its values.
 *
 * @private
 * @param {Object} set The set to convert.
 * @returns {Array} Returns the values.
 */
function setToArray(set) {
  var index = -1,
      result = Array(set.size);

  set.forEach(function(value) {
    result[++index] = value;
  });
  return result;
}

var _setToArray = setToArray;

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

/**
 * Creates a set object of `values`.
 *
 * @private
 * @param {Array} values The values to add to the set.
 * @returns {Object} Returns the new set.
 */
var createSet = !(_Set && (1 / _setToArray(new _Set([,-0]))[1]) == INFINITY) ? noop_1 : function(values) {
  return new _Set(values);
};

var _createSet = createSet;

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/**
 * The base implementation of `_.uniqBy` without support for iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new duplicate free array.
 */
function baseUniq(array, iteratee, comparator) {
  var index = -1,
      includes = _arrayIncludes,
      length = array.length,
      isCommon = true,
      result = [],
      seen = result;

  if (comparator) {
    isCommon = false;
    includes = _arrayIncludesWith;
  }
  else if (length >= LARGE_ARRAY_SIZE) {
    var set = iteratee ? null : _createSet(array);
    if (set) {
      return _setToArray(set);
    }
    isCommon = false;
    includes = _cacheHas;
    seen = new _SetCache;
  }
  else {
    seen = iteratee ? [] : result;
  }
  outer:
  while (++index < length) {
    var value = array[index],
        computed = iteratee ? iteratee(value) : value;

    value = (comparator || value !== 0) ? value : 0;
    if (isCommon && computed === computed) {
      var seenIndex = seen.length;
      while (seenIndex--) {
        if (seen[seenIndex] === computed) {
          continue outer;
        }
      }
      if (iteratee) {
        seen.push(computed);
      }
      result.push(value);
    }
    else if (!includes(seen, computed, comparator)) {
      if (seen !== result) {
        seen.push(computed);
      }
      result.push(value);
    }
  }
  return result;
}

var _baseUniq = baseUniq;

/**
 * Creates a duplicate-free version of an array, using
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons, in which only the first occurrence of each element
 * is kept. The order of result values is determined by the order they occur
 * in the array.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Array
 * @param {Array} array The array to inspect.
 * @returns {Array} Returns the new duplicate free array.
 * @example
 *
 * _.uniq([2, 1, 2]);
 * // => [2, 1]
 */
function uniq(array) {
  return (array && array.length) ? _baseUniq(array) : [];
}

var uniq_1 = uniq;

const access = util.promisify(fs__default.access);
async function exists(somePath) {
  return access(somePath).then(() => true).catch(() => false);
}

const defaultGitignoreRules = `

# Created by https://www.gitignore.io/api/node,code,linux,macos,windows,composer,phpstorm+all
# Edit at https://www.gitignore.io/?templates=node,code,linux,macos,windows,composer,phpstorm+all

### Code ###
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json

### Composer ###
composer.phar
/vendor/

# Commit your application's lock file https://getcomposer.org/doc/01-basic-usage.md#commit-your-composer-lock-file-to-version-control
# You may choose to ignore a library lock file http://getcomposer.org/doc/02-libraries.md#lock-file
# composer.lock

### Linux ###
*~

# temporary files which can be created if a process still has a handle open of a deleted file
.fuse_hidden*

# KDE directory preferences
.directory

# Linux trash folder which might appear on any partition or disk
.Trash-*

# .nfs files are created when an open file is removed but is still being accessed
.nfs*

### macOS ###
# General
.DS_Store
.AppleDouble
.LSOverride

# Icon must end with two \r
Icon

# Thumbnails
._*

# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent

# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk

### Node ###
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*

# Diagnostic reports (https://nodejs.org/api/report.html)
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov

# Coverage directory used by tools like istanbul
coverage
*.lcov

# nyc test coverage
.nyc_output

# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt

# Bower dependency directory (https://bower.io/)
bower_components

# node-waf configuration
.lock-wscript

# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release

# Dependency directories
node_modules/
jspm_packages/

# TypeScript v1 declaration files
typings/

# TypeScript cache
*.tsbuildinfo

# Optional npm cache directory
.npm

# Optional eslint cache
.eslintcache

# Optional REPL history
.node_repl_history

# Output of 'npm pack'
*.tgz

# Yarn Integrity file
.yarn-integrity

# dotenv environment variables file
.env
.env.test

# parcel-bundler cache (https://parceljs.org/)
.cache

# next.js build output
.next

# nuxt.js build output
.nuxt

# rollup.js default build output
dist/

# Uncomment the public line if your project uses Gatsby
# https://nextjs.org/blog/next-9-1#public-directory-support
# https://create-react-app.dev/docs/using-the-public-folder/#docsNav
# public

# Storybook build outputs
.out
.storybook-out

# vuepress build output
.vuepress/dist

# Serverless directories
.serverless/

# FuseBox cache
.fusebox/

# DynamoDB Local files
.dynamodb/

# Temporary folders
tmp/
temp/

### PhpStorm+all ###
# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

# User-specific stuff
.idea/**/workspace.xml
.idea/**/tasks.xml
.idea/**/usage.statistics.xml
.idea/**/dictionaries
.idea/**/shelf

# Generated files
.idea/**/contentModel.xml

# Sensitive or high-churn files
.idea/**/dataSources/
.idea/**/dataSources.ids
.idea/**/dataSources.local.xml
.idea/**/sqlDataSources.xml
.idea/**/dynamic.xml
.idea/**/uiDesigner.xml
.idea/**/dbnavigator.xml

# Gradle
.idea/**/gradle.xml
.idea/**/libraries

# Gradle and Maven with auto-import
# When using Gradle or Maven with auto-import, you should exclude module files,
# since they will be recreated, and may cause churn.  Uncomment if using
# auto-import.
# .idea/modules.xml
# .idea/*.iml
# .idea/modules
# *.iml
# *.ipr

# CMake
cmake-build-*/

# Mongo Explorer plugin
.idea/**/mongoSettings.xml

# File-based project format
*.iws

# IntelliJ
out/

# mpeltonen/sbt-idea plugin
.idea_modules/

# JIRA plugin
atlassian-ide-plugin.xml

# Cursive Clojure plugin
.idea/replstate.xml

# Crashlytics plugin (for Android Studio and IntelliJ)
com_crashlytics_export_strings.xml
crashlytics.properties
crashlytics-build.properties
fabric.properties

# Editor-based Rest Client
.idea/httpRequests

# Android studio 3.1+ serialized cache file
.idea/caches/build_file_checksums.ser

### PhpStorm+all Patch ###
# Ignores the whole .idea folder and all .iml files
# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360

.idea/

# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023

*.iml
modules.xml
.idea/misc.xml
*.ipr

# Sonarlint plugin
.idea/sonarlint

### Windows ###
# Windows thumbnail cache files
Thumbs.db
Thumbs.db:encryptable
ehthumbs.db
ehthumbs_vista.db

# Dump file
*.stackdump

# Folder config file
[Dd]esktop.ini

# Recycle Bin used on file shares
$RECYCLE.BIN/

# Windows Installer files
*.cab
*.msi
*.msix
*.msm
*.msp

# Windows shortcuts
*.lnk

# End of https://www.gitignore.io/api/node,code,linux,macos,windows,composer,phpstorm+all

`;
/**
 * These are all the gitignore rules that are added on top of all Burst
 * projects.
 */

const projectGitignore = [// Files that are scaffolded
'.vscode', '.idea', 'phpcs.xml', // Platform.sh dump files
'*--dump.sql', '*--dump.sql.gz', // DDev configuration
'.ddev', // Various other rules, as defined by .gitignore templates
...defaultGitignoreRules.split('\n').map(s => s.trim()).filter(s => s !== '' && !s.startsWith('#'))];

/**
 * This file should be scaffolded into .vscode/extensions.json.
 */
const vscodeExtensions = `
{
  "recommendations": [
    // This shows PHP lint validation errors while editing PHP files, and fixes them on save.
    "wongjn.php-sniffer",

    // Show the right styntax highlighting for Drupal-specific file extensions.
    "marcostazi.vs-code-drupal",

    // Shows and autofixes ESLint errors (including Prettier errors).
    "dbaeumer.vscode-eslint",

    // Shows and autofixes Stylelint errors (including Prettier errors).
    "stylelint.vscode-stylelint",

    // Applies prettier fixes to all supported files.
    "esbenp.prettier-vscode"
  ]
}
`;

class SyncPlatformToDdevCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'sync-platform-to-ddev');

    _defineProperty(this, "description", 'Synchronizes a platform.sh database to a local ddev database.');

    _defineProperty(this, "action", async () => {
      const ddevConfigurations = getDdevConfigurations();

      if (!ddevConfigurations.length) {
        console.error('There are no ddev configurations available.');
        return;
      }

      const ddevProjects = await getDdevProjects();
      const ddevs = ddevConfigurations.map(configuration => ({
        configuration,
        project: ddevProjects.find(p => p.approot === configuration.projectRoot)
      }));

      if (!ddevs.some(d => d.project)) {
        console.error('There are no ddev projects running.');
        return;
      }

      for (const ddev of ddevs) {
        // eslint-disable-next-line no-continue
        if (!ddev.project) continue;
        const dbFile = `${repoRoot}/ddev--dump.sql.gz`;

        try {
          console.log(`Downloading database from the Platform.sh app ${ddev.configuration.platformApp}...`);
          await execa('platform', ['db:dump', '--project', ddev.configuration.platformProject, '--app', ddev.configuration.platformApp, '--file', 'ddev--dump.sql.gz', '--gzip'], {
            cwd: repoRoot,
            stdio: 'inherit'
          });
          console.log('Importing database into ddev...');
          await execa('ddev', ['import-db', '--src', dbFile], {
            cwd: ddev.project.approot,
            stdio: 'inherit'
          });
        } finally {
          fs__default.unlinkSync(dbFile);
        }
      }
    });
  }

}
function getDdevConfigurations() {
  const projects = [];
  projectConfig.apps.forEach(async app => {
    try {
      const hosting = app.hosting.find(h => h.type === 'platform');
      if (!hosting) return;
      const platformFile = yaml__default.load(fs__default.readFileSync(`${app.path}/.platform.app.yaml`, {
        encoding: 'utf8'
      }));
      const webroot = platformFile.web.locations['/'].root;
      const forceRoot = !projectConfig.apps.some(a => !a.dir) && app.dir === 'drupal';
      projects.push({
        app,
        docroot: forceRoot ? `${app.dir}/${webroot}` : webroot,
        projectName: `burst--${path$1__default.basename(repoRoot)}--${app.name}`,
        projectRoot: forceRoot ? repoRoot : app.path,
        platformApp: platformFile.name,
        platformProject: hosting.id,
        phpVersion: platformFile.type.split(':')[1]
      });
    } catch (_unused) {// Don't add project.
    }
  });
  return projects;
}

async function getDdevProjects() {
  try {
    const ddevList = await execa.command('ddev list -j');
    const ddevProjects = JSON.parse(ddevList.stdout).raw;
    return ddevProjects.filter(p => p.status === 'running');
  } catch (_unused2) {
    return [];
  }
}

const prettierConfig = require('@burst/prettier-config');

const write = util.promisify(fs__default.writeFile);
const read = util.promisify(fs__default.readFile);
const unlink = util.promisify(fs__default.unlink);
const mkdir = util.promisify(fs__default.mkdir);
const parseXml = util.promisify(new xml2js.Parser().parseString);
const buildXml = new xml2js.Builder();
const {
  apps
} = projectConfig;
class ScaffoldCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'scaffold');

    _defineProperty(this, "description", 'Scaffolds various configuration files into the root of the git repository.');

    _defineProperty(this, "action", async () => {
      // Delete all files that were created in previous versions of the scaffold
      // command. They can conflict with the other settings written to the file
      // system.
      const filesToDelete = ['.eslintrc.yaml', '.prettierrc.yaml', 'tslint.yaml'];
      await Promise.all(filesToDelete.map(async filename => {
        if (await exists(`${repoRoot}/${filename}`)) {
          await unlink(`${repoRoot}/${filename}`);
          console.log(`💣 Deleted ${filename} because it isn't used anymore.`);
        }
      }));
      const composerHelperDir = path$1__default.join(__dirname, '../composer-helper'); // The primary app type is any app type other then 'other' when available.

      const primaryAppType = apps.map(a => a.type).filter(t => t !== 'other')[0] || 'other';
      const phpcsRuleset = ['<?xml version="1.0"?>', '<ruleset name="Auto-generated ruleset for this project by the Burst CLI" namespace="Burst">', `  <config name="installed_paths" value="${composerHelperDir}/vendor/wp-coding-standards/wpcs" />`, ...appTypes.map(type => apps.some(app => app.type === type) ? type === primaryAppType ? `  <rule ref="${composerHelperDir}/${type}_ruleset.xml" />` : `  <!--rule ref="${composerHelperDir}/${type}_ruleset.xml" /-->` : `  <!-- No ${type} apps -->`), '</ruleset>'];
      await write(`${repoRoot}/phpcs.xml`, phpcsRuleset.join('\n'));
      console.log('🔥 Written to phpcs.xml');
      const eslintModuleFolder = `${require.resolve('eslint').split('/node_modules/eslint/')[0]}/node_modules`;
      const eslintFolder = `${eslintModuleFolder}/eslint`;

      if (!(await exists(`${repoRoot}/.idea`))) {
        console.log("⛔ The .idea folder doesn't exist, so IntelliJ won't be configured.");
      } else {
        // PHPStorm reads from a eslint.xml file. Because it only contains eslint
        // settings we can just overwrite it.
        if (!(await exists(`${repoRoot}/.idea/jsLinters`))) {
          await mkdir(`${repoRoot}/.idea/jsLinters`);
          console.log('🔥 Created .idea/jsLinters');
        }

        await write(`${repoRoot}/.idea/jsLinters/eslint.xml`, `<?xml version="1.0" encoding="UTF-8"?>
          <project version="4">
            <component name="EslintConfiguration">
              <custom-configuration-file used="true" path="${require.resolve('@burst/eslint-config')}" />
            </component>
          </project>
        `);
        console.log('🔥 Written to .idea/jsLinters/eslint.xml');
        const phpXmlPath = `${repoRoot}/.idea/php.xml`;

        if (!(await exists(phpXmlPath))) {
          await write(`${repoRoot}/.idea/php.xml`, `<?xml version="1.0" encoding="UTF-8"?>
            <project version="4">
              <component name="PhpCodeSniffer">
                <phpcs_settings>
                  <PhpCSConfiguration standards="Drupal;DrupalPractice;MySource;PEAR;PHPCS;PSR1;PSR2;Squiz;Zend" tool_path="${composerHelperDir}/vendor/bin/phpcs" timeout="30000" />
                </phpcs_settings>
              </component>
            </project>
          `);
          console.log('🔥 Created .idea/php.xml');
        } else {
          try {
            const phpXml = await parseXml((await read(phpXmlPath)));
            phpXml.project.component = phpXml.project.component ? phpXml.project.component.filter(c => c.$.name !== 'PhpCodeSniffer') : [];
            phpXml.project.component.push({
              $: {
                name: 'PhpCodeSniffer'
              },
              phpcs_settings: [{
                PhpCSConfiguration: [{
                  $: {
                    standards: 'Drupal;DrupalPractice;MySource;PEAR;PHPCS;PSR1;PSR2;Squiz;Zend',
                    tool_path: `${composerHelperDir}/vendor/bin/phpcs`,
                    beautifier_path: `${composerHelperDir}/vendor/bin/phpcbf`,
                    timeout: 30000
                  }
                }]
              }]
            });
            await write(phpXmlPath, buildXml.buildObject(phpXml));
            console.log('🔥 Adjusted .idea/php.xml');
          } catch (e) {
            console.error(e);
            console.error();
            console.log('⛔ Writing to .idea/php.xml not possible. Please configure the following phpcs package:');
            console.error(`   ${composerHelperDir}/vendor/bin/phpcs`);
          }
        }

        try {
          const workspacePath = `${repoRoot}/.idea/workspace.xml`;
          const workspaceXml = await parseXml((await read(workspacePath)));
          const properties = workspaceXml.project.component.find(c => c.$.name === 'PropertiesComponent').property;
          Object.entries({
            'node.js.detected.package.eslint': 'true',
            'node.js.path.for.package.eslint': 'project',
            'node.js.selected.package.eslint': eslintFolder,
            'node.js.detected.package.standard': 'true',
            'node.js.path.for.package.standard': 'project',
            'node.js.selected.package.standard': eslintFolder
          }).forEach(([name, value]) => {
            const property = properties.find(p => p.$.name === name);
            if (property) property.$.value = value;else properties.push({
              $: {
                name,
                value
              }
            });
          });
          await write(workspacePath, buildXml.buildObject(workspaceXml));
          console.log('🔥 Written to .idea/workspace.xml');
        } catch (e) {
          console.error(e);
          console.error();
          console.log('⛔ Writing to .idea/workspace.xml not possible. Please configure the following eslint package:');
          console.log(`  ${eslintFolder}`);
        }

        try {
          const inspectionPath = `${repoRoot}/.idea/inspectionProfiles/Project_Default.xml`;

          if (!(await exists(`${repoRoot}/.idea/inspectionProfiles`))) {
            await mkdir(`${repoRoot}/.idea/inspectionProfiles`);
            console.log('🔥 Created .idea/inspectionProfiles');
          }

          if (!(await exists(inspectionPath))) {
            await write(inspectionPath, `<component name="InspectionProjectProfileManager">
              <profile version="1.0">
                <option name="myName" value="Project Default" />
                <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
              </profile>
            </component>`);
            console.log('🔥 Created .idea/inspectionProfiles/Project_Default.xml');
          } else {
            const inspectionXml = await parseXml((await read(inspectionPath)));
            const profile = inspectionXml.component.profile[0];

            if (!profile.inspection_tool) {
              profile.inspection_tool = [];
            }

            profile.inspection_tool = profile.inspection_tool.filter(i => i.$.class !== 'Eslint' && i.$.class !== 'PhpCSValidationInspection');
            profile.inspection_tool.push({
              $: {
                class: 'Eslint',
                enabled: true,
                level: 'WARNING',
                enabled_by_default: 'true'
              }
            });
            profile.inspection_tool.push({
              $: {
                class: 'PhpCSValidationInspection',
                enabled: true,
                level: 'WARNING',
                enabled_by_default: 'true'
              },
              option: [{
                $: {
                  name: 'CODING_STANDARD',
                  value: 'Custom'
                }
              }, {
                $: {
                  name: 'CUSTOM_RULESET_PATH',
                  value: `${repoRoot}/phpcs.xml`
                }
              }, {
                $: {
                  name: 'EXTENSIONS',
                  value: 'php'
                }
              }]
            });
            await write(inspectionPath, buildXml.buildObject(inspectionXml));
            console.log('🔥 Adjusted .idea/inspectionProfiles/Project_Default.xml');
          }
        } catch (e) {
          console.error(e);
          console.error();
          console.log('⛔ Writing to .idea/inspectionProfiles/Project_Default.xml not possible. You need to enable eslint in the project settings yourself.');
        }
      } // VSCode reads its settings from .vscode/settings.json. We write to this
      // file to configure VSCode to automatically fix all linting errors.


      const vscode = this.json(_objectSpread({
        // Prettier uses 80 as the max line length, so we want to show that in the
        // editor too.
        'editor.rulers': [80],
        // This adds eslint configs to reflect the burst lint command.
        'editor.codeActionsOnSave': {
          'source.fixAll.eslint': true
        },
        'eslint.nodePath': `${eslintModuleFolder}/`,
        'eslint.options': {
          configFile: require.resolve('@burst/eslint-config'),
          useEslintRc: false,
          reportUnusedDisaleDirectives: true
        }
      }, Object.entries(prettierConfig).reduce((c, [k, v]) => _objectSpread({}, c, {
        [`prettier.${k}`]: v
      }), {}), {
        // We want to run Prettier every time someone saves a file.
        'editor.formatOnSave': true,
        // Because ESLint already fixes all JS and TS files, we need to disable
        // prettier on these file types.
        '[javascript]': {
          'editor.formatOnSave': false
        },
        '[javascriptreact]': {
          'editor.formatOnSave': false
        },
        '[typescript]': {
          'editor.formatOnSave': false
        },
        '[typescriptreact]': {
          'editor.formatOnSave': false
        },
        // This configures PHP linting for the 'wongjn.php-sniffer' extension.
        'phpSniffer.executablesFolder': `${composerHelperDir}/vendor/bin/`,
        'phpSniffer.standard': `${repoRoot}/phpcs.xml`,
        'phpSniffer.run': 'onType',
        'css.validate': false,
        'stylelint.config': {
          extends: require.resolve('@burst/stylelint-config')
        }
      })).trim().split('\n').slice(1, -1); // Create .vscode/settings.json if it doesn't exist yet.

      if (!(await exists(`${repoRoot}/.vscode`))) {
        await mkdir(`${repoRoot}/.vscode`);
        console.log('🔥 Created .vscode');
      }

      if (!(await exists(`${repoRoot}/.vscode/settings.json`))) {
        await write(`${repoRoot}/.vscode/settings.json`, `{\n}`);
        console.log('🔥 Created .vscode/settings.json');
      }

      const vscodeFile = (await read(`${repoRoot}/.vscode/settings.json`, {
        encoding: 'utf8'
      })).trim().split('\n');
      const startScaffoldL = '  // @start-burst-cli-scaffold';
      const endScaffoldL = '  // @end-burst-cli-scaffold';
      const startScaffoldI = vscodeFile.findIndex(l => l.trim() === startScaffoldL.trim());
      const endScaffoldI = vscodeFile.findIndex(l => l.trim() === endScaffoldL.trim());
      const newVscodeFile = startScaffoldI !== -1 && endScaffoldI !== -1 ? [// Only replace the parts between the start and end scaffold lines.
      // All other lines are kept intact.
      ...vscodeFile.slice(0, startScaffoldI + 1), ...vscode, ...vscodeFile.slice(endScaffoldI), ''] : [// Always start with our own settings.
      '{', startScaffoldL, ...vscode, endScaffoldL, // Then output the original contents, but without the brackets.
      ...vscodeFile.slice(1, -1), '}', ''];
      await write(`${repoRoot}/.vscode/settings.json`, newVscodeFile.join('\n'));
      console.log('🔥 Written to .vscode/settings.json');
      await write(`${repoRoot}/.vscode/extensions.json`, vscodeExtensions);
      console.log('🔥 Written to .vscode/extensions.json'); // Write to the .gitignore file.

      const gitignoreLines = ['# @start-burst-cli-gitignore', ...['', `# DON'T ADD ANY RULES BEFORE THIS BLOCK.`, `# These rules are automatically generated by the 'burst scaffold' command.`, '# Add your own rules after this block, or they will be overwritten.', ...projectGitignore.map(p => `${p}\n#${'     👇 ONLY EDIT BELOW THIS BLOCK 👇'.padStart(79, '#')}`)], '# YOU CAN ADD RULES AFTER THE NEXT LINE.', '# @end-burst-cli-gitignore'];
      const giS = gitignoreLines[0];
      const giE = gitignoreLines[gitignoreLines.length - 1];
      const gitignore = await read(`${repoRoot}/.gitignore`, {
        encoding: 'utf8'
      });

      if (gitignore.startsWith(giS)) {
        await write(`${repoRoot}/.gitignore`, `${gitignoreLines.join('\n')}${gitignore.split(giE, 2)[1]}`);
        console.log('🔥 Adjusted .gitignore rules');
      } else {
        await write(`${repoRoot}/.gitignore`, `${gitignoreLines.join('\n')}\n\n${gitignore}`);
        console.log('🔥 Added new .gitignore rules');
      }

      const ddevVersionCheck = await execa.command('ddev --version', {
        reject: false
      });

      if (!ddevVersionCheck.failed) {
        await Promise.all(getDdevConfigurations().map(async project => {
          try {
            const additionalHostnames = await getPlatformRoutes(project.platformProject, project.platformApp).catch(() => []);
            await execa('ddev', ['config', '--project-name', project.projectName, '--project-tld', 'localhost', '--docroot', project.docroot, '--php-version', project.phpVersion, ...(additionalHostnames.length ? ['--additional-hostnames', additionalHostnames.join(',')] : [])], {
              cwd: project.projectRoot
            });
            console.log(`🔥 Initialized ddev for Platform.sh app ${project.platformApp}`);
          } catch (_unused) {
            console.log(`⛔ Could not initialize ddev for Platform.sh app ${project.platformApp}`);
          }
        }));
      }
    });
  }

  json(data) {
    return JSON.stringify(data, null, 2);
  }

}

async function getPlatformRoutes(projectId, projectApp) {
  const {
    stdout
  } = await execa('platform', ['route:list', '--project', projectId, '--environment', 'master', '--format', 'csv']);
  let routes = stdout.split('\n').map(route => route.match(/https:\/\/(.*)\/,upstream,(.*)/)).filter(route => route && route[2] === projectApp).map(route => route[1]); // Replace the {default} placeholder with the default domain on platform.sh

  try {
    if (routes.some(r => r.includes('{default}'))) {
      const {
        stdout: defaultDomain
      } = await execa('platform', ['project:info', 'default_domain', '--project', projectId]);
      routes = routes.map(r => r.replace('{default}', defaultDomain));
    }
  } catch (_unused2) {} // We can ignore any errors, as we will remove all hostnames that
  // still contain placeholders.
  // Replace the {all} placeholder with all domains on platform.sh


  try {
    const routesWithAll = routes.filter(r => r.includes('{all}'));

    if (routesWithAll.length) {
      const {
        stdout: allDomains
      } = await execa('platform', ['domain:list', '--project', projectId, '--columns=name', '--format=csv', '--no-header']); // We can just append the newly formatted domains, as they will be removed
      // anyway.

      routesWithAll.forEach(route => {
        allDomains.split('\n').forEach(domain => {
          routes.push(route.replace('{all}', domain));
        });
      });
    }
  } catch (_unused3) {} // We can ignore any errors, as we will remove all hostnames that
  // still contain placeholders.
  // Remove all hostnames that still contain placeholders.


  routes = routes.filter(r => !r.includes('{'));
  return uniq_1(routes);
}

class InstallCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'install');

    _defineProperty(this, "description", 'Installs all dependencies of a repository.');

    _defineProperty(this, "action", async () => {
      // With these parameters, the CI job can be parallized. This means that in
      // this script, we only have to execute a part of the installations.
      const index = parseInt(process.env.CI_NODE_INDEX || '0', 10) - 1;
      const total = parseInt(process.env.CI_NODE_TOTAL || '1', 10); // Get all package manager files.

      const lockfiles = await getListOfRepoFiles(['package-lock.json', '*/package-lock.json', 'yarn.lock', '*/yarn.lock', 'composer.lock', '*/composer.lock'], true); // Take the lockfiles we're going to install this time.
      // Let's take this example:
      //   - lockfiles.length = 8
      //   - index            = 2  (shows up as 3/5)
      //   - total            = 5
      // That means that we want to execute the install of the third and the
      // eighth lockfile. The following formula does that:

      const lockfilesToInstall = lockfiles.filter(({}, i) => (i - index) % total === 0);

      if (lockfilesToInstall.length === 0) {
        console.log("This job doesn't do anything.");
        console.log("That's completely fine, and you don't have to change anything about that.");

        if (lockfiles.length > 0) {
          console.log(`Please look at the first ${lockfiles.length !== 1 ? `${lockfiles.length} jobs` : 'job'}.`);
        }

        return;
      }

      console.log('===================================');
      console.log('INSTALLING THE FOLLOWING LOCKFILES:\n');
      lockfilesToInstall.forEach(l => console.log(l));
      console.log('===================================\n\n');
      const root = await getRepoRoot(); // eslint-disable-next-line no-restricted-syntax

      for (const lockfile of lockfilesToInstall) {
        const absolutePath = `${root}/${lockfile}`;
        console.log('===================================');
        console.log('Starting installation of:');
        console.log(absolutePath);
        console.log('===================================\n');

        if (absolutePath.endsWith('/package-lock.json')) {
          await exec('npm install', absolutePath);
        } else if (absolutePath.endsWith('/yarn.lock')) {
          // Make sure that there is not a package-lock.json file in the same
          // directory.
          if (lockfiles.includes(lockfile.replace('yarn.lock', 'package-lock.json'))) {
            console.log('There is both a yarn.lock and package-lock.json in the same folder.');
            console.log('Please delete one of them.');
            process.exit(1);
          }

          await exec('yarn', absolutePath);
        } else if (absolutePath.endsWith('/composer.lock')) {
          await exec('composer validate', absolutePath);
          await exec('composer install --no-interaction', absolutePath);
        } else {
          console.log('Unexpected file.');
          process.exit(1);
        }
      }

      const {
        stdout: status
      } = await execa('git', ['status', '--porcelain']);

      if (status) {
        console.log("\n\nAfter installations, some files were changed. That shouldn't happen.");
        console.log("It's about these files:");
        console.log(status);
        process.exit(1);
      }
    });
  }

}

function exec(cmd, path) {
  console.log(`\n\n$ ${cmd}\n\n`);
  const [bin, ...args] = cmd.split(' ');
  return execa(bin, args, {
    cwd: path$1.dirname(path),
    stdio: 'inherit',
    preferLocal: false,
    env: {
      NODE_ENV: 'development'
    }
  });
}

const rimraf = util.promisify(rimrafWithCallback);
const stagedFiles = util.promisify(stagedFilesWithCallback);
const read$1 = util.promisify(fs.readFile);
const write$1 = util.promisify(fs.writeFile);
const append = util.promisify(fs.appendFile);
const removeFile = util.promisify(fs.unlink); // Always run Composer commands without memory limit.

process.env.COMPOSER_MEMORY_LIMIT = '-1';
const databaseSettingsToAppend = `
$databases['default']['default'] = [
  'database' => getenv('MYSQL_DATABASE'),
  'username' => 'root',
  'password' => getenv('MYSQL_ROOT_PASSWORD'),
  'host' => 'mariadb',
  'port' => getenv('MARIADB_PORT_3306_TCP_PORT'),
  'driver' => 'mysql',
  'prefix' => '',
  'collation' => 'utf8mb4_general_ci',
];
`;
class UpdateDrupalCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'update-drupal');

    _defineProperty(this, "description", 'Updates a Drupal project to the latest versions of all modules');

    _defineProperty(this, "options", [{
      flags: '--no-db',
      description: 'Do not download a fresh database and import it.'
    }, {
      flags: '--no-config',
      description: 'Only run composer requires and updates.'
    }]);

    _defineProperty(this, "action", async ({
      db,
      config
    }) => {
      const apps = projectConfig.apps.filter(a => a.type === 'drupal');

      if (!apps.length) {
        console.log('There were no Drupal apps found in the burst.yaml file.');
      }

      for (const app of apps) {
        // We change the working directory to the directory of this app. This
        // way, all commands executed will be automatically executed in this
        // directory.
        process.chdir(app.path); // Get the Platform.sh project ID.

        const platformHosting = app.hosting.find(h => h.type === 'platform');
        const platform = platformHosting ? platformHosting.id : undefined;

        if (!platform) {
          console.log(`The Drupal app ${app.name} doesn't have a Platform hosting configured in the burst.yaml file.`);
          continue;
        } // Get the name of this Drupal app in Platform.


        const platformApp = yaml.safeLoad((await read$1(`${app.path}/.platform.app.yaml`, 'utf8'))).name;

        if (typeof platformApp !== 'string') {
          throw new Error("Platform app yaml doesn't contain a valid name.");
        }

        console.log(`
    
        UPDATING DRUPAL

        Path: ${app.path}
        Platform project: ${platform}
        Platform app name: ${platformApp}

      `);

        try {
          const composerLock = await this.readJsonFile(`${process.cwd()}/composer.lock`);

          if (!composerLock.packages.some(p => p.name === 'drupal/core')) {
            throw new Error('The drupal/core package was not found.');
          }
        } catch (error) {
          console.log('We will not update this Drupal install, because:', error.message || error);
          continue;
        } // Unstage all changes, start with a clean slate. This is only for local stuff, in
        // Gitlab CI the slate should always be clean.


        await execa.command('git reset');
        await this.cleanComposer(); // There are some best practices that we want to have in every composer.json file.

        await this.applyComposerConfig();
        await this.commit('build(drupal): change composer config', 'composer.json composer.lock'); // Now, install the whole site with Composer!

        await this.cleanComposer();
        await this.logPromise('composer install', this.composer('install')); // At this phase, there should be nothing to commit. But if there is, it should be
        // in git. Probabily some scaffolded files that aren't committed.

        await this.commit('build(drupal): add missing files');
        const devtool = process.env.MYSQL_DATABASE ? null : (await execa.command('ddev describe').catch(() => false)) ? 'ddev' : 'lando';

        if (config) {
          // We need to start the Lando containers, if we're not in the CI.
          if (devtool) {
            await this.logPromise(`${devtool} start`, execa.command(`${devtool} start`));
          } else {
            // If we are in the CI, we need to add the database connection to the
            // settings.php file.
            const {
              all: statusString
            } = await this.drush(devtool, 'status --format=json');
            const status = JSON.parse(statusString);
            const settingsPath = `${status.root}/${status.site}/settings.php`;
            await append(settingsPath, databaseSettingsToAppend);
            this.actionsBeforeCommit.push(async () => write$1(settingsPath, (await read$1(settingsPath, 'utf8')).replace(databaseSettingsToAppend, '')));
            this.actionsAfterCommit.push(() => append(settingsPath, databaseSettingsToAppend));
          } // For debugging purposes, show the status.


          await this.logPromise('Logging result of "drush status"', this.drush(devtool, 'status', true));

          if (db) {
            // We need a database! Get the latest datbase from Platform.
            await this.downloadDatabase(platform, platformApp); // Import the database, and remove the datbase from the file system. This
            // way, it's not accidentely committed.

            await this.importDatabase(devtool);
            await rimraf(`${process.cwd()}/drupal--dump.sql`);
          } // We re-export the config. This shouldn't present any changes, but if it does, we
          // need to commit that first.


          await this.clearCache(devtool);

          try {
            await this.exportConfig(devtool);
            await this.commit('fix(drupal): update config with latest production data');
          } catch (e) {
            console.log(e.all || e);
            console.log(`${chalk.bgRed('ERROR')} Re-exporting config failed. Let's just ignore this for now.`); // Reset the config folder to the latest git version.

            await execa.command('git checkout -- config');
          }
        }

        await this.logPromise('Changing php version in composer.json to the one defined in .platform.app.yaml', this.setPhpVersionsInComposer());
        await this.commit('Set php version to the version defined in .platform.app.yaml.');
        await this.logPromise('Removing legacy Burst distribution', this.removeLegacyBurstDistribution());
        await this.commit('refactor(drupal): remove legacy Burst distribution');
        await this.logPromise('Updating references to legacy Drupal distribution', this.upgradeReferencesToOldDrupalDistribution());
        await this.commit('refactor(drupal): update references to legacy Burst distribution');
        await this.addBurstDrupalDistribution(); // Now, we're going to do the actual updating.

        await this.logPromise('updating drupal modules with composer', this.composer('update burst/drupal-distribution drupal/* --with-all-dependencies'));

        if (config) {
          await this.clearCache(devtool);
          await this.accountForSlowDocker(devtool, () => this.logPromise('update database', this.drush(devtool, 'updb')));

          try {
            await this.clearCache(devtool);
            await this.exportConfig(devtool);
          } catch (_unused) {
            await this.exportConfig(devtool);
          }

          await this.commit('fix(drupal): update all drupal-related packages');

          if (devtool) {
            await this.logPromise(`${devtool} stop`, execa.command(`${devtool} stop`));
          }
        }
      }

      console.log('Done with all sites.');
    });

    _defineProperty(this, "actionsBeforeCommit", []);

    _defineProperty(this, "actionsAfterCommit", []);

    _defineProperty(this, "log", {
      start(label) {
        console.time(label);
        console.log(chalk.bgYellow('START'), label);
        return () => {
          process.stdout.write(`${chalk.bgGreen('DONE')} `);
          console.timeEnd(label);
        };
      }

    });
  }

  async applyComposerConfig() {
    const l = this.log.start('Applying composer best practices');
    await this.composer('config minimum-stability dev');
    await this.composer('config prefer-stable true');
    await this.composer('config discard-changes true');
    await this.composer('config sort-packages true');
    await this.composer('config extra.enable-patching true');
    await this.composer('config extra.composer-exit-on-patch-failure true');
    await this.composer('config extra.drupal-scaffold.locations web-root.web');
    const composerFile = `${process.cwd()}/composer.json`;
    await write$1(composerFile, (await read$1(composerFile, 'utf8')).replace(`"enable-patching": "true"`, `"enable-patching": true`).replace(`"composer-exit-on-patch-failure": "true"`, `"composer-exit-on-patch-failure": true`).replace(`"locations": "web-root.web"`, `"locations": {"web-root": "web"}`));
    await this.composer('update --lock');
    l();
  }

  async downloadDatabase(project, app, schema) {
    try {
      await this.logPromise('database download', execa.command(`platform db:dump --project ${project} --environment master --directory . --file drupal--dump.sql --app ${app}${schema ? ` --schema ${schema}` : ''} --yes`));
    } catch (error) {
      if (schema) throw error;

      if (typeof error.stderr === 'string') {
        const errMatch = error.stderr.match(/Available schemas: ([^ ]*), /);

        if (errMatch) {
          console.log(`There is not a default database configured. Using database ${errMatch[1]}.`);
          await this.downloadDatabase(project, app, errMatch[1]);
          return;
        }
      }

      throw error;
    }
  }

  async importDatabase(devtool) {
    if (devtool) {
      await this.logPromise('database import', execa.command(devtool === 'lando' ? 'lando db-import drupal--dump.sql' : 'ddev import-db --src=drupal--dump.sql'));
    } else {
      const connectionCommand = await this.drush(devtool, 'sql-connect');
      await this.logPromise('database import', execa.command(`${connectionCommand.all} < drupal--dump.sql`, {
        shell: true
      }));
    }
  }

  async setPhpVersionsInComposer() {
    const composerJson = await this.readJsonFile(`${process.cwd()}/composer.json`);

    try {
      const platformYaml = await read$1(`${process.cwd()}/.platform.app.yaml`, 'utf8');
      const platform = yaml.safeLoad(platformYaml);
      if (typeof platform.type !== 'string' || !platform.type.startsWith('php:')) throw new Error();
      const phpVersion = `${platform.type.substr(4)}.999`;
      let somethingChanged = false;
      if (!composerJson.config) composerJson.config = {};
      if (!composerJson.config.platform) composerJson.config.platform = {};

      if (composerJson.config.platform.php !== phpVersion) {
        somethingChanged = true;
        composerJson.config.platform.php = phpVersion;
      }

      Object.entries(composerJson.config.platform).forEach(([d, v]) => {
        if (d.startsWith('ext-') && typeof v === 'string' && v.startsWith('7.') && composerJson.config.platform[d] !== phpVersion) {
          somethingChanged = true;
          composerJson.config.platform[d] = phpVersion;
        }
      });

      if (somethingChanged) {
        await write$1(`${process.cwd()}/composer.json`, JSON.stringify(composerJson));
        await this.composer('update --lock');
      }
    } catch (e) {
      console.log('Could not detect php version in .platform.app.yaml and set it in composer.json.');
      console.log(e);
    }
  }

  async removeLegacyBurstDistribution() {
    const composerJson = await this.readJsonFile(`${process.cwd()}/composer.json`);
    const composerLock = await this.readJsonFile(`${process.cwd()}/composer.lock`);
    const burstDistribution = composerLock.packages.find(p => p.name === 'burst/drupal-distribution');
    const hnDistribution = composerLock.packages.find(p => p.name === 'headless-ninja/drupal-distribution');

    if (burstDistribution && !hnDistribution) {
      console.log('There was not a legacy version of the Burst distribution found that needs migration.');
      return;
    }

    if (burstDistribution) {
      console.log('Found a legacy version of the Burst distribution that will be removed.');
      const requiredPackagesByDists = [...Object.entries(burstDistribution.require), ...Object.entries(hnDistribution.require)]; // This requires all packages to the root composer.json that are
      // already required by one of the distributions, but do not exist
      // in the root composer.json already.

      await this.logPromise('Adding packages of legacy Burst distribution to the root composer.json', this.composer(`require ${requiredPackagesByDists.filter(([p]) => p !== 'headless-ninja/drupal-distribution' && !Object.keys(composerJson.require).includes(p)).map(([p, v]) => `"${p}:${v}"`).join(' ')} --no-update`, {
        shell: true
      })); // This removes the old distribution.

      await this.composer('remove burst/drupal-distribution');
      await this.applyComposerConfig();
    }
  }

  async upgradeReferencesToOldDrupalDistribution() {
    let composerJson = await this.readJsonFile(`${process.cwd()}/composer.json`);
    const composerLock = await this.readJsonFile(`${process.cwd()}/composer.lock`);
    await this.upgradeDistributionSettingsCall();

    if (composerLock.packages.some(p => p.name === 'drupal-composer/drupal-scaffold')) {
      composerJson = await this.readJsonFile(`${process.cwd()}/composer.json`);

      if (typeof composerJson.scripts === 'object') {
        let removedScripts = ['__NONE_YET__'];

        while (removedScripts.length) {
          const removeScripts = removedScripts;
          removedScripts = [];
          Object.entries(composerJson.scripts).forEach(([key, value]) => {
            const newValue = (Array.isArray(value) ? value : [value]).filter(s => !s.startsWith('DrupalProject\\') && !s.startsWith('DrupalComposer\\') && !(s.includes('drupal') && s.includes('scaffold')) && !removeScripts.some(r => s === `@${r}`)); // eslint-disable-next-line prefer-destructuring

            if (newValue.length === 1) composerJson.scripts[key] = newValue[0];else if (newValue.length) composerJson.scripts[key] = newValue;else {
              delete composerJson.scripts[key];
              removedScripts.push(key);
            }
          });
        }
      }

      if (composerJson.autoload && Array.isArray(composerJson.autoload.classmap)) {
        composerJson.autoload.classmap = composerJson.autoload.classmap.filter(c => c !== 'scripts/composer/ScriptHandler.php');
        if (composerJson.autoload.classmap.length === 0) delete composerJson.autoload.classmap;
        if (Object.keys(composerJson.autoload).length === 0) delete composerJson.autoload;
      }

      if (!composerJson.extra) composerJson.extra = {};
      composerJson.extra['drupal-scaffold'] = {
        locations: {
          'web-root': 'web'
        }
      };
      await write$1(`${process.cwd()}/composer.json`, JSON.stringify(composerJson));
    }
  }

  async getLatestDrupalDistribution() {
    const {
      data
    } = await axios.get('https://repo.packagist.org/p/burst/drupal-distribution.json');
    const lastVersion = Object.keys(data.packages['burst/drupal-distribution']).filter(v => semver__default.valid(v) && !semver__default.prerelease(v)).sort(semver__default.rcompare)[0];
    return data.packages['burst/drupal-distribution'][lastVersion];
  }

  async addBurstDrupalDistribution() {
    const latest = await this.getLatestDrupalDistribution();
    const packagesInLatest = [// In the last version of the Burst distribution
    ...Object.keys(latest.require), // Not needed anymore
    'drupal-composer/drupal-scaffold', 'drupal/console'];
    const composerJson = await this.readJsonFile(`${process.cwd()}/composer.json`);
    const rootRequirements = Object.keys(composerJson.require);
    const packagesThatShouldBeRemoved = rootRequirements.filter(pkg => packagesInLatest.includes(pkg));

    if (!packagesThatShouldBeRemoved.length) {
      console.log('There are no packages that are part of the latest Burst distribution, that are currently a requirement and should be removed.');
    } else {
      try {
        await this.logPromise('Remove packages that are part of the latest Burst distribution', this.composer(`remove ${packagesThatShouldBeRemoved.join(' ')}`));
      } catch (_unused2) {
        console.log("Couldn't remove these packages using the 'remove' command. Trying again with --no-update-with-dependencies");

        try {
          await this.logPromise('Remove packages that are part of the latest Burst distribution', this.composer(`remove ${packagesThatShouldBeRemoved.join(' ')} --no-update-with-dependencies`));
        } catch (_unused3) {
          console.log("Couldn't remove these packages using the 'remove --no-update-with-dependencies' command. Trying again with --no-update");
          await this.logPromise('Remove packages that are part of the latest Burst distribution', this.composer(`remove ${packagesThatShouldBeRemoved.join(' ')} --no-update`));
        }
      }
    }

    const burstDistIsInstalled = rootRequirements.includes('burst/drupal-distribution');

    try {
      await this.logPromise('Require latest Burst distribution', this.composer(`require burst/drupal-distribution:^${latest.version} --update-with-all-dependencies`));

      if (!burstDistIsInstalled) {
        await this.commit('feat(drupal): add Burst distribution');
      }
    } catch (error) {
      if (!burstDistIsInstalled) throw error;
      console.log('Could not require latest burst/drupal-distribution. But just updating the current one could suffice.');
    }
  }

  async upgradeDistributionSettingsCall() {
    // Find all calls to burst_distribution_settings();
    const files = await execa.command('git grep -l burst_distribution_settings', {
      reject: false
    });
    await Promise.all(files.stdout.split('\n').filter(Boolean).map(relativeFile => `${process.cwd()}/${relativeFile}`).map(async absoluteFile => this.logPromise(`Rewriting burst_distribution_settings() call in file ${absoluteFile}`, write$1(absoluteFile, (await read$1(absoluteFile, 'utf8')).replace(/burst_distribution_settings\([^)]*\)/g, `require_once __DIR__ . '/${path$1.relative(path$1.dirname(absoluteFile), `${process.cwd()}/web/profiles/contrib/burst-drupal-distribution/includes/settings.php`)}'`))).catch(() => {// The error will be logged, and we will continue.
    })));
  }

  async drush(devtool, drushCommand, echo = false) {
    const drush = devtool === 'ddev' ? 'ddev . drush' : devtool === 'lando' ? 'lando drush' : `drush --root=${process.cwd()}`;
    const cmd = `${drush} -y ${drushCommand}`;

    if (echo) {
      await execa.command(cmd, {
        stdio: 'inherit'
      });
      return null;
    }

    return execa.command(cmd);
  }

  cleanComposer() {
    return Promise.all([rimraf(`${process.cwd()}/vendor`), rimraf(`${process.cwd()}/web/composer.json`), rimraf(`${process.cwd()}/web/composer.lock`), rimraf(`${process.cwd()}/web/core`), rimraf(`${process.cwd()}/web/modules/contrib`), rimraf(`${process.cwd()}/web/themes/contrib`), rimraf(`${process.cwd()}/web/profiles/contrib`), rimraf(`${process.cwd()}/drush/contrib`)]);
  }

  async composer(command, options = {}, retryCount = 0) {
    try {
      const res = await execa.command(`composer ${command} --ansi${command.startsWith('install') || command.startsWith('require') || command.startsWith('update') ? ' --no-progress --no-suggest' : ''}`, options);

      if (retryCount > 0) {
        console.log('This time, the command succeeded.');
      }

      return res;
    } catch (err) {
      const log = err && err.all;
      if (!log) throw err; // Match this log: https://github.com/cweagans/composer-patches/blob/9a08b4defec6f7fefed0d56051fe710d60e99652/src/Plugin/Patches.php#L338

      const cannotApplyMatch = log.match(/Cannot apply patch .* \(([^)]*)\)!/);

      if (cannotApplyMatch && retryCount > 0) {
        console.log(`Composer fails to apply patch ${cannotApplyMatch[1]}`);
        const composerJson = await this.readJsonFile(`${process.cwd()}/composer.json`);
        let composerJsonChanged = false;

        if (typeof composerJson === 'object' && typeof composerJson.extra === 'object' && typeof composerJson.extra.patches === 'object') {
          const {
            patches
          } = composerJson.extra;
          Object.keys(patches).forEach(module => {
            if (typeof patches[module] === 'object') {
              Object.keys(patches[module]).forEach(patchName => {
                if (patches[module][patchName] === cannotApplyMatch[1]) {
                  composerJsonChanged = true;
                  delete patches[module][patchName];
                }
              });

              if (Object.keys(patches[module]).length === 0) {
                delete patches[module];
              }
            }
          });
        }

        if (composerJsonChanged) {
          await write$1(`${process.cwd()}/composer.json`, JSON.stringify(composerJson));
          console.log(`Removed patch ${cannotApplyMatch[1]}`); // This makes sure that every package will be re-installed the next run.

          await this.cleanComposer(); // Something changed, so reset the retryCount.

          return this.composer(command, options);
        }

        console.log(`Could not find patch ${cannotApplyMatch[1]}, so can't fix.`);
      }

      if (retryCount < 3 && (cannotApplyMatch || log.includes("Uncaught Error: Class 'cweagans\\Composer\\PatchEvent' not found") || log.includes('Could not scan for classes inside '))) {
        console.log("Composer command failed because of a common error (so we don't show the full output).");
      } else {
        // Show the formatted output that Composer generated.
        console.log(log);
        console.log(`\n\n\nThe composer command failed: ${command}`);
      }

      if (retryCount < 3) {
        console.log('Deleting all composer folders...');
        await this.cleanComposer();
        console.log(`Re-running command (retry ${retryCount + 1})...`);
        return this.composer(command, options, retryCount + 1);
      }

      if (command.startsWith('require') && (await this.readJsonFile(`${process.cwd()}/composer.lock`).catch(() => null))) {
        console.log('Taking drastic measures... deleting composer.lock..');
        await removeFile(`${process.cwd()}/composer.lock`);
        return this.composer(command, options);
      }

      throw err;
    }
  }

  async accountForSlowDocker(devtool, promise) {
    try {
      return await promise();
    } catch (e) {
      if (!devtool) throw e;
      console.log('Retry in 40 seconds (could be slow Docker sync)');
      await new Promise(r => setTimeout(r, 40 * 1000));
      return promise();
    }
  }

  async clearCache(devtool) {
    await this.accountForSlowDocker(devtool, () => this.logPromise('cache clear', this.drush(devtool, 'cache-rebuild')));
  }

  async commit(msg, filesToAdd = '--all') {
    await Promise.all(this.actionsBeforeCommit.map(a => a()));

    try {
      await execa.command(`git add ${filesToAdd}`);

      if (!(await stagedFiles()).length) {
        throw new Error('Nothing to commit');
      }

      await this.logPromise('Linting & fixing changed files', execa.command(`${process.argv0} ${process.argv[1]} lint --fix --staged`, {
        reject: false
      }));

      if (!(await stagedFiles()).length) {
        throw new Error('Nothing to commit');
      }

      const {
        all
      } = await execa('git', ['commit', `-m ${msg}`, '--author="Bart Langelaan <bart@burst-digital.com>"', '--no-verify']);
      console.log(`\n\n${chalk.bgBlue('COMMIT')} ${all}\n\n`);
    } catch (err) {
      console.log(chalk.bgBlue('SKIPPED COMMIT'), err.all || err.message || err);
    }

    await Promise.all(this.actionsAfterCommit.map(a => a()));
  }

  async exportConfig(devtool) {
    await rimraf(`${process.cwd()}/config/**/*.yml`);
    await this.logPromise('config export', this.drush(devtool, 'config-export'));
  }

  async readJsonFile(file) {
    return JSON.parse((await read$1(file, 'utf8')));
  }

  async logPromise(label, promise) {
    const promiseDone = this.log.start(label);

    try {
      const p = await promise;
      promiseDone();
      return p;
    } catch (e) {
      process.stdout.write(`${chalk.bgRed('ERROR')} `);
      console.timeEnd(label);
      throw e;
    }
  }

}

const isCI$4 = require('is-ci');

class TestCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'test');

    _defineProperty(this, "description", 'Uses testcafe to execute all tests in this repository');

    _defineProperty(this, "options", [{
      flags: '--browsers <browserlist>',
      description: 'Define a comma separated list of browsers to run tests on. Will default to all installed browsers.'
    }]);

    _defineProperty(this, "action", async ({
      browsers = ''
    }) => {
      try {
        console.log('\n\n');
        const root = getRepoRoot();

        if (!(await exists(`${root}/tests/testcafe`))) {
          throw new Error('There does not exist a directory /tests/testcafe in the root of this reporitory. This is currently the only place where tests can be placed.');
        }

        if (isCI$4) {
          console.log('INSTALLING NPM DEPENDENCIES');
          console.log('(should contain testcafe)');
          await execa.command('npm i', {
            cwd: root,
            stdio: 'inherit'
          });
        }

        let testBrowsers = browsers || isCI$4 && 'firefox:headless,chromium:headless';

        if (!testBrowsers) {
          console.log('Checking installed browsers...');
          testBrowsers = (await execa.command('testcafe --list-browsers', {
            preferLocal: true
          })).stdout.split('\n').join(',');
        }

        console.log(`Will test on these browsers: ${testBrowsers}`);
        const extraArgs = isCI$4 ? ' --reporter slack-errors-only' : '';
        await execa.command(`testcafe ${testBrowsers} tests/testcafe/**/* ${extraArgs}`, {
          preferLocal: true,
          stdio: 'inherit',
          env: {
            TESTCAFE_SLACK_CHANNEL: 'test-reports',
            TESTCAFE_SLACK_BOT: 'TestCafé Bot'
          }
        });
      } catch (error) {
        if (isCI$4) {
          console.log('A fatal error occured. Alerting in Slack...');
          await sendTestFailedMessage(error).catch(e => console.error(e));
        }

        throw error;
      }
    });
  }

}

class StartCommand extends Command {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "command", 'start');

    _defineProperty(this, "description", 'Start apps on your local environment.');
  }

  async action() {
    const one = ink.render(React__default.createElement(StartInstall, null));
    await one.waitUntilExit();
    one.cleanup();
    const two = ink.render(React__default.createElement(ink.Box, {
      marginTop: 1
    }, React__default.createElement(ink.Text, {
      bold: true
    }, "Step 2 - Scaffold project")));
    two.unmount();
    await new ScaffoldCommand().action();
    const three = ink.render(React__default.createElement(DownloadMounts, null));
    await three.waitUntilExit();
    three.cleanup();
    const four = ink.render(React__default.createElement(StartDdevs, null));
    await four.waitUntilExit();
    four.cleanup();
    const five = ink.render(React__default.createElement(ink.Box, {
      marginTop: 1
    }, React__default.createElement(ink.Text, {
      bold: true
    }, "Step 5 - Sync database from Platform.sh")));
    five.unmount();
    await new SyncPlatformToDdevCommand().action();
    const six = ink.render(React__default.createElement(ink.Box, {
      marginTop: 1
    }, React__default.createElement(ink.Text, {
      bold: true
    }, "Step 6 - Profit!")));
    six.unmount();
  }

}

function StartInstall() {
  const [lockfiles, setLockfiles] = React.useState();
  React.useEffect(() => {
    getListOfRepoFiles(['package-lock.json', '*/package-lock.json', 'yarn.lock', '*/yarn.lock', 'composer.lock', '*/composer.lock'], true).then(f => setLockfiles(f));
  }, []);
  const [lockfileResults, setLockfileResults] = React.useState([]);
  const onLockfileComplete = React.useCallback(success => {
    setLockfileResults(r => [...r, success]);
  }, []);
  useExit(!!lockfiles && lockfileResults.length === lockfiles.length);
  return React__default.createElement(ink.Box, {
    flexDirection: "column"
  }, React__default.createElement(ink.Text, {
    bold: true
  }, "Step 1 - Install dependencies"), !lockfiles ? React__default.createElement(ink.Text, {
    italic: true
  }, "Finding lockfiles in repository...") : lockfiles.map(file => React__default.createElement(InstallLockfile, {
    file: file,
    key: file,
    onComplete: onLockfileComplete
  })));
}

function InstallLockfile(props) {
  const absolutePath = `${repoRoot}/${props.file}`;
  const command = absolutePath.endsWith('/package-lock.json') ? 'npm i' : absolutePath.endsWith('/yarn.lock') ? 'yarn' : 'composer install --no-interaction';
  const [install, setInstall] = React.useState();
  React.useEffect(() => {
    execa.command(command, {
      cwd: path$1.dirname(absolutePath),
      env: {
        NODE_ENV: 'development'
      },
      reject: false
    }).then(r => setInstall(r));
  }, [absolutePath, command]);
  const {
    onComplete
  } = props;
  React.useEffect(() => {
    if (install) onComplete(!install.failed);
  }, [install, onComplete]);
  return React__default.createElement(ink.Text, null, "Running ", React__default.createElement(ink.Text, {
    color: "cyan"
  }, command), " for", ' ', React__default.createElement(ink.Text, {
    color: "cyan"
  }, props.file), !install ? React__default.createElement(ink.Text, null, "...") : install.failed ? ' failed.' : ' completed.');
}

function DownloadMounts() {
  const ddevConfig = React.useMemo(() => getDdevConfigurations(), []);
  const [downloadResults, setDownloadResults] = React.useState([]);
  const onDownloadComplete = React.useCallback(success => {
    setDownloadResults(r => [...r, success]);
  }, []);
  useExit(downloadResults.length === ddevConfig.length);
  return React__default.createElement(ink.Box, {
    flexDirection: "column",
    marginTop: 1
  }, React__default.createElement(ink.Text, {
    bold: true
  }, "Step 3 - Download files from Platform.sh"), ddevConfig.map((c, i) => // eslint-disable-next-line react/no-array-index-key
  React__default.createElement(DownloadMount, {
    config: c,
    key: i,
    onComplete: onDownloadComplete
  })));
}

function DownloadMount(props) {
  const cmd = `platform mount:download --project=${props.config.platformProject} --environment=master --app=${props.config.platformApp} --all --target=${props.config.app.path}`;
  const download = useExeca(cmd);
  const {
    onComplete
  } = props;
  React.useEffect(() => {
    if (download) onComplete(!download.failed);
  }, [download, onComplete]);
  return React__default.createElement(ink.Text, null, "Files of app ", React__default.createElement(ink.Text, {
    color: "cyan"
  }, props.config.platformApp), " are", ' ', !download ? 'downloading...' : download.failed ? `not downloaded, because of a failure.\nYou can try to run this command manually:\n${cmd}\n` : 'downloaded!');
}

function StartDdevs() {
  const ddevConfig = React.useMemo(() => getDdevConfigurations(), []);
  const [downloadResults, setDownloadResults] = React.useState([]);
  const onDownloadComplete = React.useCallback(success => {
    setDownloadResults(r => [...r, success]);
  }, []);
  useExit(downloadResults.length === ddevConfig.length);
  return React__default.createElement(ink.Box, {
    flexDirection: "column",
    marginTop: 1
  }, React__default.createElement(ink.Text, {
    bold: true
  }, "Step 4 - Start ddev apps"), ddevConfig.map((c, i) => React__default.createElement(StartDdev, {
    cwd: c.projectRoot // eslint-disable-next-line react/no-array-index-key
    ,
    key: i,
    onComplete: onDownloadComplete
  })));
}

function StartDdev(props) {
  const download = useExeca('ddev start', React.useMemo(() => ({
    cwd: props.cwd
  }), [props.cwd]));
  const {
    onComplete
  } = props;
  React.useEffect(() => {
    if (download) onComplete(!download.failed);
  }, [download, onComplete]);
  return React__default.createElement(ink.Text, null, "Ddev in ", React__default.createElement(ink.Text, {
    color: "cyan"
  }, props.cwd), !download ? ' starting...' : download.failed ? ` did not start, because of a failure.\nYou can try to run 'ddev start' manually.` : ' started!');
}

/**
 * All available commands are listed here.
 */

const commands = [CheckCommand, LintCommand, DeployCommand, ScaffoldCommand, PrepareCICommand, InstallCommand, UpdateDrupalCommand, TestCommand, SyncPlatformToDdevCommand, StartCommand];
/**
 * This registers all commands to commander.
 */

function registerCommands(commander) {
  commands.forEach(CommandClass => {
    // Create an instance of the command class.
    const command = new CommandClass(); // Declare the command and it's description from the instance.

    const commanderCommand = commander.command(command.command).description(command.description); // All commands should execute the 'checkFirst' function, except the 'check' command.

    if (command.command === 'check') {
      commanderCommand.action(command.action);
    } else {
      commanderCommand.action(checkFirst(command.action));
    } // Add all options to the command.


    command.options.forEach(opt => commanderCommand.option(opt.flags, opt.description));
  });
}

/* eslint-disable no-console */
process.stdout.columns = process.stdout.columns || 80; // Add the current version to the commander instance. This is used when
// running `burst --version`.

const pkg = require('../package.json');

commander.version(pkg.version); // Add all available commands to the commander.
// You can see all available commands in ./commands/index.tsx.

registerCommands(commander); // When the command isn't found, show an error.

commander.on('command:*', checkFirst(() => {
  console.log(chalk`Command {magenta ${commander.args.join(' ')}} not found.`);
  process.exit(1);
})); // Parse the argumens passed to the process. This actually executes the
// registered commands.

commander.parse(process.argv); // If there was no command entered (just 'burst'), show help.

if (!process.argv.slice(2).length) {
  commander.help();
}