@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 jsYaml = require('js-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 = 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.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.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;
};

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

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

var isPure = false;

var shared = createCommonjsModule(function (module) {
var SHARED = '__core-js_shared__';
var store = global[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.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.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) {
    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;
  } else if (STATIC) {
    target = global[TARGET] || setGlobal(TARGET, {});
  } else {
    target = (global[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.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.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.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.setImmediate;
var clear = global.clearImmediate;
var process$1 = global.process;
var MessageChannel = global.MessageChannel;
var Dispatch = global.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.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
    defer = function (id) {
      global.postMessage(id + '', '*');
    };
    global.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.navigator;

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

var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;

var macrotask = task.set;

var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
var process$2 = global.process;
var Promise$1 = global.Promise;
var IS_NODE = classofRaw(process$2) == 'process';
// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global, '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, 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.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;

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[namespace])
    : path[namespace] && path[namespace][method] || global[namespace] && global[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[PROMISE];
var TypeError$1 = global.TypeError;
var document$3 = global.document;
var process$3 = global.process;
var $fetch = global.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.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.dispatchEvent(event);
  } else event = { promise: promise, reason: reason };
  if (handler = global['on' + name]) handler(event);
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
};

var onUnhandled = function (promise, state) {
  task$1.call(global, 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, 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, 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 ? 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 {
  /**
   * Definitions of the command.
   */
  constructor() {
    _defineProperty(this, "command", void 0);

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

    _defineProperty(this, "options", []);
  }
  /**
   * What gets executed when this command runs.
   */


}

// 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) {
  const [execaResult, setExecaResult] = React__default.useState();
  React__default.useEffect(() => {
    const p = execa.command(cmd, {
      reject: false
    });
    p.then(r => {
      if (r.killed) return;
      setExecaResult(r);
    });
    return () => p.kill();
  }, [cmd]);
  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.Color, {
    cyan: true
  }, typeof version === 'string' ? version : version.format());
}

function usePHPCheck() {
  const phpV = useExeca('php -v');
  const version = phpV ? 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 >= 1) {
    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.Ok,
    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.1"
    }), ".")
  };
}

function useExit(shouldExit, error) {
  const {
    exit
  } = React__default.useContext(ink.AppContext);
  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.124";

/* eslint-disable no-console */
function UpdateBurstCli() {
  const updateCommand = useExeca('npm i -g @burst/cli');
  React__default.useEffect(() => {
    if (updateCommand) {
      console.log('Burst CLI updated, please re-run your command.');
      console.log();
      process.exit(1);
    }
  }, [updateCommand]);

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

  return null;
}
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) {
      const a = ink.render(React__default.createElement(Check, {
        onlyDisplayErrors: true
      }));
      await a.waitUntilExit(); // @ts-ignore

      a.cleanup();
    }

    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
  }, c.type === CheckStatusType.Loading ? '⌚' : c.type === CheckStatusType.Warning ? '🚧' : c.type === CheckStatusType.Error ? '❌' : c.type === CheckStatusType.LoadingError ? '❌' : '👍'), React__default.createElement(ink.Box, {
    width: 12
  }, n), React__default.createElement(ink.Box, {
    textWrap: "wrap",
    flexGrow: 1
  }, c.message))), !checksLoaded && React__default.createElement(ink.Box, {
    marginTop: 1,
    marginBottom: 1
  }, "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 = 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,
  showProgress
} = {}) {
  // 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: showProgress && !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'], showProgress ? {
      stdio: 'inherit'
    } : undefined);
  } 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', ['doTsCheck']);
}
function usePrettierWorker() {
  return useWorker('./workers/prettier', ['getFileInfo', 'format']);
}
function useEslintWorker() {
  return useWorker('./workers/eslint', ['lintFile', 'writeToDisk']);
}

