@windrun-huaiin/dev-scripts 14.0.0 → 14.1.0

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js

@@ -0,0 +1,144 @@
+'use strict';
+
+var re = require('./internal/re.js');
+var constants = require('./internal/constants.js');
+var semver$1 = require('./classes/semver.js');
+var identifiers = require('./internal/identifiers.js');
+var parse = require('./functions/parse.js');
+var valid = require('./functions/valid.js');
+var clean = require('./functions/clean.js');
+var inc = require('./functions/inc.js');
+var diff = require('./functions/diff.js');
+var major = require('./functions/major.js');
+var minor = require('./functions/minor.js');
+var patch = require('./functions/patch.js');
+var prerelease = require('./functions/prerelease.js');
+var compare = require('./functions/compare.js');
+var rcompare = require('./functions/rcompare.js');
+var compareLoose = require('./functions/compare-loose.js');
+var compareBuild = require('./functions/compare-build.js');
+var sort = require('./functions/sort.js');
+var rsort = require('./functions/rsort.js');
+var gt = require('./functions/gt.js');
+var lt = require('./functions/lt.js');
+var eq = require('./functions/eq.js');
+var neq = require('./functions/neq.js');
+var gte = require('./functions/gte.js');
+var lte = require('./functions/lte.js');
+var cmp = require('./functions/cmp.js');
+var coerce = require('./functions/coerce.js');
+var comparator = require('./classes/comparator.js');
+var range = require('./classes/range.js');
+var satisfies = require('./functions/satisfies.js');
+var toComparators = require('./ranges/to-comparators.js');
+var maxSatisfying = require('./ranges/max-satisfying.js');
+var minSatisfying = require('./ranges/min-satisfying.js');
+var minVersion = require('./ranges/min-version.js');
+var valid$1 = require('./ranges/valid.js');
+var outside = require('./ranges/outside.js');
+var gtr = require('./ranges/gtr.js');
+var ltr = require('./ranges/ltr.js');
+var intersects = require('./ranges/intersects.js');
+var simplify = require('./ranges/simplify.js');
+var subset = require('./ranges/subset.js');
+
+var semver;
+var hasRequiredSemver;
+
+function requireSemver () {
+	if (hasRequiredSemver) return semver;
+	hasRequiredSemver = 1;
+
+	// just pre-load all the stuff that index.js lazily exports
+	const internalRe = re.__require();
+	const constants$1 = constants.__require();
+	const SemVer = semver$1.__require();
+	const identifiers$1 = identifiers.__require();
+	const parse$1 = parse.__require();
+	const valid$2 = valid.__require();
+	const clean$1 = clean.__require();
+	const inc$1 = inc.__require();
+	const diff$1 = diff.__require();
+	const major$1 = major.__require();
+	const minor$1 = minor.__require();
+	const patch$1 = patch.__require();
+	const prerelease$1 = prerelease.__require();
+	const compare$1 = compare.__require();
+	const rcompare$1 = rcompare.__require();
+	const compareLoose$1 = compareLoose.__require();
+	const compareBuild$1 = compareBuild.__require();
+	const sort$1 = sort.__require();
+	const rsort$1 = rsort.__require();
+	const gt$1 = gt.__require();
+	const lt$1 = lt.__require();
+	const eq$1 = eq.__require();
+	const neq$1 = neq.__require();
+	const gte$1 = gte.__require();
+	const lte$1 = lte.__require();
+	const cmp$1 = cmp.__require();
+	const coerce$1 = coerce.__require();
+	const Comparator = comparator.__require();
+	const Range = range.__require();
+	const satisfies$1 = satisfies.__require();
+	const toComparators$1 = toComparators.__require();
+	const maxSatisfying$1 = maxSatisfying.__require();
+	const minSatisfying$1 = minSatisfying.__require();
+	const minVersion$1 = minVersion.__require();
+	const validRange = valid$1.__require();
+	const outside$1 = outside.__require();
+	const gtr$1 = gtr.__require();
+	const ltr$1 = ltr.__require();
+	const intersects$1 = intersects.__require();
+	const simplifyRange = simplify.__require();
+	const subset$1 = subset.__require();
+	semver = {
+	  parse: parse$1,
+	  valid: valid$2,
+	  clean: clean$1,
+	  inc: inc$1,
+	  diff: diff$1,
+	  major: major$1,
+	  minor: minor$1,
+	  patch: patch$1,
+	  prerelease: prerelease$1,
+	  compare: compare$1,
+	  rcompare: rcompare$1,
+	  compareLoose: compareLoose$1,
+	  compareBuild: compareBuild$1,
+	  sort: sort$1,
+	  rsort: rsort$1,
+	  gt: gt$1,
+	  lt: lt$1,
+	  eq: eq$1,
+	  neq: neq$1,
+	  gte: gte$1,
+	  lte: lte$1,
+	  cmp: cmp$1,
+	  coerce: coerce$1,
+	  Comparator,
+	  Range,
+	  satisfies: satisfies$1,
+	  toComparators: toComparators$1,
+	  maxSatisfying: maxSatisfying$1,
+	  minSatisfying: minSatisfying$1,
+	  minVersion: minVersion$1,
+	  validRange,
+	  outside: outside$1,
+	  gtr: gtr$1,
+	  ltr: ltr$1,
+	  intersects: intersects$1,
+	  simplifyRange,
+	  subset: subset$1,
+	  SemVer,
+	  re: internalRe.re,
+	  src: internalRe.src,
+	  tokens: internalRe.t,
+	  SEMVER_SPEC_VERSION: constants$1.SEMVER_SPEC_VERSION,
+	  RELEASE_TYPES: constants$1.RELEASE_TYPES,
+	  compareIdentifiers: identifiers$1.compareIdentifiers,
+	  rcompareIdentifiers: identifiers$1.rcompareIdentifiers,
+	};
+	return semver;
+}
+
+exports.__require = requireSemver;

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.mjs

