@bleedingdev/modern-js-runtime-utils 3.2.0-ultramodern.0

package/dist/esm/universal/cache.mjs

@@ -0,0 +1,326 @@
+import { LRUCache } from "lru-cache";
+import { getAsyncLocalStorage } from "./async_storage.mjs";
+const CacheSize = {
+    KB: 1024,
+    MB: 1048576,
+    GB: 1073741824
+};
+const CacheTime = {
+    SECOND: 1000,
+    MINUTE: 60000,
+    HOUR: 3600000,
+    DAY: 86400000,
+    WEEK: 604800000,
+    MONTH: 2592000000
+};
+function estimateObjectSize(data) {
+    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;
+}
+class MemoryContainer {
+    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 LRUCache({
+            maxSize: options?.maxSize ?? CacheSize.GB,
+            sizeCalculation: estimateObjectSize,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true
+        });
+    }
+}
+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
+};
+function getStorage() {
+    if (cache_storage) return cache_storage;
+    cache_storage = cacheConfig.container ? cacheConfig.container : new MemoryContainer({
+        maxSize: cacheConfig.maxSize
+    });
+    return cache_storage;
+}
+function configureCache(config) {
+    cacheConfig = {
+        ...cacheConfig,
+        ...config
+    };
+    cache_storage = void 0;
+}
+function generateKey(args) {
+    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;
+    }
+    return `fn_${fn.name || 'anonymous'}_${Math.abs(hash).toString(36)}`;
+}
+function cache(fn, options) {
+    return async (...args)=>{
+        if (isServer && void 0 === options) {
+            const storage = await getAsyncLocalStorage();
+            const request = 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 = 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 getAsyncLocalStorage();
+                const request = asyncStorage?.useContext()?.request;
+                if (request) shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+                    request
+                });
+            }
+            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 (!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 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;
+                    }
+                    missReason = 3;
+                } catch (error) {
+                    console.warn('Failed to parse cached data:', error);
+                    missReason = 4;
+                }
+                else missReason = 2;
+            }
+            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
+            });
+            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;
+        }
+        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(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(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);
+    }
+}
+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);
+        }
+    }
+}
+function withRequestCache(handler) {
+    if (!isServer) return handler;
+    return async (req, ...args)=>{
+        const storage = await 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);
+                }
+            } catch (error) {
+                console.warn('Failed to parse cached data while revalidating:', error);
+            }
+            await currentStorage.delete(cacheKey);
+        }
+        await currentStorage.delete(tagStoreKey);
+    } catch (error) {
+        console.warn('Failed to process tag key list:', error);
+    }
+}
+async function clearStore() {
+    const currentStorage = getStorage();
+    await currentStorage.clear();
+    cache_storage = void 0;
+    ongoingRevalidations.clear();
+}
+export { CacheSize, CacheTime, cache, clearStore, configureCache, generateKey, revalidateTag, withRequestCache };

package/dist/esm/universal/request.mjs

@@ -0,0 +1,40 @@
+function parseQuery(req) {
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
+}
+function parseHeaders(request) {
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
+}
+function getPathname(request) {
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match ? match[1] : '/';
+}
+function getHost(request) {
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
+}
+function parseCookie(req) {
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k) cookie[k] = v;
+    });
+    return cookie;
+}
+export { getHost, getPathname, parseCookie, parseHeaders, parseQuery };

package/dist/esm/url.mjs

@@ -0,0 +1,5 @@
+function normalizePathname(pathname) {
+    const normalized = '/' + pathname.replace(/^\/+|\/+$/g, '');
+    return normalized;
+}
+export { normalizePathname };

package/dist/esm-node/browser/deferreds.mjs

