From ca548ccf8697bf60d35b0ff7c0488d82dc82557a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 22 Mar 2022 07:22:22 +0000 Subject: [PATCH 1/2] build(deps): bump hosted-git-info from 4.1.0 to 5.0.0 Bumps [hosted-git-info](https://github.com/npm/hosted-git-info) from 4.1.0 to 5.0.0. - [Release notes](https://github.com/npm/hosted-git-info/releases) - [Changelog](https://github.com/npm/hosted-git-info/blob/main/CHANGELOG.md) - [Commits](https://github.com/npm/hosted-git-info/compare/v4.1.0...v5.0.0) --- updated-dependencies: - dependency-name: hosted-git-info dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- package-lock.json | 129 +++++++++++++++++++++++++++++++++++++++++----- package.json | 2 +- 2 files changed, 118 insertions(+), 13 deletions(-) diff --git a/package-lock.json b/package-lock.json index 4abbe347..a58755af 100644 --- a/package-lock.json +++ b/package-lock.json @@ -12,7 +12,7 @@ "@actions/core": "^1.6.0", "@actions/exec": "^1.1.1", "@actions/github": "^5.0.0", - "hosted-git-info": "^4.1.0" + "hosted-git-info": "^5.0.0" }, "devDependencies": { "@types/hosted-git-info": "^3.0.2", @@ -3755,6 +3755,18 @@ "node": ">=4" } }, + "node_modules/conventional-changelog-core/node_modules/hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/conventional-changelog-core/node_modules/locate-path": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", @@ -6377,6 +6389,18 @@ "node": ">=6.9.0" } }, + "node_modules/get-pkg-repo/node_modules/hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/get-pkg-repo/node_modules/readable-stream": { "version": "2.3.7", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", @@ -6699,14 +6723,22 @@ } }, "node_modules/hosted-git-info": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", - "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-5.0.0.tgz", + "integrity": "sha512-rRnjWu0Bxj+nIfUOkz0695C0H6tRrN5iYIzYejb0tDEefe2AekHu/U5Kn9pEie5vsJqpNQU02az7TGSH3qpz4Q==", "dependencies": { - "lru-cache": "^6.0.0" + "lru-cache": "^7.5.1" }, "engines": { - "node": ">=10" + "node": "^12.13.0 || ^14.15.0 || >=16" + } + }, + "node_modules/hosted-git-info/node_modules/lru-cache": { + "version": "7.7.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.7.1.tgz", + "integrity": "sha512-cRffBiTW8s73eH4aTXqBcTLU0xQnwGV3/imttRHGWCrbergmnK4D6JXQd8qin5z43HnDwRI+o7mVW0LEB+tpAw==", + "engines": { + "node": ">=12" } }, "node_modules/html-encoding-sniffer": { @@ -9674,6 +9706,7 @@ "version": "6.0.0", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, "dependencies": { "yallist": "^4.0.0" }, @@ -10034,6 +10067,18 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/meow/node_modules/hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/meow/node_modules/normalize-package-data": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz", @@ -12546,6 +12591,18 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/remark-validate-links/node_modules/hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", @@ -14543,7 +14600,8 @@ "node_modules/yallist": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true }, "node_modules/yaml": { "version": "1.10.2", @@ -17504,6 +17562,15 @@ "locate-path": "^2.0.0" } }, + "hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, "locate-path": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", @@ -19372,6 +19439,15 @@ "yargs": "^16.2.0" }, "dependencies": { + "hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, "readable-stream": { "version": "2.3.7", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", @@ -19615,11 +19691,18 @@ } }, "hosted-git-info": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", - "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-5.0.0.tgz", + "integrity": "sha512-rRnjWu0Bxj+nIfUOkz0695C0H6tRrN5iYIzYejb0tDEefe2AekHu/U5Kn9pEie5vsJqpNQU02az7TGSH3qpz4Q==", "requires": { - "lru-cache": "^6.0.0" + "lru-cache": "^7.5.1" + }, + "dependencies": { + "lru-cache": { + "version": "7.7.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.7.1.tgz", + "integrity": "sha512-cRffBiTW8s73eH4aTXqBcTLU0xQnwGV3/imttRHGWCrbergmnK4D6JXQd8qin5z43HnDwRI+o7mVW0LEB+tpAw==" + } } }, "html-encoding-sniffer": { @@ -21820,6 +21903,7 @@ "version": "6.0.0", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, "requires": { "yallist": "^4.0.0" } @@ -22083,6 +22167,15 @@ "yargs-parser": "^20.2.3" }, "dependencies": { + "hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, "normalize-package-data": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz", @@ -23897,6 +23990,17 @@ "unified-engine": "^9.0.0", "unist-util-visit": "^4.0.0", "vfile": "^5.0.0" + }, + "dependencies": { + "hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + } } }, "require-directory": { @@ -25409,7 +25513,8 @@ "yallist": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true }, "yaml": { "version": "1.10.2", diff --git a/package.json b/package.json index 93cccc7a..820c320b 100644 --- a/package.json +++ b/package.json @@ -44,7 +44,7 @@ "@actions/core": "^1.6.0", "@actions/exec": "^1.1.1", "@actions/github": "^5.0.0", - "hosted-git-info": "^4.1.0" + "hosted-git-info": "^5.0.0" }, "devDependencies": { "@types/hosted-git-info": "^3.0.2", From 620afe87230eb474d53eeba685238043afda17df Mon Sep 17 00:00:00 2001 From: ybiquitous Date: Tue, 22 Mar 2022 07:25:10 +0000 Subject: [PATCH 2/2] build: update dist --- dist/index.cjs | 1227 +++++++++++++++++++++++++----------------------- 1 file changed, 634 insertions(+), 593 deletions(-) diff --git a/dist/index.cjs b/dist/index.cjs index 846656f7..2229a52c 100644 --- a/dist/index.cjs +++ b/dist/index.cjs @@ -2288,9 +2288,9 @@ var require_exec = __commonJS({ } }); -// node_modules/hosted-git-info/git-host-info.js +// node_modules/hosted-git-info/lib/git-host-info.js var require_git_host_info = __commonJS({ - "node_modules/hosted-git-info/git-host-info.js"(exports, module2) { + "node_modules/hosted-git-info/lib/git-host-info.js"(exports, module2) { "use strict"; var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : ""; var maybeEncode = (arg) => arg ? encodeURIComponent(arg) : ""; @@ -2448,9 +2448,9 @@ var require_git_host_info = __commonJS({ } }); -// node_modules/hosted-git-info/git-host.js +// node_modules/hosted-git-info/lib/git-host.js var require_git_host = __commonJS({ - "node_modules/hosted-git-info/git-host.js"(exports, module2) { + "node_modules/hosted-git-info/lib/git-host.js"(exports, module2) { "use strict"; var gitHosts = require_git_host_info(); var GitHost = class { @@ -2538,660 +2538,701 @@ var require_git_host = __commonJS({ } }); -// node_modules/yallist/iterator.js -var require_iterator = __commonJS({ - "node_modules/yallist/iterator.js"(exports, module2) { - "use strict"; - module2.exports = function(Yallist) { - Yallist.prototype[Symbol.iterator] = function* () { - for (let walker = this.head; walker; walker = walker.next) { - yield walker.value; - } - }; - }; - } -}); - -// node_modules/yallist/yallist.js -var require_yallist = __commonJS({ - "node_modules/yallist/yallist.js"(exports, module2) { - "use strict"; - module2.exports = Yallist; - Yallist.Node = Node; - Yallist.create = Yallist; - function Yallist(list) { - var self = this; - if (!(self instanceof Yallist)) { - self = new Yallist(); - } - self.tail = null; - self.head = null; - self.length = 0; - if (list && typeof list.forEach === "function") { - list.forEach(function(item) { - self.push(item); - }); - } else if (arguments.length > 0) { - for (var i = 0, l = arguments.length; i < l; i++) { - self.push(arguments[i]); - } - } - return self; - } - Yallist.prototype.removeNode = function(node) { - if (node.list !== this) { - throw new Error("removing node which does not belong to this list"); - } - var next = node.next; - var prev = node.prev; - if (next) { - next.prev = prev; - } - if (prev) { - prev.next = next; - } - if (node === this.head) { - this.head = next; - } - if (node === this.tail) { - this.tail = prev; - } - node.list.length--; - node.next = null; - node.prev = null; - node.list = null; - return next; - }; - Yallist.prototype.unshiftNode = function(node) { - if (node === this.head) { - return; - } - if (node.list) { - node.list.removeNode(node); - } - var head = this.head; - node.list = this; - node.next = head; - if (head) { - head.prev = node; - } - this.head = node; - if (!this.tail) { - this.tail = node; - } - this.length++; - }; - Yallist.prototype.pushNode = function(node) { - if (node === this.tail) { - return; - } - if (node.list) { - node.list.removeNode(node); - } - var tail = this.tail; - node.list = this; - node.prev = tail; - if (tail) { - tail.next = node; - } - this.tail = node; - if (!this.head) { - this.head = node; - } - this.length++; - }; - Yallist.prototype.push = function() { - for (var i = 0, l = arguments.length; i < l; i++) { - push(this, arguments[i]); - } - return this.length; - }; - Yallist.prototype.unshift = function() { - for (var i = 0, l = arguments.length; i < l; i++) { - unshift(this, arguments[i]); - } - return this.length; - }; - Yallist.prototype.pop = function() { - if (!this.tail) { - return void 0; - } - var res = this.tail.value; - this.tail = this.tail.prev; - if (this.tail) { - this.tail.next = null; - } else { - this.head = null; - } - this.length--; - return res; - }; - Yallist.prototype.shift = function() { - if (!this.head) { - return void 0; - } - var res = this.head.value; - this.head = this.head.next; - if (this.head) { - this.head.prev = null; - } else { - this.tail = null; - } - this.length--; - return res; - }; - Yallist.prototype.forEach = function(fn, thisp) { - thisp = thisp || this; - for (var walker = this.head, i = 0; walker !== null; i++) { - fn.call(thisp, walker.value, i, this); - walker = walker.next; - } - }; - Yallist.prototype.forEachReverse = function(fn, thisp) { - thisp = thisp || this; - for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { - fn.call(thisp, walker.value, i, this); - walker = walker.prev; - } - }; - Yallist.prototype.get = function(n) { - for (var i = 0, walker = this.head; walker !== null && i < n; i++) { - walker = walker.next; +// node_modules/hosted-git-info/node_modules/lru-cache/index.js +var require_lru_cache = __commonJS({ + "node_modules/hosted-git-info/node_modules/lru-cache/index.js"(exports, module2) { + var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date; + var hasAbortController = typeof AbortController !== "undefined"; + var AC = hasAbortController ? AbortController : Object.assign(class AbortController { + constructor() { + this.signal = new AC.AbortSignal(); } - if (i === n && walker !== null) { - return walker.value; + abort() { + this.signal.aborted = true; } - }; - Yallist.prototype.getReverse = function(n) { - for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { - walker = walker.prev; + }, { AbortSignal: class AbortSignal { + constructor() { + this.aborted = false; } - if (i === n && walker !== null) { - return walker.value; + } }); + var warned = /* @__PURE__ */ new Set(); + var deprecatedOption = (opt, instead) => { + const code = `LRU_CACHE_OPTION_${opt}`; + if (shouldWarn(code)) { + warn(code, `${opt} option`, `options.${instead}`, LRUCache); } }; - Yallist.prototype.map = function(fn, thisp) { - thisp = thisp || this; - var res = new Yallist(); - for (var walker = this.head; walker !== null; ) { - res.push(fn.call(thisp, walker.value, this)); - walker = walker.next; - } - return res; - }; - Yallist.prototype.mapReverse = function(fn, thisp) { - thisp = thisp || this; - var res = new Yallist(); - for (var walker = this.tail; walker !== null; ) { - res.push(fn.call(thisp, walker.value, this)); - walker = walker.prev; - } - return res; - }; - Yallist.prototype.reduce = function(fn, initial) { - var acc; - var walker = this.head; - if (arguments.length > 1) { - acc = initial; - } else if (this.head) { - walker = this.head.next; - acc = this.head.value; - } else { - throw new TypeError("Reduce of empty list with no initial value"); - } - for (var i = 0; walker !== null; i++) { - acc = fn(acc, walker.value, i); - walker = walker.next; + var deprecatedMethod = (method, instead) => { + const code = `LRU_CACHE_METHOD_${method}`; + if (shouldWarn(code)) { + const { prototype } = LRUCache; + const { get } = Object.getOwnPropertyDescriptor(prototype, method); + warn(code, `${method} method`, `cache.${instead}()`, get); } - return acc; }; - Yallist.prototype.reduceReverse = function(fn, initial) { - var acc; - var walker = this.tail; - if (arguments.length > 1) { - acc = initial; - } else if (this.tail) { - walker = this.tail.prev; - acc = this.tail.value; - } else { - throw new TypeError("Reduce of empty list with no initial value"); - } - for (var i = this.length - 1; walker !== null; i--) { - acc = fn(acc, walker.value, i); - walker = walker.prev; + var deprecatedProperty = (field, instead) => { + const code = `LRU_CACHE_PROPERTY_${field}`; + if (shouldWarn(code)) { + const { prototype } = LRUCache; + const { get } = Object.getOwnPropertyDescriptor(prototype, field); + warn(code, `${field} property`, `cache.${instead}`, get); } - return acc; }; - Yallist.prototype.toArray = function() { - var arr = new Array(this.length); - for (var i = 0, walker = this.head; walker !== null; i++) { - arr[i] = walker.value; - walker = walker.next; - } - return arr; + var shouldWarn = (code) => typeof process === "object" && process && !warned.has(code); + var warn = (code, what, instead, fn) => { + warned.add(code); + const msg = `The ${what} is deprecated. Please use ${instead} instead.`; + process.emitWarning(msg, "DeprecationWarning", code, fn); }; - Yallist.prototype.toArrayReverse = function() { - var arr = new Array(this.length); - for (var i = 0, walker = this.tail; walker !== null; i++) { - arr[i] = walker.value; - walker = walker.prev; + var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n); + var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null; + var ZeroArray = class extends Array { + constructor(size) { + super(size); + this.fill(0); } - return arr; }; - Yallist.prototype.slice = function(from, to) { - to = to || this.length; - if (to < 0) { - to += this.length; - } - from = from || 0; - if (from < 0) { - from += this.length; - } - var ret = new Yallist(); - if (to < from || to < 0) { - return ret; - } - if (from < 0) { - from = 0; + var Stack = class { + constructor(max) { + const UintArray = max ? getUintArray(max) : Array; + this.heap = new UintArray(max); + this.length = 0; } - if (to > this.length) { - to = this.length; + push(n) { + this.heap[this.length++] = n; } - for (var i = 0, walker = this.head; walker !== null && i < from; i++) { - walker = walker.next; - } - for (; walker !== null && i < to; i++, walker = walker.next) { - ret.push(walker.value); + pop() { + return this.heap[--this.length]; } - return ret; }; - Yallist.prototype.sliceReverse = function(from, to) { - to = to || this.length; - if (to < 0) { - to += this.length; - } - from = from || 0; - if (from < 0) { - from += this.length; + var LRUCache = class { + constructor(options = {}) { + const { + max = 0, + ttl, + ttlResolution = 1, + ttlAutopurge, + updateAgeOnGet, + allowStale, + dispose, + disposeAfter, + noDisposeOnSet, + noUpdateTTL, + maxSize = 0, + sizeCalculation, + fetchMethod + } = options; + const { + length, + maxAge, + stale + } = options instanceof LRUCache ? {} : options; + if (max !== 0 && !isPosInt(max)) { + throw new TypeError("max option must be a nonnegative integer"); + } + const UintArray = max ? getUintArray(max) : Array; + if (!UintArray) { + throw new Error("invalid max value: " + max); + } + this.max = max; + this.maxSize = maxSize; + this.sizeCalculation = sizeCalculation || length; + if (this.sizeCalculation) { + if (!this.maxSize) { + throw new TypeError("cannot set sizeCalculation without setting maxSize"); + } + if (typeof this.sizeCalculation !== "function") { + throw new TypeError("sizeCalculating set to non-function"); + } + } + this.fetchMethod = fetchMethod || null; + if (this.fetchMethod && typeof this.fetchMethod !== "function") { + throw new TypeError("fetchMethod must be a function if specified"); + } + this.keyMap = /* @__PURE__ */ new Map(); + this.keyList = new Array(max).fill(null); + this.valList = new Array(max).fill(null); + this.next = new UintArray(max); + this.prev = new UintArray(max); + this.head = 0; + this.tail = 0; + this.free = new Stack(max); + this.initialFill = 1; + this.size = 0; + if (typeof dispose === "function") { + this.dispose = dispose; + } + if (typeof disposeAfter === "function") { + this.disposeAfter = disposeAfter; + this.disposed = []; + } else { + this.disposeAfter = null; + this.disposed = null; + } + this.noDisposeOnSet = !!noDisposeOnSet; + this.noUpdateTTL = !!noUpdateTTL; + if (this.maxSize !== 0) { + if (!isPosInt(this.maxSize)) { + throw new TypeError("maxSize must be a positive integer if specified"); + } + this.initializeSizeTracking(); + } + this.allowStale = !!allowStale || !!stale; + this.updateAgeOnGet = !!updateAgeOnGet; + this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1; + this.ttlAutopurge = !!ttlAutopurge; + this.ttl = ttl || maxAge || 0; + if (this.ttl) { + if (!isPosInt(this.ttl)) { + throw new TypeError("ttl must be a positive integer if specified"); + } + this.initializeTTLTracking(); + } + if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) { + throw new TypeError("At least one of max, maxSize, or ttl is required"); + } + if (!this.ttlAutopurge && !this.max && !this.maxSize) { + const code = "LRU_CACHE_UNBOUNDED"; + if (shouldWarn(code)) { + warned.add(code); + const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption."; + process.emitWarning(msg, "UnboundedCacheWarning", code, LRUCache); + } + } + if (stale) { + deprecatedOption("stale", "allowStale"); + } + if (maxAge) { + deprecatedOption("maxAge", "ttl"); + } + if (length) { + deprecatedOption("length", "sizeCalculation"); + } + } + getRemainingTTL(key) { + return this.has(key) ? Infinity : 0; + } + initializeTTLTracking() { + this.ttls = new ZeroArray(this.max); + this.starts = new ZeroArray(this.max); + this.setItemTTL = (index, ttl) => { + this.starts[index] = ttl !== 0 ? perf.now() : 0; + this.ttls[index] = ttl; + if (ttl !== 0 && this.ttlAutopurge) { + const t = setTimeout(() => { + if (this.isStale(index)) { + this.delete(this.keyList[index]); + } + }, ttl + 1); + if (t.unref) { + t.unref(); + } + } + }; + this.updateItemAge = (index) => { + this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0; + }; + let cachedNow = 0; + const getNow = () => { + const n = perf.now(); + if (this.ttlResolution > 0) { + cachedNow = n; + const t = setTimeout(() => cachedNow = 0, this.ttlResolution); + if (t.unref) { + t.unref(); + } + } + return n; + }; + this.getRemainingTTL = (key) => { + const index = this.keyMap.get(key); + if (index === void 0) { + return 0; + } + return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity : this.starts[index] + this.ttls[index] - (cachedNow || getNow()); + }; + this.isStale = (index) => { + return this.ttls[index] !== 0 && this.starts[index] !== 0 && (cachedNow || getNow()) - this.starts[index] > this.ttls[index]; + }; } - var ret = new Yallist(); - if (to < from || to < 0) { - return ret; + updateItemAge(index) { } - if (from < 0) { - from = 0; + setItemTTL(index, ttl) { } - if (to > this.length) { - to = this.length; + isStale(index) { + return false; } - for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { - walker = walker.prev; + initializeSizeTracking() { + this.calculatedSize = 0; + this.sizes = new ZeroArray(this.max); + this.removeItemSize = (index) => this.calculatedSize -= this.sizes[index]; + this.requireSize = (k, v, size, sizeCalculation) => { + if (sizeCalculation && !size) { + size = sizeCalculation(v, k); + } + if (!isPosInt(size)) { + throw new TypeError("size must be positive integer"); + } + return size; + }; + this.addItemSize = (index, v, k, size) => { + this.sizes[index] = size; + const maxSize = this.maxSize - this.sizes[index]; + while (this.calculatedSize > maxSize) { + this.evict(); + } + this.calculatedSize += this.sizes[index]; + }; + this.delete = (k) => { + if (this.size !== 0) { + const index = this.keyMap.get(k); + if (index !== void 0) { + this.calculatedSize -= this.sizes[index]; + } + } + return LRUCache.prototype.delete.call(this, k); + }; } - for (; walker !== null && i > from; i--, walker = walker.prev) { - ret.push(walker.value); + removeItemSize(index) { } - return ret; - }; - Yallist.prototype.splice = function(start, deleteCount, ...nodes) { - if (start > this.length) { - start = this.length - 1; + addItemSize(index, v, k, size) { } - if (start < 0) { - start = this.length + start; + requireSize(k, v, size, sizeCalculation) { + if (size || sizeCalculation) { + throw new TypeError("cannot set size without setting maxSize on cache"); + } } - for (var i = 0, walker = this.head; walker !== null && i < start; i++) { - walker = walker.next; + *indexes({ allowStale = this.allowStale } = {}) { + if (this.size) { + for (let i = this.tail; true; ) { + if (!this.isValidIndex(i)) { + break; + } + if (allowStale || !this.isStale(i)) { + yield i; + } + if (i === this.head) { + break; + } else { + i = this.prev[i]; + } + } + } } - var ret = []; - for (var i = 0; walker && i < deleteCount; i++) { - ret.push(walker.value); - walker = this.removeNode(walker); + *rindexes({ allowStale = this.allowStale } = {}) { + if (this.size) { + for (let i = this.head; true; ) { + if (!this.isValidIndex(i)) { + break; + } + if (allowStale || !this.isStale(i)) { + yield i; + } + if (i === this.tail) { + break; + } else { + i = this.next[i]; + } + } + } } - if (walker === null) { - walker = this.tail; + isValidIndex(index) { + return this.keyMap.get(this.keyList[index]) === index; } - if (walker !== this.head && walker !== this.tail) { - walker = walker.prev; + *entries() { + for (const i of this.indexes()) { + yield [this.keyList[i], this.valList[i]]; + } } - for (var i = 0; i < nodes.length; i++) { - walker = insert(this, walker, nodes[i]); + *rentries() { + for (const i of this.rindexes()) { + yield [this.keyList[i], this.valList[i]]; + } } - return ret; - }; - Yallist.prototype.reverse = function() { - var head = this.head; - var tail = this.tail; - for (var walker = head; walker !== null; walker = walker.prev) { - var p = walker.prev; - walker.prev = walker.next; - walker.next = p; - } - this.head = tail; - this.tail = head; - return this; - }; - function insert(self, node, value) { - var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self); - if (inserted.next === null) { - self.tail = inserted; + *keys() { + for (const i of this.indexes()) { + yield this.keyList[i]; + } } - if (inserted.prev === null) { - self.head = inserted; + *rkeys() { + for (const i of this.rindexes()) { + yield this.keyList[i]; + } } - self.length++; - return inserted; - } - function push(self, item) { - self.tail = new Node(item, self.tail, null, self); - if (!self.head) { - self.head = self.tail; + *values() { + for (const i of this.indexes()) { + yield this.valList[i]; + } } - self.length++; - } - function unshift(self, item) { - self.head = new Node(item, null, self.head, self); - if (!self.tail) { - self.tail = self.head; + *rvalues() { + for (const i of this.rindexes()) { + yield this.valList[i]; + } } - self.length++; - } - function Node(value, prev, next, list) { - if (!(this instanceof Node)) { - return new Node(value, prev, next, list); + [Symbol.iterator]() { + return this.entries(); } - this.list = list; - this.value = value; - if (prev) { - prev.next = this; - this.prev = prev; - } else { - this.prev = null; + find(fn, getOptions = {}) { + for (const i of this.indexes()) { + if (fn(this.valList[i], this.keyList[i], this)) { + return this.get(this.keyList[i], getOptions); + } + } } - if (next) { - next.prev = this; - this.next = next; - } else { - this.next = null; + forEach(fn, thisp = this) { + for (const i of this.indexes()) { + fn.call(thisp, this.valList[i], this.keyList[i], this); + } } - } - try { - require_iterator()(Yallist); - } catch (er) { - } - } -}); - -// node_modules/lru-cache/index.js -var require_lru_cache = __commonJS({ - "node_modules/lru-cache/index.js"(exports, module2) { - "use strict"; - var Yallist = require_yallist(); - var MAX = Symbol("max"); - var LENGTH = Symbol("length"); - var LENGTH_CALCULATOR = Symbol("lengthCalculator"); - var ALLOW_STALE = Symbol("allowStale"); - var MAX_AGE = Symbol("maxAge"); - var DISPOSE = Symbol("dispose"); - var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet"); - var LRU_LIST = Symbol("lruList"); - var CACHE = Symbol("cache"); - var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet"); - var naiveLength = () => 1; - var LRUCache = class { - constructor(options) { - if (typeof options === "number") - options = { max: options }; - if (!options) - options = {}; - if (options.max && (typeof options.max !== "number" || options.max < 0)) - throw new TypeError("max must be a non-negative number"); - const max = this[MAX] = options.max || Infinity; - const lc = options.length || naiveLength; - this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc; - this[ALLOW_STALE] = options.stale || false; - if (options.maxAge && typeof options.maxAge !== "number") - throw new TypeError("maxAge must be a number"); - this[MAX_AGE] = options.maxAge || 0; - this[DISPOSE] = options.dispose; - this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false; - this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false; - this.reset(); - } - set max(mL) { - if (typeof mL !== "number" || mL < 0) - throw new TypeError("max must be a non-negative number"); - this[MAX] = mL || Infinity; - trim(this); - } - get max() { - return this[MAX]; - } - set allowStale(allowStale) { - this[ALLOW_STALE] = !!allowStale; - } - get allowStale() { - return this[ALLOW_STALE]; - } - set maxAge(mA) { - if (typeof mA !== "number") - throw new TypeError("maxAge must be a non-negative number"); - this[MAX_AGE] = mA; - trim(this); - } - get maxAge() { - return this[MAX_AGE]; - } - set lengthCalculator(lC) { - if (typeof lC !== "function") - lC = naiveLength; - if (lC !== this[LENGTH_CALCULATOR]) { - this[LENGTH_CALCULATOR] = lC; - this[LENGTH] = 0; - this[LRU_LIST].forEach((hit) => { - hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key); - this[LENGTH] += hit.length; - }); + rforEach(fn, thisp = this) { + for (const i of this.rindexes()) { + fn.call(thisp, this.valList[i], this.keyList[i], this); } - trim(this); } - get lengthCalculator() { - return this[LENGTH_CALCULATOR]; + get prune() { + deprecatedMethod("prune", "purgeStale"); + return this.purgeStale; } - get length() { - return this[LENGTH]; + purgeStale() { + let deleted = false; + for (const i of this.rindexes({ allowStale: true })) { + if (this.isStale(i)) { + this.delete(this.keyList[i]); + deleted = true; + } + } + return deleted; } - get itemCount() { - return this[LRU_LIST].length; + dump() { + const arr = []; + for (const i of this.indexes()) { + const key = this.keyList[i]; + const value = this.valList[i]; + const entry = { value }; + if (this.ttls) { + entry.ttl = this.ttls[i]; + } + if (this.sizes) { + entry.size = this.sizes[i]; + } + arr.unshift([key, entry]); + } + return arr; } - rforEach(fn, thisp) { - thisp = thisp || this; - for (let walker = this[LRU_LIST].tail; walker !== null; ) { - const prev = walker.prev; - forEachStep(this, fn, walker, thisp); - walker = prev; + load(arr) { + this.clear(); + for (const [key, entry] of arr) { + this.set(key, entry.value, entry); + } + } + dispose(v, k, reason) { + } + set(k, v, { + ttl = this.ttl, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL + } = {}) { + size = this.requireSize(k, v, size, sizeCalculation); + let index = this.size === 0 ? void 0 : this.keyMap.get(k); + if (index === void 0) { + index = this.newIndex(); + this.keyList[index] = k; + this.valList[index] = v; + this.keyMap.set(k, index); + this.next[this.tail] = index; + this.prev[index] = this.tail; + this.tail = index; + this.size++; + this.addItemSize(index, v, k, size); + noUpdateTTL = false; + } else { + const oldVal = this.valList[index]; + if (v !== oldVal) { + if (this.isBackgroundFetch(oldVal)) { + oldVal.__abortController.abort(); + } else { + if (!noDisposeOnSet) { + this.dispose(oldVal, k, "set"); + if (this.disposeAfter) { + this.disposed.push([oldVal, k, "set"]); + } + } + } + this.removeItemSize(index); + this.valList[index] = v; + this.addItemSize(index, v, k, size); + } + this.moveToTail(index); + } + if (ttl !== 0 && this.ttl === 0 && !this.ttls) { + this.initializeTTLTracking(); } + if (!noUpdateTTL) { + this.setItemTTL(index, ttl); + } + if (this.disposeAfter) { + while (this.disposed.length) { + this.disposeAfter(...this.disposed.shift()); + } + } + return this; } - forEach(fn, thisp) { - thisp = thisp || this; - for (let walker = this[LRU_LIST].head; walker !== null; ) { - const next = walker.next; - forEachStep(this, fn, walker, thisp); - walker = next; + newIndex() { + if (this.size === 0) { + return this.tail; + } + if (this.size === this.max) { + return this.evict(); } + if (this.free.length !== 0) { + return this.free.pop(); + } + return this.initialFill++; } - keys() { - return this[LRU_LIST].toArray().map((k) => k.key); + pop() { + if (this.size) { + const val = this.valList[this.head]; + this.evict(); + return val; + } + } + evict() { + const head = this.head; + const k = this.keyList[head]; + const v = this.valList[head]; + if (this.isBackgroundFetch(v)) { + v.__abortController.abort(); + } else { + this.dispose(v, k, "evict"); + if (this.disposeAfter) { + this.disposed.push([v, k, "evict"]); + } + } + this.removeItemSize(head); + this.head = this.next[head]; + this.keyMap.delete(k); + this.size--; + return head; } - values() { - return this[LRU_LIST].toArray().map((k) => k.value); + has(k) { + return this.keyMap.has(k) && !this.isStale(this.keyMap.get(k)); } - reset() { - if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) { - this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value)); + peek(k, { allowStale = this.allowStale } = {}) { + const index = this.keyMap.get(k); + if (index !== void 0 && (allowStale || !this.isStale(index))) { + return this.valList[index]; } - this[CACHE] = /* @__PURE__ */ new Map(); - this[LRU_LIST] = new Yallist(); - this[LENGTH] = 0; } - dump() { - return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : { - k: hit.key, - v: hit.value, - e: hit.now + (hit.maxAge || 0) - }).toArray().filter((h) => h); - } - dumpLru() { - return this[LRU_LIST]; - } - set(key, value, maxAge) { - maxAge = maxAge || this[MAX_AGE]; - if (maxAge && typeof maxAge !== "number") - throw new TypeError("maxAge must be a number"); - const now = maxAge ? Date.now() : 0; - const len = this[LENGTH_CALCULATOR](value, key); - if (this[CACHE].has(key)) { - if (len > this[MAX]) { - del(this, this[CACHE].get(key)); - return false; - } - const node = this[CACHE].get(key); - const item = node.value; - if (this[DISPOSE]) { - if (!this[NO_DISPOSE_ON_SET]) - this[DISPOSE](key, item.value); - } - item.now = now; - item.maxAge = maxAge; - item.value = value; - this[LENGTH] += len - item.length; - item.length = len; - this.get(key); - trim(this); - return true; + backgroundFetch(k, index, options) { + const v = index === void 0 ? void 0 : this.valList[index]; + if (this.isBackgroundFetch(v)) { + return v; } - const hit = new Entry(key, value, len, now, maxAge); - if (hit.length > this[MAX]) { - if (this[DISPOSE]) - this[DISPOSE](key, value); - return false; + const ac = new AbortController(); + const fetchOpts = { + signal: ac.signal, + options + }; + const p = Promise.resolve(this.fetchMethod(k, v, fetchOpts)).then((v2) => { + if (!ac.signal.aborted) { + this.set(k, v2, fetchOpts.options); + } + return v2; + }); + p.__abortController = ac; + p.__staleWhileFetching = v; + if (index === void 0) { + this.set(k, p, fetchOpts.options); + index = this.keyMap.get(k); + } else { + this.valList[index] = p; + } + return p; + } + isBackgroundFetch(p) { + return p && typeof p === "object" && typeof p.then === "function" && Object.prototype.hasOwnProperty.call(p, "__staleWhileFetching"); + } + async fetch(k, { + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet, + ttl = this.ttl, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL + } = {}) { + if (!this.fetchMethod) { + return this.get(k, { allowStale, updateAgeOnGet }); + } + const options = { + allowStale, + updateAgeOnGet, + ttl, + noDisposeOnSet, + size, + sizeCalculation, + noUpdateTTL + }; + let index = this.keyMap.get(k); + if (index === void 0) { + return this.backgroundFetch(k, index, options); + } else { + const v = this.valList[index]; + if (this.isBackgroundFetch(v)) { + return allowStale && v.__staleWhileFetching !== void 0 ? v.__staleWhileFetching : v; + } + if (!this.isStale(index)) { + this.moveToTail(index); + if (updateAgeOnGet) { + this.updateItemAge(index); + } + return v; + } + const p = this.backgroundFetch(k, index, options); + return allowStale && p.__staleWhileFetching !== void 0 ? p.__staleWhileFetching : p; + } + } + get(k, { + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet + } = {}) { + const index = this.keyMap.get(k); + if (index !== void 0) { + const value = this.valList[index]; + const fetching = this.isBackgroundFetch(value); + if (this.isStale(index)) { + if (!fetching) { + this.delete(k); + return allowStale ? value : void 0; + } else { + return allowStale ? value.__staleWhileFetching : void 0; + } + } else { + if (fetching) { + return void 0; + } + this.moveToTail(index); + if (updateAgeOnGet) { + this.updateItemAge(index); + } + return value; + } } - this[LENGTH] += hit.length; - this[LRU_LIST].unshift(hit); - this[CACHE].set(key, this[LRU_LIST].head); - trim(this); - return true; } - has(key) { - if (!this[CACHE].has(key)) - return false; - const hit = this[CACHE].get(key).value; - return !isStale(this, hit); + connect(p, n) { + this.prev[n] = p; + this.next[p] = n; } - get(key) { - return get(this, key, true); - } - peek(key) { - return get(this, key, false); - } - pop() { - const node = this[LRU_LIST].tail; - if (!node) - return null; - del(this, node); - return node.value; + moveToTail(index) { + if (index !== this.tail) { + if (index === this.head) { + this.head = this.next[index]; + } else { + this.connect(this.prev[index], this.next[index]); + } + this.connect(this.tail, index); + this.tail = index; + } } - del(key) { - del(this, this[CACHE].get(key)); + get del() { + deprecatedMethod("del", "delete"); + return this.delete; } - load(arr) { - this.reset(); - const now = Date.now(); - for (let l = arr.length - 1; l >= 0; l--) { - const hit = arr[l]; - const expiresAt = hit.e || 0; - if (expiresAt === 0) - this.set(hit.k, hit.v); - else { - const maxAge = expiresAt - now; - if (maxAge > 0) { - this.set(hit.k, hit.v, maxAge); + delete(k) { + let deleted = false; + if (this.size !== 0) { + const index = this.keyMap.get(k); + if (index !== void 0) { + deleted = true; + if (this.size === 1) { + this.clear(); + } else { + this.removeItemSize(index); + const v = this.valList[index]; + if (this.isBackgroundFetch(v)) { + v.__abortController.abort(); + } else { + this.dispose(v, k, "delete"); + if (this.disposeAfter) { + this.disposed.push([v, k, "delete"]); + } + } + this.keyMap.delete(k); + this.keyList[index] = null; + this.valList[index] = null; + if (index === this.tail) { + this.tail = this.prev[index]; + } else if (index === this.head) { + this.head = this.next[index]; + } else { + this.next[this.prev[index]] = this.next[index]; + this.prev[this.next[index]] = this.prev[index]; + } + this.size--; + this.free.push(index); } } } - } - prune() { - this[CACHE].forEach((value, key) => get(this, key, false)); - } - }; - var get = (self, key, doUse) => { - const node = self[CACHE].get(key); - if (node) { - const hit = node.value; - if (isStale(self, hit)) { - del(self, node); - if (!self[ALLOW_STALE]) - return void 0; - } else { - if (doUse) { - if (self[UPDATE_AGE_ON_GET]) - node.value.now = Date.now(); - self[LRU_LIST].unshiftNode(node); + if (this.disposed) { + while (this.disposed.length) { + this.disposeAfter(...this.disposed.shift()); } } - return hit.value; + return deleted; } - }; - var isStale = (self, hit) => { - if (!hit || !hit.maxAge && !self[MAX_AGE]) - return false; - const diff = Date.now() - hit.now; - return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE]; - }; - var trim = (self) => { - if (self[LENGTH] > self[MAX]) { - for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) { - const prev = walker.prev; - del(self, walker); - walker = prev; + clear() { + for (const index of this.rindexes({ allowStale: true })) { + const v = this.valList[index]; + if (this.isBackgroundFetch(v)) { + v.__abortController.abort(); + } else { + const k = this.keyList[index]; + this.dispose(v, k, "delete"); + if (this.disposeAfter) { + this.disposed.push([v, k, "delete"]); + } + } + } + this.keyMap.clear(); + this.valList.fill(null); + this.keyList.fill(null); + if (this.ttls) { + this.ttls.fill(0); + this.starts.fill(0); + } + if (this.sizes) { + this.sizes.fill(0); + } + this.head = 0; + this.tail = 0; + this.initialFill = 1; + this.free.length = 0; + this.calculatedSize = 0; + this.size = 0; + if (this.disposed) { + while (this.disposed.length) { + this.disposeAfter(...this.disposed.shift()); + } } } - }; - var del = (self, node) => { - if (node) { - const hit = node.value; - if (self[DISPOSE]) - self[DISPOSE](hit.key, hit.value); - self[LENGTH] -= hit.length; - self[CACHE].delete(hit.key); - self[LRU_LIST].removeNode(node); + get reset() { + deprecatedMethod("reset", "clear"); + return this.clear; } - }; - var Entry = class { - constructor(key, value, length, now, maxAge) { - this.key = key; - this.value = value; - this.length = length; - this.now = now; - this.maxAge = maxAge || 0; + get length() { + deprecatedProperty("length", "size"); + return this.size; } }; - var forEachStep = (self, fn, node, thisp) => { - let hit = node.value; - if (isStale(self, hit)) { - del(self, node); - if (!self[ALLOW_STALE]) - hit = void 0; - } - if (hit) - fn.call(thisp, hit.value, hit.key, self); - }; module2.exports = LRUCache; } }); -// node_modules/hosted-git-info/index.js -var require_hosted_git_info = __commonJS({ - "node_modules/hosted-git-info/index.js"(exports, module2) { +// node_modules/hosted-git-info/lib/index.js +var require_lib = __commonJS({ + "node_modules/hosted-git-info/lib/index.js"(exports, module2) { "use strict"; var url = require("url"); var gitHosts = require_git_host_info(); @@ -3987,7 +4028,7 @@ var require_is_plain_object2 = __commonJS({ }); // node_modules/node-fetch/node_modules/webidl-conversions/lib/index.js -var require_lib = __commonJS({ +var require_lib2 = __commonJS({ "node_modules/node-fetch/node_modules/webidl-conversions/lib/index.js"(exports, module2) { "use strict"; var conversions = {}; @@ -5564,7 +5605,7 @@ var require_URL_impl = __commonJS({ var require_URL = __commonJS({ "node_modules/node-fetch/node_modules/whatwg-url/lib/URL.js"(exports, module2) { "use strict"; - var conversions = require_lib(); + var conversions = require_lib2(); var utils = require_utils3(); var Impl = require_URL_impl(); var impl = utils.implSymbol; @@ -5760,7 +5801,7 @@ var require_public_api = __commonJS({ }); // node_modules/node-fetch/lib/index.js -var require_lib2 = __commonJS({ +var require_lib3 = __commonJS({ "node_modules/node-fetch/lib/index.js"(exports, module2) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); @@ -6976,7 +7017,7 @@ var require_dist_node5 = __commonJS({ var endpoint = require_dist_node2(); var universalUserAgent = require_dist_node(); var isPlainObject = require_is_plain_object2(); - var nodeFetch = _interopDefault(require_lib2()); + var nodeFetch = _interopDefault(require_lib3()); var requestError = require_dist_node4(); var VERSION = "5.4.15"; function getBufferResponse(response) { @@ -8785,7 +8826,7 @@ var import_exec7 = __toESM(require_exec(), 1); // lib/packageRepoUrls.js var import_core = __toESM(require_core(), 1); var import_exec = __toESM(require_exec(), 1); -var hostedGitInfo = __toESM(require_hosted_git_info(), 1); +var hostedGitInfo = __toESM(require_lib(), 1); var cache = /* @__PURE__ */ new Map(); async function fetchUrl(packageName) { const cached = cache.get(packageName);