langgraph-ui-components 0.0.1 → 0.0.2

package/dist/index.es220.js

@@ -0,0 +1,140 @@
+import { __require as requireRe } from "./index.es221.js";
+import { __require as requireConstants } from "./index.es222.js";
+import { __require as requireSemver$1 } from "./index.es223.js";
+import { __require as requireIdentifiers } from "./index.es224.js";
+import { __require as requireParse } from "./index.es225.js";
+import { __require as requireValid } from "./index.es226.js";
+import { __require as requireClean } from "./index.es227.js";
+import { __require as requireInc } from "./index.es228.js";
+import { __require as requireDiff } from "./index.es229.js";
+import { __require as requireMajor } from "./index.es230.js";
+import { __require as requireMinor } from "./index.es231.js";
+import { __require as requirePatch } from "./index.es232.js";
+import { __require as requirePrerelease } from "./index.es233.js";
+import { __require as requireCompare } from "./index.es234.js";
+import { __require as requireRcompare } from "./index.es235.js";
+import { __require as requireCompareLoose } from "./index.es236.js";
+import { __require as requireCompareBuild } from "./index.es237.js";
+import { __require as requireSort } from "./index.es238.js";
+import { __require as requireRsort } from "./index.es239.js";
+import { __require as requireGt } from "./index.es240.js";
+import { __require as requireLt } from "./index.es241.js";
+import { __require as requireEq } from "./index.es242.js";
+import { __require as requireNeq } from "./index.es243.js";
+import { __require as requireGte } from "./index.es244.js";
+import { __require as requireLte } from "./index.es245.js";
+import { __require as requireCmp } from "./index.es246.js";
+import { __require as requireCoerce } from "./index.es247.js";
+import { __require as requireComparator } from "./index.es248.js";
+import { __require as requireRange } from "./index.es249.js";
+import { __require as requireSatisfies } from "./index.es250.js";
+import { __require as requireToComparators } from "./index.es251.js";
+import { __require as requireMaxSatisfying } from "./index.es252.js";
+import { __require as requireMinSatisfying } from "./index.es253.js";
+import { __require as requireMinVersion } from "./index.es254.js";
+import { __require as requireValid$1 } from "./index.es255.js";
+import { __require as requireOutside } from "./index.es256.js";
+import { __require as requireGtr } from "./index.es257.js";
+import { __require as requireLtr } from "./index.es258.js";
+import { __require as requireIntersects } from "./index.es259.js";
+import { __require as requireSimplify } from "./index.es260.js";
+import { __require as requireSubset } from "./index.es261.js";
+var semver;
+var hasRequiredSemver;
+function requireSemver() {
+  if (hasRequiredSemver) return semver;
+  hasRequiredSemver = 1;
+  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
+};
+//# sourceMappingURL=index.es220.js.map