@@ -0,0 +1,119 @@
+import "node:module";
+function invariant(value, message) {
+    if (false === value || null == value) throw new Error(message);
+}
+class AbortedDeferredError extends Error {
+}
+function isTrackedPromise(value) {
+    return value instanceof Promise && true === value._tracked;
+}
+function unwrapTrackedPromise(value) {
+    if (!isTrackedPromise(value)) return value;
+    if (value._error) throw value._error;
+    return value._data;
+}
+class DeferredData {
+    trackPromise(key, value) {
+        if (!(value instanceof Promise)) return value;
+        this.deferredKeys.push(key);
+        this.pendingKeysSet.add(key);
+        const promise = Promise.race([
+            value,
+            this.abortPromise
+        ]).then((data)=>this.onSettle(promise, key, void 0, data), (error)=>this.onSettle(promise, key, error));
+        promise.catch(()=>{});
+        Object.defineProperty(promise, '_tracked', {
+            get: ()=>true
+        });
+        return promise;
+    }
+    onSettle(promise, key, error, data) {
+        if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
+            this.unlistenAbortSignal();
+            Object.defineProperty(promise, '_error', {
+                get: ()=>error
+            });
+            return Promise.reject(error);
+        }
+        this.pendingKeysSet.delete(key);
+        if (this.done) this.unlistenAbortSignal();
+        if (void 0 === error && void 0 === data) {
+            const undefinedError = new Error(`Deferred data for key "${key}" resolved/rejected with \`undefined\`, you must resolve/reject with a value or \`null\`.`);
+            Object.defineProperty(promise, '_error', {
+                get: ()=>undefinedError
+            });
+            this.emit(false, key);
+            return Promise.reject(undefinedError);
+        }
+        if (void 0 === data) {
+            Object.defineProperty(promise, '_error', {
+                get: ()=>error
+            });
+            this.emit(false, key);
+            return Promise.reject(error);
+        }
+        Object.defineProperty(promise, '_data', {
+            get: ()=>data
+        });
+        this.emit(false, key);
+        return data;
+    }
+    emit(aborted, settledKey) {
+        this.subscribers.forEach((subscriber)=>subscriber(aborted, settledKey));
+    }
+    subscribe(fn) {
+        this.subscribers.add(fn);
+        return ()=>this.subscribers.delete(fn);
+    }
+    cancel() {
+        this.controller.abort();
+        this.pendingKeysSet.forEach((v, k)=>this.pendingKeysSet.delete(k));
+        this.emit(true);
+    }
+    async resolveData(signal) {
+        let aborted = false;
+        if (!this.done) {
+            const onAbort = ()=>this.cancel();
+            signal.addEventListener('abort', onAbort);
+            aborted = await new Promise((resolve)=>{
+                this.subscribe((aborted)=>{
+                    signal.removeEventListener('abort', onAbort);
+                    if (aborted || this.done) resolve(aborted);
+                });
+            });
+        }
+        return aborted;
+    }
+    get done() {
+        return 0 === this.pendingKeysSet.size;
+    }
+    get unwrappedData() {
+        invariant(null !== this.data && this.done, 'Can only unwrap data on initialized and settled deferreds');
+        return Object.entries(this.data).reduce((acc, [key, value])=>Object.assign(acc, {
+                [key]: unwrapTrackedPromise(value)
+            }), {});
+    }
+    get pendingKeys() {
+        return Array.from(this.pendingKeysSet);
+    }
+    constructor(data, responseInit){
+        this.pendingKeysSet = new Set();
+        this.subscribers = new Set();
+        this.__modern_deferred = true;
+        this.deferredKeys = [];
+        invariant(data && 'object' == typeof data && !Array.isArray(data), 'defer() only accepts plain objects');
+        let reject;
+        this.abortPromise = new Promise((_, r)=>reject = r);
+        this.controller = new AbortController();
+        const onAbort = ()=>reject(new AbortedDeferredError('Deferred data aborted'));
+        this.unlistenAbortSignal = ()=>this.controller.signal.removeEventListener('abort', onAbort);
+        this.controller.signal.addEventListener('abort', onAbort);
+        this.data = Object.entries(data).reduce((acc, [key, value])=>Object.assign(acc, {
+                [key]: this.trackPromise(key, value)
+            }), {});
+        if (this.done) this.unlistenAbortSignal();
+        this.init = responseInit;
+    }
+}
+const activeDeferreds = new Map();
+export { AbortedDeferredError, DeferredData, activeDeferreds, invariant };

