@modern-js/runtime-utils 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/universal/cache.js

@@ -1,432 +1,381 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cache_exports = {};
-__export(cache_exports, {
-  CacheSize: () => CacheSize,
-  CacheTime: () => CacheTime,
-  cache: () => cache,
-  clearStore: () => clearStore,
-  configureCache: () => configureCache,
-  generateKey: () => generateKey,
-  revalidateTag: () => revalidateTag,
-  withRequestCache: () => withRequestCache
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    cache: ()=>cache,
+    revalidateTag: ()=>revalidateTag,
+    CacheSize: ()=>CacheSize,
+    clearStore: ()=>clearStore,
+    configureCache: ()=>configureCache,
+    withRequestCache: ()=>withRequestCache,
+    generateKey: ()=>generateKey,
+    CacheTime: ()=>CacheTime
 });
-module.exports = __toCommonJS(cache_exports);
-var import_lru_cache = require("lru-cache");
-var import_async_storage = require("./async_storage");
+const external_lru_cache_namespaceObject = require("lru-cache");
+const external_async_storage_js_namespaceObject = require("./async_storage.js");
 const CacheSize = {
-  KB: 1024,
-  MB: 1024 * 1024,
-  GB: 1024 * 1024 * 1024
+    KB: 1024,
+    MB: 1048576,
+    GB: 1073741824
 };
 const CacheTime = {
-  SECOND: 1e3,
-  MINUTE: 60 * 1e3,
-  HOUR: 60 * 60 * 1e3,
-  DAY: 24 * 60 * 60 * 1e3,
-  WEEK: 7 * 24 * 60 * 60 * 1e3,
-  MONTH: 30 * 24 * 60 * 60 * 1e3
+    SECOND: 1000,
+    MINUTE: 60000,
+    HOUR: 3600000,
+    DAY: 86400000,
+    WEEK: 604800000,
+    MONTH: 2592000000
 };
 function estimateObjectSize(data) {
-  const type = typeof data;
-  if (type === "number")
-    return 8;
-  if (type === "boolean")
-    return 4;
-  if (type === "string")
-    return Math.max(data.length * 2, 1);
-  if (data === null || data === void 0)
+    const type = typeof data;
+    if ('number' === type) return 8;
+    if ('boolean' === type) return 4;
+    if ('string' === type) return Math.max(2 * data.length, 1);
+    if (null == data) return 1;
+    if (ArrayBuffer.isView(data)) return Math.max(data.byteLength, 1);
+    if (Array.isArray(data)) return Math.max(data.reduce((acc, item)=>acc + estimateObjectSize(item), 0), 1);
+    if (data instanceof Map || data instanceof Set) return 1024;
+    if (data instanceof Date) return 8;
+    if ('object' === type) return Math.max(Object.entries(data).reduce((acc, [key, value])=>acc + 2 * key.length + estimateObjectSize(value), 0), 1);
     return 1;
-  if (ArrayBuffer.isView(data)) {
-    return Math.max(data.byteLength, 1);
-  }
-  if (Array.isArray(data)) {
-    return Math.max(data.reduce((acc, item) => acc + estimateObjectSize(item), 0), 1);
-  }
-  if (data instanceof Map || data instanceof Set) {
-    return 1024;
-  }
-  if (data instanceof Date) {
-    return 8;
-  }
-  if (type === "object") {
-    return Math.max(Object.entries(data).reduce((acc, [key, value]) => acc + key.length * 2 + estimateObjectSize(value), 0), 1);
-  }
-  return 1;
 }
 class MemoryContainer {
-  async get(key) {
-    return this.lru.get(key);
-  }
-  async set(key, value, options) {
-    if (options === null || options === void 0 ? void 0 : options.ttl) {
-      this.lru.set(key, value, {
-        ttl: options.ttl * 1e3
-      });
-    } else {
-      this.lru.set(key, value);
+    async get(key) {
+        return this.lru.get(key);
+    }
+    async set(key, value, options) {
+        if (options?.ttl) this.lru.set(key, value, {
+            ttl: 1000 * options.ttl
+        });
+        else this.lru.set(key, value);
+    }
+    async has(key) {
+        return this.lru.has(key);
+    }
+    async delete(key) {
+        return this.lru.delete(key);
+    }
+    async clear() {
+        this.lru.clear();
+    }
+    constructor(options){
+        this.lru = new external_lru_cache_namespaceObject.LRUCache({
+            maxSize: options?.maxSize ?? CacheSize.GB,
+            sizeCalculation: estimateObjectSize,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true
+        });
     }
-  }
-  async has(key) {
-    return this.lru.has(key);
-  }
-  async delete(key) {
-    return this.lru.delete(key);
-  }
-  async clear() {
-    this.lru.clear();
-  }
-  constructor(options) {
-    var _options_maxSize;
-    this.lru = new import_lru_cache.LRUCache({
-      maxSize: (_options_maxSize = options === null || options === void 0 ? void 0 : options.maxSize) !== null && _options_maxSize !== void 0 ? _options_maxSize : CacheSize.GB,
-      sizeCalculation: estimateObjectSize,
-      updateAgeOnGet: true,
-      updateAgeOnHas: true
-    });
-  }
 }
-const isServer = typeof window === "undefined";
-const requestCacheMap = /* @__PURE__ */ new WeakMap();
-const TAG_PREFIX = "tag:";
-const CACHE_PREFIX = "modernjs_cache:";
-const ongoingRevalidations = /* @__PURE__ */ new Map();
-let storage;
+const isServer = "u" < typeof window;
+const requestCacheMap = new WeakMap();
+const TAG_PREFIX = 'tag:';
+const CACHE_PREFIX = 'modernjs_cache:';
+const ongoingRevalidations = new Map();
+let cache_storage;
 let cacheConfig = {
-  maxSize: CacheSize.GB
+    maxSize: CacheSize.GB
 };
 function getStorage() {
-  if (storage) {
-    return storage;
-  }
-  if (cacheConfig.container) {
-    storage = cacheConfig.container;
-  } else {
-    storage = new MemoryContainer({
-      maxSize: cacheConfig.maxSize
+    if (cache_storage) return cache_storage;
+    cache_storage = cacheConfig.container ? cacheConfig.container : new MemoryContainer({
+        maxSize: cacheConfig.maxSize
     });
-  }
-  return storage;
+    return cache_storage;
 }
 function configureCache(config) {
-  cacheConfig = {
-    ...cacheConfig,
-    ...config
-  };
-  storage = void 0;
+    cacheConfig = {
+        ...cacheConfig,
+        ...config
+    };
+    cache_storage = void 0;
 }
 function generateKey(args) {
-  return JSON.stringify(args, (_, value) => {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      return Object.keys(value).sort().reduce((result, key) => {
-        result[key] = value[key];
-        return result;
-      }, {});
-    }
-    return value;
-  });
+    return JSON.stringify(args, (_, value)=>{
+        if (value && 'object' == typeof value && !Array.isArray(value)) return Object.keys(value).sort().reduce((result, key)=>{
+            result[key] = value[key];
+            return result;
+        }, {});
+        return value;
+    });
 }
 function generateStableFunctionId(fn) {
-  const fnString = fn.toString();
-  let hash = 0;
-  for (let i = 0; i < fnString.length; i++) {
-    const char = fnString.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return `fn_${fn.name || "anonymous"}_${Math.abs(hash).toString(36)}`;
+    const fnString = fn.toString();
+    let hash = 0;
+    for(let i = 0; i < fnString.length; i++){
+        const char = fnString.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash &= hash;
+    }
+    return `fn_${fn.name || 'anonymous'}_${Math.abs(hash).toString(36)}`;
 }
 function cache(fn, options) {
-  return async (...args) => {
-    if (isServer && typeof options === "undefined") {
-      var _storage_useContext;
-      const storage2 = (0, import_async_storage.getAsyncLocalStorage)();
-      const request = storage2 === null || storage2 === void 0 ? void 0 : (_storage_useContext = storage2.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
-      if (request) {
-        let shouldDisableCaching = false;
-        if (cacheConfig.unstable_shouldDisable) {
-          shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
-            request
-          });
-        }
-        if (shouldDisableCaching) {
-          return fn(...args);
-        }
-        let requestCache = requestCacheMap.get(request);
-        if (!requestCache) {
-          requestCache = /* @__PURE__ */ new Map();
-          requestCacheMap.set(request, requestCache);
-        }
-        let fnCache = requestCache.get(fn);
-        if (!fnCache) {
-          fnCache = /* @__PURE__ */ new Map();
-          requestCache.set(fn, fnCache);
-        }
-        const key = generateKey(args);
-        if (fnCache.has(key)) {
-          return fnCache.get(key);
-        }
-        const promise = fn(...args);
-        fnCache.set(key, promise);
-        try {
-          const data = await promise;
-          return data;
-        } catch (error) {
-          fnCache.delete(key);
-          throw error;
-        }
-      }
-    } else if (typeof options !== "undefined") {
-      try {
-        const { tag, maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey, unstable_shouldCache } = options;
-        let missReason;
-        const currentStorage = getStorage();
-        const now = Date.now();
-        const tags = tag ? Array.isArray(tag) ? tag : [
-          tag
-        ] : [];
-        const genKey = getKey ? getKey(...args) : generateKey(args);
-        let finalKey;
-        if (customKey) {
-          finalKey = customKey({
-            params: args,
-            fn,
-            generatedKey: genKey
-          });
-        } else {
-          const functionId = generateStableFunctionId(fn);
-          finalKey = `${functionId}:${genKey}`;
-        }
-        const storageKey = `${CACHE_PREFIX}${finalKey}`;
-        let shouldDisableCaching = false;
-        if (isServer && cacheConfig.unstable_shouldDisable) {
-          var _asyncStorage_useContext;
-          const asyncStorage = (0, import_async_storage.getAsyncLocalStorage)();
-          const request = asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext = asyncStorage.useContext()) === null || _asyncStorage_useContext === void 0 ? void 0 : _asyncStorage_useContext.request;
-          if (request) {
-            shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
-              request
-            });
-          }
-        }
-        if (!shouldDisableCaching) {
-          const cached = await currentStorage.get(storageKey);
-          if (cached) {
-            try {
-              const cacheItem = cached;
-              const age = now - cacheItem.timestamp;
-              if (age < maxAge) {
-                onCache === null || onCache === void 0 ? void 0 : onCache({
-                  status: "hit",
-                  key: finalKey,
-                  params: args,
-                  result: cacheItem.data
+    return async (...args)=>{
+        if (isServer && void 0 === options) {
+            const storage = await (0, external_async_storage_js_namespaceObject.getAsyncLocalStorage)();
+            const request = storage?.useContext()?.request;
+            if (request) {
+                let shouldDisableCaching = false;
+                if (cacheConfig.unstable_shouldDisable) shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+                    request
                 });
-                return cacheItem.data;
-              }
-              if (revalidate > 0 && age < maxAge + revalidate) {
-                onCache === null || onCache === void 0 ? void 0 : onCache({
-                  status: "stale",
-                  key: finalKey,
-                  params: args,
-                  result: cacheItem.data
+                if (shouldDisableCaching) return fn(...args);
+                let requestCache = requestCacheMap.get(request);
+                if (!requestCache) {
+                    requestCache = new Map();
+                    requestCacheMap.set(request, requestCache);
+                }
+                let fnCache = requestCache.get(fn);
+                if (!fnCache) {
+                    fnCache = new Map();
+                    requestCache.set(fn, fnCache);
+                }
+                const key = generateKey(args);
+                if (fnCache.has(key)) return fnCache.get(key);
+                const promise = fn(...args);
+                fnCache.set(key, promise);
+                try {
+                    const data = await promise;
+                    return data;
+                } catch (error) {
+                    fnCache.delete(key);
+                    throw error;
+                }
+            }
+        } else if (void 0 !== options) try {
+            const { tag, maxAge = 5 * CacheTime.MINUTE, revalidate = 0, customKey, onCache, getKey, unstable_shouldCache } = options;
+            let missReason;
+            const currentStorage = getStorage();
+            const now = Date.now();
+            const tags = tag ? Array.isArray(tag) ? tag : [
+                tag
+            ] : [];
+            const genKey = getKey ? getKey(...args) : generateKey(args);
+            let finalKey;
+            if (customKey) finalKey = customKey({
+                params: args,
+                fn,
+                generatedKey: genKey
+            });
+            else {
+                const functionId = generateStableFunctionId(fn);
+                finalKey = `${functionId}:${genKey}`;
+            }
+            const storageKey = `${CACHE_PREFIX}${finalKey}`;
+            let shouldDisableCaching = false;
+            if (isServer && cacheConfig.unstable_shouldDisable) {
+                const asyncStorage = await (0, external_async_storage_js_namespaceObject.getAsyncLocalStorage)();
+                const request = asyncStorage?.useContext()?.request;
+                if (request) shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+                    request
                 });
-                if (!ongoingRevalidations.has(storageKey)) {
-                  const revalidationPromise = (async () => {
-                    try {
-                      const newData = await fn(...args);
-                      let shouldCache = true;
-                      if (unstable_shouldCache) {
-                        shouldCache = await unstable_shouldCache({
-                          params: args,
-                          result: newData
+            }
+            if (shouldDisableCaching) missReason = 1;
+            else {
+                const cached = await currentStorage.get(storageKey);
+                if (cached) try {
+                    const cacheItem = cached;
+                    const age = now - cacheItem.timestamp;
+                    if (age < maxAge) {
+                        onCache?.({
+                            status: 'hit',
+                            key: finalKey,
+                            params: args,
+                            result: cacheItem.data
+                        });
+                        return cacheItem.data;
+                    }
+                    if (revalidate > 0 && age < maxAge + revalidate) {
+                        onCache?.({
+                            status: 'stale',
+                            key: finalKey,
+                            params: args,
+                            result: cacheItem.data
                         });
-                      }
-                      if (shouldCache) {
-                        await setCacheItem(currentStorage, storageKey, newData, tags, maxAge, revalidate);
-                      }
-                    } catch (error) {
-                      if (isServer) {
-                        var _asyncStorage_useContext_monitors, _asyncStorage_useContext2;
-                        const asyncStorage = (0, import_async_storage.getAsyncLocalStorage)();
-                        asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext2 = asyncStorage.useContext()) === null || _asyncStorage_useContext2 === void 0 ? void 0 : (_asyncStorage_useContext_monitors = _asyncStorage_useContext2.monitors) === null || _asyncStorage_useContext_monitors === void 0 ? void 0 : _asyncStorage_useContext_monitors.error(error.message);
-                      } else {
-                        console.error("Background revalidation failed:", error);
-                      }
-                    } finally {
-                      ongoingRevalidations.delete(storageKey);
+                        if (!ongoingRevalidations.has(storageKey)) {
+                            const revalidationPromise = (async ()=>{
+                                try {
+                                    const newData = await fn(...args);
+                                    let shouldCache = true;
+                                    if (unstable_shouldCache) shouldCache = await unstable_shouldCache({
+                                        params: args,
+                                        result: newData
+                                    });
+                                    if (shouldCache) await setCacheItem(currentStorage, storageKey, newData, tags, maxAge, revalidate);
+                                } catch (error) {
+                                    if (isServer) {
+                                        const asyncStorage = await (0, external_async_storage_js_namespaceObject.getAsyncLocalStorage)();
+                                        asyncStorage?.useContext()?.monitors?.error(error.message);
+                                    } else console.error('Background revalidation failed:', error);
+                                } finally{
+                                    ongoingRevalidations.delete(storageKey);
+                                }
+                            })();
+                            ongoingRevalidations.set(storageKey, revalidationPromise);
+                        }
+                        return cacheItem.data;
                     }
-                  })();
-                  ongoingRevalidations.set(storageKey, revalidationPromise);
+                    missReason = 3;
+                } catch (error) {
+                    console.warn('Failed to parse cached data:', error);
+                    missReason = 4;
                 }
-                return cacheItem.data;
-              }
-              missReason = 3;
-            } catch (error) {
-              console.warn("Failed to parse cached data:", error);
-              missReason = 4;
+                else missReason = 2;
             }
-          } else {
-            missReason = 2;
-          }
-        } else {
-          missReason = 1;
-        }
-        const data = await fn(...args);
-        if (!shouldDisableCaching) {
-          let shouldCache = true;
-          if (unstable_shouldCache) {
-            shouldCache = await unstable_shouldCache({
-              params: args,
-              result: data
+            const data = await fn(...args);
+            if (!shouldDisableCaching) {
+                let shouldCache = true;
+                if (unstable_shouldCache) shouldCache = await unstable_shouldCache({
+                    params: args,
+                    result: data
+                });
+                if (shouldCache) await setCacheItem(currentStorage, storageKey, data, tags, maxAge, revalidate);
+            }
+            onCache?.({
+                status: 'miss',
+                key: finalKey,
+                params: args,
+                result: data,
+                reason: missReason
             });
-          }
-          if (shouldCache) {
-            await setCacheItem(currentStorage, storageKey, data, tags, maxAge, revalidate);
-          }
+            return data;
+        } catch (error) {
+            console.warn('Cache operation failed, falling back to direct execution:', error);
+            const data = await fn(...args);
+            const { onCache } = options;
+            try {
+                onCache?.({
+                    status: 'miss',
+                    key: 'cache_failed',
+                    params: args,
+                    result: data,
+                    reason: 5
+                });
+            } catch (callbackError) {
+                console.warn('Failed to call onCache callback:', callbackError);
+            }
+            return data;
         }
-        onCache === null || onCache === void 0 ? void 0 : onCache({
-          status: "miss",
-          key: finalKey,
-          params: args,
-          result: data,
-          reason: missReason
-        });
-        return data;
-      } catch (error) {
-        console.warn("Cache operation failed, falling back to direct execution:", error);
-        const data = await fn(...args);
-        const { onCache } = options;
-        try {
-          onCache === null || onCache === void 0 ? void 0 : onCache({
-            status: "miss",
-            key: "cache_failed",
-            params: args,
-            result: data,
-            reason: 5
-          });
-        } catch (callbackError) {
-          console.warn("Failed to call onCache callback:", callbackError);
+        else {
+            console.warn('The cache function will not work because it runs on the browser and there are no options are provided.');
+            return fn(...args);
         }
-        return data;
-      }
-    } else {
-      console.warn("The cache function will not work because it runs on the browser and there are no options are provided.");
-      return fn(...args);
-    }
-  };
+    };
 }
-async function setCacheItem(storage2, storageKey, data, tags, maxAge, revalidate) {
-  const newItem = {
-    data,
-    timestamp: Date.now(),
-    tags: tags.length > 0 ? tags : void 0
-  };
-  const ttl = (maxAge + revalidate) / 1e3;
-  await storage2.set(storageKey, newItem, {
-    ttl: ttl > 0 ? ttl : void 0
-  });
-  await updateTagRelationships(storage2, storageKey, tags);
+async function setCacheItem(storage, storageKey, data, tags, maxAge, revalidate) {
+    const newItem = {
+        data,
+        timestamp: Date.now(),
+        tags: tags.length > 0 ? tags : void 0
+    };
+    const ttl = (maxAge + revalidate) / 1000;
+    await storage.set(storageKey, newItem, {
+        ttl: ttl > 0 ? ttl : void 0
+    });
+    await updateTagRelationships(storage, storageKey, tags);
 }
-async function updateTagRelationships(storage2, storageKey, tags) {
-  for (const tag of tags) {
-    const tagStoreKey = `${TAG_PREFIX}${tag}`;
-    const keyList = await storage2.get(tagStoreKey);
-    const keyArray = keyList || [];
-    if (!keyArray.includes(storageKey)) {
-      keyArray.push(storageKey);
+async function updateTagRelationships(storage, storageKey, tags) {
+    for (const tag of tags){
+        const tagStoreKey = `${TAG_PREFIX}${tag}`;
+        const keyList = await storage.get(tagStoreKey);
+        const keyArray = keyList || [];
+        if (!keyArray.includes(storageKey)) keyArray.push(storageKey);
+        await storage.set(tagStoreKey, keyArray);
     }
-    await storage2.set(tagStoreKey, keyArray);
-  }
 }
-async function removeKeyFromTags(storage2, storageKey, tags) {
-  for (const tag of tags) {
-    const tagStoreKey = `${TAG_PREFIX}${tag}`;
-    const keyList = await storage2.get(tagStoreKey);
-    if (keyList) {
-      try {
-        const keyArray = Array.isArray(keyList) ? keyList : [];
-        const updatedKeyList = keyArray.filter((key) => key !== storageKey);
-        if (updatedKeyList.length > 0) {
-          await storage2.set(tagStoreKey, updatedKeyList);
-        } else {
-          await storage2.delete(tagStoreKey);
+async function removeKeyFromTags(storage, storageKey, tags) {
+    for (const tag of tags){
+        const tagStoreKey = `${TAG_PREFIX}${tag}`;
+        const keyList = await storage.get(tagStoreKey);
+        if (keyList) try {
+            const keyArray = Array.isArray(keyList) ? keyList : [];
+            const updatedKeyList = keyArray.filter((key)=>key !== storageKey);
+            if (updatedKeyList.length > 0) await storage.set(tagStoreKey, updatedKeyList);
+            else await storage.delete(tagStoreKey);
+        } catch (error) {
+            console.warn(`Failed to process tag key list for tag ${tag}:`, error);
         }
-      } catch (error) {
-        console.warn(`Failed to process tag key list for tag ${tag}:`, error);
-      }
     }
-  }
 }
 function withRequestCache(handler) {
-  if (!isServer) {
-    return handler;
-  }
-  return async (req, ...args) => {
-    const storage2 = (0, import_async_storage.getAsyncLocalStorage)();
-    return storage2.run({
-      request: req
-    }, () => handler(req, ...args));
-  };
+    if (!isServer) return handler;
+    return async (req, ...args)=>{
+        const storage = await (0, external_async_storage_js_namespaceObject.getAsyncLocalStorage)();
+        return storage.run({
+            request: req
+        }, ()=>handler(req, ...args));
+    };
 }
 async function revalidateTag(tag) {
-  const currentStorage = getStorage();
-  const tagStoreKey = `${TAG_PREFIX}${tag}`;
-  const keyList = await currentStorage.get(tagStoreKey);
-  if (keyList) {
-    try {
-      const keyArray = Array.isArray(keyList) ? keyList : [];
-      for (const cacheKey of keyArray) {
-        const cached = await currentStorage.get(cacheKey);
-        if (cached) {
-          try {
-            const cacheItem = cached;
-            if (cacheItem.tags) {
-              const otherTags = cacheItem.tags.filter((t) => t !== tag);
-              await removeKeyFromTags(currentStorage, cacheKey, otherTags);
+    const currentStorage = getStorage();
+    const tagStoreKey = `${TAG_PREFIX}${tag}`;
+    const keyList = await currentStorage.get(tagStoreKey);
+    if (keyList) try {
+        const keyArray = Array.isArray(keyList) ? keyList : [];
+        for (const cacheKey of keyArray){
+            const cached = await currentStorage.get(cacheKey);
+            if (cached) try {
+                const cacheItem = cached;
+                if (cacheItem.tags) {
+                    const otherTags = cacheItem.tags.filter((t)=>t !== tag);
+                    await removeKeyFromTags(currentStorage, cacheKey, otherTags);
+                }
+            } catch (error) {
+                console.warn('Failed to parse cached data while revalidating:', error);
             }
-          } catch (error) {
-            console.warn("Failed to parse cached data while revalidating:", error);
-          }
+            await currentStorage.delete(cacheKey);
         }
-        await currentStorage.delete(cacheKey);
-      }
-      await currentStorage.delete(tagStoreKey);
+        await currentStorage.delete(tagStoreKey);
     } catch (error) {
-      console.warn("Failed to process tag key list:", error);
+        console.warn('Failed to process tag key list:', error);
     }
-  }
 }
 async function clearStore() {
-  const currentStorage = getStorage();
-  await currentStorage.clear();
-  storage = void 0;
-  ongoingRevalidations.clear();
+    const currentStorage = getStorage();
+    await currentStorage.clear();
+    cache_storage = void 0;
+    ongoingRevalidations.clear();
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CacheSize,
-  CacheTime,
-  cache,
-  clearStore,
-  configureCache,
-  generateKey,
-  revalidateTag,
-  withRequestCache
+exports.CacheSize = __webpack_exports__.CacheSize;
+exports.CacheTime = __webpack_exports__.CacheTime;
+exports.cache = __webpack_exports__.cache;
+exports.clearStore = __webpack_exports__.clearStore;
+exports.configureCache = __webpack_exports__.configureCache;
+exports.generateKey = __webpack_exports__.generateKey;
+exports.revalidateTag = __webpack_exports__.revalidateTag;
+exports.withRequestCache = __webpack_exports__.withRequestCache;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CacheSize",
+    "CacheTime",
+    "cache",
+    "clearStore",
+    "configureCache",
+    "generateKey",
+    "revalidateTag",
+    "withRequestCache"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });