@grafana/plugin-e2e 3.9.2 → 3.11.0

package/dist/node_modules/semver/functions/gt.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compare = require('./compare.js');
+
+var gt_1;
+var hasRequiredGt;
+
+function requireGt () {
+	if (hasRequiredGt) return gt_1;
+	hasRequiredGt = 1;
+
+	const compare$1 = compare.__require();
+	const gt = (a, b, loose) => compare$1(a, b, loose) > 0;
+	gt_1 = gt;
+	return gt_1;
+}
+
+exports.__require = requireGt;

package/dist/node_modules/semver/functions/gte.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compare = require('./compare.js');
+
+var gte_1;
+var hasRequiredGte;
+
+function requireGte () {
+	if (hasRequiredGte) return gte_1;
+	hasRequiredGte = 1;
+
+	const compare$1 = compare.__require();
+	const gte = (a, b, loose) => compare$1(a, b, loose) >= 0;
+	gte_1 = gte;
+	return gte_1;
+}
+
+exports.__require = requireGte;

package/dist/node_modules/semver/functions/inc.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var semver = require('../classes/semver.js');
+
+var inc_1;
+var hasRequiredInc;
+
+function requireInc () {
+	if (hasRequiredInc) return inc_1;
+	hasRequiredInc = 1;
+
+	const SemVer = semver.__require();
+
+	const inc = (version, release, options, identifier, identifierBase) => {
+	  if (typeof (options) === 'string') {
+	    identifierBase = identifier;
+	    identifier = options;
+	    options = undefined;
+	  }
+
+	  try {
+	    return new SemVer(
+	      version instanceof SemVer ? version.version : version,
+	      options
+	    ).inc(release, identifier, identifierBase).version
+	  } catch (er) {
+	    return null
+	  }
+	};
+	inc_1 = inc;
+	return inc_1;
+}
+
+exports.__require = requireInc;

package/dist/node_modules/semver/functions/lt.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compare = require('./compare.js');
+
+var lt_1;
+var hasRequiredLt;
+
+function requireLt () {
+	if (hasRequiredLt) return lt_1;
+	hasRequiredLt = 1;
+
+	const compare$1 = compare.__require();
+	const lt = (a, b, loose) => compare$1(a, b, loose) < 0;
+	lt_1 = lt;
+	return lt_1;
+}
+
+exports.__require = requireLt;

package/dist/node_modules/semver/functions/lte.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compare = require('./compare.js');
+
+var lte_1;
+var hasRequiredLte;
+
+function requireLte () {
+	if (hasRequiredLte) return lte_1;
+	hasRequiredLte = 1;
+
+	const compare$1 = compare.__require();
+	const lte = (a, b, loose) => compare$1(a, b, loose) <= 0;
+	lte_1 = lte;
+	return lte_1;
+}
+
+exports.__require = requireLte;

package/dist/node_modules/semver/functions/major.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var semver = require('../classes/semver.js');
+
+var major_1;
+var hasRequiredMajor;
+
+function requireMajor () {
+	if (hasRequiredMajor) return major_1;
+	hasRequiredMajor = 1;
+
+	const SemVer = semver.__require();
+	const major = (a, loose) => new SemVer(a, loose).major;
+	major_1 = major;
+	return major_1;
+}
+
+exports.__require = requireMajor;

package/dist/node_modules/semver/functions/minor.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var semver = require('../classes/semver.js');
+
+var minor_1;
+var hasRequiredMinor;
+
+function requireMinor () {
+	if (hasRequiredMinor) return minor_1;
+	hasRequiredMinor = 1;
+
+	const SemVer = semver.__require();
+	const minor = (a, loose) => new SemVer(a, loose).minor;
+	minor_1 = minor;
+	return minor_1;
+}
+
+exports.__require = requireMinor;

package/dist/node_modules/semver/functions/neq.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compare = require('./compare.js');
+
+var neq_1;
+var hasRequiredNeq;
+
+function requireNeq () {
+	if (hasRequiredNeq) return neq_1;
+	hasRequiredNeq = 1;
+
+	const compare$1 = compare.__require();
+	const neq = (a, b, loose) => compare$1(a, b, loose) !== 0;
+	neq_1 = neq;
+	return neq_1;
+}
+
+exports.__require = requireNeq;

package/dist/node_modules/semver/functions/parse.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var semver = require('../classes/semver.js');
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+
+	const SemVer = semver.__require();
+	const parse = (version, options, throwErrors = false) => {
+	  if (version instanceof SemVer) {
+	    return version
+	  }
+	  try {
+	    return new SemVer(version, options)
+	  } catch (er) {
+	    if (!throwErrors) {
+	      return null
+	    }
+	    throw er
+	  }
+	};
+
+	parse_1 = parse;
+	return parse_1;
+}
+
+exports.__require = requireParse;

