@jsii/runtime 1.75.0 → 1.77.0

package/webpack/bin/jsii-runtime.js

@@ -135,109 +135,10 @@ var __webpack_modules__ = {
             get: assembleStyles
         });
     },
-    5934: (module, __unused_webpack_exports, __webpack_require__) => {
-        "use strict";
-        const os = __webpack_require__(2037);
-        const tty = __webpack_require__(6224);
-        const hasFlag = __webpack_require__(4288);
-        const {env} = process;
-        let forceColor;
-        if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-            forceColor = 0;
-        } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-            forceColor = 1;
-        }
-        if ("FORCE_COLOR" in env) {
-            if (env.FORCE_COLOR === "true") {
-                forceColor = 1;
-            } else if (env.FORCE_COLOR === "false") {
-                forceColor = 0;
-            } else {
-                forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
-            }
-        }
-        function translateLevel(level) {
-            if (level === 0) {
-                return false;
-            }
-            return {
-                level,
-                hasBasic: true,
-                has256: level >= 2,
-                has16m: level >= 3
-            };
-        }
-        function supportsColor(haveStream, streamIsTTY) {
-            if (forceColor === 0) {
-                return 0;
-            }
-            if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-                return 3;
-            }
-            if (hasFlag("color=256")) {
-                return 2;
-            }
-            if (haveStream && !streamIsTTY && forceColor === undefined) {
-                return 0;
-            }
-            const min = forceColor || 0;
-            if (env.TERM === "dumb") {
-                return min;
-            }
-            if (process.platform === "win32") {
-                const osRelease = os.release().split(".");
-                if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-                    return Number(osRelease[2]) >= 14931 ? 3 : 2;
-                }
-                return 1;
-            }
-            if ("CI" in env) {
-                if ([ "TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE" ].some((sign => sign in env)) || env.CI_NAME === "codeship") {
-                    return 1;
-                }
-                return min;
-            }
-            if ("TEAMCITY_VERSION" in env) {
-                return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-            }
-            if (env.COLORTERM === "truecolor") {
-                return 3;
-            }
-            if ("TERM_PROGRAM" in env) {
-                const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-                switch (env.TERM_PROGRAM) {
-                  case "iTerm.app":
-                    return version >= 3 ? 3 : 2;
-
-                  case "Apple_Terminal":
-                    return 2;
-                }
-            }
-            if (/-256(color)?$/i.test(env.TERM)) {
-                return 2;
-            }
-            if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-                return 1;
-            }
-            if ("COLORTERM" in env) {
-                return 1;
-            }
-            return min;
-        }
-        function getSupportLevel(stream) {
-            const level = supportsColor(stream, stream && stream.isTTY);
-            return translateLevel(level);
-        }
-        module.exports = {
-            supportsColor: getSupportLevel,
-            stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-            stderr: translateLevel(supportsColor(true, tty.isatty(2)))
-        };
-    },
     1201: (module, __unused_webpack_exports, __webpack_require__) => {
         "use strict";
         const ansiStyles = __webpack_require__(5756);
-        const {stdout: stdoutColor, stderr: stderrColor} = __webpack_require__(5934);
+        const {stdout: stdoutColor, stderr: stderrColor} = __webpack_require__(9797);
         const {stringReplaceAll, stringEncaseCRLFWithFirstIndex} = __webpack_require__(8564);
         const {isArray} = Array;
         const levelMapping = [ "ansi", "ansi", "ansi256", "ansi16m" ];
@@ -1547,310 +1448,64 @@ var __webpack_modules__ = {
             return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
         };
     },
-    3437: (module, __unused_webpack_exports, __webpack_require__) => {
-        "use strict";
-        const Yallist = __webpack_require__(1455);
-        const MAX = Symbol("max");
-        const LENGTH = Symbol("length");
-        const LENGTH_CALCULATOR = Symbol("lengthCalculator");
-        const ALLOW_STALE = Symbol("allowStale");
-        const MAX_AGE = Symbol("maxAge");
-        const DISPOSE = Symbol("dispose");
-        const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
-        const LRU_LIST = Symbol("lruList");
-        const CACHE = Symbol("cache");
-        const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
-        const naiveLength = () => 1;
-        class LRUCache {
-            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];
+    7706: (module, __unused_webpack_exports, __webpack_require__) => {
+        const ANY = Symbol("SemVer ANY");
+        class Comparator {
+            static get ANY() {
+                return ANY;
             }
-            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;
-                    }));
+            constructor(comp, options) {
+                options = parseOptions(options);
+                if (comp instanceof Comparator) {
+                    if (comp.loose === !!options.loose) {
+                        return comp;
+                    } else {
+                        comp = comp.value;
+                    }
                 }
-                trim(this);
-            }
-            get lengthCalculator() {
-                return this[LENGTH_CALCULATOR];
-            }
-            get length() {
-                return this[LENGTH];
-            }
-            get itemCount() {
-                return this[LRU_LIST].length;
-            }
-            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;
+                debug("comparator", comp, options);
+                this.options = options;
+                this.loose = !!options.loose;
+                this.parse(comp);
+                if (this.semver === ANY) {
+                    this.value = "";
+                } else {
+                    this.value = this.operator + this.semver.version;
                 }
