lunibee 0.3.3 → 0.4.0

package/dist/collection/index.js

@@ -1,1122 +1,13 @@
 // @bun
-// packages/collection/src/cache.ts
-class Cache {
-  #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 Collection(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 RedisCollection {
-  #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 Collection 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] ?? Collection;
-    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 Collection;
-    let index = 0;
-    for (const item of items)
-      groups.ensure(keySelector(item, index++), () => []).push(item);
-    return groups;
-  }
-  static combineEntries(entries, combine) {
-    const result = new Collection;
-    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()];
-  }
-}
+import {
+  Cache2,
+  RedisCollection2,
+  Collection2
+} from "../chunks/index-cnmsajvk.js";
 export {
-  Cache,
-  Collection,
-  RedisCollection
+  Cache2 as Cache,
+  Collection2 as Collection,
+  RedisCollection2 as RedisCollection
 };
 
-//# debugId=8859F4CE73F8594764756E2164756E21
+//# debugId=694EF185C42CBF7E64756E2164756E21