package/dist/node_modules/semver/functions/patch.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var semver = require('../classes/semver.js');
+
+var patch_1;
+var hasRequiredPatch;
+
+function requirePatch () {
+	if (hasRequiredPatch) return patch_1;
+	hasRequiredPatch = 1;
+
+	const SemVer = semver.__require();
+	const patch = (a, loose) => new SemVer(a, loose).patch;
+	patch_1 = patch;
+	return patch_1;
+}
+
+exports.__require = requirePatch;

package/dist/node_modules/semver/functions/prerelease.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var parse = require('./parse.js');
+
+var prerelease_1;
+var hasRequiredPrerelease;
+
+function requirePrerelease () {
+	if (hasRequiredPrerelease) return prerelease_1;
+	hasRequiredPrerelease = 1;
+
+	const parse$1 = parse.__require();
+	const prerelease = (version, options) => {
+	  const parsed = parse$1(version, options);
+	  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+	};
+	prerelease_1 = prerelease;
+	return prerelease_1;
+}
+
+exports.__require = requirePrerelease;

package/dist/node_modules/semver/functions/rcompare.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compare = require('./compare.js');
+
+var rcompare_1;
+var hasRequiredRcompare;
+
+function requireRcompare () {
+	if (hasRequiredRcompare) return rcompare_1;
+	hasRequiredRcompare = 1;
+
+	const compare$1 = compare.__require();
+	const rcompare = (a, b, loose) => compare$1(b, a, loose);
+	rcompare_1 = rcompare;
+	return rcompare_1;
+}
+
+exports.__require = requireRcompare;

package/dist/node_modules/semver/functions/rsort.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compareBuild = require('./compare-build.js');
+
+var rsort_1;
+var hasRequiredRsort;
+
+function requireRsort () {
+	if (hasRequiredRsort) return rsort_1;
+	hasRequiredRsort = 1;
+
+	const compareBuild$1 = compareBuild.__require();
+	const rsort = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose));
+	rsort_1 = rsort;
+	return rsort_1;
+}
+
+exports.__require = requireRsort;

package/dist/node_modules/semver/functions/satisfies.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var range = require('../classes/range.js');
+
+var satisfies_1;
+var hasRequiredSatisfies;
+
+function requireSatisfies () {
+	if (hasRequiredSatisfies) return satisfies_1;
+	hasRequiredSatisfies = 1;
+
+	const Range = range.__require();
+	const satisfies = (version, range, options) => {
+	  try {
+	    range = new Range(range, options);
+	  } catch (er) {
+	    return false
+	  }
+	  return range.test(version)
+	};
+	satisfies_1 = satisfies;
+	return satisfies_1;
+}
+
+exports.__require = requireSatisfies;

package/dist/node_modules/semver/functions/sort.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var compareBuild = require('./compare-build.js');
+
+var sort_1;
+var hasRequiredSort;
+
+function requireSort () {
+	if (hasRequiredSort) return sort_1;
+	hasRequiredSort = 1;
+
+	const compareBuild$1 = compareBuild.__require();
+	const sort = (list, loose) => list.sort((a, b) => compareBuild$1(a, b, loose));
+	sort_1 = sort;
+	return sort_1;
+}
+
+exports.__require = requireSort;

package/dist/node_modules/semver/functions/truncate.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var parse = require('./parse.js');
+var constants = require('../internal/constants.js');
+var semver = require('../classes/semver.js');
+
+var truncate_1;
+var hasRequiredTruncate;
+
+function requireTruncate () {
+	if (hasRequiredTruncate) return truncate_1;
+	hasRequiredTruncate = 1;
+
+	const parse$1 = parse.__require();
+	const constants$1 = constants.__require();
+	const SemVer = semver.__require();
+
+	const truncate = (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 ? 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')
+	};
+
+	truncate_1 = truncate;
+	return truncate_1;
+}
+
+exports.__require = requireTruncate;

package/dist/node_modules/semver/functions/valid.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var parse = require('./parse.js');
+
+var valid_1;
+var hasRequiredValid;
+
+function requireValid () {
+	if (hasRequiredValid) return valid_1;
+	hasRequiredValid = 1;
+
+	const parse$1 = parse.__require();
+	const valid = (version, options) => {
+	  const v = parse$1(version, options);
+	  return v ? v.version : null
+	};
+	valid_1 = valid;
+	return valid_1;
+}
+
+exports.__require = requireValid;

package/dist/node_modules/semver/index.js

@@ -0,0 +1,147 @@
+'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 truncate = require('./functions/truncate.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 truncate$1 = truncate.__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,
+	  truncate: truncate$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/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/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/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;