@jsii/runtime 1.101.0 → 1.102.0

package/webpack/bin/jsii-runtime.js

@@ -1557,6 +1557,7 @@ var __webpack_modules__ = {
         const Range = __webpack_require__(3597);
     },
     3597: (module, __unused_webpack_exports, __webpack_require__) => {
+        const SPACE_CHARACTERS = /\s+/g;
         class Range {
             constructor(range, options) {
                 options = parseOptions(options);
@@ -1570,13 +1571,13 @@ var __webpack_modules__ = {
                 if (range instanceof Comparator) {
                     this.raw = range.value;
                     this.set = [ [ range ] ];
-                    this.format();
+                    this.formatted = undefined;
                     return this;
                 }
                 this.options = options;
                 this.loose = !!options.loose;
                 this.includePrerelease = !!options.includePrerelease;
-                this.raw = range.trim().split(/\s+/).join(" ");
+                this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
                 this.set = this.raw.split("||").map((r => this.parseRange(r.trim()))).filter((c => c.length));
                 if (!this.set.length) {
                     throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
@@ -1595,10 +1596,27 @@ var __webpack_modules__ = {
                         }
                     }
                 }
-                this.format();
+                this.formatted = undefined;
+            }
+            get range() {
+                if (this.formatted === undefined) {
+                    this.formatted = "";
+                    for (let i = 0; i < this.set.length; i++) {
+                        if (i > 0) {
+                            this.formatted += "||";
+                        }
+                        const comps = this.set[i];
+                        for (let k = 0; k < comps.length; k++) {
+                            if (k > 0) {
+                                this.formatted += " ";
+                            }
+                            this.formatted += comps[k].toString().trim();
+                        }
+                    }
+                }
+                return this.formatted;
             }
             format() {
-                this.range = this.set.map((comps => comps.join(" ").trim())).join("||").trim();
                 return this.range;
             }
             toString() {
@@ -1670,10 +1688,8 @@ var __webpack_modules__ = {
             }
         }
         module.exports = Range;
-        const LRU = __webpack_require__(8163);
-        const cache = new LRU({
-            max: 1e3
-        });
+        const LRU = __webpack_require__(1380);
+        const cache = new LRU;
         const parseOptions = __webpack_require__(6837);
         const Comparator = __webpack_require__(3114);
         const debug = __webpack_require__(4122);
@@ -1839,7 +1855,7 @@ var __webpack_modules__ = {
             debug("replaceGTE0", comp, options);
             return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
         };
-        const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
+        const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
             if (isX(fM)) {
                 from = "";
             } else if (isX(fm)) {
@@ -2014,7 +2030,7 @@ var __webpack_modules__ = {
                 do {
                     const a = this.build[i];
                     const b = other.build[i];
-                    debug("prerelease compare", i, a, b);
+                    debug("build compare", i, a, b);
                     if (a === undefined && b === undefined) {
                         return 0;
                     } else if (b === undefined) {
@@ -2544,6 +2560,39 @@ var __webpack_modules__ = {
             rcompareIdentifiers
         };
     },
+    1380: module => {
+        class LRUCache {
+            constructor() {
+                this.max = 1e3;
+                this.map = new Map;
+            }
+            get(key) {
+                const value = this.map.get(key);
+                if (value === undefined) {
+                    return undefined;
+                } else {
+                    this.map.delete(key);
+                    this.map.set(key, value);
+                    return value;
+                }
+            }
+            delete(key) {
+                return this.map.delete(key);
+            }
+            set(key, value) {
+                const deleted = this.delete(key);
+                if (!deleted && value !== undefined) {
+                    if (this.map.size >= this.max) {
+                        const firstKey = this.map.keys().next().value;
+                        this.delete(firstKey);
+                    }
+                    this.map.set(key, value);
+                }
+                return this;
+            }
+        }
+        module.exports = LRUCache;
+    },
     6837: module => {
         const looseOption = Object.freeze({
             loose: true
@@ -2633,252 +2682,6 @@ var __webpack_modules__ = {
         createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
         createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
     },
-    8163: (module, __unused_webpack_exports, __webpack_require__) => {
-        "use strict";
-        const Yallist = __webpack_require__(5773);
-        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];
-            }
-            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;
-    },
     7369: (module, __unused_webpack_exports, __webpack_require__) => {
         const outside = __webpack_require__(2641);
         const gtr = (version, range, options) => outside(version, range, ">", options);
@@ -3384,380 +3187,6 @@ var __webpack_modules__ = {
             stderr: translateLevel(supportsColor(true, tty.isatty(2)))
         };
     },
-    6949: module => {
-        "use strict";
-        module.exports = function(Yallist) {
-            Yallist.prototype[Symbol.iterator] = function*() {
-                for (let walker = this.head; walker; walker = walker.next) {
-                    yield walker.value;
-                }
-            };
-        };
-    },
-    5773: (module, __unused_webpack_exports, __webpack_require__) => {
-        "use strict";
-        module.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 undefined;
-            }
-            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 undefined;
-            }
-            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;
-            }
-            if (i === n && walker !== null) {
-                return walker.value;
-            }
-        };
-        Yallist.prototype.getReverse = function(n) {
-            for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
-                walker = walker.prev;
-            }
-            if (i === n && walker !== null) {
-                return walker.value;
-            }
-        };
-        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;
-            }
-            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;
-            }
-            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;
-        };
-        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;
-            }
-            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;
-            }
-            if (to > this.length) {
-                to = this.length;
-            }
-            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);
-            }
-            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 ret = new Yallist;
-            if (to < from || to < 0) {
-                return ret;
-            }
-            if (from < 0) {
-                from = 0;
-            }
-            if (to > this.length) {
-                to = this.length;
-            }
-            for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-                walker = walker.prev;
-            }
-            for (;walker !== null && i > from; i--, walker = walker.prev) {
-                ret.push(walker.value);
-            }
-            return ret;
-        };
-        Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
-            if (start > this.length) {
-                start = this.length - 1;
-            }
-            if (start < 0) {
-                start = this.length + start;
-            }
-            for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-                walker = walker.next;
-            }
-            var ret = [];
-            for (var i = 0; walker && i < deleteCount; i++) {
-                ret.push(walker.value);
-                walker = this.removeNode(walker);
-            }
-            if (walker === null) {
-                walker = this.tail;
-            }
-            if (walker !== this.head && walker !== this.tail) {
-                walker = walker.prev;
-            }
-            for (var i = 0; i < nodes.length; i++) {
-                walker = insert(this, walker, nodes[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;
-            }
-            if (inserted.prev === null) {
-                self.head = inserted;
-            }
-            self.length++;
-            return inserted;
-        }
-        function push(self, item) {
-            self.tail = new Node(item, self.tail, null, self);
-            if (!self.head) {
-                self.head = self.tail;
-            }
-            self.length++;
-        }
-        function unshift(self, item) {
-            self.head = new Node(item, null, self.head, self);
-            if (!self.tail) {
-                self.tail = self.head;
-            }
-            self.length++;
-        }
-        function Node(value, prev, next, list) {
-            if (!(this instanceof Node)) {
-                return new Node(value, prev, next, list);
-            }
-            this.list = list;
-            this.value = value;
-            if (prev) {
-                prev.next = this;
-                this.prev = prev;
-            } else {
-                this.prev = null;
-            }
-            if (next) {
-                next.prev = this;
-                this.next = next;
-            } else {
-                this.next = null;
-            }
-        }
-        try {
-            __webpack_require__(6949)(Yallist);
-        } catch (er) {}
-    },
     268: (__unused_webpack_module, exports, __webpack_require__) => {
         "use strict";
         Object.defineProperty(exports, "__esModule", {
@@ -3825,13 +3254,13 @@ var __webpack_modules__ = {
         }), new NodeRelease(19, {
             endOfLife: new Date("2023-06-01"),
             untested: true
+        }), new NodeRelease(21, {
+            endOfLife: new Date("2024-06-01"),
+            untested: true
         }), new NodeRelease(18, {
             endOfLife: new Date("2025-04-30")
         }), new NodeRelease(20, {
             endOfLife: new Date("2026-04-30")
-        }), new NodeRelease(21, {
-            endOfLife: new Date("2024-06-01"),
-            untested: true
         }), new NodeRelease(22, {
             endOfLife: new Date("2027-04-30")
         }) ];