@module-federation/modern-js 0.0.0-chore-bump-node-22-20260710161714

package/dist/esm/cli/ssrPlugin.mjs

@@ -0,0 +1,297 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof__ } from "@swc/helpers/_/_instanceof";
+import { _ as _type_of__ } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import fs from "fs";
+import { ModuleFederationPlugin, TreeShakingSharedPlugin as enhanced_TreeShakingSharedPlugin } from "@module-federation/enhanced";
+import { ModuleFederationPlugin as rspack_ModuleFederationPlugin, TreeShakingSharedPlugin as rspack_TreeShakingSharedPlugin } from "@module-federation/enhanced/rspack";
+import universe_entry_chunk_tracker_plugin from "@module-federation/node/universe-entry-chunk-tracker-plugin";
+import logger from "../logger.mjs";
+import { isDev, isWebTarget, skipByTarget } from "./utils.mjs";
+import { updateStatsAndManifest } from "@module-federation/rsbuild-plugin/utils";
+import { ManifestFileName, StatsFileName, simpleJoinRemoteEntry } from "@module-federation/sdk";
+function setEnv() {
+    process.env['MF_SSR_PRJ'] = 'true';
+}
+var CHAIN_MF_PLUGIN_ID = 'plugin-module-federation-server';
+function getManifestAssetFileNames(manifestOption) {
+    if (!manifestOption) return {
+        statsFileName: StatsFileName,
+        manifestFileName: ManifestFileName
+    };
+    var JSON_EXT = '.json';
+    var filePath = 'boolean' == typeof manifestOption ? '' : manifestOption.filePath || '';
+    var baseFileName = 'boolean' == typeof manifestOption ? '' : manifestOption.fileName || '';
+    var ensureExt = function(name) {
+        return name.endsWith(JSON_EXT) ? name : "".concat(name).concat(JSON_EXT);
+    };
+    var withSuffix = function(name, suffix) {
+        return name.replace(JSON_EXT, "".concat(suffix).concat(JSON_EXT));
+    };
+    var manifestFileName = baseFileName ? ensureExt(baseFileName) : ManifestFileName;
+    var statsFileName = baseFileName ? withSuffix(manifestFileName, '-stats') : StatsFileName;
+    return {
+        statsFileName: simpleJoinRemoteEntry(filePath, statsFileName),
+        manifestFileName: simpleJoinRemoteEntry(filePath, manifestFileName)
+    };
+}
+var STATIC_ASSET_MODULE_TYPES = [
+    'asset',
+    'asset/resource'
+];
+var ssrPlugin_preserveStaticAssetPublicPath = function(config, publicPath) {
+    var _config, _moduleConfig;
+    if ('string' != typeof publicPath || '' === publicPath || 'auto' === publicPath) return;
+    (_config = config).module || (_config.module = {});
+    var moduleConfig = config.module;
+    (_moduleConfig = moduleConfig).generator || (_moduleConfig.generator = {});
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        for(var _iterator = STATIC_ASSET_MODULE_TYPES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var moduleType = _step.value;
+            var _moduleConfig_generator, _moduleType, _moduleConfig_generator_moduleType;
+            (_moduleConfig_generator = moduleConfig.generator)[_moduleType = moduleType] || (_moduleConfig_generator[_moduleType] = {});
+            null != (_moduleConfig_generator_moduleType = moduleConfig.generator[moduleType]).publicPath || (_moduleConfig_generator_moduleType.publicPath = publicPath);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
+        }
+    }
+};
+var ssrPlugin_mfSSRRsbuildPlugin = function(pluginOptions) {
+    return {
+        name: '@modern-js/plugin-mf-post-config',
+        pre: [
+            '@modern-js/builder-plugin-ssr'
+        ],
+        setup: function(api) {
+            var _pluginOptions_csrConfig, _pluginOptions_assetFileNames, _pluginOptions_ssrConfig;
+            if (pluginOptions.csrConfig.getPublicPath) return;
+            var csrOutputPath = '';
+            var ssrOutputPath = '';
+            var ssrEnv = '';
+            var csrEnv = '';
+            var browserAssetFileNames = pluginOptions.assetFileNames.browser || getManifestAssetFileNames(null == (_pluginOptions_csrConfig = pluginOptions.csrConfig) ? void 0 : _pluginOptions_csrConfig.manifest);
+            var nodeAssetFileNames = (null == (_pluginOptions_assetFileNames = pluginOptions.assetFileNames) ? void 0 : _pluginOptions_assetFileNames.node) || getManifestAssetFileNames(null == (_pluginOptions_ssrConfig = pluginOptions.ssrConfig) ? void 0 : _pluginOptions_ssrConfig.manifest);
+            var collectAssets = function(assets, fileNames, tag) {
+                var statsAsset = assets[fileNames.statsFileName];
+                var manifestAsset = assets[fileNames.manifestFileName];
+                if (!statsAsset || !manifestAsset) return;
+                try {
+                    var statsRaw = statsAsset.source();
+                    var manifestRaw = manifestAsset.source();
+                    var statsContent = 'string' == typeof statsRaw ? statsRaw : statsRaw.toString();
+                    var manifestContent = 'string' == typeof manifestRaw ? manifestRaw : manifestRaw.toString();
+                    return {
+                        stats: {
+                            data: JSON.parse(statsContent),
+                            filename: fileNames.statsFileName
+                        },
+                        manifest: {
+                            data: JSON.parse(manifestContent),
+                            filename: fileNames.manifestFileName
+                        }
+                    };
+                } catch (err) {
+                    var message = _instanceof__(err, Error) ? err.message : String(err);
+                    logger.error("Failed to parse ".concat(tag, " manifest assets: ").concat(message));
+                    return;
+                }
+            };
+            api.modifyEnvironmentConfig(function(config, param) {
+                var name = param.name;
+                var target = config.output.target;
+                if (skipByTarget(target)) return config;
+                if (isWebTarget(target)) {
+                    csrOutputPath = config.output.distPath.root;
+                    csrEnv = name;
+                } else {
+                    ssrOutputPath = config.output.distPath.root;
+                    ssrEnv = name;
+                }
+                return config;
+            });
+            var modifySSRPublicPath = function(config, utils) {
+                if (ssrEnv !== utils.environment.name) return config;
+                var userSSRConfig = pluginOptions.userConfig.ssr ? 'object' === _type_of__(pluginOptions.userConfig.ssr) ? pluginOptions.userConfig.ssr : {} : {};
+                if (!userSSRConfig.distOutputDir) return;
+                var publicPath = config.output.publicPath;
+                ssrPlugin_preserveStaticAssetPublicPath(config, publicPath);
+                config.output.publicPath = "".concat(publicPath).concat(path.relative(csrOutputPath, ssrOutputPath), "/");
+                return config;
+            };
+            api.modifyWebpackConfig(function(config, utils) {
+                modifySSRPublicPath(config, utils);
+                return config;
+            });
+            api.modifyRspackConfig(function(config, utils) {
+                modifySSRPublicPath(config, utils);
+                return config;
+            });
+            api.processAssets({
+                stage: 'report'
+            }, function(param) {
+                var assets = param.assets, envContext = param.environment;
+                var _pluginOptions_csrConfig, _pluginOptions_ssrConfig;
+                var envName = envContext.name;
+                if ((null == (_pluginOptions_csrConfig = pluginOptions.csrConfig) ? void 0 : _pluginOptions_csrConfig.manifest) !== false && csrEnv && envName === csrEnv) {
+                    var browserAssets = collectAssets(assets, browserAssetFileNames, 'browser');
+                    if (browserAssets) pluginOptions.assetResources.browser = browserAssets;
+                }
+                if ((null == (_pluginOptions_ssrConfig = pluginOptions.ssrConfig) ? void 0 : _pluginOptions_ssrConfig.manifest) !== false && ssrEnv && envName === ssrEnv) {
+                    var nodeAssets = collectAssets(assets, nodeAssetFileNames, 'node');
+                    if (nodeAssets) pluginOptions.assetResources.node = nodeAssets;
+                }
+            });
+        }
+    };
+};
+var ssrPlugin_moduleFederationSSRPlugin = function(pluginOptions) {
+    return {
+        name: '@modern-js/plugin-module-federation-ssr',
+        pre: [
+            '@modern-js/plugin-module-federation-config',
+            '@modern-js/plugin-module-federation'
+        ],
+        setup: function(api) {
+            return _(function() {
+                var _ref, _pluginOptions_userConfig, _modernjsConfig_server, modernjsConfig, enableSSR, secondarySharedTreeShaking, writeMergedManifest;
+                return _ts_generator__(this, function(_state) {
+                    modernjsConfig = api.getConfig();
+                    enableSSR = null != (_ref = null == (_pluginOptions_userConfig = pluginOptions.userConfig) ? void 0 : _pluginOptions_userConfig.ssr) ? _ref : Boolean(null == modernjsConfig ? void 0 : null == (_modernjsConfig_server = modernjsConfig.server) ? void 0 : _modernjsConfig_server.ssr);
+                    secondarySharedTreeShaking = pluginOptions.secondarySharedTreeShaking;
+                    if (!enableSSR) return [
+                        2
+                    ];
+                    setEnv();
+                    api._internalRuntimePlugins(function(param) {
+                        var entrypoint = param.entrypoint, plugins = param.plugins;
+                        if (secondarySharedTreeShaking) return {
+                            entrypoint: entrypoint,
+                            plugins: plugins
+                        };
+                        var fetchServerQuery = pluginOptions.fetchServerQuery;
+                        plugins.push({
+                            name: 'injectDataFetchFunction',
+                            path: '@module-federation/modern-js/ssr-inject-data-fetch-function-plugin',
+                            config: {
+                                fetchServerQuery: fetchServerQuery
+                            }
+                        });
+                        if (!isDev()) return {
+                            entrypoint: entrypoint,
+                            plugins: plugins
+                        };
+                        plugins.push({
+                            name: 'mfSSRDev',
+                            path: '@module-federation/modern-js/ssr-dev-plugin',
+                            config: {}
+                        });
+                        return {
+                            entrypoint: entrypoint,
+                            plugins: plugins
+                        };
+                    });
+                    if (pluginOptions.ssrConfig.remotes) api._internalServerPlugins(function(param) {
+                        var plugins = param.plugins;
+                        plugins.push({
+                            name: '@module-federation/modern-js/data-fetch-server-plugin',
+                            options: {}
+                        });
+                        return {
+                            plugins: plugins
+                        };
+                    });
+                    api.modifyBundlerChain(function(chain) {
+                        var target = chain.get('target');
+                        if (skipByTarget(target)) return;
+                        var bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                        var MFPlugin = 'webpack' === bundlerType ? ModuleFederationPlugin : rspack_ModuleFederationPlugin;
+                        var TreeShakingSharedPlugin = 'webpack' === bundlerType ? enhanced_TreeShakingSharedPlugin : rspack_TreeShakingSharedPlugin;
+                        var isWeb = isWebTarget(target);
+                        if (!isWeb) {
+                            if (!chain.plugins.has(CHAIN_MF_PLUGIN_ID)) if (secondarySharedTreeShaking) chain.plugin(CHAIN_MF_PLUGIN_ID).use(TreeShakingSharedPlugin, [
+                                {
+                                    mfConfig: pluginOptions.ssrConfig,
+                                    secondary: true
+                                }
+                            ]);
+                            else chain.plugin(CHAIN_MF_PLUGIN_ID).use(MFPlugin, [
+                                pluginOptions.ssrConfig
+                            ]).init(function(Plugin, args) {
+                                pluginOptions.nodePlugin = new Plugin(args[0]);
+                                return pluginOptions.nodePlugin;
+                            });
+                        }
+                        if (!isWeb && !secondarySharedTreeShaking) {
+                            chain.target('async-node');
+                            if (isDev()) chain.plugin('UniverseEntryChunkTrackerPlugin').use(universe_entry_chunk_tracker_plugin);
+                        }
+                        if (isDev() && isWeb) chain.externals({
+                            '@module-federation/node/utils': 'NOT_USED_IN_BROWSER'
+                        });
+                    });
+                    api.config(function() {
+                        return {
+                            builderPlugins: [
+                                ssrPlugin_mfSSRRsbuildPlugin(pluginOptions)
+                            ],
+                            tools: {
+                                devServer: {
+                                    before: [
+                                        function(req, res, next) {
+                                            if (!enableSSR) return void next();
+                                            try {
+                                                var _req_url, _req_url1;
+                                                if ((null == (_req_url = req.url) ? void 0 : _req_url.includes('.json')) && !(null == (_req_url1 = req.url) ? void 0 : _req_url1.includes('hot-update'))) {
+                                                    var filepath = path.join(process.cwd(), "dist".concat(req.url));
+                                                    fs.statSync(filepath);
+                                                    res.setHeader('Access-Control-Allow-Origin', '*');
+                                                    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+                                                    res.setHeader('Access-Control-Allow-Headers', '*');
+                                                    fs.createReadStream(filepath).pipe(res);
+                                                } else next();
+                                            } catch (err) {
+                                                logger.debug(err);
+                                                next();
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        };
+                    });
+                    writeMergedManifest = function() {
+                        var distOutputDir = pluginOptions.distOutputDir, assetResources = pluginOptions.assetResources;
+                        var browserAssets = assetResources.browser;
+                        var nodeAssets = assetResources.node;
+                        if (!distOutputDir || !browserAssets || !nodeAssets) return;
+                        try {
+                            updateStatsAndManifest(nodeAssets, browserAssets, distOutputDir);
+                        } catch (err) {
+                            logger.error(err);
+                        }
+                    };
+                    api.onAfterBuild(function() {
+                        writeMergedManifest();
+                    });
+                    api.onDevCompileDone(function() {
+                        writeMergedManifest();
+                    });
+                    return [
+                        2
+                    ];
+                });
+            })();
+        }
+    };
+};
+var ssrPlugin = ssrPlugin_moduleFederationSSRPlugin;
+export { CHAIN_MF_PLUGIN_ID, ssrPlugin as default, ssrPlugin_moduleFederationSSRPlugin as moduleFederationSSRPlugin, setEnv };

package/dist/esm/cli/utils.mjs

@@ -0,0 +1,40 @@
+import os from "os";
+var localIpv4 = '127.0.0.1';
+var utils_getIpv4Interfaces = function() {
+    try {
+        var interfaces = os.networkInterfaces();
+        var ipv4Interfaces = [];
+        Object.values(interfaces).forEach(function(detail) {
+            null == detail || detail.forEach(function(detail) {
+                var familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+                if (detail.family === familyV4Value && detail.address !== localIpv4) ipv4Interfaces.push(detail);
+            });
+        });
+        return ipv4Interfaces;
+    } catch (_err) {
+        return [];
+    }
+};
+var utils_getIPV4 = function() {
+    var ipv4Interfaces = utils_getIpv4Interfaces();
+    var ipv4Interface = ipv4Interfaces[0] || {
+        address: localIpv4
+    };
+    return ipv4Interface.address;
+};
+var utils_isWebTarget = function(target) {
+    var WEB_TARGET = 'web';
+    if (Array.isArray(target)) return target.includes(WEB_TARGET);
+    if ('string' == typeof target) return target === WEB_TARGET;
+    return false;
+};
+var utils_skipByTarget = function(target) {
+    var IGNORE_TARGET = 'webworker';
+    if (Array.isArray(target)) return target.includes(IGNORE_TARGET);
+    if ('string' == typeof target) return target === IGNORE_TARGET;
+    return false;
+};
+function isDev() {
+    return 'development' === process.env.NODE_ENV;
+}
+export { utils_getIPV4 as getIPV4, isDev, utils_isWebTarget as isWebTarget, utils_skipByTarget as skipByTarget };

package/dist/esm/constant.mjs

@@ -0,0 +1,3 @@
+var LOCALHOST = 'localhost';
+var PLUGIN_IDENTIFIER = '[ Modern.js Module Federation ]';
+export { LOCALHOST, PLUGIN_IDENTIFIER };

package/dist/esm/logger.mjs

@@ -0,0 +1,5 @@
+import { createLogger } from "@module-federation/sdk";
+import { PLUGIN_IDENTIFIER } from "./constant.mjs";
+var logger = createLogger(PLUGIN_IDENTIFIER);
+var src_logger = logger;
+export { src_logger as default };

package/dist/esm/react/data-fetch.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react/data-fetch";

package/dist/esm/react/index.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react";

package/dist/esm/react/plugin.mjs

@@ -0,0 +1,3 @@
+import bridge_react_plugin from "@module-federation/bridge-react/plugin";
+export * from "@module-federation/bridge-react/plugin";
+export { bridge_react_plugin as default };

package/dist/esm/react/v18.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react/v18";

package/dist/esm/react/v19.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react/v19";

package/dist/esm/runtime/index.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/enhanced/runtime";

package/dist/esm/server/fileCache.mjs

@@ -0,0 +1,125 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check__ } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { access, lstat, readFile } from "fs/promises";
+import { LRUCache } from "lru-cache";
+var fileCache_pathExists = function(filepath) {
+    return _(function() {
+        return _ts_generator__(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        access(filepath)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2,
+                        true
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2,
+                        false
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+};
+var fileCache_FileCache = /*#__PURE__*/ function() {
+    "use strict";
+    function FileCache() {
+        _class_call_check__(this, FileCache);
+        this.cache = new LRUCache({
+            maxSize: 209715200
+        });
+    }
+    var _proto = FileCache.prototype;
+    _proto.getFile = function(filepath) {
+        return _(function() {
+            var stat, currentModified, cachedEntry, content, newEntry;
+            return _ts_generator__(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            fileCache_pathExists(filepath)
+                        ];
+                    case 1:
+                        if (!_state.sent()) return [
+                            2,
+                            null
+                        ];
+                        _state.label = 2;
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            5,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            lstat(filepath)
+                        ];
+                    case 3:
+                        stat = _state.sent();
+                        currentModified = stat.mtimeMs;
+                        cachedEntry = this.cache.get(filepath);
+                        if (cachedEntry && currentModified <= cachedEntry.lastModified) return [
+                            2,
+                            {
+                                content: cachedEntry.content,
+                                lastModified: cachedEntry.lastModified
+                            }
+                        ];
+                        return [
+                            4,
+                            readFile(filepath, 'utf-8')
+                        ];
+                    case 4:
+                        content = _state.sent();
+                        newEntry = {
+                            content: content,
+                            lastModified: currentModified
+                        };
+                        this.cache.set(filepath, newEntry, {
+                            size: stat.size || content.length
+                        });
+                        return [
+                            2,
+                            {
+                                content: content,
+                                lastModified: currentModified
+                            }
+                        ];
+                    case 5:
+                        _state.sent();
+                        return [
+                            2,
+                            null
+                        ];
+                    case 6:
+                        return [
+                            2
+                        ];
+                }
+            });
+        }).call(this);
+    };
+    return FileCache;
+}();
+var fileCache = new fileCache_FileCache();
+export { fileCache_FileCache as FileCache, fileCache };

package/dist/esm/server/index.mjs

@@ -0,0 +1,36 @@
+import { createCorsMiddleware, createStaticMiddleware } from "./staticMiddleware.mjs";
+var server_staticServePlugin = function() {
+    return {
+        name: '@modern-js/module-federation/server',
+        setup: function(api) {
+            api.onPrepare(function() {
+                var _config_output, _config_server;
+                if ('development' === process.env.NODE_ENV) return;
+                var middlewares = api.getServerContext().middlewares;
+                var config = api.getServerConfig();
+                var assetPrefix = (null == (_config_output = config.output) ? void 0 : _config_output.assetPrefix) || '';
+                if (null == (_config_server = config.server) ? void 0 : _config_server.ssr) {
+                    var context = api.getServerContext();
+                    var pwd = context.distDirectory;
+                    var serverStaticMiddleware = createStaticMiddleware({
+                        assetPrefix: assetPrefix,
+                        pwd: pwd
+                    });
+                    middlewares.push({
+                        name: 'module-federation-serve-manifest',
+                        handler: serverStaticMiddleware
+                    });
+                }
+                if (process.env.MODERN_MF_AUTO_CORS) {
+                    var corsMiddleware = createCorsMiddleware();
+                    middlewares.push({
+                        name: 'module-federation-cors',
+                        handler: corsMiddleware
+                    });
+                }
+            });
+        }
+    };
+};
+var server = server_staticServePlugin;
+export { server as default, server_staticServePlugin as staticServePlugin };

package/dist/esm/server/staticMiddleware.mjs

@@ -0,0 +1,122 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { access } from "fs/promises";
+import path from "path";
+import { fileCache } from "./fileCache.mjs";
+var staticMiddleware_pathExists = function(filepath) {
+    return _(function() {
+        return _ts_generator__(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        access(filepath)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2,
+                        true
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2,
+                        false
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+};
+var bundlesAssetPrefix = '/bundles';
+var staticMiddleware_removeHost = function(url) {
+    try {
+        var hasProtocol = url.includes('://');
+        var hasDomain = hasProtocol || url.startsWith('//');
+        var pathname = hasDomain ? new URL(hasProtocol ? url : "http:".concat(url)).pathname : url;
+        return pathname;
+    } catch (e) {
+        return url;
+    }
+};
+var staticMiddleware_createStaticMiddleware = function(options) {
+    var assetPrefix = options.assetPrefix, pwd = options.pwd;
+    return function(c, next) {
+        return _(function() {
+            var pathname, prefixWithoutHost, prefixWithBundle, pathnameWithoutPrefix, filepath, fileResult;
+            return _ts_generator__(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        pathname = c.req.path;
+                        if ('.js' !== path.extname(pathname)) return [
+                            2,
+                            next()
+                        ];
+                        prefixWithoutHost = staticMiddleware_removeHost(assetPrefix);
+                        prefixWithBundle = path.join(prefixWithoutHost, bundlesAssetPrefix);
+                        if (!pathname.startsWith(prefixWithBundle)) return [
+                            2,
+                            next()
+                        ];
+                        pathnameWithoutPrefix = pathname.replace(prefixWithBundle, '');
+                        filepath = path.join(pwd, bundlesAssetPrefix, pathnameWithoutPrefix);
+                        return [
+                            4,
+                            staticMiddleware_pathExists(filepath)
+                        ];
+                    case 1:
+                        if (!_state.sent()) return [
+                            2,
+                            next()
+                        ];
+                        return [
+                            4,
+                            fileCache.getFile(filepath)
+                        ];
+                    case 2:
+                        fileResult = _state.sent();
+                        if (!fileResult) return [
+                            2,
+                            next()
+                        ];
+                        c.header('Content-Type', "application/javascript");
+                        c.header('Content-Length', String(fileResult.content.length));
+                        return [
+                            2,
+                            c.body(fileResult.content, 200)
+                        ];
+                }
+            });
+        })();
+    };
+};
+var staticMiddleware_createCorsMiddleware = function() {
+    return function(c, next) {
+        return _(function() {
+            var pathname;
+            return _ts_generator__(this, function(_state) {
+                pathname = c.req.path;
+                if (path.extname(pathname)) {
+                    c.header('Access-Control-Allow-Origin', '*');
+                    c.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+                    c.header('Access-Control-Allow-Headers', '*');
+                }
+                return [
+                    2,
+                    next()
+                ];
+            });
+        })();
+    };
+};
+export { staticMiddleware_createCorsMiddleware as createCorsMiddleware, staticMiddleware_createStaticMiddleware as createStaticMiddleware };