mirror of
https://github.com/angular/angular.git
synced 2026-09-14 13:54:52 +08:00
build: lock file maintenance (#56361)
See associated pull request for more information. PR Close #56361
This commit is contained in:
Angular Robot
committed by
Alex Rickabaugh
Alex Rickabaugh
parent
ea3c802056
commit
6ca056532a
@@ -6924,7 +6924,7 @@ var require_semver = __commonJS({
|
||||
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 === void 0 && b === void 0) {
|
||||
return 0;
|
||||
} else if (b === void 0) {
|
||||
@@ -7394,652 +7394,38 @@ var require_coerce = __commonJS({
|
||||
});
|
||||
|
||||
//
|
||||
var require_iterator = __commonJS({
|
||||
var require_lrucache = __commonJS({
|
||||
""(exports, module) {
|
||||
"use strict";
|
||||
module.exports = function(Yallist) {
|
||||
Yallist.prototype[Symbol.iterator] = function* () {
|
||||
for (let walker = this.head; walker; walker = walker.next) {
|
||||
yield walker.value;
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
});
|
||||
|
||||
//
|
||||
var require_yallist = __commonJS({
|
||||
""(exports, module) {
|
||||
"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 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;
|
||||
}
|
||||
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 {
|
||||
require_iterator()(Yallist);
|
||||
} catch (er) {
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
//
|
||||
var require_lru_cache = __commonJS({
|
||||
""(exports, module) {
|
||||
"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;
|
||||
});
|
||||
}
|
||||
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] = /* @__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;
|
||||
}
|
||||
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);
|
||||
constructor() {
|
||||
this.max = 1e3;
|
||||
this.map = /* @__PURE__ */ new Map();
|
||||
}
|
||||
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));
|
||||
}
|
||||
};
|
||||
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;
|
||||
const value = this.map.get(key);
|
||||
if (value === void 0) {
|
||||
return void 0;
|
||||
} else {
|
||||
if (doUse) {
|
||||
if (self[UPDATE_AGE_ON_GET])
|
||||
node.value.now = Date.now();
|
||||
self[LRU_LIST].unshiftNode(node);
|
||||
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 !== void 0) {
|
||||
if (this.map.size >= this.max) {
|
||||
const firstKey = this.map.keys().next().value;
|
||||
this.delete(firstKey);
|
||||
}
|
||||
this.map.set(key, value);
|
||||
}
|
||||
return hit.value;
|
||||
return this;
|
||||
}
|
||||
};
|
||||
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;
|
||||
}
|
||||
}
|
||||
};
|
||||
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);
|
||||
}
|
||||
};
|
||||
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;
|
||||
}
|
||||
};
|
||||
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);
|
||||
};
|
||||
module.exports = LRUCache;
|
||||
}
|
||||
});
|
||||
@@ -8168,8 +7554,8 @@ var require_range = __commonJS({
|
||||
}
|
||||
};
|
||||
module.exports = Range;
|
||||
var LRU = require_lru_cache();
|
||||
var cache = new LRU({ max: 1e3 });
|
||||
var LRU = require_lrucache();
|
||||
var cache = new LRU();
|
||||
var parseOptions = require_parse_options();
|
||||
var Comparator = require_comparator();
|
||||
var debug = require_debug();
|
||||
@@ -8347,7 +7733,7 @@ var require_range = __commonJS({
|
||||
debug("replaceGTE0", comp, options);
|
||||
return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
|
||||
};
|
||||
var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
|
||||
var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
|
||||
if (isX(fM)) {
|
||||
from = "";
|
||||
} else if (isX(fm)) {
|
||||
|
||||
Reference in New Issue
Block a user