lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-cnmsajvk.js

@@ -0,0 +1,1119 @@
+// @bun
+// packages/collection/src/cache.ts
+class Cache2 {
+  #entries;
+  constructor(options = {}) {
+    const maxSize = options.maxSize ?? Infinity;
+    const ttl = options.ttl ?? 0;
+    if (!Number.isInteger(maxSize) && maxSize !== Infinity || maxSize < 1)
+      throw new RangeError("Cache maxSize must be a positive integer.");
+    if (!Number.isFinite(ttl) || ttl < 0)
+      throw new RangeError("Cache ttl must be a non-negative finite number.");
+    if (!((options.jitter ?? 0) >= 0 && (options.jitter ?? 0) <= 1))
+      throw new RangeError("Cache jitter must be between 0 and 1.");
+    if (ttl > 0) {
+      const interval = options.sweepInterval ?? Math.min(ttl, 60000);
+      if (!Number.isFinite(interval) || interval < 1)
+        throw new RangeError("Cache sweepInterval must be positive.");
+    }
+    this.#entries = new Collection2(null, {
+      ttl: ttl > 0 ? ttl : undefined,
+      jitter: options.jitter,
+      maxSize: maxSize === Infinity ? undefined : maxSize,
+      slide: false
+    });
+  }
+  get size() {
+    return this.#entries.size;
+  }
+  get(key) {
+    return this.#entries.get(key);
+  }
+  has(key) {
+    return this.#entries.has(key);
+  }
+  set(key, value) {
+    this.#entries.set(key, value);
+    return this;
+  }
+  delete(key) {
+    return this.#entries.delete(key);
+  }
+  clear() {
+    this.#entries.clear();
+  }
+  invalidate(predicate) {
+    return this.#entries.sweep(predicate);
+  }
+  sweep() {
+    return this.#entries.purge();
+  }
+  dispose() {}
+  values() {
+    return [...this.#entries.values()];
+  }
+  entries() {
+    return [...this.#entries.entries()];
+  }
+}
+// packages/collection/src/redis.ts
+var PRELUDE = `
+local exp, lru, clock, ep = KEYS[1], KEYS[2], KEYS[3], ARGV[1]
+local t = redis.call('TIME')
+local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
+local out = {}
+local function drop(m, reason)
+  local v = redis.call('GET', ep .. m)
+  redis.call('DEL', ep .. m)
+  redis.call('ZREM', exp, m)
+  redis.call('ZREM', lru, m)
+  if reason then
+    table.insert(out, m)
+    table.insert(out, v or false)
+    table.insert(out, reason)
+  end
+end
+local gone = redis.call('ZRANGEBYSCORE', exp, '-inf', now, 'LIMIT', 0, 1000)
+for _, m in ipairs(gone) do drop(m, 'expired') end
+local function touch(m) redis.call('ZADD', lru, redis.call('INCR', clock), m) end
+`;
+var SET_SCRIPT = `${PRELUDE}
+local m, payload, ttl, max, mode = ARGV[2], ARGV[3], tonumber(ARGV[4]), tonumber(ARGV[5]), ARGV[6]
+if mode == 'nx' then
+  local cur = redis.call('GET', ep .. m)
+  if cur then
+    touch(m)
+    table.insert(out, 1, cur)
+    return out
+  end
+end
+local env = ttl .. ':' .. payload
+if ttl > 0 then
+  -- The key outlives its logical expiry by a grace second, so the prune
+  -- that reports the expiry can still hand the value to onEvict.
+  redis.call('SET', ep .. m, env, 'PX', ttl + 1000)
+  redis.call('ZADD', exp, now + ttl, m)
+else
+  redis.call('SET', ep .. m, env)
+  redis.call('ZREM', exp, m)
+end
+touch(m)
+if max > 0 then
+  local n = redis.call('ZCARD', lru)
+  while n > max do
+    local popped = redis.call('ZPOPMIN', lru)
+    local victim = popped[1]
+    if victim == nil then break end
+    if victim ~= m then drop(victim, 'evicted') end
+    n = n - 1
+  end
+end
+table.insert(out, 1, false)
+return out
+`;
+var GET_SCRIPT = `${PRELUDE}
+local m, slide, mark = ARGV[2], ARGV[3], ARGV[4]
+local env = redis.call('GET', ep .. m)
+if not env then
+  redis.call('ZREM', exp, m)
+  redis.call('ZREM', lru, m)
+  table.insert(out, 1, false)
+  return out
+end
+if mark == '1' then touch(m) end
+if slide == '1' then
+  local ttl = tonumber(string.match(env, '^(%d+):'))
+  if ttl and ttl > 0 then
+    redis.call('PEXPIRE', ep .. m, ttl + 1000)
+    redis.call('ZADD', exp, now + ttl, m)
+  end
+end
+table.insert(out, 1, env)
+return out
+`;
+var DELETE_SCRIPT = `${PRELUDE}
+local m = ARGV[2]
+local existed = redis.call('EXISTS', ep .. m)
+drop(m, nil)
+table.insert(out, 1, existed)
+return out
+`;
+var LIST_SCRIPT = `${PRELUDE}
+local what = ARGV[2]
+if what == 'clear' then
+  local n = 0
+  repeat
+    local batch = redis.call('ZRANGE', lru, 0, 999)
+    for _, m in ipairs(batch) do drop(m, nil) end
+    n = n + #batch
+  until #batch == 0
+  redis.call('DEL', exp, lru, clock)
+  return {n}
+end
+local result = what == 'size' and redis.call('ZCARD', lru) or redis.call('ZRANGE', lru, 0, -1)
+return {result, unpack(out)}
+`;
+var EXPIRY_GRACE_MS = 1000;
+var JSON_SERIALIZER = {
+  serialize: (value) => JSON.stringify(value),
+  deserialize: (raw) => JSON.parse(raw)
+};
+
+class RedisCollection2 {
+  #redis;
+  #keys;
+  #ep;
+  #ttl;
+  #slide;
+  #maxSize;
+  #serializer;
+  #onEvict;
+  #stats = {
+    hits: 0,
+    misses: 0,
+    expired: 0,
+    evicted: 0
+  };
+  name;
+  constructor(options) {
+    if (typeof options.name !== "string" || !/^[\w.:-]{1,100}$/.test(options.name))
+      throw new TypeError("name must be 1-100 letters, digits, '_', '.', ':' or '-'.");
+    checkTTL(options.ttl);
+    if (options.maxSize !== undefined && !(Number.isInteger(options.maxSize) && options.maxSize > 0))
+      throw new RangeError("maxSize must be a positive integer.");
+    this.#redis = options.client;
+    this.name = options.name;
+    const base = `${options.prefix ?? "lunibee:collection:"}v1:{${options.name}}:`;
+    this.#keys = [`${base}exp`, `${base}lru`, `${base}clock`];
+    this.#ep = `${base}e:`;
+    this.#ttl = options.ttl ?? 0;
+    this.#slide = options.slide ?? true;
+    this.#maxSize = options.maxSize ?? 0;
+    this.#serializer = options.serializer ?? JSON_SERIALIZER;
+    this.#onEvict = options.onEvict;
+  }
+  get stats() {
+    return { ...this.#stats };
+  }
+  async#run(script, ...argv) {
+    const reply = await this.#redis.send("EVAL", [
+      script,
+      "3",
+      ...this.#keys,
+      this.#ep,
+      ...argv
+    ]);
+    if (!Array.isArray(reply))
+      throw new Error("Unexpected reply from a RedisCollection script.");
+    return reply;
+  }
+  #settle(reply, skip) {
+    for (let i = skip;i + 2 < reply.length + 0; i += 3) {
+      const key = String(reply[i]);
+      const raw = reply[i + 1];
+      const reason = reply[i + 2];
+      if (reason === "expired")
+        this.#stats.expired++;
+      else
+        this.#stats.evicted++;
+      if (!this.#onEvict)
+        continue;
+      let value;
+      try {
+        value = typeof raw === "string" ? this.#decode(raw) : undefined;
+      } catch {
+        value = undefined;
+      }
+      try {
+        this.#onEvict(key, value, reason);
+      } catch {}
+    }
+    return reply[0];
+  }
+  #decode(envelope) {
+    const colon = envelope.indexOf(":");
+    return this.#serializer.deserialize(envelope.slice(colon + 1));
+  }
+  async get(key) {
+    const raw = this.#settle(await this.#run(GET_SCRIPT, String(key), this.#slide ? "1" : "0", "1"), 1);
+    if (typeof raw !== "string") {
+      this.#stats.misses++;
+      return;
+    }
+    this.#stats.hits++;
+    return this.#decode(raw);
+  }
+  async peek(key) {
+    const raw = this.#settle(await this.#run(GET_SCRIPT, String(key), "0", "0"), 1);
+    return typeof raw === "string" ? this.#decode(raw) : undefined;
+  }
+  async has(key) {
+    return await this.peek(key) !== undefined;
+  }
+  async set(key, value, ttl) {
+    checkTTL(ttl, true);
+    this.#settle(await this.#run(SET_SCRIPT, String(key), this.#serializer.serialize(value), String(Math.ceil(ttl ?? this.#ttl)), String(this.#maxSize), "set"), 1);
+    return this;
+  }
+  setWithoutTTL(key, value) {
+    return this.set(key, value, 0);
+  }
+  async ensure(key, factory, ttl) {
+    const existing = await this.get(key);
+    if (existing !== undefined)
+      return existing;
+    checkTTL(ttl, true);
+    const value = await factory(String(key));
+    const raw = this.#settle(await this.#run(SET_SCRIPT, String(key), this.#serializer.serialize(value), String(Math.ceil(ttl ?? this.#ttl)), String(this.#maxSize), "nx"), 1);
+    return typeof raw === "string" ? this.#decode(raw) : value;
+  }
+  async delete(key) {
+    const reply = await this.#run(DELETE_SCRIPT, String(key));
+    return Number(this.#settle(reply, 1)) === 1;
+  }
+  async clear() {
+    const reply = await this.#run(LIST_SCRIPT, "clear");
+    return Number(reply[0]);
+  }
+  async size() {
+    return Number(this.#settle(await this.#run(LIST_SCRIPT, "size"), 1));
+  }
+  async keys() {
+    return this.#settle(await this.#run(LIST_SCRIPT, "keys"), 1).map(String);
+  }
+  async entries() {
+    const keys = await this.keys();
+    if (keys.length === 0)
+      return [];
+    const out = [];
+    for (let i = 0;i < keys.length; i += 1000) {
+      const batch = keys.slice(i, i + 1000);
+      const raws = await this.#redis.send("MGET", batch.map((k) => this.#ep + k));
+      raws.forEach((raw, j) => {
+        if (typeof raw === "string")
+          out.push([batch[j], this.#decode(raw)]);
+      });
+    }
+    return out;
+  }
+  async values() {
+    return (await this.entries()).map(([, value]) => value);
+  }
+  async ttlRemaining(key) {
+    const ms = Number(await this.#redis.send("PTTL", [this.#ep + String(key)]));
+    return ms >= 0 ? Math.max(0, ms - EXPIRY_GRACE_MS) : undefined;
+  }
+}
+function checkTTL(ttl, allowZero = false) {
+  if (ttl === undefined)
+    return;
+  if (!Number.isFinite(ttl) || ttl < 0 || !allowZero && ttl === 0)
+    throw new RangeError(allowZero ? "ttl must be 0 or a positive number." : "ttl must be a positive number.");
+}
+
+// packages/collection/src/index.ts
+function newPolicy(options = {}) {
+  return {
+    ttl: options.ttl,
+    jitter: options.jitter ?? 0,
+    maxSize: options.maxSize,
+    slide: options.slide ?? true,
+    onEvict: options.onEvict,
+    expired: 0,
+    evicted: 0,
+    entries: new Map,
+    oldest: undefined,
+    newest: undefined,
+    lruSize: 0,
+    heap: [],
+    armedFor: Infinity
+  };
+}
+function peekOf(collection, key) {
+  return collection instanceof Map ? Map.prototype.get.call(collection, key) : collection.get(key);
+}
+var mapGet = Map.prototype.get;
+var mapHas = Map.prototype.has;
+function sample(items, amount) {
+  if (!Number.isInteger(amount) || amount < 0)
+    throw new RangeError("amount must be a non-negative integer.");
+  const count = Math.min(amount, items.length);
+  for (let i = 0;i < count; i++) {
+    const j = i + Math.floor(Math.random() * (items.length - i));
+    [items[i], items[j]] = [items[j], items[i]];
+  }
+  items.length = count;
+  return items;
+}
+function assertTTL(ttl) {
+  if (ttl !== undefined && (!Number.isFinite(ttl) || ttl <= 0))
+    throw new RangeError("TTL must be a positive number, or omitted.");
+}
+
+class Collection2 extends Map {
+  #policy;
+  #hits = 0;
+  #misses = 0;
+  constructor(entries, options = {}) {
+    super();
+    assertTTL(options.ttl);
+    if (options.jitter !== undefined && !(options.jitter >= 0 && options.jitter <= 1))
+      throw new RangeError("jitter must be between 0 and 1.");
+    if (options.maxSize !== undefined && (!Number.isInteger(options.maxSize) || options.maxSize <= 0))
+      throw new RangeError("maxSize must be a positive integer.");
+    if (options.ttl !== undefined || options.jitter !== undefined || options.maxSize !== undefined || options.slide !== undefined || options.onEvict !== undefined)
+      this.#policy = newPolicy(options);
+    if (entries)
+      for (const [key, value] of entries)
+        this.set(key, value);
+  }
+  set(key, value, ttl) {
+    let policy = this.#policy;
+    if (ttl === undefined && policy === undefined)
+      return super.set(key, value);
+    if (ttl !== undefined)
+      assertTTL(ttl);
+    let window = ttl ?? policy?.ttl;
+    if (window !== undefined && policy !== undefined && policy.jitter > 0)
+      window = Math.max(1, window * (1 - policy.jitter * Math.random()));
+    if (policy === undefined) {
+      if (window === undefined)
+        return super.set(key, value);
+      policy = this.#policy = newPolicy();
+    }
+    const entry = policy.entries.get(key);
+    super.set(key, value);
+    if (entry !== undefined && window !== undefined && entry.window !== 0) {
+      const deadline = Date.now() + window;
+      if (deadline >= entry.filed) {
+        entry.value = value;
+        entry.deadline = deadline;
+        entry.window = window;
+        if (entry.inLru)
+          this.#promote(policy, entry);
+        return this;
+      }
+    }
+    this.#track(key, value, window, entry);
+    if (policy.maxSize !== undefined && policy.lruSize > policy.maxSize)
+      this.#enforceCap();
+    return this;
+  }
+  setWithoutTTL(key, value) {
+    if (this.#policy)
+      this.#forget(key);
+    super.set(key, value);
+    return this;
+  }
+  get(key) {
+    const policy = this.#policy;
+    const entry = policy?.entries.get(key);
+    if (entry === undefined) {
+      const value = mapGet.call(this, key);
+      if (value !== undefined || mapHas.call(this, key)) {
+        this.#hits++;
+        return value;
+      }
+      this.#misses++;
+      return;
+    }
+    const timed = entry.window !== 0;
+    const now = timed ? Date.now() : 0;
+    if (timed && entry.deadline <= now) {
+      this.#expire(entry);
+      this.#misses++;
+      return;
+    }
+    this.#hits++;
+    if (timed && policy.slide)
+      entry.deadline = now + entry.window;
+    if (entry.inLru)
+      this.#promote(policy, entry);
+    return entry.value;
+  }
+  ensure(key, factory, ttl) {
+    const existing = this.get(key);
+    if (existing !== undefined || super.has(key))
+      return existing;
+    const created = factory(key, this);
+    this.set(key, created, ttl);
+    return created;
+  }
+  peek(key) {
+    if (!this.#expireIfDue(key) && super.has(key)) {
+      this.#hits++;
+      return super.get(key);
+    }
+    this.#misses++;
+    return;
+  }
+  get stats() {
+    return {
+      hits: this.#hits,
+      misses: this.#misses,
+      expired: this.#policy?.expired ?? 0,
+      evicted: this.#policy?.evicted ?? 0
+    };
+  }
+  has(key) {
+    return !this.#expireIfDue(key) && super.has(key);
+  }
+  delete(key) {
+    if (this.#expireIfDue(key))
+      return false;
+    if (this.#policy)
+      this.#forget(key);
+    return super.delete(key);
+  }
+  clear() {
+    super.clear();
+    const policy = this.#policy;
+    if (!policy)
+      return;
+    policy.entries.clear();
+    policy.oldest = policy.newest = undefined;
+    policy.lruSize = 0;
+    policy.heap.length = 0;
+    if (policy.timer)
+      clearTimeout(policy.timer);
+    policy.timer = undefined;
+    policy.armedFor = Infinity;
+  }
+  get size() {
+    this.purge();
+    return super.size;
+  }
+  entries() {
+    this.purge();
+    return super.entries();
+  }
+  keys() {
+    this.purge();
+    return super.keys();
+  }
+  values() {
+    this.purge();
+    return super.values();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(callback, thisArg) {
+    this.purge();
+    super.forEach(callback, thisArg);
+  }
+  ttlRemaining(key) {
+    if (this.#expireIfDue(key))
+      return;
+    const entry = this.#policy?.entries.get(key);
+    return entry && entry.window !== 0 ? Math.max(0, entry.deadline - Date.now()) : undefined;
+  }
+  purge() {
+    if (!this.#policy || this.#policy.heap.length === 0)
+      return 0;
+    const now = Date.now();
+    let removed = 0;
+    const dropped = [];
+    while (this.#nextDeadline() <= now) {
+      const due = this.#heapPop();
+      dropped.push([due.key, super.get(due.key)]);
+      this.#remove(due.key);
+      removed++;
+    }
+    this.#policy.expired += removed;
+    this.#rearm();
+    for (const [key, value] of dropped)
+      this.#notify(key, value, "expired");
+    return removed;
+  }
+  #expireIfDue(key) {
+    const entry = this.#policy?.entries.get(key);
+    if (!entry || entry.window === 0 || entry.deadline > Date.now())
+      return false;
+    this.#expire(entry);
+    return true;
+  }
+  #expire(entry) {
+    const value = super.get(entry.key);
+    this.#remove(entry.key);
+    this.#policy.expired++;
+    this.#notify(entry.key, value, "expired");
+  }
+  #remove(key) {
+    this.#forget(key);
+    super.delete(key);
+  }
+  #forget(key) {
+    const policy = this.#policy;
+    const entry = policy.entries.get(key);
+    if (!entry)
+      return;
+    if (entry.inLru)
+      this.#unlink(policy, entry);
+    policy.entries.delete(key);
+  }
+  #track(key, value, window, existing) {
+    const policy = this.#policy;
+    const lru = policy.maxSize !== undefined;
+    let entry = existing;
+    if (entry)
+      entry.value = value;
+    if (window === undefined) {
+      if (entry && entry.window !== 0) {
+        if (lru)
+          entry = this.#replace(policy, entry, 0, 0);
+        else {
+          this.#forget(key);
+          return;
+        }
+      }
+      if (!entry && lru) {
+        entry = this.#create(key, value, 0, 0);
+        policy.entries.set(key, entry);
+      }
+      if (entry)
+        this.#promote(policy, entry);
+      return;
+    }
+    const deadline = Date.now() + window;
+    if (entry && entry.window !== 0) {
+      entry.deadline = deadline;
+      entry.window = window;
+      if (deadline < entry.filed)
+        entry = this.#replace(policy, entry, window, deadline);
+      else {
+        if (entry.inLru)
+          this.#promote(policy, entry);
+        return;
+      }
+    } else if (entry) {
+      entry.window = window;
+      entry.deadline = entry.filed = deadline;
+    } else {
+      entry = this.#create(key, value, window, deadline);
+      policy.entries.set(key, entry);
+    }
+    if (lru)
+      this.#promote(policy, entry);
+    this.#heapPush(entry);
+    if (policy.heap.length > 2 * policy.entries.size + 8)
+      this.#compact();
+    if (policy.timer === undefined || deadline < policy.armedFor)
+      this.#rearm();
+  }
+  #create(key, value, window, deadline) {
+    return {
+      key,
+      value,
+      older: undefined,
+      newer: undefined,
+      inLru: false,
+      window,
+      deadline,
+      filed: deadline
+    };
+  }
+  #replace(policy, old, window, deadline) {
+    const entry = {
+      ...old,
+      window,
+      deadline,
+      filed: deadline
+    };
+    if (old.inLru) {
+      if (old.older)
+        old.older.newer = entry;
+      else
+        policy.oldest = entry;
+      if (old.newer)
+        old.newer.older = entry;
+      else
+        policy.newest = entry;
+    }
+    policy.entries.set(old.key, entry);
+    return entry;
+  }
+  #promote(policy, entry) {
+    if (entry === policy.newest)
+      return;
+    if (entry.inLru)
+      this.#unlink(policy, entry, true);
+    else {
+      entry.inLru = true;
+      policy.lruSize++;
+    }
+    entry.older = policy.newest;
+    entry.newer = undefined;
+    if (policy.newest)
+      policy.newest.newer = entry;
+    else
+      policy.oldest = entry;
+    policy.newest = entry;
+  }
+  #unlink(policy, entry, keepCount = false) {
+    if (entry.older)
+      entry.older.newer = entry.newer;
+    else
+      policy.oldest = entry.newer;
+    if (entry.newer)
+      entry.newer.older = entry.older;
+    else
+      policy.newest = entry.older;
+    entry.older = entry.newer = undefined;
+    if (!keepCount) {
+      entry.inLru = false;
+      policy.lruSize--;
+    }
+  }
+  #derived() {
+    const Species = this.constructor[Symbol.species] ?? Collection2;
+    return new Species;
+  }
+  #notify(key, value, reason) {
+    const onEvict = this.#policy?.onEvict;
+    if (!onEvict)
+      return;
+    try {
+      onEvict(key, value, reason);
+    } catch {}
+  }
+  #enforceCap() {
+    const policy = this.#policy;
+    const max = policy.maxSize;
+    if (max === undefined)
+      return;
+    if (policy.lruSize > max && policy.heap.length > 0 && policy.heap[0].filed <= Date.now())
+      this.purge();
+    while (policy.lruSize > max) {
+      const oldest = policy.oldest;
+      const value = policy.onEvict ? super.get(oldest.key) : undefined;
+      const next = oldest.newer;
+      policy.oldest = next;
+      if (next)
+        next.older = undefined;
+      else
+        policy.newest = undefined;
+      oldest.newer = undefined;
+      oldest.inLru = false;
+      policy.lruSize--;
+      policy.entries.delete(oldest.key);
+      super.delete(oldest.key);
+      policy.evicted++;
+      if (policy.onEvict)
+        this.#notify(oldest.key, value, "evicted");
+    }
+  }
+  #nextDeadline() {
+    const policy = this.#policy;
+    for (;; ) {
+      const top = policy.heap[0];
+      if (top === undefined)
+        return Infinity;
+      if (policy.entries.get(top.key) !== top) {
+        this.#heapPop();
+        continue;
+      }
+      if (top.deadline === top.filed)
+        return top.filed;
+      this.#heapPop();
+      top.filed = top.deadline;
+      this.#heapPush(top);
+    }
+  }
+  #compact() {
+    const policy = this.#policy;
+    const live = policy.heap.filter((entry) => policy.entries.get(entry.key) === entry);
+    policy.heap.length = 0;
+    for (const entry of live)
+      this.#heapPush(entry);
+  }
+  #rearm() {
+    const p = this.#policy;
+    const deadline = this.#nextDeadline();
+    if (p.timer !== undefined && deadline >= p.armedFor)
+      return;
+    if (p.timer)
+      clearTimeout(p.timer);
+    p.timer = undefined;
+    p.armedFor = deadline;
+    if (deadline === Infinity)
+      return;
+    p.timer = setTimeout(() => {
+      p.timer = undefined;
+      p.armedFor = Infinity;
+      this.purge();
+    }, Math.max(0, deadline - Date.now()));
+    p.timer.unref?.();
+  }
+  #heapPush(entry) {
+    const heap = this.#policy.heap;
+    let i = heap.length;
+    heap.push(entry);
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      const above = heap[parent];
+      if (above.filed <= entry.filed)
+        break;
+      heap[i] = above;
+      i = parent;
+    }
+    heap[i] = entry;
+  }
+  #heapPop() {
+    const heap = this.#policy.heap;
+    const top = heap[0];
+    const last = heap.pop();
+    if (top === undefined || heap.length === 0)
+      return top;
+    let i = 0;
+    for (;; ) {
+      let child = 2 * i + 1;
+      if (child >= heap.length)
+        break;
+      if (child + 1 < heap.length && heap[child + 1].filed < heap[child].filed)
+        child++;
+      if (heap[child].filed >= last.filed)
+        break;
+      heap[i] = heap[child];
+      i = child;
+    }
+    heap[i] = last;
+    return top;
+  }
+  first() {
+    for (const value of this.values())
+      return value;
+    return;
+  }
+  firstKey() {
+    for (const key of this.keys())
+      return key;
+    return;
+  }
+  last() {
+    let value;
+    for (const item of this.values())
+      value = item;
+    return value;
+  }
+  lastKey() {
+    let key;
+    for (const item of this.keys())
+      key = item;
+    return key;
+  }
+  find(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return value;
+    }
+    return;
+  }
+  findLast(predicate) {
+    const keys = this.keyArray();
+    const values = this.array();
+    for (let i = values.length - 1;i >= 0; i--)
+      if (predicate(values[i], keys[i], this))
+        return values[i];
+    return;
+  }
+  findLastKey(predicate) {
+    const keys = this.keyArray();
+    const values = this.array();
+    for (let i = values.length - 1;i >= 0; i--)
+      if (predicate(values[i], keys[i], this))
+        return keys[i];
+    return;
+  }
+  filter(predicate) {
+    const result = this.#derived();
+    this.forEach((value, key) => {
+      if (predicate(value, key, this))
+        result.set(key, value);
+    });
+    return result;
+  }
+  map(transform) {
+    const result = [];
+    this.forEach((value, key) => {
+      result.push(transform(value, key, this));
+    });
+    return result;
+  }
+  some(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const [key, value] of this) {
+      if (!predicate(value, key, this))
+        return false;
+    }
+    return true;
+  }
+  each(callback) {
+    this.forEach((value, key) => {
+      callback(value, key, this);
+    });
+    return this;
+  }
+  array() {
+    return [...this.values()];
+  }
+  keyArray() {
+    return [...this.keys()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  clone() {
+    const copy = this.#derived();
+    this.forEach((value, key) => {
+      copy.set(key, value);
+    });
+    return copy;
+  }
+  hasAll(...keys) {
+    for (let i = 0;i < keys.length; i++) {
+      if (!this.has(keys[i]))
+        return false;
+    }
+    return true;
+  }
+  hasAny(...keys) {
+    for (let i = 0;i < keys.length; i++) {
+      if (this.has(keys[i]))
+        return true;
+    }
+    return false;
+  }
+  findKey(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        return key;
+    }
+    return;
+  }
+  someEntry(predicate) {
+    return this.some(predicate);
+  }
+  sweep(predicate) {
+    let removed = 0;
+    for (const [key, value] of this) {
+      if (predicate(value, key, this) && this.delete(key))
+        removed++;
+    }
+    return removed;
+  }
+  firstEntry() {
+    for (const [key, value] of this)
+      return [key, value];
+    return;
+  }
+  lastEntry() {
+    let entry;
+    for (const item of this)
+      entry = [item[0], item[1]];
+    return entry;
+  }
+  union(other) {
+    const result = this.clone();
+    for (const [key, value] of other)
+      result.set(key, value);
+    return result;
+  }
+  intersection(other) {
+    const result = this.#derived();
+    for (const [key, value] of this) {
+      if (other.has(key))
+        result.set(key, value);
+    }
+    return result;
+  }
+  difference(other) {
+    const result = this.#derived();
+    for (const [key, value] of this) {
+      if (!other.has(key))
+        result.set(key, value);
+    }
+    return result;
+  }
+  partition(predicate) {
+    const pass = this.#derived();
+    const fail = this.#derived();
+    for (const [key, value] of this) {
+      if (predicate(value, key, this))
+        pass.set(key, value);
+      else
+        fail.set(key, value);
+    }
+    return [pass, fail];
+  }
+  symmetricDifference(other) {
+    const result = this.#derived();
+    for (const [key, value] of this)
+      if (!other.has(key))
+        result.set(key, value);
+    for (const [key, value] of other)
+      if (!this.has(key))
+        result.set(key, value);
+    return result;
+  }
+  concat(...collections) {
+    const result = this.clone();
+    for (const collection of collections)
+      for (const [key, value] of collection)
+        result.set(key, value);
+    return result;
+  }
+  merge(other, whenInSelf, whenInOther, whenInBoth) {
+    const result = this.#derived();
+    const decide = (key, kept) => {
+      if (kept.keep)
+        result.set(key, kept.value);
+    };
+    for (const [key, value] of this) {
+      decide(key, other.has(key) ? whenInBoth(value, peekOf(other, key), key) : whenInSelf(value, key));
+    }
+    for (const [key, value] of other)
+      if (!this.has(key))
+        decide(key, whenInOther(value, key));
+    return result;
+  }
+  equals(other) {
+    if (!other)
+      return false;
+    if (other === this)
+      return true;
+    if (this.size !== other.size)
+      return false;
+    for (const [key, value] of this) {
+      if (!other.has(key))
+        return false;
+      if (value !== peekOf(other, key))
+        return false;
+    }
+    return true;
+  }
+  mapValues(transform) {
+    const result = this.#derived();
+    for (const [key, value] of this)
+      result.set(key, transform(value, key, this));
+    return result;
+  }
+  toReversed() {
+    const result = this.#derived();
+    const entries = [...this];
+    for (let i = entries.length - 1;i >= 0; i--)
+      result.set(entries[i][0], entries[i][1]);
+    return result;
+  }
+  toSorted(comparator) {
+    return this.sorted(comparator);
+  }
+  static groupBy(items, keySelector) {
+    const groups = new Collection2;
+    let index = 0;
+    for (const item of items)
+      groups.ensure(keySelector(item, index++), () => []).push(item);
+    return groups;
+  }
+  static combineEntries(entries, combine) {
+    const result = new Collection2;
+    for (const [key, value] of entries)
+      result.set(key, result.has(key) ? combine(result.get(key), value, key) : value);
+    return result;
+  }
+  tap(fn) {
+    fn(this);
+    return this;
+  }
+  flatMap(transform) {
+    const result = [];
+    for (const [key, value] of this) {
+      for (const item of transform(value, key, this))
+        result.push(item);
+    }
+    return result;
+  }
+  reduce(fn, initialValue) {
+    let acc = initialValue;
+    for (const [key, value] of this)
+      acc = fn(acc, value, key, this);
+    return acc;
+  }
+  reduceRight(fn, initialValue) {
+    const entries = [...this];
+    let acc = initialValue;
+    for (let i = entries.length - 1;i >= 0; i--)
+      acc = fn(acc, entries[i][1], entries[i][0], this);
+    return acc;
+  }
+  sorted(comparator) {
+    const decorated = [...this.entries()].map((entry, index) => ({
+      entry,
+      index
+    }));
+    if (comparator)
+      decorated.sort((x, y) => {
+        const comparison = comparator(x.entry[1], y.entry[1], x.entry[0], y.entry[0]);
+        return comparison !== 0 ? comparison : x.index - y.index;
+      });
+    const result = this.#derived();
+    for (const { entry } of decorated)
+      result.set(entry[0], entry[1]);
+    return result;
+  }
+  random(amount) {
+    if (amount !== undefined)
+      return sample([...this.values()], amount);
+    const size = this.size;
+    if (size === 0)
+      return;
+    let index = Math.floor(Math.random() * size);
+    for (const value of this.values())
+      if (index-- === 0)
+        return value;
+    return;
+  }
+  randomKey(amount) {
+    if (amount !== undefined)
+      return sample([...this.keys()], amount);
+    const size = this.size;
+    if (size === 0)
+      return;
+    let index = Math.floor(Math.random() * size);
+    for (const key of this.keys())
+      if (index-- === 0)
+        return key;
+    return;
+  }
+  at(index) {
+    let remaining = index < 0 ? this.size + index : index;
+    if (remaining < 0)
+      return;
+    for (const value of this.values())
+      if (remaining-- === 0)
+        return value;
+    return;
+  }
+  keyAt(index) {
+    let remaining = index < 0 ? this.size + index : index;
+    if (remaining < 0)
+      return;
+    for (const key of this.keys())
+      if (remaining-- === 0)
+        return key;
+    return;
+  }
+  toJSON() {
+    return [...this.entries()];
+  }
+}
+
+export { Cache2, RedisCollection2, Collection2 };
+
+//# debugId=8210ED8C141EF20B64756E2164756E21