function useWorker(path, exposedMethods) {
  const exposedMethodsJson = JSON.stringify(exposedMethods);
  const worker = React.useMemo(() => new Worker(require.resolve(path), {
    exposedMethods: JSON.parse(exposedMethodsJson)
  }), [exposedMethodsJson, path]);
  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 (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 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
    });
  });
  return {
    files,
    reports,
    filesAutoFixed,
    errors,
    done: reports.length + Object.keys(execErrors).length === files.length
  };
}

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 = jsYaml.safeLoad(burstYaml);
  const gitlabConfig = jsYaml.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 path = getPathFromDir(dir);
    return {
      name,
      type,
      dir,
      path,
      options: app,
      disableLinting: !!app.disableLinting
    };
  }) : [];

  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 usesProjectTemplate = 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,
    deployEnabled: variableFlag(vars, 'BURST_DEPLOY', true),
    lintEnabled: variableFlag(vars, 'BURST_LINT', usesProjectTemplate),
    lintStylesEnabled: variableFlag(vars, 'BURST_LINT_STYLES', usesProjectTemplate),
    lintPhpEnabled: variableFlag(vars, 'BURST_LINT_PHP', usesProjectTemplate)
  };
}

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
    !!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 envsMax = this.project.platformProject.data.subscription.environments + 1;
    const envsToBeUsed = this.environments.filter(e => e === this || e.isActive()).length;
    const mirrorPossible = envsToBeUsed <= envsMax || this.environments.some(e => e.model.id === 'mirror');
    let newParent = this.project.isEnterpriseProject || this.getDeployTarget() !== DeployTarget.Dynamic ? 'master' : !this.model.new && this.model.parent === 'staging' && this.environments.some(e => e.model.id === 'staging' && e.isActive()) && this.isActive() ? 'staging' : 'mirror';

    if (newParent === 'staging' && mirrorPossible && !process.env.CI) {
      const {
        transfer
      } = await inquirer.prompt([{
        type: 'confirm',
        name: 'transfer',
        message: `Do you want to change the parent from 'staging' to 'mirror'? The staging environment is deprecated.`
      }]);

      if (transfer) {
        newParent = '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) {
        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) {
        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) {
        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.");
          await this.catchTooManyEnvironments(() => {
            if (m.model.new) throw new Error('Not possible.');
            return m.model.branch('Mirror', newParent);
          });
        } else if (!p.isActive()) {
          await this.catchTooManyEnvironments(() => {
            if (p.model.new) throw new Error('Not possible.');
            return p.model.activate();
          });
        }
      }

      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.catchTooManyEnvironments(() => {
          if (this.model.new) throw new Error('Not possible');
          return this.model.activate();
        });
        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,
      showProgress: true
    });
  }

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

  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();
      return 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') : '{}', isFile(gitlabYamlPath) ? fs.readFileSync(gitlabYamlPath, 'utf8') : '{}', 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 => {
      // If the app doesn't have any hosting places defined, continue to the next app.
      if (typeof app.options.hosting === 'undefined') return; // Get all hosting configs

      const hostingConfigs = Array.isArray(app.options.hosting) ? app.options.hosting : [app.options.hosting];
      hostingConfigs.forEach(hc => {
        // Verify that what we got is actually an object.
        if (typeof hc !== 'object' || typeof hc.type !== 'string') {
          throw new Error('Please check your burst.yaml file.');
        }

        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 => 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 () => {
      // The arguments we need to pass to the phpcs and phpcbf commands.
      const args = [...chunkFiles.map(f => f.absolutePath), '-q', `--standard=${standard}`]; // 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); // 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.

      chunkFiles.forEach(f => {
        if (!result.files[f.absolutePath]) result.files[f.absolutePath] = {
          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) {
  return JSON.parse(result);
}

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.Box, null, "Listing all files in this repository...");
  }

  if (filePaths.length === 0) {
    return React__default.createElement(ink.Box, 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
  }, "Git"), React__default.createElement(ink.Box, null, "Found ", React__default.createElement(ink.Color, {
    cyan: true
  }, props.files.length), " files.")), !!eslint.files.length && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, "ESLint"), React__default.createElement(ink.Box, 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
  }, "Prettier"), React__default.createElement(ink.Box, 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
  }, "Typescript"), tsChecker.done ? React__default.createElement(ink.Box, null, "Typechecked projects, found", ' ', React__default.createElement(ErrorCount, {
    errors: tsChecker.errors.length
  }), ".") : React__default.createElement(ink.Box, 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
  }, "PHPCS"), React__default.createElement(ink.Box, 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
  }, "PHPCS"), React__default.createElement(ink.Box, null, React__default.createElement(ink.Text, {
    italic: true
  }, "Disabled."))), !!stylelint.filesToLint && React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, "Stylelint"), React__default.createElement(ink.Box, null, stylelint.done ? 'Linted' : 'Linting', ' ', React__default.createElement(ink.Color, {
    cyan: true
  }, 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
  }, "Stylelint"), React__default.createElement(ink.Box, null, React__default.createElement(ink.Text, {
    italic: true
  }, "Disabled."))), React__default.createElement(ink.Box, null, React__default.createElement(ink.Box, {
    width: 15
  }, "Time"), React__default.createElement(ink.Box, 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.Color, {
    grey: true
  }, "If you run ", React__default.createElement(ink.Color, {
    red: true
  }, "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"
  }, errors), React__default.createElement(ink.Box, {
    textWrap: "wrap"
  }, 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
  }, error.autoFixable ? '✨' : ''), React__default.createElement(ink.Box, {
    width: 10
  }, error.linter), React__default.createElement(ink.Box, {
    width: 10
  }, error.sourceLocation ? React__default.createElement(ink.Color, {
    grey: true,
    blue: true
  }, error.sourceLocation.start.line, ":", error.sourceLocation.start.column) : null), React__default.createElement(ink.Box, {
    textWrap: "wrap"
  }, error.message, " ", !!error.rule && React__default.createElement(ink.Color, {
    grey: true
  }, error.rule))), verbose && error.rawlines && error.sourceLocation && codeFrame.codeFrameColumns(error.rawlines, error.sourceLocation));
}

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