package/dist/esm-node/browser/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export * from "./deferreds.mjs";
+export * from "./nestedRoutes.mjs";

package/dist/esm-node/browser/nestedRoutes.mjs

@@ -0,0 +1,105 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { Suspense } from "react";
+import { Outlet, Route, createRoutesFromElements } from "react-router";
+import { time } from "../time.mjs";
+import { getAsyncLocalStorage } from "../universal/async_storage.mjs";
+import { DeferredData, activeDeferreds as external_deferreds_mjs_activeDeferreds } from "./deferreds.mjs";
+const privateDefer = (data)=>new DeferredData(data);
+const transformNestedRoutes = (routes)=>{
+    const routeElements = [];
+    for (const route of routes){
+        const routeElement = renderNestedRoute(route);
+        routeElements.push(routeElement);
+    }
+    return createRoutesFromElements(routeElements);
+};
+const renderNestedRoute = (nestedRoute, options = {})=>{
+    const { children, index, id, component, isRoot, lazyImport, config, handle } = nestedRoute;
+    const Component = component;
+    const { parent, props = {} } = options;
+    const routeProps = {
+        caseSensitive: nestedRoute.caseSensitive,
+        path: nestedRoute.path,
+        id: nestedRoute.id,
+        loader: createLoader(nestedRoute),
+        action: nestedRoute.action,
+        hasErrorBoundary: nestedRoute.hasErrorBoundary,
+        shouldRevalidate: nestedRoute.shouldRevalidate,
+        handle: {
+            ...handle,
+            ...'object' == typeof config ? config?.handle : {}
+        },
+        index: nestedRoute.index,
+        element: nestedRoute.element,
+        errorElement: nestedRoute.errorElement
+    };
+    if (nestedRoute.error) {
+        const errorElement = /*#__PURE__*/ jsx(nestedRoute.error, {});
+        routeProps.errorElement = errorElement;
+    }
+    let element;
+    if (Component) if (parent?.loading && lazyImport) {
+        const Loading = parent.loading;
+        element = isLoadableComponent(Component) ? /*#__PURE__*/ jsx(Component, {
+            fallback: /*#__PURE__*/ jsx(Loading, {})
+        }) : /*#__PURE__*/ jsx(Suspense, {
+            fallback: /*#__PURE__*/ jsx(Loading, {}),
+            children: /*#__PURE__*/ jsx(Component, {})
+        });
+    } else element = isLoadableComponent(Component) && lazyImport ? /*#__PURE__*/ jsx(Component, {}) : isRoot ? /*#__PURE__*/ jsx(Component, {
+        ...props
+    }) : lazyImport ? /*#__PURE__*/ jsx(Suspense, {
+        fallback: null,
+        children: /*#__PURE__*/ jsx(Component, {})
+    }) : /*#__PURE__*/ jsx(Component, {});
+    else {
+        nestedRoute.loading = parent?.loading;
+        routeProps.element = /*#__PURE__*/ jsx(Outlet, {});
+    }
+    if (element) routeProps.element = element;
+    const childElements = children?.map((childRoute)=>renderNestedRoute(childRoute, {
+            parent: nestedRoute
+        }));
+    const routeElement = index ? /*#__PURE__*/ jsx(Route, {
+        ...routeProps,
+        index: true
+    }, id) : /*#__PURE__*/ jsx(Route, {
+        ...routeProps,
+        index: false,
+        children: childElements
+    }, id);
+    return routeElement;
+};
+function isPlainObject(value) {
+    return null != value && 'object' == typeof value && Object.getPrototypeOf(value) === Object.prototype;
+}
+function createLoader(route) {
+    const { loader } = route;
+    if (loader) return async (args)=>{
+        if ('function' == typeof route.lazyImport) route.lazyImport();
+        const end = time();
+        const res = await loader(args);
+        let activeDeferreds = null;
+        activeDeferreds = "u" < typeof document ? (await getAsyncLocalStorage())?.useContext()?.activeDeferreds : external_deferreds_mjs_activeDeferreds;
+        if (isPlainObject(res)) {
+            const deferredData = privateDefer(res);
+            activeDeferreds.set(route.id, deferredData);
+        }
+        const cost = end();
+        if ("u" < typeof document) {
+            const storage = await getAsyncLocalStorage();
+            storage?.useContext().monitors?.timing(`${LOADER_REPORTER_NAME}-${route.id?.replace(/\//g, '_')}`, cost);
+        }
+        return res;
+    };
+    return ()=>{
+        if ('function' == typeof route.lazyImport) route.lazyImport();
+        return null;
+    };
+}
+function isLoadableComponent(component) {
+    return component && 'Loadable' === component.displayName && component.preload && 'function' == typeof component.preload;
+}
+export { renderNestedRoute, transformNestedRoutes };