package/dist/index.es220.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es220.js","sources":["../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js"],"sourcesContent":["'use strict'\n\n// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nconst constants = require('./internal/constants')\nconst SemVer = require('./classes/semver')\nconst identifiers = require('./internal/identifiers')\nconst parse = require('./functions/parse')\nconst valid = require('./functions/valid')\nconst clean = require('./functions/clean')\nconst inc = require('./functions/inc')\nconst diff = require('./functions/diff')\nconst major = require('./functions/major')\nconst minor = require('./functions/minor')\nconst patch = require('./functions/patch')\nconst prerelease = require('./functions/prerelease')\nconst compare = require('./functions/compare')\nconst rcompare = require('./functions/rcompare')\nconst compareLoose = require('./functions/compare-loose')\nconst compareBuild = require('./functions/compare-build')\nconst sort = require('./functions/sort')\nconst rsort = require('./functions/rsort')\nconst gt = require('./functions/gt')\nconst lt = require('./functions/lt')\nconst eq = require('./functions/eq')\nconst neq = require('./functions/neq')\nconst gte = require('./functions/gte')\nconst lte = require('./functions/lte')\nconst cmp = require('./functions/cmp')\nconst coerce = require('./functions/coerce')\nconst Comparator = require('./classes/comparator')\nconst Range = require('./classes/range')\nconst satisfies = require('./functions/satisfies')\nconst toComparators = require('./ranges/to-comparators')\nconst maxSatisfying = require('./ranges/max-satisfying')\nconst minSatisfying = require('./ranges/min-satisfying')\nconst minVersion = require('./ranges/min-version')\nconst validRange = require('./ranges/valid')\nconst outside = require('./ranges/outside')\nconst gtr = require('./ranges/gtr')\nconst ltr = require('./ranges/ltr')\nconst intersects = require('./ranges/intersects')\nconst simplifyRange = require('./ranges/simplify')\nconst subset = require('./ranges/subset')\nmodule.exports = {\n  parse,\n  valid,\n  clean,\n  inc,\n  diff,\n  major,\n  minor,\n  patch,\n  prerelease,\n  compare,\n  rcompare,\n  compareLoose,\n  compareBuild,\n  sort,\n  rsort,\n  gt,\n  lt,\n  eq,\n  neq,\n  gte,\n  lte,\n  cmp,\n  coerce,\n  Comparator,\n  Range,\n  satisfies,\n  toComparators,\n  maxSatisfying,\n  minSatisfying,\n  minVersion,\n  validRange,\n  outside,\n  gtr,\n  ltr,\n  intersects,\n  simplifyRange,\n  subset,\n  SemVer,\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n  RELEASE_TYPES: constants.RELEASE_TYPES,\n  compareIdentifiers: identifiers.compareIdentifiers,\n  rcompareIdentifiers: identifiers.rcompareIdentifiers,\n}\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","require$$15","require$$16","require$$17","require$$18","require$$19","require$$20","require$$21","require$$22","require$$23","require$$24","require$$25","require$$26","require$$27","require$$28","require$$29","require$$30","require$$31","require$$32","require$$33","require$$34","require$$35","require$$36","require$$37","require$$38","require$$39","require$$40"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,QAAM,aAAaA,UAAA;AACnB,QAAM,YAAYC,iBAAA;AAClB,QAAM,SAASC,gBAAA;AACf,QAAM,cAAcC,mBAAA;AACpB,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,MAAMC,WAAA;AACZ,QAAM,OAAOC,YAAA;AACb,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,aAAaC,kBAAA;AACnB,QAAM,UAAUC,eAAA;AAChB,QAAM,WAAWC,gBAAA;AACjB,QAAM,eAAeC,oBAAA;AACrB,QAAM,eAAeC,oBAAA;AACrB,QAAM,OAAOC,YAAA;AACb,QAAM,QAAQC,aAAA;AACd,QAAM,KAAKC,UAAA;AACX,QAAM,KAAKC,UAAA;AACX,QAAM,KAAKC,UAAA;AACX,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,SAASC,cAAA;AACf,QAAM,aAAaC,kBAAA;AACnB,QAAM,QAAQC,aAAA;AACd,QAAM,YAAYC,iBAAA;AAClB,QAAM,gBAAgBC,qBAAA;AACtB,QAAM,gBAAgBC,qBAAA;AACtB,QAAM,gBAAgBC,qBAAA;AACtB,QAAM,aAAaC,kBAAA;AACnB,QAAM,aAAaC,eAAA;AACnB,QAAM,UAAUC,eAAA;AAChB,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,aAAaC,kBAAA;AACnB,QAAM,gBAAgBC,gBAAA;AACtB,QAAM,SAASC,cAAA;AACf,WAAiB;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,IAAI,WAAW;AAAA,IACf,KAAK,WAAW;AAAA,IAChB,QAAQ,WAAW;AAAA,IACnB,qBAAqB,UAAU;AAAA,IAC/B,eAAe,UAAU;AAAA,IACzB,oBAAoB,YAAY;AAAA,IAChC,qBAAqB,YAAY;AAAA,EACnC;;;","x_google_ignoreList":[0]}

package/dist/index.es221.js