@@ -0,0 +1,142 @@
+import { __require as requireRe } from './internal/re.mjs';
+import { __require as requireConstants } from './internal/constants.mjs';
+import { __require as requireSemver$1 } from './classes/semver.mjs';
+import { __require as requireIdentifiers } from './internal/identifiers.mjs';
+import { __require as requireParse } from './functions/parse.mjs';
+import { __require as requireValid } from './functions/valid.mjs';
+import { __require as requireClean } from './functions/clean.mjs';
+import { __require as requireInc } from './functions/inc.mjs';
+import { __require as requireDiff } from './functions/diff.mjs';
+import { __require as requireMajor } from './functions/major.mjs';
+import { __require as requireMinor } from './functions/minor.mjs';
+import { __require as requirePatch } from './functions/patch.mjs';
+import { __require as requirePrerelease } from './functions/prerelease.mjs';
+import { __require as requireCompare } from './functions/compare.mjs';
+import { __require as requireRcompare } from './functions/rcompare.mjs';
+import { __require as requireCompareLoose } from './functions/compare-loose.mjs';
+import { __require as requireCompareBuild } from './functions/compare-build.mjs';
+import { __require as requireSort } from './functions/sort.mjs';
+import { __require as requireRsort } from './functions/rsort.mjs';
+import { __require as requireGt } from './functions/gt.mjs';
+import { __require as requireLt } from './functions/lt.mjs';
+import { __require as requireEq } from './functions/eq.mjs';
+import { __require as requireNeq } from './functions/neq.mjs';
+import { __require as requireGte } from './functions/gte.mjs';
+import { __require as requireLte } from './functions/lte.mjs';
+import { __require as requireCmp } from './functions/cmp.mjs';
+import { __require as requireCoerce } from './functions/coerce.mjs';
+import { __require as requireComparator } from './classes/comparator.mjs';
+import { __require as requireRange } from './classes/range.mjs';
+import { __require as requireSatisfies } from './functions/satisfies.mjs';
+import { __require as requireToComparators } from './ranges/to-comparators.mjs';
+import { __require as requireMaxSatisfying } from './ranges/max-satisfying.mjs';
+import { __require as requireMinSatisfying } from './ranges/min-satisfying.mjs';
+import { __require as requireMinVersion } from './ranges/min-version.mjs';
+import { __require as requireValid$1 } from './ranges/valid.mjs';
+import { __require as requireOutside } from './ranges/outside.mjs';
+import { __require as requireGtr } from './ranges/gtr.mjs';
+import { __require as requireLtr } from './ranges/ltr.mjs';
+import { __require as requireIntersects } from './ranges/intersects.mjs';
+import { __require as requireSimplify } from './ranges/simplify.mjs';
+import { __require as requireSubset } from './ranges/subset.mjs';
+
+var semver;
+var hasRequiredSemver;
+
+function requireSemver () {
+	if (hasRequiredSemver) return semver;
+	hasRequiredSemver = 1;
+
+	// just pre-load all the stuff that index.js lazily exports
+	const internalRe = requireRe();
+	const constants = requireConstants();
+	const SemVer = requireSemver$1();
+	const identifiers = requireIdentifiers();
+	const parse = requireParse();
+	const valid = requireValid();
+	const clean = requireClean();
+	const inc = requireInc();
+	const diff = requireDiff();
+	const major = requireMajor();
+	const minor = requireMinor();
+	const patch = requirePatch();
+	const prerelease = requirePrerelease();
+	const compare = requireCompare();
+	const rcompare = requireRcompare();
+	const compareLoose = requireCompareLoose();
+	const compareBuild = requireCompareBuild();
+	const sort = requireSort();
+	const rsort = requireRsort();
+	const gt = requireGt();
+	const lt = requireLt();
+	const eq = requireEq();
+	const neq = requireNeq();
+	const gte = requireGte();
+	const lte = requireLte();
+	const cmp = requireCmp();
+	const coerce = requireCoerce();
+	const Comparator = requireComparator();
+	const Range = requireRange();
+	const satisfies = requireSatisfies();
+	const toComparators = requireToComparators();
+	const maxSatisfying = requireMaxSatisfying();
+	const minSatisfying = requireMinSatisfying();
+	const minVersion = requireMinVersion();
+	const validRange = requireValid$1();
+	const outside = requireOutside();
+	const gtr = requireGtr();
+	const ltr = requireLtr();
+	const intersects = requireIntersects();
+	const simplifyRange = requireSimplify();
+	const subset = requireSubset();
+	semver = {
+	  parse,
+	  valid,
+	  clean,
+	  inc,
+	  diff,
+	  major,
+	  minor,
+	  patch,
+	  prerelease,
+	  compare,
+	  rcompare,
+	  compareLoose,
+	  compareBuild,
+	  sort,
+	  rsort,
+	  gt,
+	  lt,
+	  eq,
+	  neq,
+	  gte,
+	  lte,
+	  cmp,
+	  coerce,
+	  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,
+	};
+	return semver;
+}
+
+export { requireSemver as __require };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	// 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 = 256;
+	const MAX_SAFE_INTEGER = 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 - 6;
+
+	const RELEASE_TYPES = [
+	  'major',
+	  'premajor',
+	  'minor',
+	  'preminor',
+	  'patch',
+	  'prepatch',
+	  'prerelease',
+	];
+
+	constants = {
+	  MAX_LENGTH,
+	  MAX_SAFE_COMPONENT_LENGTH,
+	  MAX_SAFE_BUILD_LENGTH,
+	  MAX_SAFE_INTEGER,
+	  RELEASE_TYPES,
+	  SEMVER_SPEC_VERSION,
+	  FLAG_INCLUDE_PRERELEASE: 0b001,
+	  FLAG_LOOSE: 0b010,
+	};
+	return constants;
+}
+
+exports.__require = requireConstants;

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.mjs

