@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.2

package/dist/cjs/cloudflare-output-verifier/worker-bundles.js

@@ -0,0 +1,378 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    getEffectBffWorker: ()=>getEffectBffWorker,
+    getWorkerBundleReferences: ()=>getWorkerBundleReferences,
+    missingWorkerBundleMessage: ()=>missingWorkerBundleMessage,
+    resolveWorkerBundleReference: ()=>resolveWorkerBundleReference,
+    verifyWorkerBundleReferences: ()=>verifyWorkerBundleReferences,
+    verifyWorkerImport: ()=>verifyWorkerImport
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_node_util_namespaceObject = require("node:util");
+const parser_namespaceObject = require("@babel/parser");
+const traverse_namespaceObject = require("@babel/traverse");
+var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
+const external_cloudflare_output_contract_js_namespaceObject = require("../cloudflare-output-contract.js");
+const external_issues_js_namespaceObject = require("./issues.js");
+const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
+const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
+const getWorkerBundleReferences = (manifest)=>{
+    const effectBffWorker = getEffectBffWorker(manifest);
+    return [
+        ...effectBffWorker ? [
+            {
+                dispatcherExport: 'string' == typeof manifest.bff?.dispatcherExport ? manifest.bff.dispatcherExport : void 0,
+                kind: 'effect-bff',
+                reference: effectBffWorker
+            }
+        ] : [],
+        ...getReferencedRouteWorkers(manifest).map((reference)=>({
+                kind: 'route',
+                reference
+            }))
+    ];
+};
+const resolveWorkerBundleReference = (issues, outputDirectory, reference, manifestPath)=>{
+    const workerRoot = external_node_path_default().resolve(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY);
+    const workerPath = external_node_path_default().resolve(outputDirectory, reference.reference);
+    const relativeToWorkerRoot = external_node_path_default().relative(workerRoot, workerPath);
+    if (external_node_path_default().isAbsolute(reference.reference) || relativeToWorkerRoot.startsWith('..') || external_node_path_default().isAbsolute(relativeToWorkerRoot)) {
+        (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-manifest',
+            message: 'Cloudflare output manifest worker bundle references must stay under worker/.',
+            path: manifestPath
+        });
+        return null;
+    }
+    return {
+        ...reference,
+        path: workerPath
+    };
+};
+const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
+const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
+const getNodeName = (node)=>{
+    if (!isAstNode(node)) return;
+    return 'Identifier' === node.type && 'string' == typeof node.name ? node.name : 'StringLiteral' === node.type && 'string' == typeof node.value ? node.value : void 0;
+};
+const getStringLiteralValue = (node)=>isAstNode(node) && 'StringLiteral' === node.type && 'string' == typeof node.value ? node.value : void 0;
+const collectBindingNames = (node, names)=>{
+    if (!isAstNode(node)) return;
+    const name = getNodeName(node);
+    if (name) return void names.add(name);
+    if ('ObjectPattern' === node.type && Array.isArray(node.properties)) {
+        for (const property of node.properties)if (isAstNode(property)) collectBindingNames('RestElement' === property.type ? property.argument : property.value, names);
+    } else if ('ArrayPattern' === node.type && Array.isArray(node.elements)) for (const element of node.elements)collectBindingNames(element, names);
+    else if ('AssignmentPattern' === node.type || 'RestElement' === node.type) collectBindingNames('AssignmentPattern' === node.type ? node.left : node.argument, names);
+};
+const getMemberPropertyName = (node)=>{
+    if ('MemberExpression' !== node.type) return;
+    return true === node.computed ? getStringLiteralValue(node.property) : getNodeName(node.property);
+};
+const isAmbientModuleRequire = (node, modulePath)=>isAstNode(node) && 'MemberExpression' === node.type && isAstNode(node.object) && 'Identifier' === node.object.type && 'module' === node.object.name && void 0 === modulePath.scope.getBinding('module') && 'require' === getMemberPropertyName(node);
+const isModuleExports = (node)=>isAstNode(node) && 'MemberExpression' === node.type && isAstNode(node.object) && 'Identifier' === node.object.type && 'module' === node.object.name && 'exports' === getMemberPropertyName(node);
+const collectCommonJsExports = (statement, exports1)=>{
+    if ('ExpressionStatement' !== statement.type || !isAstNode(statement.expression) || 'AssignmentExpression' !== statement.expression.type) return;
+    const { left, right } = statement.expression;
+    if (isAstNode(left) && 'MemberExpression' === left.type && (isAstNode(left.object) && 'Identifier' === left.object.type && 'exports' === left.object.name || isModuleExports(left.object))) {
+        const exportName = getMemberPropertyName(left);
+        if (exportName) exports1.add(exportName);
+        return;
+    }
+    if (isModuleExports(left) && isAstNode(right) && 'ObjectExpression' === right.type && Array.isArray(right.properties)) {
+        for (const property of right.properties)if (isAstNode(property)) {
+            const exportName = getNodeName(property.key);
+            if (exportName) exports1.add(exportName);
+        }
+    }
+};
+const collectEsmExports = (statement, exports1)=>{
+    if ('ExportDefaultDeclaration' === statement.type) return void exports1.add('default');
+    if ('ExportNamedDeclaration' !== statement.type) return;
+    if (isAstNode(statement.declaration)) {
+        const declaration = statement.declaration;
+        const declarationName = getNodeName(declaration.id);
+        if (declarationName) exports1.add(declarationName);
+        if ('VariableDeclaration' === declaration.type && Array.isArray(declaration.declarations)) {
+            for (const declarator of declaration.declarations)if (isAstNode(declarator)) collectBindingNames(declarator.id, exports1);
+        }
+    }
+    if (Array.isArray(statement.specifiers)) {
+        for (const specifier of statement.specifiers)if (isAstNode(specifier)) {
+            const exportName = getNodeName(specifier.exported);
+            if (exportName) exports1.add(exportName);
+        }
+    }
+};
+const getStaticImport = (modulePath)=>{
+    const node = modulePath.node;
+    if (('ImportDeclaration' === node.type || 'ExportNamedDeclaration' === node.type || 'ExportAllDeclaration' === node.type) && isAstNode(node.source)) return getStringLiteralValue(node.source);
+    if ('ImportExpression' === node.type && isAstNode(node.source)) return getStringLiteralValue(node.source);
+    if ('CallExpression' === node.type && Array.isArray(node.arguments) && 1 === node.arguments.length && isAstNode(node.callee) && ('Identifier' === node.callee.type && 'require' === node.callee.name && void 0 === modulePath.scope.getBinding('require') || isAmbientModuleRequire(node.callee, modulePath) || 'Import' === node.callee.type)) return getStringLiteralValue(node.arguments[0]);
+};
+const isAmbientLoaderWrite = (modulePath)=>{
+    let targetPath = modulePath;
+    while(true){
+        const parentPath = targetPath.parentPath;
+        if (null === parentPath) return false;
+        if (parentPath.isAssignmentExpression()) return 'left' === targetPath.key;
+        if (parentPath.isUpdateExpression()) return 'argument' === targetPath.key;
+        if (parentPath.isForInStatement() || parentPath.isForOfStatement()) return 'left' === targetPath.key;
+        if (parentPath.isObjectProperty()) {
+            if ('value' !== targetPath.key) return false;
+            targetPath = parentPath;
+            continue;
+        }
+        if (parentPath.isObjectPattern() || parentPath.isArrayPattern() || parentPath.isRestElement() || parentPath.isAssignmentPattern()) {
+            targetPath = parentPath;
+            continue;
+        }
+        return false;
+    }
+};
+const analyzeWorkerModule = (source)=>{
+    const ast = (0, parser_namespaceObject.parse)(source, {
+        sourceType: 'unambiguous'
+    });
+    const exports1 = new Set();
+    const imports = new Set();
+    let unsafeCommonJsLoaderUsage = false;
+    let unsafeDynamicImport = false;
+    for (const statement of ast.program.body){
+        collectEsmExports(statement, exports1);
+        collectCommonJsExports(statement, exports1);
+    }
+    traverse_default()(ast, {
+        enter (modulePath) {
+            const node = modulePath.node;
+            if (('ImportExpression' === node.type || 'CallExpression' === node.type && isAstNode(node.callee) && 'Import' === node.callee.type) && void 0 === getStaticImport(modulePath)) unsafeDynamicImport = true;
+            if (modulePath.isReferencedIdentifier({
+                name: 'require'
+            }) && void 0 === modulePath.scope.getBinding('require')) {
+                const parentPath = modulePath.parentPath;
+                const isStaticRequireCall = parentPath?.isCallExpression() && 'callee' === modulePath.key && void 0 !== getStaticImport(parentPath);
+                const isAvailabilityCheck = parentPath?.isUnaryExpression({
+                    operator: 'typeof'
+                });
+                if (!isStaticRequireCall && !isAvailabilityCheck) unsafeCommonJsLoaderUsage = true;
+            }
+            if ('Identifier' === node.type && isAmbientLoaderWrite(modulePath) && ('require' === node.name || 'module' === node.name) && void 0 === modulePath.scope.getBinding(node.name)) unsafeCommonJsLoaderUsage = true;
+            if (modulePath.isReferencedIdentifier({
+                name: 'module'
+            }) && void 0 === modulePath.scope.getBinding('module')) {
+                const parentPath = modulePath.parentPath;
+                const isExportsAccess = null !== parentPath && isModuleExports(parentPath.node);
+                const isStaticModuleRequireCall = null !== parentPath && isAmbientModuleRequire(parentPath.node, parentPath) && parentPath.parentPath?.isCallExpression() === true && 'callee' === parentPath.key && void 0 !== getStaticImport(parentPath.parentPath);
+                if (!isExportsAccess && !isStaticModuleRequireCall) unsafeCommonJsLoaderUsage = true;
+            }
+            if (isAmbientModuleRequire(node, modulePath)) {
+                const parentPath = modulePath.parentPath;
+                const isStaticRequireCall = parentPath?.isCallExpression() && 'callee' === modulePath.key && void 0 !== getStaticImport(parentPath);
+                if (!isStaticRequireCall) unsafeCommonJsLoaderUsage = true;
+            }
+            const specifier = getStaticImport(modulePath);
+            if (void 0 !== specifier) imports.add(specifier);
+        }
+    });
+    return {
+        exports: exports1,
+        imports,
+        unsafeCommonJsLoaderUsage,
+        unsafeDynamicImport
+    };
+};
+const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
+const isInsideDirectory = (directory, filePath)=>{
+    const relative = external_node_path_default().relative(directory, filePath);
+    return 0 === relative.length || !relative.startsWith('..') && !external_node_path_default().isAbsolute(relative);
+};
+const resolveWorkerModule = async (importer, specifier)=>{
+    const unresolvedPath = external_node_path_default().resolve(external_node_path_default().dirname(importer), specifier);
+    const candidates = [
+        unresolvedPath,
+        `${unresolvedPath}.js`,
+        `${unresolvedPath}.mjs`,
+        `${unresolvedPath}.cjs`,
+        external_node_path_default().join(unresolvedPath, 'index.js'),
+        external_node_path_default().join(unresolvedPath, 'index.mjs'),
+        external_node_path_default().join(unresolvedPath, 'index.cjs')
+    ];
+    for (const candidate of candidates)try {
+        if ((await promises_default().stat(candidate)).isFile()) return await promises_default().realpath(candidate);
+    } catch  {}
+};
+const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contract)=>{
+    const visited = new Set();
+    let entryAnalysis;
+    const [realWorkerRoot, realEntryPath] = await Promise.all([
+        promises_default().realpath(contract.workerRoot),
+        promises_default().realpath(entryPath)
+    ]);
+    if (!isInsideDirectory(realWorkerRoot, realEntryPath)) return void (0, external_issues_js_namespaceObject.addIssue)(issues, {
+        code: 'invalid-worker-bundle',
+        message: 'Cloudflare worker bundles must not resolve outside the staged worker directory.',
+        path: entryPath
+    });
+    const visitModule = async (modulePath, source, isEntry = false)=>{
+        if (visited.has(modulePath)) return;
+        visited.add(modulePath);
+        let analysis;
+        try {
+            analysis = analyzeWorkerModule(source ?? await promises_default().readFile(modulePath, 'utf-8'));
+        } catch (error) {
+            (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-worker-bundle',
+                message: `Cloudflare worker bundle module could not be parsed: ${error instanceof Error ? error.message : String(error)}`,
+                path: modulePath
+            });
+            return;
+        }
+        if (isEntry) entryAnalysis = analysis;
+        if (analysis.unsafeCommonJsLoaderUsage) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-worker-bundle',
+            message: 'Cloudflare worker bundles must use exactly one string-literal specifier in ambient CommonJS loader calls and must not pass or alias the loader.',
+            path: modulePath
+        });
+        if (analysis.unsafeDynamicImport) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-worker-bundle',
+            message: 'Cloudflare worker bundles must not contain non-static dynamic module imports.',
+            path: modulePath
+        });
+        for (const specifier of analysis.imports){
+            if (0 === specifier.length) {
+                (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: 'Cloudflare worker bundle module specifiers must not be empty.',
+                    path: modulePath
+                });
+                continue;
+            }
+            if (!specifier.startsWith('.') && !external_node_path_default().isAbsolute(specifier)) {
+                if (CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS.has(specifier)) continue;
+                if (specifier.startsWith('node:')) {
+                    (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                        code: 'invalid-worker-bundle',
+                        message: `Cloudflare worker bundle import "${specifier}" is not a supported Worker node: builtin.`,
+                        path: modulePath
+                    });
+                    continue;
+                }
+                if (!contract.providedPackages.has(getPackageName(specifier))) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: `Cloudflare worker bundle import "${specifier}" is not provided by worker/package.json dependencies.`,
+                    path: modulePath
+                });
+                continue;
+            }
+            const resolved = await resolveWorkerModule(modulePath, specifier);
+            if (resolved && !isInsideDirectory(realWorkerRoot, resolved)) {
+                (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: 'Cloudflare worker bundles must not resolve outside the staged worker directory.',
+                    path: modulePath
+                });
+                continue;
+            }
+            if (!resolved) {
+                (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: `Cloudflare worker bundle import "${specifier}" does not resolve inside worker/.`,
+                    path: modulePath
+                });
+                continue;
+            }
+            await visitModule(resolved);
+        }
+    };
+    await visitModule(realEntryPath, entrySource, true);
+    return entryAnalysis;
+};
+const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
+    const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
+    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+        code: 'invalid-worker-bundle',
+        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        path: worker.path
+    });
+};
+const verifyWorkerImport = async (issues, entryPath, expectedManifest)=>{
+    try {
+        const workerModule = await import(`${(0, external_node_url_namespaceObject.pathToFileURL)(entryPath).href}?t=${Date.now()}`);
+        const worker = workerModule.default;
+        if (!worker || 'function' != typeof worker.fetch) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'worker-import-failed',
+            message: 'Cloudflare server entry must default-export a Worker with fetch.',
+            path: entryPath
+        });
+        if (void 0 !== expectedManifest && !(0, external_node_util_namespaceObject.isDeepStrictEqual)(workerModule.modernWorkerManifest, expectedManifest)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'worker-import-failed',
+            message: 'Cloudflare server entry runtime manifest must exactly match modern-worker-manifest.json.',
+            path: entryPath
+        });
+    } catch (error) {
+        (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'worker-import-failed',
+            message: `Cloudflare server entry could not be imported: ${error instanceof Error ? error.message : String(error)}`,
+            path: entryPath
+        });
+    }
+};
+exports.getEffectBffWorker = __webpack_exports__.getEffectBffWorker;
+exports.getWorkerBundleReferences = __webpack_exports__.getWorkerBundleReferences;
+exports.missingWorkerBundleMessage = __webpack_exports__.missingWorkerBundleMessage;
+exports.resolveWorkerBundleReference = __webpack_exports__.resolveWorkerBundleReference;
+exports.verifyWorkerBundleReferences = __webpack_exports__.verifyWorkerBundleReferences;
+exports.verifyWorkerImport = __webpack_exports__.verifyWorkerImport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getEffectBffWorker",
+    "getWorkerBundleReferences",
+    "missingWorkerBundleMessage",
+    "resolveWorkerBundleReference",
+    "verifyWorkerBundleReferences",
+    "verifyWorkerImport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/config.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/css-extract-runtime-plugin.js

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+const PLUGIN_NAME = 'ModernjsCssExtractRuntimePlugin';
+const CSS_LOADING_RUNTIME_MODULE = 'webpack/runtime/css loading';
+const CSS_EXTRACT_STYLESHEET_MATCH = '\t\tif (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return tag;';
+const CSS_EXTRACT_STYLESHEET_MATCH_WITH_NORMALIZED_URL = `\t\tvar absoluteHref = tag.href;
+\t\tvar absoluteFullHref = new URL(fullhref, document.baseURI).href;
+\t\tif (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref || absoluteHref === absoluteFullHref)) return tag;`;
+const isAutomaticPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath;
+const normalizeCssExtractRuntimeStylesheetLookup = (source)=>{
+    if (!source.includes('__webpack_require__.miniCssF')) return source;
+    const occurrences = source.split(CSS_EXTRACT_STYLESHEET_MATCH).length - 1;
+    if (1 !== occurrences) throw new Error(`Unsupported CssExtractRspackPlugin runtime shape: expected one stylesheet lookup, found ${occurrences}.`);
+    return source.replace(CSS_EXTRACT_STYLESHEET_MATCH, CSS_EXTRACT_STYLESHEET_MATCH_WITH_NORMALIZED_URL);
+};
+class CssExtractRuntimePlugin {
+    apply(compiler) {
+        if (!isAutomaticPublicPath(compiler.options.output.publicPath)) return;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (runtimeModule)=>{
+                if (runtimeModule.identifier() !== CSS_LOADING_RUNTIME_MODULE) return;
+                const source = runtimeModule.source;
+                if (!source) return;
+                const runtimeSource = source.source;
+                if ('string' != typeof runtimeSource) return;
+                source.source = normalizeCssExtractRuntimeStylesheetLookup(runtimeSource);
+            });
+        });
+    }
+    constructor(){
+        this.name = PLUGIN_NAME;
+    }
+}
+__webpack_require__.d(__webpack_exports__, {
+    CssExtractRuntimePlugin: ()=>CssExtractRuntimePlugin
+}, {
+    normalizeCssExtractRuntimeStylesheetLookup: normalizeCssExtractRuntimeStylesheetLookup
+});
+exports.CssExtractRuntimePlugin = __webpack_exports__.CssExtractRuntimePlugin;
+exports.normalizeCssExtractRuntimeStylesheetLookup = __webpack_exports__.normalizeCssExtractRuntimeStylesheetLookup;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CssExtractRuntimePlugin",
+    "normalizeCssExtractRuntimeStylesheetLookup"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_modules__ = {
+    "./cloudflare-builder" (module) {
+        module.exports = require("./cloudflare-builder.js");
+    },
+    "./cloudflare-output-contract" (module) {
+        module.exports = require("./cloudflare-output-contract.js");
+    },
+    "./cloudflare-output-plan" (module) {
+        module.exports = require("./cloudflare-output-plan.js");
+    },
+    "./cloudflare-output-verifier" (module) {
+        module.exports = require("./cloudflare-output-verifier/index.js");
+    },
+    "./cloudflare" (module) {
+        module.exports = require("./cloudflare/index.js");
+    },
+    "./config" (module) {
+        module.exports = require("./config.js");
+    },
+    "./css-extract-runtime-plugin" (module) {
+        module.exports = require("./css-extract-runtime-plugin.js");
+    },
+    "./release-envelope" (module) {
+        module.exports = require("./release-envelope/index.js");
+    },
+    "./release-envelope/plugin" (module) {
+        module.exports = require("./release-envelope/plugin.js");
+    },
+    "./release-identity" (module) {
+        module.exports = require("./release-identity.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+    var _cloudflare__rspack_import_0 = __webpack_require__("./cloudflare");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _cloudflare__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_cloudflare__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _cloudflare_builder__rspack_import_1 = __webpack_require__("./cloudflare-builder");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _cloudflare_builder__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_cloudflare_builder__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _cloudflare_output_contract__rspack_import_2 = __webpack_require__("./cloudflare-output-contract");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _cloudflare_output_contract__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_cloudflare_output_contract__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _cloudflare_output_plan__rspack_import_3 = __webpack_require__("./cloudflare-output-plan");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _cloudflare_output_plan__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_cloudflare_output_plan__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _cloudflare_output_verifier__rspack_import_4 = __webpack_require__("./cloudflare-output-verifier");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _cloudflare_output_verifier__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_cloudflare_output_verifier__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _config__rspack_import_5 = __webpack_require__("./config");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _config__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_config__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _css_extract_runtime_plugin__rspack_import_6 = __webpack_require__("./css-extract-runtime-plugin");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _css_extract_runtime_plugin__rspack_import_6)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_css_extract_runtime_plugin__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _release_envelope__rspack_import_7 = __webpack_require__("./release-envelope");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _release_envelope__rspack_import_7)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_release_envelope__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _release_envelope_plugin__rspack_import_8 = __webpack_require__("./release-envelope/plugin");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _release_envelope_plugin__rspack_import_8)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_release_envelope_plugin__rspack_import_8[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _release_identity__rspack_import_9 = __webpack_require__("./release-identity");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _release_identity__rspack_import_9)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_release_identity__rspack_import_9[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/read-template.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    getTemplatePath: ()=>getTemplatePath,
+    readTemplate: ()=>readTemplate
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const getTemplatePath = (file)=>external_node_path_default().join(__dirname, 'templates', file);
+const readTemplate = async (file)=>(await utils_namespaceObject.fs.readFile(getTemplatePath(file))).toString();
+exports.getTemplatePath = __webpack_exports__.getTemplatePath;
+exports.readTemplate = __webpack_exports__.readTemplate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getTemplatePath",
+    "readTemplate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});