@@ -0,0 +1,96 @@
+import { __module as re } from "./index.es262.js";
+import { __require as requireConstants } from "./index.es222.js";
+import { __require as requireDebug } from "./index.es263.js";
+var hasRequiredRe;
+function requireRe() {
+  if (hasRequiredRe) return re.exports;
+  hasRequiredRe = 1;
+  (function(module, exports$1) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = requireConstants();
+    const debug = requireDebug();
+    exports$1 = module.exports = {};
+    const re2 = exports$1.re = [];
+    const safeRe = exports$1.safeRe = [];
+    const src = exports$1.src = [];
+    const safeSrc = exports$1.safeSrc = [];
+    const t = exports$1.t = {};
+    let R = 0;
+    const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    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;
+      re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    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]}$`);
+    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);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports$1.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports$1.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports$1.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  })(re, re.exports);
+  return re.exports;
+}
+export {
+  requireRe as __require
+};
+//# sourceMappingURL=index.es221.js.map

package/dist/index.es221.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es221.js","sources":["../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js"],"sourcesContent":["'use strict'\n\nconst {\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_LENGTH,\n} = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst safeRe = exports.safeRe = []\nconst src = exports.src = []\nconst safeSrc = exports.safeSrc = []\nconst t = exports.t = {}\nlet R = 0\n\nconst LETTERDASHNUMBER = '[a-zA-Z0-9-]'\n\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nconst safeRegexReplacements = [\n  ['\\\\s', 1],\n  ['\\\\d', MAX_LENGTH],\n  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],\n]\n\nconst makeSafeRegex = (value) => {\n  for (const [token, max] of safeRegexReplacements) {\n    value = value\n      .split(`${token}*`).join(`${token}{0,${max}}`)\n      .split(`${token}+`).join(`${token}{1,${max}}`)\n  }\n  return value\n}\n\nconst createToken = (name, value, isGlobal) => {\n  const safe = makeSafeRegex(value)\n  const index = R++\n  debug(name, index, value)\n  t[name] = index\n  src[index] = value\n  safeSrc[index] = safe\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '\\\\d+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', `\\\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n// Non-numberic identifiers include numberic identifiers but can be longer.\n// Therefore non-numberic identifiers must go first.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]\n}|${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]\n}|${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCEPLAIN', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)\ncreateToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\\\d])`)\ncreateToken('COERCEFULL', src[t.COERCEPLAIN] +\n              `(?:${src[t.PRERELEASE]})?` +\n              `(?:${src[t.BUILD]})?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\ncreateToken('COERCERTLFULL', src[t.COERCEFULL], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$')\n"],"names":["require$$0","require$$1","exports","re"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es222.js

@@ -0,0 +1,36 @@
+var constants;
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+  const SEMVER_SPEC_VERSION = "2.0.0";
+  const MAX_LENGTH = 256;
+  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991;
+  const MAX_SAFE_COMPONENT_LENGTH = 16;
+  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: 1,
+    FLAG_LOOSE: 2
+  };
+  return constants;
+}
+export {
+  requireConstants as __require
+};
+//# sourceMappingURL=index.es222.js.map

package/dist/index.es222.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es222.js","sources":["../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js"],"sourcesContent":["'use strict'\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst SEMVER_SPEC_VERSION = '2.0.0'\n\nconst MAX_LENGTH = 256\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nconst MAX_SAFE_COMPONENT_LENGTH = 16\n\n// Max safe length for a build identifier. The max length minus 6 characters for\n// the shortest version with a build 0.0.0+BUILD.\nconst MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6\n\nconst RELEASE_TYPES = [\n  'major',\n  'premajor',\n  'minor',\n  'preminor',\n  'patch',\n  'prepatch',\n  'prerelease',\n]\n\nmodule.exports = {\n  MAX_LENGTH,\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_SAFE_INTEGER,\n  RELEASE_TYPES,\n  SEMVER_SPEC_VERSION,\n  FLAG_INCLUDE_PRERELEASE: 0b001,\n  FLAG_LOOSE: 0b010,\n}\n"],"names":[],"mappings":";;;;;AAIA,QAAM,sBAAsB;AAE5B,QAAM,aAAa;AACnB,QAAM,mBAAmB,OAAO;AAAA,EACL;AAG3B,QAAM,4BAA4B;AAIlC,QAAM,wBAAwB,aAAa;AAE3C,QAAM,gBAAgB;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,cAAiB;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,yBAAyB;AAAA,IACzB,YAAY;AAAA,EACd;;;","x_google_ignoreList":[0]}

package/dist/index.es223.js