@@ -0,0 +1,46 @@
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	// 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 = 256;
+	const MAX_SAFE_INTEGER = 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 - 6;
+
+	const RELEASE_TYPES = [
+	  'major',
+	  'premajor',
+	  'minor',
+	  'preminor',
+	  'patch',
+	  'prepatch',
+	  'prerelease',
+	];
+
+	constants = {
+	  MAX_LENGTH,
+	  MAX_SAFE_COMPONENT_LENGTH,
+	  MAX_SAFE_BUILD_LENGTH,
+	  MAX_SAFE_INTEGER,
+	  RELEASE_TYPES,
+	  SEMVER_SPEC_VERSION,
+	  FLAG_INCLUDE_PRERELEASE: 0b001,
+	  FLAG_LOOSE: 0b010,
+	};
+	return constants;
+}
+
+export { requireConstants as __require };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var debug_1;
+var hasRequiredDebug;
+
+function requireDebug () {
+	if (hasRequiredDebug) return debug_1;
+	hasRequiredDebug = 1;
+
+	const debug = (
+	  typeof process === 'object' &&
+	  process.env &&
+	  process.env.NODE_DEBUG &&
+	  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+	) ? (...args) => console.error('SEMVER', ...args)
+	  : () => {};
+
+	debug_1 = debug;
+	return debug_1;
+}
+
+exports.__require = requireDebug;

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.mjs

