moved around files

user-mgmt_backend/node_modules/lru.min/lib/index.mjs

@@ -0,0 +1,207 @@
+const createLRU = (options) => {
+  let { max } = options;
+  if (!(Number.isInteger(max) && max > 0))
+    throw new TypeError("`max` must be a positive integer");
+  let size = 0;
+  let head = 0;
+  let tail = 0;
+  let free = [];
+  const { onEviction } = options;
+  const keyMap = /* @__PURE__ */ new Map();
+  const keyList = new Array(max).fill(void 0);
+  const valList = new Array(max).fill(void 0);
+  const next = new Array(max).fill(0);
+  const prev = new Array(max).fill(0);
+  const setTail = (index, type) => {
+    if (index === tail) return;
+    const nextIndex = next[index];
+    const prevIndex = prev[index];
+    if (index === head) head = nextIndex;
+    else if (type === "get" || prevIndex !== 0) next[prevIndex] = nextIndex;
+    if (nextIndex !== 0) prev[nextIndex] = prevIndex;
+    next[tail] = index;
+    prev[index] = tail;
+    next[index] = 0;
+    tail = index;
+  };
+  const _evict = () => {
+    const evictHead = head;
+    const key = keyList[evictHead];
+    onEviction == null ? void 0 : onEviction(key, valList[evictHead]);
+    keyMap.delete(key);
+    keyList[evictHead] = void 0;
+    valList[evictHead] = void 0;
+    head = next[evictHead];
+    if (head !== 0) prev[head] = 0;
+    size--;
+    if (size === 0) head = tail = 0;
+    free.push(evictHead);
+    return evictHead;
+  };
+  return {
+    /** Adds a key-value pair to the cache. Updates the value if the key already exists. */
+    set(key, value) {
+      if (key === void 0) return;
+      let index = keyMap.get(key);
+      if (index === void 0) {
+        index = size === max ? _evict() : free.length > 0 ? free.pop() : size;
+        keyMap.set(key, index);
+        keyList[index] = key;
+        size++;
+      } else onEviction == null ? void 0 : onEviction(key, valList[index]);
+      valList[index] = value;
+      if (size === 1) head = tail = index;
+      else setTail(index, "set");
+    },
+    /** Retrieves the value for a given key and moves the key to the most recent position. */
+    get(key) {
+      const index = keyMap.get(key);
+      if (index === void 0) return;
+      if (index !== tail) setTail(index, "get");
+      return valList[index];
+    },
+    /** Retrieves the value for a given key without changing its position. */
+    peek: (key) => {
+      const index = keyMap.get(key);
+      return index !== void 0 ? valList[index] : void 0;
+    },
+    /** Checks if a key exists in the cache. */
+    has: (key) => keyMap.has(key),
+    /** Iterates over all keys in the cache, from most recent to least recent. */
+    *keys() {
+      let current = tail;
+      for (let i = 0; i < size; i++) {
+        yield keyList[current];
+        current = prev[current];
+      }
+    },
+    /** Iterates over all values in the cache, from most recent to least recent. */
+    *values() {
+      let current = tail;
+      for (let i = 0; i < size; i++) {
+        yield valList[current];
+        current = prev[current];
+      }
+    },
+    /** Iterates over `[key, value]` pairs in the cache, from most recent to least recent. */
+    *entries() {
+      let current = tail;
+      for (let i = 0; i < size; i++) {
+        yield [keyList[current], valList[current]];
+        current = prev[current];
+      }
+    },
+    /** Iterates over each value-key pair in the cache, from most recent to least recent. */
+    forEach: (callback) => {
+      let current = tail;
+      for (let i = 0; i < size; i++) {
+        const key = keyList[current];
+        const value = valList[current];
+        callback(value, key);
+        current = prev[current];
+      }
+    },
+    /** Deletes a key-value pair from the cache. */
+    delete(key) {
+      const index = keyMap.get(key);
+      if (index === void 0) return false;
+      onEviction == null ? void 0 : onEviction(key, valList[index]);
+      keyMap.delete(key);
+      free.push(index);
+      keyList[index] = void 0;
+      valList[index] = void 0;
+      const prevIndex = prev[index];
+      const nextIndex = next[index];
+      if (prevIndex !== 0) next[prevIndex] = nextIndex;
+      if (nextIndex !== 0) prev[nextIndex] = prevIndex;
+      if (index === head) head = nextIndex;
+      if (index === tail) tail = prevIndex;
+      size--;
+      return true;
+    },
+    /** Evicts the oldest item or the specified number of the oldest items from the cache. */
+    evict: (number) => {
+      let toPrune = Math.min(number, size);
+      while (toPrune > 0) {
+        _evict();
+        toPrune--;
+      }
+    },
+    /** Clears all key-value pairs from the cache. */
+    clear() {
+      if (typeof onEviction === "function") {
+        const iterator = keyMap.values();
+        for (let result = iterator.next(); !result.done; result = iterator.next())
+          onEviction(keyList[result.value], valList[result.value]);
+      }
+      keyMap.clear();
+      keyList.fill(void 0);
+      valList.fill(void 0);
+      free = [];
+      size = 0;
+      head = tail = 0;
+    },
+    /** Resizes the cache to a new maximum size, evicting items if necessary. */
+    resize: (newMax) => {
+      if (!(Number.isInteger(newMax) && newMax > 0))
+        throw new TypeError("`max` must be a positive integer");
+      if (newMax === max) return;
+      if (newMax < max) {
+        let current = tail;
+        const preserve = Math.min(size, newMax);
+        const remove = size - preserve;
+        const newKeyList = new Array(newMax);
+        const newValList = new Array(newMax);
+        const newNext = new Array(newMax);
+        const newPrev = new Array(newMax);
+        for (let i = 1; i <= remove; i++)
+          onEviction == null ? void 0 : onEviction(keyList[i], valList[i]);
+        for (let i = preserve - 1; i >= 0; i--) {
+          newKeyList[i] = keyList[current];
+          newValList[i] = valList[current];
+          newNext[i] = i + 1;
+          newPrev[i] = i - 1;
+          keyMap.set(newKeyList[i], i);
+          current = prev[current];
+        }
+        head = 0;
+        tail = preserve - 1;
+        size = preserve;
+        keyList.length = newMax;
+        valList.length = newMax;
+        next.length = newMax;
+        prev.length = newMax;
+        for (let i = 0; i < preserve; i++) {
+          keyList[i] = newKeyList[i];
+          valList[i] = newValList[i];
+          next[i] = newNext[i];
+          prev[i] = newPrev[i];
+        }
+        free = [];
+        for (let i = preserve; i < newMax; i++) free.push(i);
+      } else {
+        const fill = newMax - max;
+        keyList.push(...new Array(fill).fill(void 0));
+        valList.push(...new Array(fill).fill(void 0));
+        next.push(...new Array(fill).fill(0));
+        prev.push(...new Array(fill).fill(0));
+      }
+      max = newMax;
+    },
+    /** Returns the maximum number of items that can be stored in the cache. */
+    get max() {
+      return max;
+    },
+    /** Returns the number of items currently stored in the cache. */
+    get size() {
+      return size;
+    },
+    /** Returns the number of currently available slots in the cache before reaching the maximum size. */
+    get available() {
+      return max - size;
+    }
+  };
+};
+export {
+  createLRU
+};