@bleedingdev/modern-js-create 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

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

@@ -0,0 +1,375 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createJsonLdHelperModule: ()=>createJsonLdHelperModule,
+    createLocalisedUrlsMap: ()=>createLocalisedUrlsMap,
+    createLocalisedUrlsMapFromRoutes: ()=>createLocalisedUrlsMapFromRoutes,
+    createPublicRouteMetadata: ()=>createPublicRouteMetadata,
+    createPublicRouteMetadataFromRoutes: ()=>createPublicRouteMetadataFromRoutes,
+    createRouteAliasPage: ()=>createRouteAliasPage,
+    createRouteMetaFilePath: ()=>createRouteMetaFilePath,
+    createRouteMetaModule: ()=>createRouteMetaModule,
+    createRouteMetadataModule: ()=>createRouteMetadataModule,
+    createRouteOwnedI18nPaths: ()=>createRouteOwnedI18nPaths,
+    createRoutePageFilePath: ()=>createRoutePageFilePath,
+    isConcretePublicPath: ()=>isConcretePublicPath,
+    isDynamicPublicPathSegment: ()=>isDynamicPublicPathSegment,
+    isPublicIndexableRoute: ()=>isPublicIndexableRoute,
+    normalisePublicPath: ()=>normalisePublicPath,
+    privateAppRoutePublicness: ()=>privateAppRoutePublicness,
+    routePathDirectorySegments: ()=>routePathDirectorySegments,
+    routePathParamName: ()=>routePathParamName,
+    routeSegmentToDirectory: ()=>routeSegmentToDirectory,
+    splitPublicPathSegments: ()=>splitPublicPathSegments
+});
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const privateAppRoutePublicness = {
+    indexable: false,
+    public: false,
+    publicSurface: 'private-app-screen'
+};
+function createRouteOwnedI18nPaths(app) {
+    const namespace = (0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(app);
+    const base = {
+        descriptionKey: `${namespace}.seo.description`,
+        mfBoundaryId: app.mfName,
+        namespace,
+        ownerAppId: app.id,
+        ...privateAppRoutePublicness
+    };
+    if ('shell' === app.kind) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'shell-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'shell.title'
+        }
+    ];
+    return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: `${app.id}-home`,
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: `${namespace}.title`
+        }
+    ];
+}
+function isPublicIndexableRoute(route) {
+    return route.public && route.indexable;
+}
+function createLocalisedUrlsMapFromRoutes(routes) {
+    return Object.fromEntries(routes.flatMap((route)=>{
+        if ('/' === route.canonicalPath) return [];
+        return Array.from(new Set([
+            route.canonicalPath,
+            ...Object.values(route.localisedPaths)
+        ])).map((pathname)=>[
+                pathname,
+                route.localisedPaths
+            ]);
+    }));
+}
+function createLocalisedUrlsMap(app) {
+    return createLocalisedUrlsMapFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createPublicRouteMetadataFromRoutes(routes) {
+    return routes.filter(isPublicIndexableRoute).map((route)=>{
+        const metadata = {
+            canonicalPath: route.canonicalPath,
+            id: route.id,
+            localisedPaths: route.localisedPaths,
+            namespace: route.namespace,
+            ownerAppId: route.ownerAppId,
+            descriptionKey: route.descriptionKey,
+            titleKey: route.titleKey
+        };
+        if (void 0 !== route.jsonLd) metadata.jsonLd = route.jsonLd;
+        return metadata;
+    });
+}
+function createPublicRouteMetadata(app) {
+    return createPublicRouteMetadataFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createJsonLdHelperModule() {
+    return `export type JsonLdPrimitive = string | number | boolean | null;
+export type JsonLdValue =
+  | JsonLdPrimitive
+  | readonly JsonLdValue[]
+  | { readonly [key: string]: JsonLdValue };
+export type JsonLdObject = Readonly<Record<string, JsonLdValue>>;
+export type RouteJsonLd = JsonLdObject | readonly JsonLdObject[];
+
+const schemaContext = 'https://schema.org' as const;
+
+type SchemaObject<TType extends string> = JsonLdObject & {
+  readonly '@context': typeof schemaContext;
+  readonly '@type': TType;
+};
+
+type ThingReference =
+  | string
+  | {
+      readonly '@id'?: string;
+      readonly '@type'?: string;
+      readonly name?: string;
+      readonly url?: string;
+    };
+
+const withSchemaContext = <TType extends string, TInput extends object>(
+  type: TType,
+  input: TInput,
+): SchemaObject<TType> & TInput => ({
+  '@context': schemaContext,
+  '@type': type,
+  ...input,
+});
+
+export const defineRouteJsonLd = <TJsonLd extends RouteJsonLd>(
+  jsonLd: TJsonLd,
+): TJsonLd => jsonLd;
+
+export interface WebPageJsonLdInput {
+  readonly name: string;
+  readonly url: string;
+  readonly description?: string;
+  readonly inLanguage?: string | readonly string[];
+  readonly isPartOf?: ThingReference;
+}
+
+export const webPageJsonLd = (input: WebPageJsonLdInput) =>
+  withSchemaContext('WebPage', input);
+
+export interface WebApplicationJsonLdInput {
+  readonly name: string;
+  readonly url: string;
+  readonly applicationCategory?: string;
+  readonly browserRequirements?: string;
+  readonly description?: string;
+  readonly operatingSystem?: string;
+}
+
+export const webApplicationJsonLd = (input: WebApplicationJsonLdInput) =>
+  withSchemaContext('WebApplication', input);
+
+export interface SoftwareApplicationJsonLdInput {
+  readonly name: string;
+  readonly url: string;
+  readonly applicationCategory?: string;
+  readonly applicationSubCategory?: string;
+  readonly description?: string;
+  readonly offers?: ThingReference;
+  readonly operatingSystem?: string;
+}
+
+export const softwareApplicationJsonLd = (
+  input: SoftwareApplicationJsonLdInput,
+) => withSchemaContext('SoftwareApplication', input);
+
+export interface OrganizationJsonLdInput {
+  readonly name: string;
+  readonly url?: string;
+  readonly logo?: string;
+  readonly sameAs?: readonly string[];
+}
+
+export const organizationJsonLd = (input: OrganizationJsonLdInput) =>
+  withSchemaContext('Organization', input);
+
+export interface BreadcrumbListItemInput {
+  readonly name: string;
+  readonly item: string;
+}
+
+export const breadcrumbListJsonLd = (
+  items: readonly BreadcrumbListItemInput[],
+) =>
+  withSchemaContext('BreadcrumbList', {
+    itemListElement: items.map((entry, index) => ({
+      '@type': 'ListItem',
+      item: entry.item,
+      name: entry.name,
+      position: index + 1,
+    })),
+  });
+
+export interface FAQPageQuestionInput {
+  readonly name: string;
+  readonly acceptedAnswer: {
+    readonly text: string;
+  };
+}
+
+export const faqPageJsonLd = (questions: readonly FAQPageQuestionInput[]) =>
+  withSchemaContext('FAQPage', {
+    mainEntity: questions.map(question => ({
+      '@type': 'Question',
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: question.acceptedAnswer.text,
+      },
+      name: question.name,
+    })),
+  });
+`;
+}
+function createRouteMetadataModule(app) {
+    const routes = (0, external_types_cjs_namespaceObject.sortJsonValue)(createRouteOwnedI18nPaths(app));
+    const localisedUrls = (0, external_types_cjs_namespaceObject.sortJsonValue)(createLocalisedUrlsMap(app));
+    const publicRoutes = (0, external_types_cjs_namespaceObject.sortJsonValue)(createPublicRouteMetadata(app));
+    const namespace = (0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(app);
+    return `// @generated by @modern-js/create.
+// Author route metadata in colocated src/routes/**/route.meta.ts files.
+// This compatibility manifest is regenerated from route-owned metadata.
+
+export const ultramodernRouteNamespace = '${namespace}' as const;
+
+export const ultramodernRouteMetadata = ${JSON.stringify(routes, null, 2)} as const;
+
+export const ultramodernLocalisedUrls = ${JSON.stringify(localisedUrls, null, 2)} as const;
+
+export const ultramodernPublicRoutes = ${JSON.stringify(publicRoutes, null, 2)} as const;
+
+export const ultramodernRouteConfig = {
+  authoring: 'colocated-route-meta',
+  generatedManifest: true,
+  localisedUrls: ultramodernLocalisedUrls,
+  namespace: ultramodernRouteNamespace,
+  publicRoutes: ultramodernPublicRoutes,
+  routes: ultramodernRouteMetadata,
+  source: 'route-owned',
+} as const;
+`;
+}
+function createRouteMetaModule(route) {
+    return `const routeMeta = ${JSON.stringify((0, external_types_cjs_namespaceObject.sortJsonValue)(route), null, 2)} as const;
+
+export default routeMeta;
+export { routeMeta };
+`;
+}
+function normalisePublicPath(pathname) {
+    const normalised = pathname.trim().replaceAll(/\/+/gu, '/').replace(/\/+$/u, '');
+    return normalised.length > 0 && normalised.startsWith('/') ? normalised : `/${normalised}`;
+}
+function splitPublicPathSegments(pathname) {
+    return normalisePublicPath(pathname).split('/').filter(Boolean);
+}
+function routePathParamName(segment) {
+    if (segment.startsWith(':')) return segment.slice(1).replace(/[?*+]$/u, '');
+    if (segment.startsWith('[') && segment.endsWith(']')) return segment.slice(1, -1).replace(/^\.\.\./u, '').replace(/\$$/u, '');
+}
+function isDynamicPublicPathSegment(segment) {
+    return void 0 !== routePathParamName(segment) || segment.includes('*') || segment.startsWith('[');
+}
+function isConcretePublicPath(pathname) {
+    return !splitPublicPathSegments(pathname).some(isDynamicPublicPathSegment);
+}
+function routeSegmentToDirectory(segment) {
+    const paramName = routePathParamName(segment);
+    if (paramName && segment.startsWith(':')) return segment.endsWith('?') ? `[${paramName}$]` : `[${paramName}]`;
+    return segment;
+}
+function routePathDirectorySegments(routePath) {
+    return splitPublicPathSegments(routePath).map(routeSegmentToDirectory);
+}
+function createRoutePageFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'page.tsx'
+    ].join('/')}`;
+}
+function createRouteMetaFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'route.meta.ts'
+    ].join('/')}`;
+}
+function createRouteAliasPage(canonicalPath) {
+    const depth = canonicalPath.split('/').filter(Boolean).length;
+    const rootPageImport = `${'../'.repeat(depth)}page`;
+    return `export { default } from '${rootPageImport}';
+`;
+}
+exports.createJsonLdHelperModule = __webpack_exports__.createJsonLdHelperModule;
+exports.createLocalisedUrlsMap = __webpack_exports__.createLocalisedUrlsMap;
+exports.createLocalisedUrlsMapFromRoutes = __webpack_exports__.createLocalisedUrlsMapFromRoutes;
+exports.createPublicRouteMetadata = __webpack_exports__.createPublicRouteMetadata;
+exports.createPublicRouteMetadataFromRoutes = __webpack_exports__.createPublicRouteMetadataFromRoutes;
+exports.createRouteAliasPage = __webpack_exports__.createRouteAliasPage;
+exports.createRouteMetaFilePath = __webpack_exports__.createRouteMetaFilePath;
+exports.createRouteMetaModule = __webpack_exports__.createRouteMetaModule;
+exports.createRouteMetadataModule = __webpack_exports__.createRouteMetadataModule;
+exports.createRouteOwnedI18nPaths = __webpack_exports__.createRouteOwnedI18nPaths;
+exports.createRoutePageFilePath = __webpack_exports__.createRoutePageFilePath;
+exports.isConcretePublicPath = __webpack_exports__.isConcretePublicPath;
+exports.isDynamicPublicPathSegment = __webpack_exports__.isDynamicPublicPathSegment;
+exports.isPublicIndexableRoute = __webpack_exports__.isPublicIndexableRoute;
+exports.normalisePublicPath = __webpack_exports__.normalisePublicPath;
+exports.privateAppRoutePublicness = __webpack_exports__.privateAppRoutePublicness;
+exports.routePathDirectorySegments = __webpack_exports__.routePathDirectorySegments;
+exports.routePathParamName = __webpack_exports__.routePathParamName;
+exports.routeSegmentToDirectory = __webpack_exports__.routeSegmentToDirectory;
+exports.splitPublicPathSegments = __webpack_exports__.splitPublicPathSegments;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createJsonLdHelperModule",
+    "createLocalisedUrlsMap",
+    "createLocalisedUrlsMapFromRoutes",
+    "createPublicRouteMetadata",
+    "createPublicRouteMetadataFromRoutes",
+    "createRouteAliasPage",
+    "createRouteMetaFilePath",
+    "createRouteMetaModule",
+    "createRouteMetadataModule",
+    "createRouteOwnedI18nPaths",
+    "createRoutePageFilePath",
+    "isConcretePublicPath",
+    "isDynamicPublicPathSegment",
+    "isPublicIndexableRoute",
+    "normalisePublicPath",
+    "privateAppRoutePublicness",
+    "routePathDirectorySegments",
+    "routePathParamName",
+    "routeSegmentToDirectory",
+    "splitPublicPathSegments"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,61 @@
+"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__);
+function sortJsonValue(value) {
+    if (Array.isArray(value)) return value.map(sortJsonValue);
+    if (null !== value && 'object' == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entry])=>[
+            key,
+            sortJsonValue(entry)
+        ]));
+    return value;
+}
+const supportedWorkspaceLanguages = [
+    'en',
+    'cs'
+];
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+__webpack_require__.d(__webpack_exports__, {
+    isRecord: ()=>isRecord,
+    sortJsonValue: ()=>sortJsonValue
+}, {
+    supportedWorkspaceLanguages: supportedWorkspaceLanguages
+});
+exports.isRecord = __webpack_exports__.isRecord;
+exports.sortJsonValue = __webpack_exports__.sortJsonValue;
+exports.supportedWorkspaceLanguages = __webpack_exports__.supportedWorkspaceLanguages;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRecord",
+    "sortJsonValue",
+    "supportedWorkspaceLanguages"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,153 @@
+"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 TANSTACK_ROUTER_VERSION = '1.170.15';
+const MODULE_FEDERATION_VERSION = '2.5.1';
+const ZEPHYR_RSPACK_PLUGIN_VERSION = '1.1.1';
+const ZEPHYR_AGENT_VERSION = '1.1.1';
+const WRANGLER_VERSION = '4.99.0';
+const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
+const TAILWIND_VERSION = '4.3.0';
+const TAILWIND_POSTCSS_VERSION = '4.3.0';
+const POSTCSS_VERSION = '8.5.15';
+const EFFECT_TSGO_VERSION = '0.14.3';
+const TYPESCRIPT_VERSION = '6.0.3';
+const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260610.1';
+const OXLINT_VERSION = '1.69.0';
+const OXFMT_VERSION = '0.54.0';
+const ULTRACITE_VERSION = '7.8.3';
+const LEFTHOOK_VERSION = '^2.1.9';
+const I18NEXT_VERSION = '26.3.1';
+const NODE_FETCH_VERSION = '^3.3.2';
+const REACT_VERSION = '^19.2.7';
+const REACT_DOM_VERSION = '^19.2.7';
+const REACT_ROUTER_DOM_VERSION = '7.17.0';
+const TYPES_REACT_VERSION = '^19.2.17';
+const TYPES_REACT_DOM_VERSION = '^19.2.3';
+const NODE_VERSION = '26.3.0';
+const PNPM_VERSION = '11.5.3';
+const RSTACK_AGENT_SKILLS_COMMIT = '61c948b42512e223bad44b83af4080eba48b2677';
+const MODULE_FEDERATION_AGENT_SKILLS_COMMIT = '07bb5b6c43ad457609e00c081b72d4c42508ec76';
+const ultramodernWorkspaceVersions = {
+    tanstackRouter: TANSTACK_ROUTER_VERSION,
+    moduleFederation: MODULE_FEDERATION_VERSION,
+    tailwind: TAILWIND_VERSION,
+    tailwindPostcss: TAILWIND_POSTCSS_VERSION
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    CLOUDFLARE_COMPATIBILITY_DATE: CLOUDFLARE_COMPATIBILITY_DATE,
+    EFFECT_TSGO_VERSION: EFFECT_TSGO_VERSION,
+    I18NEXT_VERSION: I18NEXT_VERSION,
+    LEFTHOOK_VERSION: LEFTHOOK_VERSION,
+    MODULE_FEDERATION_AGENT_SKILLS_COMMIT: MODULE_FEDERATION_AGENT_SKILLS_COMMIT,
+    MODULE_FEDERATION_VERSION: MODULE_FEDERATION_VERSION,
+    NODE_FETCH_VERSION: NODE_FETCH_VERSION,
+    NODE_VERSION: NODE_VERSION,
+    OXFMT_VERSION: OXFMT_VERSION,
+    OXLINT_VERSION: OXLINT_VERSION,
+    PNPM_VERSION: PNPM_VERSION,
+    POSTCSS_VERSION: POSTCSS_VERSION,
+    REACT_DOM_VERSION: REACT_DOM_VERSION,
+    REACT_ROUTER_DOM_VERSION: REACT_ROUTER_DOM_VERSION,
+    REACT_VERSION: REACT_VERSION,
+    RSTACK_AGENT_SKILLS_COMMIT: RSTACK_AGENT_SKILLS_COMMIT,
+    TAILWIND_POSTCSS_VERSION: TAILWIND_POSTCSS_VERSION,
+    TAILWIND_VERSION: TAILWIND_VERSION,
+    TANSTACK_ROUTER_VERSION: TANSTACK_ROUTER_VERSION,
+    TYPESCRIPT_NATIVE_PREVIEW_VERSION: TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+    TYPESCRIPT_VERSION: TYPESCRIPT_VERSION,
+    TYPES_REACT_DOM_VERSION: TYPES_REACT_DOM_VERSION,
+    TYPES_REACT_VERSION: TYPES_REACT_VERSION,
+    ULTRACITE_VERSION: ULTRACITE_VERSION,
+    WRANGLER_VERSION: WRANGLER_VERSION,
+    ZEPHYR_AGENT_VERSION: ZEPHYR_AGENT_VERSION,
+    ZEPHYR_RSPACK_PLUGIN_VERSION: ZEPHYR_RSPACK_PLUGIN_VERSION,
+    ultramodernWorkspaceVersions: ultramodernWorkspaceVersions
+});
+exports.CLOUDFLARE_COMPATIBILITY_DATE = __webpack_exports__.CLOUDFLARE_COMPATIBILITY_DATE;
+exports.EFFECT_TSGO_VERSION = __webpack_exports__.EFFECT_TSGO_VERSION;
+exports.I18NEXT_VERSION = __webpack_exports__.I18NEXT_VERSION;
+exports.LEFTHOOK_VERSION = __webpack_exports__.LEFTHOOK_VERSION;
+exports.MODULE_FEDERATION_AGENT_SKILLS_COMMIT = __webpack_exports__.MODULE_FEDERATION_AGENT_SKILLS_COMMIT;
+exports.MODULE_FEDERATION_VERSION = __webpack_exports__.MODULE_FEDERATION_VERSION;
+exports.NODE_FETCH_VERSION = __webpack_exports__.NODE_FETCH_VERSION;
+exports.NODE_VERSION = __webpack_exports__.NODE_VERSION;
+exports.OXFMT_VERSION = __webpack_exports__.OXFMT_VERSION;
+exports.OXLINT_VERSION = __webpack_exports__.OXLINT_VERSION;
+exports.PNPM_VERSION = __webpack_exports__.PNPM_VERSION;
+exports.POSTCSS_VERSION = __webpack_exports__.POSTCSS_VERSION;
+exports.REACT_DOM_VERSION = __webpack_exports__.REACT_DOM_VERSION;
+exports.REACT_ROUTER_DOM_VERSION = __webpack_exports__.REACT_ROUTER_DOM_VERSION;
+exports.REACT_VERSION = __webpack_exports__.REACT_VERSION;
+exports.RSTACK_AGENT_SKILLS_COMMIT = __webpack_exports__.RSTACK_AGENT_SKILLS_COMMIT;
+exports.TAILWIND_POSTCSS_VERSION = __webpack_exports__.TAILWIND_POSTCSS_VERSION;
+exports.TAILWIND_VERSION = __webpack_exports__.TAILWIND_VERSION;
+exports.TANSTACK_ROUTER_VERSION = __webpack_exports__.TANSTACK_ROUTER_VERSION;
+exports.TYPESCRIPT_NATIVE_PREVIEW_VERSION = __webpack_exports__.TYPESCRIPT_NATIVE_PREVIEW_VERSION;
+exports.TYPESCRIPT_VERSION = __webpack_exports__.TYPESCRIPT_VERSION;
+exports.TYPES_REACT_DOM_VERSION = __webpack_exports__.TYPES_REACT_DOM_VERSION;
+exports.TYPES_REACT_VERSION = __webpack_exports__.TYPES_REACT_VERSION;
+exports.ULTRACITE_VERSION = __webpack_exports__.ULTRACITE_VERSION;
+exports.WRANGLER_VERSION = __webpack_exports__.WRANGLER_VERSION;
+exports.ZEPHYR_AGENT_VERSION = __webpack_exports__.ZEPHYR_AGENT_VERSION;
+exports.ZEPHYR_RSPACK_PLUGIN_VERSION = __webpack_exports__.ZEPHYR_RSPACK_PLUGIN_VERSION;
+exports.ultramodernWorkspaceVersions = __webpack_exports__.ultramodernWorkspaceVersions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOUDFLARE_COMPATIBILITY_DATE",
+    "EFFECT_TSGO_VERSION",
+    "I18NEXT_VERSION",
+    "LEFTHOOK_VERSION",
+    "MODULE_FEDERATION_AGENT_SKILLS_COMMIT",
+    "MODULE_FEDERATION_VERSION",
+    "NODE_FETCH_VERSION",
+    "NODE_VERSION",
+    "OXFMT_VERSION",
+    "OXLINT_VERSION",
+    "PNPM_VERSION",
+    "POSTCSS_VERSION",
+    "REACT_DOM_VERSION",
+    "REACT_ROUTER_DOM_VERSION",
+    "REACT_VERSION",
+    "RSTACK_AGENT_SKILLS_COMMIT",
+    "TAILWIND_POSTCSS_VERSION",
+    "TAILWIND_VERSION",
+    "TANSTACK_ROUTER_VERSION",
+    "TYPESCRIPT_NATIVE_PREVIEW_VERSION",
+    "TYPESCRIPT_VERSION",
+    "TYPES_REACT_DOM_VERSION",
+    "TYPES_REACT_VERSION",
+    "ULTRACITE_VERSION",
+    "WRANGLER_VERSION",
+    "ZEPHYR_AGENT_VERSION",
+    "ZEPHYR_RSPACK_PLUGIN_VERSION",
+    "ultramodernWorkspaceVersions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});