@slicemachine/init 1.1.19 → 2.0.1

package/build/index.js

@@ -1,3388 +0,0 @@
-#!/usr/bin/env node
-
-'use strict';
-
-const client = require('@slicemachine/client');
-const Prismic = require('@slicemachine/core/build/prismic');
-const ServerAnalytics = require('analytics-node');
-const uuid = require('uuid');
-const path = require('path');
-const util = require('util');
-const child_process = require('child_process');
-const chalk = require('chalk');
-const ora = require('ora');
-const core = require('@slicemachine/core');
-const hapi = require('@hapi/hapi');
-const open = require('open');
-const t$5 = require('io-ts');
-const cookie = require('@slicemachine/core/build/utils/cookie');
-const fs = require('fs');
-const NodeUtils = require('@slicemachine/core/build/node-utils');
-const inquirer = require('inquirer');
-const Separator = require('inquirer/lib/objects/separator');
-const tmp = require('tmp');
-const AdmZip = require('adm-zip');
-const fsExtra = require('fs-extra');
-const axios = require('axios');
-const Either = require('fp-ts/Either');
-const models = require('@slicemachine/core/build/models');
-const Libraries = require('@slicemachine/core/build/libraries');
-const customtypes = require('@prismicio/types-internal/lib/customtypes');
-const Either$1 = require('fp-ts/lib/Either');
-const SharedConfig = require('@slicemachine/core/build/prismic/SharedConfig');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      if (k !== 'default') {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    }
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-const Prismic__namespace = /*#__PURE__*/_interopNamespace(Prismic);
-const Prismic__default = /*#__PURE__*/_interopDefaultLegacy(Prismic);
-const ServerAnalytics__default = /*#__PURE__*/_interopDefaultLegacy(ServerAnalytics);
-const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-const util__default = /*#__PURE__*/_interopDefaultLegacy(util);
-const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
-const ora__default = /*#__PURE__*/_interopDefaultLegacy(ora);
-const hapi__namespace = /*#__PURE__*/_interopNamespace(hapi);
-const open__default = /*#__PURE__*/_interopDefaultLegacy(open);
-const t__namespace = /*#__PURE__*/_interopNamespace(t$5);
-const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-const NodeUtils__namespace = /*#__PURE__*/_interopNamespace(NodeUtils);
-const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
-const inquirer__default = /*#__PURE__*/_interopDefaultLegacy(inquirer);
-const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
-const tmp__default = /*#__PURE__*/_interopDefaultLegacy(tmp);
-const AdmZip__default = /*#__PURE__*/_interopDefaultLegacy(AdmZip);
-const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
-const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-const Libraries__namespace = /*#__PURE__*/_interopNamespace(Libraries);
-
-const noop = () => void 0;
-
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var _client, _isTrackingActive, _anonymousId, _userId, _repository;
-var EventType;
-(function(EventType2) {
-  EventType2["DownloadLibrary"] = "SliceMachine Download Library";
-  EventType2["InitStart"] = "SliceMachine Init Start";
-  EventType2["InitIdentify"] = "SliceMachine Init Identify";
-  EventType2["InitEnd"] = "SliceMachine Init End";
-})(EventType || (EventType = {}));
-class InitTracker {
-  constructor() {
-    __privateAdd(this, _client, null);
-    __privateAdd(this, _isTrackingActive, true);
-    __privateAdd(this, _anonymousId, "");
-    __privateAdd(this, _userId, null);
-    __privateAdd(this, _repository, null);
-  }
-  initialize(segmentKey, isTrackingActive = true) {
-    try {
-      if (!!__privateGet(this, _client))
-        return;
-      __privateSet(this, _isTrackingActive, isTrackingActive);
-      __privateSet(this, _anonymousId, uuid.v4());
-      __privateSet(this, _client, new ServerAnalytics__default["default"](segmentKey, {
-        flushAt: 1,
-        errorHandler: noop
-      }));
-    } catch (error) {
-    }
-  }
-  _trackEvent(eventType, attributes = {}) {
-    return new Promise((resolve) => {
-      if (!this._isTrackingPossible(__privateGet(this, _client))) {
-        return resolve();
-      }
-      const identifier = this._createSegmentIdentifier();
-      const payload = {
-        event: eventType,
-        ...identifier,
-        properties: attributes,
-        ...__privateGet(this, _repository) ? { context: { groupId: { Repository: __privateGet(this, _repository) } } } : {}
-      };
-      return __privateGet(this, _client).track(payload, () => {
-        return resolve();
-      });
-    });
-  }
-  _identifyEvent(userId, intercomHash) {
-    if (!this._isTrackingPossible(__privateGet(this, _client))) {
-      return;
-    }
-    try {
-      __privateGet(this, _client).identify({
-        userId,
-        anonymousId: __privateGet(this, _anonymousId),
-        integrations: {
-          Intercom: {
-            user_hash: intercomHash
-          }
-        }
-      });
-    } catch (e) {
-    }
-  }
-  _isTrackingPossible(client) {
-    return !!client && __privateGet(this, _isTrackingActive);
-  }
-  _createSegmentIdentifier() {
-    return !!__privateGet(this, _userId) ? { userId: __privateGet(this, _userId) } : { anonymousId: __privateGet(this, _anonymousId) };
-  }
-  setRepository(repository) {
-    __privateSet(this, _repository, repository);
-  }
-  identifyUser(userId, intercomHash) {
-    __privateSet(this, _userId, userId);
-    return this._identifyEvent(userId, intercomHash);
-  }
-  trackDownloadLibrary(library) {
-    return this._trackEvent(EventType.DownloadLibrary, { library });
-  }
-  trackInitIdentify() {
-    return this._trackEvent(EventType.InitIdentify);
-  }
-  trackInitStart(repoDomain) {
-    if (repoDomain)
-      this.setRepository(repoDomain);
-    return this._trackEvent(EventType.InitStart, { repo: repoDomain });
-  }
-  trackInitEndSuccess(framework) {
-    return this._trackEvent(EventType.InitEnd, {
-      framework,
-      repo: __privateGet(this, _repository),
-      result: "success"
-    });
-  }
-  trackInitEndFail(framework, error) {
-    return this._trackEvent(EventType.InitEnd, {
-      framework,
-      repo: __privateGet(this, _repository),
-      result: "error",
-      error
-    });
-  }
-}
-_client = new WeakMap();
-_isTrackingActive = new WeakMap();
-_anonymousId = new WeakMap();
-_userId = new WeakMap();
-_repository = new WeakMap();
-const Tracker = (() => {
-  let smTrackerInstance;
-  const init = () => new InitTracker();
-  return {
-    get() {
-      if (!smTrackerInstance)
-        smTrackerInstance = init();
-      return smTrackerInstance;
-    }
-  };
-})();
-
-const purple = chalk__default["default"].hex("8c76fc");
-const error = chalk__default["default"].hex("FF6868");
-const warning = chalk__default["default"].hex("F3AD38");
-const underline$1 = chalk__default["default"].underline;
-const bold$1 = chalk__default["default"].bold;
-const dim = chalk__default["default"].dim;
-const cyan = chalk__default["default"].cyan;
-const yellow = chalk__default["default"].yellow;
-const white = chalk__default["default"].white;
-const spinner$1 = ora__default["default"];
-const writeError$1 = (msg, prefix = "Error!") => console.error(`${error(prefix)} ${msg}`);
-const writeWarning = (msg, prefix = "Warning!") => console.warn(`${warning(prefix)} ${msg}`);
-const writeCheck = (msg) => {
-  ora__default["default"]().succeed(msg);
-};
-const writeInfo = (msg) => {
-  console.log(`${yellow("\u2139")} ${dim(msg)}`);
-};
-
-const logs = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  purple: purple,
-  error: error,
-  warning: warning,
-  underline: underline$1,
-  bold: bold$1,
-  dim: dim,
-  cyan: cyan,
-  yellow: yellow,
-  white: white,
-  spinner: spinner$1,
-  writeError: writeError$1,
-  writeWarning: writeWarning,
-  writeCheck: writeCheck,
-  writeInfo: writeInfo
-});
-
-const { Cookie } = core.Utils;
-const { DEFAULT_BASE, DEFAULT_SERVER_PORT } = core.CONSTS;
-const { bold, underline, spinner, writeError } = logs;
-const isHandlerData = (data) => {
-  if (typeof data != "object")
-    return false;
-  const { email, cookies } = data;
-  return Boolean(email && cookies) && Array.isArray(cookies) && !cookies.some((c) => typeof c !== "string");
-};
-const Routes = {
-  authentication: (server) => (onSuccess, onFail) => ({
-    method: "POST",
-    path: "/",
-    handler: authenticationHandler(server)(onSuccess, onFail)
-  }),
-  notFound: {
-    method: ["GET", "POST"],
-    path: "/{any*}",
-    handler: (request, h) => {
-      return h.response(`not found: [${request.method}]: ${request.url.toString()}`).code(404);
-    }
-  }
-};
-function validatePayload(payload) {
-  if (Buffer.isBuffer(payload))
-    return null;
-  return isHandlerData(payload) ? payload : null;
-}
-const authenticationHandler = (server) => (onSuccess, onFail) => {
-  return (request, h) => {
-    try {
-      const data = validatePayload(request.payload);
-      if (!data) {
-        onFail();
-        h.response("Error with cookies").code(400);
-        throw new Error("It seems the server didn't respond properly, please contact us.");
-      }
-      onSuccess(data);
-      return h.response(data).code(200);
-    } finally {
-      void server.stop({ timeout: 1e4 });
-    }
-  };
-};
-function stripTrailingSlash(str) {
-  return str.endsWith("/") ? str.slice(0, -1) : str;
-}
-function buildServer(base, port, host) {
-  const server = hapi__namespace.server({
-    port,
-    host,
-    routes: {
-      cors: {
-        origin: [stripTrailingSlash(base)],
-        headers: ["Origin", "X-Requested-With", "Content-Type", "Accept"]
-      }
-    }
-  });
-  return server;
-}
-function askSingleChar(title) {
-  return new Promise((resolve) => {
-    process.stdout.write(title);
-    const rawMode = process.stdin.isRaw;
-    if (process.stdin.setRawMode)
-      process.stdin.setRawMode(true);
-    function handler(key) {
-      const response = key.toString("utf-8");
-      if (process.stdin.setRawMode)
-        process.stdin.setRawMode(Boolean(rawMode));
-      process.stdin.removeListener("data", handler);
-      resolve(response);
-    }
-    process.stdin.on("data", handler);
-  });
-}
-async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE, port = DEFAULT_SERVER_PORT) {
-  const confirmation = await askSingleChar(`>> Press any key to open the browser to ${action} or q to exit:`);
-  if (confirmation === "q" || confirmation === "")
-    return process.exit(-1);
-  const s = spinner("Waiting for the browser response");
-  const onLoginFail = () => {
-    s.stop();
-    writeError(`We failed to log you into your Prismic account`);
-    console.log(`Run ${bold("npx slicemachine init")} again!`);
-    process.exit(-1);
-  };
-  function onSuccess(data) {
-    s.succeed(`Logged in as ${bold(data.email)}`).stop();
-    Prismic.PrismicSharedConfigManager.setProperties({
-      cookies: Cookie.serializeCookies(data.cookies),
-      base
-    });
-  }
-  function onFail() {
-    onLoginFail();
-  }
-  const server = buildServer(base, port, "localhost");
-  server.route([
-    Routes.authentication(server)(onSuccess, onFail),
-    Routes.notFound
-  ]);
-  return server.start().then(() => {
-    console.log("\nOpening browser to " + underline(url));
-    s.start();
-    void open__default["default"](url);
-    return {
-      onLoginFail
-    };
-  });
-}
-
-async function startAuth({
-  client,
-  url,
-  action
-}) {
-  const { onLoginFail } = await startServerAndOpenBrowser(url, action, client.apisEndpoints.Wroom);
-  try {
-    await core.Utils.Poll.startPolling(() => Auth.validateSession(client), (isSessionValid) => isSessionValid == true, 3e3, 60);
-    return;
-  } catch (e) {
-    onLoginFail();
-  }
-}
-const Auth = {
-  login: async (client) => {
-    const endpoints = Prismic.Endpoints.buildEndpoints(client.apisEndpoints.Wroom);
-    return startAuth({
-      client,
-      url: endpoints.Dashboard.cliLogin,
-      action: "login"
-    });
-  },
-  validateSession: async (client) => {
-    const authToken = Prismic.PrismicSharedConfigManager.getAuth();
-    return client.updateAuthenticationToken(authToken).profile().then((userProfile) => {
-      Prismic.PrismicSharedConfigManager.setProperties({
-        shortId: userProfile.shortId,
-        intercomHash: userProfile.intercomHash
-      });
-      return true;
-    }).catch(() => false);
-  }
-};
-
-class InitClient extends client.Client {
-  async listRepositories() {
-    return client.getAndValidateResponse(this._get(`${this.apisEndpoints.Users}repositories`), "repository list", t__namespace.array(core.Models.Repository));
-  }
-  async createRepository(domain, framework) {
-    const data = {
-      domain,
-      framework,
-      plan: "personal",
-      isAnnual: "false",
-      role: "developer"
-    };
-    return this._fetch({
-      method: "post",
-      url: `${this.apisEndpoints.Wroom}authentication/newrepository?app=slicemachine`,
-      data,
-      headers: {
-        Cookie: Prismic.PrismicSharedConfigManager.get().cookies,
-        "User-Agent": "prismic-cli/sm"
-      }
-    }).then(() => domain);
-  }
-  async deleteRepository(domain, password, cookies) {
-    const repositoryDirectUrl = new URL(this.apisEndpoints.Wroom);
-    repositoryDirectUrl.hostname = `${domain}.${repositoryDirectUrl.hostname}`;
-    const token = cookie.parse(cookies).X_XSRF;
-    return this._fetch({
-      method: "post",
-      url: `${repositoryDirectUrl.toString()}app/settings/delete?_=${token}`,
-      data: { confirm: domain, password },
-      headers: {
-        Cookie: cookies,
-        "User-Agent": "prismic-cli/0"
-      }
-    }).then(() => domain);
-  }
-  async domainExist(domain) {
-    return client.getAndValidateResponse(this._get(`${this.apisEndpoints.Wroom}app/dashboard/repositories/${domain}/exists`), "repository exists", t__namespace.boolean);
-  }
-  async pushDocuments(signature, documents, cookies) {
-    if (!this.repository)
-      throw new Error("Repository undefined in the client");
-    const repositoryDirectUrl = new URL(this.apisEndpoints.Wroom);
-    repositoryDirectUrl.hostname = `${this.repository}.${repositoryDirectUrl.hostname}`;
-    return this._fetch({
-      method: "post",
-      url: `${repositoryDirectUrl.toString()}starter/documents`,
-      data: { signature, documents: JSON.stringify(documents) },
-      headers: {
-        Cookie: cookies,
-        "User-Agent": "prismic-cli/0"
-      }
-    });
-  }
-}
-
-async function lsdir(dir) {
-  return fs__default["default"].promises.readdir(dir).then((dirs) => {
-    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isDirectory()).map((subdirectory) => path__default["default"].join(dir, subdirectory));
-  });
-}
-async function lsfiles(dir) {
-  return fs__default["default"].promises.readdir(dir).then((dirs) => {
-    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isFile()).map((file) => path__default["default"].join(dir, file));
-  });
-}
-
-const debug$3 = (
-  typeof process === 'object' &&
-  process.env &&
-  process.env.NODE_DEBUG &&
-  /\bsemver\b/i.test(process.env.NODE_DEBUG)
-) ? (...args) => console.error('SEMVER', ...args)
-  : () => {};
-
-var debug_1 = debug$3;
-
-// Note: this is the semver.org version of the spec that it implements
-// Not necessarily the package version of this code.
-const SEMVER_SPEC_VERSION = '2.0.0';
-
-const MAX_LENGTH$2 = 256;
-const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
-/* istanbul ignore next */ 9007199254740991;
-
-// Max safe segment length for coercion.
-const MAX_SAFE_COMPONENT_LENGTH = 16;
-
-var constants = {
-  SEMVER_SPEC_VERSION,
-  MAX_LENGTH: MAX_LENGTH$2,
-  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
-  MAX_SAFE_COMPONENT_LENGTH,
-};
-
-var re$5 = {exports: {}};
-
-(function (module, exports) {
-const { MAX_SAFE_COMPONENT_LENGTH } = constants;
-const debug = debug_1;
-exports = module.exports = {};
-
-// The actual regexps go on exports.re
-const re = exports.re = [];
-const src = exports.src = [];
-const t = exports.t = {};
-let R = 0;
-
-const createToken = (name, value, isGlobal) => {
-  const index = R++;
-  debug(name, index, value);
-  t[name] = index;
-  src[index] = value;
-  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
-};
-
-// The following Regular Expressions can be used for tokenizing,
-// validating, and parsing SemVer version strings.
-
-// ## Numeric Identifier
-// A single `0`, or a non-zero digit followed by zero or more digits.
-
-createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
-
-// ## Non-numeric Identifier
-// Zero or more digits, followed by a letter or hyphen, and then zero or
-// more letters, digits, or hyphens.
-
-createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
-
-// ## Main Version
-// Three dot-separated numeric identifiers.
-
-createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
-                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
-                   `(${src[t.NUMERICIDENTIFIER]})`);
-
-createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
-                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
-                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-
-// ## Pre-release Version Identifier
-// A numeric identifier, or a non-numeric identifier.
-
-createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
-}|${src[t.NONNUMERICIDENTIFIER]})`);
-
-createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
-}|${src[t.NONNUMERICIDENTIFIER]})`);
-
-// ## Pre-release Version
-// Hyphen, followed by one or more dot-separated pre-release version
-// identifiers.
-
-createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
-}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-
-createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
-}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-
-// ## Build Metadata Identifier
-// Any combination of digits, letters, or hyphens.
-
-createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
-
-// ## Build Metadata
-// Plus sign, followed by one or more period-separated build metadata
-// identifiers.
-
-createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
-}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-
-// ## Full Version String
-// A main version, followed optionally by a pre-release version and
-// build metadata.
-
-// Note that the only major, minor, patch, and pre-release sections of
-// the version string are capturing groups.  The build metadata is not a
-// capturing group, because it should not ever be used in version
-// comparison.
-
-createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
-}${src[t.PRERELEASE]}?${
-  src[t.BUILD]}?`);
-
-createToken('FULL', `^${src[t.FULLPLAIN]}$`);
-
-// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
-// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
-// common in the npm registry.
-createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
-}${src[t.PRERELEASELOOSE]}?${
-  src[t.BUILD]}?`);
-
-createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
-
-createToken('GTLT', '((?:<|>)?=?)');
-
-// Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
-// Only the first item is strictly required.
-createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-
-createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
-                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
-                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
-                   `(?:${src[t.PRERELEASE]})?${
-                     src[t.BUILD]}?` +
-                   `)?)?`);
-
-createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-                        `(?:${src[t.PRERELEASELOOSE]})?${
-                          src[t.BUILD]}?` +
-                        `)?)?`);
-
-createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-
-// Coercion.
-// Extract anything that could conceivably be a part of a valid semver
-createToken('COERCE', `${'(^|[^\\d])' +
-              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
-              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-              `(?:$|[^\\d])`);
-createToken('COERCERTL', src[t.COERCE], true);
-
-// Tilde ranges.
-// Meaning is "reasonably at or greater than"
-createToken('LONETILDE', '(?:~>?)');
-
-createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-exports.tildeTrimReplace = '$1~';
-
-createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-// Caret ranges.
-// Meaning is "at least and backwards compatible with"
-createToken('LONECARET', '(?:\\^)');
-
-createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
-exports.caretTrimReplace = '$1^';
-
-createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-// A simple gt/lt/eq thing, or just "" to indicate "any version"
-createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-
-// An expression to strip any whitespace between the gtlt and the thing
-// it modifies, so that `> 1.2.3` ==> `>1.2.3`
-createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
-}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-exports.comparatorTrimReplace = '$1$2$3';
-
-// Something like `1.2.3 - 1.2.4`
-// Note that these all use the loose form, because they'll be
-// checked against either the strict or loose comparator form
-// later.
-createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
-                   `\\s+-\\s+` +
-                   `(${src[t.XRANGEPLAIN]})` +
-                   `\\s*$`);
-
-createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
-                        `\\s+-\\s+` +
-                        `(${src[t.XRANGEPLAINLOOSE]})` +
-                        `\\s*$`);
-
-// Star ranges basically just allow anything at all.
-createToken('STAR', '(<|>)?=?\\s*\\*');
-// >=0.0.0 is like a star
-createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
-createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
-}(re$5, re$5.exports));
-
-// parse out just the options we care about so we always get a consistent
-// obj with keys in a consistent order.
-const opts = ['includePrerelease', 'loose', 'rtl'];
-const parseOptions$4 = options =>
-  !options ? {}
-  : typeof options !== 'object' ? { loose: true }
-  : opts.filter(k => options[k]).reduce((o, k) => {
-    o[k] = true;
-    return o
-  }, {});
-var parseOptions_1 = parseOptions$4;
-
-const numeric = /^[0-9]+$/;
-const compareIdentifiers$1 = (a, b) => {
-  const anum = numeric.test(a);
-  const bnum = numeric.test(b);
-
-  if (anum && bnum) {
-    a = +a;
-    b = +b;
-  }
-
-  return a === b ? 0
-    : (anum && !bnum) ? -1
-    : (bnum && !anum) ? 1
-    : a < b ? -1
-    : 1
-};
-
-const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
-
-var identifiers = {
-  compareIdentifiers: compareIdentifiers$1,
-  rcompareIdentifiers,
-};
-
-const debug$2 = debug_1;
-const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants;
-const { re: re$4, t: t$4 } = re$5.exports;
-
-const parseOptions$3 = parseOptions_1;
-const { compareIdentifiers } = identifiers;
-class SemVer$5 {
-  constructor (version, options) {
-    options = parseOptions$3(options);
-
-    if (version instanceof SemVer$5) {
-      if (version.loose === !!options.loose &&
-          version.includePrerelease === !!options.includePrerelease) {
-        return version
-      } else {
-        version = version.version;
-      }
-    } else if (typeof version !== 'string') {
-      throw new TypeError(`Invalid Version: ${version}`)
-    }
-
-    if (version.length > MAX_LENGTH$1) {
-      throw new TypeError(
-        `version is longer than ${MAX_LENGTH$1} characters`
-      )
-    }
-
-    debug$2('SemVer', version, options);
-    this.options = options;
-    this.loose = !!options.loose;
-    // this isn't actually relevant for versions, but keep it so that we
-    // don't run into trouble passing this.options around.
-    this.includePrerelease = !!options.includePrerelease;
-
-    const m = version.trim().match(options.loose ? re$4[t$4.LOOSE] : re$4[t$4.FULL]);
-
-    if (!m) {
-      throw new TypeError(`Invalid Version: ${version}`)
-    }
-
-    this.raw = version;
-
-    // these are actually numbers
-    this.major = +m[1];
-    this.minor = +m[2];
-    this.patch = +m[3];
-
-    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-      throw new TypeError('Invalid major version')
-    }
-
-    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-      throw new TypeError('Invalid minor version')
-    }
-
-    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-      throw new TypeError('Invalid patch version')
-    }
-
-    // numberify any prerelease numeric ids
-    if (!m[4]) {
-      this.prerelease = [];
-    } else {
-      this.prerelease = m[4].split('.').map((id) => {
-        if (/^[0-9]+$/.test(id)) {
-          const num = +id;
-          if (num >= 0 && num < MAX_SAFE_INTEGER) {
-            return num
-          }
-        }
-        return id
-      });
-    }
-
-    this.build = m[5] ? m[5].split('.') : [];
-    this.format();
-  }
-
-  format () {
-    this.version = `${this.major}.${this.minor}.${this.patch}`;
-    if (this.prerelease.length) {
-      this.version += `-${this.prerelease.join('.')}`;
-    }
-    return this.version
-  }
-
-  toString () {
-    return this.version
-  }
-
-  compare (other) {
-    debug$2('SemVer.compare', this.version, this.options, other);
-    if (!(other instanceof SemVer$5)) {
-      if (typeof other === 'string' && other === this.version) {
-        return 0
-      }
-      other = new SemVer$5(other, this.options);
-    }
-
-    if (other.version === this.version) {
-      return 0
-    }
-
-    return this.compareMain(other) || this.comparePre(other)
-  }
-
-  compareMain (other) {
-    if (!(other instanceof SemVer$5)) {
-      other = new SemVer$5(other, this.options);
-    }
-
-    return (
-      compareIdentifiers(this.major, other.major) ||
-      compareIdentifiers(this.minor, other.minor) ||
-      compareIdentifiers(this.patch, other.patch)
-    )
-  }
-
-  comparePre (other) {
-    if (!(other instanceof SemVer$5)) {
-      other = new SemVer$5(other, this.options);
-    }
-
-    // NOT having a prerelease is > having one
-    if (this.prerelease.length && !other.prerelease.length) {
-      return -1
-    } else if (!this.prerelease.length && other.prerelease.length) {
-      return 1
-    } else if (!this.prerelease.length && !other.prerelease.length) {
-      return 0
-    }
-
-    let i = 0;
-    do {
-      const a = this.prerelease[i];
-      const b = other.prerelease[i];
-      debug$2('prerelease compare', i, a, b);
-      if (a === undefined && b === undefined) {
-        return 0
-      } else if (b === undefined) {
-        return 1
-      } else if (a === undefined) {
-        return -1
-      } else if (a === b) {
-        continue
-      } else {
-        return compareIdentifiers(a, b)
-      }
-    } while (++i)
-  }
-
-  compareBuild (other) {
-    if (!(other instanceof SemVer$5)) {
-      other = new SemVer$5(other, this.options);
-    }
-
-    let i = 0;
-    do {
-      const a = this.build[i];
-      const b = other.build[i];
-      debug$2('prerelease compare', i, a, b);
-      if (a === undefined && b === undefined) {
-        return 0
-      } else if (b === undefined) {
-        return 1
-      } else if (a === undefined) {
-        return -1
-      } else if (a === b) {
-        continue
-      } else {
-        return compareIdentifiers(a, b)
-      }
-    } while (++i)
-  }
-
-  // preminor will bump the version up to the next minor release, and immediately
-  // down to pre-release. premajor and prepatch work the same way.
-  inc (release, identifier) {
-    switch (release) {
-      case 'premajor':
-        this.prerelease.length = 0;
-        this.patch = 0;
-        this.minor = 0;
-        this.major++;
-        this.inc('pre', identifier);
-        break
-      case 'preminor':
-        this.prerelease.length = 0;
-        this.patch = 0;
-        this.minor++;
-        this.inc('pre', identifier);
-        break
-      case 'prepatch':
-        // If this is already a prerelease, it will bump to the next version
-        // drop any prereleases that might already exist, since they are not
-        // relevant at this point.
-        this.prerelease.length = 0;
-        this.inc('patch', identifier);
-        this.inc('pre', identifier);
-        break
-      // If the input is a non-prerelease version, this acts the same as
-      // prepatch.
-      case 'prerelease':
-        if (this.prerelease.length === 0) {
-          this.inc('patch', identifier);
-        }
-        this.inc('pre', identifier);
-        break
-
-      case 'major':
-        // If this is a pre-major version, bump up to the same major version.
-        // Otherwise increment major.
-        // 1.0.0-5 bumps to 1.0.0
-        // 1.1.0 bumps to 2.0.0
-        if (
-          this.minor !== 0 ||
-          this.patch !== 0 ||
-          this.prerelease.length === 0
-        ) {
-          this.major++;
-        }
-        this.minor = 0;
-        this.patch = 0;
-        this.prerelease = [];
-        break
-      case 'minor':
-        // If this is a pre-minor version, bump up to the same minor version.
-        // Otherwise increment minor.
-        // 1.2.0-5 bumps to 1.2.0
-        // 1.2.1 bumps to 1.3.0
-        if (this.patch !== 0 || this.prerelease.length === 0) {
-          this.minor++;
-        }
-        this.patch = 0;
-        this.prerelease = [];
-        break
-      case 'patch':
-        // If this is not a pre-release version, it will increment the patch.
-        // If it is a pre-release it will bump up to the same patch version.
-        // 1.2.0-5 patches to 1.2.0
-        // 1.2.0 patches to 1.2.1
-        if (this.prerelease.length === 0) {
-          this.patch++;
-        }
-        this.prerelease = [];
-        break
-      // This probably shouldn't be used publicly.
-      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
-      case 'pre':
-        if (this.prerelease.length === 0) {
-          this.prerelease = [0];
-        } else {
-          let i = this.prerelease.length;
-          while (--i >= 0) {
-            if (typeof this.prerelease[i] === 'number') {
-              this.prerelease[i]++;
-              i = -2;
-            }
-          }
-          if (i === -1) {
-            // didn't increment anything
-            this.prerelease.push(0);
-          }
-        }
-        if (identifier) {
-          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
-          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
-          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-            if (isNaN(this.prerelease[1])) {
-              this.prerelease = [identifier, 0];
-            }
-          } else {
-            this.prerelease = [identifier, 0];
-          }
-        }
-        break
-
-      default:
-        throw new Error(`invalid increment argument: ${release}`)
-    }
-    this.format();
-    this.raw = this.version;
-    return this
-  }
-}
-
-var semver = SemVer$5;
-
-const { MAX_LENGTH } = constants;
-const { re: re$3, t: t$3 } = re$5.exports;
-const SemVer$4 = semver;
-
-const parseOptions$2 = parseOptions_1;
-const parse$1 = (version, options) => {
-  options = parseOptions$2(options);
-
-  if (version instanceof SemVer$4) {
-    return version
-  }
-
-  if (typeof version !== 'string') {
-    return null
-  }
-
-  if (version.length > MAX_LENGTH) {
-    return null
-  }
-
-  const r = options.loose ? re$3[t$3.LOOSE] : re$3[t$3.FULL];
-  if (!r.test(version)) {
-    return null
-  }
-
-  try {
-    return new SemVer$4(version, options)
-  } catch (er) {
-    return null
-  }
-};
-
-var parse_1 = parse$1;
-
-const SemVer$3 = semver;
-const parse = parse_1;
-const { re: re$2, t: t$2 } = re$5.exports;
-
-const coerce = (version, options) => {
-  if (version instanceof SemVer$3) {
-    return version
-  }
-
-  if (typeof version === 'number') {
-    version = String(version);
-  }
-
-  if (typeof version !== 'string') {
-    return null
-  }
-
-  options = options || {};
-
-  let match = null;
-  if (!options.rtl) {
-    match = version.match(re$2[t$2.COERCE]);
-  } else {
-    // Find the right-most coercible string that does not share
-    // a terminus with a more left-ward coercible string.
-    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
-    //
-    // Walk through the string checking with a /g regexp
-    // Manually set the index so as to pick up overlapping matches.
-    // Stop when we get a match that ends at the string end, since no
-    // coercible string can be more right-ward without the same terminus.
-    let next;
-    while ((next = re$2[t$2.COERCERTL].exec(version)) &&
-        (!match || match.index + match[0].length !== version.length)
-    ) {
-      if (!match ||
-            next.index + next[0].length !== match.index + match[0].length) {
-        match = next;
-      }
-      re$2[t$2.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
-    }
-    // leave it in a clean state
-    re$2[t$2.COERCERTL].lastIndex = -1;
-  }
-
-  if (match === null) {
-    return null
-  }
-
-  return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
-};
-var coerce_1 = coerce;
-
-var iterator = function (Yallist) {
-  Yallist.prototype[Symbol.iterator] = function* () {
-    for (let walker = this.head; walker; walker = walker.next) {
-      yield walker.value;
-    }
-  };
-};
-
-var yallist = Yallist$1;
-
-Yallist$1.Node = Node;
-Yallist$1.create = Yallist$1;
-
-function Yallist$1 (list) {
-  var self = this;
-  if (!(self instanceof Yallist$1)) {
-    self = new Yallist$1();
-  }
-
-  self.tail = null;
-  self.head = null;
-  self.length = 0;
-
-  if (list && typeof list.forEach === 'function') {
-    list.forEach(function (item) {
-      self.push(item);
-    });
-  } else if (arguments.length > 0) {
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      self.push(arguments[i]);
-    }
-  }
-
-  return self
-}
-
-Yallist$1.prototype.removeNode = function (node) {
-  if (node.list !== this) {
-    throw new Error('removing node which does not belong to this list')
-  }
-
-  var next = node.next;
-  var prev = node.prev;
-
-  if (next) {
-    next.prev = prev;
-  }
-
-  if (prev) {
-    prev.next = next;
-  }
-
-  if (node === this.head) {
-    this.head = next;
-  }
-  if (node === this.tail) {
-    this.tail = prev;
-  }
-
-  node.list.length--;
-  node.next = null;
-  node.prev = null;
-  node.list = null;
-
-  return next
-};
-
-Yallist$1.prototype.unshiftNode = function (node) {
-  if (node === this.head) {
-    return
-  }
-
-  if (node.list) {
-    node.list.removeNode(node);
-  }
-
-  var head = this.head;
-  node.list = this;
-  node.next = head;
-  if (head) {
-    head.prev = node;
-  }
-
-  this.head = node;
-  if (!this.tail) {
-    this.tail = node;
-  }
-  this.length++;
-};
-
-Yallist$1.prototype.pushNode = function (node) {
-  if (node === this.tail) {
-    return
-  }
-
-  if (node.list) {
-    node.list.removeNode(node);
-  }
-
-  var tail = this.tail;
-  node.list = this;
-  node.prev = tail;
-  if (tail) {
-    tail.next = node;
-  }
-
-  this.tail = node;
-  if (!this.head) {
-    this.head = node;
-  }
-  this.length++;
-};
-
-Yallist$1.prototype.push = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    push(this, arguments[i]);
-  }
-  return this.length
-};
-
-Yallist$1.prototype.unshift = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    unshift(this, arguments[i]);
-  }
-  return this.length
-};
-
-Yallist$1.prototype.pop = function () {
-  if (!this.tail) {
-    return undefined
-  }
-
-  var res = this.tail.value;
-  this.tail = this.tail.prev;
-  if (this.tail) {
-    this.tail.next = null;
-  } else {
-    this.head = null;
-  }
-  this.length--;
-  return res
-};
-
-Yallist$1.prototype.shift = function () {
-  if (!this.head) {
-    return undefined
-  }
-
-  var res = this.head.value;
-  this.head = this.head.next;
-  if (this.head) {
-    this.head.prev = null;
-  } else {
-    this.tail = null;
-  }
-  this.length--;
-  return res
-};
-
-Yallist$1.prototype.forEach = function (fn, thisp) {
-  thisp = thisp || this;
-  for (var walker = this.head, i = 0; walker !== null; i++) {
-    fn.call(thisp, walker.value, i, this);
-    walker = walker.next;
-  }
-};
-
-Yallist$1.prototype.forEachReverse = function (fn, thisp) {
-  thisp = thisp || this;
-  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
-    fn.call(thisp, walker.value, i, this);
-    walker = walker.prev;
-  }
-};
-
-Yallist$1.prototype.get = function (n) {
-  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.next;
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-};
-
-Yallist$1.prototype.getReverse = function (n) {
-  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.prev;
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-};
-
-Yallist$1.prototype.map = function (fn, thisp) {
-  thisp = thisp || this;
-  var res = new Yallist$1();
-  for (var walker = this.head; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this));
-    walker = walker.next;
-  }
-  return res
-};
-
-Yallist$1.prototype.mapReverse = function (fn, thisp) {
-  thisp = thisp || this;
-  var res = new Yallist$1();
-  for (var walker = this.tail; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this));
-    walker = walker.prev;
-  }
-  return res
-};
-
-Yallist$1.prototype.reduce = function (fn, initial) {
-  var acc;
-  var walker = this.head;
-  if (arguments.length > 1) {
-    acc = initial;
-  } else if (this.head) {
-    walker = this.head.next;
-    acc = this.head.value;
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
-
-  for (var i = 0; walker !== null; i++) {
-    acc = fn(acc, walker.value, i);
-    walker = walker.next;
-  }
-
-  return acc
-};
-
-Yallist$1.prototype.reduceReverse = function (fn, initial) {
-  var acc;
-  var walker = this.tail;
-  if (arguments.length > 1) {
-    acc = initial;
-  } else if (this.tail) {
-    walker = this.tail.prev;
-    acc = this.tail.value;
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
-
-  for (var i = this.length - 1; walker !== null; i--) {
-    acc = fn(acc, walker.value, i);
-    walker = walker.prev;
-  }
-
-  return acc
-};
-
-Yallist$1.prototype.toArray = function () {
-  var arr = new Array(this.length);
-  for (var i = 0, walker = this.head; walker !== null; i++) {
-    arr[i] = walker.value;
-    walker = walker.next;
-  }
-  return arr
-};
-
-Yallist$1.prototype.toArrayReverse = function () {
-  var arr = new Array(this.length);
-  for (var i = 0, walker = this.tail; walker !== null; i++) {
-    arr[i] = walker.value;
-    walker = walker.prev;
-  }
-  return arr
-};
-
-Yallist$1.prototype.slice = function (from, to) {
-  to = to || this.length;
-  if (to < 0) {
-    to += this.length;
-  }
-  from = from || 0;
-  if (from < 0) {
-    from += this.length;
-  }
-  var ret = new Yallist$1();
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0;
-  }
-  if (to > this.length) {
-    to = this.length;
-  }
-  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
-    walker = walker.next;
-  }
-  for (; walker !== null && i < to; i++, walker = walker.next) {
-    ret.push(walker.value);
-  }
-  return ret
-};
-
-Yallist$1.prototype.sliceReverse = function (from, to) {
-  to = to || this.length;
-  if (to < 0) {
-    to += this.length;
-  }
-  from = from || 0;
-  if (from < 0) {
-    from += this.length;
-  }
-  var ret = new Yallist$1();
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0;
-  }
-  if (to > this.length) {
-    to = this.length;
-  }
-  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-    walker = walker.prev;
-  }
-  for (; walker !== null && i > from; i--, walker = walker.prev) {
-    ret.push(walker.value);
-  }
-  return ret
-};
-
-Yallist$1.prototype.splice = function (start, deleteCount, ...nodes) {
-  if (start > this.length) {
-    start = this.length - 1;
-  }
-  if (start < 0) {
-    start = this.length + start;
-  }
-
-  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-    walker = walker.next;
-  }
-
-  var ret = [];
-  for (var i = 0; walker && i < deleteCount; i++) {
-    ret.push(walker.value);
-    walker = this.removeNode(walker);
-  }
-  if (walker === null) {
-    walker = this.tail;
-  }
-
-  if (walker !== this.head && walker !== this.tail) {
-    walker = walker.prev;
-  }
-
-  for (var i = 0; i < nodes.length; i++) {
-    walker = insert(this, walker, nodes[i]);
-  }
-  return ret;
-};
-
-Yallist$1.prototype.reverse = function () {
-  var head = this.head;
-  var tail = this.tail;
-  for (var walker = head; walker !== null; walker = walker.prev) {
-    var p = walker.prev;
-    walker.prev = walker.next;
-    walker.next = p;
-  }
-  this.head = tail;
-  this.tail = head;
-  return this
-};
-
-function insert (self, node, value) {
-  var inserted = node === self.head ?
-    new Node(value, null, node, self) :
-    new Node(value, node, node.next, self);
-
-  if (inserted.next === null) {
-    self.tail = inserted;
-  }
-  if (inserted.prev === null) {
-    self.head = inserted;
-  }
-
-  self.length++;
-
-  return inserted
-}
-
-function push (self, item) {
-  self.tail = new Node(item, self.tail, null, self);
-  if (!self.head) {
-    self.head = self.tail;
-  }
-  self.length++;
-}
-
-function unshift (self, item) {
-  self.head = new Node(item, null, self.head, self);
-  if (!self.tail) {
-    self.tail = self.head;
-  }
-  self.length++;
-}
-
-function Node (value, prev, next, list) {
-  if (!(this instanceof Node)) {
-    return new Node(value, prev, next, list)
-  }
-
-  this.list = list;
-  this.value = value;
-
-  if (prev) {
-    prev.next = this;
-    this.prev = prev;
-  } else {
-    this.prev = null;
-  }
-
-  if (next) {
-    next.prev = this;
-    this.next = next;
-  } else {
-    this.next = null;
-  }
-}
-
-try {
-  // add if support for Symbol.iterator is present
-  iterator(Yallist$1);
-} catch (er) {}
-
-// A linked list to keep track of recently-used-ness
-const Yallist = yallist;
-
-const MAX = Symbol('max');
-const LENGTH = Symbol('length');
-const LENGTH_CALCULATOR = Symbol('lengthCalculator');
-const ALLOW_STALE = Symbol('allowStale');
-const MAX_AGE = Symbol('maxAge');
-const DISPOSE = Symbol('dispose');
-const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
-const LRU_LIST = Symbol('lruList');
-const CACHE = Symbol('cache');
-const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
-
-const naiveLength = () => 1;
-
-// lruList is a yallist where the head is the youngest
-// item, and the tail is the oldest.  the list contains the Hit
-// objects as the entries.
-// Each Hit object has a reference to its Yallist.Node.  This
-// never changes.
-//
-// cache is a Map (or PseudoMap) that matches the keys to
-// the Yallist.Node object.
-class LRUCache {
-  constructor (options) {
-    if (typeof options === 'number')
-      options = { max: options };
-
-    if (!options)
-      options = {};
-
-    if (options.max && (typeof options.max !== 'number' || options.max < 0))
-      throw new TypeError('max must be a non-negative number')
-    // Kind of weird to have a default max of Infinity, but oh well.
-    this[MAX] = options.max || Infinity;
-
-    const lc = options.length || naiveLength;
-    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
-    this[ALLOW_STALE] = options.stale || false;
-    if (options.maxAge && typeof options.maxAge !== 'number')
-      throw new TypeError('maxAge must be a number')
-    this[MAX_AGE] = options.maxAge || 0;
-    this[DISPOSE] = options.dispose;
-    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
-    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
-    this.reset();
-  }
-
-  // resize the cache when the max changes.
-  set max (mL) {
-    if (typeof mL !== 'number' || mL < 0)
-      throw new TypeError('max must be a non-negative number')
-
-    this[MAX] = mL || Infinity;
-    trim(this);
-  }
-  get max () {
-    return this[MAX]
-  }
-
-  set allowStale (allowStale) {
-    this[ALLOW_STALE] = !!allowStale;
-  }
-  get allowStale () {
-    return this[ALLOW_STALE]
-  }
-
-  set maxAge (mA) {
-    if (typeof mA !== 'number')
-      throw new TypeError('maxAge must be a non-negative number')
-
-    this[MAX_AGE] = mA;
-    trim(this);
-  }
-  get maxAge () {
-    return this[MAX_AGE]
-  }
-
-  // resize the cache when the lengthCalculator changes.
-  set lengthCalculator (lC) {
-    if (typeof lC !== 'function')
-      lC = naiveLength;
-
-    if (lC !== this[LENGTH_CALCULATOR]) {
-      this[LENGTH_CALCULATOR] = lC;
-      this[LENGTH] = 0;
-      this[LRU_LIST].forEach(hit => {
-        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
-        this[LENGTH] += hit.length;
-      });
-    }
-    trim(this);
-  }
-  get lengthCalculator () { return this[LENGTH_CALCULATOR] }
-
-  get length () { return this[LENGTH] }
-  get itemCount () { return this[LRU_LIST].length }
-
-  rforEach (fn, thisp) {
-    thisp = thisp || this;
-    for (let walker = this[LRU_LIST].tail; walker !== null;) {
-      const prev = walker.prev;
-      forEachStep(this, fn, walker, thisp);
-      walker = prev;
-    }
-  }
-
-  forEach (fn, thisp) {
-    thisp = thisp || this;
-    for (let walker = this[LRU_LIST].head; walker !== null;) {
-      const next = walker.next;
-      forEachStep(this, fn, walker, thisp);
-      walker = next;
-    }
-  }
-
-  keys () {
-    return this[LRU_LIST].toArray().map(k => k.key)
-  }
-
-  values () {
-    return this[LRU_LIST].toArray().map(k => k.value)
-  }
-
-  reset () {
-    if (this[DISPOSE] &&
-        this[LRU_LIST] &&
-        this[LRU_LIST].length) {
-      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
-    }
-
-    this[CACHE] = new Map(); // hash of items by key
-    this[LRU_LIST] = new Yallist(); // list of items in order of use recency
-    this[LENGTH] = 0; // length of items in the list
-  }
-
-  dump () {
-    return this[LRU_LIST].map(hit =>
-      isStale(this, hit) ? false : {
-        k: hit.key,
-        v: hit.value,
-        e: hit.now + (hit.maxAge || 0)
-      }).toArray().filter(h => h)
-  }
-
-  dumpLru () {
-    return this[LRU_LIST]
-  }
-
-  set (key, value, maxAge) {
-    maxAge = maxAge || this[MAX_AGE];
-
-    if (maxAge && typeof maxAge !== 'number')
-      throw new TypeError('maxAge must be a number')
-
-    const now = maxAge ? Date.now() : 0;
-    const len = this[LENGTH_CALCULATOR](value, key);
-
-    if (this[CACHE].has(key)) {
-      if (len > this[MAX]) {
-        del(this, this[CACHE].get(key));
-        return false
-      }
-
-      const node = this[CACHE].get(key);
-      const item = node.value;
-
-      // dispose of the old one before overwriting
-      // split out into 2 ifs for better coverage tracking
-      if (this[DISPOSE]) {
-        if (!this[NO_DISPOSE_ON_SET])
-          this[DISPOSE](key, item.value);
-      }
-
-      item.now = now;
-      item.maxAge = maxAge;
-      item.value = value;
-      this[LENGTH] += len - item.length;
-      item.length = len;
-      this.get(key);
-      trim(this);
-      return true
-    }
-
-    const hit = new Entry(key, value, len, now, maxAge);
-
-    // oversized objects fall out of cache automatically.
-    if (hit.length > this[MAX]) {
-      if (this[DISPOSE])
-        this[DISPOSE](key, value);
-
-      return false
-    }
-
-    this[LENGTH] += hit.length;
-    this[LRU_LIST].unshift(hit);
-    this[CACHE].set(key, this[LRU_LIST].head);
-    trim(this);
-    return true
-  }
-
-  has (key) {
-    if (!this[CACHE].has(key)) return false
-    const hit = this[CACHE].get(key).value;
-    return !isStale(this, hit)
-  }
-
-  get (key) {
-    return get(this, key, true)
-  }
-
-  peek (key) {
-    return get(this, key, false)
-  }
-
-  pop () {
-    const node = this[LRU_LIST].tail;
-    if (!node)
-      return null
-
-    del(this, node);
-    return node.value
-  }
-
-  del (key) {
-    del(this, this[CACHE].get(key));
-  }
-
-  load (arr) {
-    // reset the cache
-    this.reset();
-
-    const now = Date.now();
-    // A previous serialized cache has the most recent items first
-    for (let l = arr.length - 1; l >= 0; l--) {
-      const hit = arr[l];
-      const expiresAt = hit.e || 0;
-      if (expiresAt === 0)
-        // the item was created without expiration in a non aged cache
-        this.set(hit.k, hit.v);
-      else {
-        const maxAge = expiresAt - now;
-        // dont add already expired items
-        if (maxAge > 0) {
-          this.set(hit.k, hit.v, maxAge);
-        }
-      }
-    }
-  }
-
-  prune () {
-    this[CACHE].forEach((value, key) => get(this, key, false));
-  }
-}
-
-const get = (self, key, doUse) => {
-  const node = self[CACHE].get(key);
-  if (node) {
-    const hit = node.value;
-    if (isStale(self, hit)) {
-      del(self, node);
-      if (!self[ALLOW_STALE])
-        return undefined
-    } else {
-      if (doUse) {
-        if (self[UPDATE_AGE_ON_GET])
-          node.value.now = Date.now();
-        self[LRU_LIST].unshiftNode(node);
-      }
-    }
-    return hit.value
-  }
-};
-
-const isStale = (self, hit) => {
-  if (!hit || (!hit.maxAge && !self[MAX_AGE]))
-    return false
-
-  const diff = Date.now() - hit.now;
-  return hit.maxAge ? diff > hit.maxAge
-    : self[MAX_AGE] && (diff > self[MAX_AGE])
-};
-
-const trim = self => {
-  if (self[LENGTH] > self[MAX]) {
-    for (let walker = self[LRU_LIST].tail;
-      self[LENGTH] > self[MAX] && walker !== null;) {
-      // We know that we're about to delete this one, and also
-      // what the next least recently used key will be, so just
-      // go ahead and set it now.
-      const prev = walker.prev;
-      del(self, walker);
-      walker = prev;
-    }
-  }
-};
-
-const del = (self, node) => {
-  if (node) {
-    const hit = node.value;
-    if (self[DISPOSE])
-      self[DISPOSE](hit.key, hit.value);
-
-    self[LENGTH] -= hit.length;
-    self[CACHE].delete(hit.key);
-    self[LRU_LIST].removeNode(node);
-  }
-};
-
-class Entry {
-  constructor (key, value, length, now, maxAge) {
-    this.key = key;
-    this.value = value;
-    this.length = length;
-    this.now = now;
-    this.maxAge = maxAge || 0;
-  }
-}
-
-const forEachStep = (self, fn, node, thisp) => {
-  let hit = node.value;
-  if (isStale(self, hit)) {
-    del(self, node);
-    if (!self[ALLOW_STALE])
-      hit = undefined;
-  }
-  if (hit)
-    fn.call(thisp, hit.value, hit.key, self);
-};
-
-var lruCache = LRUCache;
-
-const SemVer$2 = semver;
-const compare$6 = (a, b, loose) =>
-  new SemVer$2(a, loose).compare(new SemVer$2(b, loose));
-
-var compare_1 = compare$6;
-
-const compare$5 = compare_1;
-const eq$1 = (a, b, loose) => compare$5(a, b, loose) === 0;
-var eq_1 = eq$1;
-
-const compare$4 = compare_1;
-const neq$1 = (a, b, loose) => compare$4(a, b, loose) !== 0;
-var neq_1 = neq$1;
-
-const compare$3 = compare_1;
-const gt$1 = (a, b, loose) => compare$3(a, b, loose) > 0;
-var gt_1 = gt$1;
-
-const compare$2 = compare_1;
-const gte$1 = (a, b, loose) => compare$2(a, b, loose) >= 0;
-var gte_1 = gte$1;
-
-const compare$1 = compare_1;
-const lt$1 = (a, b, loose) => compare$1(a, b, loose) < 0;
-var lt_1 = lt$1;
-
-const compare = compare_1;
-const lte$1 = (a, b, loose) => compare(a, b, loose) <= 0;
-var lte_1 = lte$1;
-
-const eq = eq_1;
-const neq = neq_1;
-const gt = gt_1;
-const gte = gte_1;
-const lt = lt_1;
-const lte = lte_1;
-
-const cmp$1 = (a, op, b, loose) => {
-  switch (op) {
-    case '===':
-      if (typeof a === 'object') {
-        a = a.version;
-      }
-      if (typeof b === 'object') {
-        b = b.version;
-      }
-      return a === b
-
-    case '!==':
-      if (typeof a === 'object') {
-        a = a.version;
-      }
-      if (typeof b === 'object') {
-        b = b.version;
-      }
-      return a !== b
-
-    case '':
-    case '=':
-    case '==':
-      return eq(a, b, loose)
-
-    case '!=':
-      return neq(a, b, loose)
-
-    case '>':
-      return gt(a, b, loose)
-
-    case '>=':
-      return gte(a, b, loose)
-
-    case '<':
-      return lt(a, b, loose)
-
-    case '<=':
-      return lte(a, b, loose)
-
-    default:
-      throw new TypeError(`Invalid operator: ${op}`)
-  }
-};
-var cmp_1 = cmp$1;
-
-const ANY = Symbol('SemVer ANY');
-// hoisted class for cyclic dependency
-class Comparator$1 {
-  static get ANY () {
-    return ANY
-  }
-
-  constructor (comp, options) {
-    options = parseOptions$1(options);
-
-    if (comp instanceof Comparator$1) {
-      if (comp.loose === !!options.loose) {
-        return comp
-      } else {
-        comp = comp.value;
-      }
-    }
-
-    debug$1('comparator', comp, options);
-    this.options = options;
-    this.loose = !!options.loose;
-    this.parse(comp);
-
-    if (this.semver === ANY) {
-      this.value = '';
-    } else {
-      this.value = this.operator + this.semver.version;
-    }
-
-    debug$1('comp', this);
-  }
-
-  parse (comp) {
-    const r = this.options.loose ? re$1[t$1.COMPARATORLOOSE] : re$1[t$1.COMPARATOR];
-    const m = comp.match(r);
-
-    if (!m) {
-      throw new TypeError(`Invalid comparator: ${comp}`)
-    }
-
-    this.operator = m[1] !== undefined ? m[1] : '';
-    if (this.operator === '=') {
-      this.operator = '';
-    }
-
-    // if it literally is just '>' or '' then allow anything.
-    if (!m[2]) {
-      this.semver = ANY;
-    } else {
-      this.semver = new SemVer$1(m[2], this.options.loose);
-    }
-  }
-
-  toString () {
-    return this.value
-  }
-
-  test (version) {
-    debug$1('Comparator.test', version, this.options.loose);
-
-    if (this.semver === ANY || version === ANY) {
-      return true
-    }
-
-    if (typeof version === 'string') {
-      try {
-        version = new SemVer$1(version, this.options);
-      } catch (er) {
-        return false
-      }
-    }
-
-    return cmp(version, this.operator, this.semver, this.options)
-  }
-
-  intersects (comp, options) {
-    if (!(comp instanceof Comparator$1)) {
-      throw new TypeError('a Comparator is required')
-    }
-
-    if (!options || typeof options !== 'object') {
-      options = {
-        loose: !!options,
-        includePrerelease: false,
-      };
-    }
-
-    if (this.operator === '') {
-      if (this.value === '') {
-        return true
-      }
-      return new Range$2(comp.value, options).test(this.value)
-    } else if (comp.operator === '') {
-      if (comp.value === '') {
-        return true
-      }
-      return new Range$2(this.value, options).test(comp.semver)
-    }
-
-    const sameDirectionIncreasing =
-      (this.operator === '>=' || this.operator === '>') &&
-      (comp.operator === '>=' || comp.operator === '>');
-    const sameDirectionDecreasing =
-      (this.operator === '<=' || this.operator === '<') &&
-      (comp.operator === '<=' || comp.operator === '<');
-    const sameSemVer = this.semver.version === comp.semver.version;
-    const differentDirectionsInclusive =
-      (this.operator === '>=' || this.operator === '<=') &&
-      (comp.operator === '>=' || comp.operator === '<=');
-    const oppositeDirectionsLessThan =
-      cmp(this.semver, '<', comp.semver, options) &&
-      (this.operator === '>=' || this.operator === '>') &&
-        (comp.operator === '<=' || comp.operator === '<');
-    const oppositeDirectionsGreaterThan =
-      cmp(this.semver, '>', comp.semver, options) &&
-      (this.operator === '<=' || this.operator === '<') &&
-        (comp.operator === '>=' || comp.operator === '>');
-
-    return (
-      sameDirectionIncreasing ||
-      sameDirectionDecreasing ||
-      (sameSemVer && differentDirectionsInclusive) ||
-      oppositeDirectionsLessThan ||
-      oppositeDirectionsGreaterThan
-    )
-  }
-}
-
-var comparator = Comparator$1;
-
-const parseOptions$1 = parseOptions_1;
-const { re: re$1, t: t$1 } = re$5.exports;
-const cmp = cmp_1;
-const debug$1 = debug_1;
-const SemVer$1 = semver;
-const Range$2 = range;
-
-// hoisted class for cyclic dependency
-class Range$1 {
-  constructor (range, options) {
-    options = parseOptions(options);
-
-    if (range instanceof Range$1) {
-      if (
-        range.loose === !!options.loose &&
-        range.includePrerelease === !!options.includePrerelease
-      ) {
-        return range
-      } else {
-        return new Range$1(range.raw, options)
-      }
-    }
-
-    if (range instanceof Comparator) {
-      // just put it in the set and return
-      this.raw = range.value;
-      this.set = [[range]];
-      this.format();
-      return this
-    }
-
-    this.options = options;
-    this.loose = !!options.loose;
-    this.includePrerelease = !!options.includePrerelease;
-
-    // First, split based on boolean or ||
-    this.raw = range;
-    this.set = range
-      .split('||')
-      // map the range to a 2d array of comparators
-      .map(r => this.parseRange(r.trim()))
-      // throw out any comparator lists that are empty
-      // this generally means that it was not a valid range, which is allowed
-      // in loose mode, but will still throw if the WHOLE range is invalid.
-      .filter(c => c.length);
-
-    if (!this.set.length) {
-      throw new TypeError(`Invalid SemVer Range: ${range}`)
-    }
-
-    // if we have any that are not the null set, throw out null sets.
-    if (this.set.length > 1) {
-      // keep the first one, in case they're all null sets
-      const first = this.set[0];
-      this.set = this.set.filter(c => !isNullSet(c[0]));
-      if (this.set.length === 0) {
-        this.set = [first];
-      } else if (this.set.length > 1) {
-        // if we have any that are *, then the range is just *
-        for (const c of this.set) {
-          if (c.length === 1 && isAny(c[0])) {
-            this.set = [c];
-            break
-          }
-        }
-      }
-    }
-
-    this.format();
-  }
-
-  format () {
-    this.range = this.set
-      .map((comps) => {
-        return comps.join(' ').trim()
-      })
-      .join('||')
-      .trim();
-    return this.range
-  }
-
-  toString () {
-    return this.range
-  }
-
-  parseRange (range) {
-    range = range.trim();
-
-    // memoize range parsing for performance.
-    // this is a very hot path, and fully deterministic.
-    const memoOpts = Object.keys(this.options).join(',');
-    const memoKey = `parseRange:${memoOpts}:${range}`;
-    const cached = cache.get(memoKey);
-    if (cached) {
-      return cached
-    }
-
-    const loose = this.options.loose;
-    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-    debug('hyphen replace', range);
-    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-    debug('comparator trim', range);
-
-    // `~ 1.2.3` => `~1.2.3`
-    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-
-    // `^ 1.2.3` => `^1.2.3`
-    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-
-    // normalize spaces
-    range = range.split(/\s+/).join(' ');
-
-    // At this point, the range is completely trimmed and
-    // ready to be split into comparators.
-
-    let rangeList = range
-      .split(' ')
-      .map(comp => parseComparator(comp, this.options))
-      .join(' ')
-      .split(/\s+/)
-      // >=0.0.0 is equivalent to *
-      .map(comp => replaceGTE0(comp, this.options));
-
-    if (loose) {
-      // in loose mode, throw out any that are not valid comparators
-      rangeList = rangeList.filter(comp => {
-        debug('loose invalid filter', comp, this.options);
-        return !!comp.match(re[t.COMPARATORLOOSE])
-      });
-    }
-    debug('range list', rangeList);
-
-    // if any comparators are the null set, then replace with JUST null set
-    // if more than one comparator, remove any * comparators
-    // also, don't include the same comparator more than once
-    const rangeMap = new Map();
-    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
-    for (const comp of comparators) {
-      if (isNullSet(comp)) {
-        return [comp]
-      }
-      rangeMap.set(comp.value, comp);
-    }
-    if (rangeMap.size > 1 && rangeMap.has('')) {
-      rangeMap.delete('');
-    }
-
-    const result = [...rangeMap.values()];
-    cache.set(memoKey, result);
-    return result
-  }
-
-  intersects (range, options) {
-    if (!(range instanceof Range$1)) {
-      throw new TypeError('a Range is required')
-    }
-
-    return this.set.some((thisComparators) => {
-      return (
-        isSatisfiable(thisComparators, options) &&
-        range.set.some((rangeComparators) => {
-          return (
-            isSatisfiable(rangeComparators, options) &&
-            thisComparators.every((thisComparator) => {
-              return rangeComparators.every((rangeComparator) => {
-                return thisComparator.intersects(rangeComparator, options)
-              })
-            })
-          )
-        })
-      )
-    })
-  }
-
-  // if ANY of the sets match ALL of its comparators, then pass
-  test (version) {
-    if (!version) {
-      return false
-    }
-
-    if (typeof version === 'string') {
-      try {
-        version = new SemVer(version, this.options);
-      } catch (er) {
-        return false
-      }
-    }
-
-    for (let i = 0; i < this.set.length; i++) {
-      if (testSet(this.set[i], version, this.options)) {
-        return true
-      }
-    }
-    return false
-  }
-}
-var range = Range$1;
-
-const LRU = lruCache;
-const cache = new LRU({ max: 1000 });
-
-const parseOptions = parseOptions_1;
-const Comparator = comparator;
-const debug = debug_1;
-const SemVer = semver;
-const {
-  re,
-  t,
-  comparatorTrimReplace,
-  tildeTrimReplace,
-  caretTrimReplace,
-} = re$5.exports;
-
-const isNullSet = c => c.value === '<0.0.0-0';
-const isAny = c => c.value === '';
-
-// take a set of comparators and determine whether there
-// exists a version which can satisfy it
-const isSatisfiable = (comparators, options) => {
-  let result = true;
-  const remainingComparators = comparators.slice();
-  let testComparator = remainingComparators.pop();
-
-  while (result && remainingComparators.length) {
-    result = remainingComparators.every((otherComparator) => {
-      return testComparator.intersects(otherComparator, options)
-    });
-
-    testComparator = remainingComparators.pop();
-  }
-
-  return result
-};
-
-// comprised of xranges, tildes, stars, and gtlt's at this point.
-// already replaced the hyphen ranges
-// turn into a set of JUST comparators.
-const parseComparator = (comp, options) => {
-  debug('comp', comp, options);
-  comp = replaceCarets(comp, options);
-  debug('caret', comp);
-  comp = replaceTildes(comp, options);
-  debug('tildes', comp);
-  comp = replaceXRanges(comp, options);
-  debug('xrange', comp);
-  comp = replaceStars(comp, options);
-  debug('stars', comp);
-  return comp
-};
-
-const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
-
-// ~, ~> --> * (any, kinda silly)
-// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
-// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
-// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
-// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
-// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
-// ~0.0.1 --> >=0.0.1 <0.1.0-0
-const replaceTildes = (comp, options) =>
-  comp.trim().split(/\s+/).map((c) => {
-    return replaceTilde(c, options)
-  }).join(' ');
-
-const replaceTilde = (comp, options) => {
-  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-  return comp.replace(r, (_, M, m, p, pr) => {
-    debug('tilde', comp, _, M, m, p, pr);
-    let ret;
-
-    if (isX(M)) {
-      ret = '';
-    } else if (isX(m)) {
-      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
-    } else if (isX(p)) {
-      // ~1.2 == >=1.2.0 <1.3.0-0
-      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
-    } else if (pr) {
-      debug('replaceTilde pr', pr);
-      ret = `>=${M}.${m}.${p}-${pr
-      } <${M}.${+m + 1}.0-0`;
-    } else {
-      // ~1.2.3 == >=1.2.3 <1.3.0-0
-      ret = `>=${M}.${m}.${p
-      } <${M}.${+m + 1}.0-0`;
-    }
-
-    debug('tilde return', ret);
-    return ret
-  })
-};
-
-// ^ --> * (any, kinda silly)
-// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
-// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
-// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
-// ^1.2.3 --> >=1.2.3 <2.0.0-0
-// ^1.2.0 --> >=1.2.0 <2.0.0-0
-// ^0.0.1 --> >=0.0.1 <0.0.2-0
-// ^0.1.0 --> >=0.1.0 <0.2.0-0
-const replaceCarets = (comp, options) =>
-  comp.trim().split(/\s+/).map((c) => {
-    return replaceCaret(c, options)
-  }).join(' ');
-
-const replaceCaret = (comp, options) => {
-  debug('caret', comp, options);
-  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-  const z = options.includePrerelease ? '-0' : '';
-  return comp.replace(r, (_, M, m, p, pr) => {
-    debug('caret', comp, _, M, m, p, pr);
-    let ret;
-
-    if (isX(M)) {
-      ret = '';
-    } else if (isX(m)) {
-      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
-    } else if (isX(p)) {
-      if (M === '0') {
-        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
-      } else {
-        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
-      }
-    } else if (pr) {
-      debug('replaceCaret pr', pr);
-      if (M === '0') {
-        if (m === '0') {
-          ret = `>=${M}.${m}.${p}-${pr
-          } <${M}.${m}.${+p + 1}-0`;
-        } else {
-          ret = `>=${M}.${m}.${p}-${pr
-          } <${M}.${+m + 1}.0-0`;
-        }
-      } else {
-        ret = `>=${M}.${m}.${p}-${pr
-        } <${+M + 1}.0.0-0`;
-      }
-    } else {
-      debug('no pr');
-      if (M === '0') {
-        if (m === '0') {
-          ret = `>=${M}.${m}.${p
-          }${z} <${M}.${m}.${+p + 1}-0`;
-        } else {
-          ret = `>=${M}.${m}.${p
-          }${z} <${M}.${+m + 1}.0-0`;
-        }
-      } else {
-        ret = `>=${M}.${m}.${p
-        } <${+M + 1}.0.0-0`;
-      }
-    }
-
-    debug('caret return', ret);
-    return ret
-  })
-};
-
-const replaceXRanges = (comp, options) => {
-  debug('replaceXRanges', comp, options);
-  return comp.split(/\s+/).map((c) => {
-    return replaceXRange(c, options)
-  }).join(' ')
-};
-
-const replaceXRange = (comp, options) => {
-  comp = comp.trim();
-  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
-  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
-    debug('xRange', comp, ret, gtlt, M, m, p, pr);
-    const xM = isX(M);
-    const xm = xM || isX(m);
-    const xp = xm || isX(p);
-    const anyX = xp;
-
-    if (gtlt === '=' && anyX) {
-      gtlt = '';
-    }
-
-    // if we're including prereleases in the match, then we need
-    // to fix this to -0, the lowest possible prerelease value
-    pr = options.includePrerelease ? '-0' : '';
-
-    if (xM) {
-      if (gtlt === '>' || gtlt === '<') {
-        // nothing is allowed
-        ret = '<0.0.0-0';
-      } else {
-        // nothing is forbidden
-        ret = '*';
-      }
-    } else if (gtlt && anyX) {
-      // we know patch is an x, because we have any x at all.
-      // replace X with 0
-      if (xm) {
-        m = 0;
-      }
-      p = 0;
-
-      if (gtlt === '>') {
-        // >1 => >=2.0.0
-        // >1.2 => >=1.3.0
-        gtlt = '>=';
-        if (xm) {
-          M = +M + 1;
-          m = 0;
-          p = 0;
-        } else {
-          m = +m + 1;
-          p = 0;
-        }
-      } else if (gtlt === '<=') {
-        // <=0.7.x is actually <0.8.0, since any 0.7.x should
-        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
-        gtlt = '<';
-        if (xm) {
-          M = +M + 1;
-        } else {
-          m = +m + 1;
-        }
-      }
-
-      if (gtlt === '<') {
-        pr = '-0';
-      }
-
-      ret = `${gtlt + M}.${m}.${p}${pr}`;
-    } else if (xm) {
-      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
-    } else if (xp) {
-      ret = `>=${M}.${m}.0${pr
-      } <${M}.${+m + 1}.0-0`;
-    }
-
-    debug('xRange return', ret);
-
-    return ret
-  })
-};
-
-// Because * is AND-ed with everything else in the comparator,
-// and '' means "any version", just remove the *s entirely.
-const replaceStars = (comp, options) => {
-  debug('replaceStars', comp, options);
-  // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re[t.STAR], '')
-};
-
-const replaceGTE0 = (comp, options) => {
-  debug('replaceGTE0', comp, options);
-  return comp.trim()
-    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
-};
-
-// This function is passed to string.replace(re[t.HYPHENRANGE])
-// M, m, patch, prerelease, build
-// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
-// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
-// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
-const hyphenReplace = incPr => ($0,
-  from, fM, fm, fp, fpr, fb,
-  to, tM, tm, tp, tpr, tb) => {
-  if (isX(fM)) {
-    from = '';
-  } else if (isX(fm)) {
-    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
-  } else if (isX(fp)) {
-    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
-  } else if (fpr) {
-    from = `>=${from}`;
-  } else {
-    from = `>=${from}${incPr ? '-0' : ''}`;
-  }
-
-  if (isX(tM)) {
-    to = '';
-  } else if (isX(tm)) {
-    to = `<${+tM + 1}.0.0-0`;
-  } else if (isX(tp)) {
-    to = `<${tM}.${+tm + 1}.0-0`;
-  } else if (tpr) {
-    to = `<=${tM}.${tm}.${tp}-${tpr}`;
-  } else if (incPr) {
-    to = `<${tM}.${tm}.${+tp + 1}-0`;
-  } else {
-    to = `<=${to}`;
-  }
-
-  return (`${from} ${to}`).trim()
-};
-
-const testSet = (set, version, options) => {
-  for (let i = 0; i < set.length; i++) {
-    if (!set[i].test(version)) {
-      return false
-    }
-  }
-
-  if (version.prerelease.length && !options.includePrerelease) {
-    // Find the set of versions that are allowed to have prereleases
-    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
-    // That should allow `1.2.3-pr.2` to pass.
-    // However, `1.2.4-alpha.notready` should NOT be allowed,
-    // even though it's within the range set by the comparators.
-    for (let i = 0; i < set.length; i++) {
-      debug(set[i].semver);
-      if (set[i].semver === Comparator.ANY) {
-        continue
-      }
-
-      if (set[i].semver.prerelease.length > 0) {
-        const allowed = set[i].semver;
-        if (allowed.major === version.major &&
-            allowed.minor === version.minor &&
-            allowed.patch === version.patch) {
-          return true
-        }
-      }
-    }
-
-    // Version has a -pre, but it's not one of the ones we like.
-    return false
-  }
-
-  return true
-};
-
-const Range = range;
-const satisfies = (version, range, options) => {
-  try {
-    range = new Range(range, options);
-  } catch (er) {
-    return false
-  }
-  return range.test(version)
-};
-var satisfies_1 = satisfies;
-
-function checkVersion(threshold, version) {
-  if (!version)
-    return false;
-  const parsedVersion = coerce_1(version);
-  if (parsedVersion === null)
-    return false;
-  return satisfies_1(parsedVersion, threshold);
-}
-
-function findArgument(args, name) {
-  const flagIndex = args.indexOf(`--${name}`);
-  if (flagIndex === -1)
-    return;
-  if (args.length < flagIndex + 2)
-    return;
-  const flagValue = args[flagIndex + 1];
-  if (flagValue.startsWith("--"))
-    return;
-  return flagValue;
-}
-function findFlag(args, name) {
-  const toFind = `--${name}`;
-  return args.includes(toFind);
-}
-const execCommand = util__default["default"].promisify(child_process.exec);
-function getApplicationMode(argumentValue) {
-  switch (argumentValue) {
-    case client.ApplicationMode.PROD:
-    case client.ApplicationMode.STAGE:
-    case client.ApplicationMode.DEV:
-      return argumentValue;
-    default:
-      return null;
-  }
-}
-
-const {
-  PRISMIC_CLIENT,
-  PRISMIC_DOM_PACKAGE_NAME,
-  PRISMIC_REACT_PACKAGE_NAME,
-  PRISMIC_NEXT,
-  SM_PACKAGE_NAME,
-  NUXT_PRISMIC,
-  PRISMIC_VUE,
-  SLICE_SIMULATOR_REACT,
-  SLICE_SIMULATOR_VUE,
-  PRISMIC_HELPERS,
-  PRISMIC_TYPES
-} = core.CONSTS;
-function nextDeps(version) {
-  if (checkVersion(">=13.0.0", version)) {
-    return PRISMIC_NEXT;
-  }
-  return "";
-}
-function depsForFramework(framework, version) {
-  switch (framework) {
-    case core.Models.Frameworks.react:
-      return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT} ${PRISMIC_HELPERS}`;
-    case core.Models.Frameworks.next:
-      return `${PRISMIC_REACT_PACKAGE_NAME} ${nextDeps(version)} ${PRISMIC_CLIENT} ${SLICE_SIMULATOR_REACT} ${PRISMIC_HELPERS}`;
-    case core.Models.Frameworks.svelte:
-      return `${PRISMIC_DOM_PACKAGE_NAME} ${PRISMIC_CLIENT}`;
-    case core.Models.Frameworks.nuxt:
-      return `${NUXT_PRISMIC} ${SLICE_SIMULATOR_VUE}`;
-    case core.Models.Frameworks.vue:
-      return `${PRISMIC_VUE} ${PRISMIC_CLIENT} ${PRISMIC_DOM_PACKAGE_NAME}`;
-    default:
-      return "";
-  }
-}
-async function addAndInstallDeps(framework, version, useYarn = false) {
-  const installDevDependencyCommand = useYarn ? "yarn add -D" : "npm install --save-dev";
-  const installDependencyCommand = useYarn ? "yarn add" : "npm install --save";
-  const { stderr } = await execCommand(`${installDevDependencyCommand} ${SM_PACKAGE_NAME} ${PRISMIC_TYPES}`);
-  const deps = depsForFramework(framework, version);
-  if (deps)
-    await execCommand(`${installDependencyCommand} ${deps}`);
-  return stderr;
-}
-async function installDeps(useYarn = false) {
-  const installCommand = useYarn ? "yarn" : "npm install";
-  const { stderr } = await execCommand(installCommand);
-  return stderr;
-}
-async function installRequiredDependencies(cwd, framework, skipDependencies, version) {
-  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
-  const spinner = spinner$1("Installing Slice Machine");
-  spinner.start();
-  const stderr = await (skipDependencies ? installDeps(yarnLock) : addAndInstallDeps(framework, version, yarnLock));
-  const pathToPkg = path__default["default"].join(NodeUtils__namespace.PackagePaths(cwd).value(), SM_PACKAGE_NAME);
-  const isPackageInstalled = NodeUtils__namespace.Files.exists(pathToPkg);
-  if (isPackageInstalled || !stderr.length) {
-    spinner.succeed("Slice Machine was installed successfully");
-    return;
-  }
-  spinner.fail();
-  writeWarning(`could not install ${SM_PACKAGE_NAME}. Please do it manually!`);
-}
-
-function validatePkg(cwd) {
-  const jsonPackage = NodeUtils__namespace.retrieveJsonPackage(cwd);
-  if (!jsonPackage.exists) {
-    writeError$1(`package.json not found. Are you in the right folder?`);
-    return process.exit(-1);
-  }
-  if (!jsonPackage.content) {
-    writeError$1(`could not parse package.json.`);
-    return process.exit(-1);
-  }
-}
-
-function createRepository(client, domain, framework) {
-  const spinner = spinner$1("Creating Prismic Repository");
-  spinner.start();
-  return client.createRepository(domain, framework).then((domain2) => {
-    const addressUrl = new URL(client.apisEndpoints.Wroom);
-    addressUrl.hostname = `${domain2}.${addressUrl.hostname}`;
-    const address = addressUrl.toString();
-    spinner.succeed(`We created your new repository ${address}`);
-    return domain2;
-  }).catch(async (error) => {
-    spinner.fail(`Error creating repository ${domain}`);
-    await Tracker.get().trackInitEndFail(framework, "Failed to create repository");
-    if (error.message) {
-      writeError$1(error.message);
-    }
-    writeError$1(`We failed to create you new prismic repository`);
-    console.log(`Run ${bold$1("npx @slicemachine/init")} again!`);
-    process.exit(-1);
-  });
-}
-
-async function validateRepositoryName(client, name) {
-  const domain = name.trim();
-  const errors = [];
-  const startsWithLetter = /^[a-zA-Z]/.test(domain);
-  if (!startsWithLetter)
-    errors.push("Must start with a letter.");
-  const acceptedChars = /^[a-z0-9-]+$/.test(domain);
-  if (!acceptedChars)
-    errors.push("Must contain only lowercase letters, numbers and hyphens.");
-  const fourCharactersOrMore = domain.length >= 4;
-  if (!fourCharactersOrMore)
-    errors.push("Must have four or more alphanumeric characters and/or hyphens.");
-  const endsWithALetterOrNumber = /[a-z0-9]$/.test(domain);
-  if (!endsWithALetterOrNumber)
-    errors.push("Must end in a letter or a number.");
-  const thirtyCharacterOrLess = domain.length <= 30;
-  if (!thirtyCharacterOrLess)
-    errors.push("Must be 30 characters or less");
-  if (errors.length > 0) {
-    const errorString = errors.map((d, i) => `(${i + 1}: ${d}`).join(" ");
-    const msg = `Validation errors: ${errorString}`;
-    return Promise.reject(new Error(msg));
-  }
-  return client.domainExist(domain).then((isAvailable) => isAvailable ? true : Promise.reject(new Error(`${name} is already in use`))).catch(() => Promise.reject(new Error(`${name} is already in use`)));
-}
-
-const CREATE_REPO = "$_CREATE_REPO";
-function prettyRepoName(address, domain) {
-  return `${cyan.dim(`${address.protocol}//`)}${cyan(domain)}${cyan.dim(`.${address.hostname}`)}`;
-}
-async function promptForRepoDomain(client, defaultValue) {
-  const address = new URL(client.apisEndpoints.Wroom);
-  writeInfo("The name acts as a domain/endpoint for your content repo and should be completely unique.");
-  return inquirer__namespace.prompt([
-    {
-      name: "repoDomain",
-      message: "Name your Prismic repository",
-      type: "input",
-      required: true,
-      default: defaultValue,
-      transformer: (value) => prettyRepoName(address, value || defaultValue || "repository"),
-      validate: (name) => validateRepositoryName(client, name)
-    }
-  ]).then((res) => res.repoDomain);
-}
-function makeReposPretty(base) {
-  return function({ name, domain, role }) {
-    const address = new URL(base);
-    address.hostname = `${domain}.${address.hostname}`;
-    if (core.Models.canUpdateCustomTypes(role) === false) {
-      return {
-        name: `${purple.dim("Use")} ${bold$1.dim(name)} ${purple.dim(`"${address.hostname}"`)}`,
-        value: domain,
-        disabled: "Unauthorized"
-      };
-    }
-    return {
-      name: `${purple("Use")} ${bold$1(name)} ${purple(`"${address.hostname}"`)}`,
-      value: domain
-    };
-  };
-}
-function orderPrompts(maybeName) {
-  return (a, b) => {
-    if (a instanceof Separator__default["default"] || b instanceof Separator__default["default"])
-      return 0;
-    if (maybeName && (a.value === maybeName || b.value === maybeName))
-      return 0;
-    if (a.value === CREATE_REPO || b.value === CREATE_REPO)
-      return 0;
-    if (a.disabled && !b.disabled)
-      return 1;
-    if (!a.disabled && b.disabled)
-      return -1;
-    return 0;
-  };
-}
-function maybeStickTheRepoToTheTopOfTheList(repoName) {
-  return (acc, curr) => {
-    if (repoName && curr.value === repoName) {
-      return [curr, ...acc];
-    }
-    return [...acc, curr];
-  };
-}
-function sortReposForPrompt(repos, base, cwd) {
-  const createNew = {
-    name: `${purple("Create a")} ${bold$1("new")} ${purple("Repository")}`,
-    value: CREATE_REPO
-  };
-  const maybeConfiguredRepoName = NodeUtils__namespace.maybeRepoNameFromSMFile(cwd, base);
-  return repos.reverse().map(makeReposPretty(base)).reduce(maybeStickTheRepoToTheTopOfTheList(maybeConfiguredRepoName), [
-    createNew
-  ]).sort(orderPrompts(maybeConfiguredRepoName));
-}
-async function chooseOrCreateARepository(client, cwd, framework, preSelectedRepository) {
-  const repositories = await client.listRepositories();
-  const isPreSelectedValid = preSelectedRepository && repositories.find((repository) => repository.domain === preSelectedRepository);
-  if (isPreSelectedValid)
-    return preSelectedRepository;
-  if (repositories.length === 0) {
-    const domainName = await promptForRepoDomain(client, preSelectedRepository);
-    await createRepository(client, domainName, framework);
-    return domainName;
-  }
-  const choices = sortReposForPrompt(repositories, client.apisEndpoints.Wroom, cwd);
-  const numberOfDisabledRepos = choices.filter((repo) => {
-    if (repo instanceof Separator__default["default"])
-      return false;
-    return repo.disabled;
-  }).length;
-  const promptResult = await inquirer__namespace.prompt([
-    {
-      type: "list",
-      name: "chosenRepository",
-      default: 0,
-      required: true,
-      message: "Connect a Prismic Repository or create a new one",
-      choices,
-      pageSize: numberOfDisabledRepos + 2 <= 7 ? 7 : numberOfDisabledRepos + 2
-    }
-  ]);
-  if (promptResult.chosenRepository === CREATE_REPO) {
-    const domainName = await promptForRepoDomain(client, preSelectedRepository);
-    await createRepository(client, domainName, framework);
-    return domainName;
-  }
-  return promptResult.chosenRepository;
-}
-
-async function promptForFramework() {
-  const choices = core.Models.SupportedFrameworks.map((framework) => {
-    return {
-      name: NodeUtils__namespace.Framework.fancyName(framework),
-      value: framework
-    };
-  });
-  return inquirer__namespace.prompt([
-    {
-      name: "framework",
-      type: "list",
-      message: "Select a framework to use",
-      required: true,
-      choices
-    }
-  ]).then((res) => {
-    return {
-      value: res.framework,
-      manuallyAdded: true,
-      version: void 0
-    };
-  });
-}
-async function detectFramework(cwd) {
-  const failMessage = `Please run ${bold$1("npx @slicemachine/init")} in a Nuxt or Next.js project`;
-  const spinner = spinner$1("Detecting framework to install correct dependencies");
-  spinner.start();
-  try {
-    const { framework, version } = NodeUtils__namespace.Framework.defineFrameworkWithVersion({
-      cwd,
-      supportedFrameworks: Object.values(core.Models.Frameworks)
-    });
-    spinner.stop();
-    if (!framework || framework === core.Models.Frameworks.vanillajs) {
-      writeError$1("Framework not detected");
-      return await promptForFramework();
-    }
-    const nameToPrint = NodeUtils__namespace.Framework.fancyName(framework);
-    if (!NodeUtils__namespace.Framework.isFrameworkSupported(framework)) {
-      writeError$1(`${nameToPrint} is currently not supported`);
-      console.log(failMessage);
-      process.exit(1);
-    }
-    writeCheck(`${nameToPrint} detected`);
-    return {
-      value: framework,
-      manuallyAdded: false,
-      version
-    };
-  } catch (error) {
-    spinner.fail("package.json not found");
-    if (error instanceof Error && error.message) {
-      writeError$1(error.message);
-    } else {
-      console.log(failMessage);
-    }
-    await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Framework not detected");
-    process.exit(1);
-  }
-}
-
-async function loginOrBypass(client) {
-  const user = await client.profile().catch(() => null);
-  if (user) {
-    const email = user.email;
-    writeCheck(`Logged in as ${bold$1(email)}`);
-    return user;
-  }
-  await Auth.login(client);
-  client.updateAuthenticationToken(Prismic.PrismicSharedConfigManager.getAuth());
-  const userAfterLogin = await client.profile();
-  return userAfterLogin;
-}
-
-async function configureProject(client, cwd, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
-  const frameworkName = NodeUtils__namespace.Framework.fancyName(framework.value);
-  const spinner = spinner$1(`Configuring your ${frameworkName} and Prismic project...`);
-  spinner.start();
-  try {
-    const manifest = NodeUtils__namespace.retrieveManifest(cwd);
-    const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
-    const libs = manifest.content && manifest.content.libraries && manifest.content.libraries.length > 0 ? manifest.content.libraries : ["@/slices"];
-    const manifestUpdated = {
-      ...manifestAlreadyExistWithContent ? manifest.content : {},
-      apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(client.apisEndpoints.Wroom, repositoryDomainName),
-      libraries: [...libs, ...sliceLibPath],
-      ...framework.manuallyAdded ? { framework: framework.value } : {},
-      ...!tracking ? { tracking } : {}
-    };
-    if (!manifest.exists)
-      NodeUtils__namespace.createManifest(cwd, manifestUpdated);
-    else
-      NodeUtils__namespace.patchManifest(cwd, manifestUpdated);
-    const pathToSlicesFolder = NodeUtils__namespace.CustomPaths(cwd).library("slices").value();
-    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder) && libs.includes("@/slices")) {
-      NodeUtils__namespace.Files.mkdir(pathToSlicesFolder, { recursive: true });
-    }
-    NodeUtils__namespace.addJsonPackageSmScript(cwd);
-    await Tracker.get().trackInitEndSuccess(framework.value);
-    spinner.succeed("Project configured! Ready to start");
-  } catch (error) {
-    await Tracker.get().trackInitEndFail(framework.value, "Failed to configure Slice Machine");
-    spinner.fail("Failed to configure Slice Machine");
-    process.exit(-1);
-  }
-}
-
-function displayFinalMessage(cwd, wasStarter, reponame, base) {
-  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
-  const command = `${yarnLock ? "yarn" : "npm"} run ${core.CONSTS.SCRIPT_NAME}`;
-  console.log();
-  if (wasStarter) {
-    const repoUrl = new URL(base);
-    repoUrl.hostname = `${reponame}.${repoUrl.hostname}`;
-    const urlAsString = repoUrl.toString();
-    const message = `${white("\u25A0")} Start editing your content in Prismic ${purple(urlAsString)}`;
-    console.log(message);
-  } else {
-    console.log(`${white("\u25A0")} Run ${purple(command)} to launch Slice Machine and create your first Custom Type`);
-  }
-}
-
-const Dependencies = {
-  fromPkgFormat(pkgDeps) {
-    if (!pkgDeps)
-      return;
-    return Object.entries(pkgDeps).map(([name, version]) => ({
-      name,
-      version
-    }));
-  }
-};
-function formatDeps(dependencies) {
-  return dependencies.map((dep) => {
-    if (typeof dep === "string")
-      return dep;
-    return `${dep.name}@${dep.version}`;
-  }).join(" ");
-}
-const PackageManager = {
-  get(cwd) {
-    if (NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd))) {
-      return Yarn;
-    }
-    return Npm;
-  }
-};
-const Yarn = {
-  install(dependencies) {
-    return execCommand(`yarn add ${formatDeps(dependencies)}`);
-  },
-  installDev(dependencies) {
-    return execCommand(`yarn add --dev ${formatDeps(dependencies)}`);
-  }
-};
-const Npm = {
-  install(dependencies) {
-    return execCommand(`npm i --save ${formatDeps(dependencies)}`);
-  },
-  installDev(dependencies) {
-    return execCommand(`npm i --save-dev ${formatDeps(dependencies)}`);
-  }
-};
-
-const { PackageJsonHelper } = NodeUtils__namespace;
-const downloadFile = async (reqUrl) => {
-  const res = await axios__default["default"].get(reqUrl, { responseType: "arraybuffer" });
-  return new Promise((resolve, reject) => {
-    if (res.status == 200) {
-      const tmpZipFile = tmp__default["default"].tmpNameSync();
-      const zip = new AdmZip__default["default"](res.data);
-      zip.extractAllTo(tmpZipFile);
-      resolve(tmpZipFile);
-    } else {
-      reject();
-    }
-  });
-};
-function toGithubSource(githubPath, branch) {
-  return `https://codeload.github.com/${githubPath}/zip/${branch}`;
-}
-async function installLib(cwd, libGithubPath, branch = "HEAD") {
-  const spinner = spinner$1(`Installing the ${libGithubPath} lib in your project...`);
-  try {
-    spinner.start();
-    const [githubUserName, githubProjectName] = libGithubPath.split("/");
-    const source = toGithubSource(libGithubPath, branch);
-    const zipFilePath = await downloadFile(source);
-    const outputFolder = `${githubProjectName}-${branch}`;
-    const projectPath = path__default["default"].join(zipFilePath, outputFolder);
-    const name = `${githubUserName}-${githubProjectName}`;
-    const libDestinationFolder = path__default["default"].join(cwd, name);
-    if (fs__default["default"].existsSync(libDestinationFolder)) {
-      spinner.succeed(`Lib "${libGithubPath}" was already installed (skipped)`);
-      return;
-    }
-    fsExtra__default["default"].moveSync(path__default["default"].join(projectPath, "src"), libDestinationFolder);
-    const pkgManager = PackageManager.get(cwd);
-    const pkgJson = PackageJsonHelper.fromPath(path__default["default"].join(projectPath, "package.json"));
-    if (pkgJson instanceof Error)
-      throw pkgJson;
-    const dependencies = Dependencies.fromPkgFormat(pkgJson.dependencies);
-    if (dependencies)
-      await pkgManager.install(dependencies);
-    NodeUtils__namespace.Files.write(path__default["default"].join(libDestinationFolder, "meta.json"), {
-      name: pkgJson.name
-    });
-    const manifest = NodeUtils__namespace.Files.readEntity(path__default["default"].join(projectPath, "sm.json"), (payload) => {
-      return Either.getOrElseW(() => new Error(`Unable to parse sm.json from lib ${libGithubPath}`))(core.Models.Manifest.decode(payload));
-    });
-    if (manifest instanceof Error)
-      throw manifest;
-    const localLibs = core.Models.ManifestHelper.localLibraries(manifest).map(({ path: path2 }) => {
-      return `~/${name}/${path2.replace("src/", "")}`;
-    });
-    spinner.succeed(`Slice library "${libGithubPath}" was installed successfully`);
-    void Tracker.get().trackDownloadLibrary(libGithubPath);
-    return localLibs;
-  } catch (error) {
-    spinner.fail(`Error installing ${libGithubPath} lib!`);
-    if (error instanceof Error) {
-      console.error(error.message);
-    }
-    await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Failed to install ${libGithubPath} library");
-    process.exit(-1);
-  }
-}
-
-async function promptToPushSlices() {
-  return inquirer__default["default"].prompt([
-    {
-      type: "confirm",
-      name: "pushSlices",
-      default: false,
-      message: "Your repository already contains Slices. Do you want to continue pushing your local Slices?"
-    }
-  ]).then((res) => res.pushSlices);
-}
-async function promptToPushCustomTypes() {
-  return inquirer__default["default"].prompt([
-    {
-      type: "confirm",
-      name: "pushCustomTypes",
-      default: false,
-      message: "Your repository already contains Custom Types. Do you want to continue pushing your local Custom Types?"
-    }
-  ]).then((res) => res.pushCustomTypes);
-}
-
-async function updateVariationWithScreenshot(client, acl, screenshots, sliceId, variation) {
-  const screenshot = screenshots[variation.id];
-  if (!screenshot || !screenshot.path)
-    return Promise.resolve(variation);
-  return client.uploadScreenshot({
-    acl,
-    sliceId,
-    variationId: variation.id,
-    filePath: screenshot.path
-  }).then((screenshotUrl) => {
-    return {
-      ...variation,
-      imageUrl: screenshotUrl
-    };
-  }).catch((error) => {
-    writeError$1(`Couldn't upload screenshot slice: ${sliceId} - variation: ${variation.id}`);
-    writeError$1(error.message, "Full error:");
-    return variation;
-  });
-}
-async function updateSlicesWithScreenshots(client, acl, components) {
-  return Promise.all(components.map(async (component) => {
-    const { screenshots, model } = component;
-    const variationsUpdated = await Promise.all(model.variations.map(async (variation) => updateVariationWithScreenshot(client, acl, screenshots, model.id, variation)));
-    return {
-      ...model,
-      variations: variationsUpdated
-    };
-  }));
-}
-
-async function sendSlices(client, cwd, manifest) {
-  if (!manifest.libraries)
-    return Promise.resolve(false);
-  const libraries = Libraries__namespace.libraries(cwd, manifest.libraries);
-  const components = libraries.reduce((acc, lib) => {
-    return [...acc, ...lib.components];
-  }, []);
-  if (components.length === 0)
-    return Promise.resolve(false);
-  const remoteSlicesIds = await client.getSlices().then((slices) => slices.map((slice) => slice.id));
-  if (remoteSlicesIds.length) {
-    const pushAnyway = await promptToPushSlices();
-    if (pushAnyway === false)
-      return Promise.resolve(true);
-  }
-  const spinner = spinner$1("Pushing existing Slice models to your repository");
-  spinner.start();
-  const acl = await client.createAcl().catch((error) => {
-    writeError$1("Uploading screenshots for your slices failed, please contact us.");
-    writeError$1(error.message, "Full error:");
-    return null;
-  });
-  const models$1 = acl ? await updateSlicesWithScreenshots(client, acl, components) : components.map((component) => component.model);
-  await Promise.all(models$1.map(async (model) => {
-    const slice = models.Slices.fromSM(model);
-    const promise = remoteSlicesIds.includes(slice.id) ? client.updateSlice(slice) : client.insertSlice(slice);
-    return promise.catch((error) => {
-      writeError$1(`Sending slice ${model.id} - ${error.message}`);
-      throw error;
-    });
-  })).catch(() => {
-    process.exit(1);
-  });
-  spinner.succeed();
-  return Promise.resolve(true);
-}
-
-function readLocalCustomTypes(cwd) {
-  const customTypePaths = NodeUtils.CustomTypesPaths(cwd);
-  const dir = customTypePaths.value();
-  if (NodeUtils.Files.isDirectory(dir) === false)
-    return [];
-  const fileNames = NodeUtils.Files.readDirectory(dir);
-  const files = fileNames.reduce((acc, fileName) => {
-    const filePath = customTypePaths.customType(fileName).model();
-    const json = NodeUtils.Files.safeReadJson(filePath);
-    if (!json)
-      return acc;
-    const file = customtypes.CustomType.decode(json);
-    if (file instanceof Error) {
-      writeError$1(`reading ${filePath}: ${file.message}`);
-      return acc;
-    }
-    if (Either$1.isLeft(file)) {
-      writeError$1(`validating ${filePath}: ${JSON.stringify(file.left)}`);
-      return acc;
-    }
-    return [...acc, file.right];
-  }, []);
-  return files;
-}
-async function sendCustomTypes(client, cwd) {
-  const localCustomTypes = readLocalCustomTypes(cwd);
-  if (localCustomTypes.length === 0)
-    return Promise.resolve(false);
-  const remoteCustomTypeIds = await client.getCustomTypes().then((customTypes) => customTypes.map((customType) => customType.id));
-  if (remoteCustomTypeIds.length) {
-    const shouldPush = await promptToPushCustomTypes();
-    if (shouldPush === false)
-      return Promise.resolve(false);
-  }
-  const spinner = spinner$1("Pushing existing custom types to your repository");
-  spinner.start();
-  await Promise.all(localCustomTypes.map(async (customType) => {
-    const promise = remoteCustomTypeIds.includes(customType.id) ? client.updateCustomType(customType) : client.insertCustomType(customType);
-    return promise.catch((error) => {
-      writeError$1(`Sending custom type ${customType.id} - ${error.message}`);
-      throw error;
-    });
-  })).catch(() => {
-    process.exit(1);
-  });
-  spinner.succeed();
-  return Promise.resolve(true);
-}
-
-const SignatureFileReader = t__namespace.type({
-  signature: t__namespace.string
-});
-async function readSignatureFile(cwd) {
-  const pathToFile = path__default["default"].join(cwd, "documents", "index.json");
-  return fs__default["default"].promises.readFile(pathToFile, "utf-8").then((res) => {
-    const data = JSON.parse(res);
-    return Either.getOrElseW(() => {
-      throw new Error("Unable to read document signature file");
-    })(SignatureFileReader.decode(data));
-  });
-}
-async function readDocuments(cwd) {
-  const documentDir = path__default["default"].join(cwd, "documents");
-  const dirs = await lsdir(documentDir);
-  const files = (await Promise.all(dirs.map((dir) => lsfiles(dir)))).flat();
-  const documentObj = files.reduce((acc, file) => {
-    const filename = path__default["default"].parse(file).name;
-    const fileContent = fs__default["default"].readFileSync(file, "utf-8");
-    const json = JSON.parse(fileContent);
-    return { ...acc, [filename]: json };
-  }, {});
-  return documentObj;
-}
-async function sendDocuments(client, cwd) {
-  const pathToDocuments = path__default["default"].join(cwd, "documents");
-  const pathToSignatureFile = path__default["default"].join(pathToDocuments, "index.json");
-  if (!fs__default["default"].existsSync(pathToSignatureFile))
-    return Promise.resolve(false);
-  const signatureObj = await readSignatureFile(cwd);
-  const documents = await readDocuments(cwd);
-  if (Object.keys(documents).length === 0)
-    return Promise.resolve(false);
-  const spinner = spinner$1("Pushing existing documents to your repository");
-  spinner.start();
-  return client.pushDocuments(signatureObj.signature, documents, SharedConfig.PrismicSharedConfigManager.get().cookies).then(() => {
-    spinner.succeed();
-    fs__default["default"].rmSync(pathToDocuments, { recursive: true, force: true });
-    return true;
-  }).catch(async (e) => {
-    var _a;
-    spinner.fail();
-    if (((_a = e.response) == null ? void 0 : _a.data) === "Repository should not contain documents") {
-      writeError$1("The selected repository is not empty, documents cannot be uploaded. Please choose an empty repository or delete the documents contained in your repository.");
-    } else {
-      writeError$1("Sending documents failed, please try again. If the problem persists, contact us.");
-      writeError$1(`Full error: ${e.code || 500} - ${e.message}`);
-    }
-    await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Failed to push documents");
-    process.exit(1);
-  });
-}
-
-async function sendStarterData(client, cwd, pushDocuments = true) {
-  const manifest = NodeUtils.retrieveManifest(cwd);
-  const documentsPath = path__default["default"].join(cwd, "documents");
-  const hasDocuments = NodeUtils.Files.exists(documentsPath);
-  if (manifest.exists === false || hasDocuments === false)
-    return Promise.resolve(false);
-  if (manifest.content)
-    await sendSlices(client, cwd, manifest.content);
-  await sendCustomTypes(client, cwd);
-  if (!pushDocuments) {
-    fs__default["default"].rmSync(documentsPath, { recursive: true, force: true });
-    return Promise.resolve(true);
-  }
-  return sendDocuments(client, cwd);
-}
-
-const defaultSliceMachineVersion = "0.0.41";
-const getTheSliceMachineVersionInstalled = (packageJson) => {
-  var _a;
-  const sliceMachinePackageInstalled = Object.entries(((_a = packageJson.content) == null ? void 0 : _a.devDependencies) || {}).find((devDependency) => {
-    if (devDependency[0] === core.CONSTS.SM_PACKAGE_NAME) {
-      return devDependency;
-    }
-  });
-  if (!sliceMachinePackageInstalled) {
-    return defaultSliceMachineVersion;
-  }
-  const extractedVersion = extractVersionNumberFromSemver(sliceMachinePackageInstalled[1]);
-  if (!extractedVersion) {
-    return defaultSliceMachineVersion;
-  }
-  return extractedVersion;
-};
-const extractVersionNumberFromSemver = (semver) => {
-  const versionFound = semver.match(/\d+\.\d+\.\d+/);
-  if (versionFound && versionFound.length > 0) {
-    return versionFound[0];
-  }
-  return null;
-};
-function setVersion(cwd) {
-  var _a;
-  try {
-    const manifest = NodeUtils__namespace.retrieveManifest(cwd);
-    if ((_a = manifest.content) == null ? void 0 : _a._latest) {
-      return;
-    }
-    const packageJson = NodeUtils__namespace.retrieveJsonPackage(cwd);
-    const sliceMachineVersionInstalled = getTheSliceMachineVersionInstalled(packageJson);
-    NodeUtils__namespace.patchManifest(cwd, { _latest: sliceMachineVersionInstalled });
-  } catch (e) {
-    warning("Could not set _latest to installed slice-machine-ui version in sm.json");
-  }
-}
-
-async function init() {
-  const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const mode = getApplicationMode(findArgument(process.argv, "mode")) || client.ApplicationMode.PROD;
-  const lib = findArgument(process.argv, "library");
-  const branch = findArgument(process.argv, "branch");
-  const isTrackingAvailable = findArgument(process.argv, "tracking") !== "false";
-  const preSelectedRepository = findArgument(process.argv, "repository");
-  const pushDocuments = !findFlag(process.argv, "no-docs");
-  Tracker.get().initialize("ED3O1FVsa8DteNyRmAuDyMcPoftJ6VdP" , isTrackingAvailable);
-  void Tracker.get().trackInitStart(preSelectedRepository);
-  const client$1 = new InitClient(mode, null, Prismic__default["default"].PrismicSharedConfigManager.getAuth());
-  console.log(purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
-  validatePkg(cwd);
-  const user = await loginOrBypass(client$1);
-  Tracker.get().identifyUser(user.shortId, user.intercomHash);
-  void Tracker.get().trackInitIdentify();
-  const frameworkResult = await detectFramework(cwd);
-  const repository = await chooseOrCreateARepository(client$1, cwd, frameworkResult.value, preSelectedRepository);
-  Tracker.get().setRepository(repository);
-  client$1.updateRepository(repository);
-  const sliceLibPath = lib ? await installLib(cwd, lib, branch) : void 0;
-  const wasStarter = await sendStarterData(client$1, cwd, pushDocuments);
-  await configureProject(client$1, cwd, repository, frameworkResult, sliceLibPath, isTrackingAvailable);
-  await installRequiredDependencies(cwd, frameworkResult.value, wasStarter, frameworkResult.version);
-  setVersion(cwd);
-  if (isTrackingAvailable) {
-    writeInfo("We use tracking tools to improve user experience. Learn more: https://prismic.io/docs/slice-machine#tracking");
-  }
-  displayFinalMessage(cwd, wasStarter, repository, client$1.apisEndpoints.Wroom);
-}
-init().then(() => {
-  process.exit(0);
-}).catch(async (error) => {
-  if (error instanceof Error)
-    writeError$1(error.message);
-  else
-    console.error(error);
-  await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Failed to initialise Slice Machine.");
-});
-//# sourceMappingURL=index.js.map