function NumberOfTotal(props) {
  return React__default.createElement(React__default.Fragment, null, React__default.createElement(ink.Color, {
    cyan: true
  }, props.number), props.number !== props.total && React__default.createElement(React__default.Fragment, null, ' ', "/ ", React__default.createElement(ink.Color, {
    cyan: true
  }, 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
    });
  };
}

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
          ...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)');
}

// `IsArray` abstract operation
// https://tc39.github.io/ecma262/#sec-isarray
var isArray = Array.isArray || function isArray(arg) {
  return classofRaw(arg) == 'Array';
};

// `FlattenIntoArray` abstract operation
// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
var flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
  var targetIndex = start;
  var sourceIndex = 0;
  var mapFn = mapper ? bindContext(mapper, thisArg, 3) : false;
  var element;

  while (sourceIndex < sourceLen) {
    if (sourceIndex in source) {
      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];

      if (depth > 0 && isArray(element)) {
        targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;
      } else {
        if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length');
        target[targetIndex] = element;
      }

      targetIndex++;
    }
    sourceIndex++;
  }
  return targetIndex;
};

var flattenIntoArray_1 = flattenIntoArray;

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

// `ArraySpeciesCreate` abstract operation
// https://tc39.github.io/ecma262/#sec-arrayspeciescreate
var arraySpeciesCreate = function (originalArray, length) {
  var C;
  if (isArray(originalArray)) {
    C = originalArray.constructor;
    // cross-realm fallback
    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
    else if (isObject(C)) {
      C = C[SPECIES$4];
      if (C === null) C = undefined;
    }
  } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
};

// `Array.prototype.flat` method
// https://github.com/tc39/proposal-flatMap
_export({ target: 'Array', proto: true }, {
  flat: function flat(/* depthArg = 1 */) {
    var depthArg = arguments[0];
    var O = toObject(this);
    var sourceLen = toLength(O.length);
    var A = arraySpeciesCreate(O, 0);
    A.length = flattenIntoArray_1(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));
    return A;
  }
});