@@ -0,0 +1,20 @@
+var debug_1;
+var hasRequiredDebug;
+
+function requireDebug () {
+	if (hasRequiredDebug) return debug_1;
+	hasRequiredDebug = 1;
+
+	const debug = (
+	  typeof process === 'object' &&
+	  process.env &&
+	  process.env.NODE_DEBUG &&
+	  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+	) ? (...args) => console.error('SEMVER', ...args)
+	  : () => {};
+
+	debug_1 = debug;
+	return debug_1;
+}
+
+export { requireDebug as __require };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var identifiers;
+var hasRequiredIdentifiers;
+
+function requireIdentifiers () {
+	if (hasRequiredIdentifiers) return identifiers;
+	hasRequiredIdentifiers = 1;
+
+	const numeric = /^[0-9]+$/;
+	const compareIdentifiers = (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(b, a);
+
+	identifiers = {
+	  compareIdentifiers,
+	  rcompareIdentifiers,
+	};
+	return identifiers;
+}
+
+exports.__require = requireIdentifiers;

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.mjs

@@ -0,0 +1,38 @@
+var identifiers;
+var hasRequiredIdentifiers;
+
+function requireIdentifiers () {
+	if (hasRequiredIdentifiers) return identifiers;
+	hasRequiredIdentifiers = 1;
+
+	const numeric = /^[0-9]+$/;
+	const compareIdentifiers = (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(b, a);
+
+	identifiers = {
+	  compareIdentifiers,
+	  rcompareIdentifiers,
+	};
+	return identifiers;
+}
+
+export { requireIdentifiers as __require };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js

@@ -0,0 +1,53 @@
+'use strict';
+
+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;
+}
+
+exports.__require = requireLrucache;

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.mjs

@@ -0,0 +1,51 @@
+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;
+}
+
+export { requireLrucache as __require };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var parseOptions_1;
+var hasRequiredParseOptions;
+
+function requireParseOptions () {
+	if (hasRequiredParseOptions) return parseOptions_1;
+	hasRequiredParseOptions = 1;
+
+	// parse out just the options we care about
+	const looseOption = Object.freeze({ loose: true });
+	const emptyOpts = Object.freeze({ });
+	const parseOptions = options => {
+	  if (!options) {
+	    return emptyOpts
+	  }
+
+	  if (typeof options !== 'object') {
+	    return looseOption
+	  }
+
+	  return options
+	};
+	parseOptions_1 = parseOptions;
+	return parseOptions_1;
+}
+
+exports.__require = requireParseOptions;

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.mjs

@@ -0,0 +1,26 @@
+var parseOptions_1;
+var hasRequiredParseOptions;
+
+function requireParseOptions () {
+	if (hasRequiredParseOptions) return parseOptions_1;
+	hasRequiredParseOptions = 1;
+
+	// parse out just the options we care about
+	const looseOption = Object.freeze({ loose: true });
+	const emptyOpts = Object.freeze({ });
+	const parseOptions = options => {
+	  if (!options) {
+	    return emptyOpts
+	  }
+
+	  if (typeof options !== 'object') {
+	    return looseOption
+	  }
+
+	  return options
+	};
+	parseOptions_1 = parseOptions;
+	return parseOptions_1;
+}
+
+export { requireParseOptions as __require };