+                debug("comp", 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;
+            parse(comp) {
+                const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+                const m = comp.match(r);
+                if (!m) {
+                    throw new TypeError(`Invalid comparator: ${comp}`);
                 }
-            }
-            keys() {
-                return this[LRU_LIST].toArray().map((k => k.key));
-            }
-            values() {
-                return this[LRU_LIST].toArray().map((k => k.value));
-            }
-            reset() {
-                if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
-                    this[LRU_LIST].forEach((hit => this[DISPOSE](hit.key, hit.value)));
+                this.operator = m[1] !== undefined ? m[1] : "";
+                if (this.operator === "=") {
+                    this.operator = "";
+                }
+                if (!m[2]) {
+                    this.semver = ANY;
+                } else {
+                    this.semver = new SemVer(m[2], this.options.loose);
                 }
-                this[CACHE] = 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));
+            toString() {
+                return this.value;
             }
-            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;
-                }
-                const hit = new Entry(key, value, len, now, maxAge);
-                if (hit.length > this[MAX]) {
-                    if (this[DISPOSE]) this[DISPOSE](key, value);
-                    return false;
-                }
-                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);
-            }
-            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;
-            }
-            del(key) {
-                del(this, this[CACHE].get(key));
-            }
-            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);
-                        }
-                    }
-                }
-            }
-            prune() {
-                this[CACHE].forEach(((value, key) => get(this, key, false)));
-            }
-        }
-        const 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 undefined;
-                } else {
-                    if (doUse) {
-                        if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
-                        self[LRU_LIST].unshiftNode(node);
-                    }
-                }
-                return hit.value;
-            }
-        };
-        const 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];
-        };
-        const 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;
-                }
-            }
-        };
-        const 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);
-            }
-        };
-        class Entry {
-            constructor(key, value, length, now, maxAge) {
-                this.key = key;
-                this.value = value;
-                this.length = length;
-                this.now = now;
-                this.maxAge = maxAge || 0;
-            }
-        }
-        const forEachStep = (self, fn, node, thisp) => {
-            let hit = node.value;
-            if (isStale(self, hit)) {
-                del(self, node);
-                if (!self[ALLOW_STALE]) hit = undefined;
-            }
-            if (hit) fn.call(thisp, hit.value, hit.key, self);
-        };
-        module.exports = LRUCache;
-    },
-    7706: (module, __unused_webpack_exports, __webpack_require__) => {
-        const ANY = Symbol("SemVer ANY");
-        class Comparator {
-            static get ANY() {
-                return ANY;
-            }
-            constructor(comp, options) {
-                options = parseOptions(options);
-                if (comp instanceof Comparator) {
-                    if (comp.loose === !!options.loose) {
-                        return comp;
-                    } else {
-                        comp = comp.value;
-                    }
-                }
-                debug("comparator", comp, options);
-                this.options = options;
-                this.loose = !!options.loose;
-                this.parse(comp);
-                if (this.semver === ANY) {
-                    this.value = "";
-                } else {
-                    this.value = this.operator + this.semver.version;
-                }
-                debug("comp", this);
-            }
-            parse(comp) {
-                const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-                const m = comp.match(r);
-                if (!m) {
-                    throw new TypeError(`Invalid comparator: ${comp}`);
-                }
-                this.operator = m[1] !== undefined ? m[1] : "";
-                if (this.operator === "=") {
-                    this.operator = "";
-                }
-                if (!m[2]) {
-                    this.semver = ANY;
-                } else {
-                    this.semver = new SemVer(m[2], this.options.loose);
-                }
-            }
-            toString() {
-                return this.value;
-            }
-            test(version) {
-                debug("Comparator.test", version, this.options.loose);
-                if (this.semver === ANY || version === ANY) {
-                    return true;
-                }
-                if (typeof version === "string") {
-                    try {
-                        version = new SemVer(version, this.options);
-                    } catch (er) {
-                        return false;
-                    }
-                }
-                return cmp(version, this.operator, this.semver, this.options);
+            test(version) {
+                debug("Comparator.test", version, this.options.loose);
+                if (this.semver === ANY || version === ANY) {
+                    return true;
+                }
+                if (typeof version === "string") {
+                    try {
+                        version = new SemVer(version, this.options);
+                    } catch (er) {
+                        return false;
+                    }
+                }
+                return cmp(version, this.operator, this.semver, this.options);
             }
             intersects(comp, options) {
                 if (!(comp instanceof Comparator)) {
@@ -2004,7 +1659,7 @@ var __webpack_modules__ = {
             }
         }
         module.exports = Range;
-        const LRU = __webpack_require__(3437);
+        const LRU = __webpack_require__(6923);
         const cache = new LRU({
             max: 1e3
         });
@@ -2912,46 +2567,292 @@ var __webpack_modules__ = {
         createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
         createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
     },
-    4933: (module, __unused_webpack_exports, __webpack_require__) => {
-        const outside = __webpack_require__(939);
-        const gtr = (version, range, options) => outside(version, range, ">", options);
-        module.exports = gtr;
-    },
-    8842: (module, __unused_webpack_exports, __webpack_require__) => {
-        const Range = __webpack_require__(6833);
-        const intersects = (r1, r2, options) => {
-            r1 = new Range(r1, options);
-            r2 = new Range(r2, options);
-            return r1.intersects(r2);
-        };
-        module.exports = intersects;
-    },
-    7233: (module, __unused_webpack_exports, __webpack_require__) => {
-        const outside = __webpack_require__(939);
-        const ltr = (version, range, options) => outside(version, range, "<", options);
-        module.exports = ltr;
-    },
-    1678: (module, __unused_webpack_exports, __webpack_require__) => {
-        const SemVer = __webpack_require__(3013);
-        const Range = __webpack_require__(6833);
-        const maxSatisfying = (versions, range, options) => {
-            let max = null;
-            let maxSV = null;
-            let rangeObj = null;
-            try {
-                rangeObj = new Range(range, options);
-            } catch (er) {
-                return null;
+    6923: (module, __unused_webpack_exports, __webpack_require__) => {
+        "use strict";
+        const Yallist = __webpack_require__(1455);
+        const MAX = Symbol("max");
+        const LENGTH = Symbol("length");
+        const LENGTH_CALCULATOR = Symbol("lengthCalculator");
+        const ALLOW_STALE = Symbol("allowStale");
+        const MAX_AGE = Symbol("maxAge");
+        const DISPOSE = Symbol("dispose");
+        const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
+        const LRU_LIST = Symbol("lruList");
+        const CACHE = Symbol("cache");
+        const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
+        const naiveLength = () => 1;
+        class LRUCache {
+            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();
             }
-            versions.forEach((v => {
-                if (rangeObj.test(v)) {
-                    if (!max || maxSV.compare(v) === -1) {
-                        max = v;
-                        maxSV = new SemVer(max, options);
-                    }
-                }
-            }));
-            return max;
+            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;
+                    }));
+                }
+                trim(this);
+            }
+            get lengthCalculator() {
+                return this[LENGTH_CALCULATOR];
+            }
+            get length() {
+                return this[LENGTH];
+            }
+            get itemCount() {
+                return this[LRU_LIST].length;
+            }
+            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;
+                }
+            }
+            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;
+                }
+            }
+            keys() {
+                return this[LRU_LIST].toArray().map((k => k.key));
+            }
+            values() {
+                return this[LRU_LIST].toArray().map((k => k.value));
+            }
+            reset() {
+                if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+                    this[LRU_LIST].forEach((hit => this[DISPOSE](hit.key, hit.value)));
+                }
+                this[CACHE] = 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;
+                }
+                const hit = new Entry(key, value, len, now, maxAge);
+                if (hit.length > this[MAX]) {
+                    if (this[DISPOSE]) this[DISPOSE](key, value);
+                    return false;
+                }
+                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);
+            }
+            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;
+            }
+            del(key) {
+                del(this, this[CACHE].get(key));
+            }
+            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);
+                        }
+                    }
+                }
+            }
+            prune() {
+                this[CACHE].forEach(((value, key) => get(this, key, false)));
+            }
+        }
+        const 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 undefined;
+                } else {
+                    if (doUse) {
+                        if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
+                        self[LRU_LIST].unshiftNode(node);
+                    }
+                }
+                return hit.value;
+            }
+        };
+        const 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];
+        };
+        const 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;
+                }
+            }
+        };
+        const 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);
+            }
+        };
+        class Entry {
+            constructor(key, value, length, now, maxAge) {
+                this.key = key;
+                this.value = value;
+                this.length = length;
+                this.now = now;
+                this.maxAge = maxAge || 0;
+            }
+        }
+        const forEachStep = (self, fn, node, thisp) => {
+            let hit = node.value;
+            if (isStale(self, hit)) {
+                del(self, node);
+                if (!self[ALLOW_STALE]) hit = undefined;
+            }
+            if (hit) fn.call(thisp, hit.value, hit.key, self);
+        };
+        module.exports = LRUCache;
+    },
+    4933: (module, __unused_webpack_exports, __webpack_require__) => {
+        const outside = __webpack_require__(939);
+        const gtr = (version, range, options) => outside(version, range, ">", options);
+        module.exports = gtr;
+    },
+    8842: (module, __unused_webpack_exports, __webpack_require__) => {
+        const Range = __webpack_require__(6833);
+        const intersects = (r1, r2, options) => {
+            r1 = new Range(r1, options);
+            r2 = new Range(r2, options);
+            return r1.intersects(r2);
+        };
+        module.exports = intersects;
+    },
+    7233: (module, __unused_webpack_exports, __webpack_require__) => {
+        const outside = __webpack_require__(939);
+        const ltr = (version, range, options) => outside(version, range, "<", options);
+        module.exports = ltr;
+    },
+    1678: (module, __unused_webpack_exports, __webpack_require__) => {
+        const SemVer = __webpack_require__(3013);
+        const Range = __webpack_require__(6833);
+        const maxSatisfying = (versions, range, options) => {
+            let max = null;
+            let maxSV = null;
+            let rangeObj = null;
+            try {
+                rangeObj = new Range(range, options);
+            } catch (er) {
+                return null;
+            }
+            versions.forEach((v => {
+                if (rangeObj.test(v)) {
+                    if (!max || maxSV.compare(v) === -1) {
+                        max = v;
+                        maxSV = new SemVer(max, options);
+                    }
+                }
+            }));
+            return max;
         };
         module.exports = maxSatisfying;
     },
