.config/coc/extensions/node_modules/coc-prettier/lib/index.js

   1 var __create = Object.create;
   2 var __defProp = Object.defineProperty;
   3 var __getProtoOf = Object.getPrototypeOf;
   4 var __hasOwnProp = Object.prototype.hasOwnProperty;
   5 var __getOwnPropNames = Object.getOwnPropertyNames;
   6 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   7 var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
   8 var __commonJS = (callback, module2) => () => {
   9   if (!module2) {
  10     module2 = {exports: {}};
  11     callback(module2.exports, module2);
  12   }
  13   return module2.exports;
  14 };
  15 var __export = (target, all) => {
  16   for (var name in all)
  17     __defProp(target, name, {get: all[name], enumerable: true});
  18 };
  19 var __exportStar = (target, module2, desc) => {
  20   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
  21     for (let key of __getOwnPropNames(module2))
  22       if (!__hasOwnProp.call(target, key) && key !== "default")
  23         __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
  24   }
  25   return target;
  26 };
  27 var __toModule = (module2) => {
  28   if (module2 && module2.__esModule)
  29     return module2;
  30   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", {value: module2, enumerable: true})), module2);
  31 };
  32
  33 // node_modules/resolve-from/index.js
  34 var require_resolve_from = __commonJS((exports2, module2) => {
  35   "use strict";
  36   var path5 = require("path");
  37   var Module = require("module");
  38   var fs = require("fs");
  39   var resolveFrom2 = (fromDirectory, moduleId, silent) => {
  40     if (typeof fromDirectory !== "string") {
  41       throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDirectory}\``);
  42     }
  43     if (typeof moduleId !== "string") {
  44       throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
  45     }
  46     try {
  47       fromDirectory = fs.realpathSync(fromDirectory);
  48     } catch (error) {
  49       if (error.code === "ENOENT") {
  50         fromDirectory = path5.resolve(fromDirectory);
  51       } else if (silent) {
  52         return;
  53       } else {
  54         throw error;
  55       }
  56     }
  57     const fromFile = path5.join(fromDirectory, "noop.js");
  58     const resolveFileName = () => Module._resolveFilename(moduleId, {
  59       id: fromFile,
  60       filename: fromFile,
  61       paths: Module._nodeModulePaths(fromDirectory)
  62     });
  63     if (silent) {
  64       try {
  65         return resolveFileName();
  66       } catch (error) {
  67         return;
  68       }
  69     }
  70     return resolveFileName();
  71   };
  72   module2.exports = (fromDirectory, moduleId) => resolveFrom2(fromDirectory, moduleId);
  73   module2.exports.silent = (fromDirectory, moduleId) => resolveFrom2(fromDirectory, moduleId, true);
  74 });
  75
  76 // node_modules/semver/internal/constants.js
  77 var require_constants = __commonJS((exports2, module2) => {
  78   var SEMVER_SPEC_VERSION = "2.0.0";
  79   var MAX_LENGTH = 256;
  80   var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
  81   var MAX_SAFE_COMPONENT_LENGTH = 16;
  82   module2.exports = {
  83     SEMVER_SPEC_VERSION,
  84     MAX_LENGTH,
  85     MAX_SAFE_INTEGER,
  86     MAX_SAFE_COMPONENT_LENGTH
  87   };
  88 });
  89
  90 // node_modules/semver/internal/debug.js
  91 var require_debug = __commonJS((exports2, module2) => {
  92   var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
  93   };
  94   module2.exports = debug;
  95 });
  96
  97 // node_modules/semver/internal/re.js
  98 var require_re = __commonJS((exports2, module2) => {
  99   var {MAX_SAFE_COMPONENT_LENGTH} = require_constants();
 100   var debug = require_debug();
 101   exports2 = module2.exports = {};
 102   var re = exports2.re = [];
 103   var src = exports2.src = [];
 104   var t = exports2.t = {};
 105   var R = 0;
 106   var createToken = (name, value, isGlobal) => {
 107     const index = R++;
 108     debug(index, value);
 109     t[name] = index;
 110     src[index] = value;
 111     re[index] = new RegExp(value, isGlobal ? "g" : void 0);
 112   };
 113   createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
 114   createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+");
 115   createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*");
 116   createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
 117   createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
 118   createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
 119   createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
 120   createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
 121   createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
 122   createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+");
 123   createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
 124   createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
 125   createToken("FULL", `^${src[t.FULLPLAIN]}$`);
 126   createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
 127   createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
 128   createToken("GTLT", "((?:<|>)?=?)");
 129   createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
 130   createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
 131   createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
 132   createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
 133   createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
 134   createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
 135   createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`);
 136   createToken("COERCERTL", src[t.COERCE], true);
 137   createToken("LONETILDE", "(?:~>?)");
 138   createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
 139   exports2.tildeTrimReplace = "$1~";
 140   createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
 141   createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
 142   createToken("LONECARET", "(?:\\^)");
 143   createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
 144   exports2.caretTrimReplace = "$1^";
 145   createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
 146   createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
 147   createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
 148   createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
 149   createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
 150   exports2.comparatorTrimReplace = "$1$2$3";
 151   createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
 152   createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
 153   createToken("STAR", "(<|>)?=?\\s*\\*");
 154   createToken("GTE0", "^\\s*>=\\s*0.0.0\\s*$");
 155   createToken("GTE0PRE", "^\\s*>=\\s*0.0.0-0\\s*$");
 156 });
 157
 158 // node_modules/semver/internal/parse-options.js
 159 var require_parse_options = __commonJS((exports2, module2) => {
 160   var opts = ["includePrerelease", "loose", "rtl"];
 161   var parseOptions = (options) => !options ? {} : typeof options !== "object" ? {loose: true} : opts.filter((k) => options[k]).reduce((options2, k) => {
 162     options2[k] = true;
 163     return options2;
 164   }, {});
 165   module2.exports = parseOptions;
 166 });
 167
 168 // node_modules/semver/internal/identifiers.js
 169 var require_identifiers = __commonJS((exports2, module2) => {
 170   var numeric = /^[0-9]+$/;
 171   var compareIdentifiers = (a, b) => {
 172     const anum = numeric.test(a);
 173     const bnum = numeric.test(b);
 174     if (anum && bnum) {
 175       a = +a;
 176       b = +b;
 177     }
 178     return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
 179   };
 180   var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
 181   module2.exports = {
 182     compareIdentifiers,
 183     rcompareIdentifiers
 184   };
 185 });
 186
 187 // node_modules/semver/classes/semver.js
 188 var require_semver = __commonJS((exports2, module2) => {
 189   var debug = require_debug();
 190   var {MAX_LENGTH, MAX_SAFE_INTEGER} = require_constants();
 191   var {re, t} = require_re();
 192   var parseOptions = require_parse_options();
 193   var {compareIdentifiers} = require_identifiers();
 194   var SemVer = class {
 195     constructor(version, options) {
 196       options = parseOptions(options);
 197       if (version instanceof SemVer) {
 198         if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
 199           return version;
 200         } else {
 201           version = version.version;
 202         }
 203       } else if (typeof version !== "string") {
 204         throw new TypeError(`Invalid Version: ${version}`);
 205       }
 206       if (version.length > MAX_LENGTH) {
 207         throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
 208       }
 209       debug("SemVer", version, options);
 210       this.options = options;
 211       this.loose = !!options.loose;
 212       this.includePrerelease = !!options.includePrerelease;
 213       const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
 214       if (!m) {
 215         throw new TypeError(`Invalid Version: ${version}`);
 216       }
 217       this.raw = version;
 218       this.major = +m[1];
 219       this.minor = +m[2];
 220       this.patch = +m[3];
 221       if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
 222         throw new TypeError("Invalid major version");
 223       }
 224       if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
 225         throw new TypeError("Invalid minor version");
 226       }
 227       if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
 228         throw new TypeError("Invalid patch version");
 229       }
 230       if (!m[4]) {
 231         this.prerelease = [];
 232       } else {
 233         this.prerelease = m[4].split(".").map((id) => {
 234           if (/^[0-9]+$/.test(id)) {
 235             const num = +id;
 236             if (num >= 0 && num < MAX_SAFE_INTEGER) {
 237               return num;
 238             }
 239           }
 240           return id;
 241         });
 242       }
 243       this.build = m[5] ? m[5].split(".") : [];
 244       this.format();
 245     }
 246     format() {
 247       this.version = `${this.major}.${this.minor}.${this.patch}`;
 248       if (this.prerelease.length) {
 249         this.version += `-${this.prerelease.join(".")}`;
 250       }
 251       return this.version;
 252     }
 253     toString() {
 254       return this.version;
 255     }
 256     compare(other) {
 257       debug("SemVer.compare", this.version, this.options, other);
 258       if (!(other instanceof SemVer)) {
 259         if (typeof other === "string" && other === this.version) {
 260           return 0;
 261         }
 262         other = new SemVer(other, this.options);
 263       }
 264       if (other.version === this.version) {
 265         return 0;
 266       }
 267       return this.compareMain(other) || this.comparePre(other);
 268     }
 269     compareMain(other) {
 270       if (!(other instanceof SemVer)) {
 271         other = new SemVer(other, this.options);
 272       }
 273       return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
 274     }
 275     comparePre(other) {
 276       if (!(other instanceof SemVer)) {
 277         other = new SemVer(other, this.options);
 278       }
 279       if (this.prerelease.length && !other.prerelease.length) {
 280         return -1;
 281       } else if (!this.prerelease.length && other.prerelease.length) {
 282         return 1;
 283       } else if (!this.prerelease.length && !other.prerelease.length) {
 284         return 0;
 285       }
 286       let i = 0;
 287       do {
 288         const a = this.prerelease[i];
 289         const b = other.prerelease[i];
 290         debug("prerelease compare", i, a, b);
 291         if (a === void 0 && b === void 0) {
 292           return 0;
 293         } else if (b === void 0) {
 294           return 1;
 295         } else if (a === void 0) {
 296           return -1;
 297         } else if (a === b) {
 298           continue;
 299         } else {
 300           return compareIdentifiers(a, b);
 301         }
 302       } while (++i);
 303     }
 304     compareBuild(other) {
 305       if (!(other instanceof SemVer)) {
 306         other = new SemVer(other, this.options);
 307       }
 308       let i = 0;
 309       do {
 310         const a = this.build[i];
 311         const b = other.build[i];
 312         debug("prerelease compare", i, a, b);
 313         if (a === void 0 && b === void 0) {
 314           return 0;
 315         } else if (b === void 0) {
 316           return 1;
 317         } else if (a === void 0) {
 318           return -1;
 319         } else if (a === b) {
 320           continue;
 321         } else {
 322           return compareIdentifiers(a, b);
 323         }
 324       } while (++i);
 325     }
 326     inc(release, identifier) {
 327       switch (release) {
 328         case "premajor":
 329           this.prerelease.length = 0;
 330           this.patch = 0;
 331           this.minor = 0;
 332           this.major++;
 333           this.inc("pre", identifier);
 334           break;
 335         case "preminor":
 336           this.prerelease.length = 0;
 337           this.patch = 0;
 338           this.minor++;
 339           this.inc("pre", identifier);
 340           break;
 341         case "prepatch":
 342           this.prerelease.length = 0;
 343           this.inc("patch", identifier);
 344           this.inc("pre", identifier);
 345           break;
 346         case "prerelease":
 347           if (this.prerelease.length === 0) {
 348             this.inc("patch", identifier);
 349           }
 350           this.inc("pre", identifier);
 351           break;
 352         case "major":
 353           if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
 354             this.major++;
 355           }
 356           this.minor = 0;
 357           this.patch = 0;
 358           this.prerelease = [];
 359           break;
 360         case "minor":
 361           if (this.patch !== 0 || this.prerelease.length === 0) {
 362             this.minor++;
 363           }
 364           this.patch = 0;
 365           this.prerelease = [];
 366           break;
 367         case "patch":
 368           if (this.prerelease.length === 0) {
 369             this.patch++;
 370           }
 371           this.prerelease = [];
 372           break;
 373         case "pre":
 374           if (this.prerelease.length === 0) {
 375             this.prerelease = [0];
 376           } else {
 377             let i = this.prerelease.length;
 378             while (--i >= 0) {
 379               if (typeof this.prerelease[i] === "number") {
 380                 this.prerelease[i]++;
 381                 i = -2;
 382               }
 383             }
 384             if (i === -1) {
 385               this.prerelease.push(0);
 386             }
 387           }
 388           if (identifier) {
 389             if (this.prerelease[0] === identifier) {
 390               if (isNaN(this.prerelease[1])) {
 391                 this.prerelease = [identifier, 0];
 392               }
 393             } else {
 394               this.prerelease = [identifier, 0];
 395             }
 396           }
 397           break;
 398         default:
 399           throw new Error(`invalid increment argument: ${release}`);
 400       }
 401       this.format();
 402       this.raw = this.version;
 403       return this;
 404     }
 405   };
 406   module2.exports = SemVer;
 407 });
 408
 409 // node_modules/semver/functions/parse.js
 410 var require_parse = __commonJS((exports2, module2) => {
 411   var {MAX_LENGTH} = require_constants();
 412   var {re, t} = require_re();
 413   var SemVer = require_semver();
 414   var parseOptions = require_parse_options();
 415   var parse = (version, options) => {
 416     options = parseOptions(options);
 417     if (version instanceof SemVer) {
 418       return version;
 419     }
 420     if (typeof version !== "string") {
 421       return null;
 422     }
 423     if (version.length > MAX_LENGTH) {
 424       return null;
 425     }
 426     const r = options.loose ? re[t.LOOSE] : re[t.FULL];
 427     if (!r.test(version)) {
 428       return null;
 429     }
 430     try {
 431       return new SemVer(version, options);
 432     } catch (er) {
 433       return null;
 434     }
 435   };
 436   module2.exports = parse;
 437 });
 438
 439 // node_modules/semver/functions/valid.js
 440 var require_valid = __commonJS((exports2, module2) => {
 441   var parse = require_parse();
 442   var valid = (version, options) => {
 443     const v = parse(version, options);
 444     return v ? v.version : null;
 445   };
 446   module2.exports = valid;
 447 });
 448
 449 // node_modules/semver/functions/clean.js
 450 var require_clean = __commonJS((exports2, module2) => {
 451   var parse = require_parse();
 452   var clean = (version, options) => {
 453     const s = parse(version.trim().replace(/^[=v]+/, ""), options);
 454     return s ? s.version : null;
 455   };
 456   module2.exports = clean;
 457 });
 458
 459 // node_modules/semver/functions/inc.js
 460 var require_inc = __commonJS((exports2, module2) => {
 461   var SemVer = require_semver();
 462   var inc = (version, release, options, identifier) => {
 463     if (typeof options === "string") {
 464       identifier = options;
 465       options = void 0;
 466     }
 467     try {
 468       return new SemVer(version, options).inc(release, identifier).version;
 469     } catch (er) {
 470       return null;
 471     }
 472   };
 473   module2.exports = inc;
 474 });
 475
 476 // node_modules/semver/functions/compare.js
 477 var require_compare = __commonJS((exports2, module2) => {
 478   var SemVer = require_semver();
 479   var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
 480   module2.exports = compare;
 481 });
 482
 483 // node_modules/semver/functions/eq.js
 484 var require_eq = __commonJS((exports2, module2) => {
 485   var compare = require_compare();
 486   var eq = (a, b, loose) => compare(a, b, loose) === 0;
 487   module2.exports = eq;
 488 });
 489
 490 // node_modules/semver/functions/diff.js
 491 var require_diff = __commonJS((exports2, module2) => {
 492   var parse = require_parse();
 493   var eq = require_eq();
 494   var diff = (version1, version2) => {
 495     if (eq(version1, version2)) {
 496       return null;
 497     } else {
 498       const v1 = parse(version1);
 499       const v2 = parse(version2);
 500       const hasPre = v1.prerelease.length || v2.prerelease.length;
 501       const prefix = hasPre ? "pre" : "";
 502       const defaultResult = hasPre ? "prerelease" : "";
 503       for (const key in v1) {
 504         if (key === "major" || key === "minor" || key === "patch") {
 505           if (v1[key] !== v2[key]) {
 506             return prefix + key;
 507           }
 508         }
 509       }
 510       return defaultResult;
 511     }
 512   };
 513   module2.exports = diff;
 514 });
 515
 516 // node_modules/semver/functions/major.js
 517 var require_major = __commonJS((exports2, module2) => {
 518   var SemVer = require_semver();
 519   var major = (a, loose) => new SemVer(a, loose).major;
 520   module2.exports = major;
 521 });
 522
 523 // node_modules/semver/functions/minor.js
 524 var require_minor = __commonJS((exports2, module2) => {
 525   var SemVer = require_semver();
 526   var minor = (a, loose) => new SemVer(a, loose).minor;
 527   module2.exports = minor;
 528 });
 529
 530 // node_modules/semver/functions/patch.js
 531 var require_patch = __commonJS((exports2, module2) => {
 532   var SemVer = require_semver();
 533   var patch = (a, loose) => new SemVer(a, loose).patch;
 534   module2.exports = patch;
 535 });
 536
 537 // node_modules/semver/functions/prerelease.js
 538 var require_prerelease = __commonJS((exports2, module2) => {
 539   var parse = require_parse();
 540   var prerelease = (version, options) => {
 541     const parsed = parse(version, options);
 542     return parsed && parsed.prerelease.length ? parsed.prerelease : null;
 543   };
 544   module2.exports = prerelease;
 545 });
 546
 547 // node_modules/semver/functions/rcompare.js
 548 var require_rcompare = __commonJS((exports2, module2) => {
 549   var compare = require_compare();
 550   var rcompare = (a, b, loose) => compare(b, a, loose);
 551   module2.exports = rcompare;
 552 });
 553
 554 // node_modules/semver/functions/compare-loose.js
 555 var require_compare_loose = __commonJS((exports2, module2) => {
 556   var compare = require_compare();
 557   var compareLoose = (a, b) => compare(a, b, true);
 558   module2.exports = compareLoose;
 559 });
 560
 561 // node_modules/semver/functions/compare-build.js
 562 var require_compare_build = __commonJS((exports2, module2) => {
 563   var SemVer = require_semver();
 564   var compareBuild = (a, b, loose) => {
 565     const versionA = new SemVer(a, loose);
 566     const versionB = new SemVer(b, loose);
 567     return versionA.compare(versionB) || versionA.compareBuild(versionB);
 568   };
 569   module2.exports = compareBuild;
 570 });
 571
 572 // node_modules/semver/functions/sort.js
 573 var require_sort = __commonJS((exports2, module2) => {
 574   var compareBuild = require_compare_build();
 575   var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
 576   module2.exports = sort;
 577 });
 578
 579 // node_modules/semver/functions/rsort.js
 580 var require_rsort = __commonJS((exports2, module2) => {
 581   var compareBuild = require_compare_build();
 582   var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
 583   module2.exports = rsort;
 584 });
 585
 586 // node_modules/semver/functions/gt.js
 587 var require_gt = __commonJS((exports2, module2) => {
 588   var compare = require_compare();
 589   var gt = (a, b, loose) => compare(a, b, loose) > 0;
 590   module2.exports = gt;
 591 });
 592
 593 // node_modules/semver/functions/lt.js
 594 var require_lt = __commonJS((exports2, module2) => {
 595   var compare = require_compare();
 596   var lt = (a, b, loose) => compare(a, b, loose) < 0;
 597   module2.exports = lt;
 598 });
 599
 600 // node_modules/semver/functions/neq.js
 601 var require_neq = __commonJS((exports2, module2) => {
 602   var compare = require_compare();
 603   var neq = (a, b, loose) => compare(a, b, loose) !== 0;
 604   module2.exports = neq;
 605 });
 606
 607 // node_modules/semver/functions/gte.js
 608 var require_gte = __commonJS((exports2, module2) => {
 609   var compare = require_compare();
 610   var gte = (a, b, loose) => compare(a, b, loose) >= 0;
 611   module2.exports = gte;
 612 });
 613
 614 // node_modules/semver/functions/lte.js
 615 var require_lte = __commonJS((exports2, module2) => {
 616   var compare = require_compare();
 617   var lte = (a, b, loose) => compare(a, b, loose) <= 0;
 618   module2.exports = lte;
 619 });
 620
 621 // node_modules/semver/functions/cmp.js
 622 var require_cmp = __commonJS((exports2, module2) => {
 623   var eq = require_eq();
 624   var neq = require_neq();
 625   var gt = require_gt();
 626   var gte = require_gte();
 627   var lt = require_lt();
 628   var lte = require_lte();
 629   var cmp = (a, op, b, loose) => {
 630     switch (op) {
 631       case "===":
 632         if (typeof a === "object")
 633           a = a.version;
 634         if (typeof b === "object")
 635           b = b.version;
 636         return a === b;
 637       case "!==":
 638         if (typeof a === "object")
 639           a = a.version;
 640         if (typeof b === "object")
 641           b = b.version;
 642         return a !== b;
 643       case "":
 644       case "=":
 645       case "==":
 646         return eq(a, b, loose);
 647       case "!=":
 648         return neq(a, b, loose);
 649       case ">":
 650         return gt(a, b, loose);
 651       case ">=":
 652         return gte(a, b, loose);
 653       case "<":
 654         return lt(a, b, loose);
 655       case "<=":
 656         return lte(a, b, loose);
 657       default:
 658         throw new TypeError(`Invalid operator: ${op}`);
 659     }
 660   };
 661   module2.exports = cmp;
 662 });
 663
 664 // node_modules/semver/functions/coerce.js
 665 var require_coerce = __commonJS((exports2, module2) => {
 666   var SemVer = require_semver();
 667   var parse = require_parse();
 668   var {re, t} = require_re();
 669   var coerce = (version, options) => {
 670     if (version instanceof SemVer) {
 671       return version;
 672     }
 673     if (typeof version === "number") {
 674       version = String(version);
 675     }
 676     if (typeof version !== "string") {
 677       return null;
 678     }
 679     options = options || {};
 680     let match = null;
 681     if (!options.rtl) {
 682       match = version.match(re[t.COERCE]);
 683     } else {
 684       let next;
 685       while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
 686         if (!match || next.index + next[0].length !== match.index + match[0].length) {
 687           match = next;
 688         }
 689         re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
 690       }
 691       re[t.COERCERTL].lastIndex = -1;
 692     }
 693     if (match === null)
 694       return null;
 695     return parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
 696   };
 697   module2.exports = coerce;
 698 });
 699
 700 // node_modules/yallist/iterator.js
 701 var require_iterator = __commonJS((exports2, module2) => {
 702   "use strict";
 703   module2.exports = function(Yallist) {
 704     Yallist.prototype[Symbol.iterator] = function* () {
 705       for (let walker = this.head; walker; walker = walker.next) {
 706         yield walker.value;
 707       }
 708     };
 709   };
 710 });
 711
 712 // node_modules/yallist/yallist.js
 713 var require_yallist = __commonJS((exports2, module2) => {
 714   "use strict";
 715   module2.exports = Yallist;
 716   Yallist.Node = Node;
 717   Yallist.create = Yallist;
 718   function Yallist(list) {
 719     var self = this;
 720     if (!(self instanceof Yallist)) {
 721       self = new Yallist();
 722     }
 723     self.tail = null;
 724     self.head = null;
 725     self.length = 0;
 726     if (list && typeof list.forEach === "function") {
 727       list.forEach(function(item) {
 728         self.push(item);
 729       });
 730     } else if (arguments.length > 0) {
 731       for (var i = 0, l = arguments.length; i < l; i++) {
 732         self.push(arguments[i]);
 733       }
 734     }
 735     return self;
 736   }
 737   Yallist.prototype.removeNode = function(node) {
 738     if (node.list !== this) {
 739       throw new Error("removing node which does not belong to this list");
 740     }
 741     var next = node.next;
 742     var prev = node.prev;
 743     if (next) {
 744       next.prev = prev;
 745     }
 746     if (prev) {
 747       prev.next = next;
 748     }
 749     if (node === this.head) {
 750       this.head = next;
 751     }
 752     if (node === this.tail) {
 753       this.tail = prev;
 754     }
 755     node.list.length--;
 756     node.next = null;
 757     node.prev = null;
 758     node.list = null;
 759     return next;
 760   };
 761   Yallist.prototype.unshiftNode = function(node) {
 762     if (node === this.head) {
 763       return;
 764     }
 765     if (node.list) {
 766       node.list.removeNode(node);
 767     }
 768     var head = this.head;
 769     node.list = this;
 770     node.next = head;
 771     if (head) {
 772       head.prev = node;
 773     }
 774     this.head = node;
 775     if (!this.tail) {
 776       this.tail = node;
 777     }
 778     this.length++;
 779   };
 780   Yallist.prototype.pushNode = function(node) {
 781     if (node === this.tail) {
 782       return;
 783     }
 784     if (node.list) {
 785       node.list.removeNode(node);
 786     }
 787     var tail = this.tail;
 788     node.list = this;
 789     node.prev = tail;
 790     if (tail) {
 791       tail.next = node;
 792     }
 793     this.tail = node;
 794     if (!this.head) {
 795       this.head = node;
 796     }
 797     this.length++;
 798   };
 799   Yallist.prototype.push = function() {
 800     for (var i = 0, l = arguments.length; i < l; i++) {
 801       push(this, arguments[i]);
 802     }
 803     return this.length;
 804   };
 805   Yallist.prototype.unshift = function() {
 806     for (var i = 0, l = arguments.length; i < l; i++) {
 807       unshift(this, arguments[i]);
 808     }
 809     return this.length;
 810   };
 811   Yallist.prototype.pop = function() {
 812     if (!this.tail) {
 813       return void 0;
 814     }
 815     var res = this.tail.value;
 816     this.tail = this.tail.prev;
 817     if (this.tail) {
 818       this.tail.next = null;
 819     } else {
 820       this.head = null;
 821     }
 822     this.length--;
 823     return res;
 824   };
 825   Yallist.prototype.shift = function() {
 826     if (!this.head) {
 827       return void 0;
 828     }
 829     var res = this.head.value;
 830     this.head = this.head.next;
 831     if (this.head) {
 832       this.head.prev = null;
 833     } else {
 834       this.tail = null;
 835     }
 836     this.length--;
 837     return res;
 838   };
 839   Yallist.prototype.forEach = function(fn, thisp) {
 840     thisp = thisp || this;
 841     for (var walker = this.head, i = 0; walker !== null; i++) {
 842       fn.call(thisp, walker.value, i, this);
 843       walker = walker.next;
 844     }
 845   };
 846   Yallist.prototype.forEachReverse = function(fn, thisp) {
 847     thisp = thisp || this;
 848     for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
 849       fn.call(thisp, walker.value, i, this);
 850       walker = walker.prev;
 851     }
 852   };
 853   Yallist.prototype.get = function(n) {
 854     for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
 855       walker = walker.next;
 856     }
 857     if (i === n && walker !== null) {
 858       return walker.value;
 859     }
 860   };
 861   Yallist.prototype.getReverse = function(n) {
 862     for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
 863       walker = walker.prev;
 864     }
 865     if (i === n && walker !== null) {
 866       return walker.value;
 867     }
 868   };
 869   Yallist.prototype.map = function(fn, thisp) {
 870     thisp = thisp || this;
 871     var res = new Yallist();
 872     for (var walker = this.head; walker !== null; ) {
 873       res.push(fn.call(thisp, walker.value, this));
 874       walker = walker.next;
 875     }
 876     return res;
 877   };
 878   Yallist.prototype.mapReverse = function(fn, thisp) {
 879     thisp = thisp || this;
 880     var res = new Yallist();
 881     for (var walker = this.tail; walker !== null; ) {
 882       res.push(fn.call(thisp, walker.value, this));
 883       walker = walker.prev;
 884     }
 885     return res;
 886   };
 887   Yallist.prototype.reduce = function(fn, initial) {
 888     var acc;
 889     var walker = this.head;
 890     if (arguments.length > 1) {
 891       acc = initial;
 892     } else if (this.head) {
 893       walker = this.head.next;
 894       acc = this.head.value;
 895     } else {
 896       throw new TypeError("Reduce of empty list with no initial value");
 897     }
 898     for (var i = 0; walker !== null; i++) {
 899       acc = fn(acc, walker.value, i);
 900       walker = walker.next;
 901     }
 902     return acc;
 903   };
 904   Yallist.prototype.reduceReverse = function(fn, initial) {
 905     var acc;
 906     var walker = this.tail;
 907     if (arguments.length > 1) {
 908       acc = initial;
 909     } else if (this.tail) {
 910       walker = this.tail.prev;
 911       acc = this.tail.value;
 912     } else {
 913       throw new TypeError("Reduce of empty list with no initial value");
 914     }
 915     for (var i = this.length - 1; walker !== null; i--) {
 916       acc = fn(acc, walker.value, i);
 917       walker = walker.prev;
 918     }
 919     return acc;
 920   };
 921   Yallist.prototype.toArray = function() {
 922     var arr = new Array(this.length);
 923     for (var i = 0, walker = this.head; walker !== null; i++) {
 924       arr[i] = walker.value;
 925       walker = walker.next;
 926     }
 927     return arr;
 928   };
 929   Yallist.prototype.toArrayReverse = function() {
 930     var arr = new Array(this.length);
 931     for (var i = 0, walker = this.tail; walker !== null; i++) {
 932       arr[i] = walker.value;
 933       walker = walker.prev;
 934     }
 935     return arr;
 936   };
 937   Yallist.prototype.slice = function(from, to) {
 938     to = to || this.length;
 939     if (to < 0) {
 940       to += this.length;
 941     }
 942     from = from || 0;
 943     if (from < 0) {
 944       from += this.length;
 945     }
 946     var ret = new Yallist();
 947     if (to < from || to < 0) {
 948       return ret;
 949     }
 950     if (from < 0) {
 951       from = 0;
 952     }
 953     if (to > this.length) {
 954       to = this.length;
 955     }
 956     for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
 957       walker = walker.next;
 958     }
 959     for (; walker !== null && i < to; i++, walker = walker.next) {
 960       ret.push(walker.value);
 961     }
 962     return ret;
 963   };
 964   Yallist.prototype.sliceReverse = function(from, to) {
 965     to = to || this.length;
 966     if (to < 0) {
 967       to += this.length;
 968     }
 969     from = from || 0;
 970     if (from < 0) {
 971       from += this.length;
 972     }
 973     var ret = new Yallist();
 974     if (to < from || to < 0) {
 975       return ret;
 976     }
 977     if (from < 0) {
 978       from = 0;
 979     }
 980     if (to > this.length) {
 981       to = this.length;
 982     }
 983     for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
 984       walker = walker.prev;
 985     }
 986     for (; walker !== null && i > from; i--, walker = walker.prev) {
 987       ret.push(walker.value);
 988     }
 989     return ret;
 990   };
 991   Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
 992     if (start > this.length) {
 993       start = this.length - 1;
 994     }
 995     if (start < 0) {
 996       start = this.length + start;
 997     }
 998     for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
 999       walker = walker.next;
1000     }
1001     var ret = [];
1002     for (var i = 0; walker && i < deleteCount; i++) {
1003       ret.push(walker.value);
1004       walker = this.removeNode(walker);
1005     }
1006     if (walker === null) {
1007       walker = this.tail;
1008     }
1009     if (walker !== this.head && walker !== this.tail) {
1010       walker = walker.prev;
1011     }
1012     for (var i = 0; i < nodes.length; i++) {
1013       walker = insert(this, walker, nodes[i]);
1014     }
1015     return ret;
1016   };
1017   Yallist.prototype.reverse = function() {
1018     var head = this.head;
1019     var tail = this.tail;
1020     for (var walker = head; walker !== null; walker = walker.prev) {
1021       var p = walker.prev;
1022       walker.prev = walker.next;
1023       walker.next = p;
1024     }
1025     this.head = tail;
1026     this.tail = head;
1027     return this;
1028   };
1029   function insert(self, node, value) {
1030     var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
1031     if (inserted.next === null) {
1032       self.tail = inserted;
1033     }
1034     if (inserted.prev === null) {
1035       self.head = inserted;
1036     }
1037     self.length++;
1038     return inserted;
1039   }
1040   function push(self, item) {
1041     self.tail = new Node(item, self.tail, null, self);
1042     if (!self.head) {
1043       self.head = self.tail;
1044     }
1045     self.length++;
1046   }
1047   function unshift(self, item) {
1048     self.head = new Node(item, null, self.head, self);
1049     if (!self.tail) {
1050       self.tail = self.head;
1051     }
1052     self.length++;
1053   }
1054   function Node(value, prev, next, list) {
1055     if (!(this instanceof Node)) {
1056       return new Node(value, prev, next, list);
1057     }
1058     this.list = list;
1059     this.value = value;
1060     if (prev) {
1061       prev.next = this;
1062       this.prev = prev;
1063     } else {
1064       this.prev = null;
1065     }
1066     if (next) {
1067       next.prev = this;
1068       this.next = next;
1069     } else {
1070       this.next = null;
1071     }
1072   }
1073   try {
1074     require_iterator()(Yallist);
1075   } catch (er) {
1076   }
1077 });
1078
1079 // node_modules/lru-cache/index.js
1080 var require_lru_cache = __commonJS((exports2, module2) => {
1081   "use strict";
1082   var Yallist = require_yallist();
1083   var MAX = Symbol("max");
1084   var LENGTH = Symbol("length");
1085   var LENGTH_CALCULATOR = Symbol("lengthCalculator");
1086   var ALLOW_STALE = Symbol("allowStale");
1087   var MAX_AGE = Symbol("maxAge");
1088   var DISPOSE = Symbol("dispose");
1089   var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
1090   var LRU_LIST = Symbol("lruList");
1091   var CACHE = Symbol("cache");
1092   var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
1093   var naiveLength = () => 1;
1094   var LRUCache = class {
1095     constructor(options) {
1096       if (typeof options === "number")
1097         options = {max: options};
1098       if (!options)
1099         options = {};
1100       if (options.max && (typeof options.max !== "number" || options.max < 0))
1101         throw new TypeError("max must be a non-negative number");
1102       const max = this[MAX] = options.max || Infinity;
1103       const lc = options.length || naiveLength;
1104       this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
1105       this[ALLOW_STALE] = options.stale || false;
1106       if (options.maxAge && typeof options.maxAge !== "number")
1107         throw new TypeError("maxAge must be a number");
1108       this[MAX_AGE] = options.maxAge || 0;
1109       this[DISPOSE] = options.dispose;
1110       this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
1111       this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
1112       this.reset();
1113     }
1114     set max(mL) {
1115       if (typeof mL !== "number" || mL < 0)
1116         throw new TypeError("max must be a non-negative number");
1117       this[MAX] = mL || Infinity;
1118       trim(this);
1119     }
1120     get max() {
1121       return this[MAX];
1122     }
1123     set allowStale(allowStale) {
1124       this[ALLOW_STALE] = !!allowStale;
1125     }
1126     get allowStale() {
1127       return this[ALLOW_STALE];
1128     }
1129     set maxAge(mA) {
1130       if (typeof mA !== "number")
1131         throw new TypeError("maxAge must be a non-negative number");
1132       this[MAX_AGE] = mA;
1133       trim(this);
1134     }
1135     get maxAge() {
1136       return this[MAX_AGE];
1137     }
1138     set lengthCalculator(lC) {
1139       if (typeof lC !== "function")
1140         lC = naiveLength;
1141       if (lC !== this[LENGTH_CALCULATOR]) {
1142         this[LENGTH_CALCULATOR] = lC;
1143         this[LENGTH] = 0;
1144         this[LRU_LIST].forEach((hit) => {
1145           hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
1146           this[LENGTH] += hit.length;
1147         });
1148       }
1149       trim(this);
1150     }
1151     get lengthCalculator() {
1152       return this[LENGTH_CALCULATOR];
1153     }
1154     get length() {
1155       return this[LENGTH];
1156     }
1157     get itemCount() {
1158       return this[LRU_LIST].length;
1159     }
1160     rforEach(fn, thisp) {
1161       thisp = thisp || this;
1162       for (let walker = this[LRU_LIST].tail; walker !== null; ) {
1163         const prev = walker.prev;
1164         forEachStep(this, fn, walker, thisp);
1165         walker = prev;
1166       }
1167     }
1168     forEach(fn, thisp) {
1169       thisp = thisp || this;
1170       for (let walker = this[LRU_LIST].head; walker !== null; ) {
1171         const next = walker.next;
1172         forEachStep(this, fn, walker, thisp);
1173         walker = next;
1174       }
1175     }
1176     keys() {
1177       return this[LRU_LIST].toArray().map((k) => k.key);
1178     }
1179     values() {
1180       return this[LRU_LIST].toArray().map((k) => k.value);
1181     }
1182     reset() {
1183       if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
1184         this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
1185       }
1186       this[CACHE] = new Map();
1187       this[LRU_LIST] = new Yallist();
1188       this[LENGTH] = 0;
1189     }
1190     dump() {
1191       return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
1192         k: hit.key,
1193         v: hit.value,
1194         e: hit.now + (hit.maxAge || 0)
1195       }).toArray().filter((h) => h);
1196     }
1197     dumpLru() {
1198       return this[LRU_LIST];
1199     }
1200     set(key, value, maxAge) {
1201       maxAge = maxAge || this[MAX_AGE];
1202       if (maxAge && typeof maxAge !== "number")
1203         throw new TypeError("maxAge must be a number");
1204       const now = maxAge ? Date.now() : 0;
1205       const len = this[LENGTH_CALCULATOR](value, key);
1206       if (this[CACHE].has(key)) {
1207         if (len > this[MAX]) {
1208           del(this, this[CACHE].get(key));
1209           return false;
1210         }
1211         const node = this[CACHE].get(key);
1212         const item = node.value;
1213         if (this[DISPOSE]) {
1214           if (!this[NO_DISPOSE_ON_SET])
1215             this[DISPOSE](key, item.value);
1216         }
1217         item.now = now;
1218         item.maxAge = maxAge;
1219         item.value = value;
1220         this[LENGTH] += len - item.length;
1221         item.length = len;
1222         this.get(key);
1223         trim(this);
1224         return true;
1225       }
1226       const hit = new Entry(key, value, len, now, maxAge);
1227       if (hit.length > this[MAX]) {
1228         if (this[DISPOSE])
1229           this[DISPOSE](key, value);
1230         return false;
1231       }
1232       this[LENGTH] += hit.length;
1233       this[LRU_LIST].unshift(hit);
1234       this[CACHE].set(key, this[LRU_LIST].head);
1235       trim(this);
1236       return true;
1237     }
1238     has(key) {
1239       if (!this[CACHE].has(key))
1240         return false;
1241       const hit = this[CACHE].get(key).value;
1242       return !isStale(this, hit);
1243     }
1244     get(key) {
1245       return get(this, key, true);
1246     }
1247     peek(key) {
1248       return get(this, key, false);
1249     }
1250     pop() {
1251       const node = this[LRU_LIST].tail;
1252       if (!node)
1253         return null;
1254       del(this, node);
1255       return node.value;
1256     }
1257     del(key) {
1258       del(this, this[CACHE].get(key));
1259     }
1260     load(arr) {
1261       this.reset();
1262       const now = Date.now();
1263       for (let l = arr.length - 1; l >= 0; l--) {
1264         const hit = arr[l];
1265         const expiresAt = hit.e || 0;
1266         if (expiresAt === 0)
1267           this.set(hit.k, hit.v);
1268         else {
1269           const maxAge = expiresAt - now;
1270           if (maxAge > 0) {
1271             this.set(hit.k, hit.v, maxAge);
1272           }
1273         }
1274       }
1275     }
1276     prune() {
1277       this[CACHE].forEach((value, key) => get(this, key, false));
1278     }
1279   };
1280   var get = (self, key, doUse) => {
1281     const node = self[CACHE].get(key);
1282     if (node) {
1283       const hit = node.value;
1284       if (isStale(self, hit)) {
1285         del(self, node);
1286         if (!self[ALLOW_STALE])
1287           return void 0;
1288       } else {
1289         if (doUse) {
1290           if (self[UPDATE_AGE_ON_GET])
1291             node.value.now = Date.now();
1292           self[LRU_LIST].unshiftNode(node);
1293         }
1294       }
1295       return hit.value;
1296     }
1297   };
1298   var isStale = (self, hit) => {
1299     if (!hit || !hit.maxAge && !self[MAX_AGE])
1300       return false;
1301     const diff = Date.now() - hit.now;
1302     return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
1303   };
1304   var trim = (self) => {
1305     if (self[LENGTH] > self[MAX]) {
1306       for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) {
1307         const prev = walker.prev;
1308         del(self, walker);
1309         walker = prev;
1310       }
1311     }
1312   };
1313   var del = (self, node) => {
1314     if (node) {
1315       const hit = node.value;
1316       if (self[DISPOSE])
1317         self[DISPOSE](hit.key, hit.value);
1318       self[LENGTH] -= hit.length;
1319       self[CACHE].delete(hit.key);
1320       self[LRU_LIST].removeNode(node);
1321     }
1322   };
1323   var Entry = class {
1324     constructor(key, value, length, now, maxAge) {
1325       this.key = key;
1326       this.value = value;
1327       this.length = length;
1328       this.now = now;
1329       this.maxAge = maxAge || 0;
1330     }
1331   };
1332   var forEachStep = (self, fn, node, thisp) => {
1333     let hit = node.value;
1334     if (isStale(self, hit)) {
1335       del(self, node);
1336       if (!self[ALLOW_STALE])
1337         hit = void 0;
1338     }
1339     if (hit)
1340       fn.call(thisp, hit.value, hit.key, self);
1341   };
1342   module2.exports = LRUCache;
1343 });
1344
1345 // node_modules/semver/classes/range.js
1346 var require_range = __commonJS((exports2, module2) => {
1347   var Range2 = class {
1348     constructor(range, options) {
1349       options = parseOptions(options);
1350       if (range instanceof Range2) {
1351         if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
1352           return range;
1353         } else {
1354           return new Range2(range.raw, options);
1355         }
1356       }
1357       if (range instanceof Comparator) {
1358         this.raw = range.value;
1359         this.set = [[range]];
1360         this.format();
1361         return this;
1362       }
1363       this.options = options;
1364       this.loose = !!options.loose;
1365       this.includePrerelease = !!options.includePrerelease;
1366       this.raw = range;
1367       this.set = range.split(/\s*\|\|\s*/).map((range2) => this.parseRange(range2.trim())).filter((c) => c.length);
1368       if (!this.set.length) {
1369         throw new TypeError(`Invalid SemVer Range: ${range}`);
1370       }
1371       if (this.set.length > 1) {
1372         const first = this.set[0];
1373         this.set = this.set.filter((c) => !isNullSet(c[0]));
1374         if (this.set.length === 0)
1375           this.set = [first];
1376         else if (this.set.length > 1) {
1377           for (const c of this.set) {
1378             if (c.length === 1 && isAny(c[0])) {
1379               this.set = [c];
1380               break;
1381             }
1382           }
1383         }
1384       }
1385       this.format();
1386     }
1387     format() {
1388       this.range = this.set.map((comps) => {
1389         return comps.join(" ").trim();
1390       }).join("||").trim();
1391       return this.range;
1392     }
1393     toString() {
1394       return this.range;
1395     }
1396     parseRange(range) {
1397       range = range.trim();
1398       const memoOpts = Object.keys(this.options).join(",");
1399       const memoKey = `parseRange:${memoOpts}:${range}`;
1400       const cached = cache.get(memoKey);
1401       if (cached)
1402         return cached;
1403       const loose = this.options.loose;
1404       const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
1405       range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
1406       debug("hyphen replace", range);
1407       range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
1408       debug("comparator trim", range, re[t.COMPARATORTRIM]);
1409       range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
1410       range = range.replace(re[t.CARETTRIM], caretTrimReplace);
1411       range = range.split(/\s+/).join(" ");
1412       const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
1413       const rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)).filter(this.options.loose ? (comp) => !!comp.match(compRe) : () => true).map((comp) => new Comparator(comp, this.options));
1414       const l = rangeList.length;
1415       const rangeMap = new Map();
1416       for (const comp of rangeList) {
1417         if (isNullSet(comp))
1418           return [comp];
1419         rangeMap.set(comp.value, comp);
1420       }
1421       if (rangeMap.size > 1 && rangeMap.has(""))
1422         rangeMap.delete("");
1423       const result = [...rangeMap.values()];
1424       cache.set(memoKey, result);
1425       return result;
1426     }
1427     intersects(range, options) {
1428       if (!(range instanceof Range2)) {
1429         throw new TypeError("a Range is required");
1430       }
1431       return this.set.some((thisComparators) => {
1432         return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
1433           return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
1434             return rangeComparators.every((rangeComparator) => {
1435               return thisComparator.intersects(rangeComparator, options);
1436             });
1437           });
1438         });
1439       });
1440     }
1441     test(version) {
1442       if (!version) {
1443         return false;
1444       }
1445       if (typeof version === "string") {
1446         try {
1447           version = new SemVer(version, this.options);
1448         } catch (er) {
1449           return false;
1450         }
1451       }
1452       for (let i = 0; i < this.set.length; i++) {
1453         if (testSet(this.set[i], version, this.options)) {
1454           return true;
1455         }
1456       }
1457       return false;
1458     }
1459   };
1460   module2.exports = Range2;
1461   var LRU = require_lru_cache();
1462   var cache = new LRU({max: 1e3});
1463   var parseOptions = require_parse_options();
1464   var Comparator = require_comparator();
1465   var debug = require_debug();
1466   var SemVer = require_semver();
1467   var {
1468     re,
1469     t,
1470     comparatorTrimReplace,
1471     tildeTrimReplace,
1472     caretTrimReplace
1473   } = require_re();
1474   var isNullSet = (c) => c.value === "<0.0.0-0";
1475   var isAny = (c) => c.value === "";
1476   var isSatisfiable = (comparators, options) => {
1477     let result = true;
1478     const remainingComparators = comparators.slice();
1479     let testComparator = remainingComparators.pop();
1480     while (result && remainingComparators.length) {
1481       result = remainingComparators.every((otherComparator) => {
1482         return testComparator.intersects(otherComparator, options);
1483       });
1484       testComparator = remainingComparators.pop();
1485     }
1486     return result;
1487   };
1488   var parseComparator = (comp, options) => {
1489     debug("comp", comp, options);
1490     comp = replaceCarets(comp, options);
1491     debug("caret", comp);
1492     comp = replaceTildes(comp, options);
1493     debug("tildes", comp);
1494     comp = replaceXRanges(comp, options);
1495     debug("xrange", comp);
1496     comp = replaceStars(comp, options);
1497     debug("stars", comp);
1498     return comp;
1499   };
1500   var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
1501   var replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((comp2) => {
1502     return replaceTilde(comp2, options);
1503   }).join(" ");
1504   var replaceTilde = (comp, options) => {
1505     const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
1506     return comp.replace(r, (_, M, m, p, pr) => {
1507       debug("tilde", comp, _, M, m, p, pr);
1508       let ret;
1509       if (isX(M)) {
1510         ret = "";
1511       } else if (isX(m)) {
1512         ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
1513       } else if (isX(p)) {
1514         ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
1515       } else if (pr) {
1516         debug("replaceTilde pr", pr);
1517         ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
1518       } else {
1519         ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
1520       }
1521       debug("tilde return", ret);
1522       return ret;
1523     });
1524   };
1525   var replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((comp2) => {
1526     return replaceCaret(comp2, options);
1527   }).join(" ");
1528   var replaceCaret = (comp, options) => {
1529     debug("caret", comp, options);
1530     const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
1531     const z = options.includePrerelease ? "-0" : "";
1532     return comp.replace(r, (_, M, m, p, pr) => {
1533       debug("caret", comp, _, M, m, p, pr);
1534       let ret;
1535       if (isX(M)) {
1536         ret = "";
1537       } else if (isX(m)) {
1538         ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
1539       } else if (isX(p)) {
1540         if (M === "0") {
1541           ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
1542         } else {
1543           ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
1544         }
1545       } else if (pr) {
1546         debug("replaceCaret pr", pr);
1547         if (M === "0") {
1548           if (m === "0") {
1549             ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
1550           } else {
1551             ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
1552           }
1553         } else {
1554           ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
1555         }
1556       } else {
1557         debug("no pr");
1558         if (M === "0") {
1559           if (m === "0") {
1560             ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
1561           } else {
1562             ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
1563           }
1564         } else {
1565           ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
1566         }
1567       }
1568       debug("caret return", ret);
1569       return ret;
1570     });
1571   };
1572   var replaceXRanges = (comp, options) => {
1573     debug("replaceXRanges", comp, options);
1574     return comp.split(/\s+/).map((comp2) => {
1575       return replaceXRange(comp2, options);
1576     }).join(" ");
1577   };
1578   var replaceXRange = (comp, options) => {
1579     comp = comp.trim();
1580     const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
1581     return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
1582       debug("xRange", comp, ret, gtlt, M, m, p, pr);
1583       const xM = isX(M);
1584       const xm = xM || isX(m);
1585       const xp = xm || isX(p);
1586       const anyX = xp;
1587       if (gtlt === "=" && anyX) {
1588         gtlt = "";
1589       }
1590       pr = options.includePrerelease ? "-0" : "";
1591       if (xM) {
1592         if (gtlt === ">" || gtlt === "<") {
1593           ret = "<0.0.0-0";
1594         } else {
1595           ret = "*";
1596         }
1597       } else if (gtlt && anyX) {
1598         if (xm) {
1599           m = 0;
1600         }
1601         p = 0;
1602         if (gtlt === ">") {
1603           gtlt = ">=";
1604           if (xm) {
1605             M = +M + 1;
1606             m = 0;
1607             p = 0;
1608           } else {
1609             m = +m + 1;
1610             p = 0;
1611           }
1612         } else if (gtlt === "<=") {
1613           gtlt = "<";
1614           if (xm) {
1615             M = +M + 1;
1616           } else {
1617             m = +m + 1;
1618           }
1619         }
1620         if (gtlt === "<")
1621           pr = "-0";
1622         ret = `${gtlt + M}.${m}.${p}${pr}`;
1623       } else if (xm) {
1624         ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
1625       } else if (xp) {
1626         ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
1627       }
1628       debug("xRange return", ret);
1629       return ret;
1630     });
1631   };
1632   var replaceStars = (comp, options) => {
1633     debug("replaceStars", comp, options);
1634     return comp.trim().replace(re[t.STAR], "");
1635   };
1636   var replaceGTE0 = (comp, options) => {
1637     debug("replaceGTE0", comp, options);
1638     return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
1639   };
1640   var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
1641     if (isX(fM)) {
1642       from = "";
1643     } else if (isX(fm)) {
1644       from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
1645     } else if (isX(fp)) {
1646       from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
1647     } else if (fpr) {
1648       from = `>=${from}`;
1649     } else {
1650       from = `>=${from}${incPr ? "-0" : ""}`;
1651     }
1652     if (isX(tM)) {
1653       to = "";
1654     } else if (isX(tm)) {
1655       to = `<${+tM + 1}.0.0-0`;
1656     } else if (isX(tp)) {
1657       to = `<${tM}.${+tm + 1}.0-0`;
1658     } else if (tpr) {
1659       to = `<=${tM}.${tm}.${tp}-${tpr}`;
1660     } else if (incPr) {
1661       to = `<${tM}.${tm}.${+tp + 1}-0`;
1662     } else {
1663       to = `<=${to}`;
1664     }
1665     return `${from} ${to}`.trim();
1666   };
1667   var testSet = (set, version, options) => {
1668     for (let i = 0; i < set.length; i++) {
1669       if (!set[i].test(version)) {
1670         return false;
1671       }
1672     }
1673     if (version.prerelease.length && !options.includePrerelease) {
1674       for (let i = 0; i < set.length; i++) {
1675         debug(set[i].semver);
1676         if (set[i].semver === Comparator.ANY) {
1677           continue;
1678         }
1679         if (set[i].semver.prerelease.length > 0) {
1680           const allowed = set[i].semver;
1681           if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
1682             return true;
1683           }
1684         }
1685       }
1686       return false;
1687     }
1688     return true;
1689   };
1690 });
1691
1692 // node_modules/semver/classes/comparator.js
1693 var require_comparator = __commonJS((exports2, module2) => {
1694   var ANY = Symbol("SemVer ANY");
1695   var Comparator = class {
1696     static get ANY() {
1697       return ANY;
1698     }
1699     constructor(comp, options) {
1700       options = parseOptions(options);
1701       if (comp instanceof Comparator) {
1702         if (comp.loose === !!options.loose) {
1703           return comp;
1704         } else {
1705           comp = comp.value;
1706         }
1707       }
1708       debug("comparator", comp, options);
1709       this.options = options;
1710       this.loose = !!options.loose;
1711       this.parse(comp);
1712       if (this.semver === ANY) {
1713         this.value = "";
1714       } else {
1715         this.value = this.operator + this.semver.version;
1716       }
1717       debug("comp", this);
1718     }
1719     parse(comp) {
1720       const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
1721       const m = comp.match(r);
1722       if (!m) {
1723         throw new TypeError(`Invalid comparator: ${comp}`);
1724       }
1725       this.operator = m[1] !== void 0 ? m[1] : "";
1726       if (this.operator === "=") {
1727         this.operator = "";
1728       }
1729       if (!m[2]) {
1730         this.semver = ANY;
1731       } else {
1732         this.semver = new SemVer(m[2], this.options.loose);
1733       }
1734     }
1735     toString() {
1736       return this.value;
1737     }
1738     test(version) {
1739       debug("Comparator.test", version, this.options.loose);
1740       if (this.semver === ANY || version === ANY) {
1741         return true;
1742       }
1743       if (typeof version === "string") {
1744         try {
1745           version = new SemVer(version, this.options);
1746         } catch (er) {
1747           return false;
1748         }
1749       }
1750       return cmp(version, this.operator, this.semver, this.options);
1751     }
1752     intersects(comp, options) {
1753       if (!(comp instanceof Comparator)) {
1754         throw new TypeError("a Comparator is required");
1755       }
1756       if (!options || typeof options !== "object") {
1757         options = {
1758           loose: !!options,
1759           includePrerelease: false
1760         };
1761       }
1762       if (this.operator === "") {
1763         if (this.value === "") {
1764           return true;
1765         }
1766         return new Range2(comp.value, options).test(this.value);
1767       } else if (comp.operator === "") {
1768         if (comp.value === "") {
1769           return true;
1770         }
1771         return new Range2(this.value, options).test(comp.semver);
1772       }
1773       const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
1774       const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
1775       const sameSemVer = this.semver.version === comp.semver.version;
1776       const differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
1777       const oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
1778       const oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
1779       return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
1780     }
1781   };
1782   module2.exports = Comparator;
1783   var parseOptions = require_parse_options();
1784   var {re, t} = require_re();
1785   var cmp = require_cmp();
1786   var debug = require_debug();
1787   var SemVer = require_semver();
1788   var Range2 = require_range();
1789 });
1790
1791 // node_modules/semver/functions/satisfies.js
1792 var require_satisfies = __commonJS((exports2, module2) => {
1793   var Range2 = require_range();
1794   var satisfies = (version, range, options) => {
1795     try {
1796       range = new Range2(range, options);
1797     } catch (er) {
1798       return false;
1799     }
1800     return range.test(version);
1801   };
1802   module2.exports = satisfies;
1803 });
1804
1805 // node_modules/semver/ranges/to-comparators.js
1806 var require_to_comparators = __commonJS((exports2, module2) => {
1807   var Range2 = require_range();
1808   var toComparators = (range, options) => new Range2(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
1809   module2.exports = toComparators;
1810 });
1811
1812 // node_modules/semver/ranges/max-satisfying.js
1813 var require_max_satisfying = __commonJS((exports2, module2) => {
1814   var SemVer = require_semver();
1815   var Range2 = require_range();
1816   var maxSatisfying = (versions, range, options) => {
1817     let max = null;
1818     let maxSV = null;
1819     let rangeObj = null;
1820     try {
1821       rangeObj = new Range2(range, options);
1822     } catch (er) {
1823       return null;
1824     }
1825     versions.forEach((v) => {
1826       if (rangeObj.test(v)) {
1827         if (!max || maxSV.compare(v) === -1) {
1828           max = v;
1829           maxSV = new SemVer(max, options);
1830         }
1831       }
1832     });
1833     return max;
1834   };
1835   module2.exports = maxSatisfying;
1836 });
1837
1838 // node_modules/semver/ranges/min-satisfying.js
1839 var require_min_satisfying = __commonJS((exports2, module2) => {
1840   var SemVer = require_semver();
1841   var Range2 = require_range();
1842   var minSatisfying = (versions, range, options) => {
1843     let min = null;
1844     let minSV = null;
1845     let rangeObj = null;
1846     try {
1847       rangeObj = new Range2(range, options);
1848     } catch (er) {
1849       return null;
1850     }
1851     versions.forEach((v) => {
1852       if (rangeObj.test(v)) {
1853         if (!min || minSV.compare(v) === 1) {
1854           min = v;
1855           minSV = new SemVer(min, options);
1856         }
1857       }
1858     });
1859     return min;
1860   };
1861   module2.exports = minSatisfying;
1862 });
1863
1864 // node_modules/semver/ranges/min-version.js
1865 var require_min_version = __commonJS((exports2, module2) => {
1866   var SemVer = require_semver();
1867   var Range2 = require_range();
1868   var gt = require_gt();
1869   var minVersion = (range, loose) => {
1870     range = new Range2(range, loose);
1871     let minver = new SemVer("0.0.0");
1872     if (range.test(minver)) {
1873       return minver;
1874     }
1875     minver = new SemVer("0.0.0-0");
1876     if (range.test(minver)) {
1877       return minver;
1878     }
1879     minver = null;
1880     for (let i = 0; i < range.set.length; ++i) {
1881       const comparators = range.set[i];
1882       let setMin = null;
1883       comparators.forEach((comparator) => {
1884         const compver = new SemVer(comparator.semver.version);
1885         switch (comparator.operator) {
1886           case ">":
1887             if (compver.prerelease.length === 0) {
1888               compver.patch++;
1889             } else {
1890               compver.prerelease.push(0);
1891             }
1892             compver.raw = compver.format();
1893           case "":
1894           case ">=":
1895             if (!setMin || gt(compver, setMin)) {
1896               setMin = compver;
1897             }
1898             break;
1899           case "<":
1900           case "<=":
1901             break;
1902           default:
1903             throw new Error(`Unexpected operation: ${comparator.operator}`);
1904         }
1905       });
1906       if (setMin && (!minver || gt(minver, setMin)))
1907         minver = setMin;
1908     }
1909     if (minver && range.test(minver)) {
1910       return minver;
1911     }
1912     return null;
1913   };
1914   module2.exports = minVersion;
1915 });
1916
1917 // node_modules/semver/ranges/valid.js
1918 var require_valid2 = __commonJS((exports2, module2) => {
1919   var Range2 = require_range();
1920   var validRange = (range, options) => {
1921     try {
1922       return new Range2(range, options).range || "*";
1923     } catch (er) {
1924       return null;
1925     }
1926   };
1927   module2.exports = validRange;
1928 });
1929
1930 // node_modules/semver/ranges/outside.js
1931 var require_outside = __commonJS((exports2, module2) => {
1932   var SemVer = require_semver();
1933   var Comparator = require_comparator();
1934   var {ANY} = Comparator;
1935   var Range2 = require_range();
1936   var satisfies = require_satisfies();
1937   var gt = require_gt();
1938   var lt = require_lt();
1939   var lte = require_lte();
1940   var gte = require_gte();
1941   var outside = (version, range, hilo, options) => {
1942     version = new SemVer(version, options);
1943     range = new Range2(range, options);
1944     let gtfn, ltefn, ltfn, comp, ecomp;
1945     switch (hilo) {
1946       case ">":
1947         gtfn = gt;
1948         ltefn = lte;
1949         ltfn = lt;
1950         comp = ">";
1951         ecomp = ">=";
1952         break;
1953       case "<":
1954         gtfn = lt;
1955         ltefn = gte;
1956         ltfn = gt;
1957         comp = "<";
1958         ecomp = "<=";
1959         break;
1960       default:
1961         throw new TypeError('Must provide a hilo val of "<" or ">"');
1962     }
1963     if (satisfies(version, range, options)) {
1964       return false;
1965     }
1966     for (let i = 0; i < range.set.length; ++i) {
1967       const comparators = range.set[i];
1968       let high = null;
1969       let low = null;
1970       comparators.forEach((comparator) => {
1971         if (comparator.semver === ANY) {
1972           comparator = new Comparator(">=0.0.0");
1973         }
1974         high = high || comparator;
1975         low = low || comparator;
1976         if (gtfn(comparator.semver, high.semver, options)) {
1977           high = comparator;
1978         } else if (ltfn(comparator.semver, low.semver, options)) {
1979           low = comparator;
1980         }
1981       });
1982       if (high.operator === comp || high.operator === ecomp) {
1983         return false;
1984       }
1985       if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
1986         return false;
1987       } else if (low.operator === ecomp && ltfn(version, low.semver)) {
1988         return false;
1989       }
1990     }
1991     return true;
1992   };
1993   module2.exports = outside;
1994 });
1995
1996 // node_modules/semver/ranges/gtr.js
1997 var require_gtr = __commonJS((exports2, module2) => {
1998   var outside = require_outside();
1999   var gtr = (version, range, options) => outside(version, range, ">", options);
2000   module2.exports = gtr;
2001 });
2002
2003 // node_modules/semver/ranges/ltr.js
2004 var require_ltr = __commonJS((exports2, module2) => {
2005   var outside = require_outside();
2006   var ltr = (version, range, options) => outside(version, range, "<", options);
2007   module2.exports = ltr;
2008 });
2009
2010 // node_modules/semver/ranges/intersects.js
2011 var require_intersects = __commonJS((exports2, module2) => {
2012   var Range2 = require_range();
2013   var intersects = (r1, r2, options) => {
2014     r1 = new Range2(r1, options);
2015     r2 = new Range2(r2, options);
2016     return r1.intersects(r2);
2017   };
2018   module2.exports = intersects;
2019 });
2020
2021 // node_modules/semver/ranges/simplify.js
2022 var require_simplify = __commonJS((exports2, module2) => {
2023   var satisfies = require_satisfies();
2024   var compare = require_compare();
2025   module2.exports = (versions, range, options) => {
2026     const set = [];
2027     let min = null;
2028     let prev = null;
2029     const v = versions.sort((a, b) => compare(a, b, options));
2030     for (const version of v) {
2031       const included = satisfies(version, range, options);
2032       if (included) {
2033         prev = version;
2034         if (!min)
2035           min = version;
2036       } else {
2037         if (prev) {
2038           set.push([min, prev]);
2039         }
2040         prev = null;
2041         min = null;
2042       }
2043     }
2044     if (min)
2045       set.push([min, null]);
2046     const ranges = [];
2047     for (const [min2, max] of set) {
2048       if (min2 === max)
2049         ranges.push(min2);
2050       else if (!max && min2 === v[0])
2051         ranges.push("*");
2052       else if (!max)
2053         ranges.push(`>=${min2}`);
2054       else if (min2 === v[0])
2055         ranges.push(`<=${max}`);
2056       else
2057         ranges.push(`${min2} - ${max}`);
2058     }
2059     const simplified = ranges.join(" || ");
2060     const original = typeof range.raw === "string" ? range.raw : String(range);
2061     return simplified.length < original.length ? simplified : range;
2062   };
2063 });
2064
2065 // node_modules/semver/ranges/subset.js
2066 var require_subset = __commonJS((exports2, module2) => {
2067   var Range2 = require_range();
2068   var {ANY} = require_comparator();
2069   var satisfies = require_satisfies();
2070   var compare = require_compare();
2071   var subset = (sub, dom, options) => {
2072     if (sub === dom)
2073       return true;
2074     sub = new Range2(sub, options);
2075     dom = new Range2(dom, options);
2076     let sawNonNull = false;
2077     OUTER:
2078       for (const simpleSub of sub.set) {
2079         for (const simpleDom of dom.set) {
2080           const isSub = simpleSubset(simpleSub, simpleDom, options);
2081           sawNonNull = sawNonNull || isSub !== null;
2082           if (isSub)
2083             continue OUTER;
2084         }
2085         if (sawNonNull)
2086           return false;
2087       }
2088     return true;
2089   };
2090   var simpleSubset = (sub, dom, options) => {
2091     if (sub === dom)
2092       return true;
2093     if (sub.length === 1 && sub[0].semver === ANY)
2094       return dom.length === 1 && dom[0].semver === ANY;
2095     const eqSet = new Set();
2096     let gt, lt;
2097     for (const c of sub) {
2098       if (c.operator === ">" || c.operator === ">=")
2099         gt = higherGT(gt, c, options);
2100       else if (c.operator === "<" || c.operator === "<=")
2101         lt = lowerLT(lt, c, options);
2102       else
2103         eqSet.add(c.semver);
2104     }
2105     if (eqSet.size > 1)
2106       return null;
2107     let gtltComp;
2108     if (gt && lt) {
2109       gtltComp = compare(gt.semver, lt.semver, options);
2110       if (gtltComp > 0)
2111         return null;
2112       else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<="))
2113         return null;
2114     }
2115     for (const eq of eqSet) {
2116       if (gt && !satisfies(eq, String(gt), options))
2117         return null;
2118       if (lt && !satisfies(eq, String(lt), options))
2119         return null;
2120       for (const c of dom) {
2121         if (!satisfies(eq, String(c), options))
2122           return false;
2123       }
2124       return true;
2125     }
2126     let higher, lower;
2127     let hasDomLT, hasDomGT;
2128     for (const c of dom) {
2129       hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
2130       hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
2131       if (gt) {
2132         if (c.operator === ">" || c.operator === ">=") {
2133           higher = higherGT(gt, c, options);
2134           if (higher === c && higher !== gt)
2135             return false;
2136         } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options))
2137           return false;
2138       }
2139       if (lt) {
2140         if (c.operator === "<" || c.operator === "<=") {
2141           lower = lowerLT(lt, c, options);
2142           if (lower === c && lower !== lt)
2143             return false;
2144         } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options))
2145           return false;
2146       }
2147       if (!c.operator && (lt || gt) && gtltComp !== 0)
2148         return false;
2149     }
2150     if (gt && hasDomLT && !lt && gtltComp !== 0)
2151       return false;
2152     if (lt && hasDomGT && !gt && gtltComp !== 0)
2153       return false;
2154     return true;
2155   };
2156   var higherGT = (a, b, options) => {
2157     if (!a)
2158       return b;
2159     const comp = compare(a.semver, b.semver, options);
2160     return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
2161   };
2162   var lowerLT = (a, b, options) => {
2163     if (!a)
2164       return b;
2165     const comp = compare(a.semver, b.semver, options);
2166     return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
2167   };
2168   module2.exports = subset;
2169 });
2170
2171 // node_modules/semver/index.js
2172 var require_semver2 = __commonJS((exports2, module2) => {
2173   var internalRe = require_re();
2174   module2.exports = {
2175     re: internalRe.re,
2176     src: internalRe.src,
2177     tokens: internalRe.t,
2178     SEMVER_SPEC_VERSION: require_constants().SEMVER_SPEC_VERSION,
2179     SemVer: require_semver(),
2180     compareIdentifiers: require_identifiers().compareIdentifiers,
2181     rcompareIdentifiers: require_identifiers().rcompareIdentifiers,
2182     parse: require_parse(),
2183     valid: require_valid(),
2184     clean: require_clean(),
2185     inc: require_inc(),
2186     diff: require_diff(),
2187     major: require_major(),
2188     minor: require_minor(),
2189     patch: require_patch(),
2190     prerelease: require_prerelease(),
2191     compare: require_compare(),
2192     rcompare: require_rcompare(),
2193     compareLoose: require_compare_loose(),
2194     compareBuild: require_compare_build(),
2195     sort: require_sort(),
2196     rsort: require_rsort(),
2197     gt: require_gt(),
2198     lt: require_lt(),
2199     eq: require_eq(),
2200     neq: require_neq(),
2201     gte: require_gte(),
2202     lte: require_lte(),
2203     cmp: require_cmp(),
2204     coerce: require_coerce(),
2205     Comparator: require_comparator(),
2206     Range: require_range(),
2207     satisfies: require_satisfies(),
2208     toComparators: require_to_comparators(),
2209     maxSatisfying: require_max_satisfying(),
2210     minSatisfying: require_min_satisfying(),
2211     minVersion: require_min_version(),
2212     validRange: require_valid2(),
2213     outside: require_outside(),
2214     gtr: require_gtr(),
2215     ltr: require_ltr(),
2216     intersects: require_intersects(),
2217     simplifyRange: require_simplify(),
2218     subset: require_subset()
2219   };
2220 });
2221
2222 // node_modules/ignore/index.js
2223 var require_ignore = __commonJS((exports2, module2) => {
2224   function makeArray(subject) {
2225     return Array.isArray(subject) ? subject : [subject];
2226   }
2227   var EMPTY = "";
2228   var SPACE = " ";
2229   var ESCAPE = "\\";
2230   var REGEX_TEST_BLANK_LINE = /^\s+$/;
2231   var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
2232   var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
2233   var REGEX_SPLITALL_CRLF = /\r?\n/g;
2234   var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
2235   var SLASH = "/";
2236   var KEY_IGNORE = typeof Symbol !== "undefined" ? Symbol.for("node-ignore") : "node-ignore";
2237   var define = (object, key, value) => Object.defineProperty(object, key, {value});
2238   var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
2239   var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
2240   var cleanRangeBackSlash = (slashes) => {
2241     const {length} = slashes;
2242     return slashes.slice(0, length - length % 2);
2243   };
2244   var REPLACERS = [
2245     [
2246       /\\?\s+$/,
2247       (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
2248     ],
2249     [
2250       /\\\s/g,
2251       () => SPACE
2252     ],
2253     [
2254       /[\\$.|*+(){^]/g,
2255       (match) => `\\${match}`
2256     ],
2257     [
2258       /(?!\\)\?/g,
2259       () => "[^/]"
2260     ],
2261     [
2262       /^\//,
2263       () => "^"
2264     ],
2265     [
2266       /\//g,
2267       () => "\\/"
2268     ],
2269     [
2270       /^\^*\\\*\\\*\\\//,
2271       () => "^(?:.*\\/)?"
2272     ],
2273     [
2274       /^(?=[^^])/,
2275       function startingReplacer() {
2276         return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
2277       }
2278     ],
2279     [
2280       /\\\/\\\*\\\*(?=\\\/|$)/g,
2281       (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
2282     ],
2283     [
2284       /(^|[^\\]+)\\\*(?=.+)/g,
2285       (_, p1) => `${p1}[^\\/]*`
2286     ],
2287     [
2288       /\\\\\\(?=[$.|*+(){^])/g,
2289       () => ESCAPE
2290     ],
2291     [
2292       /\\\\/g,
2293       () => ESCAPE
2294     ],
2295     [
2296       /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
2297       (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
2298     ],
2299     [
2300       /(?:[^*])$/,
2301       (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
2302     ],
2303     [
2304       /(\^|\\\/)?\\\*$/,
2305       (_, p1) => {
2306         const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
2307         return `${prefix}(?=$|\\/$)`;
2308       }
2309     ]
2310   ];
2311   var regexCache = Object.create(null);
2312   var makeRegex = (pattern, negative, ignorecase) => {
2313     const r = regexCache[pattern];
2314     if (r) {
2315       return r;
2316     }
2317     const source = REPLACERS.reduce((prev, current) => prev.replace(current[0], current[1].bind(pattern)), pattern);
2318     return regexCache[pattern] = ignorecase ? new RegExp(source, "i") : new RegExp(source);
2319   };
2320   var isString = (subject) => typeof subject === "string";
2321   var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && pattern.indexOf("#") !== 0;
2322   var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
2323   var IgnoreRule = class {
2324     constructor(origin, pattern, negative, regex) {
2325       this.origin = origin;
2326       this.pattern = pattern;
2327       this.negative = negative;
2328       this.regex = regex;
2329     }
2330   };
2331   var createRule = (pattern, ignorecase) => {
2332     const origin = pattern;
2333     let negative = false;
2334     if (pattern.indexOf("!") === 0) {
2335       negative = true;
2336       pattern = pattern.substr(1);
2337     }
2338     pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
2339     const regex = makeRegex(pattern, negative, ignorecase);
2340     return new IgnoreRule(origin, pattern, negative, regex);
2341   };
2342   var throwError = (message, Ctor) => {
2343     throw new Ctor(message);
2344   };
2345   var checkPath = (path5, originalPath, doThrow) => {
2346     if (!isString(path5)) {
2347       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
2348     }
2349     if (!path5) {
2350       return doThrow(`path must not be empty`, TypeError);
2351     }
2352     if (checkPath.isNotRelative(path5)) {
2353       const r = "`path.relative()`d";
2354       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
2355     }
2356     return true;
2357   };
2358   var isNotRelative = (path5) => REGEX_TEST_INVALID_PATH.test(path5);
2359   checkPath.isNotRelative = isNotRelative;
2360   checkPath.convert = (p) => p;
2361   var Ignore = class {
2362     constructor({
2363       ignorecase = true
2364     } = {}) {
2365       this._rules = [];
2366       this._ignorecase = ignorecase;
2367       define(this, KEY_IGNORE, true);
2368       this._initCache();
2369     }
2370     _initCache() {
2371       this._ignoreCache = Object.create(null);
2372       this._testCache = Object.create(null);
2373     }
2374     _addPattern(pattern) {
2375       if (pattern && pattern[KEY_IGNORE]) {
2376         this._rules = this._rules.concat(pattern._rules);
2377         this._added = true;
2378         return;
2379       }
2380       if (checkPattern(pattern)) {
2381         const rule = createRule(pattern, this._ignorecase);
2382         this._added = true;
2383         this._rules.push(rule);
2384       }
2385     }
2386     add(pattern) {
2387       this._added = false;
2388       makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this);
2389       if (this._added) {
2390         this._initCache();
2391       }
2392       return this;
2393     }
2394     addPattern(pattern) {
2395       return this.add(pattern);
2396     }
2397     _testOne(path5, checkUnignored) {
2398       let ignored = false;
2399       let unignored = false;
2400       this._rules.forEach((rule) => {
2401         const {negative} = rule;
2402         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
2403           return;
2404         }
2405         const matched = rule.regex.test(path5);
2406         if (matched) {
2407           ignored = !negative;
2408           unignored = negative;
2409         }
2410       });
2411       return {
2412         ignored,
2413         unignored
2414       };
2415     }
2416     _test(originalPath, cache, checkUnignored, slices) {
2417       const path5 = originalPath && checkPath.convert(originalPath);
2418       checkPath(path5, originalPath, throwError);
2419       return this._t(path5, cache, checkUnignored, slices);
2420     }
2421     _t(path5, cache, checkUnignored, slices) {
2422       if (path5 in cache) {
2423         return cache[path5];
2424       }
2425       if (!slices) {
2426         slices = path5.split(SLASH);
2427       }
2428       slices.pop();
2429       if (!slices.length) {
2430         return cache[path5] = this._testOne(path5, checkUnignored);
2431       }
2432       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
2433       return cache[path5] = parent.ignored ? parent : this._testOne(path5, checkUnignored);
2434     }
2435     ignores(path5) {
2436       return this._test(path5, this._ignoreCache, false).ignored;
2437     }
2438     createFilter() {
2439       return (path5) => !this.ignores(path5);
2440     }
2441     filter(paths) {
2442       return makeArray(paths).filter(this.createFilter());
2443     }
2444     test(path5) {
2445       return this._test(path5, this._testCache, true);
2446     }
2447   };
2448   var factory = (options) => new Ignore(options);
2449   var returnFalse = () => false;
2450   var isPathValid = (path5) => checkPath(path5 && checkPath.convert(path5), path5, returnFalse);
2451   factory.isPathValid = isPathValid;
2452   factory.default = factory;
2453   module2.exports = factory;
2454   if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
2455     const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
2456     checkPath.convert = makePosix;
2457     const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
2458     checkPath.isNotRelative = (path5) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path5) || isNotRelative(path5);
2459   }
2460 });
2461
2462 // src/index.ts
2463 __markAsModule(exports);
2464 __export(exports, {
2465   activate: () => activate
2466 });
2467 var import_coc6 = __toModule(require("coc.nvim"));
2468
2469 // src/configCacheHandler.ts
2470 var import_coc = __toModule(require("coc.nvim"));
2471 var prettier = require("prettier");
2472 var PRETTIER_CONFIG_FILES = [
2473   ".prettierrc",
2474   ".prettierrc.json",
2475   ".prettierrc.yaml",
2476   ".prettierrc.yml",
2477   ".prettierrc.js",
2478   "package.json",
2479   "prettier.config.js"
2480 ];
2481 function fileListener() {
2482   const fileWatcher = import_coc.workspace.createFileSystemWatcher(`**/{${PRETTIER_CONFIG_FILES.join(",")}}`);
2483   fileWatcher.onDidChange(prettier.clearConfigCache);
2484   fileWatcher.onDidCreate(prettier.clearConfigCache);
2485   fileWatcher.onDidDelete(prettier.clearConfigCache);
2486   return fileWatcher;
2487 }
2488 var configCacheHandler_default = fileListener;
2489
2490 // src/errorHandler.ts
2491 var import_coc2 = __toModule(require("coc.nvim"));
2492 var outputChannel;
2493 function addFilePath(msg, fileName) {
2494   const lines = msg.split("\n");
2495   if (lines.length > 0) {
2496     lines[0] = lines[0].replace(/(\d*):(\d*)/g, `${fileName}:$1:$2`);
2497     return lines.join("\n");
2498   }
2499   return msg;
2500 }
2501 function addToOutput(message, type = "Trace") {
2502   if (!outputChannel)
2503     return;
2504   const title = `${type} - ${new Date().toLocaleString()}:`;
2505   outputChannel.appendLine("");
2506   outputChannel.appendLine(`[${title}] ${message}
2507 `);
2508 }
2509 function safeExecution(cb, defaultText, fileName) {
2510   if (cb instanceof Promise) {
2511     return cb.then((returnValue) => {
2512       return returnValue;
2513     }).catch((err) => {
2514       addToOutput(addFilePath(err.message, fileName), "Error");
2515       return defaultText;
2516     });
2517   }
2518   try {
2519     const returnValue = cb();
2520     return returnValue;
2521   } catch (err) {
2522     addToOutput(addFilePath(err.message, fileName), "Error");
2523     return defaultText;
2524   }
2525 }
2526 function setupErrorHandler() {
2527   outputChannel = import_coc2.window.createOutputChannel("prettier");
2528   return import_coc2.commands.registerCommand("prettier.open-output", () => {
2529     outputChannel.show();
2530   });
2531 }
2532
2533 // src/ignoreFileHandler.ts
2534 var import_coc4 = __toModule(require("coc.nvim"));
2535 var import_fs = __toModule(require("fs"));
2536 var path3 = __toModule(require("path"));
2537
2538 // src/utils.ts
2539 var import_coc3 = __toModule(require("coc.nvim"));
2540 var import_path2 = __toModule(require("path"));
2541
2542 // src/requirePkg.ts
2543 var import_resolve_from = __toModule(require_resolve_from());
2544 var import_path = __toModule(require("path"));
2545 function requireLocalPkg(fspath, pkgName, options = {silent: true, ignoreBundled: false}) {
2546   let modulePath = import_resolve_from.default.silent(fspath, pkgName);
2547   if (modulePath !== void 0) {
2548     try {
2549       return require(modulePath);
2550     } catch (e) {
2551       if (!options.silent) {
2552         addToOutput(`Failed to load require ${pkgName} from ${modulePath}.${options.ignoreBundled ? `` : ` Using bundled`}`, "Error");
2553       }
2554     }
2555   }
2556   if (options.ignoreBundled) {
2557     return null;
2558   }
2559   try {
2560     return require(pkgName);
2561   } catch (e) {
2562     addToOutput(`Failed to load ${pkgName} from ${import_path.default.dirname(__dirname)}`, "Error");
2563   }
2564   return null;
2565 }
2566
2567 // src/utils.ts
2568 var import_semver = __toModule(require_semver2());
2569 function getConfig(uri) {
2570   return import_coc3.workspace.getConfiguration("prettier", uri ? uri.toString() : void 0);
2571 }
2572 async function getPrettierInstance() {
2573   const document = await import_coc3.workspace.document;
2574   const uri = import_coc3.Uri.parse(document.uri);
2575   const fileName = uri.fsPath;
2576   const vscodeConfig = getConfig(uri);
2577   const localOnly = vscodeConfig.onlyUseLocalVersion;
2578   const resolvedPrettier = await requireLocalPkg(import_path2.default.dirname(fileName), "prettier", {silent: true, ignoreBundled: localOnly});
2579   if (!resolvedPrettier) {
2580     addToOutput(`Prettier module not found, prettier.onlyUseLocalVersion: ${vscodeConfig.onlyUseLocalVersion}`, "Error");
2581   }
2582   return resolvedPrettier;
2583 }
2584 function getParsersFromLanguageId(languageId, prettierInstance, path5) {
2585   const supportedLanguages = getSupportLanguages(prettierInstance);
2586   const language = supportedLanguages.find((lang) => Array.isArray(lang.vscodeLanguageIds) && lang.vscodeLanguageIds.includes(languageId) && (lang.extensions.length > 0 || path5 != null && lang.filenames != null && lang.filenames.includes(import_path2.basename(path5))));
2587   if (!language) {
2588     return [];
2589   }
2590   return language.parsers;
2591 }
2592 function allLanguages(prettierInstance) {
2593   const supportedLanguages = getSupportLanguages(prettierInstance);
2594   return supportedLanguages.reduce((ids, language) => [...ids, ...language.vscodeLanguageIds || []], []);
2595 }
2596 function enabledLanguages(prettierInstance) {
2597   const {disableLanguages} = getConfig();
2598   const languages2 = allLanguages(prettierInstance);
2599   return languages2.filter((x) => disableLanguages.indexOf(x) == -1);
2600 }
2601 function rangeLanguages() {
2602   const {disableLanguages} = getConfig();
2603   return [
2604     "javascript",
2605     "javascriptreact",
2606     "typescript",
2607     "typescriptreact",
2608     "json",
2609     "graphql"
2610   ].filter((x) => disableLanguages.indexOf(x) == -1);
2611 }
2612 function getSupportLanguages(prettierInstance) {
2613   if (import_semver.default.gte(prettierInstance.version, "2.0.0")) {
2614     return prettierInstance.getSupportInfo({
2615       showUnreleased: true
2616     }).languages;
2617   }
2618   return prettierInstance.getSupportInfo().languages;
2619 }
2620 function hasLocalPrettierInstalled(filePath) {
2621   const localPrettier = requireLocalPkg(filePath, "prettier", {
2622     silent: true,
2623     ignoreBundled: true
2624   });
2625   return localPrettier != null;
2626 }
2627
2628 // src/ignoreFileHandler.ts
2629 var ignore = require_ignore();
2630 var nullIgnorer = {ignores: () => false};
2631 function ignoreFileHandler(disposables) {
2632   const ignorers = new Map();
2633   disposables.push({dispose: () => ignorers.clear()});
2634   return {
2635     fileIsIgnored(filePath) {
2636       const {ignorer, ignoreFilePath} = getIgnorerForFile(filePath);
2637       return ignorer.ignores(path3.relative(path3.dirname(ignoreFilePath), filePath));
2638     }
2639   };
2640   function getIgnorerForFile(fsPath) {
2641     const absolutePath = getIgnorePathForFile(fsPath, getConfig(import_coc4.Uri.file(fsPath)).ignorePath);
2642     if (!absolutePath) {
2643       return {ignoreFilePath: "", ignorer: nullIgnorer};
2644     }
2645     if (!ignorers.has(absolutePath)) {
2646       loadIgnorer(import_coc4.Uri.file(absolutePath));
2647     }
2648     if (!import_fs.existsSync(absolutePath)) {
2649       const ignorePath = getConfig(import_coc4.Uri.file(fsPath)).ignorePath;
2650       if (ignorePath !== ".prettierignore") {
2651         addToOutput(`Wrong prettier.ignorePath provided in your settings. The path (${ignorePath}) does not exist.`, "Warning");
2652       }
2653       return {ignoreFilePath: "", ignorer: nullIgnorer};
2654     }
2655     return {
2656       ignoreFilePath: absolutePath,
2657       ignorer: ignorers.get(absolutePath)
2658     };
2659   }
2660   function loadIgnorer(ignoreUri) {
2661     let ignorer = nullIgnorer;
2662     if (!ignorers.has(ignoreUri.fsPath)) {
2663       const fileWatcher = import_coc4.workspace.createFileSystemWatcher(ignoreUri.fsPath);
2664       disposables.push(fileWatcher);
2665       fileWatcher.onDidCreate(loadIgnorer, null, disposables);
2666       fileWatcher.onDidChange(loadIgnorer, null, disposables);
2667       fileWatcher.onDidDelete(unloadIgnorer, null, disposables);
2668     }
2669     if (import_fs.existsSync(ignoreUri.fsPath)) {
2670       const ignoreFileContents = import_fs.readFileSync(ignoreUri.fsPath, "utf8");
2671       ignorer = ignore().add(ignoreFileContents);
2672     }
2673     ignorers.set(ignoreUri.fsPath, ignorer);
2674   }
2675   function unloadIgnorer(ignoreUri) {
2676     ignorers.set(ignoreUri.fsPath, nullIgnorer);
2677   }
2678 }
2679 function getIgnorePathForFile(_filePath, ignorePath) {
2680   if (!ignorePath) {
2681     return null;
2682   }
2683   if (import_coc4.workspace.workspaceFolder) {
2684     const folder = import_coc4.workspace.workspaceFolder;
2685     return folder ? getPath(ignorePath, import_coc4.Uri.parse(folder.uri).fsPath) : null;
2686   }
2687   return null;
2688 }
2689 function getPath(fsPath, relativeTo) {
2690   return path3.isAbsolute(fsPath) ? fsPath : path3.join(relativeTo, fsPath);
2691 }
2692 var ignoreFileHandler_default = ignoreFileHandler;
2693
2694 // src/PrettierEditProvider.ts
2695 var import_coc5 = __toModule(require("coc.nvim"));
2696 var import_path3 = __toModule(require("path"));
2697 var STYLE_PARSERS = ["postcss", "css", "less", "scss"];
2698 async function resolveConfig(filePath, options) {
2699   try {
2700     const localPrettier = await requireLocalPkg(import_path3.default.dirname(filePath), "prettier", {silent: true, ignoreBundled: true});
2701     let prettierInstance = localPrettier;
2702     if (!prettierInstance && !options.onlyUseLocalVersion) {
2703       prettierInstance = require("prettier");
2704     }
2705     const config = await prettierInstance.resolveConfig(filePath, options);
2706     return {config};
2707   } catch (error) {
2708     return {config: null, error};
2709   }
2710 }
2711 function mergeConfig(hasPrettierConfig, additionalConfig, prettierConfig, vscodeConfig) {
2712   return hasPrettierConfig ? Object.assign({
2713     parser: vscodeConfig.parser,
2714     filepath: vscodeConfig.filepath
2715   }, prettierConfig, additionalConfig) : Object.assign(vscodeConfig, prettierConfig, additionalConfig);
2716 }
2717 async function format(text, {languageId, uri}, customOptions) {
2718   let u = import_coc5.Uri.parse(uri);
2719   const isUntitled = u.scheme == "untitled";
2720   const fileName = u.fsPath;
2721   const vscodeConfig = getConfig(u);
2722   const localOnly = vscodeConfig.onlyUseLocalVersion;
2723   const resolvedPrettier = await getPrettierInstance();
2724   if (!resolvedPrettier) {
2725     addToOutput(`Prettier module not found, prettier.onlyUseLocalVersion: ${vscodeConfig.onlyUseLocalVersion}`, "Error");
2726     return;
2727   }
2728   let supportedLanguages = allLanguages(resolvedPrettier);
2729   if (supportedLanguages.indexOf(languageId) == -1) {
2730     import_coc5.window.showMessage(`${languageId} not supported by prettier`, "error");
2731     return;
2732   }
2733   const dynamicParsers = getParsersFromLanguageId(languageId, resolvedPrettier, isUntitled ? void 0 : fileName);
2734   let useBundled = false;
2735   let parser;
2736   if (!dynamicParsers.length) {
2737     const bundledParsers = getParsersFromLanguageId(languageId, require("prettier"), isUntitled ? void 0 : fileName);
2738     parser = bundledParsers[0] || "babylon";
2739     useBundled = true;
2740   } else if (dynamicParsers.includes(vscodeConfig.parser)) {
2741     parser = vscodeConfig.parser;
2742   } else {
2743     parser = dynamicParsers[0];
2744   }
2745   const doesParserSupportEslint = [
2746     "javascript",
2747     "javascriptreact",
2748     "typescript",
2749     "typescriptreact",
2750     "vue"
2751   ].includes(languageId);
2752   const {config: fileOptions, error} = await resolveConfig(fileName, {
2753     editorconfig: true,
2754     onlyUseLocalVersion: localOnly,
2755     requireConfig: vscodeConfig.requireConfig
2756   });
2757   const hasConfig = fileOptions != null;
2758   if (!hasConfig && vscodeConfig.requireConfig) {
2759     return text;
2760   }
2761   if (error) {
2762     addToOutput(`Failed to resolve config for ${fileName}. Falling back to the default config settings.`, "Error");
2763   }
2764   const prettierOptions = mergeConfig(hasConfig, customOptions, fileOptions || {}, {
2765     printWidth: vscodeConfig.printWidth,
2766     tabWidth: vscodeConfig.tabWidth,
2767     singleQuote: vscodeConfig.singleQuote,
2768     jsxSingleQuote: vscodeConfig.jsxSingleQuote,
2769     trailingComma: vscodeConfig.trailingComma,
2770     bracketSpacing: vscodeConfig.bracketSpacing,
2771     jsxBracketSameLine: vscodeConfig.jsxBracketSameLine,
2772     parser,
2773     semi: vscodeConfig.semi,
2774     useTabs: vscodeConfig.useTabs,
2775     proseWrap: vscodeConfig.proseWrap,
2776     arrowParens: vscodeConfig.arrowParens,
2777     filepath: fileName
2778   });
2779   if (vscodeConfig.tslintIntegration && parser === "typescript") {
2780     return safeExecution(() => {
2781       const prettierTslint = requireLocalPkg(u.fsPath, "prettier-tslint").format;
2782       return prettierTslint({
2783         text,
2784         filePath: fileName,
2785         fallbackPrettierOptions: prettierOptions
2786       });
2787     }, text, fileName);
2788   }
2789   if (vscodeConfig.eslintIntegration && doesParserSupportEslint) {
2790     return safeExecution(() => {
2791       const prettierEslint = requireLocalPkg(u.fsPath, "prettier-eslint");
2792       return prettierEslint({
2793         text,
2794         filePath: fileName,
2795         fallbackPrettierOptions: prettierOptions
2796       });
2797     }, text, fileName);
2798   }
2799   if (vscodeConfig.stylelintIntegration && STYLE_PARSERS.includes(parser)) {
2800     const prettierStylelint = requireLocalPkg(u.fsPath, "prettier-stylelint");
2801     return safeExecution(prettierStylelint.format({
2802       text,
2803       filePath: fileName,
2804       prettierOptions
2805     }), text, fileName);
2806   }
2807   if (!doesParserSupportEslint && useBundled) {
2808     let bundledPrettier = require("prettier");
2809     return safeExecution(() => {
2810       const warningMessage = `prettier@${bundledPrettier.version} doesn't support ${languageId}. Falling back to bundled prettier@${bundledPrettier.version}.`;
2811       addToOutput(warningMessage, "Warning");
2812       return bundledPrettier.format(text, prettierOptions);
2813     }, text, fileName);
2814   }
2815   return safeExecution(() => resolvedPrettier.format(text, prettierOptions), text, fileName);
2816 }
2817 function fullDocumentRange(document) {
2818   const lastLineId = document.lineCount - 1;
2819   let doc = import_coc5.workspace.getDocument(document.uri);
2820   return {
2821     start: {character: 0, line: 0},
2822     end: {character: doc.getline(lastLineId).length, line: lastLineId}
2823   };
2824 }
2825 var PrettierEditProvider = class {
2826   constructor(_fileIsIgnored) {
2827     this._fileIsIgnored = _fileIsIgnored;
2828   }
2829   provideDocumentRangeFormattingEdits(document, range, _options, _token) {
2830     return this._provideEdits(document, {
2831       rangeStart: document.offsetAt(range.start),
2832       rangeEnd: document.offsetAt(range.end)
2833     });
2834   }
2835   provideDocumentFormattingEdits(document, _options, _token) {
2836     return this._provideEdits(document, {});
2837   }
2838   async _provideEdits(document, options) {
2839     let fileName = import_coc5.Uri.parse(document.uri).fsPath;
2840     if (!document.uri.startsWith("untitled") && this._fileIsIgnored(fileName)) {
2841       return Promise.resolve([]);
2842     }
2843     const code = await format(document.getText(), document, options);
2844     const edits = [{
2845       range: fullDocumentRange(document),
2846       newText: code
2847     }];
2848     const {disableSuccessMessage} = getConfig();
2849     if (edits && edits.length && !disableSuccessMessage) {
2850       import_coc5.window.showMessage("Formatted by prettier");
2851     }
2852     addToOutput(`Formatted file: ${document.uri}`);
2853     addToOutput(`Prettier format edits: ${JSON.stringify(edits, null, 2)}`);
2854     return edits;
2855   }
2856 };
2857 var PrettierEditProvider_default = PrettierEditProvider;
2858
2859 // src/index.ts
2860 var formatterHandler;
2861 var rangeFormatterHandler;
2862 function disposeHandlers() {
2863   if (formatterHandler) {
2864     formatterHandler.dispose();
2865   }
2866   if (rangeFormatterHandler) {
2867     rangeFormatterHandler.dispose();
2868   }
2869   formatterHandler = void 0;
2870   rangeFormatterHandler = void 0;
2871 }
2872 function selectors(prettierInstance) {
2873   let languageSelector = enabledLanguages(prettierInstance).reduce((curr, language) => {
2874     return curr.concat([
2875       {language, scheme: "file"},
2876       {language, scheme: "untitled"}
2877     ]);
2878   }, []);
2879   let rangeLanguageSelector = rangeLanguages().reduce((curr, language) => {
2880     return curr.concat([
2881       {language, scheme: "file"},
2882       {language, scheme: "untitled"}
2883     ]);
2884   }, []);
2885   return {
2886     languageSelector,
2887     rangeLanguageSelector
2888   };
2889 }
2890 function wait(ms) {
2891   return new Promise((resolve) => {
2892     setTimeout(() => {
2893       resolve(void 0);
2894     }, ms);
2895   });
2896 }
2897 async function activate(context) {
2898   context.subscriptions.push(setupErrorHandler());
2899   const {fileIsIgnored} = ignoreFileHandler_default(context.subscriptions);
2900   const editProvider = new PrettierEditProvider_default(fileIsIgnored);
2901   const statusItem = import_coc6.window.createStatusBarItem(0);
2902   context.subscriptions.push(statusItem);
2903   const config = import_coc6.workspace.getConfiguration("prettier");
2904   statusItem.text = config.get("statusItemText", "Prettier");
2905   let priority = config.get("formatterPriority", 1);
2906   const prettierInstance = await getPrettierInstance();
2907   if (!prettierInstance)
2908     return;
2909   async function checkDocument() {
2910     await wait(30);
2911     let doc = import_coc6.workspace.getDocument(import_coc6.workspace.bufnr);
2912     let languageIds = enabledLanguages(prettierInstance);
2913     if (doc && languageIds.indexOf(doc.filetype) !== -1) {
2914       statusItem.show();
2915     } else {
2916       statusItem.hide();
2917     }
2918   }
2919   function registerFormatter() {
2920     disposeHandlers();
2921     const {languageSelector, rangeLanguageSelector} = selectors(prettierInstance);
2922     rangeFormatterHandler = import_coc6.languages.registerDocumentRangeFormatProvider(rangeLanguageSelector, editProvider, priority);
2923     formatterHandler = import_coc6.languages.registerDocumentFormatProvider(languageSelector, editProvider, priority);
2924   }
2925   registerFormatter();
2926   checkDocument().catch((_e) => {
2927   });
2928   import_coc6.events.on("BufEnter", async () => {
2929     await checkDocument();
2930   }, null, context.subscriptions);
2931   context.subscriptions.push(configCacheHandler_default());
2932   context.subscriptions.push(import_coc6.commands.registerCommand("prettier.formatFile", async () => {
2933     let document = await import_coc6.workspace.document;
2934     let prettierConfig = import_coc6.workspace.getConfiguration("prettier", document.uri);
2935     let onlyUseLocalVersion = prettierConfig.get("onlyUseLocalVersion", false);
2936     if (onlyUseLocalVersion && (!hasLocalPrettierInstalled(import_coc6.Uri.parse(document.uri).fsPath) || document.schema != "file")) {
2937       import_coc6.window.showMessage(`Flag prettier.onlyUseLocalVersion is set, but prettier is not installed locally. No operation will be made.`, "warning");
2938       return;
2939     }
2940     let edits = await format(document.content, document.textDocument, {}).then((code) => {
2941       if (code == null)
2942         return null;
2943       return [{
2944         range: fullDocumentRange(document.textDocument),
2945         newText: code
2946       }];
2947     });
2948     if (edits && edits.length) {
2949       await document.applyEdits(edits);
2950     }
2951   }));
2952 }
2953 //# sourceMappingURL=index.js.map