// this method was added to unscopables after implementation
// in popular engines, so it's moved to a separate module
addToUnscopables('flat');

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 access = util.promisify(fs__default.access);
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 this.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');
      const rootApp = apps.find(a => a.dir === undefined);
      const rootRuleset = rootApp ? rootApp.type : 'other';
      const paths = {};
      appTypes.filter(t => t !== rootRuleset).forEach(t => {
        paths[t] = apps.filter(a => a.type === t).map(a => [a.path, `phpcs_temp.tmp/${a.dir}`]).flat();
      });
      const allNotOtherPaths = Object.values(paths).flat();
      const phpcsRuleset = ['<?xml version="1.0"?>', '<ruleset name="Auto-generated ruleset for this project by the Burst CLI" namespace="Burst">', `  <rule ref="${composerHelperDir}/${rootRuleset}_ruleset.xml">`, ...allNotOtherPaths.map(p => `    <exclude-pattern>${p}</exclude-pattern>`), `  </rule>`, ...Object.entries(paths).map(([type, ps]) => ps.length ? `  <rule ref="${composerHelperDir}/${type}_ruleset.xml">\n${ps.map(p => `    <include-pattern>${p}</include-pattern>\n`).join('')}  </rule>` : `  <!-- 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 this.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
        if (!(await this.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 this.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 this.exists(`${repoRoot}/.idea/inspectionProfiles`))) {
            await mkdir(`${repoRoot}/.idea/inspectionProfiles`);
            console.log('🔥 Created .idea/inspectionProfiles');
          }

          if (!(await this.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.
        'eslint.autoFixOnSave': true,
        'eslint.validate': ['javascript', 'javascriptreact', {
          language: 'typescript',
          autoFix: true
        }, {
          language: 'typescriptreact',
          autoFix: 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
        },
        'phpSniffer.executablesFolder': `${composerHelperDir}/vendor/bin/`,
        'phpSniffer.standard': `${repoRoot}/phpcs.xml`,
        'phpSniffer.run': 'onType',
        'phpcs.executablePath': `${composerHelperDir}/vendor/bin/phpcs`,
        'phpcs.standard': `${repoRoot}/phpcs.xml`,
        '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 this.exists(`${repoRoot}/.vscode`))) {
        await mkdir(`${repoRoot}/.vscode`);
        console.log('🔥 Created .vscode');
      }

      if (!(await this.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.
      ...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'); // 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.', '', '.vscode', '.idea', 'phpcs.xml', '', '# 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');
      }
    });
  }

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

  async exists(somePath) {
    return access(somePath).then(() => true).catch(() => false);
  }

}

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); // Always run Composer commands without memory limit.

process.env.COMPOSER_MEMORY_LIMIT = '-1';
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, "unstageFiles", []);

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

    _defineProperty(this, "action", async ({
      db
    }) => {
      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 platform = app.options && isObject$1(app.options.hosting) && app.options.hosting.type === 'platform' && typeof app.options.hosting.id === 'string' && app.options.hosting.id;

        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 = jsYaml.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}

      `); // 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'));
        await this.lint(); // 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'; // 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, `
            $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',
            ];
          `);
          this.unstageFiles.push(settingsPath);
        } // 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.logPromise('database download', execa.command(`platform db:dump --project ${platform} --environment master --directory . --file drupal--dump.sql --app ${platformApp} --yes`)); // 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); // Exported files shouldn't be linted by the burst linter, but let's just be safe here ;-)

          await this.lint();
          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.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'));
        await this.clearCache(devtool);
        await this.accountForSlowDocker(devtool, () => this.logPromise('update database', this.drush(devtool, 'updb')));

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

        await this.lint();
        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, "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');
    await this.lint();
    l();
  }

  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');
      this.log.start('database import');
      await this.logPromise('database import', execa.command(`${connectionCommand.all} < drupal--dump.sql`, {
        shell: true
      }));
    }
  }

  async addBurstDrupalDistribution() {
    let 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.logPromise('Removing legacy Burst distribution', this.composer('remove burst/drupal-distribution'));
      await this.applyComposerConfig();
      await this.commit('refactor(drupal): remove legacy Burst distribution');
    }

    console.log('Installing latest version of the Burst distribution.');
    await this.upgradeDistributionSettingsCall();

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

      if (typeof composerJson.scripts === 'object') {
        Object.entries(composerJson.scripts).forEach(([key, value]) => {
          const newValue = (Array.isArray(value) ? value : [value]).filter(s => !s.startsWith('DrupalProject\\') && !s.startsWith('DrupalComposer\\') && s !== '@drupal-scaffold'); // 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];
        });
      }

      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, null, 4));
      configChangesDone();
    }

    const packagesInLatest = [// In the last version of the Burst distribution
    'composer/installers', 'cweagans/composer-patches', 'drupal/admin_toolbar', 'drupal/config_ignore', 'drupal/core', 'drupal/core-composer-scaffold', 'drupal/devel', 'drupal/paragraphs', 'drupal/pathauto', 'drupal/simple_sitemap', 'drush/drush', // Not needed anymore
    'drupal-composer/drupal-scaffold', 'drupal/console'];
    await this.logPromise('Remove packages that are part of the latest Burst distribution', this.composer(`remove ${packagesInLatest.join(' ')}`));
    await this.logPromise('Add latest Burst distribution', this.composer('require burst/drupal-distribution --update-with-all-dependencies'));
    await this.lint();
    await this.commit('feat(drupal): add Burst distribution');
  }

  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/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;
      const cannotApplyMatch = log.match(/Cannot apply patch [^(]* \(([^)]*)\)/);

      if (cannotApplyMatch) {
        const composerFile = `${process.cwd()}/composer.json`;
        const contents = await read$1(composerFile, 'utf8');
        const newContents = contents.replace(new RegExp(`,?\\s*"[^"]*":\\s"${cannotApplyMatch[1]}"`), '');

        if (contents !== newContents) {
          await write$1(composerFile, newContents);
          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.`);
      } // 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);
      }

      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 = '.') {
    await execa.command(`git add ${filesToAdd}`);

    if (this.unstageFiles.length) {
      await execa.command(`git reset -- ${this.unstageFiles.join(' ')}`);
    }

    if (!(await stagedFiles()).length) {
      console.log(`${chalk.bgBlue('EMPTY COMMIT SKIPPED')} ${msg}\n\n`);
      return;
    }

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

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

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

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

}

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

const commands = [CheckCommand, LintCommand, DeployCommand, ScaffoldCommand, PrepareCICommand, InstallCommand, UpdateDrupalCommand];
/**
 * 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 */
// 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();
}