@@ -3316,6 +3217,105 @@ var __webpack_modules__ = {
         };
         module.exports = validRange;
     },
+    9797: (module, __unused_webpack_exports, __webpack_require__) => {
+        "use strict";
+        const os = __webpack_require__(2037);
+        const tty = __webpack_require__(6224);
+        const hasFlag = __webpack_require__(4288);
+        const {env} = process;
+        let forceColor;
+        if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+            forceColor = 0;
+        } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+            forceColor = 1;
+        }
+        if ("FORCE_COLOR" in env) {
+            if (env.FORCE_COLOR === "true") {
+                forceColor = 1;
+            } else if (env.FORCE_COLOR === "false") {
+                forceColor = 0;
+            } else {
+                forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+            }
+        }
+        function translateLevel(level) {
+            if (level === 0) {
+                return false;
+            }
+            return {
+                level,
+                hasBasic: true,
+                has256: level >= 2,
+                has16m: level >= 3
+            };
+        }
+        function supportsColor(haveStream, streamIsTTY) {
+            if (forceColor === 0) {
+                return 0;
+            }
+            if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+                return 3;
+            }
+            if (hasFlag("color=256")) {
+                return 2;
+            }
+            if (haveStream && !streamIsTTY && forceColor === undefined) {
+                return 0;
+            }
+            const min = forceColor || 0;
+            if (env.TERM === "dumb") {
+                return min;
+            }
+            if (process.platform === "win32") {
+                const osRelease = os.release().split(".");
+                if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+                    return Number(osRelease[2]) >= 14931 ? 3 : 2;
+                }
+                return 1;
+            }
+            if ("CI" in env) {
+                if ([ "TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE" ].some((sign => sign in env)) || env.CI_NAME === "codeship") {
+                    return 1;
+                }
+                return min;
+            }
+            if ("TEAMCITY_VERSION" in env) {
+                return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+            }
+            if (env.COLORTERM === "truecolor") {
+                return 3;
+            }
+            if ("TERM_PROGRAM" in env) {
+                const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+                switch (env.TERM_PROGRAM) {
+                  case "iTerm.app":
+                    return version >= 3 ? 3 : 2;
+
+                  case "Apple_Terminal":
+                    return 2;
+                }
+            }
+            if (/-256(color)?$/i.test(env.TERM)) {
+                return 2;
+            }
+            if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+                return 1;
+            }
+            if ("COLORTERM" in env) {
+                return 1;
+            }
+            return min;
+        }
+        function getSupportLevel(stream) {
+            const level = supportsColor(stream, stream && stream.isTTY);
+            return translateLevel(level);
+        }
+        module.exports = {
+            supportsColor: getSupportLevel,
+            stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+            stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+        };
+    },
     3278: module => {
         "use strict";
         module.exports = function(Yallist) {