@@ -0,0 +1,288 @@
+import { __require as requireDebug } from "./index.es263.js";
+import { __require as requireConstants } from "./index.es222.js";
+import { __require as requireRe } from "./index.es221.js";
+import { __require as requireParseOptions } from "./index.es264.js";
+import { __require as requireIdentifiers } from "./index.es224.js";
+var semver;
+var hasRequiredSemver;
+function requireSemver() {
+  if (hasRequiredSemver) return semver;
+  hasRequiredSemver = 1;
+  const debug = requireDebug();
+  const { MAX_LENGTH, MAX_SAFE_INTEGER } = requireConstants();
+  const { safeRe: re, t } = requireRe();
+  const parseOptions = requireParseOptions();
+  const { compareIdentifiers } = requireIdentifiers();
+  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.includePrerelease = !!options.includePrerelease;
+      const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+      if (!m) {
+        throw new TypeError(`Invalid Version: ${version}`);
+      }
+      this.raw = version;
+      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");
+      }
+      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);
+      }
+      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 === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          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 === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          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");
+        }
+        if (identifier) {
+          const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.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":
+          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.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "minor":
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "patch":
+          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) {
+              if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                throw new Error("invalid increment argument: identifier already exists");
+              }
+              this.prerelease.push(base);
+            }
+          }
+          if (identifier) {
+            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;
+    }
+  }
+  semver = SemVer;
+  return semver;
+}
+export {
+  requireSemver as __require
+};
+//# sourceMappingURL=index.es223.js.map