package/dist/esm-node/merge.mjs

@@ -0,0 +1,27 @@
+import "node:module";
+function isObject(obj) {
+    return obj && 'object' == typeof obj && !Array.isArray(obj);
+}
+function isComplexInstance(obj) {
+    if (!isObject(obj)) return false;
+    const hasMethods = 'function' == typeof obj.init || 'function' == typeof obj.changeLanguage || 'function' == typeof obj.t;
+    const hasInternalProps = void 0 !== obj.isInitialized || void 0 !== obj.language || void 0 !== obj.store;
+    return hasMethods || hasInternalProps;
+}
+function merge(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) for(const key in source)if (isComplexInstance(source[key])) Object.assign(target, {
+        [key]: source[key]
+    });
+    else if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, {
+            [key]: {}
+        });
+        merge(target[key], source[key]);
+    } else Object.assign(target, {
+        [key]: source[key]
+    });
+    return merge(target, ...sources);
+}
+export { merge };

package/dist/esm-node/node/fileReader.mjs

@@ -0,0 +1,48 @@
+import "node:module";
+import fs_extra from "@modern-js/utils/fs-extra";
+import { createMemoryStorage } from "./storer/index.mjs";
+class FileReader {
+    async readFile(path, encoding = 'utf-8') {
+        const { fs } = this;
+        const _readfile = this._readFileFactory(fs);
+        return _readfile(path, encoding);
+    }
+    async readFileFromSystem(path, encoding = 'utf-8') {
+        const _readfile = this._readFileFactory(fs_extra);
+        return _readfile(path, encoding);
+    }
+    _readFileFactory(fs) {
+        return async (path, encoding = 'utf-8')=>{
+            const cache = await this.storage.get(path);
+            if (null === cache) return null;
+            if (cache) return this.encodingContent(cache, encoding);
+            const isExistFile = await new Promise((resolve)=>{
+                fs.stat(path, (err, stats)=>{
+                    if (err) return void resolve(false);
+                    stats.isFile() ? resolve(true) : resolve(false);
+                });
+            });
+            if (isExistFile) {
+                const content = await fs.promises.readFile(path);
+                this.storage.set(path, content);
+                return this.encodingContent(content, encoding);
+            }
+            this.storage.set(path, null);
+            return null;
+        };
+    }
+    reset(fs) {
+        fs && (this.fs = fs);
+        return this.storage.clear?.();
+    }
+    encodingContent(value, encoding) {
+        if ('utf-8' === encoding) return value.toString();
+        return value;
+    }
+    constructor(storage){
+        this.fs = fs_extra;
+        this.storage = storage;
+    }
+}
+const fileReader = new FileReader(createMemoryStorage('__file__system'));
+export { FileReader, fileReader };

package/dist/esm-node/node/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+export * from "./loaderContext/index.mjs";
+export * from "./nestedRoutes.mjs";
+export { storage } from "../universal/async_storage.server.mjs";
+export { sanitizeSSRPayload } from "./sanitize.mjs";
+export { serializeJson } from "./serialize.mjs";