@bundlekit/service 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3451 @@
+#!/usr/bin/env node
+import path from 'path';
+import { createJiti } from 'jiti';
+import { FileManager, Logger, PackageManager, BUNDLER_PACKAGE_MAP, confirm, buildSSRView } from '@bundlekit/shared-utils';
+import http from 'node:http';
+import { createRequire } from 'module';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var re$2 = {exports: {}};
+
+// 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$1 = 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;
+
+// Max safe length for a build identifier. The max length minus 6 characters for
+// the shortest version with a build 0.0.0+BUILD.
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+
+const RELEASE_TYPES = [
+  'major',
+  'premajor',
+  'minor',
+  'preminor',
+  'patch',
+  'prepatch',
+  'prerelease',
+];
+
+var constants$2 = {
+  MAX_LENGTH: MAX_LENGTH$1,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 0b001,
+  FLAG_LOOSE: 0b010,
+};
+
+const debug$1 = (
+  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$1;
+
+(function (module, exports) {
+
+	const {
+	  MAX_SAFE_COMPONENT_LENGTH,
+	  MAX_SAFE_BUILD_LENGTH,
+	  MAX_LENGTH,
+	} = constants$2;
+	const debug = debug_1;
+	exports = module.exports = {};
+
+	// The actual regexps go on exports.re
+	const re = exports.re = [];
+	const safeRe = exports.safeRe = [];
+	const src = exports.src = [];
+	const safeSrc = exports.safeSrc = [];
+	const t = exports.t = {};
+	let R = 0;
+
+	const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+	// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+	// used internally via the safeRe object since all inputs in this library get
+	// normalized first to trim and collapse all extra whitespace. The original
+	// regexes are exported for userland consumption and lower level usage. A
+	// future breaking change could export the safer regex only with a note that
+	// all input should have extra whitespace removed.
+	const safeRegexReplacements = [
+	  ['\\s', 1],
+	  ['\\d', MAX_LENGTH],
+	  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+	];
+
+	const makeSafeRegex = (value) => {
+	  for (const [token, max] of safeRegexReplacements) {
+	    value = value
+	      .split(`${token}*`).join(`${token}{0,${max}}`)
+	      .split(`${token}+`).join(`${token}{1,${max}}`);
+	  }
+	  return value
+	};
+
+	const createToken = (name, value, isGlobal) => {
+	  const safe = makeSafeRegex(value);
+	  const index = R++;
+	  debug(name, index, value);
+	  t[name] = index;
+	  src[index] = value;
+	  safeSrc[index] = safe;
+	  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+	  safeRe[index] = new RegExp(safe, 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', '\\d+');
+
+	// ## 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-]${LETTERDASHNUMBER}*`);
+
+	// ## 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.
+	// Non-numeric identifiers include numeric identifiers but can be longer.
+	// Therefore non-numeric identifiers must go first.
+
+	createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
+	}|${src[t.NUMERICIDENTIFIER]})`);
+
+	createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
+	}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+
+	// ## 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', `${LETTERDASHNUMBER}+`);
+
+	// ## 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 identifier, 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('COERCEPLAIN', `${'(^|[^\\d])' +
+	              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken('COERCEFULL', src[t.COERCEPLAIN] +
+	              `(?:${src[t.PRERELEASE]})?` +
+	              `(?:${src[t.BUILD]})?` +
+	              `(?:$|[^\\d])`);
+	createToken('COERCERTL', src[t.COERCE], true);
+	createToken('COERCERTLFULL', src[t.COERCEFULL], 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$2, re$2.exports));
+
+var reExports = re$2.exports;
+
+// parse out just the options we care about
+const looseOption = Object.freeze({ loose: true });
+const emptyOpts = Object.freeze({ });
+const parseOptions$1 = options => {
+  if (!options) {
+    return emptyOpts
+  }
+
+  if (typeof options !== 'object') {
+    return looseOption
+  }
+
+  return options
+};
+var parseOptions_1 = parseOptions$1;
+
+const numeric = /^[0-9]+$/;
+const compareIdentifiers$1 = (a, b) => {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a === b ? 0 : a < b ? -1 : 1
+  }
+
+  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$1 = {
+  compareIdentifiers: compareIdentifiers$1,
+  rcompareIdentifiers,
+};
+
+const debug = debug_1;
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants$2;
+const { safeRe: re$1, t: t$1 } = reExports;
+
+const parseOptions = parseOptions_1;
+const { compareIdentifiers } = identifiers$1;
+let SemVer$e = class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options);
+
+    if (version instanceof SemVer) {
+      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. Must be a string. Got type "${typeof version}".`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('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$1[t$1.LOOSE] : re$1[t$1.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('SemVer.compare', this.version, this.options, other);
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options);
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+
+    if (this.major < other.major) {
+      return -1
+    }
+    if (this.major > other.major) {
+      return 1
+    }
+    if (this.minor < other.minor) {
+      return -1
+    }
+    if (this.minor > other.minor) {
+      return 1
+    }
+    if (this.patch < other.patch) {
+      return -1
+    }
+    if (this.patch > other.patch) {
+      return 1
+    }
+    return 0
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(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('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)) {
+      other = new SemVer(other, this.options);
+    }
+
+    let i = 0;
+    do {
+      const a = this.build[i];
+      const b = other.build[i];
+      debug('build 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, identifierBase) {
+    if (release.startsWith('pre')) {
+      if (!identifier && identifierBase === false) {
+        throw new Error('invalid increment argument: identifier is empty')
+      }
+      // Avoid an invalid semver results
+      if (identifier) {
+        const match = `-${identifier}`.match(this.options.loose ? re$1[t$1.PRERELEASELOOSE] : re$1[t$1.PRERELEASE]);
+        if (!match || match[1] !== identifier) {
+          throw new Error(`invalid identifier: ${identifier}`)
+        }
+      }
+    }
+
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc('pre', identifier, identifierBase);
+        break
+      case 'preminor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc('pre', identifier, identifierBase);
+        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, identifierBase);
+        this.inc('pre', identifier, identifierBase);
+        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, identifierBase);
+        }
+        this.inc('pre', identifier, identifierBase);
+        break
+      case 'release':
+        if (this.prerelease.length === 0) {
+          throw new Error(`version ${this.raw} is not a prerelease`)
+        }
+        this.prerelease.length = 0;
+        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': {
+        const base = Number(identifierBase) ? 1 : 0;
+
+        if (this.prerelease.length === 0) {
+          this.prerelease = [base];
+        } 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
+            if (identifier === this.prerelease.join('.') && identifierBase === false) {
+              throw new Error('invalid increment argument: identifier already exists')
+            }
+            this.prerelease.push(base);
+          }
+        }
+        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
+          let prerelease = [identifier, base];
+          if (identifierBase === false) {
+            prerelease = [identifier];
+          }
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = prerelease;
+            }
+          } else {
+            this.prerelease = prerelease;
+          }
+        }
+        break
+      }
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.raw = this.format();
+    if (this.build.length) {
+      this.raw += `+${this.build.join('.')}`;
+    }
+    return this
+  }
+};
+
+var semver$2 = SemVer$e;
+
+const SemVer$d = semver$2;
+const parse$7 = (version, options, throwErrors = false) => {
+  if (version instanceof SemVer$d) {
+    return version
+  }
+  try {
+    return new SemVer$d(version, options)
+  } catch (er) {
+    if (!throwErrors) {
+      return null
+    }
+    throw er
+  }
+};
+
+var parse_1 = parse$7;
+
+const parse$6 = parse_1;
+const valid$2 = (version, options) => {
+  const v = parse$6(version, options);
+  return v ? v.version : null
+};
+var valid_1 = valid$2;
+
+const parse$5 = parse_1;
+const clean$1 = (version, options) => {
+  const s = parse$5(version.trim().replace(/^[=v]+/, ''), options);
+  return s ? s.version : null
+};
+var clean_1 = clean$1;
+
+const SemVer$c = semver$2;
+
+const inc$1 = (version, release, options, identifier, identifierBase) => {
+  if (typeof (options) === 'string') {
+    identifierBase = identifier;
+    identifier = options;
+    options = undefined;
+  }
+
+  try {
+    return new SemVer$c(
+      version instanceof SemVer$c ? version.version : version,
+      options
+    ).inc(release, identifier, identifierBase).version
+  } catch (er) {
+    return null
+  }
+};
+var inc_1 = inc$1;
+
+const parse$4 = parse_1;
+
+const diff$1 = (version1, version2) => {
+  const v1 = parse$4(version1, null, true);
+  const v2 = parse$4(version2, null, true);
+  const comparison = v1.compare(v2);
+
+  if (comparison === 0) {
+    return null
+  }
+
+  const v1Higher = comparison > 0;
+  const highVersion = v1Higher ? v1 : v2;
+  const lowVersion = v1Higher ? v2 : v1;
+  const highHasPre = !!highVersion.prerelease.length;
+  const lowHasPre = !!lowVersion.prerelease.length;
+
+  if (lowHasPre && !highHasPre) {
+    // Going from prerelease -> no prerelease requires some special casing
+
+    // If the low version has only a major, then it will always be a major
+    // Some examples:
+    // 1.0.0-1 -> 1.0.0
+    // 1.0.0-1 -> 1.1.1
+    // 1.0.0-1 -> 2.0.0
+    if (!lowVersion.patch && !lowVersion.minor) {
+      return 'major'
+    }
+
+    // If the main part has no difference
+    if (lowVersion.compareMain(highVersion) === 0) {
+      if (lowVersion.minor && !lowVersion.patch) {
+        return 'minor'
+      }
+      return 'patch'
+    }
+  }
+
+  // add the `pre` prefix if we are going to a prerelease version
+  const prefix = highHasPre ? 'pre' : '';
+
+  if (v1.major !== v2.major) {
+    return prefix + 'major'
+  }
+
+  if (v1.minor !== v2.minor) {
+    return prefix + 'minor'
+  }
+
+  if (v1.patch !== v2.patch) {
+    return prefix + 'patch'
+  }
+
+  // high and low are prereleases
+  return 'prerelease'
+};
+
+var diff_1 = diff$1;
+
+const SemVer$b = semver$2;
+const major$1 = (a, loose) => new SemVer$b(a, loose).major;
+var major_1 = major$1;
+
+const SemVer$a = semver$2;
+const minor$1 = (a, loose) => new SemVer$a(a, loose).minor;
+var minor_1 = minor$1;
+
+const SemVer$9 = semver$2;
+const patch$1 = (a, loose) => new SemVer$9(a, loose).patch;
+var patch_1 = patch$1;
+
+const parse$3 = parse_1;
+const prerelease$1 = (version, options) => {
+  const parsed = parse$3(version, options);
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+};
+var prerelease_1 = prerelease$1;
+
+const SemVer$8 = semver$2;
+const compare$b = (a, b, loose) =>
+  new SemVer$8(a, loose).compare(new SemVer$8(b, loose));
+
+var compare_1 = compare$b;
+
+const compare$a = compare_1;
+const rcompare$1 = (a, b, loose) => compare$a(b, a, loose);
+var rcompare_1 = rcompare$1;
+
+const compare$9 = compare_1;
+const compareLoose$1 = (a, b) => compare$9(a, b, true);
+var compareLoose_1 = compareLoose$1;
+
+const SemVer$7 = semver$2;
+const compareBuild$3 = (a, b, loose) => {
+  const versionA = new SemVer$7(a, loose);
+  const versionB = new SemVer$7(b, loose);
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+};
+var compareBuild_1 = compareBuild$3;
+
+const compareBuild$2 = compareBuild_1;
+const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose));
+var sort_1 = sort$1;
+
+const compareBuild$1 = compareBuild_1;
+const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose));
+var rsort_1 = rsort$1;
+
+const compare$8 = compare_1;
+const gt$4 = (a, b, loose) => compare$8(a, b, loose) > 0;
+var gt_1 = gt$4;
+
+const compare$7 = compare_1;
+const lt$3 = (a, b, loose) => compare$7(a, b, loose) < 0;
+var lt_1 = lt$3;
+
+const compare$6 = compare_1;
+const eq$2 = (a, b, loose) => compare$6(a, b, loose) === 0;
+var eq_1 = eq$2;
+
+const compare$5 = compare_1;
+const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0;
+var neq_1 = neq$2;
+
+const compare$4 = compare_1;
+const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0;
+var gte_1 = gte$3;
+
+const compare$3 = compare_1;
+const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0;
+var lte_1 = lte$3;
+
+const eq$1 = eq_1;
+const neq$1 = neq_1;
+const gt$3 = gt_1;
+const gte$2 = gte_1;
+const lt$2 = lt_1;
+const lte$2 = 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$1(a, b, loose)
+
+    case '!=':
+      return neq$1(a, b, loose)
+
+    case '>':
+      return gt$3(a, b, loose)
+
+    case '>=':
+      return gte$2(a, b, loose)
+
+    case '<':
+      return lt$2(a, b, loose)
+
+    case '<=':
+      return lte$2(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+};
+var cmp_1 = cmp$1;
+
+const SemVer$6 = semver$2;
+const parse$2 = parse_1;
+const { safeRe: re, t } = reExports;
+
+const coerce$1 = (version, options) => {
+  if (version instanceof SemVer$6) {
+    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(options.includePrerelease ? re[t.COERCEFULL] : re[t.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'
+    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.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.
+    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+    let next;
+    while ((next = coerceRtlRegex.exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+        match = next;
+      }
+      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+    }
+    // leave it in a clean state
+    coerceRtlRegex.lastIndex = -1;
+  }
+
+  if (match === null) {
+    return null
+  }
+
+  const major = match[2];
+  const minor = match[3] || '0';
+  const patch = match[4] || '0';
+  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : '';
+  const build = options.includePrerelease && match[6] ? `+${match[6]}` : '';
+
+  return parse$2(`${major}.${minor}.${patch}${prerelease}${build}`, options)
+};
+var coerce_1 = coerce$1;
+
+const parse$1 = parse_1;
+const constants$1 = constants$2;
+const SemVer$5 = semver$2;
+
+const truncate$1 = (version, truncation, options) => {
+  if (!constants$1.RELEASE_TYPES.includes(truncation)) {
+    return null
+  }
+
+  const clonedVersion = cloneInputVersion(version, options);
+  return clonedVersion && doTruncation(clonedVersion, truncation)
+};
+
+const cloneInputVersion = (version, options) => {
+  const versionStringToParse = (
+    version instanceof SemVer$5 ? version.version : version
+  );
+
+  return parse$1(versionStringToParse, options)
+};
+
+const doTruncation = (version, truncation) => {
+  if (isPrerelease(truncation)) {
+    return version.version
+  }
+
+  version.prerelease = [];
+
+  switch (truncation) {
+    case 'major':
+      version.minor = 0;
+      version.patch = 0;
+      break
+    case 'minor':
+      version.patch = 0;
+      break
+  }
+
+  return version.format()
+};
+
+const isPrerelease = (type) => {
+  return type.startsWith('pre')
+};
+
+var truncate_1 = truncate$1;
+
+var lrucache;
+var hasRequiredLrucache;
+
+function requireLrucache () {
+	if (hasRequiredLrucache) return lrucache;
+	hasRequiredLrucache = 1;
+
+	class LRUCache {
+	  constructor () {
+	    this.max = 1000;
+	    this.map = new Map();
+	  }
+
+	  get (key) {
+	    const value = this.map.get(key);
+	    if (value === undefined) {
+	      return undefined
+	    } else {
+	      // Remove the key from the map and add it to the end
+	      this.map.delete(key);
+	      this.map.set(key, value);
+	      return value
+	    }
+	  }
+
+	  delete (key) {
+	    return this.map.delete(key)
+	  }
+
+	  set (key, value) {
+	    const deleted = this.delete(key);
+
+	    if (!deleted && value !== undefined) {
+	      // If cache is full, delete the least recently used item
+	      if (this.map.size >= this.max) {
+	        const firstKey = this.map.keys().next().value;
+	        this.delete(firstKey);
+	      }
+
+	      this.map.set(key, value);
+	    }
+
+	    return this
+	  }
+	}
+
+	lrucache = LRUCache;
+	return lrucache;
+}
+
+var range;
+var hasRequiredRange;
+
+function requireRange () {
+	if (hasRequiredRange) return range;
+	hasRequiredRange = 1;
+
+	const SPACE_CHARACTERS = /\s+/g;
+
+	// hoisted class for cyclic dependency
+	class Range {
+	  constructor (range, options) {
+	    options = parseOptions(options);
+
+	    if (range instanceof Range) {
+	      if (
+	        range.loose === !!options.loose &&
+	        range.includePrerelease === !!options.includePrerelease
+	      ) {
+	        return range
+	      } else {
+	        return new Range(range.raw, options)
+	      }
+	    }
+
+	    if (range instanceof Comparator) {
+	      // just put it in the set and return
+	      this.raw = range.value;
+	      this.set = [[range]];
+	      this.formatted = undefined;
+	      return this
+	    }
+
+	    this.options = options;
+	    this.loose = !!options.loose;
+	    this.includePrerelease = !!options.includePrerelease;
+
+	    // First reduce all whitespace as much as possible so we do not have to rely
+	    // on potentially slow regexes like \s*. This is then stored and used for
+	    // future error messages as well.
+	    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
+
+	    // First, split on ||
+	    this.set = this.raw
+	      .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: ${this.raw}`)
+	    }
+
+	    // 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.formatted = undefined;
+	  }
+
+	  get range () {
+	    if (this.formatted === undefined) {
+	      this.formatted = '';
+	      for (let i = 0; i < this.set.length; i++) {
+	        if (i > 0) {
+	          this.formatted += '||';
+	        }
+	        const comps = this.set[i];
+	        for (let k = 0; k < comps.length; k++) {
+	          if (k > 0) {
+	            this.formatted += ' ';
+	          }
+	          this.formatted += comps[k].toString().trim();
+	        }
+	      }
+	    }
+	    return this.formatted
+	  }
+
+	  format () {
+	    return this.range
+	  }
+
+	  toString () {
+	    return this.range
+	  }
+
+	  parseRange (range) {
+	    // memoize range parsing for performance.
+	    // this is a very hot path, and fully deterministic.
+	    const memoOpts =
+	      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
+	      (this.options.loose && FLAG_LOOSE);
+	    const memoKey = 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);
+	    debug('tilde trim', range);
+
+	    // `^ 1.2.3` => `^1.2.3`
+	    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+	    debug('caret trim', range);
+
+	    // 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)) {
+	      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
+	  }
+	}
+
+	range = Range;
+
+	const LRU = requireLrucache();
+	const cache = new LRU();
+
+	const parseOptions = parseOptions_1;
+	const Comparator = requireComparator();
+	const debug = debug_1;
+	const SemVer = semver$2;
+	const {
+	  safeRe: re,
+	  t,
+	  comparatorTrimReplace,
+	  tildeTrimReplace,
+	  caretTrimReplace,
+	} = reExports;
+	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = constants$2;
+
+	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) => {
+	  comp = comp.replace(re[t.BUILD], '');
+	  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) => {
+	  return comp
+	    .trim()
+	    .split(/\s+/)
+	    .map((c) => 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) => {
+	  return comp
+	    .trim()
+	    .split(/\s+/)
+	    .map((c) => 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) => 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
+	// TODO build?
+	const hyphenReplace = incPr => ($0,
+	  from, fM, fm, fp, fpr, fb,
+	  to, tM, tm, tp, tpr) => {
+	  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
+	};
+	return range;
+}
+
+var comparator;
+var hasRequiredComparator;
+
+function requireComparator () {
+	if (hasRequiredComparator) return comparator;
+	hasRequiredComparator = 1;
+
+	const ANY = Symbol('SemVer ANY');
+	// hoisted class for cyclic dependency
+	class Comparator {
+	  static get ANY () {
+	    return ANY
+	  }
+
+	  constructor (comp, options) {
+	    options = parseOptions(options);
+
+	    if (comp instanceof Comparator) {
+	      if (comp.loose === !!options.loose) {
+	        return comp
+	      } else {
+	        comp = comp.value;
+	      }
+	    }
+
+	    comp = comp.trim().split(/\s+/).join(' ');
+	    debug('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('comp', this);
+	  }
+
+	  parse (comp) {
+	    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.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(m[2], this.options.loose);
+	    }
+	  }
+
+	  toString () {
+	    return this.value
+	  }
+
+	  test (version) {
+	    debug('Comparator.test', version, this.options.loose);
+
+	    if (this.semver === ANY || version === ANY) {
+	      return true
+	    }
+
+	    if (typeof version === 'string') {
+	      try {
+	        version = new SemVer(version, this.options);
+	      } catch (er) {
+	        return false
+	      }
+	    }
+
+	    return cmp(version, this.operator, this.semver, this.options)
+	  }
+
+	  intersects (comp, options) {
+	    if (!(comp instanceof Comparator)) {
+	      throw new TypeError('a Comparator is required')
+	    }
+
+	    if (this.operator === '') {
+	      if (this.value === '') {
+	        return true
+	      }
+	      return new Range(comp.value, options).test(this.value)
+	    } else if (comp.operator === '') {
+	      if (comp.value === '') {
+	        return true
+	      }
+	      return new Range(this.value, options).test(comp.semver)
+	    }
+
+	    options = parseOptions(options);
+
+	    // Special cases where nothing can possibly be lower
+	    if (options.includePrerelease &&
+	      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+	      return false
+	    }
+	    if (!options.includePrerelease &&
+	      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+	      return false
+	    }
+
+	    // Same direction increasing (> or >=)
+	    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+	      return true
+	    }
+	    // Same direction decreasing (< or <=)
+	    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+	      return true
+	    }
+	    // same SemVer and both sides are inclusive (<= or >=)
+	    if (
+	      (this.semver.version === comp.semver.version) &&
+	      this.operator.includes('=') && comp.operator.includes('=')) {
+	      return true
+	    }
+	    // opposite directions less than
+	    if (cmp(this.semver, '<', comp.semver, options) &&
+	      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+	      return true
+	    }
+	    // opposite directions greater than
+	    if (cmp(this.semver, '>', comp.semver, options) &&
+	      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+	      return true
+	    }
+	    return false
+	  }
+	}
+
+	comparator = Comparator;
+
+	const parseOptions = parseOptions_1;
+	const { safeRe: re, t } = reExports;
+	const cmp = cmp_1;
+	const debug = debug_1;
+	const SemVer = semver$2;
+	const Range = requireRange();
+	return comparator;
+}
+
+const Range$9 = requireRange();
+const satisfies$4 = (version, range, options) => {
+  try {
+    range = new Range$9(range, options);
+  } catch (er) {
+    return false
+  }
+  return range.test(version)
+};
+var satisfies_1 = satisfies$4;
+
+const Range$8 = requireRange();
+
+// Mostly just for testing and legacy API reasons
+const toComparators$1 = (range, options) =>
+  new Range$8(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '));
+
+var toComparators_1 = toComparators$1;
+
+const SemVer$4 = semver$2;
+const Range$7 = requireRange();
+
+const maxSatisfying$1 = (versions, range, options) => {
+  let max = null;
+  let maxSV = null;
+  let rangeObj = null;
+  try {
+    rangeObj = new Range$7(range, options);
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v;
+        maxSV = new SemVer$4(max, options);
+      }
+    }
+  });
+  return max
+};
+var maxSatisfying_1 = maxSatisfying$1;
+
+const SemVer$3 = semver$2;
+const Range$6 = requireRange();
+const minSatisfying$1 = (versions, range, options) => {
+  let min = null;
+  let minSV = null;
+  let rangeObj = null;
+  try {
+    rangeObj = new Range$6(range, options);
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v;
+        minSV = new SemVer$3(min, options);
+      }
+    }
+  });
+  return min
+};
+var minSatisfying_1 = minSatisfying$1;
+
+const SemVer$2 = semver$2;
+const Range$5 = requireRange();
+const gt$2 = gt_1;
+
+const minVersion$1 = (range, loose) => {
+  range = new Range$5(range, loose);
+
+  let minver = new SemVer$2('0.0.0');
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer$2('0.0.0-0');
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null;
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i];
+
+    let setMin = null;
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer$2(comparator.semver.version);
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++;
+          } else {
+            compver.prerelease.push(0);
+          }
+          compver.raw = compver.format();
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt$2(compver, setMin)) {
+            setMin = compver;
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    });
+    if (setMin && (!minver || gt$2(minver, setMin))) {
+      minver = setMin;
+    }
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+};
+var minVersion_1 = minVersion$1;
+
+const Range$4 = requireRange();
+const validRange$1 = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range$4(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+};
+var valid$1 = validRange$1;
+
+const SemVer$1 = semver$2;
+const Comparator$2 = requireComparator();
+const { ANY: ANY$1 } = Comparator$2;
+const Range$3 = requireRange();
+const satisfies$3 = satisfies_1;
+const gt$1 = gt_1;
+const lt$1 = lt_1;
+const lte$1 = lte_1;
+const gte$1 = gte_1;
+
+const outside$3 = (version, range, hilo, options) => {
+  version = new SemVer$1(version, options);
+  range = new Range$3(range, options);
+
+  let gtfn, ltefn, ltfn, comp, ecomp;
+  switch (hilo) {
+    case '>':
+      gtfn = gt$1;
+      ltefn = lte$1;
+      ltfn = lt$1;
+      comp = '>';
+      ecomp = '>=';
+      break
+    case '<':
+      gtfn = lt$1;
+      ltefn = gte$1;
+      ltfn = gt$1;
+      comp = '<';
+      ecomp = '<=';
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisfies the range it is not outside
+  if (satisfies$3(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i];
+
+    let high = null;
+    let low = null;
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY$1) {
+        comparator = new Comparator$2('>=0.0.0');
+      }
+      high = high || comparator;
+      low = low || comparator;
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator;
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator;
+      }
+    });
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+};
+
+var outside_1 = outside$3;
+
+// Determine if version is greater than all the versions possible in the range.
+const outside$2 = outside_1;
+const gtr$1 = (version, range, options) => outside$2(version, range, '>', options);
+var gtr_1 = gtr$1;
+
+const outside$1 = outside_1;
+// Determine if version is less than all the versions possible in the range
+const ltr$1 = (version, range, options) => outside$1(version, range, '<', options);
+var ltr_1 = ltr$1;
+
+const Range$2 = requireRange();
+const intersects$1 = (r1, r2, options) => {
+  r1 = new Range$2(r1, options);
+  r2 = new Range$2(r2, options);
+  return r1.intersects(r2, options)
+};
+var intersects_1 = intersects$1;
+
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies$2 = satisfies_1;
+const compare$2 = compare_1;
+var simplify = (versions, range, options) => {
+  const set = [];
+  let first = null;
+  let prev = null;
+  const v = versions.sort((a, b) => compare$2(a, b, options));
+  for (const version of v) {
+    const included = satisfies$2(version, range, options);
+    if (included) {
+      prev = version;
+      if (!first) {
+        first = version;
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev]);
+      }
+      prev = null;
+      first = null;
+    }
+  }
+  if (first) {
+    set.push([first, null]);
+  }
+
+  const ranges = [];
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min);
+    } else if (!max && min === v[0]) {
+      ranges.push('*');
+    } else if (!max) {
+      ranges.push(`>=${min}`);
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`);
+    } else {
+      ranges.push(`${min} - ${max}`);
+    }
+  }
+  const simplified = ranges.join(' || ');
+  const original = typeof range.raw === 'string' ? range.raw : String(range);
+  return simplified.length < original.length ? simplified : range
+};
+
+const Range$1 = requireRange();
+const Comparator$1 = requireComparator();
+const { ANY } = Comparator$1;
+const satisfies$1 = satisfies_1;
+const compare$1 = compare_1;
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a null set, OR
+// - Every simple range `r1, r2, ...` which is not a null set is a subset of
+//   some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else if in prerelease mode, return false
+//   - else replace c with `[>=0.0.0]`
+// - If C is only the ANY comparator
+//   - if in prerelease mode, return true
+//   - else replace C with `[>=0.0.0]`
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If any C is a = range, and GT or LT are set, return false
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the GT.semver tuple, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+//   - If LT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the LT.semver tuple, return false
+// - Else return true
+
+const subset$1 = (sub, dom, options = {}) => {
+  if (sub === dom) {
+    return true
+  }
+
+  sub = new Range$1(sub, options);
+  dom = new Range$1(dom, options);
+  let sawNonNull = false;
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options);
+      sawNonNull = sawNonNull || isSub !== null;
+      if (isSub) {
+        continue OUTER
+      }
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull) {
+      return false
+    }
+  }
+  return true
+};
+
+const minimumVersionWithPreRelease = [new Comparator$1('>=0.0.0-0')];
+const minimumVersion = [new Comparator$1('>=0.0.0')];
+
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom) {
+    return true
+  }
+
+  if (sub.length === 1 && sub[0].semver === ANY) {
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      return true
+    } else if (options.includePrerelease) {
+      sub = minimumVersionWithPreRelease;
+    } else {
+      sub = minimumVersion;
+    }
+  }
+
+  if (dom.length === 1 && dom[0].semver === ANY) {
+    if (options.includePrerelease) {
+      return true
+    } else {
+      dom = minimumVersion;
+    }
+  }
+
+  const eqSet = new Set();
+  let gt, lt;
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=') {
+      gt = higherGT(gt, c, options);
+    } else if (c.operator === '<' || c.operator === '<=') {
+      lt = lowerLT(lt, c, options);
+    } else {
+      eqSet.add(c.semver);
+    }
+  }
+
+  if (eqSet.size > 1) {
+    return null
+  }
+
+  let gtltComp;
+  if (gt && lt) {
+    gtltComp = compare$1(gt.semver, lt.semver, options);
+    if (gtltComp > 0) {
+      return null
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
+      return null
+    }
+  }
+
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies$1(eq, String(gt), options)) {
+      return null
+    }
+
+    if (lt && !satisfies$1(eq, String(lt), options)) {
+      return null
+    }
+
+    for (const c of dom) {
+      if (!satisfies$1(eq, String(c), options)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  let higher, lower;
+  let hasDomLT, hasDomGT;
+  // if the subset has a prerelease, we need a comparator in the superset
+  // with the same tuple and a prerelease, or it's not a subset
+  let needDomLTPre = lt &&
+    !options.includePrerelease &&
+    lt.semver.prerelease.length ? lt.semver : false;
+  let needDomGTPre = gt &&
+    !options.includePrerelease &&
+    gt.semver.prerelease.length ? gt.semver : false;
+  // exception: <1.2.3-0 is the same as <1.2.3
+  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
+      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
+    needDomLTPre = false;
+  }
+
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=';
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=';
+    if (gt) {
+      if (needDomGTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomGTPre.major &&
+            c.semver.minor === needDomGTPre.minor &&
+            c.semver.patch === needDomGTPre.patch) {
+          needDomGTPre = false;
+        }
+      }
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options);
+        if (higher === c && higher !== gt) {
+          return false
+        }
+      } else if (gt.operator === '>=' && !satisfies$1(gt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (lt) {
+      if (needDomLTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomLTPre.major &&
+            c.semver.minor === needDomLTPre.minor &&
+            c.semver.patch === needDomLTPre.patch) {
+          needDomLTPre = false;
+        }
+      }
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options);
+        if (lower === c && lower !== lt) {
+          return false
+        }
+      } else if (lt.operator === '<=' && !satisfies$1(lt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      return false
+    }
+  }
+
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    return false
+  }
+
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    return false
+  }
+
+  // we needed a prerelease range in a specific tuple, but didn't get one
+  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
+  // because it includes prereleases in the 1.2.3 tuple
+  if (needDomGTPre || needDomLTPre) {
+    return false
+  }
+
+  return true
+};
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare$1(a.semver, b.semver, options);
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+};
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare$1(a.semver, b.semver, options);
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+};
+
+var subset_1 = subset$1;
+
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = reExports;
+const constants = constants$2;
+const SemVer = semver$2;
+const identifiers = identifiers$1;
+const parse = parse_1;
+const valid = valid_1;
+const clean = clean_1;
+const inc = inc_1;
+const diff = diff_1;
+const major = major_1;
+const minor = minor_1;
+const patch = patch_1;
+const prerelease = prerelease_1;
+const compare = compare_1;
+const rcompare = rcompare_1;
+const compareLoose = compareLoose_1;
+const compareBuild = compareBuild_1;
+const sort = sort_1;
+const rsort = rsort_1;
+const gt = gt_1;
+const lt = lt_1;
+const eq = eq_1;
+const neq = neq_1;
+const gte = gte_1;
+const lte = lte_1;
+const cmp = cmp_1;
+const coerce = coerce_1;
+const truncate = truncate_1;
+const Comparator = requireComparator();
+const Range = requireRange();
+const satisfies = satisfies_1;
+const toComparators = toComparators_1;
+const maxSatisfying = maxSatisfying_1;
+const minSatisfying = minSatisfying_1;
+const minVersion = minVersion_1;
+const validRange = valid$1;
+const outside = outside_1;
+const gtr = gtr_1;
+const ltr = ltr_1;
+const intersects = intersects_1;
+const simplifyRange = simplify;
+const subset = subset_1;
+var semver = {
+  parse,
+  valid,
+  clean,
+  inc,
+  diff,
+  major,
+  minor,
+  patch,
+  prerelease,
+  compare,
+  rcompare,
+  compareLoose,
+  compareBuild,
+  sort,
+  rsort,
+  gt,
+  lt,
+  eq,
+  neq,
+  gte,
+  lte,
+  cmp,
+  coerce,
+  truncate,
+  Comparator,
+  Range,
+  satisfies,
+  toComparators,
+  maxSatisfying,
+  minSatisfying,
+  minVersion,
+  validRange,
+  outside,
+  gtr,
+  ltr,
+  intersects,
+  simplifyRange,
+  subset,
+  SemVer,
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  RELEASE_TYPES: constants.RELEASE_TYPES,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+};
+
+var semver$1 = /*@__PURE__*/getDefaultExportFromCjs(semver);
+
+function hasKey(obj, keys) {
+	var o = obj;
+	keys.slice(0, -1).forEach(function (key) {
+		o = o[key] || {};
+	});
+
+	var key = keys[keys.length - 1];
+	return key in o;
+}
+
+function isNumber(x) {
+	if (typeof x === 'number') { return true; }
+	if ((/^0x[0-9a-f]+$/i).test(x)) { return true; }
+	return (/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/).test(x);
+}
+
+function isConstructorOrProto(obj, key) {
+	return (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__';
+}
+
+var minimist = function (args, opts) {
+	if (!opts) { opts = {}; }
+
+	var flags = {
+		bools: {},
+		strings: {},
+		unknownFn: null,
+	};
+
+	if (typeof opts.unknown === 'function') {
+		flags.unknownFn = opts.unknown;
+	}
+
+	if (typeof opts.boolean === 'boolean' && opts.boolean) {
+		flags.allBools = true;
+	} else {
+		[].concat(opts.boolean).filter(Boolean).forEach(function (key) {
+			flags.bools[key] = true;
+		});
+	}
+
+	var aliases = {};
+
+	function aliasIsBoolean(key) {
+		return aliases[key].some(function (x) {
+			return flags.bools[x];
+		});
+	}
+
+	Object.keys(opts.alias || {}).forEach(function (key) {
+		aliases[key] = [].concat(opts.alias[key]);
+		aliases[key].forEach(function (x) {
+			aliases[x] = [key].concat(aliases[key].filter(function (y) {
+				return x !== y;
+			}));
+		});
+	});
+
+	[].concat(opts.string).filter(Boolean).forEach(function (key) {
+		flags.strings[key] = true;
+		if (aliases[key]) {
+			[].concat(aliases[key]).forEach(function (k) {
+				flags.strings[k] = true;
+			});
+		}
+	});
+
+	var defaults = opts.default || {};
+
+	var argv = { _: [] };
+
+	function argDefined(key, arg) {
+		return (flags.allBools && (/^--[^=]+$/).test(arg))
+			|| flags.strings[key]
+			|| flags.bools[key]
+			|| aliases[key];
+	}
+
+	function setKey(obj, keys, value) {
+		var o = obj;
+		for (var i = 0; i < keys.length - 1; i++) {
+			var key = keys[i];
+			if (isConstructorOrProto(o, key)) { return; }
+			if (o[key] === undefined) { o[key] = {}; }
+			if (
+				o[key] === Object.prototype
+				|| o[key] === Number.prototype
+				|| o[key] === String.prototype
+			) {
+				o[key] = {};
+			}
+			if (o[key] === Array.prototype) { o[key] = []; }
+			o = o[key];
+		}
+
+		var lastKey = keys[keys.length - 1];
+		if (isConstructorOrProto(o, lastKey)) { return; }
+		if (
+			o === Object.prototype
+			|| o === Number.prototype
+			|| o === String.prototype
+		) {
+			o = {};
+		}
+		if (o === Array.prototype) { o = []; }
+		if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') {
+			o[lastKey] = value;
+		} else if (Array.isArray(o[lastKey])) {
+			o[lastKey].push(value);
+		} else {
+			o[lastKey] = [o[lastKey], value];
+		}
+	}
+
+	function setArg(key, val, arg) {
+		if (arg && flags.unknownFn && !argDefined(key, arg)) {
+			if (flags.unknownFn(arg) === false) { return; }
+		}
+
+		var value = !flags.strings[key] && isNumber(val)
+			? Number(val)
+			: val;
+		setKey(argv, key.split('.'), value);
+
+		(aliases[key] || []).forEach(function (x) {
+			setKey(argv, x.split('.'), value);
+		});
+	}
+
+	Object.keys(flags.bools).forEach(function (key) {
+		setArg(key, defaults[key] === undefined ? false : defaults[key]);
+	});
+
+	var notFlags = [];
+
+	if (args.indexOf('--') !== -1) {
+		notFlags = args.slice(args.indexOf('--') + 1);
+		args = args.slice(0, args.indexOf('--'));
+	}
+
+	for (var i = 0; i < args.length; i++) {
+		var arg = args[i];
+		var key;
+		var next;
+
+		if ((/^--.+=/).test(arg)) {
+			// Using [\s\S] instead of . because js doesn't support the
+			// 'dotall' regex modifier. See:
+			// http://stackoverflow.com/a/1068308/13216
+			var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+			key = m[1];
+			var value = m[2];
+			if (flags.bools[key]) {
+				value = value !== 'false';
+			}
+			setArg(key, value, arg);
+		} else if ((/^--no-.+/).test(arg)) {
+			key = arg.match(/^--no-(.+)/)[1];
+			setArg(key, false, arg);
+		} else if ((/^--.+/).test(arg)) {
+			key = arg.match(/^--(.+)/)[1];
+			next = args[i + 1];
+			if (
+				next !== undefined
+				&& !(/^(-|--)[^-]/).test(next)
+				&& !flags.bools[key]
+				&& !flags.allBools
+				&& (aliases[key] ? !aliasIsBoolean(key) : true)
+			) {
+				setArg(key, next, arg);
+				i += 1;
+			} else if ((/^(true|false)$/).test(next)) {
+				setArg(key, next === 'true', arg);
+				i += 1;
+			} else {
+				setArg(key, flags.strings[key] ? '' : true, arg);
+			}
+		} else if ((/^-[^-]+/).test(arg)) {
+			var letters = arg.slice(1, -1).split('');
+
+			var broken = false;
+			for (var j = 0; j < letters.length; j++) {
+				next = arg.slice(j + 2);
+
+				if (next === '-') {
+					setArg(letters[j], next, arg);
+					continue;
+				}
+
+				if ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') {
+					setArg(letters[j], next.slice(1), arg);
+					broken = true;
+					break;
+				}
+
+				if (
+					(/[A-Za-z]/).test(letters[j])
+					&& (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next)
+				) {
+					setArg(letters[j], next, arg);
+					broken = true;
+					break;
+				}
+
+				if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+					setArg(letters[j], arg.slice(j + 2), arg);
+					broken = true;
+					break;
+				} else {
+					setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+				}
+			}
+
+			key = arg.slice(-1)[0];
+			if (!broken && key !== '-') {
+				if (
+					args[i + 1]
+					&& !(/^(-|--)[^-]/).test(args[i + 1])
+					&& !flags.bools[key]
+					&& (aliases[key] ? !aliasIsBoolean(key) : true)
+				) {
+					setArg(key, args[i + 1], arg);
+					i += 1;
+				} else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) {
+					setArg(key, args[i + 1] === 'true', arg);
+					i += 1;
+				} else {
+					setArg(key, flags.strings[key] ? '' : true, arg);
+				}
+			}
+		} else {
+			if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+				argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+			}
+			if (opts.stopEarly) {
+				argv._.push.apply(argv._, args.slice(i + 1));
+				break;
+			}
+		}
+	}
+
+	Object.keys(defaults).forEach(function (k) {
+		if (!hasKey(argv, k.split('.'))) {
+			setKey(argv, k.split('.'), defaults[k]);
+
+			(aliases[k] || []).forEach(function (x) {
+				setKey(argv, x.split('.'), defaults[k]);
+			});
+		}
+	});
+
+	if (opts['--']) {
+		argv['--'] = notFlags.slice();
+	} else {
+		notFlags.forEach(function (k) {
+			argv._.push(k);
+		});
+	}
+
+	return argv;
+};
+
+var minimist$1 = /*@__PURE__*/getDefaultExportFromCjs(minimist);
+
+var name = "@bundlekit/service";
+var version = "0.0.1";
+var main = "./dist/index.cjs";
+var module$1 = "./dist/index.mjs";
+var cjs = "./dist/index.cjs";
+var description = "bundlekit-service is a tool for building and running applications using BundleKit plugins.";
+var bin = {
+	ds: "./dist/index.mjs",
+	"bundlekit-service": "./dist/index.cjs"
+};
+var exports$1 = {
+	".": {
+		"import": "./dist/index.mjs",
+		require: "./dist/index.cjs",
+		"default": "./dist/index.cjs"
+	}
+};
+var files = [
+	"dist",
+	"package.json",
+	"README.md"
+];
+var scripts = {
+	clean: "rimraf -rf ./dist",
+	debug: "tsx ./index.ts serve --bundler webpack --mode production",
+	"service:build": "pnpm run clean && rollup -c ./scripts/rollup.config.js"
+};
+var dependencies = {
+	"@bundlekit/shared-utils": "workspace:*",
+	jiti: "^2.4.2",
+	minimist: "^1.2.8",
+	semver: "^7.7.1"
+};
+var peerDependencies = {
+	"@bundlekit/bundler-webpack": "workspace:*",
+	"@bundlekit/bundler-vite": "workspace:*",
+	"@bundlekit/bundler-rspack": "workspace:*",
+	"@bundlekit/bundler-rollup": "workspace:*",
+	"@bundlekit/bundler-rolldown": "workspace:*"
+};
+var peerDependenciesMeta = {
+	"@bundlekit/bundler-webpack": {
+		optional: true
+	},
+	"@bundlekit/bundler-vite": {
+		optional: true
+	},
+	"@bundlekit/bundler-rspack": {
+		optional: true
+	},
+	"@bundlekit/bundler-rollup": {
+		optional: true
+	},
+	"@bundlekit/bundler-rolldown": {
+		optional: true
+	}
+};
+var devDependencies = {
+	"@rollup/plugin-commonjs": "^25.0.7",
+	"@rollup/plugin-json": "^6.1.0",
+	"@rollup/plugin-node-resolve": "^15.2.3",
+	"@rollup/plugin-terser": "^0.4.4",
+	"@rollup/plugin-typescript": "^11.1.6",
+	"@types/minimist": "^1.2.5",
+	"@types/semver": "^7.7.0",
+	rimraf: "^5.0.1",
+	rollup: "^4.13.0",
+	tslib: "^2.6.2",
+	tsx: "^4.19.2",
+	typescript: "^5.8.2"
+};
+var keywords = [
+	"bundlekit-service",
+	"ds"
+];
+var author = "harhao@163.com";
+var license = "ISC";
+var publishConfig = {
+	registry: "https://registry.npmjs.org/",
+	access: "public"
+};
+var engines = {
+	node: ">= 18.0.0"
+};
+var pkg = {
+	name: name,
+	version: version,
+	main: main,
+	module: module$1,
+	cjs: cjs,
+	description: description,
+	bin: bin,
+	exports: exports$1,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	peerDependencies: peerDependencies,
+	peerDependenciesMeta: peerDependenciesMeta,
+	devDependencies: devDependencies,
+	keywords: keywords,
+	author: author,
+	license: license,
+	publishConfig: publishConfig,
+	engines: engines
+};
+
+class PluginAPI {
+    // 插件构造函数
+    constructor(config) {
+        this.id = null; // 插件id名称
+        this.service = null; // 主流程service实例
+        const { id, service } = config;
+        this.id = id;
+        this.service = service;
+    }
+    // 获取插件名称
+    get pluginName() {
+        return this.id;
+    }
+    // 获取cli版本
+    get version() {
+        return pkg.version;
+    }
+    // 获取当前运行路径地址
+    getCwd() {
+        return this.service.context;
+    }
+    /**
+     * 注册命令
+     * @param command 命令名称
+     * @param args 命令参数 args = { _: ['serve'| 'build'], open: true, port: 880};
+     * @param rawArgs 原始命令参数 rawArgv = ['serve', '--open', '--port', '8080']
+     */
+    registerCommand(command, opts, fn) {
+        if (typeof opts === 'function') {
+            fn = opts;
+            opts = null;
+        }
+        this.service.commands[command] = { fn, opts: (opts || {}) };
+    }
+    /**
+     * 添加构建工具包
+     * @param packageName 包名称
+     */
+    async addBuildPackage(packageName) {
+        await this.service.packageManager.add(packageName, {
+            noSave: true,
+        });
+    }
+    /**
+     * 修改构建配置
+     * @param config 构建配置
+     */
+    modifyBuildConfig(config) {
+        this.service.setBuildConfig(config);
+    }
+}
+
+const getDefaultConfig = (context) => ({
+    mode: "development",
+    bundler: "webpack",
+    plugins: [],
+    changeConfigure: (config) => config,
+    config: {
+        development: {
+            target: "web",
+            publicPath: "/",
+            entry: "src/index",
+            output: { dir: "dist", filename: "[name].js", formats: "umd" },
+            alias: { "@": "src" },
+            externals: [],
+            js: { sourcemap: true, minify: false, splitChunks: false },
+            devServer: { open: false, proxy: {}, https: false, host: "0.0.0.0", port: 3000 },
+        },
+        production: {
+            target: "web",
+            publicPath: "/",
+            entry: "src/index",
+            output: { dir: "dist", filename: "[name].js", formats: "umd" },
+            alias: { "@": "src" },
+            externals: [],
+            js: { sourcemap: false, minify: true, splitChunks: true },
+            devServer: { open: false, proxy: {}, https: false, host: "0.0.0.0", port: 3000 },
+        },
+    },
+});
+
+class ConfigLoader {
+    constructor(context, mode) {
+        this.mode = mode;
+        this.context = context || process.cwd();
+        this.fileManager = new FileManager(context || process.cwd());
+    }
+    loadDevkitFileConfig() {
+        const tsConfigPath = path.resolve(this.context, ".bundlekitrc.ts");
+        const jsConfigPath = path.resolve(this.context, ".bundlekitrc.js");
+        const configPath = this.fileManager.isFilePathExist(tsConfigPath)
+            ? tsConfigPath
+            : this.fileManager.isFilePathExist(jsConfigPath)
+                ? jsConfigPath
+                : null;
+        if (!configPath) {
+            throw new Error(`未找到配置文件 .bundlekitrc.ts 或 .bundlekitrc.js，请在项目根目录 ${this.context} 下创建配置文件`);
+        }
+        const jiti = createJiti(import.meta.url, {
+            alias: { "@": path.resolve(this.context, "src") },
+        });
+        const userConfig = jiti(configPath);
+        return (userConfig.default || userConfig);
+    }
+    deepMerge(defaults, overrides) {
+        const result = { ...defaults };
+        for (const key of Object.keys(overrides)) {
+            const overrideVal = overrides[key];
+            const defaultVal = defaults[key];
+            if (overrideVal &&
+                typeof overrideVal === "object" &&
+                !Array.isArray(overrideVal) &&
+                defaultVal &&
+                typeof defaultVal === "object" &&
+                !Array.isArray(defaultVal)) {
+                result[key] = this.deepMerge(defaultVal, overrideVal);
+            }
+            else {
+                result[key] = overrideVal;
+            }
+        }
+        return result;
+    }
+    resolvePaths(config) {
+        const resolveDir = (dir) => path.isAbsolute(dir) ? dir : path.resolve(this.context, dir);
+        const resolved = { ...config, config: { ...config.config } };
+        for (const env of Object.keys(resolved.config || {})) {
+            const envConfig = { ...resolved.config[env] };
+            if (envConfig.entry) {
+                if (typeof envConfig.entry === "string") {
+                    envConfig.entry = resolveDir(envConfig.entry);
+                }
+                else if (Array.isArray(envConfig.entry)) {
+                    envConfig.entry = envConfig.entry.map(resolveDir);
+                }
+                else if (typeof envConfig.entry === "object") {
+                    const resolved = {};
+                    for (const [key, val] of Object.entries(envConfig.entry)) {
+                        resolved[key] = resolveDir(val);
+                    }
+                    envConfig.entry = resolved;
+                }
+            }
+            if (envConfig.output) {
+                const output = Array.isArray(envConfig.output) ? envConfig.output : [envConfig.output];
+                const resolvedOutputs = output.map((o) => ({
+                    ...o,
+                    dir: resolveDir(o.dir),
+                }));
+                envConfig.output = Array.isArray(envConfig.output) ? resolvedOutputs : resolvedOutputs[0];
+            }
+            if (envConfig.alias) {
+                const resolvedAlias = {};
+                for (const [key, val] of Object.entries(envConfig.alias)) {
+                    resolvedAlias[key] = resolveDir(String(val));
+                }
+                envConfig.alias = resolvedAlias;
+            }
+            resolved.config[env] = envConfig;
+        }
+        return resolved;
+    }
+    async resolveAllConfig() {
+        const defaultConfig = getDefaultConfig(this.context);
+        const userConfig = this.loadDevkitFileConfig();
+        const merged = this.deepMerge(defaultConfig, userConfig);
+        return this.resolvePaths(merged);
+    }
+}
+
+/**
+ * 在 transformConfig 完成后、changeConfigure 之前调用 tools[bundler]?(config, ctx)
+ *
+ * 返回值约定：
+ *   - hook 返回 undefined / void → 用 mutate 后的 rawConfig
+ *   - hook 返回新对象           → 用新对象替换
+ *
+ * hook 抛错 / Promise reject 时不吞掉，由调用方上层 try/catch 处理。
+ */
+async function applyTools(buildConfig, bundlerName, rawConfig, ctx) {
+    if (!buildConfig?.tools)
+        return rawConfig;
+    const hook = buildConfig.tools[bundlerName];
+    if (typeof hook !== "function")
+        return rawConfig;
+    const result = await hook(rawConfig, ctx);
+    return result === undefined ? rawConfig : result;
+}
+
+/**
+ * 简易 connect 风格 middleware 链运行器。
+ *
+ * 不引入 connect 依赖：service 通过 http.createServer 起服务，把 adapter 返回的
+ * middleware 数组按顺序调用；任意 middleware 调 next(err) 触发错误兜底，调 next()
+ * 不带参数则进入下一项；无 next 调用则视作终止响应（已写 res.end）。
+ */
+function runMiddlewares(req, res, mws) {
+    return new Promise((resolve, reject) => {
+        let i = 0;
+        const next = (err) => {
+            if (err)
+                return reject(err);
+            if (i >= mws.length)
+                return resolve();
+            const mw = mws[i++];
+            try {
+                const r = mw(req, res, next);
+                if (r && typeof r.then === "function") {
+                    r.then(undefined, reject);
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        };
+        next();
+    });
+}
+/**
+ * 启动 dev SSR HTTP server：把 adapter 的 middleware 链串到 http.createServer 上。
+ *
+ * 错误语义：
+ *   - middleware 抛错 → 返回 500 + stack overlay（dev 友好），生产不应启用 dev SSR
+ *   - 服务器自身 EADDRINUSE / 其他启动错 → reject promise
+ */
+async function startSSRDevServer(opts) {
+    const mws = Array.isArray(opts.middleware)
+        ? opts.middleware
+        : [opts.middleware];
+    const server = http.createServer((req, res) => {
+        runMiddlewares(req, res, mws).catch((err) => {
+            opts.onError?.(err);
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "text/html; charset=utf-8");
+            }
+            const safeStack = String(err?.stack || err?.message || err)
+                .replace(/&/g, "&amp;")
+                .replace(/</g, "&lt;");
+            res.end(`<pre>${safeStack}</pre>`);
+        });
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(opts.port, opts.host, () => {
+            const addr = server.address();
+            const port = typeof addr === "object" && addr ? addr.port : opts.port;
+            server.removeListener("error", reject);
+            resolve({
+                port,
+                close: () => new Promise((res2) => {
+                    server.close(() => res2());
+                }),
+            });
+        });
+    });
+}
+/**
+ * 从 buildConfig 中读取 envConfig（按 mode）的 devServer.host/port，回退到默认值
+ */
+function resolveDevServerBinding(buildConfig, mode) {
+    const envConfig = buildConfig.config?.[mode];
+    const host = envConfig?.devServer?.host || "0.0.0.0";
+    const port = typeof envConfig?.devServer?.port === "number"
+        ? envConfig.devServer.port
+        : 3000;
+    return { host, port };
+}
+
+class Service {
+    constructor(context) {
+        // 是否初始化
+        this.isInitial = false;
+        // 打包工具环境
+        this.mode = "development";
+        // 当前执行的命令名（serve / build / ...）
+        this.currentCommand = null;
+        // 执行命令的目录
+        this.context = null;
+        // 注册的命令集合
+        this.commands = {};
+        // 注册的插件集合
+        this.plugins = [];
+        // 各插件运行环境集合
+        this.modes = {};
+        // 日志打印
+        this.logger = new Logger();
+        // 需要跳过的插件列表
+        this.skipPlugins = null;
+        // 传递进来的config配置
+        this.configLoader = null;
+        // 打包工具配置
+        this.buildConfig = null;
+        this.context = context || process.cwd();
+        this.fileManager = new FileManager(this.context);
+        this.packageManager = new PackageManager({
+            context: this.context
+        });
+    }
+    /**
+     * 获取构建配置
+     * @returns 构建配置
+     */
+    getBuildConfig() {
+        return this.buildConfig;
+    }
+    /**
+     * 设置构建配置
+     * @param config 构建配置
+     */
+    setBuildConfig(config) {
+        if (!config) {
+            return;
+        }
+        this.buildConfig = config;
+    }
+    // 获取内置插件列表
+    async resolvePlugins() {
+        const sortedPlugins = [];
+        const builtInPlugins = [
+            await import('./chunks/build-BWky34L_.mjs').then(m => m.default),
+            await import('./chunks/serve-B-j5a77h.mjs').then(m => m.default),
+            await import('./chunks/help-BJWxLw5O.mjs').then(m => m.default)
+        ];
+        for (let plugin of builtInPlugins) {
+            const { defaultModes, apply } = plugin;
+            sortedPlugins.push({
+                id: `built-in:${plugin.defaultModes ? Object.keys(plugin.defaultModes)[0] : 'unknown'}`,
+                apply: apply,
+                defaultModes,
+            });
+        }
+        return sortedPlugins;
+    }
+    // 获取用户配置的插件列表（需在 buildConfig 加载后调用）
+    async resolveUserPlugins() {
+        const userPlugins = [];
+        if (this.buildConfig?.plugins && Array.isArray(this.buildConfig.plugins)) {
+            for (const pluginName of this.buildConfig.plugins) {
+                try {
+                    const require = createRequire(import.meta.url);
+                    const pluginPath = require.resolve(pluginName, {
+                        paths: [path.join(this.context, "node_modules")]
+                    });
+                    // 使用 jiti 加载，支持 .ts 源文件形式的插件包
+                    const jiti = createJiti(import.meta.url);
+                    const pluginModule = jiti(pluginPath);
+                    const resolved = pluginModule?.default || pluginModule;
+                    if (resolved?.apply) {
+                        userPlugins.push({
+                            id: `project:${pluginName}`,
+                            apply: resolved.apply,
+                            defaultModes: resolved.defaultModes || {},
+                        });
+                    }
+                }
+                catch (e) {
+                    this.logger.warn(`无法加载插件: ${pluginName}`, "插件管理");
+                }
+            }
+        }
+        return userPlugins;
+    }
+    /**
+     * 初始化服务所有的配置
+     * @param mode IBuildEnv 构建模式
+     * @param args Record<string, unknown> 额外的参数
+     */
+    async init(mode, args) {
+        this.configLoader = new ConfigLoader(this.context, mode);
+        // 要重新定义projectOptions类型
+        const buildConfig = await this.configLoader.resolveAllConfig();
+        // 设置构建配置
+        this.setBuildConfig({ ...buildConfig, ...(args.bundler ? { bundler: args.bundler } : {}) });
+        // buildConfig 加载完成后，追加用户配置的插件
+        const userPlugins = await this.resolveUserPlugins();
+        this.plugins = [...this.plugins, ...userPlugins];
+        for (let plugin of this.plugins) {
+            // 如果不是需要跳过的插件, 则执行apply函数
+            if (!this.skipPlugins?.has(plugin.id)) {
+                const { id, apply } = plugin;
+                const api = new PluginAPI({ id: id, service: this });
+                apply(api, this.getBuildConfig());
+            }
+        }
+    }
+    /**
+     * 收集需要跳过的插件
+     * @param args 格式化参数
+     * @param rawArgv 字符串参数
+     */
+    setPluginsToSkip(args, rawArgv) {
+        if (!this.skipPlugins) {
+            this.skipPlugins = new Set();
+        }
+        const skipArg = (args["skip-plugin"] || args.skipPlugin || args["skip-plugins"]);
+        if (skipArg) {
+            const pluginNames = skipArg.split(",").map((s) => s.trim()).filter(Boolean);
+            for (const name of pluginNames) {
+                this.skipPlugins.add(name);
+            }
+            this.logger.log(`跳过插件: ${Array.from(this.skipPlugins).join(", ")}`, "插件管理");
+        }
+    }
+    /**
+     * 处理打包工具的原生配置(暴露出去的配置)
+     * @param config 打包工具的配置(针对具体的bundler配置， 所以这里config的类型是Record<string, unknown>)
+     * @returns Recodr<string, unknown>
+     */
+    async configureConfig(config) {
+        if (!this.buildConfig?.changeConfigure) {
+            return config;
+        }
+        const result = this.buildConfig.changeConfigure(config, this.mode);
+        return result instanceof Promise ? await result : result;
+    }
+    /**
+     * 加载打包工具插件
+     * @param packageName 打包工具插件的packageName
+     * @returns 打包工具插件
+     */
+    async loadBundlerPlugin(packageName) {
+        try {
+            const require = createRequire(import.meta.url);
+            let bundlerModule;
+            try {
+                // 显式指定查找路径，优先当前 context 的 node_modules
+                const packagePath = require.resolve(packageName, {
+                    paths: [
+                        path.join(this.context, "node_modules"),
+                        path.join(process.cwd(), "node_modules")
+                    ]
+                });
+                bundlerModule = require(packagePath);
+                bundlerModule = bundlerModule.default || bundlerModule;
+            }
+            catch (e) {
+                // fallback: 动态 import
+                bundlerModule = await import(packageName);
+                bundlerModule = bundlerModule.default || bundlerModule;
+            }
+            return bundlerModule;
+        }
+        catch (error) {
+            this.logger.error(`无法加载打包工具插件: ${packageName}`, "构建工具");
+            return null;
+        }
+    }
+    /**
+     * 获取打包工具注册表（bundler 名称 → 适配器包名）
+     * @returns IBuildTools
+     */
+    getBundlerRegistry() {
+        return { ...BUNDLER_PACKAGE_MAP };
+    }
+    /**
+     * bundler 缺失时按策略矩阵决定：
+     * - TTY 且未设 DEVKIT_NO_PROMPT      → 弹 yes/no 询问
+     * - 非 TTY 且 DEVKIT_AUTO_INSTALL=1  → 直接装入 devDeps
+     * - 其他情况                          → 报错引导，返回 false
+     */
+    async resolveBundlerOrPrompt(packageName) {
+        const isTTY = !!process.stdout.isTTY && !!process.stdin.isTTY;
+        const noPrompt = process.env.DEVKIT_NO_PROMPT === "1";
+        const autoInstall = process.env.DEVKIT_AUTO_INSTALL === "1";
+        let shouldInstall = false;
+        if (isTTY && !noPrompt) {
+            shouldInstall = await confirm({
+                message: `未安装 ${packageName}，是否现在安装?`,
+                default: true,
+            });
+        }
+        else if (autoInstall) {
+            this.logger.log(`检测到 DEVKIT_AUTO_INSTALL=1，自动安装 ${packageName}`, "构建工具");
+            shouldInstall = true;
+        }
+        else {
+            shouldInstall = false;
+        }
+        if (!shouldInstall) {
+            const shortName = packageName.replace(/^@bundlekit\/bundler-/, "");
+            this.logger.error(`未安装 ${packageName}。请先运行：\n  bundlekit-cli add bundler-${shortName}\n` +
+                `或在 CI 中设置环境变量 DEVKIT_AUTO_INSTALL=1`, "构建工具");
+            return false;
+        }
+        if (!this.packageManager) {
+            this.logger.error("packageManager is not initialized");
+            return false;
+        }
+        const installed = await this.packageManager.add(packageName, { dev: true });
+        if (!installed) {
+            this.logger.error(`安装 ${packageName} 失败`, "构建工具");
+            return false;
+        }
+        this.logger.done(`已安装 ${packageName} 至 devDependencies`, "构建工具");
+        return true;
+    }
+    /**
+     * 单次 pass 的执行流：transformConfig → tools → changeConfigure → run
+     */
+    async runSinglePass(bundlerPlugin, passConfig, bundlerName, env) {
+        const builder = new bundlerPlugin(this, this.mode);
+        // server pass 的 ctx.env 切换为 'server'，给 tools hook 区分
+        const toolsCtx = {
+            mode: this.mode,
+            command: (this.currentCommand === "build" ? "build" : "serve"),
+            env,
+            bundler: bundlerName,
+        };
+        const builderConifg = await builder.transformConfig(passConfig);
+        const afterTools = await applyTools(passConfig, bundlerName, builderConifg, toolsCtx);
+        const finalConfig = await this.configureConfig(afterTools);
+        await builder.run(finalConfig);
+    }
+    /**
+     * 获取指定的bundler打包工具, 开始执行打包任务
+     * @param bundler 打包工具名称 vite/webpack/rollup/rspack/rolldown
+     */
+    async startBuilder() {
+        const bundlerList = this.getBundlerRegistry();
+        const finalBundler = this.buildConfig?.bundler || "vite";
+        const packageName = bundlerList[finalBundler];
+        let isInstallBundler = !!(await this.loadBundlerPlugin(packageName));
+        // 如果打包工具不在默认列表中，则按策略矩阵决定是否安装并写入 devDependencies
+        if (!isInstallBundler) {
+            const installed = await this.resolveBundlerOrPrompt(packageName);
+            if (!installed) {
+                process.exit(1);
+            }
+            isInstallBundler = !!(await this.loadBundlerPlugin(packageName));
+            if (!isInstallBundler) {
+                this.logger.error(`安装后仍无法加载 ${packageName}，请检查 node_modules`, "构建工具");
+                process.exit(1);
+            }
+        }
+        if (!isInstallBundler)
+            return;
+        this.logger.log(`使用的构建：${finalBundler}`, "构建工具");
+        const bundlerPlugin = await this.loadBundlerPlugin(packageName);
+        // 检测是否启用 SSR：当前 envConfig 上有 ssr 字段
+        const envConfig = this.buildConfig?.config?.[this.mode];
+        const ssrEnabled = !!envConfig?.ssr;
+        if (!ssrEnabled) {
+            // 普通单 pass 流（保持向后兼容）
+            await this.runSinglePass(bundlerPlugin, this.buildConfig, finalBundler, "client");
+            return;
+        }
+        // dev SSR 路径：service 起 HTTP server，adapter 提供 middleware 链
+        // 当且仅当 (currentCommand === 'serve') 且 envConfig.ssr.dev !== false 时启用 dev SSR
+        const ssrDev = !!envConfig?.ssr?.dev;
+        if (this.currentCommand === "serve" && ssrDev) {
+            const builder = new bundlerPlugin(this, this.mode);
+            if (typeof builder.createSSRMiddleware !== "function") {
+                this.logger.error(`bundler "${finalBundler}" 未实现 createSSRMiddleware，无法启动 dev SSR`, "构建工具");
+                process.exit(1);
+            }
+            try {
+                const middleware = await builder.createSSRMiddleware(this.buildConfig, {
+                    env: "client",
+                    isProduction: false,
+                });
+                const { host, port } = resolveDevServerBinding(this.buildConfig, this.mode);
+                const handle = await startSSRDevServer({
+                    middleware,
+                    host,
+                    port,
+                    onError: (err) => {
+                        this.logger.error(`SSR middleware 异常: ${err?.message ?? err}`, "构建工具");
+                    },
+                });
+                this.logger.done(`SSR dev server 就绪：http://${host === "0.0.0.0" ? "localhost" : host}:${handle.port}`, "构建工具");
+            }
+            catch (err) {
+                this.logger.error(`启动 SSR dev server 失败: ${err?.message ?? err}`, "构建工具");
+                process.exit(1);
+            }
+            return;
+        }
+        // build SSR 双 pass：先 client，再 server
+        this.logger.log(`SSR 模式启用：将依次执行 client + server 两次构建`, "构建工具");
+        // Pass 1: client
+        await this.runSinglePass(bundlerPlugin, this.buildConfig, finalBundler, "client");
+        // Pass 2: server（用 buildSSRView 切换 entry / output / target）
+        const serverBuildConfig = buildSSRView(this.buildConfig, this.mode);
+        await this.runSinglePass(bundlerPlugin, serverBuildConfig, finalBundler, "server");
+        this.logger.done(`SSR 双产物构建完成`, "构建工具");
+    }
+    /**
+     * service 开始运行函数
+     * @param command 执行的命令 build/serve/help 等等
+     * @param args args = { _: ['serve'| 'build'], open: true, port: 880};
+     * @param rawArgv 原始命令参数 rawArgv = ['serve', '--open', '--port', '8080']
+     */
+    async run(command, args, rawArgv = []) {
+        if (this.isInitial) {
+            return;
+        }
+        this.isInitial = true;
+        this.currentCommand = command;
+        // 解析项目内插件和内置插件处理  
+        this.plugins = await this.resolvePlugins();
+        // 收集各插件依赖支持的环境
+        this.modes = this.plugins.reduce((modes, plugin) => {
+            if (plugin?.defaultModes) {
+                return { ...modes, ...plugin.defaultModes };
+            }
+            return modes;
+        }, {});
+        // 当前的环境
+        this.mode = (typeof args.mode === 'string'
+            ? args.mode
+            : command === 'build' && args.watch
+                ? 'development'
+                : this.modes[command]);
+        // 需要跳过的插件       
+        this.setPluginsToSkip(args, rawArgv);
+        args._ = args._ || [];
+        // 初始化操作
+        await this.init(this.mode, args);
+        let runCommand = this.commands[command];
+        if (!runCommand && command) {
+            this.logger.error(`command ${command} is not defined in bundlekit-service`);
+            process.exit(1);
+        }
+        if (!command || args.help || args.h) {
+            runCommand = this.commands["help"];
+        }
+        else {
+            args._.shift();
+            rawArgv.shift();
+        }
+        const { fn } = runCommand;
+        fn(args, rawArgv);
+    }
+}
+
+async function startBuildService() {
+    const logger = new Logger();
+    try {
+        // 检查node版本
+        let requireNodeVersion = pkg.engines.node;
+        if (!semver$1.satisfies(process.version, requireNodeVersion, { includePrerelease: true })) {
+            //增加打印错误信息
+            logger.error(`Required node version ${requireNodeVersion}, but got ${process.version}.\nPlease upgrade your node.`);
+            process.exit(1);
+        }
+        const service = new Service();
+        const rawArgv = process.argv.slice(2);
+        const args = minimist$1(rawArgv, {
+            // TODO 这里可以增加更多的参数转成布尔值
+            boolean: [
+                "open",
+            ]
+        });
+        const command = args._[0];
+        // 在服务启动前注册进程信号处理，确保启动过程中也能优雅退出
+        process.on('SIGINT', () => {
+            logger.info('接收到 SIGINT 信号，正在优雅关闭服务...');
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            logger.info('接收到 SIGTERM 信号，正在优雅关闭服务...');
+            process.exit(0);
+        });
+        await service.run(command, args, rawArgv);
+    }
+    catch (error) {
+        // 增加打印错误信息
+        logger.error(error);
+        process.exit(1);
+    }
+}
+startBuildService();
+
+export { getDefaultConfig as g };