@bleedingdev/modern-js-create 3.2.0-ultramodern.98 → 3.4.0-ultramodern.0

package/dist/cjs/ultramodern-workspace/module-federation.cjs

@@ -0,0 +1,487 @@
+"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__, {
+    createAppModernConfig: ()=>createAppModernConfig,
+    createBuildMarker: ()=>createBuildMarker,
+    createModuleFederationRemoteUrlHelpers: ()=>createModuleFederationRemoteUrlHelpers,
+    createModuleFederationRemotesConfig: ()=>createModuleFederationRemotesConfig,
+    createRemoteModuleFederationConfig: ()=>createRemoteModuleFederationConfig,
+    createSharedModuleFederationConfig: ()=>createSharedModuleFederationConfig,
+    createShellModuleFederationConfig: ()=>createShellModuleFederationConfig,
+    createUltramodernBuildModule: ()=>createUltramodernBuildModule,
+    formatTsObjectLiteral: ()=>formatTsObjectLiteral
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+function createAppModernConfig(scope, app) {
+    const bffImport = (0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
+    const bffConfig = (0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? `      bff: {
+        effect: {
+          entry: './api/effect/index',
+          openapi: {
+            path: '/openapi.json',
+          },
+        },
+        prefix: '${(0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(app)}',
+        runtimeFramework: 'effect',
+      },
+` : '';
+    const bffPluginEntry = (0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? '        bffPlugin(),\n' : '';
+    return `// @effect-diagnostics processEnv:off
+import {
+  appTools,
+  defineConfig,
+  presetUltramodern,
+} from '@modern-js/app-tools';
+${bffImport}import { i18nPlugin } from '@modern-js/plugin-i18n';
+import { tanstackRouterPlugin } from '@modern-js/plugin-tanstack';
+import { moduleFederationPlugin } from '@module-federation/modern-js-v3';
+import { withZephyr as withZephyrRspack } from 'zephyr-rspack-plugin';
+import { ultramodernLocalisedUrls } from './src/routes/ultramodern-route-metadata';
+
+type ZephyrRspackConfig = Parameters<ReturnType<typeof withZephyrRspack>>[0];
+
+const zephyrEnabled = process.env['ULTRAMODERN_ZEPHYR'] !== 'false';
+const cloudflareDeployEnabled =
+  process.env['MODERNJS_DEPLOY'] === 'cloudflare';
+
+const zephyrRspackPlugin = () => ({
+  name: 'ultramodern-zephyr-rspack-plugin',
+  pre: ['@modern-js/plugin-module-federation-config'],
+  setup(api: {
+    modifyRspackConfig: (
+      handler: (
+        config: ZephyrRspackConfig,
+      ) => ZephyrRspackConfig | Promise<ZephyrRspackConfig>,
+    ) => void;
+  }) {
+    if (!zephyrEnabled) {
+      return;
+    }
+    api.modifyRspackConfig(config => withZephyrRspack()(config));
+  },
+});
+
+const appId = '${app.id}';
+const cloudflareWorkerName = '${(0, external_descriptors_cjs_namespaceObject.createCloudflareWorkerName)(scope, app)}';
+const port = Number(process.env['${app.portEnv}'] ?? ${app.port});
+const envValue = (name: string) => {
+  const value = process.env[name]?.trim();
+  return value !== undefined && value.length > 0 ? value : undefined;
+};
+const configuredSiteUrl = envValue('MODERN_PUBLIC_SITE_URL');
+const configuredCloudflareUrl = envValue('${(0, external_descriptors_cjs_namespaceObject.createCloudflarePublicUrlEnv)(app)}');
+const configuredUltramodernAssetPrefix = envValue('ULTRAMODERN_ASSET_PREFIX');
+const configuredModernAssetPrefix = envValue('MODERN_ASSET_PREFIX');
+const cloudflareWorkersDevSubdomain = envValue(
+  'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
+);
+const inferredCloudflareUrl =
+  cloudflareDeployEnabled && cloudflareWorkersDevSubdomain !== undefined
+    ? \`https://\${cloudflareWorkerName}.\${cloudflareWorkersDevSubdomain}.workers.dev\`
+    : undefined;
+// Site origin (SEO: canonical/hreflang URLs) prefers the site-wide public URL;
+// the per-app deployment URL only fills in when no site origin is configured.
+const siteUrl =
+  configuredSiteUrl ||
+  configuredCloudflareUrl ||
+  inferredCloudflareUrl ||
+  \`http://localhost:\${port}\`;
+// Asset loading is intentionally independent from the canonical site URL and
+// deployment public URL. Without an explicit asset prefix, assets stay
+// origin-relative so self-hosted apps, tunnels, and reverse proxies never leak
+// localhost URLs into production HTML.
+const assetPrefix =
+  configuredModernAssetPrefix || configuredUltramodernAssetPrefix || '/';
+
+if (
+  cloudflareDeployEnabled &&
+  process.env['ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'] === 'true' &&
+  configuredCloudflareUrl === undefined &&
+  configuredSiteUrl === undefined &&
+  inferredCloudflareUrl === undefined
+) {
+  throw new Error(
+    \`Cloudflare deploy for \${appId} needs ${(0, external_descriptors_cjs_namespaceObject.createCloudflarePublicUrlEnv)(app)}, MODERN_PUBLIC_SITE_URL, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN.\`,
+  );
+}
+
+export default defineConfig(
+  presetUltramodern(
+    {
+${bffConfig}      ...(cloudflareDeployEnabled
+        ? {
+            deploy: {
+              worker: {
+                compatibilityDate: '${external_versions_cjs_namespaceObject.CLOUDFLARE_COMPATIBILITY_DATE}',
+                name: cloudflareWorkerName,
+                security: ${(0, external_policy_cjs_namespaceObject.formatTsJsonValue)((0, external_types_cjs_namespaceObject.sortJsonValue)((0, external_policy_cjs_namespaceObject.createCloudflareSecurityContract)()), 16)},
+                ssr: true,
+              },
+            },
+          }
+        : {}),
+      dev: {
+        // Keep dev assets origin-relative too; the default absolute
+        // http://localhost:<port> prefix breaks pages served through tunnels.
+        assetPrefix: '/',
+      },
+      html: {
+        outputStructure: 'flat',
+      },
+      output: {
+        assetPrefix,
+        disableTsChecker: true,
+        distPath: {
+          html: './',
+        },
+        polyfill: 'off',
+        splitRouteChunks: true,
+      },
+      performance: {
+        rsdoctor: {
+          disableClientServer: true,
+          enabled: process.env['ULTRAMODERN_RSDOCTOR'] === 'true',
+        },
+      },
+      plugins: [
+        appTools(),
+        tanstackRouterPlugin(),
+        i18nPlugin({
+          backend: {
+            enabled: true,
+            loadPath: '/locales/{{lng}}/{{ns}}.json',
+          },
+          localeDetection: {
+            fallbackLanguage: 'en',
+            ignoreRedirectRoutes: [
+              '/@mf-types',
+              '/assets',
+              '/bundles',
+              '${(0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(app)}',
+              '/locales',
+              '/mf-manifest.json',
+              '/mf-stats.json',
+              '/remoteEntry.js',
+              '/robots.txt',
+              '/site.webmanifest',
+              '/sitemap.xml',
+              '/static',
+              '/zephyr-manifest.json',
+            ],
+            languages: ['en', 'cs'],
+            localePathRedirect: true,
+            localisedUrls: ultramodernLocalisedUrls as Record<string, Record<string, string>>,
+          },
+          reactI18next: false,
+        }),
+${bffPluginEntry}        moduleFederationPlugin(),
+        zephyrRspackPlugin(),
+      ],
+      server: {
+        port,
+        publicDir: ['./locales', './assets'],
+        ssr: {
+          mode: 'string',
+          moduleFederationAppSSR: true,
+        },
+      },
+      source: {
+        globalVars: {
+          ULTRAMODERN_SITE_URL: siteUrl,
+        },
+        mainEntryName: 'index',
+      },
+      tools: {
+        autoprefixer: {
+          overrideBrowserslist: ['defaults'],
+        },
+        bundlerChain: chain => {
+          chain.output
+            .uniqueName('${(0, external_naming_cjs_namespaceObject.createRspackUniqueName)(app)}')
+            .chunkLoadingGlobal('${(0, external_naming_cjs_namespaceObject.createRspackChunkLoadingGlobal)(app)}');
+          chain.ignoreWarnings([
+            {
+              message: /the request of a dependency is an expression/u,
+              module: /modern-js-plugin-i18n/u,
+            },
+          ]);
+        },
+      },
+    },
+    {
+      appId,
+      enableBffRequestId: true,
+      enableModuleFederationSSR: true,
+      enableTelemetryExporters: true,
+      telemetryFailLoudStartup: false,
+    },
+  ),
+);
+`;
+}
+function createSharedModuleFederationConfig() {
+    return `  shared: {
+    '@modern-js/plugin-i18n/runtime': {
+      requiredVersion: pluginI18nVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@modern-js/plugin-tanstack/runtime': {
+      requiredVersion: pluginTanstackVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@modern-js/runtime': {
+      requiredVersion: runtimeVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@tanstack/react-router': {
+      requiredVersion: dependencies['@tanstack/react-router'],
+      singleton: true,
+      treeShaking: false,
+    },
+    react: {
+      requiredVersion: reactVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    'react-dom': {
+      requiredVersion: reactDomVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    'react-dom/client': {
+      requiredVersion: reactDomVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+  }`;
+}
+function formatTsObjectLiteral(value) {
+    const entries = Object.entries(value).sort(([left], [right])=>left.localeCompare(right));
+    if (0 === entries.length) return '{}';
+    return `{
+${entries.map(([key, entryValue])=>`    '${key}': '${entryValue}',`).join('\n')}
+  }`;
+}
+function createModuleFederationRemoteUrlHelpers(app, remotes = []) {
+    if (0 === (0, external_descriptors_cjs_namespaceObject.resolveRemoteRefs)(app, remotes).length) return '';
+    return `const cloudflareDeployEnabled =
+  process.env['MODERNJS_DEPLOY'] === 'cloudflare';
+const cloudflareWorkersDevSubdomain =
+  process.env['ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN']?.trim();
+const requireCloudflarePublicUrls =
+  process.env['ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'] === 'true';
+
+const createRemoteManifestUrl = (options: {
+  manifestEnv: string;
+  mfName: string;
+  port: number;
+  publicUrlEnv: string;
+  workerName: string;
+}) => {
+  const configuredManifest = process.env[options.manifestEnv]?.trim();
+  if (configuredManifest !== undefined && configuredManifest.length > 0) {
+    return configuredManifest;
+  }
+
+  const configuredPublicUrl = process.env[options.publicUrlEnv]?.trim();
+  if (configuredPublicUrl !== undefined && configuredPublicUrl.length > 0) {
+    return \`\${options.mfName}@\${configuredPublicUrl.replace(/\\/+$/u, '')}/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && cloudflareWorkersDevSubdomain !== undefined) {
+    return \`\${options.mfName}@https://\${options.workerName}.\${cloudflareWorkersDevSubdomain}.workers.dev/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && requireCloudflarePublicUrls) {
+    throw new Error(
+      \`Cloudflare deploy needs \${options.publicUrlEnv}, \${options.manifestEnv}, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN for remote \${options.mfName}.\`,
+    );
+  }
+
+  return \`\${options.mfName}@http://localhost:\${options.port}/mf-manifest.json\`;
+};
+
+`;
+}
+function createModuleFederationRemotesConfig(scope, app, remotes = []) {
+    const remoteEntries = (0, external_descriptors_cjs_namespaceObject.resolveRemoteRefs)(app, remotes).toSorted((left, right)=>(0, external_descriptors_cjs_namespaceObject.remoteDependencyAlias)(left).localeCompare((0, external_descriptors_cjs_namespaceObject.remoteDependencyAlias)(right))).map((remote)=>{
+        const key = (0, external_descriptors_cjs_namespaceObject.remoteDependencyAlias)(remote);
+        return `    ${key}: createRemoteManifestUrl({
+      manifestEnv: '${(0, external_descriptors_cjs_namespaceObject.createRemoteManifestEnv)(remote)}',
+      mfName: '${remote.mfName}',
+      port: ${remote.port},
+      publicUrlEnv: '${(0, external_descriptors_cjs_namespaceObject.createCloudflarePublicUrlEnv)(remote)}',
+      workerName: '${(0, external_descriptors_cjs_namespaceObject.createCloudflareWorkerName)(scope, remote)}',
+    }),`;
+    }).join('\n');
+    if (!remoteEntries) return '';
+    return `  remotes: {
+${remoteEntries}
+  },
+`;
+}
+function createShellModuleFederationConfig(scope, remotes = []) {
+    const shellHost = {
+        ...external_descriptors_cjs_namespaceObject.shellApp,
+        verticalRefs: remotes.map((remote)=>remote.id)
+    };
+    return `// @effect-diagnostics nodeBuiltinImport:off processEnv:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+${createModuleFederationRemoteUrlHelpers(shellHost, remotes)}
+export default createModuleFederationConfig({
+  bridge: {
+    enableBridgeRouter: false,
+  },
+  dev: {
+    disableDynamicRemoteTypeHints: true,
+  },
+  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+  },
+  filename: 'remoteEntry.js',
+  name: '${external_descriptors_cjs_namespaceObject.shellApp.mfName}',
+${createModuleFederationRemotesConfig(scope, shellHost, remotes)}${createSharedModuleFederationConfig()},
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+`;
+}
+function createBuildMarker(scope, app) {
+    return external_node_crypto_default().createHash('sha256').update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function createUltramodernBuildModule(scope, app) {
+    return `export const ultramodernVerticalIdentity = {
+  appId: '${app.id}',
+  build: '${createBuildMarker(scope, app)}',
+  deployProfile: 'cloudflare-ssr-mf-effect-v1',
+  packageName: '${(0, external_naming_cjs_namespaceObject.packageName)(scope, app.packageSuffix)}',
+  version: '0.1.0',
+} as const;
+
+export const ultramodernUiMarker = {
+  ...ultramodernVerticalIdentity,
+  surface: 'ui',
+} as const;
+
+export const ultramodernApiMarker = {
+  ...ultramodernVerticalIdentity,
+  surface: 'effect-bff',
+} as const;
+`;
+}
+function createRemoteModuleFederationConfig(scope, app, remotes = []) {
+    const exposes = formatTsObjectLiteral(app.exposes ?? {});
+    return `// @effect-diagnostics nodeBuiltinImport:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+${createModuleFederationRemoteUrlHelpers(app, remotes)}
+export default createModuleFederationConfig({
+  bridge: {
+    enableBridgeRouter: false,
+  },
+  dev: {
+    disableDynamicRemoteTypeHints: true,
+  },
+  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+  },
+  exposes: ${exposes},
+  filename: 'remoteEntry.js',
+  name: '${app.mfName}',
+${createModuleFederationRemotesConfig(scope, app, remotes)}${createSharedModuleFederationConfig()},
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+`;
+}
+exports.createAppModernConfig = __webpack_exports__.createAppModernConfig;
+exports.createBuildMarker = __webpack_exports__.createBuildMarker;
+exports.createModuleFederationRemoteUrlHelpers = __webpack_exports__.createModuleFederationRemoteUrlHelpers;
+exports.createModuleFederationRemotesConfig = __webpack_exports__.createModuleFederationRemotesConfig;
+exports.createRemoteModuleFederationConfig = __webpack_exports__.createRemoteModuleFederationConfig;
+exports.createSharedModuleFederationConfig = __webpack_exports__.createSharedModuleFederationConfig;
+exports.createShellModuleFederationConfig = __webpack_exports__.createShellModuleFederationConfig;
+exports.createUltramodernBuildModule = __webpack_exports__.createUltramodernBuildModule;
+exports.formatTsObjectLiteral = __webpack_exports__.formatTsObjectLiteral;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAppModernConfig",
+    "createBuildMarker",
+    "createModuleFederationRemoteUrlHelpers",
+    "createModuleFederationRemotesConfig",
+    "createRemoteModuleFederationConfig",
+    "createSharedModuleFederationConfig",
+    "createShellModuleFederationConfig",
+    "createUltramodernBuildModule",
+    "formatTsObjectLiteral"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/naming.cjs

@@ -0,0 +1,161 @@
+"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__, {
+    TAILWIND_PREFIX_DIGIT_WORDS: ()=>TAILWIND_PREFIX_DIGIT_WORDS,
+    assertUniqueTailwindPrefixes: ()=>assertUniqueTailwindPrefixes,
+    createRspackChunkLoadingGlobal: ()=>createRspackChunkLoadingGlobal,
+    createRspackUniqueName: ()=>createRspackUniqueName,
+    createTailwindPrefix: ()=>createTailwindPrefix,
+    createTw: ()=>createTw,
+    normalizePath: ()=>normalizePath,
+    packageName: ()=>naming_packageName,
+    relativeRootFor: ()=>relativeRootFor,
+    tailwindPrefixForApp: ()=>tailwindPrefixForApp,
+    toCamelCase: ()=>toCamelCase,
+    toEnvSegment: ()=>toEnvSegment,
+    toKebabCase: ()=>toKebabCase,
+    toPackageScope: ()=>toPackageScope,
+    toPascalCase: ()=>toPascalCase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const TAILWIND_PREFIX_DIGIT_WORDS = [
+    'zero',
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine'
+];
+function normalizePath(filePath) {
+    return filePath.split(external_node_path_default().sep).join('/');
+}
+function toPackageScope(packageName) {
+    const normalized = packageName.replace(/^@/, '').replace(/[\\/]+/g, '-').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+|[._-]+$/g, '').replace(/-{2,}/g, '-');
+    return normalized || 'ultramodern-superapp';
+}
+function toKebabCase(value) {
+    const normalized = value.trim().replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/[._]+/g, '-').toLowerCase().replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized;
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    return `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}`;
+}
+function toEnvSegment(value) {
+    return toKebabCase(value).replace(/-/g, '_').toUpperCase();
+}
+function createRspackUniqueName(app) {
+    return app.mfName;
+}
+function createRspackChunkLoadingGlobal(app) {
+    return `__ULTRAMODERN_${toEnvSegment(app.mfName)}_LOADED_CHUNKS__`;
+}
+function naming_packageName(scope, suffix) {
+    return `@${scope}/${suffix}`;
+}
+function relativeRootFor(packageDir) {
+    return normalizePath(external_node_path_default().relative(packageDir, '.') || '.');
+}
+function createTailwindPrefix(raw) {
+    const normalized = raw.toLowerCase().replace(/[^a-z0-9]/gu, '');
+    if (!normalized) throw new Error(`Cannot derive a Tailwind prefix from ${raw}`);
+    return normalized.replace(/[0-9]/gu, (digit)=>TAILWIND_PREFIX_DIGIT_WORDS[Number(digit)]);
+}
+function tailwindPrefixForApp(app) {
+    if ('shell' === app.kind) return 'shell';
+    return createTailwindPrefix(app.domain ?? app.id);
+}
+function assertUniqueTailwindPrefixes(apps) {
+    const seen = new Map();
+    const entries = apps.map((app)=>[
+            app.id,
+            tailwindPrefixForApp(app)
+        ]);
+    for (const [id, prefix] of entries){
+        const previous = seen.get(prefix);
+        if (previous) throw new Error(`Tailwind prefix ${prefix} for ${id} collides with ${previous}`);
+        seen.set(prefix, id);
+    }
+}
+function createTw(prefix) {
+    return (classList)=>classList.split(/\s+/u).filter(Boolean).map((candidate)=>`${prefix}:${candidate.replace(/\[&&\]:/gu, '')}`).join(' ');
+}
+function toPascalCase(value) {
+    return value.split(/[-_]+/).filter(Boolean).map((part)=>`${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
+}
+exports.TAILWIND_PREFIX_DIGIT_WORDS = __webpack_exports__.TAILWIND_PREFIX_DIGIT_WORDS;
+exports.assertUniqueTailwindPrefixes = __webpack_exports__.assertUniqueTailwindPrefixes;
+exports.createRspackChunkLoadingGlobal = __webpack_exports__.createRspackChunkLoadingGlobal;
+exports.createRspackUniqueName = __webpack_exports__.createRspackUniqueName;
+exports.createTailwindPrefix = __webpack_exports__.createTailwindPrefix;
+exports.createTw = __webpack_exports__.createTw;
+exports.normalizePath = __webpack_exports__.normalizePath;
+exports.packageName = __webpack_exports__.packageName;
+exports.relativeRootFor = __webpack_exports__.relativeRootFor;
+exports.tailwindPrefixForApp = __webpack_exports__.tailwindPrefixForApp;
+exports.toCamelCase = __webpack_exports__.toCamelCase;
+exports.toEnvSegment = __webpack_exports__.toEnvSegment;
+exports.toKebabCase = __webpack_exports__.toKebabCase;
+exports.toPackageScope = __webpack_exports__.toPackageScope;
+exports.toPascalCase = __webpack_exports__.toPascalCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TAILWIND_PREFIX_DIGIT_WORDS",
+    "assertUniqueTailwindPrefixes",
+    "createRspackChunkLoadingGlobal",
+    "createRspackUniqueName",
+    "createTailwindPrefix",
+    "createTw",
+    "normalizePath",
+    "packageName",
+    "relativeRootFor",
+    "tailwindPrefixForApp",
+    "toCamelCase",
+    "toEnvSegment",
+    "toKebabCase",
+    "toPackageScope",
+    "toPascalCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});