package/dist/index.es223.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es223.js","sources":["../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js"],"sourcesContent":["'use strict'\n\nconst debug = require('../internal/debug')\nconst { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst parseOptions = require('../internal/parse-options')\nconst { compareIdentifiers } = require('../internal/identifiers')\nclass SemVer {\n  constructor (version, options) {\n    options = parseOptions(options)\n\n    if (version instanceof SemVer) {\n      if (version.loose === !!options.loose &&\n        version.includePrerelease === !!options.includePrerelease) {\n        return version\n      } else {\n        version = version.version\n      }\n    } else if (typeof version !== 'string') {\n      throw new TypeError(`Invalid version. Must be a string. Got type \"${typeof version}\".`)\n    }\n\n    if (version.length > MAX_LENGTH) {\n      throw new TypeError(\n        `version is longer than ${MAX_LENGTH} characters`\n      )\n    }\n\n    debug('SemVer', version, options)\n    this.options = options\n    this.loose = !!options.loose\n    // this isn't actually relevant for versions, but keep it so that we\n    // don't run into trouble passing this.options around.\n    this.includePrerelease = !!options.includePrerelease\n\n    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n    if (!m) {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    this.raw = version\n\n    // these are actually numbers\n    this.major = +m[1]\n    this.minor = +m[2]\n    this.patch = +m[3]\n\n    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n      throw new TypeError('Invalid major version')\n    }\n\n    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n      throw new TypeError('Invalid minor version')\n    }\n\n    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n      throw new TypeError('Invalid patch version')\n    }\n\n    // numberify any prerelease numeric ids\n    if (!m[4]) {\n      this.prerelease = []\n    } else {\n      this.prerelease = m[4].split('.').map((id) => {\n        if (/^[0-9]+$/.test(id)) {\n          const num = +id\n          if (num >= 0 && num < MAX_SAFE_INTEGER) {\n            return num\n          }\n        }\n        return id\n      })\n    }\n\n    this.build = m[5] ? m[5].split('.') : []\n    this.format()\n  }\n\n  format () {\n    this.version = `${this.major}.${this.minor}.${this.patch}`\n    if (this.prerelease.length) {\n      this.version += `-${this.prerelease.join('.')}`\n    }\n    return this.version\n  }\n\n  toString () {\n    return this.version\n  }\n\n  compare (other) {\n    debug('SemVer.compare', this.version, this.options, other)\n    if (!(other instanceof SemVer)) {\n      if (typeof other === 'string' && other === this.version) {\n        return 0\n      }\n      other = new SemVer(other, this.options)\n    }\n\n    if (other.version === this.version) {\n      return 0\n    }\n\n    return this.compareMain(other) || this.comparePre(other)\n  }\n\n  compareMain (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    if (this.major < other.major) {\n      return -1\n    }\n    if (this.major > other.major) {\n      return 1\n    }\n    if (this.minor < other.minor) {\n      return -1\n    }\n    if (this.minor > other.minor) {\n      return 1\n    }\n    if (this.patch < other.patch) {\n      return -1\n    }\n    if (this.patch > other.patch) {\n      return 1\n    }\n    return 0\n  }\n\n  comparePre (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    // NOT having a prerelease is > having one\n    if (this.prerelease.length && !other.prerelease.length) {\n      return -1\n    } else if (!this.prerelease.length && other.prerelease.length) {\n      return 1\n    } else if (!this.prerelease.length && !other.prerelease.length) {\n      return 0\n    }\n\n    let i = 0\n    do {\n      const a = this.prerelease[i]\n      const b = other.prerelease[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  compareBuild (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    let i = 0\n    do {\n      const a = this.build[i]\n      const b = other.build[i]\n      debug('build compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  // preminor will bump the version up to the next minor release, and immediately\n  // down to pre-release. premajor and prepatch work the same way.\n  inc (release, identifier, identifierBase) {\n    if (release.startsWith('pre')) {\n      if (!identifier && identifierBase === false) {\n        throw new Error('invalid increment argument: identifier is empty')\n      }\n      // Avoid an invalid semver results\n      if (identifier) {\n        const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE])\n        if (!match || match[1] !== identifier) {\n          throw new Error(`invalid identifier: ${identifier}`)\n        }\n      }\n    }\n\n    switch (release) {\n      case 'premajor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor = 0\n        this.major++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'preminor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'prepatch':\n        // If this is already a prerelease, it will bump to the next version\n        // drop any prereleases that might already exist, since they are not\n        // relevant at this point.\n        this.prerelease.length = 0\n        this.inc('patch', identifier, identifierBase)\n        this.inc('pre', identifier, identifierBase)\n        break\n      // If the input is a non-prerelease version, this acts the same as\n      // prepatch.\n      case 'prerelease':\n        if (this.prerelease.length === 0) {\n          this.inc('patch', identifier, identifierBase)\n        }\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'release':\n        if (this.prerelease.length === 0) {\n          throw new Error(`version ${this.raw} is not a prerelease`)\n        }\n        this.prerelease.length = 0\n        break\n\n      case 'major':\n        // If this is a pre-major version, bump up to the same major version.\n        // Otherwise increment major.\n        // 1.0.0-5 bumps to 1.0.0\n        // 1.1.0 bumps to 2.0.0\n        if (\n          this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0\n        ) {\n          this.major++\n        }\n        this.minor = 0\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'minor':\n        // If this is a pre-minor version, bump up to the same minor version.\n        // Otherwise increment minor.\n        // 1.2.0-5 bumps to 1.2.0\n        // 1.2.1 bumps to 1.3.0\n        if (this.patch !== 0 || this.prerelease.length === 0) {\n          this.minor++\n        }\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'patch':\n        // If this is not a pre-release version, it will increment the patch.\n        // If it is a pre-release it will bump up to the same patch version.\n        // 1.2.0-5 patches to 1.2.0\n        // 1.2.0 patches to 1.2.1\n        if (this.prerelease.length === 0) {\n          this.patch++\n        }\n        this.prerelease = []\n        break\n      // This probably shouldn't be used publicly.\n      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n      case 'pre': {\n        const base = Number(identifierBase) ? 1 : 0\n\n        if (this.prerelease.length === 0) {\n          this.prerelease = [base]\n        } else {\n          let i = this.prerelease.length\n          while (--i >= 0) {\n            if (typeof this.prerelease[i] === 'number') {\n              this.prerelease[i]++\n              i = -2\n            }\n          }\n          if (i === -1) {\n            // didn't increment anything\n            if (identifier === this.prerelease.join('.') && identifierBase === false) {\n              throw new Error('invalid increment argument: identifier already exists')\n            }\n            this.prerelease.push(base)\n          }\n        }\n        if (identifier) {\n          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n          let prerelease = [identifier, base]\n          if (identifierBase === false) {\n            prerelease = [identifier]\n          }\n          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {\n            if (isNaN(this.prerelease[1])) {\n              this.prerelease = prerelease\n            }\n          } else {\n            this.prerelease = prerelease\n          }\n        }\n        break\n      }\n      default:\n        throw new Error(`invalid increment argument: ${release}`)\n    }\n    this.raw = this.format()\n    if (this.build.length) {\n      this.raw += `+${this.build.join('.')}`\n    }\n    return this\n  }\n}\n\nmodule.exports = SemVer\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4"],"mappings":";;;;;;;;;;AAEA,QAAM,QAAQA,aAAA;AACd,QAAM,EAAE,YAAY,iBAAgB,IAAKC,iBAAA;AACzC,QAAM,EAAE,QAAQ,IAAI,EAAC,IAAKC,UAAA;AAE1B,QAAM,eAAeC,oBAAA;AACrB,QAAM,EAAE,mBAAkB,IAAKC,mBAAA;AAAA,EAC/B,MAAM,OAAO;AAAA,IACX,YAAa,SAAS,SAAS;AAC7B,gBAAU,aAAa,OAAO;AAE9B,UAAI,mBAAmB,QAAQ;AAC7B,YAAI,QAAQ,UAAU,CAAC,CAAC,QAAQ,SAC9B,QAAQ,sBAAsB,CAAC,CAAC,QAAQ,mBAAmB;AAC3D,iBAAO;AAAA,QACf,OAAa;AACL,oBAAU,QAAQ;AAAA,QAC1B;AAAA,MACA,WAAe,OAAO,YAAY,UAAU;AACtC,cAAM,IAAI,UAAU,gDAAgD,OAAO,OAAO,IAAI;AAAA,MAC5F;AAEI,UAAI,QAAQ,SAAS,YAAY;AAC/B,cAAM,IAAI;AAAA,UACR,0BAA0B,UAAU;AAAA,QAC5C;AAAA,MACA;AAEI,YAAM,UAAU,SAAS,OAAO;AAChC,WAAK,UAAU;AACf,WAAK,QAAQ,CAAC,CAAC,QAAQ;AAGvB,WAAK,oBAAoB,CAAC,CAAC,QAAQ;AAEnC,YAAM,IAAI,QAAQ,KAAI,EAAG,MAAM,QAAQ,QAAQ,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,IAAI,CAAC;AAEvE,UAAI,CAAC,GAAG;AACN,cAAM,IAAI,UAAU,oBAAoB,OAAO,EAAE;AAAA,MACvD;AAEI,WAAK,MAAM;AAGX,WAAK,QAAQ,CAAC,EAAE,CAAC;AACjB,WAAK,QAAQ,CAAC,EAAE,CAAC;AACjB,WAAK,QAAQ,CAAC,EAAE,CAAC;AAEjB,UAAI,KAAK,QAAQ,oBAAoB,KAAK,QAAQ,GAAG;AACnD,cAAM,IAAI,UAAU,uBAAuB;AAAA,MACjD;AAEI,UAAI,KAAK,QAAQ,oBAAoB,KAAK,QAAQ,GAAG;AACnD,cAAM,IAAI,UAAU,uBAAuB;AAAA,MACjD;AAEI,UAAI,KAAK,QAAQ,oBAAoB,KAAK,QAAQ,GAAG;AACnD,cAAM,IAAI,UAAU,uBAAuB;AAAA,MACjD;AAGI,UAAI,CAAC,EAAE,CAAC,GAAG;AACT,aAAK,aAAa,CAAA;AAAA,MACxB,OAAW;AACL,aAAK,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,IAAI,CAAC,OAAO;AAC5C,cAAI,WAAW,KAAK,EAAE,GAAG;AACvB,kBAAM,MAAM,CAAC;AACb,gBAAI,OAAO,KAAK,MAAM,kBAAkB;AACtC,qBAAO;AAAA,YACnB;AAAA,UACA;AACQ,iBAAO;AAAA,QACf,CAAO;AAAA,MACP;AAEI,WAAK,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;AACtC,WAAK,OAAM;AAAA,IACf;AAAA,IAEE,SAAU;AACR,WAAK,UAAU,GAAG,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK;AACxD,UAAI,KAAK,WAAW,QAAQ;AAC1B,aAAK,WAAW,IAAI,KAAK,WAAW,KAAK,GAAG,CAAC;AAAA,MACnD;AACI,aAAO,KAAK;AAAA,IAChB;AAAA,IAEE,WAAY;AACV,aAAO,KAAK;AAAA,IAChB;AAAA,IAEE,QAAS,OAAO;AACd,YAAM,kBAAkB,KAAK,SAAS,KAAK,SAAS,KAAK;AACzD,UAAI,EAAE,iBAAiB,SAAS;AAC9B,YAAI,OAAO,UAAU,YAAY,UAAU,KAAK,SAAS;AACvD,iBAAO;AAAA,QACf;AACM,gBAAQ,IAAI,OAAO,OAAO,KAAK,OAAO;AAAA,MAC5C;AAEI,UAAI,MAAM,YAAY,KAAK,SAAS;AAClC,eAAO;AAAA,MACb;AAEI,aAAO,KAAK,YAAY,KAAK,KAAK,KAAK,WAAW,KAAK;AAAA,IAC3D;AAAA,IAEE,YAAa,OAAO;AAClB,UAAI,EAAE,iBAAiB,SAAS;AAC9B,gBAAQ,IAAI,OAAO,OAAO,KAAK,OAAO;AAAA,MAC5C;AAEI,UAAI,KAAK,QAAQ,MAAM,OAAO;AAC5B,eAAO;AAAA,MACb;AACI,UAAI,KAAK,QAAQ,MAAM,OAAO;AAC5B,eAAO;AAAA,MACb;AACI,UAAI,KAAK,QAAQ,MAAM,OAAO;AAC5B,eAAO;AAAA,MACb;AACI,UAAI,KAAK,QAAQ,MAAM,OAAO;AAC5B,eAAO;AAAA,MACb;AACI,UAAI,KAAK,QAAQ,MAAM,OAAO;AAC5B,eAAO;AAAA,MACb;AACI,UAAI,KAAK,QAAQ,MAAM,OAAO;AAC5B,eAAO;AAAA,MACb;AACI,aAAO;AAAA,IACX;AAAA,IAEE,WAAY,OAAO;AACjB,UAAI,EAAE,iBAAiB,SAAS;AAC9B,gBAAQ,IAAI,OAAO,OAAO,KAAK,OAAO;AAAA,MAC5C;AAGI,UAAI,KAAK,WAAW,UAAU,CAAC,MAAM,WAAW,QAAQ;AACtD,eAAO;AAAA,MACb,WAAe,CAAC,KAAK,WAAW,UAAU,MAAM,WAAW,QAAQ;AAC7D,eAAO;AAAA,MACb,WAAe,CAAC,KAAK,WAAW,UAAU,CAAC,MAAM,WAAW,QAAQ;AAC9D,eAAO;AAAA,MACb;AAEI,UAAI,IAAI;AACR,SAAG;AACD,cAAM,IAAI,KAAK,WAAW,CAAC;AAC3B,cAAM,IAAI,MAAM,WAAW,CAAC;AAC5B,cAAM,sBAAsB,GAAG,GAAG,CAAC;AACnC,YAAI,MAAM,UAAa,MAAM,QAAW;AACtC,iBAAO;AAAA,QACf,WAAiB,MAAM,QAAW;AAC1B,iBAAO;AAAA,QACf,WAAiB,MAAM,QAAW;AAC1B,iBAAO;AAAA,QACf,WAAiB,MAAM,GAAG;AAClB;AAAA,QACR,OAAa;AACL,iBAAO,mBAAmB,GAAG,CAAC;AAAA,QACtC;AAAA,MACA,SAAa,EAAE;AAAA,IACf;AAAA,IAEE,aAAc,OAAO;AACnB,UAAI,EAAE,iBAAiB,SAAS;AAC9B,gBAAQ,IAAI,OAAO,OAAO,KAAK,OAAO;AAAA,MAC5C;AAEI,UAAI,IAAI;AACR,SAAG;AACD,cAAM,IAAI,KAAK,MAAM,CAAC;AACtB,cAAM,IAAI,MAAM,MAAM,CAAC;AACvB,cAAM,iBAAiB,GAAG,GAAG,CAAC;AAC9B,YAAI,MAAM,UAAa,MAAM,QAAW;AACtC,iBAAO;AAAA,QACf,WAAiB,MAAM,QAAW;AAC1B,iBAAO;AAAA,QACf,WAAiB,MAAM,QAAW;AAC1B,iBAAO;AAAA,QACf,WAAiB,MAAM,GAAG;AAClB;AAAA,QACR,OAAa;AACL,iBAAO,mBAAmB,GAAG,CAAC;AAAA,QACtC;AAAA,MACA,SAAa,EAAE;AAAA,IACf;AAAA;AAAA;AAAA,IAIE,IAAK,SAAS,YAAY,gBAAgB;AACxC,UAAI,QAAQ,WAAW,KAAK,GAAG;AAC7B,YAAI,CAAC,cAAc,mBAAmB,OAAO;AAC3C,gBAAM,IAAI,MAAM,iDAAiD;AAAA,QACzE;AAEM,YAAI,YAAY;AACd,gBAAM,QAAQ,IAAI,UAAU,GAAG,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,eAAe,IAAI,GAAG,EAAE,UAAU,CAAC;AAClG,cAAI,CAAC,SAAS,MAAM,CAAC,MAAM,YAAY;AACrC,kBAAM,IAAI,MAAM,uBAAuB,UAAU,EAAE;AAAA,UAC7D;AAAA,QACA;AAAA,MACA;AAEI,cAAQ,SAAO;AAAA,QACb,KAAK;AACH,eAAK,WAAW,SAAS;AACzB,eAAK,QAAQ;AACb,eAAK,QAAQ;AACb,eAAK;AACL,eAAK,IAAI,OAAO,YAAY,cAAc;AAC1C;AAAA,QACF,KAAK;AACH,eAAK,WAAW,SAAS;AACzB,eAAK,QAAQ;AACb,eAAK;AACL,eAAK,IAAI,OAAO,YAAY,cAAc;AAC1C;AAAA,QACF,KAAK;AAIH,eAAK,WAAW,SAAS;AACzB,eAAK,IAAI,SAAS,YAAY,cAAc;AAC5C,eAAK,IAAI,OAAO,YAAY,cAAc;AAC1C;AAAA;AAAA;AAAA,QAGF,KAAK;AACH,cAAI,KAAK,WAAW,WAAW,GAAG;AAChC,iBAAK,IAAI,SAAS,YAAY,cAAc;AAAA,UACtD;AACQ,eAAK,IAAI,OAAO,YAAY,cAAc;AAC1C;AAAA,QACF,KAAK;AACH,cAAI,KAAK,WAAW,WAAW,GAAG;AAChC,kBAAM,IAAI,MAAM,WAAW,KAAK,GAAG,sBAAsB;AAAA,UACnE;AACQ,eAAK,WAAW,SAAS;AACzB;AAAA,QAEF,KAAK;AAKH,cACE,KAAK,UAAU,KACf,KAAK,UAAU,KACf,KAAK,WAAW,WAAW,GAC3B;AACA,iBAAK;AAAA,UACf;AACQ,eAAK,QAAQ;AACb,eAAK,QAAQ;AACb,eAAK,aAAa,CAAA;AAClB;AAAA,QACF,KAAK;AAKH,cAAI,KAAK,UAAU,KAAK,KAAK,WAAW,WAAW,GAAG;AACpD,iBAAK;AAAA,UACf;AACQ,eAAK,QAAQ;AACb,eAAK,aAAa,CAAA;AAClB;AAAA,QACF,KAAK;AAKH,cAAI,KAAK,WAAW,WAAW,GAAG;AAChC,iBAAK;AAAA,UACf;AACQ,eAAK,aAAa,CAAA;AAClB;AAAA;AAAA;AAAA,QAGF,KAAK,OAAO;AACV,gBAAM,OAAO,OAAO,cAAc,IAAI,IAAI;AAE1C,cAAI,KAAK,WAAW,WAAW,GAAG;AAChC,iBAAK,aAAa,CAAC,IAAI;AAAA,UACjC,OAAe;AACL,gBAAI,IAAI,KAAK,WAAW;AACxB,mBAAO,EAAE,KAAK,GAAG;AACf,kBAAI,OAAO,KAAK,WAAW,CAAC,MAAM,UAAU;AAC1C,qBAAK,WAAW,CAAC;AACjB,oBAAI;AAAA,cAClB;AAAA,YACA;AACU,gBAAI,MAAM,IAAI;AAEZ,kBAAI,eAAe,KAAK,WAAW,KAAK,GAAG,KAAK,mBAAmB,OAAO;AACxE,sBAAM,IAAI,MAAM,uDAAuD;AAAA,cACrF;AACY,mBAAK,WAAW,KAAK,IAAI;AAAA,YACrC;AAAA,UACA;AACQ,cAAI,YAAY;AAGd,gBAAI,aAAa,CAAC,YAAY,IAAI;AAClC,gBAAI,mBAAmB,OAAO;AAC5B,2BAAa,CAAC,UAAU;AAAA,YACpC;AACU,gBAAI,mBAAmB,KAAK,WAAW,CAAC,GAAG,UAAU,MAAM,GAAG;AAC5D,kBAAI,MAAM,KAAK,WAAW,CAAC,CAAC,GAAG;AAC7B,qBAAK,aAAa;AAAA,cAChC;AAAA,YACA,OAAiB;AACL,mBAAK,aAAa;AAAA,YAC9B;AAAA,UACA;AACQ;AAAA,QACR;AAAA,QACM;AACE,gBAAM,IAAI,MAAM,+BAA+B,OAAO,EAAE;AAAA,MAChE;AACI,WAAK,MAAM,KAAK,OAAM;AACtB,UAAI,KAAK,MAAM,QAAQ;AACrB,aAAK,OAAO,IAAI,KAAK,MAAM,KAAK,GAAG,CAAC;AAAA,MAC1C;AACI,aAAO;AAAA,IACX;AAAA,EACA;AAEA,WAAiB;;;","x_google_ignoreList":[0]}